blob: 8c83469ac1d8c5bd0330c7b97d646f77ac91fc3b [file] [log] [blame]
Naseer Ahmed31da0b12012-07-31 18:55:33 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
Arun Kumar K.R2aa44c62014-01-21 23:08:28 -08003 * Copyright (C) 2012-2014, 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"
radhakrishna2f00c8f2013-10-21 16:49:21 +053029using namespace qdutils;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070030namespace qhwc {
31
Naseer Ahmed31da0b12012-07-31 18:55:33 -070032struct range {
33 int current;
34 int end;
35};
36struct region_iterator : public copybit_region_t {
37
38 region_iterator(hwc_region_t region) {
39 mRegion = region;
40 r.end = region.numRects;
41 r.current = 0;
42 this->next = iterate;
43 }
44
45private:
46 static int iterate(copybit_region_t const * self, copybit_rect_t* rect){
47 if (!self || !rect) {
48 ALOGE("iterate invalid parameters");
49 return 0;
50 }
51
52 region_iterator const* me =
53 static_cast<region_iterator const*>(self);
54 if (me->r.current != me->r.end) {
55 rect->l = me->mRegion.rects[me->r.current].left;
56 rect->t = me->mRegion.rects[me->r.current].top;
57 rect->r = me->mRegion.rects[me->r.current].right;
58 rect->b = me->mRegion.rects[me->r.current].bottom;
59 me->r.current++;
60 return 1;
61 }
62 return 0;
63 }
64
65 hwc_region_t mRegion;
66 mutable range r;
67};
68
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080069void CopyBit::reset() {
70 mIsModeOn = false;
71 mCopyBitDraw = false;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070072}
73
Naseer Ahmed45a99602012-07-31 19:15:24 -070074bool CopyBit::canUseCopybitForYUV(hwc_context_t *ctx) {
75 // return true for non-overlay targets
Terence Hampsond0fd5792013-05-29 11:56:52 -040076 if(ctx->mMDP.hasOverlay && ctx->mMDP.version >= qdutils::MDP_V4_0) {
Naseer Ahmed45a99602012-07-31 19:15:24 -070077 return false;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070078 }
79 return true;
80}
Naseer Ahmed45a99602012-07-31 19:15:24 -070081
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080082bool CopyBit::canUseCopybitForRGB(hwc_context_t *ctx,
83 hwc_display_contents_1_t *list,
84 int dpy) {
85 int compositionType = qdutils::QCCompositionType::
86 getInstance().getCompositionType();
Naseer Ahmed45a99602012-07-31 19:15:24 -070087
Naseer Ahmed45a99602012-07-31 19:15:24 -070088 if (compositionType & qdutils::COMPOSITION_TYPE_DYN) {
89 // DYN Composition:
Prabhanjan Kandula73030ba2013-03-15 22:33:39 +053090 // use copybit, if (TotalRGBRenderArea < threashold * FB Area)
Naseer Ahmed45a99602012-07-31 19:15:24 -070091 // this is done based on perf inputs in ICS
92 // TODO: Above condition needs to be re-evaluated in JB
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080093 int fbWidth = ctx->dpyAttr[dpy].xres;
94 int fbHeight = ctx->dpyAttr[dpy].yres;
95 unsigned int fbArea = (fbWidth * fbHeight);
Naseer Ahmed45a99602012-07-31 19:15:24 -070096 unsigned int renderArea = getRGBRenderingArea(list);
97 ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u",
98 __FUNCTION__, renderArea, fbArea);
Prabhanjan Kandula73030ba2013-03-15 22:33:39 +053099 if (renderArea < (mDynThreshold * fbArea)) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700100 return true;
101 }
102 } else if ((compositionType & qdutils::COMPOSITION_TYPE_MDP)) {
103 // MDP composition, use COPYBIT always
104 return true;
105 } else if ((compositionType & qdutils::COMPOSITION_TYPE_C2D)) {
106 // C2D composition, use COPYBIT
107 return true;
108 }
109 return false;
110}
111
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800112unsigned int CopyBit::getRGBRenderingArea
113 (const hwc_display_contents_1_t *list) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700114 //Calculates total rendering area for RGB layers
115 unsigned int renderArea = 0;
116 unsigned int w=0, h=0;
Terence Hampsonef379d42013-05-21 10:38:01 -0400117 // Skipping last layer since FrameBuffer layer should not affect
118 // which composition to choose
119 for (unsigned int i=0; i<list->numHwLayers -1; i++) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700120 private_handle_t *hnd = (private_handle_t *)list->hwLayers[i].handle;
121 if (hnd) {
122 if (BUFFER_TYPE_UI == hnd->bufferType) {
123 getLayerResolution(&list->hwLayers[i], w, h);
124 renderArea += (w*h);
125 }
126 }
127 }
128 return renderArea;
129}
130
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800131bool CopyBit::prepare(hwc_context_t *ctx, hwc_display_contents_1_t *list,
132 int dpy) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700133
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800134 if(mEngine == NULL) {
135 // No copybit device found - cannot use copybit
136 return false;
137 }
138 int compositionType = qdutils::QCCompositionType::
139 getInstance().getCompositionType();
Naseer Ahmed45a99602012-07-31 19:15:24 -0700140
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800141 if ((compositionType == qdutils::COMPOSITION_TYPE_GPU) ||
142 (compositionType == qdutils::COMPOSITION_TYPE_CPU)) {
Naseer Ahmed45a99602012-07-31 19:15:24 -0700143 //GPU/CPU composition, don't change layer composition type
144 return true;
145 }
146
Naseer Ahmed45a99602012-07-31 19:15:24 -0700147 if(!(validateParams(ctx, list))) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800148 ALOGE("%s:Invalid Params", __FUNCTION__);
149 return false;
Naseer Ahmed45a99602012-07-31 19:15:24 -0700150 }
151
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800152 if(ctx->listStats[dpy].skipCount) {
153 //GPU will be anyways used
154 return false;
155 }
156
Ramkumar Radhakrishnane661f962013-06-05 17:21:38 -0700157 if (ctx->listStats[dpy].numAppLayers > MAX_NUM_APP_LAYERS) {
Sushil Chauhanb00f59d2013-04-29 18:35:54 -0700158 // Reached max layers supported by HWC.
159 return false;
160 }
161
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800162 bool useCopybitForYUV = canUseCopybitForYUV(ctx);
163 bool useCopybitForRGB = canUseCopybitForRGB(ctx, list, dpy);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500164 LayerProp *layerProp = ctx->layerProp[dpy];
Naseer Ahmed64b81212013-02-14 10:29:47 -0500165
Radhika Ranjan Soni46cf4e92013-08-06 16:40:05 +0530166 // Following are MDP3 limitations for which we
167 // need to fallback to GPU composition:
Terence Hampsonb1021932013-09-18 11:15:19 -0400168 // 1. Plane alpha is not supported by MDP3.
Terence Hampson6b0a4272013-11-06 16:04:51 -0500169 // 2. Scaling is within range
Terence Hampsonc235bda2013-07-12 12:47:38 -0400170 if (qdutils::MDPVersion::getInstance().getMDPVersion() < 400) {
171 for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) {
Terence Hampson6b0a4272013-11-06 16:04:51 -0500172 int dst_h, dst_w, src_h, src_w;
173 float dx, dy;
Terence Hampsonc235bda2013-07-12 12:47:38 -0400174 hwc_layer_1_t *layer = (hwc_layer_1_t *) &list->hwLayers[i];
Radhika Ranjan Soni46cf4e92013-08-06 16:40:05 +0530175 if (layer->planeAlpha != 0xFF)
176 return true;
Ramakant Singhf2b51e62013-11-28 12:07:51 +0530177 hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf);
Terence Hampson6b0a4272013-11-06 16:04:51 -0500178
179 if (layer->transform & HAL_TRANSFORM_ROT_90) {
Ramakant Singhf2b51e62013-11-28 12:07:51 +0530180 src_h = sourceCrop.right - sourceCrop.left;
181 src_w = sourceCrop.bottom - sourceCrop.top;
Terence Hampson6b0a4272013-11-06 16:04:51 -0500182 } else {
Ramakant Singhf2b51e62013-11-28 12:07:51 +0530183 src_h = sourceCrop.bottom - sourceCrop.top;
184 src_w = sourceCrop.right - sourceCrop.left;
Terence Hampson6b0a4272013-11-06 16:04:51 -0500185 }
186 dst_h = layer->displayFrame.bottom - layer->displayFrame.top;
187 dst_w = layer->displayFrame.right - layer->displayFrame.left;
188
Ramakant Singh0b35f2c2014-01-07 11:25:48 +0530189 if(src_w <=0 || src_h<=0 ||dst_w<=0 || dst_h<=0 ) {
190 ALOGE("%s: wrong params for display screen_w=%d \
191 src_crop_width=%d screen_h=%d src_crop_height=%d",
192 __FUNCTION__, dst_w,src_w,dst_h,src_h);
193 return false;
194 }
Terence Hampson6b0a4272013-11-06 16:04:51 -0500195 dx = (float)dst_w/src_w;
196 dy = (float)dst_h/src_h;
Ramakant Singh0b35f2c2014-01-07 11:25:48 +0530197
Terence Hampson6b0a4272013-11-06 16:04:51 -0500198 if (dx > MAX_SCALE_FACTOR || dx < MIN_SCALE_FACTOR)
199 return false;
200
201 if (dy > MAX_SCALE_FACTOR || dy < MIN_SCALE_FACTOR)
202 return false;
Terence Hampsonc235bda2013-07-12 12:47:38 -0400203 }
204 }
Naseer Ahmed64b81212013-02-14 10:29:47 -0500205
206 //Allocate render buffers if they're not allocated
Terence Hampsonc67b0372013-10-09 11:32:21 -0400207 if (ctx->mMDP.version != qdutils::MDP_V3_0_4 &&
208 (useCopybitForYUV || useCopybitForRGB)) {
Saurabh Shah220a30c2013-10-29 16:12:12 -0700209 int ret = allocRenderBuffers(mAlignedFBWidth,
210 mAlignedFBHeight,
211 HAL_PIXEL_FORMAT_RGBA_8888);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500212 if (ret < 0) {
213 return false;
214 } else {
215 mCurRenderBufferIndex = (mCurRenderBufferIndex + 1) %
216 NUM_RENDER_BUFFERS;
217 }
218 }
219
Terence Hampsond0fd5792013-05-29 11:56:52 -0400220 // We cannot mix copybit layer with layers marked to be drawn on FB
221 if (!useCopybitForYUV && ctx->listStats[dpy].yuvCount)
222 return true;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800223
Radhika Ranjan Soni14f6c4b2013-08-28 17:04:49 +0530224 mCopyBitDraw = false;
225 if (useCopybitForRGB &&
226 (useCopybitForYUV || !ctx->listStats[dpy].yuvCount)) {
227 mCopyBitDraw = true;
228 // numAppLayers-1, as we iterate till 0th layer index
229 // Mark all layers to be drawn by copybit
230 for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) {
Naseer Ahmed64b81212013-02-14 10:29:47 -0500231 layerProp[i].mFlags |= HWC_COPYBIT;
Terence Hampsonc67b0372013-10-09 11:32:21 -0400232 if (ctx->mMDP.version == qdutils::MDP_V3_0_4)
233 list->hwLayers[i].compositionType = HWC_BLIT;
234 else
235 list->hwLayers[i].compositionType = HWC_OVERLAY;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700236 }
237 }
Radhika Ranjan Soni14f6c4b2013-08-28 17:04:49 +0530238
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700239 return true;
240}
241
Naseer Ahmed183939d2013-03-14 20:44:17 -0400242int CopyBit::clear (private_handle_t* hnd, hwc_rect_t& rect)
243{
244 int ret = 0;
245 copybit_rect_t clear_rect = {rect.left, rect.top,
246 rect.right,
247 rect.bottom};
248
249 copybit_image_t buf;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700250 buf.w = ALIGN(getWidth(hnd),32);
251 buf.h = getHeight(hnd);
Naseer Ahmed183939d2013-03-14 20:44:17 -0400252 buf.format = hnd->format;
253 buf.base = (void *)hnd->base;
254 buf.handle = (native_handle_t *)hnd;
255
256 copybit_device_t *copybit = mEngine;
257 ret = copybit->clear(copybit, &buf, &clear_rect);
258 return ret;
259}
260
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800261bool CopyBit::draw(hwc_context_t *ctx, hwc_display_contents_1_t *list,
262 int dpy, int32_t *fd) {
263 // draw layers marked for COPYBIT
264 int retVal = true;
265 int copybitLayerCount = 0;
Terence Hampsonc67b0372013-10-09 11:32:21 -0400266 uint32_t last = 0;
Naseer Ahmed64b81212013-02-14 10:29:47 -0500267 LayerProp *layerProp = ctx->layerProp[dpy];
Terence Hampsonc67b0372013-10-09 11:32:21 -0400268 private_handle_t *renderBuffer;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800269
270 if(mCopyBitDraw == false) // there is no layer marked for copybit
Naseer Ahmed64b81212013-02-14 10:29:47 -0500271 return false ;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800272
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800273 //render buffer
Terence Hampsonc67b0372013-10-09 11:32:21 -0400274 if (ctx->mMDP.version == qdutils::MDP_V3_0_4) {
275 last = list->numHwLayers - 1;
276 renderBuffer = (private_handle_t *)list->hwLayers[last].handle;
277 } else {
278 renderBuffer = getCurrentRenderBuffer();
279 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800280 if (!renderBuffer) {
Naseer Ahmed64b81212013-02-14 10:29:47 -0500281 ALOGE("%s: Render buffer layer handle is NULL", __FUNCTION__);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800282 return false;
283 }
Naseer Ahmed64b81212013-02-14 10:29:47 -0500284
Terence Hampson0124cc72013-04-18 23:45:56 -0700285 if (ctx->mMDP.version >= qdutils::MDP_V4_0) {
Terence Hampson65fe4522013-10-17 17:40:03 -0400286 //Wait for the previous frame to complete before rendering onto it
Prabhanjan Kandula5719da42013-11-01 00:14:04 +0530287 if(mRelFd[mCurRenderBufferIndex] >=0) {
288 sync_wait(mRelFd[mCurRenderBufferIndex], 1000);
289 close(mRelFd[mCurRenderBufferIndex]);
290 mRelFd[mCurRenderBufferIndex] = -1;
Terence Hampson65fe4522013-10-17 17:40:03 -0400291 }
Terence Hampson65fe4522013-10-17 17:40:03 -0400292 } else {
Terence Hampsonc67b0372013-10-09 11:32:21 -0400293 if(list->hwLayers[last].acquireFenceFd >=0) {
Terence Hampson65fe4522013-10-17 17:40:03 -0400294 copybit_device_t *copybit = getCopyBitDevice();
Terence Hampsonc67b0372013-10-09 11:32:21 -0400295 copybit->set_sync(copybit, list->hwLayers[last].acquireFenceFd);
Terence Hampson65fe4522013-10-17 17:40:03 -0400296 }
Terence Hampson0124cc72013-04-18 23:45:56 -0700297 }
radhakrishna2f00c8f2013-10-21 16:49:21 +0530298
299 //Clear the transparent or left out region on the render buffer
300 hwc_rect_t clearRegion = {0,0,0,0};
301 if(CBUtils::getuiClearRegion(list, clearRegion, layerProp))
302 clear(renderBuffer, clearRegion);
303
Naseer Ahmed64b81212013-02-14 10:29:47 -0500304 // numAppLayers-1, as we iterate from 0th layer index with HWC_COPYBIT flag
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800305 for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) {
306 hwc_layer_1_t *layer = &list->hwLayers[i];
Naseer Ahmed64b81212013-02-14 10:29:47 -0500307 if(!(layerProp[i].mFlags & HWC_COPYBIT)) {
308 ALOGD_IF(DEBUG_COPYBIT, "%s: Not Marked for copybit", __FUNCTION__);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800309 continue;
310 }
Ramakant Singh762ae082013-11-28 18:45:34 +0530311 if(layer->flags & HWC_SKIP_HWC_COMPOSITION){
312 continue;
313 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800314 int ret = -1;
Terence Hampsonadf47302013-05-23 12:21:02 -0400315 if (list->hwLayers[i].acquireFenceFd != -1
316 && ctx->mMDP.version >= qdutils::MDP_V4_0) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800317 // Wait for acquire Fence on the App buffers.
318 ret = sync_wait(list->hwLayers[i].acquireFenceFd, 1000);
319 if(ret < 0) {
320 ALOGE("%s: sync_wait error!! error no = %d err str = %s",
321 __FUNCTION__, errno, strerror(errno));
322 }
323 close(list->hwLayers[i].acquireFenceFd);
324 list->hwLayers[i].acquireFenceFd = -1;
325 }
326 retVal = drawLayerUsingCopybit(ctx, &(list->hwLayers[i]),
Arun Kumar K.R2aa44c62014-01-21 23:08:28 -0800327 renderBuffer, !i);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800328 copybitLayerCount++;
329 if(retVal < 0) {
330 ALOGE("%s : drawLayerUsingCopybit failed", __FUNCTION__);
331 }
332 }
333
334 if (copybitLayerCount) {
335 copybit_device_t *copybit = getCopyBitDevice();
336 // Async mode
337 copybit->flush_get_fence(copybit, fd);
Terence Hampsonc67b0372013-10-09 11:32:21 -0400338 if(ctx->mMDP.version == qdutils::MDP_V3_0_4 &&
339 list->hwLayers[last].acquireFenceFd >= 0) {
340 close(list->hwLayers[last].acquireFenceFd);
341 list->hwLayers[last].acquireFenceFd = -1;
Terence Hampson65fe4522013-10-17 17:40:03 -0400342 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800343 }
344 return true;
345}
346
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700347int CopyBit::drawLayerUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer,
Arun Kumar K.R2aa44c62014-01-21 23:08:28 -0800348 private_handle_t *renderBuffer, bool isFG)
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700349{
350 hwc_context_t* ctx = (hwc_context_t*)(dev);
Terence Hampsonadf47302013-05-23 12:21:02 -0400351 int err = 0, acquireFd;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700352 if(!ctx) {
353 ALOGE("%s: null context ", __FUNCTION__);
354 return -1;
355 }
356
357 private_handle_t *hnd = (private_handle_t *)layer->handle;
358 if(!hnd) {
Sushil Chauhan943797c2013-10-21 17:35:55 -0700359 if (layer->flags & HWC_COLOR_FILL) { // Color layer
360 return fillColorUsingCopybit(layer, renderBuffer);
361 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700362 ALOGE("%s: invalid handle", __FUNCTION__);
363 return -1;
364 }
365
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800366 private_handle_t *fbHandle = (private_handle_t *)renderBuffer;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700367 if(!fbHandle) {
368 ALOGE("%s: Framebuffer handle is NULL", __FUNCTION__);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700369 return -1;
370 }
371
372 // Set the copybit source:
373 copybit_image_t src;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700374 src.w = getWidth(hnd);
375 src.h = getHeight(hnd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700376 src.format = hnd->format;
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700377
378 // Handle R/B swap
379 if ((layer->flags & HWC_FORMAT_RB_SWAP)) {
380 if (src.format == HAL_PIXEL_FORMAT_RGBA_8888) {
381 src.format = HAL_PIXEL_FORMAT_BGRA_8888;
382 } else if (src.format == HAL_PIXEL_FORMAT_RGBX_8888) {
383 src.format = HAL_PIXEL_FORMAT_BGRX_8888;
384 }
385 }
386
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700387 src.base = (void *)hnd->base;
388 src.handle = (native_handle_t *)layer->handle;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700389 src.horiz_padding = src.w - getWidth(hnd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700390 // Initialize vertical padding to zero for now,
391 // this needs to change to accomodate vertical stride
392 // if needed in the future
393 src.vert_padding = 0;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700394
shuoy7c101f92013-08-26 14:48:57 +0800395 int layerTransform = layer->transform ;
396 // When flip and rotation(90) are present alter the flip,
397 // as GPU is doing the flip and rotation in opposite order
398 // to that of MDP3.0
399 // For 270 degrees, we get 90 + (H+V) which is same as doing
400 // flip first and then rotation (H+V) + 90
401 if (qdutils::MDPVersion::getInstance().getMDPVersion() < 400) {
402 if (((layer->transform& HAL_TRANSFORM_FLIP_H) ||
403 (layer->transform & HAL_TRANSFORM_FLIP_V)) &&
404 (layer->transform & HAL_TRANSFORM_ROT_90) &&
405 !(layer->transform == HAL_TRANSFORM_ROT_270)){
406 if(layer->transform & HAL_TRANSFORM_FLIP_H){
407 layerTransform ^= HAL_TRANSFORM_FLIP_H;
408 layerTransform |= HAL_TRANSFORM_FLIP_V;
409 }
410 if(layer->transform & HAL_TRANSFORM_FLIP_V){
411 layerTransform ^= HAL_TRANSFORM_FLIP_V;
412 layerTransform |= HAL_TRANSFORM_FLIP_H;
413 }
414 }
415 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700416 // Copybit source rect
Saurabh Shah62e1d732013-09-17 10:44:05 -0700417 hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700418 copybit_rect_t srcRect = {sourceCrop.left, sourceCrop.top,
419 sourceCrop.right,
420 sourceCrop.bottom};
421
422 // Copybit destination rect
423 hwc_rect_t displayFrame = layer->displayFrame;
424 copybit_rect_t dstRect = {displayFrame.left, displayFrame.top,
425 displayFrame.right,
426 displayFrame.bottom};
427
428 // Copybit dst
429 copybit_image_t dst;
430 dst.w = ALIGN(fbHandle->width,32);
431 dst.h = fbHandle->height;
432 dst.format = fbHandle->format;
433 dst.base = (void *)fbHandle->base;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800434 dst.handle = (native_handle_t *)fbHandle;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700435
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800436 copybit_device_t *copybit = mEngine;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700437
438 int32_t screen_w = displayFrame.right - displayFrame.left;
439 int32_t screen_h = displayFrame.bottom - displayFrame.top;
440 int32_t src_crop_width = sourceCrop.right - sourceCrop.left;
441 int32_t src_crop_height = sourceCrop.bottom -sourceCrop.top;
442
443 // Copybit dst
444 float copybitsMaxScale =
445 (float)copybit->get(copybit,COPYBIT_MAGNIFICATION_LIMIT);
446 float copybitsMinScale =
447 (float)copybit->get(copybit,COPYBIT_MINIFICATION_LIMIT);
448
Sushil Chauhandffbf432013-12-09 15:33:57 -0800449 if (layer->transform & HWC_TRANSFORM_ROT_90) {
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700450 //swap screen width and height
451 int tmp = screen_w;
452 screen_w = screen_h;
453 screen_h = tmp;
454 }
455 private_handle_t *tmpHnd = NULL;
456
457 if(screen_w <=0 || screen_h<=0 ||src_crop_width<=0 || src_crop_height<=0 ) {
458 ALOGE("%s: wrong params for display screen_w=%d src_crop_width=%d \
Ramakant Singh0b35f2c2014-01-07 11:25:48 +0530459 screen_h=%d src_crop_height=%d", __FUNCTION__, screen_w,
460 src_crop_width,screen_h,src_crop_height);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700461 return -1;
462 }
463
464 float dsdx = (float)screen_w/src_crop_width;
465 float dtdy = (float)screen_h/src_crop_height;
466
467 float scaleLimitMax = copybitsMaxScale * copybitsMaxScale;
468 float scaleLimitMin = copybitsMinScale * copybitsMinScale;
469 if(dsdx > scaleLimitMax ||
470 dtdy > scaleLimitMax ||
471 dsdx < 1/scaleLimitMin ||
472 dtdy < 1/scaleLimitMin) {
Terence Hampson3c560b92013-09-03 16:58:02 -0400473 ALOGW("%s: greater than max supported size dsdx=%f dtdy=%f \
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700474 scaleLimitMax=%f scaleLimitMin=%f", __FUNCTION__,dsdx,dtdy,
475 scaleLimitMax,1/scaleLimitMin);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700476 return -1;
477 }
Terence Hampsonadf47302013-05-23 12:21:02 -0400478 acquireFd = layer->acquireFenceFd;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700479 if(dsdx > copybitsMaxScale ||
480 dtdy > copybitsMaxScale ||
481 dsdx < 1/copybitsMinScale ||
482 dtdy < 1/copybitsMinScale){
483 // The requested scale is out of the range the hardware
484 // can support.
Terence Hampson663dfa72013-08-08 12:35:41 -0400485 ALOGD("%s:%d::Need to scale twice dsdx=%f, dtdy=%f,copybitsMaxScale=%f,\
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700486 copybitsMinScale=%f,screen_w=%d,screen_h=%d \
487 src_crop_width=%d src_crop_height=%d",__FUNCTION__,__LINE__,
488 dsdx,dtdy,copybitsMaxScale,1/copybitsMinScale,screen_w,screen_h,
489 src_crop_width,src_crop_height);
490
491 //Driver makes width and height as even
492 //that may cause wrong calculation of the ratio
493 //in display and crop.Hence we make
494 //crop width and height as even.
495 src_crop_width = (src_crop_width/2)*2;
496 src_crop_height = (src_crop_height/2)*2;
497
498 int tmp_w = src_crop_width;
499 int tmp_h = src_crop_height;
500
501 if (dsdx > copybitsMaxScale || dtdy > copybitsMaxScale ){
502 tmp_w = src_crop_width*copybitsMaxScale;
503 tmp_h = src_crop_height*copybitsMaxScale;
504 }else if (dsdx < 1/copybitsMinScale ||dtdy < 1/copybitsMinScale ){
505 tmp_w = src_crop_width/copybitsMinScale;
506 tmp_h = src_crop_height/copybitsMinScale;
507 tmp_w = (tmp_w/2)*2;
508 tmp_h = (tmp_h/2)*2;
509 }
Terence Hampson663dfa72013-08-08 12:35:41 -0400510 ALOGD("%s:%d::tmp_w = %d,tmp_h = %d",__FUNCTION__,__LINE__,tmp_w,tmp_h);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700511
Naseer Ahmed64b81212013-02-14 10:29:47 -0500512 int usage = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;
Terence Hampsonb6a123a2013-07-18 11:54:16 -0400513 int format = fbHandle->format;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700514
Terence Hampsonb6a123a2013-07-18 11:54:16 -0400515 // We do not want copybit to generate alpha values from nothing
516 if (format == HAL_PIXEL_FORMAT_RGBA_8888 &&
517 src.format != HAL_PIXEL_FORMAT_RGBA_8888) {
518 format = HAL_PIXEL_FORMAT_RGBX_8888;
519 }
520 if (0 == alloc_buffer(&tmpHnd, tmp_w, tmp_h, format, usage)){
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700521 copybit_image_t tmp_dst;
522 copybit_rect_t tmp_rect;
523 tmp_dst.w = tmp_w;
524 tmp_dst.h = tmp_h;
525 tmp_dst.format = tmpHnd->format;
526 tmp_dst.handle = tmpHnd;
527 tmp_dst.horiz_padding = src.horiz_padding;
528 tmp_dst.vert_padding = src.vert_padding;
529 tmp_rect.l = 0;
530 tmp_rect.t = 0;
531 tmp_rect.r = tmp_dst.w;
532 tmp_rect.b = tmp_dst.h;
533 //create one clip region
534 hwc_rect tmp_hwc_rect = {0,0,tmp_rect.r,tmp_rect.b};
535 hwc_region_t tmp_hwc_reg = {1,(hwc_rect_t const*)&tmp_hwc_rect};
536 region_iterator tmp_it(tmp_hwc_reg);
537 copybit->set_parameter(copybit,COPYBIT_TRANSFORM,0);
Naseer Ahmed45a99602012-07-31 19:15:24 -0700538 //TODO: once, we are able to read layer alpha, update this
539 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255);
Terence Hampsonadf47302013-05-23 12:21:02 -0400540 copybit->set_sync(copybit, acquireFd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700541 err = copybit->stretch(copybit,&tmp_dst, &src, &tmp_rect,
542 &srcRect, &tmp_it);
543 if(err < 0){
544 ALOGE("%s:%d::tmp copybit stretch failed",__FUNCTION__,
545 __LINE__);
546 if(tmpHnd)
547 free_buffer(tmpHnd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700548 return err;
549 }
Terence Hampsonadf47302013-05-23 12:21:02 -0400550 // use release fence as aquire fd for next stretch
Terence Hampson1d8db6f2013-07-17 11:05:36 -0400551 if (ctx->mMDP.version < qdutils::MDP_V4_0) {
Terence Hampsonadf47302013-05-23 12:21:02 -0400552 copybit->flush_get_fence(copybit, &acquireFd);
Terence Hampson1d8db6f2013-07-17 11:05:36 -0400553 close(acquireFd);
554 acquireFd = -1;
555 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700556 // copy new src and src rect crop
557 src = tmp_dst;
558 srcRect = tmp_rect;
559 }
560 }
561 // Copybit region
562 hwc_region_t region = layer->visibleRegionScreen;
563 region_iterator copybitRegion(region);
564
565 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH,
566 renderBuffer->width);
567 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT,
568 renderBuffer->height);
569 copybit->set_parameter(copybit, COPYBIT_TRANSFORM,
shuoy7c101f92013-08-26 14:48:57 +0800570 layerTransform);
Naseer Ahmed45a99602012-07-31 19:15:24 -0700571 //TODO: once, we are able to read layer alpha, update this
572 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800573 copybit->set_parameter(copybit, COPYBIT_BLEND_MODE,
574 layer->blending);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700575 copybit->set_parameter(copybit, COPYBIT_DITHER,
576 (dst.format == HAL_PIXEL_FORMAT_RGB_565)?
577 COPYBIT_ENABLE : COPYBIT_DISABLE);
Shivaraj Shettye86506a2013-08-06 12:56:30 +0530578 copybit->set_parameter(copybit, COPYBIT_FG_LAYER, isFG ?
579 COPYBIT_ENABLE : COPYBIT_DISABLE);
580
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700581 copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,
582 COPYBIT_ENABLE);
Terence Hampsonadf47302013-05-23 12:21:02 -0400583 copybit->set_sync(copybit, acquireFd);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700584 err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect,
585 &copybitRegion);
586 copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,
587 COPYBIT_DISABLE);
588
Terence Hampsonadf47302013-05-23 12:21:02 -0400589 if(tmpHnd) {
590 if (ctx->mMDP.version < qdutils::MDP_V4_0){
591 int ret = -1, releaseFd;
592 // we need to wait for the buffer before freeing
593 copybit->flush_get_fence(copybit, &releaseFd);
594 ret = sync_wait(releaseFd, 1000);
595 if(ret < 0) {
596 ALOGE("%s: sync_wait error!! error no = %d err str = %s",
597 __FUNCTION__, errno, strerror(errno));
598 }
599 close(releaseFd);
600 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700601 free_buffer(tmpHnd);
Terence Hampsonadf47302013-05-23 12:21:02 -0400602 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700603
604 if(err < 0)
605 ALOGE("%s: copybit stretch failed",__FUNCTION__);
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700606 return err;
607}
608
Sushil Chauhan943797c2013-10-21 17:35:55 -0700609int CopyBit::fillColorUsingCopybit(hwc_layer_1_t *layer,
610 private_handle_t *renderBuffer)
611{
612 if (!renderBuffer) {
613 ALOGE("%s: Render Buffer is NULL", __FUNCTION__);
614 return -1;
615 }
616
617 // Copybit dst
618 copybit_image_t dst;
619 dst.w = ALIGN(renderBuffer->width, 32);
620 dst.h = renderBuffer->height;
621 dst.format = renderBuffer->format;
622 dst.base = (void *)renderBuffer->base;
623 dst.handle = (native_handle_t *)renderBuffer;
624
625 // Copybit dst rect
626 hwc_rect_t displayFrame = layer->displayFrame;
627 copybit_rect_t dstRect = {displayFrame.left, displayFrame.top,
628 displayFrame.right, displayFrame.bottom};
629
630 uint32_t color = layer->transform;
631 copybit_device_t *copybit = mEngine;
632 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH,
633 renderBuffer->width);
634 copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT,
635 renderBuffer->height);
636 copybit->set_parameter(copybit, COPYBIT_DITHER,
637 (dst.format == HAL_PIXEL_FORMAT_RGB_565) ?
638 COPYBIT_ENABLE : COPYBIT_DISABLE);
Sushil Chauhan2babecc2013-12-04 17:29:48 -0800639 copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0);
Sushil Chauhan943797c2013-10-21 17:35:55 -0700640 copybit->set_parameter(copybit, COPYBIT_BLEND_MODE, layer->blending);
641 copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, layer->planeAlpha);
642 copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER,COPYBIT_ENABLE);
643 int res = copybit->fill_color(copybit, &dst, &dstRect, color);
644 copybit->set_parameter(copybit,COPYBIT_BLIT_TO_FRAMEBUFFER,COPYBIT_DISABLE);
645 return res;
646}
647
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700648void CopyBit::getLayerResolution(const hwc_layer_1_t* layer,
Naseer Ahmed45a99602012-07-31 19:15:24 -0700649 unsigned int& width, unsigned int& height)
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700650{
651 hwc_rect_t displayFrame = layer->displayFrame;
652
653 width = displayFrame.right - displayFrame.left;
654 height = displayFrame.bottom - displayFrame.top;
655}
656
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800657bool CopyBit::validateParams(hwc_context_t *ctx,
658 const hwc_display_contents_1_t *list) {
659 //Validate parameters
660 if (!ctx) {
661 ALOGE("%s:Invalid HWC context", __FUNCTION__);
662 return false;
663 } else if (!list) {
664 ALOGE("%s:Invalid HWC layer list", __FUNCTION__);
665 return false;
666 }
667 return true;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700668}
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700669
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700670
Naseer Ahmed64b81212013-02-14 10:29:47 -0500671int CopyBit::allocRenderBuffers(int w, int h, int f)
672{
673 int ret = 0;
674 for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
675 if (mRenderBuffer[i] == NULL) {
676 ret = alloc_buffer(&mRenderBuffer[i],
677 w, h, f,
678 GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
679 }
680 if(ret < 0) {
681 freeRenderBuffers();
682 break;
683 }
684 }
685 return ret;
686}
687
688void CopyBit::freeRenderBuffers()
689{
690 for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
691 if(mRenderBuffer[i]) {
Prabhanjan Kandula5719da42013-11-01 00:14:04 +0530692 //Since we are freeing buffer close the fence if it has a valid one.
693 if(mRelFd[i] >= 0) {
694 close(mRelFd[i]);
695 mRelFd[i] = -1;
696 }
Naseer Ahmed64b81212013-02-14 10:29:47 -0500697 free_buffer(mRenderBuffer[i]);
698 mRenderBuffer[i] = NULL;
699 }
700 }
701}
702
703private_handle_t * CopyBit::getCurrentRenderBuffer() {
704 return mRenderBuffer[mCurRenderBufferIndex];
705}
706
707void CopyBit::setReleaseFd(int fd) {
Prabhanjan Kandula5719da42013-11-01 00:14:04 +0530708 if(mRelFd[mCurRenderBufferIndex] >=0)
709 close(mRelFd[mCurRenderBufferIndex]);
710 mRelFd[mCurRenderBufferIndex] = dup(fd);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500711}
712
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800713struct copybit_device_t* CopyBit::getCopyBitDevice() {
714 return mEngine;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700715}
716
Saurabh Shah220a30c2013-10-29 16:12:12 -0700717CopyBit::CopyBit(hwc_context_t *ctx, const int& dpy) : mIsModeOn(false),
718 mCopyBitDraw(false), mCurRenderBufferIndex(0) {
719
720 getBufferSizeAndDimensions(ctx->dpyAttr[dpy].xres,
721 ctx->dpyAttr[dpy].yres,
722 HAL_PIXEL_FORMAT_RGBA_8888,
723 mAlignedFBWidth,
724 mAlignedFBHeight);
725
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700726 hw_module_t const *module;
Prabhanjan Kandula5719da42013-11-01 00:14:04 +0530727 for (int i = 0; i < NUM_RENDER_BUFFERS; i++) {
Naseer Ahmed64b81212013-02-14 10:29:47 -0500728 mRenderBuffer[i] = NULL;
Prabhanjan Kandula5719da42013-11-01 00:14:04 +0530729 mRelFd[i] = -1;
730 }
Prabhanjan Kandula73030ba2013-03-15 22:33:39 +0530731
732 char value[PROPERTY_VALUE_MAX];
733 property_get("debug.hwc.dynThreshold", value, "2");
734 mDynThreshold = atof(value);
735
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700736 if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800737 if(copybit_open(module, &mEngine) < 0) {
738 ALOGE("FATAL ERROR: copybit open failed.");
739 }
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700740 } else {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800741 ALOGE("FATAL ERROR: copybit hw module not found");
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700742 }
743}
Saurabh Shah661a58f2012-08-30 15:30:49 -0700744
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800745CopyBit::~CopyBit()
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700746{
Naseer Ahmed64b81212013-02-14 10:29:47 -0500747 freeRenderBuffers();
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800748 if(mEngine)
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700749 {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800750 copybit_close(mEngine);
751 mEngine = NULL;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700752 }
753}
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700754}; //namespace qhwc