Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
Ramakant Singh | d2875e1 | 2015-01-19 12:45:41 +0530 | [diff] [blame] | 3 | * Copyright (C) 2012-2015, The Linux Foundation. All rights reserved. |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 4 | * |
radhakrishna | 2f00c8f | 2013-10-21 16:49:21 +0530 | [diff] [blame] | 5 | * Not a Contribution. |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 6 | * |
| 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 20 | #define DEBUG_COPYBIT 0 |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 21 | #include <copybit.h> |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 22 | #include <utils/Timers.h> |
Terence Hampson | 0124cc7 | 2013-04-18 23:45:56 -0700 | [diff] [blame] | 23 | #include <mdp_version.h> |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 24 | #include "hwc_copybit.h" |
| 25 | #include "comptype.h" |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 26 | #include "gr.h" |
radhakrishna | 2f00c8f | 2013-10-21 16:49:21 +0530 | [diff] [blame] | 27 | #include "cb_utils.h" |
Ramakant Singh | 762ae08 | 2013-11-28 18:45:34 +0530 | [diff] [blame] | 28 | #include "cb_swap_rect.h" |
Ramakant Singh | 80f36f2 | 2014-02-25 14:11:35 +0530 | [diff] [blame] | 29 | #include "math.h" |
Saurabh Shah | 74eff4d | 2014-03-28 16:33:13 -0700 | [diff] [blame] | 30 | #include "sync/sync.h" |
| 31 | |
radhakrishna | 2f00c8f | 2013-10-21 16:49:21 +0530 | [diff] [blame] | 32 | using namespace qdutils; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 33 | namespace qhwc { |
| 34 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 35 | struct range { |
| 36 | int current; |
| 37 | int end; |
| 38 | }; |
| 39 | struct region_iterator : public copybit_region_t { |
| 40 | |
| 41 | region_iterator(hwc_region_t region) { |
| 42 | mRegion = region; |
Praveena Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 43 | r.end = (int)region.numRects; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 44 | r.current = 0; |
| 45 | this->next = iterate; |
| 46 | } |
| 47 | |
| 48 | private: |
| 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 72 | void CopyBit::reset() { |
| 73 | mIsModeOn = false; |
| 74 | mCopyBitDraw = false; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 77 | bool CopyBit::canUseCopybitForYUV(hwc_context_t *ctx) { |
| 78 | // return true for non-overlay targets |
Terence Hampson | d0fd579 | 2013-05-29 11:56:52 -0400 | [diff] [blame] | 79 | if(ctx->mMDP.hasOverlay && ctx->mMDP.version >= qdutils::MDP_V4_0) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 80 | return false; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 81 | } |
| 82 | return true; |
| 83 | } |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 84 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 85 | bool 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 90 | |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 91 | if (compositionType & qdutils::COMPOSITION_TYPE_DYN) { |
| 92 | // DYN Composition: |
Prabhanjan Kandula | 73030ba | 2013-03-15 22:33:39 +0530 | [diff] [blame] | 93 | // use copybit, if (TotalRGBRenderArea < threashold * FB Area) |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 94 | // this is done based on perf inputs in ICS |
| 95 | // TODO: Above condition needs to be re-evaluated in JB |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 96 | int fbWidth = ctx->dpyAttr[dpy].xres; |
| 97 | int fbHeight = ctx->dpyAttr[dpy].yres; |
| 98 | unsigned int fbArea = (fbWidth * fbHeight); |
Dileep Kumar Reddi | 4070e93 | 2014-09-30 09:00:57 +0530 | [diff] [blame] | 99 | unsigned int renderArea = getRGBRenderingArea(ctx, list); |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 100 | ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u", |
| 101 | __FUNCTION__, renderArea, fbArea); |
Prabhanjan Kandula | 73030ba | 2013-03-15 22:33:39 +0530 | [diff] [blame] | 102 | if (renderArea < (mDynThreshold * fbArea)) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 103 | 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 Reddi | 4070e93 | 2014-09-30 09:00:57 +0530 | [diff] [blame] | 115 | unsigned int CopyBit::getRGBRenderingArea (const hwc_context_t *ctx, |
| 116 | const hwc_display_contents_1_t *list) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 117 | //Calculates total rendering area for RGB layers |
| 118 | unsigned int renderArea = 0; |
| 119 | unsigned int w=0, h=0; |
Terence Hampson | ef379d4 | 2013-05-21 10:38:01 -0400 | [diff] [blame] | 120 | // 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 123 | private_handle_t *hnd = (private_handle_t *)list->hwLayers[i].handle; |
| 124 | if (hnd) { |
Dileep Kumar Reddi | 4070e93 | 2014-09-30 09:00:57 +0530 | [diff] [blame] | 125 | if (BUFFER_TYPE_UI == hnd->bufferType && !ctx->copybitDrop[i]) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 126 | getLayerResolution(&list->hwLayers[i], w, h); |
| 127 | renderArea += (w*h); |
| 128 | } |
| 129 | } |
| 130 | } |
| 131 | return renderArea; |
| 132 | } |
| 133 | |
Dileep Kumar Reddi | 9dab73a | 2015-02-24 16:15:53 +0530 | [diff] [blame] | 134 | bool CopyBit::isLayerChanging(hwc_context_t *ctx, |
| 135 | hwc_display_contents_1_t *list, int k) { |
Dileep Kumar Reddi | aa48888 | 2014-12-16 11:19:45 +0530 | [diff] [blame] | 136 | if((mLayerCache.hnd[k] != list->hwLayers[k].handle) || |
Dileep Kumar Reddi | 9dab73a | 2015-02-24 16:15:53 +0530 | [diff] [blame] | 137 | (mLayerCache.drop[k] != ctx->copybitDrop[k]) || |
Dileep Kumar Reddi | aa48888 | 2014-12-16 11:19:45 +0530 | [diff] [blame] | 138 | (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 Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 151 | int 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 Reddi | 9dab73a | 2015-02-24 16:15:53 +0530 | [diff] [blame] | 166 | if(isLayerChanging(ctx, list, k)) { |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 167 | 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 Shah | 93c6905 | 2014-04-24 10:27:10 -0700 | [diff] [blame] | 178 | hwc_rect_t dirtyRect = list->hwLayers[changingLayerIndex].displayFrame; |
| 179 | #ifdef QCOM_BSP |
| 180 | dirtyRect = list->hwLayers[changingLayerIndex].dirtyRect; |
| 181 | #endif |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 182 | |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 183 | 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 Reddi | c354504 | 2015-03-11 19:37:06 +0530 | [diff] [blame] | 186 | if(needsScaling(&list->hwLayers[k])||( hnd && isYuvBuffer(hnd)) || |
| 187 | (list->hwLayers[k].transform & HAL_TRANSFORM_ROT_90)) { |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 188 | mFbCache.reset(); |
| 189 | return -1; |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 190 | } |
| 191 | } |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 192 | hwc_rect_t displayRect = list->hwLayers[changingLayerIndex].displayFrame; |
| 193 | if(mFbCache.getUnchangedFbDRCount(dirtyRect, displayRect) < |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 194 | NUM_RENDER_BUFFERS) { |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 195 | mFbCache.insertAndUpdateFbCache(dirtyRect, displayRect); |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 196 | changingLayerIndex = -1; |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 197 | } |
| 198 | } else { |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 199 | mFbCache.reset(); |
| 200 | changingLayerIndex = -1; |
| 201 | } |
| 202 | mLayerCache.updateCounts(ctx,list,dpy); |
| 203 | return changingLayerIndex; |
| 204 | } |
| 205 | |
| 206 | int 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 Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 212 | //2.No scaling |
| 213 | //3.No video layer |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 214 | if(mSwapRectEnable == false) |
| 215 | return -1; |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 216 | return getLayersChanging(ctx, list, dpy); |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 217 | } |
| 218 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 219 | bool CopyBit::prepareOverlap(hwc_context_t *ctx, |
| 220 | hwc_display_contents_1_t *list) { |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 221 | |
| 222 | if (ctx->mMDP.version < qdutils::MDP_V4_0) { |
| 223 | ALOGE("%s: Invalid request", __FUNCTION__); |
| 224 | return false; |
| 225 | } |
| 226 | |
Saurabh Shah | 15455aa | 2015-01-28 13:54:48 -0800 | [diff] [blame] | 227 | 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 Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 234 | return false; |
| 235 | } |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 236 | PtorInfo* ptorInfo = &(ctx->mPtorInfo); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 237 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 238 | // 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.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 250 | // 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 Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 260 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 261 | getBufferSizeAndDimensions(finalW, finalH, HAL_PIXEL_FORMAT_RGBA_8888, |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 262 | 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 282 | bool CopyBit::prepare(hwc_context_t *ctx, hwc_display_contents_1_t *list, |
| 283 | int dpy) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 284 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 285 | if(mEngine == NULL) { |
| 286 | // No copybit device found - cannot use copybit |
| 287 | return false; |
| 288 | } |
Dileep Kumar Reddi | a25a918 | 2014-07-24 20:01:44 +0530 | [diff] [blame] | 289 | |
| 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 296 | int compositionType = qdutils::QCCompositionType:: |
| 297 | getInstance().getCompositionType(); |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 298 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 299 | if ((compositionType == qdutils::COMPOSITION_TYPE_GPU) || |
| 300 | (compositionType == qdutils::COMPOSITION_TYPE_CPU)) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 301 | //GPU/CPU composition, don't change layer composition type |
| 302 | return true; |
| 303 | } |
| 304 | |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 305 | if(!(validateParams(ctx, list))) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 306 | ALOGE("%s:Invalid Params", __FUNCTION__); |
| 307 | return false; |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 308 | } |
| 309 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 310 | if(ctx->listStats[dpy].skipCount) { |
| 311 | //GPU will be anyways used |
| 312 | return false; |
| 313 | } |
| 314 | |
Ramkumar Radhakrishnan | e661f96 | 2013-06-05 17:21:38 -0700 | [diff] [blame] | 315 | if (ctx->listStats[dpy].numAppLayers > MAX_NUM_APP_LAYERS) { |
Sushil Chauhan | b00f59d | 2013-04-29 18:35:54 -0700 | [diff] [blame] | 316 | // Reached max layers supported by HWC. |
| 317 | return false; |
| 318 | } |
| 319 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 320 | bool useCopybitForYUV = canUseCopybitForYUV(ctx); |
| 321 | bool useCopybitForRGB = canUseCopybitForRGB(ctx, list, dpy); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 322 | LayerProp *layerProp = ctx->layerProp[dpy]; |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 323 | |
Radhika Ranjan Soni | 46cf4e9 | 2013-08-06 16:40:05 +0530 | [diff] [blame] | 324 | // Following are MDP3 limitations for which we |
| 325 | // need to fallback to GPU composition: |
Terence Hampson | b102193 | 2013-09-18 11:15:19 -0400 | [diff] [blame] | 326 | // 1. Plane alpha is not supported by MDP3. |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 327 | // 2. Scaling is within range |
Terence Hampson | c235bda | 2013-07-12 12:47:38 -0400 | [diff] [blame] | 328 | if (qdutils::MDPVersion::getInstance().getMDPVersion() < 400) { |
| 329 | for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) { |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 330 | int dst_h, dst_w, src_h, src_w; |
| 331 | float dx, dy; |
Dileep Kumar Reddi | 4070e93 | 2014-09-30 09:00:57 +0530 | [diff] [blame] | 332 | if(ctx->copybitDrop[i]) { |
| 333 | continue; |
| 334 | } |
Terence Hampson | c235bda | 2013-07-12 12:47:38 -0400 | [diff] [blame] | 335 | hwc_layer_1_t *layer = (hwc_layer_1_t *) &list->hwLayers[i]; |
Radhika Ranjan Soni | 46cf4e9 | 2013-08-06 16:40:05 +0530 | [diff] [blame] | 336 | if (layer->planeAlpha != 0xFF) |
| 337 | return true; |
Ramakant Singh | f2b51e6 | 2013-11-28 12:07:51 +0530 | [diff] [blame] | 338 | hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 339 | |
Sushil Chauhan | fda00fc | 2014-03-20 11:08:41 -0700 | [diff] [blame] | 340 | if (has90Transform(layer)) { |
Ramakant Singh | f2b51e6 | 2013-11-28 12:07:51 +0530 | [diff] [blame] | 341 | src_h = sourceCrop.right - sourceCrop.left; |
| 342 | src_w = sourceCrop.bottom - sourceCrop.top; |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 343 | } else { |
Ramakant Singh | f2b51e6 | 2013-11-28 12:07:51 +0530 | [diff] [blame] | 344 | src_h = sourceCrop.bottom - sourceCrop.top; |
| 345 | src_w = sourceCrop.right - sourceCrop.left; |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 346 | } |
| 347 | dst_h = layer->displayFrame.bottom - layer->displayFrame.top; |
| 348 | dst_w = layer->displayFrame.right - layer->displayFrame.left; |
| 349 | |
Ramakant Singh | 0b35f2c | 2014-01-07 11:25:48 +0530 | [diff] [blame] | 350 | 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 Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 356 | dx = (float)dst_w/(float)src_w; |
| 357 | dy = (float)dst_h/(float)src_h; |
Ramakant Singh | 0b35f2c | 2014-01-07 11:25:48 +0530 | [diff] [blame] | 358 | |
Ramakant Singh | d5b369f | 2014-12-09 23:03:43 +0530 | [diff] [blame] | 359 | 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 Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 368 | return false; |
| 369 | |
Ramakant Singh | d5b369f | 2014-12-09 23:03:43 +0530 | [diff] [blame] | 370 | if (dy > scale_factor_max || dy < scale_factor_min) |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 371 | return false; |
Terence Hampson | c235bda | 2013-07-12 12:47:38 -0400 | [diff] [blame] | 372 | } |
| 373 | } |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 374 | |
| 375 | //Allocate render buffers if they're not allocated |
Ramakant Singh | b4106a1 | 2014-10-07 18:06:56 +0530 | [diff] [blame] | 376 | if ((ctx->mMDP.version != qdutils::MDP_V3_0_4 && |
| 377 | ctx->mMDP.version != qdutils::MDP_V3_0_5) && |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 378 | (useCopybitForYUV || useCopybitForRGB)) { |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 379 | int ret = allocRenderBuffers(mAlignedWidth, |
| 380 | mAlignedHeight, |
Saurabh Shah | 220a30c | 2013-10-29 16:12:12 -0700 | [diff] [blame] | 381 | HAL_PIXEL_FORMAT_RGBA_8888); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 382 | if (ret < 0) { |
| 383 | return false; |
| 384 | } else { |
| 385 | mCurRenderBufferIndex = (mCurRenderBufferIndex + 1) % |
| 386 | NUM_RENDER_BUFFERS; |
| 387 | } |
| 388 | } |
| 389 | |
Terence Hampson | d0fd579 | 2013-05-29 11:56:52 -0400 | [diff] [blame] | 390 | // 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 393 | |
Radhika Ranjan Soni | 14f6c4b | 2013-08-28 17:04:49 +0530 | [diff] [blame] | 394 | 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 Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 401 | layerProp[i].mFlags |= HWC_COPYBIT; |
Saurabh Shah | 74eff4d | 2014-03-28 16:33:13 -0700 | [diff] [blame] | 402 | #ifdef QCOM_BSP |
Ramakant Singh | b4106a1 | 2014-10-07 18:06:56 +0530 | [diff] [blame] | 403 | if (ctx->mMDP.version == qdutils::MDP_V3_0_4 || |
| 404 | ctx->mMDP.version == qdutils::MDP_V3_0_5) |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 405 | list->hwLayers[i].compositionType = HWC_BLIT; |
| 406 | else |
Saurabh Shah | 74eff4d | 2014-03-28 16:33:13 -0700 | [diff] [blame] | 407 | #endif |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 408 | list->hwLayers[i].compositionType = HWC_OVERLAY; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 409 | } |
| 410 | } |
Radhika Ranjan Soni | 14f6c4b | 2013-08-28 17:04:49 +0530 | [diff] [blame] | 411 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 412 | return true; |
| 413 | } |
| 414 | |
Naseer Ahmed | 183939d | 2013-03-14 20:44:17 -0400 | [diff] [blame] | 415 | int 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 Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 423 | buf.w = ALIGN(getWidth(hnd),32); |
| 424 | buf.h = getHeight(hnd); |
Naseer Ahmed | 183939d | 2013-03-14 20:44:17 -0400 | [diff] [blame] | 425 | 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 Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 434 | bool CopyBit::drawUsingAppBufferComposition(hwc_context_t *ctx, |
| 435 | hwc_display_contents_1_t *list, |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 436 | int dpy, int *copybitFd) { |
| 437 | int layerCount = 0; |
Shalaj Jain | a70b435 | 2014-06-15 13:47:47 -0700 | [diff] [blame] | 438 | uint32_t last = (uint32_t)list->numHwLayers - 1; |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 439 | hwc_layer_1_t *fbLayer = &list->hwLayers[last]; |
| 440 | private_handle_t *fbhnd = (private_handle_t *)fbLayer->handle; |
Ramakant Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 441 | |
| 442 | if(ctx->enableABC == false) |
| 443 | return false; |
| 444 | |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 445 | if(ctx->listStats[dpy].numAppLayers > MAX_LAYERS_FOR_ABC ) |
Ramakant Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 446 | 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 Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 465 | if(ctx->listStats[dpy].renderBufIndexforABC == 0) { |
| 466 | if(layerCount == 1) |
Ramakant Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 467 | return true; |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 468 | |
Ramakant Singh | cc32661 | 2014-06-19 14:19:18 +0530 | [diff] [blame] | 469 | if(layerCount == MAX_LAYERS_FOR_ABC) { |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 470 | int abcRenderBufIdx = ctx->listStats[dpy].renderBufIndexforABC; |
Ramakant Singh | cc32661 | 2014-06-19 14:19:18 +0530 | [diff] [blame] | 471 | //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 Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 483 | 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 Singh | cc32661 | 2014-06-19 14:19:18 +0530 | [diff] [blame] | 490 | for(int i = abcRenderBufIdx + 1; i < layerCount; i++){ |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 491 | mDirtyLayerIndex = -1; |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 492 | 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 Singh | 52e1c0c | 2014-12-18 23:35:33 +0530 | [diff] [blame] | 500 | close(list->hwLayers[last].acquireFenceFd); |
| 501 | list->hwLayers[last].acquireFenceFd = -1; |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 502 | return true; |
| 503 | } |
Ramakant Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 504 | } |
| 505 | return false; |
| 506 | } |
| 507 | |
| 508 | bool CopyBit::draw(hwc_context_t *ctx, hwc_display_contents_1_t *list, |
| 509 | int dpy, int32_t *fd) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 510 | // draw layers marked for COPYBIT |
| 511 | int retVal = true; |
| 512 | int copybitLayerCount = 0; |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 513 | uint32_t last = 0; |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 514 | LayerProp *layerProp = ctx->layerProp[dpy]; |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 515 | private_handle_t *renderBuffer; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 516 | |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 517 | if(mCopyBitDraw == false){ |
| 518 | mFbCache.reset(); // there is no layer marked for copybit |
| 519 | return false ; |
| 520 | } |
Ramakant Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 521 | |
Ramakant Singh | 467759f | 2014-04-16 11:09:40 +0530 | [diff] [blame] | 522 | if(drawUsingAppBufferComposition(ctx, list, dpy, fd)) { |
Ramakant Singh | 0def28c | 2014-03-28 20:43:13 +0530 | [diff] [blame] | 523 | return true; |
| 524 | } |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 525 | //render buffer |
Ramakant Singh | b4106a1 | 2014-10-07 18:06:56 +0530 | [diff] [blame] | 526 | if (ctx->mMDP.version == qdutils::MDP_V3_0_4 || |
| 527 | ctx->mMDP.version == qdutils::MDP_V3_0_5) { |
Praveena Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 528 | last = (uint32_t)list->numHwLayers - 1; |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 529 | renderBuffer = (private_handle_t *)list->hwLayers[last].handle; |
| 530 | } else { |
| 531 | renderBuffer = getCurrentRenderBuffer(); |
| 532 | } |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 533 | if (!renderBuffer) { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 534 | ALOGE("%s: Render buffer layer handle is NULL", __FUNCTION__); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 535 | return false; |
| 536 | } |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 537 | |
Terence Hampson | 0124cc7 | 2013-04-18 23:45:56 -0700 | [diff] [blame] | 538 | if (ctx->mMDP.version >= qdutils::MDP_V4_0) { |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 539 | //Wait for the previous frame to complete before rendering onto it |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 540 | if(mRelFd[mCurRenderBufferIndex] >=0) { |
| 541 | sync_wait(mRelFd[mCurRenderBufferIndex], 1000); |
| 542 | close(mRelFd[mCurRenderBufferIndex]); |
| 543 | mRelFd[mCurRenderBufferIndex] = -1; |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 544 | } |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 545 | } else { |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 546 | if(list->hwLayers[last].acquireFenceFd >=0) { |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 547 | copybit_device_t *copybit = getCopyBitDevice(); |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 548 | copybit->set_sync(copybit, list->hwLayers[last].acquireFenceFd); |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 549 | } |
Terence Hampson | 0124cc7 | 2013-04-18 23:45:56 -0700 | [diff] [blame] | 550 | } |
radhakrishna | 2f00c8f | 2013-10-21 16:49:21 +0530 | [diff] [blame] | 551 | |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 552 | mDirtyLayerIndex = checkDirtyRect(ctx, list, dpy); |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 553 | ALOGD_IF (DEBUG_COPYBIT, "%s:Dirty Layer Index: %d", |
| 554 | __FUNCTION__, mDirtyLayerIndex); |
Ramakant Singh | 75b427c | 2014-12-08 17:09:31 +0530 | [diff] [blame] | 555 | hwc_rect_t clearRegion = {0,0,0,0}; |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 556 | mDirtyRect = list->hwLayers[last].displayFrame; |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 557 | |
Dileep Kumar Reddi | f4e2e0c | 2014-12-16 11:24:34 +0530 | [diff] [blame] | 558 | if (CBUtils::getuiClearRegion(list, clearRegion, layerProp, |
Ramakant Singh | 909bc2a | 2015-02-10 16:29:21 +0530 | [diff] [blame] | 559 | 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 Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 574 | // numAppLayers-1, as we iterate from 0th layer index with HWC_COPYBIT flag |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 575 | for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 576 | if(!(layerProp[i].mFlags & HWC_COPYBIT)) { |
| 577 | ALOGD_IF(DEBUG_COPYBIT, "%s: Not Marked for copybit", __FUNCTION__); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 578 | continue; |
| 579 | } |
Dileep Kumar Reddi | 4070e93 | 2014-09-30 09:00:57 +0530 | [diff] [blame] | 580 | if(ctx->copybitDrop[i]) { |
| 581 | continue; |
| 582 | } |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 583 | int ret = -1; |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 584 | if (list->hwLayers[i].acquireFenceFd != -1 |
| 585 | && ctx->mMDP.version >= qdutils::MDP_V4_0) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 586 | // 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 Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 596 | renderBuffer, !i); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 597 | 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 Singh | b4106a1 | 2014-10-07 18:06:56 +0530 | [diff] [blame] | 607 | if((ctx->mMDP.version == qdutils::MDP_V3_0_4 || |
| 608 | ctx->mMDP.version == qdutils::MDP_V3_0_5) && |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 609 | list->hwLayers[last].acquireFenceFd >= 0) { |
| 610 | close(list->hwLayers[last].acquireFenceFd); |
| 611 | list->hwLayers[last].acquireFenceFd = -1; |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 612 | } |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 613 | } |
| 614 | return true; |
| 615 | } |
| 616 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 617 | int CopyBit::drawOverlap(hwc_context_t *ctx, hwc_display_contents_1_t *list) { |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 618 | int fd = -1; |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 619 | PtorInfo* ptorInfo = &(ctx->mPtorInfo); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 620 | |
| 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 Reddi | d1f08e4 | 2014-11-05 21:24:27 +0530 | [diff] [blame] | 633 | //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 Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 639 | int copybitLayerCount = 0; |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 640 | for(int j = 0; j < ptorInfo->count; j++) { |
| 641 | int ovlapIndex = ptorInfo->layerIndex[j]; |
| 642 | hwc_rect_t overlap = list->hwLayers[ovlapIndex].displayFrame; |
Prabhanjan Kandula | 9889a20 | 2014-09-04 21:50:35 +0530 | [diff] [blame] | 643 | 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 Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 658 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 659 | // 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 Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 665 | } |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 666 | 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 Reddi | 408fde5 | 2014-11-04 22:53:15 +0530 | [diff] [blame] | 675 | /* |
| 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 Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 693 | |
Dileep Kumar Reddi | 408fde5 | 2014-11-04 22:53:15 +0530 | [diff] [blame] | 694 | int retVal = drawRectUsingCopybit(ctx, layer, renderBuffer, |
| 695 | overlap, destRect); |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 696 | copybitLayerCount++; |
| 697 | if(retVal < 0) { |
| 698 | ALOGE("%s: drawRectUsingCopybit failed", __FUNCTION__); |
| 699 | copybitLayerCount = 0; |
| 700 | } |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 701 | } |
| 702 | } |
| 703 | |
| 704 | if (copybitLayerCount) { |
| 705 | copybit_device_t *copybit = getCopyBitDevice(); |
| 706 | copybit->flush_get_fence(copybit, &fd); |
| 707 | } |
| 708 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 709 | ALOGD_IF(DEBUG_COPYBIT, "%s: done! copybitLayerCount = %d", __FUNCTION__, |
| 710 | copybitLayerCount); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 711 | return fd; |
| 712 | } |
| 713 | |
| 714 | int CopyBit::drawRectUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer, |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 715 | private_handle_t *renderBuffer, hwc_rect_t overlap, |
| 716 | hwc_rect_t destRect) |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 717 | { |
| 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.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 746 | |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 747 | hwc_rect_t dispFrame = layer->displayFrame; |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 748 | hwc_rect_t iRect = getIntersection(dispFrame, overlap); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 749 | hwc_rect_t crop = integerizeSourceCrop(layer->sourceCropf); |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 750 | qhwc::calculate_crop_rects(crop, dispFrame, iRect, |
| 751 | layer->transform); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 752 | |
| 753 | // Copybit source rect |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 754 | copybit_rect_t srcRect = {crop.left, crop.top, crop.right, |
| 755 | crop.bottom}; |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 756 | |
| 757 | // Copybit destination rect |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 758 | copybit_rect_t dstRect = {destRect.left, destRect.top, destRect.right, |
| 759 | destRect.bottom}; |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 760 | |
| 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.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 771 | // 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 = ®Rect; |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 776 | region_iterator copybitRegion(region); |
| 777 | int acquireFd = layer->acquireFenceFd; |
| 778 | |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 779 | copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH, |
| 780 | renderBuffer->width); |
| 781 | copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT, |
| 782 | renderBuffer->height); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 783 | 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.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 787 | (dst.format == HAL_PIXEL_FORMAT_RGB_565) ? COPYBIT_ENABLE : |
| 788 | COPYBIT_DISABLE); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 789 | copybit->set_sync(copybit, acquireFd); |
Arun Kumar K.R | b2a03b1 | 2014-06-03 11:54:10 -0700 | [diff] [blame] | 790 | int err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect, |
| 791 | ©bitRegion); |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 792 | |
| 793 | if (err < 0) |
| 794 | ALOGE("%s: copybit stretch failed",__FUNCTION__); |
| 795 | |
| 796 | return err; |
| 797 | } |
| 798 | |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 799 | int CopyBit::drawLayerUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer, |
Arun Kumar K.R | 2aa44c6 | 2014-01-21 23:08:28 -0800 | [diff] [blame] | 800 | private_handle_t *renderBuffer, bool isFG) |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 801 | { |
| 802 | hwc_context_t* ctx = (hwc_context_t*)(dev); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 803 | int err = 0, acquireFd; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 804 | 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 Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 811 | if (layer->flags & HWC_COLOR_FILL) { // Color layer |
| 812 | return fillColorUsingCopybit(layer, renderBuffer); |
| 813 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 814 | ALOGE("%s: invalid handle", __FUNCTION__); |
| 815 | return -1; |
| 816 | } |
| 817 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 818 | private_handle_t *fbHandle = (private_handle_t *)renderBuffer; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 819 | if(!fbHandle) { |
| 820 | ALOGE("%s: Framebuffer handle is NULL", __FUNCTION__); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 821 | return -1; |
| 822 | } |
Ramakant Singh | 140965d | 2015-01-08 23:45:04 +0530 | [diff] [blame] | 823 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 830 | // Set the copybit source: |
| 831 | copybit_image_t src; |
Ramkumar Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 832 | src.w = getWidth(hnd); |
| 833 | src.h = getHeight(hnd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 834 | src.format = hnd->format; |
Sushil Chauhan | 1f6d68f | 2013-10-11 11:49:35 -0700 | [diff] [blame] | 835 | |
| 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 845 | src.base = (void *)hnd->base; |
| 846 | src.handle = (native_handle_t *)layer->handle; |
Ramkumar Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 847 | src.horiz_padding = src.w - getWidth(hnd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 848 | // 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 852 | |
shuoy | 7c101f9 | 2013-08-26 14:48:57 +0800 | [diff] [blame] | 853 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 874 | // Copybit source rect |
Saurabh Shah | 62e1d73 | 2013-09-17 10:44:05 -0700 | [diff] [blame] | 875 | hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 876 | 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 Shah | 93c6905 | 2014-04-24 10:27:10 -0700 | [diff] [blame] | 885 | #ifdef QCOM_BSP |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 886 | //change src and dst with dirtyRect |
| 887 | if(mDirtyLayerIndex != -1) { |
Dileep Kumar Reddi | f7b7205 | 2014-12-16 11:25:11 +0530 | [diff] [blame] | 888 | 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 Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 900 | } |
Saurabh Shah | 93c6905 | 2014-04-24 10:27:10 -0700 | [diff] [blame] | 901 | #endif |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 902 | // 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 908 | dst.handle = (native_handle_t *)fbHandle; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 909 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 910 | copybit_device_t *copybit = mEngine; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 911 | |
| 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 Chauhan | dffbf43 | 2013-12-09 15:33:57 -0800 | [diff] [blame] | 923 | if (layer->transform & HWC_TRANSFORM_ROT_90) { |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 924 | //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 Singh | 0b35f2c | 2014-01-07 11:25:48 +0530 | [diff] [blame] | 933 | screen_h=%d src_crop_height=%d", __FUNCTION__, screen_w, |
| 934 | src_crop_width,screen_h,src_crop_height); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 935 | return -1; |
| 936 | } |
| 937 | |
Praveena Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 938 | float dsdx = (float)screen_w/(float)src_crop_width; |
| 939 | float dtdy = (float)screen_h/(float)src_crop_height; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 940 | |
| 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 Hampson | 3c560b9 | 2013-09-03 16:58:02 -0400 | [diff] [blame] | 947 | ALOGW("%s: greater than max supported size dsdx=%f dtdy=%f \ |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 948 | scaleLimitMax=%f scaleLimitMin=%f", __FUNCTION__,dsdx,dtdy, |
| 949 | scaleLimitMax,1/scaleLimitMin); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 950 | return -1; |
| 951 | } |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 952 | acquireFd = layer->acquireFenceFd; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 953 | 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 Hampson | 663dfa7 | 2013-08-08 12:35:41 -0400 | [diff] [blame] | 959 | ALOGD("%s:%d::Need to scale twice dsdx=%f, dtdy=%f,copybitsMaxScale=%f,\ |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 960 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 965 | |
| 966 | int tmp_w = src_crop_width; |
| 967 | int tmp_h = src_crop_height; |
| 968 | |
Ramakant Singh | d2875e1 | 2015-01-19 12:45:41 +0530 | [diff] [blame] | 969 | if (dsdx > copybitsMaxScale) |
Praveena Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 970 | tmp_w = (int)((float)src_crop_width*copybitsMaxScale); |
Ramakant Singh | d2875e1 | 2015-01-19 12:45:41 +0530 | [diff] [blame] | 971 | if (dtdy > copybitsMaxScale) |
Praveena Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 972 | tmp_h = (int)((float)src_crop_height*copybitsMaxScale); |
Ramakant Singh | d2875e1 | 2015-01-19 12:45:41 +0530 | [diff] [blame] | 973 | // 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 Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 977 | tmp_w = (int)ceil((float)src_crop_width/copybitsMinScale); |
Ramakant Singh | d2875e1 | 2015-01-19 12:45:41 +0530 | [diff] [blame] | 978 | if (dtdy < 1/copybitsMinScale) |
Praveena Pachipulusu | d9443c7 | 2014-02-17 10:42:28 +0530 | [diff] [blame] | 979 | tmp_h = (int)ceil((float)src_crop_height/copybitsMinScale); |
Ramakant Singh | d2875e1 | 2015-01-19 12:45:41 +0530 | [diff] [blame] | 980 | |
Terence Hampson | 663dfa7 | 2013-08-08 12:35:41 -0400 | [diff] [blame] | 981 | ALOGD("%s:%d::tmp_w = %d,tmp_h = %d",__FUNCTION__,__LINE__,tmp_w,tmp_h); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 982 | |
Naseer Ahmed | 8d0d72a | 2014-12-19 16:25:09 -0500 | [diff] [blame] | 983 | int usage = 0; |
Terence Hampson | b6a123a | 2013-07-18 11:54:16 -0400 | [diff] [blame] | 984 | int format = fbHandle->format; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 985 | |
Terence Hampson | b6a123a | 2013-07-18 11:54:16 -0400 | [diff] [blame] | 986 | // 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 Radhakrishnan | 36bd527 | 2014-01-31 20:03:01 -0800 | [diff] [blame] | 991 | if (0 == alloc_buffer(&tmpHnd, tmp_w, tmp_h, format, usage) && tmpHnd) { |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 992 | 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 1009 | //TODO: once, we are able to read layer alpha, update this |
| 1010 | copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 1011 | copybit->set_sync(copybit, acquireFd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1012 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1019 | return err; |
| 1020 | } |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 1021 | // use release fence as aquire fd for next stretch |
Terence Hampson | 1d8db6f | 2013-07-17 11:05:36 -0400 | [diff] [blame] | 1022 | if (ctx->mMDP.version < qdutils::MDP_V4_0) { |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 1023 | copybit->flush_get_fence(copybit, &acquireFd); |
Terence Hampson | 1d8db6f | 2013-07-17 11:05:36 -0400 | [diff] [blame] | 1024 | close(acquireFd); |
| 1025 | acquireFd = -1; |
| 1026 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1027 | // 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 Reddi | b588ebd | 2015-03-18 15:25:22 +0530 | [diff] [blame] | 1034 | //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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1042 | 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, |
shuoy | 7c101f9 | 2013-08-26 14:48:57 +0800 | [diff] [blame] | 1049 | layerTransform); |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 1050 | //TODO: once, we are able to read layer alpha, update this |
| 1051 | copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); |
Ramakant Singh | 140965d | 2015-01-08 23:45:04 +0530 | [diff] [blame] | 1052 | copybit->set_parameter(copybit, COPYBIT_DYNAMIC_FPS, dynamic_fps); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1053 | copybit->set_parameter(copybit, COPYBIT_BLEND_MODE, |
| 1054 | layer->blending); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1055 | copybit->set_parameter(copybit, COPYBIT_DITHER, |
| 1056 | (dst.format == HAL_PIXEL_FORMAT_RGB_565)? |
| 1057 | COPYBIT_ENABLE : COPYBIT_DISABLE); |
Shivaraj Shetty | e86506a | 2013-08-06 12:56:30 +0530 | [diff] [blame] | 1058 | copybit->set_parameter(copybit, COPYBIT_FG_LAYER, isFG ? |
| 1059 | COPYBIT_ENABLE : COPYBIT_DISABLE); |
| 1060 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1061 | copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER, |
| 1062 | COPYBIT_ENABLE); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 1063 | copybit->set_sync(copybit, acquireFd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1064 | err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect, |
| 1065 | ©bitRegion); |
| 1066 | copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER, |
| 1067 | COPYBIT_DISABLE); |
| 1068 | |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 1069 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1081 | free_buffer(tmpHnd); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 1082 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1083 | |
| 1084 | if(err < 0) |
| 1085 | ALOGE("%s: copybit stretch failed",__FUNCTION__); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1086 | return err; |
| 1087 | } |
| 1088 | |
Sushil Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 1089 | int 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 Chauhan | 2babecc | 2013-12-04 17:29:48 -0800 | [diff] [blame] | 1119 | copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0); |
Sushil Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 1120 | 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 Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 1128 | void CopyBit::getLayerResolution(const hwc_layer_1_t* layer, |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 1129 | unsigned int& width, unsigned int& height) |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1130 | { |
| 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1137 | bool 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1148 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1149 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1150 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 1151 | int 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 Ahmed | 8d0d72a | 2014-12-19 16:25:09 -0500 | [diff] [blame] | 1157 | w, h, f, 0); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 1158 | } |
| 1159 | if(ret < 0) { |
| 1160 | freeRenderBuffers(); |
| 1161 | break; |
| 1162 | } |
| 1163 | } |
| 1164 | return ret; |
| 1165 | } |
| 1166 | |
| 1167 | void CopyBit::freeRenderBuffers() |
| 1168 | { |
| 1169 | for (int i = 0; i < NUM_RENDER_BUFFERS; i++) { |
| 1170 | if(mRenderBuffer[i]) { |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 1171 | //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 Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 1176 | free_buffer(mRenderBuffer[i]); |
| 1177 | mRenderBuffer[i] = NULL; |
| 1178 | } |
| 1179 | } |
| 1180 | } |
| 1181 | |
| 1182 | private_handle_t * CopyBit::getCurrentRenderBuffer() { |
| 1183 | return mRenderBuffer[mCurRenderBufferIndex]; |
| 1184 | } |
| 1185 | |
| 1186 | void CopyBit::setReleaseFd(int fd) { |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 1187 | if(mRelFd[mCurRenderBufferIndex] >=0) |
| 1188 | close(mRelFd[mCurRenderBufferIndex]); |
| 1189 | mRelFd[mCurRenderBufferIndex] = dup(fd); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 1190 | } |
| 1191 | |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 1192 | void 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1204 | struct copybit_device_t* CopyBit::getCopyBitDevice() { |
| 1205 | return mEngine; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1206 | } |
| 1207 | |
Shalaj Jain | a70b435 | 2014-06-15 13:47:47 -0700 | [diff] [blame] | 1208 | CopyBit::CopyBit(hwc_context_t *ctx, const int& dpy) : mEngine(0), |
| 1209 | mIsModeOn(false), mCopyBitDraw(false), mCurRenderBufferIndex(0) { |
Saurabh Shah | 220a30c | 2013-10-29 16:12:12 -0700 | [diff] [blame] | 1210 | |
| 1211 | getBufferSizeAndDimensions(ctx->dpyAttr[dpy].xres, |
| 1212 | ctx->dpyAttr[dpy].yres, |
| 1213 | HAL_PIXEL_FORMAT_RGBA_8888, |
Sushil Chauhan | defd352 | 2014-05-13 18:17:12 -0700 | [diff] [blame] | 1214 | mAlignedWidth, |
| 1215 | mAlignedHeight); |
Saurabh Shah | 220a30c | 2013-10-29 16:12:12 -0700 | [diff] [blame] | 1216 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1217 | hw_module_t const *module; |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 1218 | for (int i = 0; i < NUM_RENDER_BUFFERS; i++) { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 1219 | mRenderBuffer[i] = NULL; |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 1220 | mRelFd[i] = -1; |
| 1221 | } |
Prabhanjan Kandula | 73030ba | 2013-03-15 22:33:39 +0530 | [diff] [blame] | 1222 | |
| 1223 | char value[PROPERTY_VALUE_MAX]; |
| 1224 | property_get("debug.hwc.dynThreshold", value, "2"); |
| 1225 | mDynThreshold = atof(value); |
| 1226 | |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1227 | property_get("debug.sf.swaprect", value, "0"); |
| 1228 | mSwapRectEnable = atoi(value) ? true:false ; |
| 1229 | mDirtyLayerIndex = -1; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1230 | if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1231 | if(copybit_open(module, &mEngine) < 0) { |
| 1232 | ALOGE("FATAL ERROR: copybit open failed."); |
| 1233 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1234 | } else { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1235 | ALOGE("FATAL ERROR: copybit hw module not found"); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1236 | } |
| 1237 | } |
Saurabh Shah | 661a58f | 2012-08-30 15:30:49 -0700 | [diff] [blame] | 1238 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1239 | CopyBit::~CopyBit() |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1240 | { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 1241 | freeRenderBuffers(); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1242 | if(mEngine) |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1243 | { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 1244 | copybit_close(mEngine); |
| 1245 | mEngine = NULL; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1246 | } |
| 1247 | } |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1248 | CopyBit::LayerCache::LayerCache() { |
| 1249 | reset(); |
| 1250 | } |
| 1251 | void CopyBit::LayerCache::reset() { |
| 1252 | memset(&hnd, 0, sizeof(hnd)); |
| 1253 | layerCount = 0; |
| 1254 | } |
| 1255 | void 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 Reddi | aa48888 | 2014-12-16 11:19:45 +0530 | [diff] [blame] | 1261 | displayFrame[i] = list->hwLayers[i].displayFrame; |
Dileep Kumar Reddi | 9dab73a | 2015-02-24 16:15:53 +0530 | [diff] [blame] | 1262 | drop[i] = ctx->copybitDrop[i]; |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1263 | } |
| 1264 | } |
| 1265 | |
| 1266 | CopyBit::FbCache::FbCache() { |
| 1267 | reset(); |
| 1268 | } |
| 1269 | void CopyBit::FbCache::reset() { |
| 1270 | memset(&FbdirtyRect, 0, sizeof(FbdirtyRect)); |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 1271 | memset(&FbdisplayRect, 0, sizeof(FbdisplayRect)); |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1272 | FbIndex =0; |
| 1273 | } |
| 1274 | |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 1275 | void CopyBit::FbCache::insertAndUpdateFbCache(hwc_rect_t dirtyRect, |
| 1276 | hwc_rect_t displayRect) { |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1277 | FbIndex = FbIndex % NUM_RENDER_BUFFERS; |
| 1278 | FbdirtyRect[FbIndex] = dirtyRect; |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 1279 | FbdisplayRect[FbIndex] = displayRect; |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1280 | FbIndex++; |
| 1281 | } |
| 1282 | |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 1283 | int CopyBit::FbCache::getUnchangedFbDRCount(hwc_rect_t dirtyRect, |
| 1284 | hwc_rect_t displayRect){ |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1285 | int sameDirtyCount = 0; |
| 1286 | for (int i = 0 ; i < NUM_RENDER_BUFFERS ; i++ ){ |
Ramakant Singh | 19ead27 | 2015-03-18 14:11:31 +0530 | [diff] [blame] | 1287 | if( FbdirtyRect[i] == dirtyRect && |
| 1288 | FbdisplayRect[i] == displayRect) |
Ramakant Singh | 21cec72 | 2014-03-07 19:11:45 +0530 | [diff] [blame] | 1289 | sameDirtyCount++; |
| 1290 | } |
| 1291 | return sameDirtyCount; |
| 1292 | } |
| 1293 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1294 | }; //namespace qhwc |