| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * Copyright (C) 2012-2013, The Linux Foundation. All rights reserved. |
| * |
| * Not a Contribution, Apache license notifications and license are retained |
| * for attribution purposes only. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define DEBUG_COPYBIT 0 |
| #include <copybit.h> |
| #include <utils/Timers.h> |
| #include "hwc_copybit.h" |
| #include "comptype.h" |
| |
| //XXX: Remove HWC_BLIT |
| #ifndef QCOM_BSP |
| #define HWC_BLIT 4 |
| #endif |
| |
| namespace qhwc { |
| |
| struct range { |
| int current; |
| int end; |
| }; |
| struct region_iterator : public copybit_region_t { |
| |
| region_iterator(hwc_region_t region) { |
| mRegion = region; |
| r.end = region.numRects; |
| r.current = 0; |
| this->next = iterate; |
| } |
| |
| private: |
| static int iterate(copybit_region_t const * self, copybit_rect_t* rect){ |
| if (!self || !rect) { |
| ALOGE("iterate invalid parameters"); |
| return 0; |
| } |
| |
| region_iterator const* me = |
| static_cast<region_iterator const*>(self); |
| if (me->r.current != me->r.end) { |
| rect->l = me->mRegion.rects[me->r.current].left; |
| rect->t = me->mRegion.rects[me->r.current].top; |
| rect->r = me->mRegion.rects[me->r.current].right; |
| rect->b = me->mRegion.rects[me->r.current].bottom; |
| me->r.current++; |
| return 1; |
| } |
| return 0; |
| } |
| |
| hwc_region_t mRegion; |
| mutable range r; |
| }; |
| |
| void CopyBit::reset() { |
| mIsModeOn = false; |
| mCopyBitDraw = false; |
| } |
| |
| bool CopyBit::canUseCopybitForYUV(hwc_context_t *ctx) { |
| // return true for non-overlay targets |
| if(ctx->mMDP.hasOverlay) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool CopyBit::canUseCopybitForRGB(hwc_context_t *ctx, |
| hwc_display_contents_1_t *list, |
| int dpy) { |
| int compositionType = qdutils::QCCompositionType:: |
| getInstance().getCompositionType(); |
| |
| if ((compositionType & qdutils::COMPOSITION_TYPE_C2D) || |
| (compositionType & qdutils::COMPOSITION_TYPE_DYN)) { |
| if(ctx->listStats[dpy].yuvCount) { |
| //Overlay up & running. Dont use COPYBIT for RGB layers. |
| return false; |
| } |
| } |
| |
| if (compositionType & qdutils::COMPOSITION_TYPE_DYN) { |
| // DYN Composition: |
| // use copybit, if (TotalRGBRenderArea < 2 * FB Area) |
| // this is done based on perf inputs in ICS |
| // TODO: Above condition needs to be re-evaluated in JB |
| int fbWidth = ctx->dpyAttr[dpy].xres; |
| int fbHeight = ctx->dpyAttr[dpy].yres; |
| unsigned int fbArea = (fbWidth * fbHeight); |
| unsigned int renderArea = getRGBRenderingArea(list); |
| ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u", |
| __FUNCTION__, renderArea, fbArea); |
| if (renderArea <= (2 * fbArea)) { |
| return true; |
| } |
| } else if ((compositionType & qdutils::COMPOSITION_TYPE_MDP)) { |
| // MDP composition, use COPYBIT always |
| return true; |
| } else if ((compositionType & qdutils::COMPOSITION_TYPE_C2D)) { |
| // C2D composition, use COPYBIT |
| return true; |
| } |
| return false; |
| } |
| |
| unsigned int CopyBit::getRGBRenderingArea |
| (const hwc_display_contents_1_t *list) { |
| //Calculates total rendering area for RGB layers |
| unsigned int renderArea = 0; |
| unsigned int w=0, h=0; |
| for (unsigned int i=0; i<list->numHwLayers; i++) { |
| private_handle_t *hnd = (private_handle_t *)list->hwLayers[i].handle; |
| if (hnd) { |
| if (BUFFER_TYPE_UI == hnd->bufferType) { |
| getLayerResolution(&list->hwLayers[i], w, h); |
| renderArea += (w*h); |
| } |
| } |
| } |
| return renderArea; |
| } |
| |
| bool CopyBit::prepare(hwc_context_t *ctx, hwc_display_contents_1_t *list, |
| int dpy) { |
| |
| if(mEngine == NULL) { |
| // No copybit device found - cannot use copybit |
| return false; |
| } |
| int compositionType = qdutils::QCCompositionType:: |
| getInstance().getCompositionType(); |
| |
| if ((compositionType == qdutils::COMPOSITION_TYPE_GPU) || |
| (compositionType == qdutils::COMPOSITION_TYPE_CPU)) { |
| //GPU/CPU composition, don't change layer composition type |
| return true; |
| } |
| |
| if(!(validateParams(ctx, list))) { |
| ALOGE("%s:Invalid Params", __FUNCTION__); |
| return false; |
| } |
| |
| if(ctx->listStats[dpy].skipCount) { |
| //GPU will be anyways used |
| return false; |
| } |
| |
| bool useCopybitForYUV = canUseCopybitForYUV(ctx); |
| bool useCopybitForRGB = canUseCopybitForRGB(ctx, list, dpy); |
| |
| // numAppLayers-1, as we iterate till 0th layer index |
| for (int i = ctx->listStats[dpy].numAppLayers-1; i >= 0 ; i--) { |
| private_handle_t *hnd = (private_handle_t *)list->hwLayers[i].handle; |
| |
| if (hnd->bufferType == BUFFER_TYPE_VIDEO) { |
| //YUV layer, check, if copybit can be used |
| // mark the video layer to gpu when all layer is |
| // going to gpu in case of dynamic composition. |
| if (useCopybitForYUV) { |
| list->hwLayers[i].compositionType = HWC_BLIT; |
| mCopyBitDraw = true; |
| } |
| } else if (hnd->bufferType == BUFFER_TYPE_UI) { |
| //RGB layer, check, if copybit can be used |
| if (useCopybitForRGB) { |
| ALOGD_IF(DEBUG_COPYBIT, "%s: Marking layer[%d] for copybit for" |
| "dpy[%d] ", __FUNCTION__, i, dpy); |
| list->hwLayers[i].compositionType = HWC_BLIT; |
| mCopyBitDraw = true; |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool CopyBit::draw(hwc_context_t *ctx, hwc_display_contents_1_t *list, |
| int dpy, int32_t *fd) { |
| // draw layers marked for COPYBIT |
| int retVal = true; |
| int copybitLayerCount = 0; |
| |
| if(mCopyBitDraw == false) // there is no layer marked for copybit |
| return true ; |
| |
| size_t fbLayerIndex = ctx->listStats[dpy].fbLayerIndex; |
| hwc_layer_1_t *fbLayer = &list->hwLayers[fbLayerIndex]; |
| //render buffer |
| private_handle_t *renderBuffer = (private_handle_t *)fbLayer->handle; |
| if (!renderBuffer) { |
| ALOGE("%s: HWC_FRAMEBUFFER_TARGET layer handle is NULL", __FUNCTION__); |
| return false; |
| } |
| // numAppLayers-1, as we iterate from 0th layer index with HWC_BLIT flag |
| for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) { |
| hwc_layer_1_t *layer = &list->hwLayers[i]; |
| if(!list->hwLayers[i].compositionType == HWC_BLIT) { |
| ALOGD_IF(DEBUG_COPYBIT, "%s: Not Marked for C2D", __FUNCTION__); |
| continue; |
| } |
| int ret = -1; |
| if (list->hwLayers[i].acquireFenceFd != -1 ) { |
| // Wait for acquire Fence on the App buffers. |
| ret = sync_wait(list->hwLayers[i].acquireFenceFd, 1000); |
| if(ret < 0) { |
| ALOGE("%s: sync_wait error!! error no = %d err str = %s", |
| __FUNCTION__, errno, strerror(errno)); |
| } |
| close(list->hwLayers[i].acquireFenceFd); |
| list->hwLayers[i].acquireFenceFd = -1; |
| } |
| retVal = drawLayerUsingCopybit(ctx, &(list->hwLayers[i]), |
| renderBuffer, dpy); |
| copybitLayerCount++; |
| if(retVal < 0) { |
| ALOGE("%s : drawLayerUsingCopybit failed", __FUNCTION__); |
| } |
| } |
| |
| if (copybitLayerCount) { |
| copybit_device_t *copybit = getCopyBitDevice(); |
| // Async mode |
| copybit->flush_get_fence(copybit, fd); |
| } |
| return true; |
| } |
| |
| int CopyBit::drawLayerUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer, |
| private_handle_t *renderBuffer, int dpy) |
| { |
| hwc_context_t* ctx = (hwc_context_t*)(dev); |
| int err = 0; |
| if(!ctx) { |
| ALOGE("%s: null context ", __FUNCTION__); |
| return -1; |
| } |
| |
| private_handle_t *hnd = (private_handle_t *)layer->handle; |
| if(!hnd) { |
| ALOGE("%s: invalid handle", __FUNCTION__); |
| return -1; |
| } |
| |
| private_handle_t *fbHandle = (private_handle_t *)renderBuffer; |
| if(!fbHandle) { |
| ALOGE("%s: Framebuffer handle is NULL", __FUNCTION__); |
| return -1; |
| } |
| |
| // Set the copybit source: |
| copybit_image_t src; |
| src.w = hnd->width; |
| src.h = hnd->height; |
| src.format = hnd->format; |
| src.base = (void *)hnd->base; |
| src.handle = (native_handle_t *)layer->handle; |
| src.horiz_padding = src.w - hnd->width; |
| // Initialize vertical padding to zero for now, |
| // this needs to change to accomodate vertical stride |
| // if needed in the future |
| src.vert_padding = 0; |
| |
| // Copybit source rect |
| hwc_rect_t sourceCrop = layer->sourceCrop; |
| copybit_rect_t srcRect = {sourceCrop.left, sourceCrop.top, |
| sourceCrop.right, |
| sourceCrop.bottom}; |
| |
| // Copybit destination rect |
| hwc_rect_t displayFrame = layer->displayFrame; |
| copybit_rect_t dstRect = {displayFrame.left, displayFrame.top, |
| displayFrame.right, |
| displayFrame.bottom}; |
| |
| // Copybit dst |
| copybit_image_t dst; |
| dst.w = ALIGN(fbHandle->width,32); |
| dst.h = fbHandle->height; |
| dst.format = fbHandle->format; |
| dst.base = (void *)fbHandle->base; |
| dst.handle = (native_handle_t *)fbHandle; |
| |
| copybit_device_t *copybit = mEngine; |
| |
| int32_t screen_w = displayFrame.right - displayFrame.left; |
| int32_t screen_h = displayFrame.bottom - displayFrame.top; |
| int32_t src_crop_width = sourceCrop.right - sourceCrop.left; |
| int32_t src_crop_height = sourceCrop.bottom -sourceCrop.top; |
| |
| // Copybit dst |
| float copybitsMaxScale = |
| (float)copybit->get(copybit,COPYBIT_MAGNIFICATION_LIMIT); |
| float copybitsMinScale = |
| (float)copybit->get(copybit,COPYBIT_MINIFICATION_LIMIT); |
| |
| if((layer->transform == HWC_TRANSFORM_ROT_90) || |
| (layer->transform == HWC_TRANSFORM_ROT_270)) { |
| //swap screen width and height |
| int tmp = screen_w; |
| screen_w = screen_h; |
| screen_h = tmp; |
| } |
| private_handle_t *tmpHnd = NULL; |
| |
| if(screen_w <=0 || screen_h<=0 ||src_crop_width<=0 || src_crop_height<=0 ) { |
| ALOGE("%s: wrong params for display screen_w=%d src_crop_width=%d \ |
| screen_w=%d src_crop_width=%d", __FUNCTION__, screen_w, |
| src_crop_width,screen_w,src_crop_width); |
| return -1; |
| } |
| |
| float dsdx = (float)screen_w/src_crop_width; |
| float dtdy = (float)screen_h/src_crop_height; |
| |
| float scaleLimitMax = copybitsMaxScale * copybitsMaxScale; |
| float scaleLimitMin = copybitsMinScale * copybitsMinScale; |
| if(dsdx > scaleLimitMax || |
| dtdy > scaleLimitMax || |
| dsdx < 1/scaleLimitMin || |
| dtdy < 1/scaleLimitMin) { |
| ALOGE("%s: greater than max supported size dsdx=%f dtdy=%f \ |
| scaleLimitMax=%f scaleLimitMin=%f", __FUNCTION__,dsdx,dtdy, |
| scaleLimitMax,1/scaleLimitMin); |
| return -1; |
| } |
| if(dsdx > copybitsMaxScale || |
| dtdy > copybitsMaxScale || |
| dsdx < 1/copybitsMinScale || |
| dtdy < 1/copybitsMinScale){ |
| // The requested scale is out of the range the hardware |
| // can support. |
| ALOGE("%s:%d::Need to scale twice dsdx=%f, dtdy=%f,copybitsMaxScale=%f,\ |
| copybitsMinScale=%f,screen_w=%d,screen_h=%d \ |
| src_crop_width=%d src_crop_height=%d",__FUNCTION__,__LINE__, |
| dsdx,dtdy,copybitsMaxScale,1/copybitsMinScale,screen_w,screen_h, |
| src_crop_width,src_crop_height); |
| |
| //Driver makes width and height as even |
| //that may cause wrong calculation of the ratio |
| //in display and crop.Hence we make |
| //crop width and height as even. |
| src_crop_width = (src_crop_width/2)*2; |
| src_crop_height = (src_crop_height/2)*2; |
| |
| int tmp_w = src_crop_width; |
| int tmp_h = src_crop_height; |
| |
| if (dsdx > copybitsMaxScale || dtdy > copybitsMaxScale ){ |
| tmp_w = src_crop_width*copybitsMaxScale; |
| tmp_h = src_crop_height*copybitsMaxScale; |
| }else if (dsdx < 1/copybitsMinScale ||dtdy < 1/copybitsMinScale ){ |
| tmp_w = src_crop_width/copybitsMinScale; |
| tmp_h = src_crop_height/copybitsMinScale; |
| tmp_w = (tmp_w/2)*2; |
| tmp_h = (tmp_h/2)*2; |
| } |
| ALOGE("%s:%d::tmp_w = %d,tmp_h = %d",__FUNCTION__,__LINE__,tmp_w,tmp_h); |
| |
| int usage = GRALLOC_USAGE_PRIVATE_MM_HEAP; |
| |
| if (0 == alloc_buffer(&tmpHnd, tmp_w, tmp_h, fbHandle->format, usage)){ |
| copybit_image_t tmp_dst; |
| copybit_rect_t tmp_rect; |
| tmp_dst.w = tmp_w; |
| tmp_dst.h = tmp_h; |
| tmp_dst.format = tmpHnd->format; |
| tmp_dst.handle = tmpHnd; |
| tmp_dst.horiz_padding = src.horiz_padding; |
| tmp_dst.vert_padding = src.vert_padding; |
| tmp_rect.l = 0; |
| tmp_rect.t = 0; |
| tmp_rect.r = tmp_dst.w; |
| tmp_rect.b = tmp_dst.h; |
| //create one clip region |
| hwc_rect tmp_hwc_rect = {0,0,tmp_rect.r,tmp_rect.b}; |
| hwc_region_t tmp_hwc_reg = {1,(hwc_rect_t const*)&tmp_hwc_rect}; |
| region_iterator tmp_it(tmp_hwc_reg); |
| copybit->set_parameter(copybit,COPYBIT_TRANSFORM,0); |
| //TODO: once, we are able to read layer alpha, update this |
| copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); |
| err = copybit->stretch(copybit,&tmp_dst, &src, &tmp_rect, |
| &srcRect, &tmp_it); |
| if(err < 0){ |
| ALOGE("%s:%d::tmp copybit stretch failed",__FUNCTION__, |
| __LINE__); |
| if(tmpHnd) |
| free_buffer(tmpHnd); |
| return err; |
| } |
| // copy new src and src rect crop |
| src = tmp_dst; |
| srcRect = tmp_rect; |
| } |
| } |
| // Copybit region |
| hwc_region_t region = layer->visibleRegionScreen; |
| region_iterator copybitRegion(region); |
| |
| copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_WIDTH, |
| renderBuffer->width); |
| copybit->set_parameter(copybit, COPYBIT_FRAMEBUFFER_HEIGHT, |
| renderBuffer->height); |
| copybit->set_parameter(copybit, COPYBIT_TRANSFORM, |
| layer->transform); |
| //TODO: once, we are able to read layer alpha, update this |
| copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); |
| copybit->set_parameter(copybit, COPYBIT_BLEND_MODE, |
| layer->blending); |
| copybit->set_parameter(copybit, COPYBIT_DITHER, |
| (dst.format == HAL_PIXEL_FORMAT_RGB_565)? |
| COPYBIT_ENABLE : COPYBIT_DISABLE); |
| copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER, |
| COPYBIT_ENABLE); |
| err = copybit->stretch(copybit, &dst, &src, &dstRect, &srcRect, |
| ©bitRegion); |
| copybit->set_parameter(copybit, COPYBIT_BLIT_TO_FRAMEBUFFER, |
| COPYBIT_DISABLE); |
| |
| if(tmpHnd) |
| free_buffer(tmpHnd); |
| |
| if(err < 0) |
| ALOGE("%s: copybit stretch failed",__FUNCTION__); |
| return err; |
| } |
| |
| void CopyBit::getLayerResolution(const hwc_layer_1_t* layer, |
| unsigned int& width, unsigned int& height) |
| { |
| hwc_rect_t displayFrame = layer->displayFrame; |
| |
| width = displayFrame.right - displayFrame.left; |
| height = displayFrame.bottom - displayFrame.top; |
| } |
| |
| bool CopyBit::validateParams(hwc_context_t *ctx, |
| const hwc_display_contents_1_t *list) { |
| //Validate parameters |
| if (!ctx) { |
| ALOGE("%s:Invalid HWC context", __FUNCTION__); |
| return false; |
| } else if (!list) { |
| ALOGE("%s:Invalid HWC layer list", __FUNCTION__); |
| return false; |
| } |
| return true; |
| } |
| |
| |
| struct copybit_device_t* CopyBit::getCopyBitDevice() { |
| return mEngine; |
| } |
| |
| CopyBit::CopyBit():mIsModeOn(false), mCopyBitDraw(false){ |
| hw_module_t const *module; |
| if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) { |
| if(copybit_open(module, &mEngine) < 0) { |
| ALOGE("FATAL ERROR: copybit open failed."); |
| } |
| } else { |
| ALOGE("FATAL ERROR: copybit hw module not found"); |
| } |
| } |
| |
| CopyBit::~CopyBit() |
| { |
| if(mEngine) |
| { |
| copybit_close(mEngine); |
| mEngine = NULL; |
| } |
| } |
| }; //namespace qhwc |