Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
Arun Kumar K.R | 2aa44c6 | 2014-01-21 23:08:28 -0800 | [diff] [blame] | 3 | * Copyright (C) 2012-2014, 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" |
radhakrishna | 2f00c8f | 2013-10-21 16:49:21 +0530 | [diff] [blame] | 29 | using namespace qdutils; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 30 | namespace qhwc { |
| 31 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 32 | struct range { |
| 33 | int current; |
| 34 | int end; |
| 35 | }; |
| 36 | struct 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 | |
| 45 | private: |
| 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 69 | void CopyBit::reset() { |
| 70 | mIsModeOn = false; |
| 71 | mCopyBitDraw = false; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 72 | } |
| 73 | |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 74 | bool CopyBit::canUseCopybitForYUV(hwc_context_t *ctx) { |
| 75 | // return true for non-overlay targets |
Terence Hampson | d0fd579 | 2013-05-29 11:56:52 -0400 | [diff] [blame] | 76 | if(ctx->mMDP.hasOverlay && ctx->mMDP.version >= qdutils::MDP_V4_0) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 77 | return false; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 78 | } |
| 79 | return true; |
| 80 | } |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 81 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 82 | bool 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 87 | |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 88 | if (compositionType & qdutils::COMPOSITION_TYPE_DYN) { |
| 89 | // DYN Composition: |
Prabhanjan Kandula | 73030ba | 2013-03-15 22:33:39 +0530 | [diff] [blame] | 90 | // use copybit, if (TotalRGBRenderArea < threashold * FB Area) |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 91 | // this is done based on perf inputs in ICS |
| 92 | // TODO: Above condition needs to be re-evaluated in JB |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 93 | int fbWidth = ctx->dpyAttr[dpy].xres; |
| 94 | int fbHeight = ctx->dpyAttr[dpy].yres; |
| 95 | unsigned int fbArea = (fbWidth * fbHeight); |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 96 | unsigned int renderArea = getRGBRenderingArea(list); |
| 97 | ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u", |
| 98 | __FUNCTION__, renderArea, fbArea); |
Prabhanjan Kandula | 73030ba | 2013-03-15 22:33:39 +0530 | [diff] [blame] | 99 | if (renderArea < (mDynThreshold * fbArea)) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 100 | 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 112 | unsigned int CopyBit::getRGBRenderingArea |
| 113 | (const hwc_display_contents_1_t *list) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 114 | //Calculates total rendering area for RGB layers |
| 115 | unsigned int renderArea = 0; |
| 116 | unsigned int w=0, h=0; |
Terence Hampson | ef379d4 | 2013-05-21 10:38:01 -0400 | [diff] [blame] | 117 | // 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 120 | 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 131 | bool CopyBit::prepare(hwc_context_t *ctx, hwc_display_contents_1_t *list, |
| 132 | int dpy) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 133 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 134 | if(mEngine == NULL) { |
| 135 | // No copybit device found - cannot use copybit |
| 136 | return false; |
| 137 | } |
| 138 | int compositionType = qdutils::QCCompositionType:: |
| 139 | getInstance().getCompositionType(); |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 140 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 141 | if ((compositionType == qdutils::COMPOSITION_TYPE_GPU) || |
| 142 | (compositionType == qdutils::COMPOSITION_TYPE_CPU)) { |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 143 | //GPU/CPU composition, don't change layer composition type |
| 144 | return true; |
| 145 | } |
| 146 | |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 147 | if(!(validateParams(ctx, list))) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 148 | ALOGE("%s:Invalid Params", __FUNCTION__); |
| 149 | return false; |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 150 | } |
| 151 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 152 | if(ctx->listStats[dpy].skipCount) { |
| 153 | //GPU will be anyways used |
| 154 | return false; |
| 155 | } |
| 156 | |
Ramkumar Radhakrishnan | e661f96 | 2013-06-05 17:21:38 -0700 | [diff] [blame] | 157 | if (ctx->listStats[dpy].numAppLayers > MAX_NUM_APP_LAYERS) { |
Sushil Chauhan | b00f59d | 2013-04-29 18:35:54 -0700 | [diff] [blame] | 158 | // Reached max layers supported by HWC. |
| 159 | return false; |
| 160 | } |
| 161 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 162 | bool useCopybitForYUV = canUseCopybitForYUV(ctx); |
| 163 | bool useCopybitForRGB = canUseCopybitForRGB(ctx, list, dpy); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 164 | LayerProp *layerProp = ctx->layerProp[dpy]; |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 165 | |
Radhika Ranjan Soni | 46cf4e9 | 2013-08-06 16:40:05 +0530 | [diff] [blame] | 166 | // Following are MDP3 limitations for which we |
| 167 | // need to fallback to GPU composition: |
Terence Hampson | b102193 | 2013-09-18 11:15:19 -0400 | [diff] [blame] | 168 | // 1. Plane alpha is not supported by MDP3. |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 169 | // 2. Scaling is within range |
Terence Hampson | c235bda | 2013-07-12 12:47:38 -0400 | [diff] [blame] | 170 | if (qdutils::MDPVersion::getInstance().getMDPVersion() < 400) { |
| 171 | for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) { |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 172 | int dst_h, dst_w, src_h, src_w; |
| 173 | float dx, dy; |
Terence Hampson | c235bda | 2013-07-12 12:47:38 -0400 | [diff] [blame] | 174 | 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] | 175 | if (layer->planeAlpha != 0xFF) |
| 176 | return true; |
Ramakant Singh | f2b51e6 | 2013-11-28 12:07:51 +0530 | [diff] [blame] | 177 | hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 178 | |
| 179 | if (layer->transform & HAL_TRANSFORM_ROT_90) { |
Ramakant Singh | f2b51e6 | 2013-11-28 12:07:51 +0530 | [diff] [blame] | 180 | src_h = sourceCrop.right - sourceCrop.left; |
| 181 | src_w = sourceCrop.bottom - sourceCrop.top; |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 182 | } else { |
Ramakant Singh | f2b51e6 | 2013-11-28 12:07:51 +0530 | [diff] [blame] | 183 | src_h = sourceCrop.bottom - sourceCrop.top; |
| 184 | src_w = sourceCrop.right - sourceCrop.left; |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 185 | } |
| 186 | dst_h = layer->displayFrame.bottom - layer->displayFrame.top; |
| 187 | dst_w = layer->displayFrame.right - layer->displayFrame.left; |
| 188 | |
Ramakant Singh | 0b35f2c | 2014-01-07 11:25:48 +0530 | [diff] [blame] | 189 | 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 Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 195 | dx = (float)dst_w/src_w; |
| 196 | dy = (float)dst_h/src_h; |
Ramakant Singh | 0b35f2c | 2014-01-07 11:25:48 +0530 | [diff] [blame] | 197 | |
Terence Hampson | 6b0a427 | 2013-11-06 16:04:51 -0500 | [diff] [blame] | 198 | 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 Hampson | c235bda | 2013-07-12 12:47:38 -0400 | [diff] [blame] | 203 | } |
| 204 | } |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 205 | |
| 206 | //Allocate render buffers if they're not allocated |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 207 | if (ctx->mMDP.version != qdutils::MDP_V3_0_4 && |
| 208 | (useCopybitForYUV || useCopybitForRGB)) { |
Saurabh Shah | 220a30c | 2013-10-29 16:12:12 -0700 | [diff] [blame] | 209 | int ret = allocRenderBuffers(mAlignedFBWidth, |
| 210 | mAlignedFBHeight, |
| 211 | HAL_PIXEL_FORMAT_RGBA_8888); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 212 | if (ret < 0) { |
| 213 | return false; |
| 214 | } else { |
| 215 | mCurRenderBufferIndex = (mCurRenderBufferIndex + 1) % |
| 216 | NUM_RENDER_BUFFERS; |
| 217 | } |
| 218 | } |
| 219 | |
Terence Hampson | d0fd579 | 2013-05-29 11:56:52 -0400 | [diff] [blame] | 220 | // 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 223 | |
Radhika Ranjan Soni | 14f6c4b | 2013-08-28 17:04:49 +0530 | [diff] [blame] | 224 | 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 Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 231 | layerProp[i].mFlags |= HWC_COPYBIT; |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 232 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 236 | } |
| 237 | } |
Radhika Ranjan Soni | 14f6c4b | 2013-08-28 17:04:49 +0530 | [diff] [blame] | 238 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 239 | return true; |
| 240 | } |
| 241 | |
Naseer Ahmed | 183939d | 2013-03-14 20:44:17 -0400 | [diff] [blame] | 242 | int 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 Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 250 | buf.w = ALIGN(getWidth(hnd),32); |
| 251 | buf.h = getHeight(hnd); |
Naseer Ahmed | 183939d | 2013-03-14 20:44:17 -0400 | [diff] [blame] | 252 | 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 261 | bool 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 Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 266 | uint32_t last = 0; |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 267 | LayerProp *layerProp = ctx->layerProp[dpy]; |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 268 | private_handle_t *renderBuffer; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 269 | |
| 270 | if(mCopyBitDraw == false) // there is no layer marked for copybit |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 271 | return false ; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 272 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 273 | //render buffer |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 274 | 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 280 | if (!renderBuffer) { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 281 | ALOGE("%s: Render buffer layer handle is NULL", __FUNCTION__); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 282 | return false; |
| 283 | } |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 284 | |
Terence Hampson | 0124cc7 | 2013-04-18 23:45:56 -0700 | [diff] [blame] | 285 | if (ctx->mMDP.version >= qdutils::MDP_V4_0) { |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 286 | //Wait for the previous frame to complete before rendering onto it |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 287 | if(mRelFd[mCurRenderBufferIndex] >=0) { |
| 288 | sync_wait(mRelFd[mCurRenderBufferIndex], 1000); |
| 289 | close(mRelFd[mCurRenderBufferIndex]); |
| 290 | mRelFd[mCurRenderBufferIndex] = -1; |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 291 | } |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 292 | } else { |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 293 | if(list->hwLayers[last].acquireFenceFd >=0) { |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 294 | copybit_device_t *copybit = getCopyBitDevice(); |
Terence Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 295 | copybit->set_sync(copybit, list->hwLayers[last].acquireFenceFd); |
Terence Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 296 | } |
Terence Hampson | 0124cc7 | 2013-04-18 23:45:56 -0700 | [diff] [blame] | 297 | } |
radhakrishna | 2f00c8f | 2013-10-21 16:49:21 +0530 | [diff] [blame] | 298 | |
| 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 Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 304 | // 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] | 305 | for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) { |
| 306 | hwc_layer_1_t *layer = &list->hwLayers[i]; |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 307 | if(!(layerProp[i].mFlags & HWC_COPYBIT)) { |
| 308 | ALOGD_IF(DEBUG_COPYBIT, "%s: Not Marked for copybit", __FUNCTION__); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 309 | continue; |
| 310 | } |
Ramakant Singh | 762ae08 | 2013-11-28 18:45:34 +0530 | [diff] [blame] | 311 | if(layer->flags & HWC_SKIP_HWC_COMPOSITION){ |
| 312 | continue; |
| 313 | } |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 314 | int ret = -1; |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 315 | if (list->hwLayers[i].acquireFenceFd != -1 |
| 316 | && ctx->mMDP.version >= qdutils::MDP_V4_0) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 317 | // 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.R | 2aa44c6 | 2014-01-21 23:08:28 -0800 | [diff] [blame] | 327 | renderBuffer, !i); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 328 | 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 Hampson | c67b037 | 2013-10-09 11:32:21 -0400 | [diff] [blame] | 338 | 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 Hampson | 65fe452 | 2013-10-17 17:40:03 -0400 | [diff] [blame] | 342 | } |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 343 | } |
| 344 | return true; |
| 345 | } |
| 346 | |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 347 | 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] | 348 | private_handle_t *renderBuffer, bool isFG) |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 349 | { |
| 350 | hwc_context_t* ctx = (hwc_context_t*)(dev); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 351 | int err = 0, acquireFd; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 352 | 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 Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 359 | if (layer->flags & HWC_COLOR_FILL) { // Color layer |
| 360 | return fillColorUsingCopybit(layer, renderBuffer); |
| 361 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 362 | ALOGE("%s: invalid handle", __FUNCTION__); |
| 363 | return -1; |
| 364 | } |
| 365 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 366 | private_handle_t *fbHandle = (private_handle_t *)renderBuffer; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 367 | if(!fbHandle) { |
| 368 | ALOGE("%s: Framebuffer handle is NULL", __FUNCTION__); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 369 | return -1; |
| 370 | } |
| 371 | |
| 372 | // Set the copybit source: |
| 373 | copybit_image_t src; |
Ramkumar Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 374 | src.w = getWidth(hnd); |
| 375 | src.h = getHeight(hnd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 376 | src.format = hnd->format; |
Sushil Chauhan | 1f6d68f | 2013-10-11 11:49:35 -0700 | [diff] [blame] | 377 | |
| 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 387 | src.base = (void *)hnd->base; |
| 388 | src.handle = (native_handle_t *)layer->handle; |
Ramkumar Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 389 | src.horiz_padding = src.w - getWidth(hnd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 390 | // 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 394 | |
shuoy | 7c101f9 | 2013-08-26 14:48:57 +0800 | [diff] [blame] | 395 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 416 | // Copybit source rect |
Saurabh Shah | 62e1d73 | 2013-09-17 10:44:05 -0700 | [diff] [blame] | 417 | hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 418 | 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 434 | dst.handle = (native_handle_t *)fbHandle; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 435 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 436 | copybit_device_t *copybit = mEngine; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 437 | |
| 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 Chauhan | dffbf43 | 2013-12-09 15:33:57 -0800 | [diff] [blame] | 449 | if (layer->transform & HWC_TRANSFORM_ROT_90) { |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 450 | //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 Singh | 0b35f2c | 2014-01-07 11:25:48 +0530 | [diff] [blame] | 459 | screen_h=%d src_crop_height=%d", __FUNCTION__, screen_w, |
| 460 | src_crop_width,screen_h,src_crop_height); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 461 | 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 Hampson | 3c560b9 | 2013-09-03 16:58:02 -0400 | [diff] [blame] | 473 | ALOGW("%s: greater than max supported size dsdx=%f dtdy=%f \ |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 474 | scaleLimitMax=%f scaleLimitMin=%f", __FUNCTION__,dsdx,dtdy, |
| 475 | scaleLimitMax,1/scaleLimitMin); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 476 | return -1; |
| 477 | } |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 478 | acquireFd = layer->acquireFenceFd; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 479 | 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 Hampson | 663dfa7 | 2013-08-08 12:35:41 -0400 | [diff] [blame] | 485 | 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] | 486 | 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 Hampson | 663dfa7 | 2013-08-08 12:35:41 -0400 | [diff] [blame] | 510 | 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] | 511 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 512 | int usage = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP; |
Terence Hampson | b6a123a | 2013-07-18 11:54:16 -0400 | [diff] [blame] | 513 | int format = fbHandle->format; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 514 | |
Terence Hampson | b6a123a | 2013-07-18 11:54:16 -0400 | [diff] [blame] | 515 | // 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 521 | 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 Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 538 | //TODO: once, we are able to read layer alpha, update this |
| 539 | copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 540 | copybit->set_sync(copybit, acquireFd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 541 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 548 | return err; |
| 549 | } |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 550 | // use release fence as aquire fd for next stretch |
Terence Hampson | 1d8db6f | 2013-07-17 11:05:36 -0400 | [diff] [blame] | 551 | if (ctx->mMDP.version < qdutils::MDP_V4_0) { |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 552 | copybit->flush_get_fence(copybit, &acquireFd); |
Terence Hampson | 1d8db6f | 2013-07-17 11:05:36 -0400 | [diff] [blame] | 553 | close(acquireFd); |
| 554 | acquireFd = -1; |
| 555 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 556 | // 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, |
shuoy | 7c101f9 | 2013-08-26 14:48:57 +0800 | [diff] [blame] | 570 | layerTransform); |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 571 | //TODO: once, we are able to read layer alpha, update this |
| 572 | copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 573 | copybit->set_parameter(copybit, COPYBIT_BLEND_MODE, |
| 574 | layer->blending); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 575 | copybit->set_parameter(copybit, COPYBIT_DITHER, |
| 576 | (dst.format == HAL_PIXEL_FORMAT_RGB_565)? |
| 577 | COPYBIT_ENABLE : COPYBIT_DISABLE); |
Shivaraj Shetty | e86506a | 2013-08-06 12:56:30 +0530 | [diff] [blame] | 578 | copybit->set_parameter(copybit, COPYBIT_FG_LAYER, isFG ? |
| 579 | COPYBIT_ENABLE : COPYBIT_DISABLE); |
| 580 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 581 | copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER, |
| 582 | COPYBIT_ENABLE); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 583 | copybit->set_sync(copybit, acquireFd); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 584 | err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect, |
| 585 | ©bitRegion); |
| 586 | copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER, |
| 587 | COPYBIT_DISABLE); |
| 588 | |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 589 | 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 601 | free_buffer(tmpHnd); |
Terence Hampson | adf4730 | 2013-05-23 12:21:02 -0400 | [diff] [blame] | 602 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 603 | |
| 604 | if(err < 0) |
| 605 | ALOGE("%s: copybit stretch failed",__FUNCTION__); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 606 | return err; |
| 607 | } |
| 608 | |
Sushil Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 609 | int 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 Chauhan | 2babecc | 2013-12-04 17:29:48 -0800 | [diff] [blame] | 639 | copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0); |
Sushil Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 640 | 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 Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 648 | void CopyBit::getLayerResolution(const hwc_layer_1_t* layer, |
Naseer Ahmed | 45a9960 | 2012-07-31 19:15:24 -0700 | [diff] [blame] | 649 | unsigned int& width, unsigned int& height) |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 650 | { |
| 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.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 657 | bool 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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 668 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 669 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 670 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 671 | int 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 | |
| 688 | void CopyBit::freeRenderBuffers() |
| 689 | { |
| 690 | for (int i = 0; i < NUM_RENDER_BUFFERS; i++) { |
| 691 | if(mRenderBuffer[i]) { |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 692 | //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 Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 697 | free_buffer(mRenderBuffer[i]); |
| 698 | mRenderBuffer[i] = NULL; |
| 699 | } |
| 700 | } |
| 701 | } |
| 702 | |
| 703 | private_handle_t * CopyBit::getCurrentRenderBuffer() { |
| 704 | return mRenderBuffer[mCurRenderBufferIndex]; |
| 705 | } |
| 706 | |
| 707 | void CopyBit::setReleaseFd(int fd) { |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 708 | if(mRelFd[mCurRenderBufferIndex] >=0) |
| 709 | close(mRelFd[mCurRenderBufferIndex]); |
| 710 | mRelFd[mCurRenderBufferIndex] = dup(fd); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 711 | } |
| 712 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 713 | struct copybit_device_t* CopyBit::getCopyBitDevice() { |
| 714 | return mEngine; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 715 | } |
| 716 | |
Saurabh Shah | 220a30c | 2013-10-29 16:12:12 -0700 | [diff] [blame] | 717 | CopyBit::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 Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 726 | hw_module_t const *module; |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 727 | for (int i = 0; i < NUM_RENDER_BUFFERS; i++) { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 728 | mRenderBuffer[i] = NULL; |
Prabhanjan Kandula | 5719da4 | 2013-11-01 00:14:04 +0530 | [diff] [blame] | 729 | mRelFd[i] = -1; |
| 730 | } |
Prabhanjan Kandula | 73030ba | 2013-03-15 22:33:39 +0530 | [diff] [blame] | 731 | |
| 732 | char value[PROPERTY_VALUE_MAX]; |
| 733 | property_get("debug.hwc.dynThreshold", value, "2"); |
| 734 | mDynThreshold = atof(value); |
| 735 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 736 | if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 737 | if(copybit_open(module, &mEngine) < 0) { |
| 738 | ALOGE("FATAL ERROR: copybit open failed."); |
| 739 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 740 | } else { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 741 | ALOGE("FATAL ERROR: copybit hw module not found"); |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 742 | } |
| 743 | } |
Saurabh Shah | 661a58f | 2012-08-30 15:30:49 -0700 | [diff] [blame] | 744 | |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 745 | CopyBit::~CopyBit() |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 746 | { |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 747 | freeRenderBuffers(); |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 748 | if(mEngine) |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 749 | { |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 750 | copybit_close(mEngine); |
| 751 | mEngine = NULL; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 752 | } |
| 753 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 754 | }; //namespace qhwc |