blob: 72445625dc1c891daf715881c9fade3484c1fda1 [file] [log] [blame]
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
Ramakant Singhd2875e12015-01-19 12:45:41 +05303 * Copyright (C) 2012-2015, The Linux Foundation. All rights reserved.
Naseer Ahmed31da0b12012-07-31 18:55:33 -07004 *
radhakrishna2f00c8f2013-10-21 16:49:21 +05305 * Not a Contribution.
Naseer Ahmed31da0b12012-07-31 18:55:33 -07006 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
Naseer Ahmed45a99602012-07-31 19:15:24 -070020#define DEBUG_COPYBIT 0
Naseer Ahmed72cf9762012-07-21 12:17:13 -070021#include <copybit.h>
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080022#include <utils/Timers.h>
Terence Hampson0124cc72013-04-18 23:45:56 -070023#include <mdp_version.h>
Naseer Ahmed45a99602012-07-31 19:15:24 -070024#include "hwc_copybit.h"
25#include "comptype.h"
Naseer Ahmed64b81212013-02-14 10:29:47 -050026#include "gr.h"
radhakrishna2f00c8f2013-10-21 16:49:21 +053027#include "cb_utils.h"
Ramakant Singh762ae082013-11-28 18:45:34 +053028#include "cb_swap_rect.h"
Ramakant Singh80f36f22014-02-25 14:11:35 +053029#include "math.h"
Saurabh Shah74eff4d2014-03-28 16:33:13 -070030#include "sync/sync.h"
31
radhakrishna2f00c8f2013-10-21 16:49:21 +053032using namespace qdutils;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070033namespace qhwc {
34
Naseer Ahmed31da0b12012-07-31 18:55:33 -070035struct range {
36 int current;
37 int end;
38};
39struct region_iterator : public copybit_region_t {
40
41 region_iterator(hwc_region_t region) {
42 mRegion = region;
Praveena Pachipulusud9443c72014-02-17 10:42:28 +053043 r.end = (int)region.numRects;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070044 r.current = 0;
45 this->next = iterate;
46 }
47
48private:
49 static int iterate(copybit_region_t const * self, copybit_rect_t* rect){
50 if (!self || !rect) {
51 ALOGE("iterate invalid parameters");
52 return 0;
53 }
54
55 region_iterator const* me =
56 static_cast<region_iterator const*>(self);
57 if (me->r.current != me->r.end) {
58 rect->l = me->mRegion.rects[me->r.current].left;
59 rect->t = me->mRegion.rects[me->r.current].top;
60 rect->r = me->mRegion.rects[me->r.current].right;
61 rect->b = me->mRegion.rects[me->r.current].bottom;
62 me->r.current++;
63 return 1;
64 }
65 return 0;
66 }
67
68 hwc_region_t mRegion;
69 mutable range r;
70};
71
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080072void CopyBit::reset() {
73 mIsModeOn = false;
74 mCopyBitDraw = false;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070075}
76
Naseer Ahmed45a99602012-07-31 19:15:24 -070077bool CopyBit::canUseCopybitForYUV(hwc_context_t *ctx) {
78 // return true for non-overlay targets
Terence Hampsond0fd5792013-05-29 11:56:52 -040079 if(ctx->mMDP.hasOverlay && ctx->mMDP.version >= qdutils::MDP_V4_0) {
Naseer Ahmed45a99602012-07-31 19:15:24 -070080 return false;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070081 }
82 return true;
83}
Naseer Ahmed45a99602012-07-31 19:15:24 -070084
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080085bool CopyBit::canUseCopybitForRGB(hwc_context_t *ctx,
86 hwc_display_contents_1_t *list,
87 int dpy) {
88 int compositionType = qdutils::QCCompositionType::
89 getInstance().getCompositionType();
Naseer Ahmed45a99602012-07-31 19:15:24 -070090
Naseer Ahmed45a99602012-07-31 19:15:24 -070091 if (compositionType & qdutils::COMPOSITION_TYPE_DYN) {
92 // DYN Composition:
Prabhanjan Kandula73030ba2013-03-15 22:33:39 +053093 // use copybit, if (TotalRGBRenderArea < threashold * FB Area)
Naseer Ahmed45a99602012-07-31 19:15:24 -070094 // this is done based on perf inputs in ICS
95 // TODO: Above condition needs to be re-evaluated in JB
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080096 int fbWidth = ctx->dpyAttr[dpy].xres;
97 int fbHeight = ctx->dpyAttr[dpy].yres;
98 unsigned int fbArea = (fbWidth * fbHeight);
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +053099 unsigned int renderArea = getRGBRenderingArea(ctx, list);
Naseer Ahmed45a99602012-07-31 19:15:24 -0700100 ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u",
101 __FUNCTION__, renderArea, fbArea);
Prabhanjan Kandula73030ba2013-03-15 22:33:39 +0530102 if (renderArea < (mDynThreshold * fbArea)) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700103 return true;
104 }
105 } else if ((compositionType & qdutils::COMPOSITION_TYPE_MDP)) {
106 // MDP composition, use COPYBIT always
107 return true;
108 } else if ((compositionType & qdutils::COMPOSITION_TYPE_C2D)) {
109 // C2D composition, use COPYBIT
110 return true;
111 }
112 return false;
113}
114
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +0530115unsigned int CopyBit::getRGBRenderingArea (const hwc_context_t *ctx,
116 const hwc_display_contents_1_t *list) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700117 //Calculates total rendering area for RGB layers
118 unsigned int renderArea = 0;
119 unsigned int w=0, h=0;
Terence Hampsonef379d42013-05-21 10:38:01 -0400120 // Skipping last layer since FrameBuffer layer should not affect
121 // which composition to choose
122 for (unsigned int i=0; i<list->numHwLayers -1; i++) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700123 private_handle_t *hnd = (private_handle_t *)list->hwLayers[i].handle;
124 if (hnd) {
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +0530125 if (BUFFER_TYPE_UI == hnd->bufferType && !ctx->copybitDrop[i]) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700126 getLayerResolution(&list->hwLayers[i], w, h);
127 renderArea += (w*h);
128 }
129 }
130 }
131 return renderArea;
132}
133
Dileep Kumar Reddi9dab73a2015-02-24 16:15:53 +0530134bool CopyBit::isLayerChanging(hwc_context_t *ctx,
135 hwc_display_contents_1_t *list, int k) {
Dileep Kumar Reddiaa488882014-12-16 11:19:45 +0530136 if((mLayerCache.hnd[k] != list->hwLayers[k].handle) ||
Dileep Kumar Reddi9dab73a2015-02-24 16:15:53 +0530137 (mLayerCache.drop[k] != ctx->copybitDrop[k]) ||
Dileep Kumar Reddiaa488882014-12-16 11:19:45 +0530138 (mLayerCache.displayFrame[k].left !=
139 list->hwLayers[k].displayFrame.left) ||
140 (mLayerCache.displayFrame[k].top !=
141 list->hwLayers[k].displayFrame.top) ||
142 (mLayerCache.displayFrame[k].right !=
143 list->hwLayers[k].displayFrame.right) ||
144 (mLayerCache.displayFrame[k].bottom !=
145 list->hwLayers[k].displayFrame.bottom)) {
146 return 1;
147 }
148 return 0;
149}
150
Ramakant Singh21cec722014-03-07 19:11:45 +0530151int CopyBit::getLayersChanging(hwc_context_t *ctx,
152 hwc_display_contents_1_t *list,
153 int dpy){
154
155 int changingLayerIndex = -1;
156 if(mLayerCache.layerCount != ctx->listStats[dpy].numAppLayers) {
157 mLayerCache.reset();
158 mFbCache.reset();
159 mLayerCache.updateCounts(ctx,list,dpy);
160 return -1;
161 }
162
163 int updatingLayerCount = 0;
164 for (int k = ctx->listStats[dpy].numAppLayers-1; k >= 0 ; k--){
165 //swap rect will kick in only for single updating layer
Dileep Kumar Reddi9dab73a2015-02-24 16:15:53 +0530166 if(isLayerChanging(ctx, list, k)) {
Ramakant Singh21cec722014-03-07 19:11:45 +0530167 updatingLayerCount ++;
168 if(updatingLayerCount == 1)
169 changingLayerIndex = k;
170 }
171 }
172 //since we are using more than one framebuffers,we have to
173 //kick in swap rect only if we are getting continuous same
174 //dirty rect for same layer at least equal of number of
175 //framebuffers
176
177 if ( updatingLayerCount == 1 ) {
Saurabh Shah93c69052014-04-24 10:27:10 -0700178 hwc_rect_t dirtyRect = list->hwLayers[changingLayerIndex].displayFrame;
179#ifdef QCOM_BSP
180 dirtyRect = list->hwLayers[changingLayerIndex].dirtyRect;
181#endif
Ramakant Singh21cec722014-03-07 19:11:45 +0530182
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530183 for (int k = ctx->listStats[dpy].numAppLayers-1; k >= 0 ; k--) {
184 //disable swap rect in case of scaling and video .
185 private_handle_t *hnd =(private_handle_t *)list->hwLayers[k].handle;
Dileep Kumar Reddic3545042015-03-11 19:37:06 +0530186 if(needsScaling(&list->hwLayers[k])||( hnd && isYuvBuffer(hnd)) ||
187 (list->hwLayers[k].transform & HAL_TRANSFORM_ROT_90)) {
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530188 mFbCache.reset();
189 return -1;
Ramakant Singh21cec722014-03-07 19:11:45 +0530190 }
191 }
Ramakant Singh19ead272015-03-18 14:11:31 +0530192 hwc_rect_t displayRect = list->hwLayers[changingLayerIndex].displayFrame;
193 if(mFbCache.getUnchangedFbDRCount(dirtyRect, displayRect) <
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530194 NUM_RENDER_BUFFERS) {
Ramakant Singh19ead272015-03-18 14:11:31 +0530195 mFbCache.insertAndUpdateFbCache(dirtyRect, displayRect);
Ramakant Singh21cec722014-03-07 19:11:45 +0530196 changingLayerIndex = -1;
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530197 }
198 } else {
Ramakant Singh21cec722014-03-07 19:11:45 +0530199 mFbCache.reset();
200 changingLayerIndex = -1;
201 }
202 mLayerCache.updateCounts(ctx,list,dpy);
203 return changingLayerIndex;
204}
205
206int CopyBit::checkDirtyRect(hwc_context_t *ctx,
207 hwc_display_contents_1_t *list,
208 int dpy) {
209
210 //dirty rect will enable only if
211 //1.Only single layer is updating.
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530212 //2.No scaling
213 //3.No video layer
Ramakant Singh21cec722014-03-07 19:11:45 +0530214 if(mSwapRectEnable == false)
215 return -1;
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530216 return getLayersChanging(ctx, list, dpy);
Ramakant Singh21cec722014-03-07 19:11:45 +0530217}
218
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700219bool CopyBit::prepareOverlap(hwc_context_t *ctx,
220 hwc_display_contents_1_t *list) {
Sushil Chauhandefd3522014-05-13 18:17:12 -0700221
222 if (ctx->mMDP.version < qdutils::MDP_V4_0) {
223 ALOGE("%s: Invalid request", __FUNCTION__);
224 return false;
225 }
226
Saurabh Shah15455aa2015-01-28 13:54:48 -0800227 if (mEngine == NULL) {
228 ALOGW("%s: Copybit HAL not enabled", __FUNCTION__);
229 return false;
230 }
231
232 if (!(validateParams(ctx, list))) {
233 ALOGE("%s: validateParams() failed", __FUNCTION__);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700234 return false;
235 }
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700236 PtorInfo* ptorInfo = &(ctx->mPtorInfo);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700237
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700238 // Allocate render buffers if they're not allocated
239 int alignW = 0, alignH = 0;
240 int finalW = 0, finalH = 0;
241 for (int i = 0; i < ptorInfo->count; i++) {
242 int ovlapIndex = ptorInfo->layerIndex[i];
243 hwc_rect_t overlap = list->hwLayers[ovlapIndex].displayFrame;
244 // render buffer width will be the max of two layers
245 // Align Widht and height to 32, Mdp would be configured
246 // with Aligned overlap w/h
247 finalW = max(finalW, ALIGN((overlap.right - overlap.left), 32));
248 finalH += ALIGN((overlap.bottom - overlap.top), 32);
249 if(finalH > ALIGN((overlap.bottom - overlap.top), 32)) {
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700250 // Calculate the dest top, left will always be zero
251 ptorInfo->displayFrame[i].top = (finalH -
252 (ALIGN((overlap.bottom - overlap.top), 32)));
253 }
254 // calculate the right and bottom values
255 ptorInfo->displayFrame[i].right = ptorInfo->displayFrame[i].left +
256 (overlap.right - overlap.left);
257 ptorInfo->displayFrame[i].bottom = ptorInfo->displayFrame[i].top +
258 (overlap.bottom - overlap.top);
259 }
Sushil Chauhandefd3522014-05-13 18:17:12 -0700260
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700261 getBufferSizeAndDimensions(finalW, finalH, HAL_PIXEL_FORMAT_RGBA_8888,
Sushil Chauhandefd3522014-05-13 18:17:12 -0700262 alignW, alignH);
263
264 if ((mAlignedWidth != alignW) || (mAlignedHeight != alignH)) {
265 // Overlap rect has changed, so free render buffers
266 freeRenderBuffers();
267 }
268
269 int ret = allocRenderBuffers(alignW, alignH, HAL_PIXEL_FORMAT_RGBA_8888);
270
271 if (ret < 0) {
272 ALOGE("%s: Render buffer allocation failed", __FUNCTION__);
273 return false;
274 }
275
276 mAlignedWidth = alignW;
277 mAlignedHeight = alignH;
278 mCurRenderBufferIndex = (mCurRenderBufferIndex + 1) % NUM_RENDER_BUFFERS;
279 return true;
280}
281
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800282bool CopyBit::prepare(hwc_context_t *ctx, hwc_display_contents_1_t *list,
283 int dpy) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700284
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800285 if(mEngine == NULL) {
286 // No copybit device found - cannot use copybit
287 return false;
288 }
Dileep Kumar Reddia25a9182014-07-24 20:01:44 +0530289
290 if(ctx->mThermalBurstMode) {
291 ALOGD_IF (DEBUG_COPYBIT, "%s:Copybit failed,"
292 "Running in Thermal Burst mode",__FUNCTION__);
293 return false;
294 }
295
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800296 int compositionType = qdutils::QCCompositionType::
297 getInstance().getCompositionType();
Naseer Ahmed45a99602012-07-31 19:15:24 -0700298
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800299 if ((compositionType == qdutils::COMPOSITION_TYPE_GPU) ||
300 (compositionType == qdutils::COMPOSITION_TYPE_CPU)) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700301 //GPU/CPU composition, don't change layer composition type
302 return true;
303 }
304
Naseer Ahmed45a99602012-07-31 19:15:24 -0700305 if(!(validateParams(ctx, list))) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800306 ALOGE("%s:Invalid Params", __FUNCTION__);
307 return false;
Naseer Ahmed45a99602012-07-31 19:15:24 -0700308 }
309
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800310 if(ctx->listStats[dpy].skipCount) {
311 //GPU will be anyways used
312 return false;
313 }
314
Ramkumar Radhakrishnane661f962013-06-05 17:21:38 -0700315 if (ctx->listStats[dpy].numAppLayers > MAX_NUM_APP_LAYERS) {
Sushil Chauhanb00f59d2013-04-29 18:35:54 -0700316 // Reached max layers supported by HWC.
317 return false;
318 }
319
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800320 bool useCopybitForYUV = canUseCopybitForYUV(ctx);
321 bool useCopybitForRGB = canUseCopybitForRGB(ctx, list, dpy);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500322 LayerProp *layerProp = ctx->layerProp[dpy];
Naseer Ahmed64b81212013-02-14 10:29:47 -0500323
Radhika Ranjan Soni46cf4e92013-08-06 16:40:05 +0530324 // Following are MDP3 limitations for which we
325 // need to fallback to GPU composition:
Terence Hampsonb1021932013-09-18 11:15:19 -0400326 // 1. Plane alpha is not supported by MDP3.
Terence Hampson6b0a4272013-11-06 16:04:51 -0500327 // 2. Scaling is within range
Terence Hampsonc235bda2013-07-12 12:47:38 -0400328 if (qdutils::MDPVersion::getInstance().getMDPVersion() < 400) {
329 for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) {
Terence Hampson6b0a4272013-11-06 16:04:51 -0500330 int dst_h, dst_w, src_h, src_w;
331 float dx, dy;
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +0530332 if(ctx->copybitDrop[i]) {
333 continue;
334 }
Terence Hampsonc235bda2013-07-12 12:47:38 -0400335 hwc_layer_1_t *layer = (hwc_layer_1_t *) &list->hwLayers[i];
Radhika Ranjan Soni46cf4e92013-08-06 16:40:05 +0530336 if (layer->planeAlpha != 0xFF)
337 return true;
Ramakant Singhf2b51e62013-11-28 12:07:51 +0530338 hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf);
Terence Hampson6b0a4272013-11-06 16:04:51 -0500339
Sushil Chauhanfda00fc2014-03-20 11:08:41 -0700340 if (has90Transform(layer)) {
Ramakant Singhf2b51e62013-11-28 12:07:51 +0530341 src_h = sourceCrop.right - sourceCrop.left;
342 src_w = sourceCrop.bottom - sourceCrop.top;
Terence Hampson6b0a4272013-11-06 16:04:51 -0500343 } else {
Ramakant Singhf2b51e62013-11-28 12:07:51 +0530344 src_h = sourceCrop.bottom - sourceCrop.top;
345 src_w = sourceCrop.right - sourceCrop.left;
Terence Hampson6b0a4272013-11-06 16:04:51 -0500346 }
347 dst_h = layer->displayFrame.bottom - layer->displayFrame.top;
348 dst_w = layer->displayFrame.right - layer->displayFrame.left;
349
Ramakant Singh0b35f2c2014-01-07 11:25:48 +0530350 if(src_w <=0 || src_h<=0 ||dst_w<=0 || dst_h<=0 ) {
351 ALOGE("%s: wrong params for display screen_w=%d \
352 src_crop_width=%d screen_h=%d src_crop_height=%d",
353 __FUNCTION__, dst_w,src_w,dst_h,src_h);
354 return false;
355 }
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530356 dx = (float)dst_w/(float)src_w;
357 dy = (float)dst_h/(float)src_h;
Ramakant Singh0b35f2c2014-01-07 11:25:48 +0530358
Ramakant Singhd5b369f2014-12-09 23:03:43 +0530359 float scale_factor_max = MAX_SCALE_FACTOR;
360 float scale_factor_min = MIN_SCALE_FACTOR;
361
362 if (isAlphaPresent(layer)) {
363 scale_factor_max = MAX_SCALE_FACTOR/4;
364 scale_factor_min = MIN_SCALE_FACTOR*4;
365 }
366
367 if (dx > scale_factor_max || dx < scale_factor_min)
Terence Hampson6b0a4272013-11-06 16:04:51 -0500368 return false;
369
Ramakant Singhd5b369f2014-12-09 23:03:43 +0530370 if (dy > scale_factor_max || dy < scale_factor_min)
Terence Hampson6b0a4272013-11-06 16:04:51 -0500371 return false;
Terence Hampsonc235bda2013-07-12 12:47:38 -0400372 }
373 }
Naseer Ahmed64b81212013-02-14 10:29:47 -0500374
375 //Allocate render buffers if they're not allocated
Ramakant Singhb4106a12014-10-07 18:06:56 +0530376 if ((ctx->mMDP.version != qdutils::MDP_V3_0_4 &&
377 ctx->mMDP.version != qdutils::MDP_V3_0_5) &&
Terence Hampsonc67b0372013-10-09 11:32:21 -0400378 (useCopybitForYUV || useCopybitForRGB)) {
Sushil Chauhandefd3522014-05-13 18:17:12 -0700379 int ret = allocRenderBuffers(mAlignedWidth,
380 mAlignedHeight,
Saurabh Shah220a30c2013-10-29 16:12:12 -0700381 HAL_PIXEL_FORMAT_RGBA_8888);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500382 if (ret < 0) {
383 return false;
384 } else {
385 mCurRenderBufferIndex = (mCurRenderBufferIndex + 1) %
386 NUM_RENDER_BUFFERS;
387 }
388 }
389
Terence Hampsond0fd5792013-05-29 11:56:52 -0400390 // We cannot mix copybit layer with layers marked to be drawn on FB
391 if (!useCopybitForYUV && ctx->listStats[dpy].yuvCount)
392 return true;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800393
Radhika Ranjan Soni14f6c4b2013-08-28 17:04:49 +0530394 mCopyBitDraw = false;
395 if (useCopybitForRGB &&
396 (useCopybitForYUV || !ctx->listStats[dpy].yuvCount)) {
397 mCopyBitDraw = true;
398 // numAppLayers-1, as we iterate till 0th layer index
399 // Mark all layers to be drawn by copybit
400 for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) {
Naseer Ahmed64b81212013-02-14 10:29:47 -0500401 layerProp[i].mFlags |= HWC_COPYBIT;
Saurabh Shah74eff4d2014-03-28 16:33:13 -0700402#ifdef QCOM_BSP
Ramakant Singhb4106a12014-10-07 18:06:56 +0530403 if (ctx->mMDP.version == qdutils::MDP_V3_0_4 ||
404 ctx->mMDP.version == qdutils::MDP_V3_0_5)
Terence Hampsonc67b0372013-10-09 11:32:21 -0400405 list->hwLayers[i].compositionType = HWC_BLIT;
406 else
Saurabh Shah74eff4d2014-03-28 16:33:13 -0700407#endif
Terence Hampsonc67b0372013-10-09 11:32:21 -0400408 list->hwLayers[i].compositionType = HWC_OVERLAY;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700409 }
410 }
Radhika Ranjan Soni14f6c4b2013-08-28 17:04:49 +0530411
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700412 return true;
413}
414
Naseer Ahmed183939d2013-03-14 20:44:17 -0400415int CopyBit::clear (private_handle_t* hnd, hwc_rect_t& rect)
416{
417 int ret = 0;
418 copybit_rect_t clear_rect = {rect.left, rect.top,
419 rect.right,
420 rect.bottom};
421
422 copybit_image_t buf;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700423 buf.w = ALIGN(getWidth(hnd),32);
424 buf.h = getHeight(hnd);
Naseer Ahmed183939d2013-03-14 20:44:17 -0400425 buf.format = hnd->format;
426 buf.base = (void *)hnd->base;
427 buf.handle = (native_handle_t *)hnd;
428
429 copybit_device_t *copybit = mEngine;
430 ret = copybit->clear(copybit, &buf, &clear_rect);
431 return ret;
432}
433
Ramakant Singh0def28c2014-03-28 20:43:13 +0530434bool CopyBit::drawUsingAppBufferComposition(hwc_context_t *ctx,
435 hwc_display_contents_1_t *list,
Ramakant Singh467759f2014-04-16 11:09:40 +0530436 int dpy, int *copybitFd) {
437 int layerCount = 0;
Shalaj Jaina70b4352014-06-15 13:47:47 -0700438 uint32_t last = (uint32_t)list->numHwLayers - 1;
Ramakant Singh467759f2014-04-16 11:09:40 +0530439 hwc_layer_1_t *fbLayer = &list->hwLayers[last];
440 private_handle_t *fbhnd = (private_handle_t *)fbLayer->handle;
Ramakant Singh0def28c2014-03-28 20:43:13 +0530441
442 if(ctx->enableABC == false)
443 return false;
444
Ramakant Singh467759f2014-04-16 11:09:40 +0530445 if(ctx->listStats[dpy].numAppLayers > MAX_LAYERS_FOR_ABC )
Ramakant Singh0def28c2014-03-28 20:43:13 +0530446 return false;
447
448 layerCount = ctx->listStats[dpy].numAppLayers;
449 //bottom most layer should
450 //equal to FB
451 hwc_layer_1_t *tmpLayer = &list->hwLayers[0];
452 private_handle_t *hnd = (private_handle_t *)tmpLayer->handle;
453 if(hnd && fbhnd && (hnd->size == fbhnd->size) &&
454 (hnd->width == fbhnd->width) && (hnd->height == fbhnd->height)){
455 if(tmpLayer->transform ||
456 (!(hnd->format == HAL_PIXEL_FORMAT_RGBA_8888 ||
457 hnd->format == HAL_PIXEL_FORMAT_RGBX_8888)) ||
458 (needsScaling(tmpLayer) == true)) {
459 return false;
460 }else {
461 ctx->listStats[dpy].renderBufIndexforABC = 0;
462 }
463 }
464
Ramakant Singh467759f2014-04-16 11:09:40 +0530465 if(ctx->listStats[dpy].renderBufIndexforABC == 0) {
466 if(layerCount == 1)
Ramakant Singh0def28c2014-03-28 20:43:13 +0530467 return true;
Ramakant Singh467759f2014-04-16 11:09:40 +0530468
Ramakant Singhcc326612014-06-19 14:19:18 +0530469 if(layerCount == MAX_LAYERS_FOR_ABC) {
Ramakant Singh467759f2014-04-16 11:09:40 +0530470 int abcRenderBufIdx = ctx->listStats[dpy].renderBufIndexforABC;
Ramakant Singhcc326612014-06-19 14:19:18 +0530471 //enable ABC only for non intersecting layers.
472 hwc_rect_t displayFrame =
473 list->hwLayers[abcRenderBufIdx].displayFrame;
474 for (int i = abcRenderBufIdx + 1; i < layerCount; i++) {
475 hwc_rect_t tmpDisplayFrame = list->hwLayers[i].displayFrame;
476 hwc_rect_t result = getIntersection(displayFrame,tmpDisplayFrame);
477 if (isValidRect(result)) {
478 ctx->listStats[dpy].renderBufIndexforABC = -1;
479 return false;
480 }
481 }
482 // Pass the Acquire Fence FD to driver for base layer
Ramakant Singh467759f2014-04-16 11:09:40 +0530483 private_handle_t *renderBuffer =
484 (private_handle_t *)list->hwLayers[abcRenderBufIdx].handle;
485 copybit_device_t *copybit = getCopyBitDevice();
486 if(list->hwLayers[abcRenderBufIdx].acquireFenceFd >=0){
487 copybit->set_sync(copybit,
488 list->hwLayers[abcRenderBufIdx].acquireFenceFd);
489 }
Ramakant Singhcc326612014-06-19 14:19:18 +0530490 for(int i = abcRenderBufIdx + 1; i < layerCount; i++){
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530491 mDirtyLayerIndex = -1;
Ramakant Singh467759f2014-04-16 11:09:40 +0530492 int retVal = drawLayerUsingCopybit(ctx,
493 &(list->hwLayers[i]),renderBuffer, 0);
494 if(retVal < 0) {
495 ALOGE("%s : Copybit failed", __FUNCTION__);
496 }
497 }
498 // Get Release Fence FD of copybit for the App layer(s)
499 copybit->flush_get_fence(copybit, copybitFd);
Ramakant Singh52e1c0c2014-12-18 23:35:33 +0530500 close(list->hwLayers[last].acquireFenceFd);
501 list->hwLayers[last].acquireFenceFd = -1;
Ramakant Singh467759f2014-04-16 11:09:40 +0530502 return true;
503 }
Ramakant Singh0def28c2014-03-28 20:43:13 +0530504 }
505 return false;
506}
507
508bool CopyBit::draw(hwc_context_t *ctx, hwc_display_contents_1_t *list,
509 int dpy, int32_t *fd) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800510 // draw layers marked for COPYBIT
511 int retVal = true;
512 int copybitLayerCount = 0;
Terence Hampsonc67b0372013-10-09 11:32:21 -0400513 uint32_t last = 0;
Naseer Ahmed64b81212013-02-14 10:29:47 -0500514 LayerProp *layerProp = ctx->layerProp[dpy];
Terence Hampsonc67b0372013-10-09 11:32:21 -0400515 private_handle_t *renderBuffer;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800516
Ramakant Singh21cec722014-03-07 19:11:45 +0530517 if(mCopyBitDraw == false){
518 mFbCache.reset(); // there is no layer marked for copybit
519 return false ;
520 }
Ramakant Singh0def28c2014-03-28 20:43:13 +0530521
Ramakant Singh467759f2014-04-16 11:09:40 +0530522 if(drawUsingAppBufferComposition(ctx, list, dpy, fd)) {
Ramakant Singh0def28c2014-03-28 20:43:13 +0530523 return true;
524 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800525 //render buffer
Ramakant Singhb4106a12014-10-07 18:06:56 +0530526 if (ctx->mMDP.version == qdutils::MDP_V3_0_4 ||
527 ctx->mMDP.version == qdutils::MDP_V3_0_5) {
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530528 last = (uint32_t)list->numHwLayers - 1;
Terence Hampsonc67b0372013-10-09 11:32:21 -0400529 renderBuffer = (private_handle_t *)list->hwLayers[last].handle;
530 } else {
531 renderBuffer = getCurrentRenderBuffer();
532 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800533 if (!renderBuffer) {
Naseer Ahmed64b81212013-02-14 10:29:47 -0500534 ALOGE("%s: Render buffer layer handle is NULL", __FUNCTION__);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800535 return false;
536 }
Naseer Ahmed64b81212013-02-14 10:29:47 -0500537
Terence Hampson0124cc72013-04-18 23:45:56 -0700538 if (ctx->mMDP.version >= qdutils::MDP_V4_0) {
Terence Hampson65fe4522013-10-17 17:40:03 -0400539 //Wait for the previous frame to complete before rendering onto it
Prabhanjan Kandula5719da42013-11-01 00:14:04 +0530540 if(mRelFd[mCurRenderBufferIndex] >=0) {
541 sync_wait(mRelFd[mCurRenderBufferIndex], 1000);
542 close(mRelFd[mCurRenderBufferIndex]);
543 mRelFd[mCurRenderBufferIndex] = -1;
Terence Hampson65fe4522013-10-17 17:40:03 -0400544 }
Terence Hampson65fe4522013-10-17 17:40:03 -0400545 } else {
Terence Hampsonc67b0372013-10-09 11:32:21 -0400546 if(list->hwLayers[last].acquireFenceFd >=0) {
Terence Hampson65fe4522013-10-17 17:40:03 -0400547 copybit_device_t *copybit = getCopyBitDevice();
Terence Hampsonc67b0372013-10-09 11:32:21 -0400548 copybit->set_sync(copybit, list->hwLayers[last].acquireFenceFd);
Terence Hampson65fe4522013-10-17 17:40:03 -0400549 }
Terence Hampson0124cc72013-04-18 23:45:56 -0700550 }
radhakrishna2f00c8f2013-10-21 16:49:21 +0530551
Ramakant Singh21cec722014-03-07 19:11:45 +0530552 mDirtyLayerIndex = checkDirtyRect(ctx, list, dpy);
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530553 ALOGD_IF (DEBUG_COPYBIT, "%s:Dirty Layer Index: %d",
554 __FUNCTION__, mDirtyLayerIndex);
Ramakant Singh75b427c2014-12-08 17:09:31 +0530555 hwc_rect_t clearRegion = {0,0,0,0};
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530556 mDirtyRect = list->hwLayers[last].displayFrame;
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530557
Dileep Kumar Reddif4e2e0c2014-12-16 11:24:34 +0530558 if (CBUtils::getuiClearRegion(list, clearRegion, layerProp,
Ramakant Singh909bc2a2015-02-10 16:29:21 +0530559 mDirtyLayerIndex)) {
560 int clear_w = clearRegion.right - clearRegion.left;
561 int clear_h = clearRegion.bottom - clearRegion.top;
562 //mdp can't handle solid fill for one line
563 //making solid fill as full in this case
564 //disable swap rect if presents
565 if ((clear_w == 1) || (clear_h ==1)) {
566 clear(renderBuffer, mDirtyRect);
567 mDirtyLayerIndex = -1;
568 }else
569 clear(renderBuffer, clearRegion);
570 }
571 if (mDirtyLayerIndex != -1)
572 mDirtyRect = list->hwLayers[mDirtyLayerIndex].displayFrame;
573
Naseer Ahmed64b81212013-02-14 10:29:47 -0500574 // numAppLayers-1, as we iterate from 0th layer index with HWC_COPYBIT flag
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800575 for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) {
Naseer Ahmed64b81212013-02-14 10:29:47 -0500576 if(!(layerProp[i].mFlags & HWC_COPYBIT)) {
577 ALOGD_IF(DEBUG_COPYBIT, "%s: Not Marked for copybit", __FUNCTION__);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800578 continue;
579 }
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +0530580 if(ctx->copybitDrop[i]) {
581 continue;
582 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800583 int ret = -1;
Terence Hampsonadf47302013-05-23 12:21:02 -0400584 if (list->hwLayers[i].acquireFenceFd != -1
585 && ctx->mMDP.version >= qdutils::MDP_V4_0) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800586 // Wait for acquire Fence on the App buffers.
587 ret = sync_wait(list->hwLayers[i].acquireFenceFd, 1000);
588 if(ret < 0) {
589 ALOGE("%s: sync_wait error!! error no = %d err str = %s",
590 __FUNCTION__, errno, strerror(errno));
591 }
592 close(list->hwLayers[i].acquireFenceFd);
593 list->hwLayers[i].acquireFenceFd = -1;
594 }
595 retVal = drawLayerUsingCopybit(ctx, &(list->hwLayers[i]),
Ramakant Singh21cec722014-03-07 19:11:45 +0530596 renderBuffer, !i);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800597 copybitLayerCount++;
598 if(retVal < 0) {
599 ALOGE("%s : drawLayerUsingCopybit failed", __FUNCTION__);
600 }
601 }
602
603 if (copybitLayerCount) {
604 copybit_device_t *copybit = getCopyBitDevice();
605 // Async mode
606 copybit->flush_get_fence(copybit, fd);
Ramakant Singhb4106a12014-10-07 18:06:56 +0530607 if((ctx->mMDP.version == qdutils::MDP_V3_0_4 ||
608 ctx->mMDP.version == qdutils::MDP_V3_0_5) &&
Terence Hampsonc67b0372013-10-09 11:32:21 -0400609 list->hwLayers[last].acquireFenceFd >= 0) {
610 close(list->hwLayers[last].acquireFenceFd);
611 list->hwLayers[last].acquireFenceFd = -1;
Terence Hampson65fe4522013-10-17 17:40:03 -0400612 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800613 }
614 return true;
615}
616
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700617int CopyBit::drawOverlap(hwc_context_t *ctx, hwc_display_contents_1_t *list) {
Sushil Chauhandefd3522014-05-13 18:17:12 -0700618 int fd = -1;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700619 PtorInfo* ptorInfo = &(ctx->mPtorInfo);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700620
621 if (ctx->mMDP.version < qdutils::MDP_V4_0) {
622 ALOGE("%s: Invalid request", __FUNCTION__);
623 return fd;
624 }
625
626 private_handle_t *renderBuffer = getCurrentRenderBuffer();
627
628 if (!renderBuffer) {
629 ALOGE("%s: Render buffer layer handle is NULL", __FUNCTION__);
630 return fd;
631 }
632
Dileep Kumar Reddid1f08e42014-11-05 21:24:27 +0530633 //Clear the transparent or left out region on the render buffer
634 hwc_rect_t clearRegion = {0,0,0,0};
635 LayerProp *layerProp = ctx->layerProp[0];
636 if(CBUtils::getuiClearRegion(list, clearRegion, layerProp))
637 clear(renderBuffer, clearRegion);
638
Sushil Chauhandefd3522014-05-13 18:17:12 -0700639 int copybitLayerCount = 0;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700640 for(int j = 0; j < ptorInfo->count; j++) {
641 int ovlapIndex = ptorInfo->layerIndex[j];
642 hwc_rect_t overlap = list->hwLayers[ovlapIndex].displayFrame;
Prabhanjan Kandula9889a202014-09-04 21:50:35 +0530643 if(j) {
644 /**
645 * It's possible that 2 PTOR layers might have overlapping.
646 * In such case, remove the intersection(again if peripheral)
647 * from the lower PTOR layer to avoid overlapping.
648 * If intersection is not on peripheral then compromise
649 * by reducing number of PTOR layers.
650 **/
651 int prevOvlapIndex = ptorInfo->layerIndex[0];
652 hwc_rect_t prevOvlap = list->hwLayers[prevOvlapIndex].displayFrame;
653 hwc_rect_t commonRect = getIntersection(prevOvlap, overlap);
654 if(isValidRect(commonRect)) {
655 overlap = deductRect(overlap, commonRect);
656 }
657 }
Sushil Chauhandefd3522014-05-13 18:17:12 -0700658
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700659 // Draw overlapped content of layers on render buffer
660 for (int i = 0; i <= ovlapIndex; i++) {
661 hwc_layer_1_t *layer = &list->hwLayers[i];
662 if(!isValidRect(getIntersection(layer->displayFrame,
663 overlap))) {
664 continue;
Sushil Chauhandefd3522014-05-13 18:17:12 -0700665 }
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700666 if ((list->hwLayers[i].acquireFenceFd != -1)) {
667 // Wait for acquire fence on the App buffers.
668 if(sync_wait(list->hwLayers[i].acquireFenceFd, 1000) < 0) {
669 ALOGE("%s: sync_wait error!! error no = %d err str = %s",
670 __FUNCTION__, errno, strerror(errno));
671 }
672 close(list->hwLayers[i].acquireFenceFd);
673 list->hwLayers[i].acquireFenceFd = -1;
674 }
Dileep Kumar Reddi408fde52014-11-04 22:53:15 +0530675 /*
676 * Find the intersection of layer display frame with PTOR layer
677 * with respect to screen co-ordinates
678 *
679 * Calculated the destination rect by transforming the overlapping
680 * region of layer display frame with respect to PTOR display frame
681 *
682 * Transform the destination rect on to render buffer
683 * */
684 hwc_rect_t destRect = getIntersection(overlap, layer->displayFrame);
685 destRect.left = destRect.left - overlap.left +
686 ptorInfo->displayFrame[j].left;
687 destRect.right = destRect.right- overlap.left +
688 ptorInfo->displayFrame[j].left;
689 destRect.top = destRect.top - overlap.top +
690 ptorInfo->displayFrame[j].top;
691 destRect.bottom = destRect.bottom - overlap.top +
692 ptorInfo->displayFrame[j].top;
Sushil Chauhandefd3522014-05-13 18:17:12 -0700693
Dileep Kumar Reddi408fde52014-11-04 22:53:15 +0530694 int retVal = drawRectUsingCopybit(ctx, layer, renderBuffer,
695 overlap, destRect);
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700696 copybitLayerCount++;
697 if(retVal < 0) {
698 ALOGE("%s: drawRectUsingCopybit failed", __FUNCTION__);
699 copybitLayerCount = 0;
700 }
Sushil Chauhandefd3522014-05-13 18:17:12 -0700701 }
702 }
703
704 if (copybitLayerCount) {
705 copybit_device_t *copybit = getCopyBitDevice();
706 copybit->flush_get_fence(copybit, &fd);
707 }
708
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700709 ALOGD_IF(DEBUG_COPYBIT, "%s: done! copybitLayerCount = %d", __FUNCTION__,
710 copybitLayerCount);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700711 return fd;
712}
713
714int CopyBit::drawRectUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer,
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700715 private_handle_t *renderBuffer, hwc_rect_t overlap,
716 hwc_rect_t destRect)
Sushil Chauhandefd3522014-05-13 18:17:12 -0700717{
718 hwc_context_t* ctx = (hwc_context_t*)(dev);
719 if (!ctx) {
720 ALOGE("%s: null context ", __FUNCTION__);
721 return -1;
722 }
723
724 private_handle_t *hnd = (private_handle_t *)layer->handle;
725 if (!hnd) {
726 ALOGE("%s: invalid handle", __FUNCTION__);
727 return -1;
728 }
729
730 private_handle_t *dstHandle = (private_handle_t *)renderBuffer;
731 if (!dstHandle) {
732 ALOGE("%s: RenderBuffer handle is NULL", __FUNCTION__);
733 return -1;
734 }
735
736 // Set the Copybit Source
737 copybit_image_t src;
738 src.handle = (native_handle_t *)layer->handle;
739 src.w = hnd->width;
740 src.h = hnd->height;
741 src.base = (void *)hnd->base;
742 src.format = hnd->format;
743 src.horiz_padding = 0;
744 src.vert_padding = 0;
745
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700746
Sushil Chauhandefd3522014-05-13 18:17:12 -0700747 hwc_rect_t dispFrame = layer->displayFrame;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700748 hwc_rect_t iRect = getIntersection(dispFrame, overlap);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700749 hwc_rect_t crop = integerizeSourceCrop(layer->sourceCropf);
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700750 qhwc::calculate_crop_rects(crop, dispFrame, iRect,
751 layer->transform);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700752
753 // Copybit source rect
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700754 copybit_rect_t srcRect = {crop.left, crop.top, crop.right,
755 crop.bottom};
Sushil Chauhandefd3522014-05-13 18:17:12 -0700756
757 // Copybit destination rect
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700758 copybit_rect_t dstRect = {destRect.left, destRect.top, destRect.right,
759 destRect.bottom};
Sushil Chauhandefd3522014-05-13 18:17:12 -0700760
761 // Copybit dst
762 copybit_image_t dst;
763 dst.handle = (native_handle_t *)dstHandle;
764 dst.w = ALIGN(dstHandle->width, 32);
765 dst.h = dstHandle->height;
766 dst.base = (void *)dstHandle->base;
767 dst.format = dstHandle->format;
768
769 copybit_device_t *copybit = mEngine;
770
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700771 // Copybit region is the destRect
772 hwc_rect_t regRect = {dstRect.l,dstRect.t, dstRect.r, dstRect.b};
773 hwc_region_t region;
774 region.numRects = 1;
775 region.rects = &regRect;
Sushil Chauhandefd3522014-05-13 18:17:12 -0700776 region_iterator copybitRegion(region);
777 int acquireFd = layer->acquireFenceFd;
778
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700779 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH,
780 renderBuffer->width);
781 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT,
782 renderBuffer->height);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700783 copybit->set_parameter(copybit, COPYBIT_TRANSFORM, layer->transform);
784 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, layer->planeAlpha);
785 copybit->set_parameter(copybit, COPYBIT_BLEND_MODE, layer->blending);
786 copybit->set_parameter(copybit, COPYBIT_DITHER,
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700787 (dst.format == HAL_PIXEL_FORMAT_RGB_565) ? COPYBIT_ENABLE :
788 COPYBIT_DISABLE);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700789 copybit->set_sync(copybit, acquireFd);
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700790 int err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect,
791 &copybitRegion);
Sushil Chauhandefd3522014-05-13 18:17:12 -0700792
793 if (err < 0)
794 ALOGE("%s: copybit stretch failed",__FUNCTION__);
795
796 return err;
797}
798
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700799int CopyBit::drawLayerUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer,
Arun Kumar K.R2aa44c62014-01-21 23:08:28 -0800800 private_handle_t *renderBuffer, bool isFG)
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700801{
802 hwc_context_t* ctx = (hwc_context_t*)(dev);
Terence Hampsonadf47302013-05-23 12:21:02 -0400803 int err = 0, acquireFd;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700804 if(!ctx) {
805 ALOGE("%s: null context ", __FUNCTION__);
806 return -1;
807 }
808
809 private_handle_t *hnd = (private_handle_t *)layer->handle;
810 if(!hnd) {
Sushil Chauhan943797c2013-10-21 17:35:55 -0700811 if (layer->flags & HWC_COLOR_FILL) { // Color layer
812 return fillColorUsingCopybit(layer, renderBuffer);
813 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700814 ALOGE("%s: invalid handle", __FUNCTION__);
815 return -1;
816 }
817
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800818 private_handle_t *fbHandle = (private_handle_t *)renderBuffer;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700819 if(!fbHandle) {
820 ALOGE("%s: Framebuffer handle is NULL", __FUNCTION__);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700821 return -1;
822 }
Ramakant Singh140965d2015-01-08 23:45:04 +0530823 uint32_t dynamic_fps = 0;
824#ifdef DYNAMIC_FPS
825 MetaData_t *mdata = hnd ? (MetaData_t *)hnd->base_metadata : NULL;
826 if (mdata && (mdata->operation & UPDATE_REFRESH_RATE)) {
827 dynamic_fps = roundOff(mdata->refreshrate);
828 }
829#endif
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700830 // Set the copybit source:
831 copybit_image_t src;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700832 src.w = getWidth(hnd);
833 src.h = getHeight(hnd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700834 src.format = hnd->format;
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700835
836 // Handle R/B swap
837 if ((layer->flags & HWC_FORMAT_RB_SWAP)) {
838 if (src.format == HAL_PIXEL_FORMAT_RGBA_8888) {
839 src.format = HAL_PIXEL_FORMAT_BGRA_8888;
840 } else if (src.format == HAL_PIXEL_FORMAT_RGBX_8888) {
841 src.format = HAL_PIXEL_FORMAT_BGRX_8888;
842 }
843 }
844
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700845 src.base = (void *)hnd->base;
846 src.handle = (native_handle_t *)layer->handle;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700847 src.horiz_padding = src.w - getWidth(hnd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700848 // Initialize vertical padding to zero for now,
849 // this needs to change to accomodate vertical stride
850 // if needed in the future
851 src.vert_padding = 0;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700852
shuoy7c101f92013-08-26 14:48:57 +0800853 int layerTransform = layer->transform ;
854 // When flip and rotation(90) are present alter the flip,
855 // as GPU is doing the flip and rotation in opposite order
856 // to that of MDP3.0
857 // For 270 degrees, we get 90 + (H+V) which is same as doing
858 // flip first and then rotation (H+V) + 90
859 if (qdutils::MDPVersion::getInstance().getMDPVersion() < 400) {
860 if (((layer->transform& HAL_TRANSFORM_FLIP_H) ||
861 (layer->transform & HAL_TRANSFORM_FLIP_V)) &&
862 (layer->transform & HAL_TRANSFORM_ROT_90) &&
863 !(layer->transform == HAL_TRANSFORM_ROT_270)){
864 if(layer->transform & HAL_TRANSFORM_FLIP_H){
865 layerTransform ^= HAL_TRANSFORM_FLIP_H;
866 layerTransform |= HAL_TRANSFORM_FLIP_V;
867 }
868 if(layer->transform & HAL_TRANSFORM_FLIP_V){
869 layerTransform ^= HAL_TRANSFORM_FLIP_V;
870 layerTransform |= HAL_TRANSFORM_FLIP_H;
871 }
872 }
873 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700874 // Copybit source rect
Saurabh Shah62e1d732013-09-17 10:44:05 -0700875 hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700876 copybit_rect_t srcRect = {sourceCrop.left, sourceCrop.top,
877 sourceCrop.right,
878 sourceCrop.bottom};
879
880 // Copybit destination rect
881 hwc_rect_t displayFrame = layer->displayFrame;
882 copybit_rect_t dstRect = {displayFrame.left, displayFrame.top,
883 displayFrame.right,
884 displayFrame.bottom};
Saurabh Shah93c69052014-04-24 10:27:10 -0700885#ifdef QCOM_BSP
Ramakant Singh21cec722014-03-07 19:11:45 +0530886 //change src and dst with dirtyRect
887 if(mDirtyLayerIndex != -1) {
Dileep Kumar Reddif7b72052014-12-16 11:25:11 +0530888 hwc_rect_t result = getIntersection(displayFrame, mDirtyRect);
889 if(!isValidRect(result))
890 return true;
891 dstRect.l = result.left;
892 dstRect.t = result.top;
893 dstRect.r = result.right;
894 dstRect.b = result.bottom;
895
896 srcRect.l += (result.left - displayFrame.left);
897 srcRect.t += (result.top - displayFrame.top);
898 srcRect.r -= (displayFrame.right - result.right);
899 srcRect.b -= (displayFrame.bottom - result.bottom);
Ramakant Singh21cec722014-03-07 19:11:45 +0530900 }
Saurabh Shah93c69052014-04-24 10:27:10 -0700901#endif
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700902 // Copybit dst
903 copybit_image_t dst;
904 dst.w = ALIGN(fbHandle->width,32);
905 dst.h = fbHandle->height;
906 dst.format = fbHandle->format;
907 dst.base = (void *)fbHandle->base;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800908 dst.handle = (native_handle_t *)fbHandle;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700909
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800910 copybit_device_t *copybit = mEngine;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700911
912 int32_t screen_w = displayFrame.right - displayFrame.left;
913 int32_t screen_h = displayFrame.bottom - displayFrame.top;
914 int32_t src_crop_width = sourceCrop.right - sourceCrop.left;
915 int32_t src_crop_height = sourceCrop.bottom -sourceCrop.top;
916
917 // Copybit dst
918 float copybitsMaxScale =
919 (float)copybit->get(copybit,COPYBIT_MAGNIFICATION_LIMIT);
920 float copybitsMinScale =
921 (float)copybit->get(copybit,COPYBIT_MINIFICATION_LIMIT);
922
Sushil Chauhandffbf432013-12-09 15:33:57 -0800923 if (layer->transform & HWC_TRANSFORM_ROT_90) {
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700924 //swap screen width and height
925 int tmp = screen_w;
926 screen_w = screen_h;
927 screen_h = tmp;
928 }
929 private_handle_t *tmpHnd = NULL;
930
931 if(screen_w <=0 || screen_h<=0 ||src_crop_width<=0 || src_crop_height<=0 ) {
932 ALOGE("%s: wrong params for display screen_w=%d src_crop_width=%d \
Ramakant Singh0b35f2c2014-01-07 11:25:48 +0530933 screen_h=%d src_crop_height=%d", __FUNCTION__, screen_w,
934 src_crop_width,screen_h,src_crop_height);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700935 return -1;
936 }
937
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530938 float dsdx = (float)screen_w/(float)src_crop_width;
939 float dtdy = (float)screen_h/(float)src_crop_height;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700940
941 float scaleLimitMax = copybitsMaxScale * copybitsMaxScale;
942 float scaleLimitMin = copybitsMinScale * copybitsMinScale;
943 if(dsdx > scaleLimitMax ||
944 dtdy > scaleLimitMax ||
945 dsdx < 1/scaleLimitMin ||
946 dtdy < 1/scaleLimitMin) {
Terence Hampson3c560b92013-09-03 16:58:02 -0400947 ALOGW("%s: greater than max supported size dsdx=%f dtdy=%f \
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700948 scaleLimitMax=%f scaleLimitMin=%f", __FUNCTION__,dsdx,dtdy,
949 scaleLimitMax,1/scaleLimitMin);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700950 return -1;
951 }
Terence Hampsonadf47302013-05-23 12:21:02 -0400952 acquireFd = layer->acquireFenceFd;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700953 if(dsdx > copybitsMaxScale ||
954 dtdy > copybitsMaxScale ||
955 dsdx < 1/copybitsMinScale ||
956 dtdy < 1/copybitsMinScale){
957 // The requested scale is out of the range the hardware
958 // can support.
Terence Hampson663dfa72013-08-08 12:35:41 -0400959 ALOGD("%s:%d::Need to scale twice dsdx=%f, dtdy=%f,copybitsMaxScale=%f,\
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700960 copybitsMinScale=%f,screen_w=%d,screen_h=%d \
961 src_crop_width=%d src_crop_height=%d",__FUNCTION__,__LINE__,
962 dsdx,dtdy,copybitsMaxScale,1/copybitsMinScale,screen_w,screen_h,
963 src_crop_width,src_crop_height);
964
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700965
966 int tmp_w = src_crop_width;
967 int tmp_h = src_crop_height;
968
Ramakant Singhd2875e12015-01-19 12:45:41 +0530969 if (dsdx > copybitsMaxScale)
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530970 tmp_w = (int)((float)src_crop_width*copybitsMaxScale);
Ramakant Singhd2875e12015-01-19 12:45:41 +0530971 if (dtdy > copybitsMaxScale)
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530972 tmp_h = (int)((float)src_crop_height*copybitsMaxScale);
Ramakant Singhd2875e12015-01-19 12:45:41 +0530973 // ceil the tmp_w and tmp_h value to maintain proper ratio
974 // b/w src and dst (should not cross the desired scale limit
975 // due to float -> int )
976 if (dsdx < 1/copybitsMinScale)
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530977 tmp_w = (int)ceil((float)src_crop_width/copybitsMinScale);
Ramakant Singhd2875e12015-01-19 12:45:41 +0530978 if (dtdy < 1/copybitsMinScale)
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530979 tmp_h = (int)ceil((float)src_crop_height/copybitsMinScale);
Ramakant Singhd2875e12015-01-19 12:45:41 +0530980
Terence Hampson663dfa72013-08-08 12:35:41 -0400981 ALOGD("%s:%d::tmp_w = %d,tmp_h = %d",__FUNCTION__,__LINE__,tmp_w,tmp_h);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700982
Naseer Ahmed8d0d72a2014-12-19 16:25:09 -0500983 int usage = 0;
Terence Hampsonb6a123a2013-07-18 11:54:16 -0400984 int format = fbHandle->format;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700985
Terence Hampsonb6a123a2013-07-18 11:54:16 -0400986 // We do not want copybit to generate alpha values from nothing
987 if (format == HAL_PIXEL_FORMAT_RGBA_8888 &&
988 src.format != HAL_PIXEL_FORMAT_RGBA_8888) {
989 format = HAL_PIXEL_FORMAT_RGBX_8888;
990 }
Ramkumar Radhakrishnan36bd5272014-01-31 20:03:01 -0800991 if (0 == alloc_buffer(&tmpHnd, tmp_w, tmp_h, format, usage) && tmpHnd) {
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700992 copybit_image_t tmp_dst;
993 copybit_rect_t tmp_rect;
994 tmp_dst.w = tmp_w;
995 tmp_dst.h = tmp_h;
996 tmp_dst.format = tmpHnd->format;
997 tmp_dst.handle = tmpHnd;
998 tmp_dst.horiz_padding = src.horiz_padding;
999 tmp_dst.vert_padding = src.vert_padding;
1000 tmp_rect.l = 0;
1001 tmp_rect.t = 0;
1002 tmp_rect.r = tmp_dst.w;
1003 tmp_rect.b = tmp_dst.h;
1004 //create one clip region
1005 hwc_rect tmp_hwc_rect = {0,0,tmp_rect.r,tmp_rect.b};
1006 hwc_region_t tmp_hwc_reg = {1,(hwc_rect_t const*)&tmp_hwc_rect};
1007 region_iterator tmp_it(tmp_hwc_reg);
1008 copybit->set_parameter(copybit,COPYBIT_TRANSFORM,0);
Naseer Ahmed45a99602012-07-31 19:15:24 -07001009 //TODO: once, we are able to read layer alpha, update this
1010 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255);
Terence Hampsonadf47302013-05-23 12:21:02 -04001011 copybit->set_sync(copybit, acquireFd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001012 err = copybit->stretch(copybit,&tmp_dst, &src, &tmp_rect,
1013 &srcRect, &tmp_it);
1014 if(err < 0){
1015 ALOGE("%s:%d::tmp copybit stretch failed",__FUNCTION__,
1016 __LINE__);
1017 if(tmpHnd)
1018 free_buffer(tmpHnd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001019 return err;
1020 }
Terence Hampsonadf47302013-05-23 12:21:02 -04001021 // use release fence as aquire fd for next stretch
Terence Hampson1d8db6f2013-07-17 11:05:36 -04001022 if (ctx->mMDP.version < qdutils::MDP_V4_0) {
Terence Hampsonadf47302013-05-23 12:21:02 -04001023 copybit->flush_get_fence(copybit, &acquireFd);
Terence Hampson1d8db6f2013-07-17 11:05:36 -04001024 close(acquireFd);
1025 acquireFd = -1;
1026 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001027 // copy new src and src rect crop
1028 src = tmp_dst;
1029 srcRect = tmp_rect;
1030 }
1031 }
1032 // Copybit region
1033 hwc_region_t region = layer->visibleRegionScreen;
Dileep Kumar Reddib588ebd2015-03-18 15:25:22 +05301034 //Do not use visible regions in case of scaling
1035 if (region.numRects > 1) {
1036 if (needsScaling(layer)) {
1037 region.numRects = 1;
1038 region.rects = &layer->displayFrame;
1039 }
1040 }
1041
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001042 region_iterator copybitRegion(region);
1043
1044 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH,
1045 renderBuffer->width);
1046 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT,
1047 renderBuffer->height);
1048 copybit->set_parameter(copybit, COPYBIT_TRANSFORM,
shuoy7c101f92013-08-26 14:48:57 +08001049 layerTransform);
Naseer Ahmed45a99602012-07-31 19:15:24 -07001050 //TODO: once, we are able to read layer alpha, update this
1051 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255);
Ramakant Singh140965d2015-01-08 23:45:04 +05301052 copybit->set_parameter(copybit, COPYBIT_DYNAMIC_FPS, dynamic_fps);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001053 copybit->set_parameter(copybit, COPYBIT_BLEND_MODE,
1054 layer->blending);
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001055 copybit->set_parameter(copybit, COPYBIT_DITHER,
1056 (dst.format == HAL_PIXEL_FORMAT_RGB_565)?
1057 COPYBIT_ENABLE : COPYBIT_DISABLE);
Shivaraj Shettye86506a2013-08-06 12:56:30 +05301058 copybit->set_parameter(copybit, COPYBIT_FG_LAYER, isFG ?
1059 COPYBIT_ENABLE : COPYBIT_DISABLE);
1060
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001061 copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,
1062 COPYBIT_ENABLE);
Terence Hampsonadf47302013-05-23 12:21:02 -04001063 copybit->set_sync(copybit, acquireFd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001064 err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect,
1065 &copybitRegion);
1066 copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,
1067 COPYBIT_DISABLE);
1068
Terence Hampsonadf47302013-05-23 12:21:02 -04001069 if(tmpHnd) {
1070 if (ctx->mMDP.version < qdutils::MDP_V4_0){
1071 int ret = -1, releaseFd;
1072 // we need to wait for the buffer before freeing
1073 copybit->flush_get_fence(copybit, &releaseFd);
1074 ret = sync_wait(releaseFd, 1000);
1075 if(ret < 0) {
1076 ALOGE("%s: sync_wait error!! error no = %d err str = %s",
1077 __FUNCTION__, errno, strerror(errno));
1078 }
1079 close(releaseFd);
1080 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001081 free_buffer(tmpHnd);
Terence Hampsonadf47302013-05-23 12:21:02 -04001082 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001083
1084 if(err < 0)
1085 ALOGE("%s: copybit stretch failed",__FUNCTION__);
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001086 return err;
1087}
1088
Sushil Chauhan943797c2013-10-21 17:35:55 -07001089int CopyBit::fillColorUsingCopybit(hwc_layer_1_t *layer,
1090 private_handle_t *renderBuffer)
1091{
1092 if (!renderBuffer) {
1093 ALOGE("%s: Render Buffer is NULL", __FUNCTION__);
1094 return -1;
1095 }
1096
1097 // Copybit dst
1098 copybit_image_t dst;
1099 dst.w = ALIGN(renderBuffer->width, 32);
1100 dst.h = renderBuffer->height;
1101 dst.format = renderBuffer->format;
1102 dst.base = (void *)renderBuffer->base;
1103 dst.handle = (native_handle_t *)renderBuffer;
1104
1105 // Copybit dst rect
1106 hwc_rect_t displayFrame = layer->displayFrame;
1107 copybit_rect_t dstRect = {displayFrame.left, displayFrame.top,
1108 displayFrame.right, displayFrame.bottom};
1109
1110 uint32_t color = layer->transform;
1111 copybit_device_t *copybit = mEngine;
1112 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH,
1113 renderBuffer->width);
1114 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT,
1115 renderBuffer->height);
1116 copybit->set_parameter(copybit, COPYBIT_DITHER,
1117 (dst.format == HAL_PIXEL_FORMAT_RGB_565) ?
1118 COPYBIT_ENABLE : COPYBIT_DISABLE);
Sushil Chauhan2babecc2013-12-04 17:29:48 -08001119 copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0);
Sushil Chauhan943797c2013-10-21 17:35:55 -07001120 copybit->set_parameter(copybit, COPYBIT_BLEND_MODE, layer->blending);
1121 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, layer->planeAlpha);
1122 copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,COPYBIT_ENABLE);
1123 int res = copybit->fill_color(copybit, &dst, &dstRect, color);
1124 copybit->set_parameter(copybit,COPYBIT_BLIT_TO_FRAMEBUFFER,COPYBIT_DISABLE);
1125 return res;
1126}
1127
Naseer Ahmed5b6708a2012-08-02 13:46:08 -07001128void CopyBit::getLayerResolution(const hwc_layer_1_t* layer,
Naseer Ahmed45a99602012-07-31 19:15:24 -07001129 unsigned int& width, unsigned int& height)
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001130{
1131 hwc_rect_t displayFrame = layer->displayFrame;
1132
1133 width = displayFrame.right - displayFrame.left;
1134 height = displayFrame.bottom - displayFrame.top;
1135}
1136
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001137bool CopyBit::validateParams(hwc_context_t *ctx,
1138 const hwc_display_contents_1_t *list) {
1139 //Validate parameters
1140 if (!ctx) {
1141 ALOGE("%s:Invalid HWC context", __FUNCTION__);
1142 return false;
1143 } else if (!list) {
1144 ALOGE("%s:Invalid HWC layer list", __FUNCTION__);
1145 return false;
1146 }
1147 return true;
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001148}
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001149
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001150
Naseer Ahmed64b81212013-02-14 10:29:47 -05001151int CopyBit::allocRenderBuffers(int w, int h, int f)
1152{
1153 int ret = 0;
1154 for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
1155 if (mRenderBuffer[i] == NULL) {
1156 ret = alloc_buffer(&mRenderBuffer[i],
Naseer Ahmed8d0d72a2014-12-19 16:25:09 -05001157 w, h, f, 0);
Naseer Ahmed64b81212013-02-14 10:29:47 -05001158 }
1159 if(ret < 0) {
1160 freeRenderBuffers();
1161 break;
1162 }
1163 }
1164 return ret;
1165}
1166
1167void CopyBit::freeRenderBuffers()
1168{
1169 for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
1170 if(mRenderBuffer[i]) {
Prabhanjan Kandula5719da42013-11-01 00:14:04 +05301171 //Since we are freeing buffer close the fence if it has a valid one.
1172 if(mRelFd[i] >= 0) {
1173 close(mRelFd[i]);
1174 mRelFd[i] = -1;
1175 }
Naseer Ahmed64b81212013-02-14 10:29:47 -05001176 free_buffer(mRenderBuffer[i]);
1177 mRenderBuffer[i] = NULL;
1178 }
1179 }
1180}
1181
1182private_handle_t * CopyBit::getCurrentRenderBuffer() {
1183 return mRenderBuffer[mCurRenderBufferIndex];
1184}
1185
1186void CopyBit::setReleaseFd(int fd) {
Prabhanjan Kandula5719da42013-11-01 00:14:04 +05301187 if(mRelFd[mCurRenderBufferIndex] >=0)
1188 close(mRelFd[mCurRenderBufferIndex]);
1189 mRelFd[mCurRenderBufferIndex] = dup(fd);
Naseer Ahmed64b81212013-02-14 10:29:47 -05001190}
1191
Sushil Chauhandefd3522014-05-13 18:17:12 -07001192void CopyBit::setReleaseFdSync(int fd) {
1193 if (mRelFd[mCurRenderBufferIndex] >=0) {
1194 int ret = -1;
1195 ret = sync_wait(mRelFd[mCurRenderBufferIndex], 1000);
1196 if (ret < 0)
1197 ALOGE("%s: sync_wait error! errno = %d, err str = %s",
1198 __FUNCTION__, errno, strerror(errno));
1199 close(mRelFd[mCurRenderBufferIndex]);
1200 }
1201 mRelFd[mCurRenderBufferIndex] = dup(fd);
1202}
1203
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001204struct copybit_device_t* CopyBit::getCopyBitDevice() {
1205 return mEngine;
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001206}
1207
Shalaj Jaina70b4352014-06-15 13:47:47 -07001208CopyBit::CopyBit(hwc_context_t *ctx, const int& dpy) : mEngine(0),
1209 mIsModeOn(false), mCopyBitDraw(false), mCurRenderBufferIndex(0) {
Saurabh Shah220a30c2013-10-29 16:12:12 -07001210
1211 getBufferSizeAndDimensions(ctx->dpyAttr[dpy].xres,
1212 ctx->dpyAttr[dpy].yres,
1213 HAL_PIXEL_FORMAT_RGBA_8888,
Sushil Chauhandefd3522014-05-13 18:17:12 -07001214 mAlignedWidth,
1215 mAlignedHeight);
Saurabh Shah220a30c2013-10-29 16:12:12 -07001216
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001217 hw_module_t const *module;
Prabhanjan Kandula5719da42013-11-01 00:14:04 +05301218 for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
Naseer Ahmed64b81212013-02-14 10:29:47 -05001219 mRenderBuffer[i] = NULL;
Prabhanjan Kandula5719da42013-11-01 00:14:04 +05301220 mRelFd[i] = -1;
1221 }
Prabhanjan Kandula73030ba2013-03-15 22:33:39 +05301222
1223 char value[PROPERTY_VALUE_MAX];
1224 property_get("debug.hwc.dynThreshold", value, "2");
1225 mDynThreshold = atof(value);
1226
Ramakant Singh21cec722014-03-07 19:11:45 +05301227 property_get("debug.sf.swaprect", value, "0");
1228 mSwapRectEnable = atoi(value) ? true:false ;
1229 mDirtyLayerIndex = -1;
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001230 if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001231 if(copybit_open(module, &mEngine) < 0) {
1232 ALOGE("FATAL ERROR: copybit open failed.");
1233 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001234 } else {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001235 ALOGE("FATAL ERROR: copybit hw module not found");
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001236 }
1237}
Saurabh Shah661a58f2012-08-30 15:30:49 -07001238
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001239CopyBit::~CopyBit()
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001240{
Naseer Ahmed64b81212013-02-14 10:29:47 -05001241 freeRenderBuffers();
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001242 if(mEngine)
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001243 {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08001244 copybit_close(mEngine);
1245 mEngine = NULL;
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001246 }
1247}
Ramakant Singh21cec722014-03-07 19:11:45 +05301248CopyBit::LayerCache::LayerCache() {
1249 reset();
1250}
1251void CopyBit::LayerCache::reset() {
1252 memset(&hnd, 0, sizeof(hnd));
1253 layerCount = 0;
1254}
1255void CopyBit::LayerCache::updateCounts(hwc_context_t *ctx,
1256 hwc_display_contents_1_t *list, int dpy)
1257{
1258 layerCount = ctx->listStats[dpy].numAppLayers;
1259 for (int i=0; i<ctx->listStats[dpy].numAppLayers; i++){
1260 hnd[i] = list->hwLayers[i].handle;
Dileep Kumar Reddiaa488882014-12-16 11:19:45 +05301261 displayFrame[i] = list->hwLayers[i].displayFrame;
Dileep Kumar Reddi9dab73a2015-02-24 16:15:53 +05301262 drop[i] = ctx->copybitDrop[i];
Ramakant Singh21cec722014-03-07 19:11:45 +05301263 }
1264}
1265
1266CopyBit::FbCache::FbCache() {
1267 reset();
1268}
1269void CopyBit::FbCache::reset() {
1270 memset(&FbdirtyRect, 0, sizeof(FbdirtyRect));
Ramakant Singh19ead272015-03-18 14:11:31 +05301271 memset(&FbdisplayRect, 0, sizeof(FbdisplayRect));
Ramakant Singh21cec722014-03-07 19:11:45 +05301272 FbIndex =0;
1273}
1274
Ramakant Singh19ead272015-03-18 14:11:31 +05301275void CopyBit::FbCache::insertAndUpdateFbCache(hwc_rect_t dirtyRect,
1276 hwc_rect_t displayRect) {
Ramakant Singh21cec722014-03-07 19:11:45 +05301277 FbIndex = FbIndex % NUM_RENDER_BUFFERS;
1278 FbdirtyRect[FbIndex] = dirtyRect;
Ramakant Singh19ead272015-03-18 14:11:31 +05301279 FbdisplayRect[FbIndex] = displayRect;
Ramakant Singh21cec722014-03-07 19:11:45 +05301280 FbIndex++;
1281}
1282
Ramakant Singh19ead272015-03-18 14:11:31 +05301283int CopyBit::FbCache::getUnchangedFbDRCount(hwc_rect_t dirtyRect,
1284 hwc_rect_t displayRect){
Ramakant Singh21cec722014-03-07 19:11:45 +05301285 int sameDirtyCount = 0;
1286 for (int i = 0 ; i < NUM_RENDER_BUFFERS ; i++ ){
Ramakant Singh19ead272015-03-18 14:11:31 +05301287 if( FbdirtyRect[i] == dirtyRect &&
1288 FbdisplayRect[i] == displayRect)
Ramakant Singh21cec722014-03-07 19:11:45 +05301289 sameDirtyCount++;
1290 }
1291 return sameDirtyCount;
1292}
1293
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001294}; //namespace qhwc