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_DYN) { int fbWidth = ctx->dpyAttr[dpy].xres; int fbHeight = ctx->dpyAttr[dpy].yres; if (ctx->mFBUpdate[dpy]->getZorder() == 0) { hwc_rect_t region; getNonWormholeRegion(list, region); if ((region.left != 0) || (region.right != fbWidth) || (region.top != 0) || (region.bottom != fbHeight)) return true; } // DYN Composition: // use copybit, if (TotalRGBRenderArea < threashold * FB Area) // this is done based on perf inputs in ICS // TODO: Above condition needs to be re-evaluated in JB unsigned int fbArea = (fbWidth * fbHeight); unsigned int renderArea = getRGBRenderingArea(list); ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u", __FUNCTION__, renderArea, fbArea); if (renderArea < (mDynThreshold * 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; }
// Configure bool FBUpdateHighRes::configure(hwc_context_t *ctx, hwc_display_contents_1 *list, int fbZorder) { bool ret = false; hwc_layer_1_t *layer = &list->hwLayers[list->numHwLayers - 1]; if (LIKELY(ctx->mOverlay)) { int extOnlyLayerIndex = ctx->listStats[mDpy].extOnlyLayerIndex; // ext only layer present.. if(extOnlyLayerIndex != -1) { layer = &list->hwLayers[extOnlyLayerIndex]; layer->compositionType = HWC_OVERLAY; } overlay::Overlay& ov = *(ctx->mOverlay); ovutils::Whf info(mAlignedFBWidth, mAlignedFBHeight, ovutils::getMdpFormat(HAL_PIXEL_FORMAT_RGBA_8888)); //Request left pipe ovutils::eDest destL = getPipeForFb(ctx, mDpy); if(destL == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure fb for dpy %d's left" " mixer", __FUNCTION__, mDpy); return false; } //Request right pipe ovutils::eDest destR = getPipeForFb(ctx, mDpy); if(destR == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure fb for dpy %d's right" " mixer", __FUNCTION__, mDpy); return false; } mDestLeft = destL; mDestRight = destR; ovutils::eMdpFlags mdpFlagsL = ovutils::OV_MDP_BLEND_FG_PREMULT; ovutils::eZorder zOrder = static_cast<ovutils::eZorder>(fbZorder); //XXX: FB layer plane alpha is currently sent as zero from //surfaceflinger ovutils::PipeArgs pargL(mdpFlagsL, info, zOrder, ovutils::IS_FG_OFF, ovutils::ROT_FLAGS_NONE, ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ov.setSource(pargL, destL); ovutils::eMdpFlags mdpFlagsR = mdpFlagsL; ovutils::setMdpFlags(mdpFlagsR, ovutils::OV_MDSS_MDP_RIGHT_MIXER); ovutils::PipeArgs pargR(mdpFlagsR, info, zOrder, ovutils::IS_FG_OFF, ovutils::ROT_FLAGS_NONE, ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ov.setSource(pargR, destR); hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); hwc_rect_t displayFrame = layer->displayFrame; // Do not use getNonWormholeRegion() function to calculate the // sourceCrop during animation on external display. if(ctx->listStats[mDpy].isDisplayAnimating && mDpy) { sourceCrop = layer->displayFrame; displayFrame = sourceCrop; } else if(extOnlyLayerIndex == -1) { getNonWormholeRegion(list, sourceCrop); displayFrame = sourceCrop; } ovutils::Dim dcropL(sourceCrop.left, sourceCrop.top, (sourceCrop.right - sourceCrop.left) / 2, sourceCrop.bottom - sourceCrop.top); ovutils::Dim dcropR( sourceCrop.left + (sourceCrop.right - sourceCrop.left) / 2, sourceCrop.top, (sourceCrop.right - sourceCrop.left) / 2, sourceCrop.bottom - sourceCrop.top); ov.setCrop(dcropL, destL); ov.setCrop(dcropR, destR); int transform = layer->transform; ovutils::eTransform orient = static_cast<ovutils::eTransform>(transform); ov.setTransform(orient, destL); ov.setTransform(orient, destR); //For FB left, top will always be 0 //That should also be the case if using 2 mixers for single display ovutils::Dim dposL(displayFrame.left, displayFrame.top, (displayFrame.right - displayFrame.left) / 2, displayFrame.bottom - displayFrame.top); ov.setPosition(dposL, destL); ovutils::Dim dposR(0, displayFrame.top, (displayFrame.right - displayFrame.left) / 2, displayFrame.bottom - displayFrame.top); ov.setPosition(dposR, destR); ret = true; if (!ov.commit(destL)) { ALOGE("%s: commit fails for left", __FUNCTION__); ret = false; } if (!ov.commit(destR)) { ALOGE("%s: commit fails for right", __FUNCTION__); ret = false; } if(ret == false) { ctx->mLayerRotMap[mDpy]->clear(); } } return ret; }
// Configure bool FBUpdateLowRes::configure(hwc_context_t *ctx, hwc_display_contents_1 *list, int fbZorder) { bool ret = false; hwc_layer_1_t *layer = &list->hwLayers[list->numHwLayers - 1]; if (LIKELY(ctx->mOverlay)) { int extOnlyLayerIndex = ctx->listStats[mDpy].extOnlyLayerIndex; // ext only layer present.. if(extOnlyLayerIndex != -1) { layer = &list->hwLayers[extOnlyLayerIndex]; layer->compositionType = HWC_OVERLAY; } overlay::Overlay& ov = *(ctx->mOverlay); ovutils::Whf info(mAlignedFBWidth, mAlignedFBHeight, ovutils::getMdpFormat(HAL_PIXEL_FORMAT_RGBA_8888)); //Request a fb pipe ovutils::eDest dest = getPipeForFb(ctx, mDpy); if(dest == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure fb for dpy %d", __FUNCTION__, mDpy); return false; } mDest = dest; if((mDpy && ctx->deviceOrientation) && ctx->listStats[mDpy].isDisplayAnimating) { fbZorder = 0; } ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_BLEND_FG_PREMULT; ovutils::eIsFg isFg = ovutils::IS_FG_OFF; ovutils::eZorder zOrder = static_cast<ovutils::eZorder>(fbZorder); hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); hwc_rect_t displayFrame = layer->displayFrame; int transform = layer->transform; int rotFlags = ovutils::ROT_FLAGS_NONE; ovutils::eTransform orient = static_cast<ovutils::eTransform>(transform); // use ext orientation if any int extOrient = getExtOrientation(ctx); // Do not use getNonWormholeRegion() function to calculate the // sourceCrop during animation on external display and // Dont do wormhole calculation when extorientation is set on External // Dont do wormhole calculation when extDownscale is enabled on External if(ctx->listStats[mDpy].isDisplayAnimating && mDpy) { sourceCrop = layer->displayFrame; displayFrame = sourceCrop; } else if((!mDpy || (mDpy && !extOrient && !ctx->dpyAttr[mDpy].mDownScaleMode)) && (extOnlyLayerIndex == -1)) { getNonWormholeRegion(list, sourceCrop); displayFrame = sourceCrop; } calcExtDisplayPosition(ctx, NULL, mDpy, sourceCrop, displayFrame, transform, orient); //Store the displayFrame, will be used in getDisplayViewFrame ctx->dpyAttr[mDpy].mDstRect = displayFrame; setMdpFlags(layer, mdpFlags, 0, transform); // For External use rotator if there is a rotation value set ret = preRotateExtDisplay(ctx, layer, info, sourceCrop, mdpFlags, rotFlags); if(!ret) { ALOGE("%s: preRotate for external Failed!", __FUNCTION__); ctx->mOverlay->clear(mDpy); ctx->mLayerRotMap[mDpy]->clear(); return false; } //For the mdp, since either we are pre-rotating or MDP does flips orient = ovutils::OVERLAY_TRANSFORM_0; transform = 0; //XXX: FB layer plane alpha is currently sent as zero from //surfaceflinger ovutils::PipeArgs parg(mdpFlags, info, zOrder, isFg, static_cast<ovutils::eRotFlags>(rotFlags), ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ret = true; if(configMdp(ctx->mOverlay, parg, orient, sourceCrop, displayFrame, NULL, mDest) < 0) { ALOGE("%s: configMdp failed for dpy %d", __FUNCTION__, mDpy); ctx->mLayerRotMap[mDpy]->clear(); ret = false; } } return ret; }
// Configure bool FBUpdateNonSplit::configure(hwc_context_t *ctx, hwc_display_contents_1 *list, hwc_rect_t fbUpdatingRect, int fbZorder) { bool ret = false; hwc_layer_1_t *layer = &list->hwLayers[list->numHwLayers - 1]; if (LIKELY(ctx->mOverlay)) { int extOnlyLayerIndex = ctx->listStats[mDpy].extOnlyLayerIndex; // ext only layer present.. if(extOnlyLayerIndex != -1) { layer = &list->hwLayers[extOnlyLayerIndex]; layer->compositionType = HWC_OVERLAY; } overlay::Overlay& ov = *(ctx->mOverlay); ovutils::Whf info(mAlignedFBWidth, mAlignedFBHeight, ovutils::getMdpFormat(HAL_PIXEL_FORMAT_RGBA_8888, mTileEnabled)); Overlay::PipeSpecs pipeSpecs; pipeSpecs.formatClass = Overlay::FORMAT_RGB; pipeSpecs.needsScaling = qhwc::needsScaling(layer); pipeSpecs.dpy = mDpy; pipeSpecs.mixer = Overlay::MIXER_DEFAULT; pipeSpecs.fb = true; ovutils::eDest dest = ov.getPipe(pipeSpecs); if(dest == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure fb for dpy %d", __FUNCTION__, mDpy); return false; } mDest = dest; if((mDpy && ctx->deviceOrientation) && ctx->listStats[mDpy].isDisplayAnimating) { fbZorder = 0; } ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_BLEND_FG_PREMULT; ovutils::eIsFg isFg = ovutils::IS_FG_OFF; ovutils::eZorder zOrder = static_cast<ovutils::eZorder>(fbZorder); hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); hwc_rect_t displayFrame = layer->displayFrame; // No FB update optimization on (1) Custom FB resolution, // (2) External Mirror mode, (3) External orientation if(!ctx->dpyAttr[mDpy].customFBSize && !ctx->mBufferMirrorMode && !ctx->mExtOrientation) { sourceCrop = fbUpdatingRect; displayFrame = fbUpdatingRect; } int transform = layer->transform; int rotFlags = ovutils::ROT_FLAGS_NONE; ovutils::eTransform orient = static_cast<ovutils::eTransform>(transform); // use ext orientation if any int extOrient = getExtOrientation(ctx); // Do not use getNonWormholeRegion() function to calculate the // sourceCrop during animation on external display and // Dont do wormhole calculation when extorientation is set on External // Dont do wormhole calculation when extDownscale is enabled on External if(ctx->listStats[mDpy].isDisplayAnimating && mDpy) { sourceCrop = layer->displayFrame; } else if((!mDpy || (mDpy && !extOrient && !ctx->dpyAttr[mDpy].mDownScaleMode)) && (extOnlyLayerIndex == -1)) { if(ctx->mOverlay->isUIScalingOnExternalSupported() && !ctx->dpyAttr[mDpy].customFBSize) { getNonWormholeRegion(list, sourceCrop); displayFrame = sourceCrop; } } calcExtDisplayPosition(ctx, NULL, mDpy, sourceCrop, displayFrame, transform, orient); //Store the displayFrame, will be used in getDisplayViewFrame ctx->dpyAttr[mDpy].mDstRect = displayFrame; setMdpFlags(layer, mdpFlags, 0, transform); // For External use rotator if there is a rotation value set ret = preRotateExtDisplay(ctx, layer, info, sourceCrop, mdpFlags, rotFlags); if(!ret) { ALOGE("%s: preRotate for external Failed!", __FUNCTION__); return false; } //For the mdp, since either we are pre-rotating or MDP does flips orient = ovutils::OVERLAY_TRANSFORM_0; transform = 0; ovutils::PipeArgs parg(mdpFlags, info, zOrder, isFg, static_cast<ovutils::eRotFlags>(rotFlags), ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ret = true; if(configMdp(ctx->mOverlay, parg, orient, sourceCrop, displayFrame, NULL, mDest) < 0) { ALOGE("%s: configMdp failed for dpy %d", __FUNCTION__, mDpy); ret = false; } } return ret; }
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; LayerProp *layerProp = ctx->layerProp[dpy]; if(mCopyBitDraw == false) // there is no layer marked for copybit return false ; //render buffer private_handle_t *renderBuffer = getCurrentRenderBuffer(); if (!renderBuffer) { ALOGE("%s: Render buffer layer handle is NULL", __FUNCTION__); return false; } //Wait for the previous frame to complete before rendering onto it if(mRelFd[mCurRenderBufferIndex] >= 0) { sync_wait(mRelFd[mCurRenderBufferIndex], 1000); close(mRelFd[mCurRenderBufferIndex]); mRelFd[mCurRenderBufferIndex] = -1; } //Clear the visible region on the render buffer //XXX: Do this only when needed. hwc_rect_t clearRegion; getNonWormholeRegion(list, clearRegion); clear(renderBuffer, clearRegion); int renderTransform = list->hwLayers[list->numHwLayers - 1].transform; for (int i = 0; i < ctx->listStats[dpy].numAppLayers; i++) { hwc_layer_1_t *layer = &list->hwLayers[i]; if(!(layerProp[i].mFlags & HWC_COPYBIT)) { ALOGD_IF(DEBUG_COPYBIT, "%s: Not Marked for copybit", __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, renderTransform, dpy); copybitLayerCount++; if(retVal < 0) { ALOGE("%s : drawLayerUsingCopybit failed", __FUNCTION__); } } if (copybitLayerCount) { copybit_device_t *copybit = getCopyBitDevice(); // Async mode if (copybit->flush_get_fence(copybit, fd) < 0) *fd = -1; } return true; }
// Configure bool FBUpdateLowRes::configure(hwc_context_t *ctx, hwc_display_contents_1 *list, int fbZorder) { bool ret = false; hwc_layer_1_t *layer = &list->hwLayers[list->numHwLayers - 1]; if (LIKELY(ctx->mOverlay)) { int extOnlyLayerIndex = ctx->listStats[mDpy].extOnlyLayerIndex; // ext only layer present.. if(extOnlyLayerIndex != -1) { layer = &list->hwLayers[extOnlyLayerIndex]; layer->compositionType = HWC_OVERLAY; } overlay::Overlay& ov = *(ctx->mOverlay); private_handle_t *hnd = (private_handle_t *)layer->handle; ovutils::Whf info(getWidth(hnd), getHeight(hnd), ovutils::getMdpFormat(hnd->format), hnd->size); //Request an RGB pipe ovutils::eDest dest = ov.nextPipe(ovutils::OV_MDP_PIPE_ANY, mDpy); if(dest == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure framebuffer", __FUNCTION__); return false; } mDest = dest; ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_BLEND_FG_PREMULT; ovutils::eIsFg isFg = ovutils::IS_FG_OFF; ovutils::eZorder zOrder = static_cast<ovutils::eZorder>(fbZorder); hwc_rect_t sourceCrop = layer->sourceCrop; hwc_rect_t displayFrame = layer->displayFrame; int transform = layer->transform; int fbWidth = ctx->dpyAttr[mDpy].xres; int fbHeight = ctx->dpyAttr[mDpy].yres; int rotFlags = ovutils::ROT_FLAGS_NONE; ovutils::eTransform orient = static_cast<ovutils::eTransform>(transform); if(mDpy && ctx->mExtOrientation) { // If there is a external orientation set, use that transform = ctx->mExtOrientation; orient = static_cast<ovutils::eTransform >(ctx->mExtOrientation); } // Dont do wormhole calculation when extorientation is set on External if((!mDpy || (mDpy && !ctx->mExtOrientation)) && extOnlyLayerIndex == -1) { getNonWormholeRegion(list, sourceCrop); displayFrame = sourceCrop; } ovutils::Dim dpos(displayFrame.left, displayFrame.top, displayFrame.right - displayFrame.left, displayFrame.bottom - displayFrame.top); if(mDpy) { // Get Aspect Ratio for external getAspectRatioPosition(ctx, mDpy, ctx->mExtOrientation, dpos.x, dpos.y, dpos.w, dpos.h); // Calculate the actionsafe dimensions for External(dpy = 1 or 2) getActionSafePosition(ctx, mDpy, dpos.x, dpos.y, dpos.w, dpos.h); // Convert dim to hwc_rect_t displayFrame.left = dpos.x; displayFrame.top = dpos.y; displayFrame.right = dpos.w + displayFrame.left; displayFrame.bottom = dpos.h + displayFrame.top; } setMdpFlags(layer, mdpFlags, 0); // For External use rotator if there is a rotation value set if(mDpy && (ctx->mExtOrientation & HWC_TRANSFORM_ROT_90)) { mRot = ctx->mRotMgr->getNext(); if(mRot == NULL) return -1; //Configure rotator for pre-rotation if(configRotator(mRot, info, mdpFlags, orient, 0) < 0) { ALOGE("%s: configRotator Failed!", __FUNCTION__); mRot = NULL; return -1; } info.format = (mRot)->getDstFormat(); updateSource(orient, info, sourceCrop); rotFlags |= ovutils::ROT_PREROTATED; } //For the mdp, since either we are pre-rotating or MDP does flips orient = ovutils::OVERLAY_TRANSFORM_0; transform = 0; //XXX: FB layer plane alpha is currently sent as zero from //surfaceflinger ovutils::PipeArgs parg(mdpFlags, info, zOrder, isFg, static_cast<ovutils::eRotFlags>(rotFlags), ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ret = true; if(configMdp(ctx->mOverlay, parg, orient, sourceCrop, displayFrame, NULL, mDest) < 0) { ALOGE("%s: ConfigMdp failed for low res", __FUNCTION__); ret = false; } } return ret; }
// Configure bool FBUpdateHighRes::configure(hwc_context_t *ctx, hwc_display_contents_1 *list, int fbZorder) { bool ret = false; hwc_layer_1_t *layer = &list->hwLayers[list->numHwLayers - 1]; if (LIKELY(ctx->mOverlay)) { int extOnlyLayerIndex = ctx->listStats[mDpy].extOnlyLayerIndex; // ext only layer present.. if(extOnlyLayerIndex != -1) { layer = &list->hwLayers[extOnlyLayerIndex]; layer->compositionType = HWC_OVERLAY; } overlay::Overlay& ov = *(ctx->mOverlay); private_handle_t *hnd = (private_handle_t *)layer->handle; ovutils::Whf info(getWidth(hnd), getHeight(hnd), ovutils::getMdpFormat(hnd->format), hnd->size); //Request left RGB pipe ovutils::eDest destL = ov.nextPipe(ovutils::OV_MDP_PIPE_RGB, mDpy); if(destL == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure framebuffer", __FUNCTION__); return false; } //Request right RGB pipe ovutils::eDest destR = ov.nextPipe(ovutils::OV_MDP_PIPE_RGB, mDpy); if(destR == ovutils::OV_INVALID) { //None available ALOGE("%s: No pipes available to configure framebuffer", __FUNCTION__); return false; } mDestLeft = destL; mDestRight = destR; ovutils::eMdpFlags mdpFlagsL = ovutils::OV_MDP_BLEND_FG_PREMULT; ovutils::eZorder zOrder = static_cast<ovutils::eZorder>(fbZorder); //XXX: FB layer plane alpha is currently sent as zero from //surfaceflinger ovutils::PipeArgs pargL(mdpFlagsL, info, zOrder, ovutils::IS_FG_OFF, ovutils::ROT_FLAGS_NONE, ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ov.setSource(pargL, destL); ovutils::eMdpFlags mdpFlagsR = mdpFlagsL; ovutils::setMdpFlags(mdpFlagsR, ovutils::OV_MDSS_MDP_RIGHT_MIXER); ovutils::PipeArgs pargR(mdpFlagsR, info, zOrder, ovutils::IS_FG_OFF, ovutils::ROT_FLAGS_NONE, ovutils::DEFAULT_PLANE_ALPHA, (ovutils::eBlending) getBlending(layer->blending)); ov.setSource(pargR, destR); hwc_rect_t sourceCrop = layer->sourceCrop; hwc_rect_t displayFrame = layer->displayFrame; if(extOnlyLayerIndex == -1) { getNonWormholeRegion(list, sourceCrop); displayFrame = sourceCrop; } ovutils::Dim dcropL(sourceCrop.left, sourceCrop.top, (sourceCrop.right - sourceCrop.left) / 2, sourceCrop.bottom - sourceCrop.top); ovutils::Dim dcropR( sourceCrop.left + (sourceCrop.right - sourceCrop.left) / 2, sourceCrop.top, (sourceCrop.right - sourceCrop.left) / 2, sourceCrop.bottom - sourceCrop.top); ov.setCrop(dcropL, destL); ov.setCrop(dcropR, destR); int transform = layer->transform; ovutils::eTransform orient = static_cast<ovutils::eTransform>(transform); ov.setTransform(orient, destL); ov.setTransform(orient, destR); //For FB left, top will always be 0 //That should also be the case if using 2 mixers for single display ovutils::Dim dposL(displayFrame.left, displayFrame.top, (displayFrame.right - displayFrame.left) / 2, displayFrame.bottom - displayFrame.top); ov.setPosition(dposL, destL); ovutils::Dim dposR(0, displayFrame.top, (displayFrame.right - displayFrame.left) / 2, displayFrame.bottom - displayFrame.top); ov.setPosition(dposR, destR); ret = true; if (!ov.commit(destL)) { ALOGE("%s: commit fails for left", __FUNCTION__); ret = false; } if (!ov.commit(destR)) { ALOGE("%s: commit fails for right", __FUNCTION__); ret = false; } } return ret; }