/* * 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. */ #include #include "hwc_mdpcomp.h" #include #include "hdmi.h" #include "virtual.h" #include "qdMetaData.h" #include "mdp_version.h" #include "hwc_fbupdate.h" #include "hwc_ad.h" #include #include "hwc_copybit.h" #include using namespace overlay; using namespace qdutils; using namespace overlay::utils; namespace ovutils = overlay::utils; namespace qhwc { //==============MDPComp======================================================== IdleInvalidator *MDPComp::idleInvalidator = NULL; bool MDPComp::sIdleFallBack = false; bool MDPComp::sDebugLogs = false; bool MDPComp::sEnabled = false; bool MDPComp::sEnableMixedMode = true; bool MDPComp::sEnablePartialFrameUpdate = false; int MDPComp::sMaxPipesPerMixer = MAX_PIPES_PER_MIXER; bool MDPComp::sEnable4k2kYUVSplit = false; MDPComp* MDPComp::getObject(hwc_context_t *ctx, const int& dpy) { if(isDisplaySplit(ctx, dpy)) { return new MDPCompSplit(dpy); } return new MDPCompNonSplit(dpy); } MDPComp::MDPComp(int dpy) : mDpy(dpy), mModeOn(false), mPrevModeOn(false) { }; void MDPComp::dump(android::String8& buf) { if(mCurrentFrame.layerCount > MAX_NUM_APP_LAYERS) return; dumpsys_log(buf,"HWC Map for Dpy: %s \n", (mDpy == 0) ? "\"PRIMARY\"" : (mDpy == 1) ? "\"EXTERNAL\"" : "\"VIRTUAL\""); dumpsys_log(buf,"CURR_FRAME: layerCount:%2d mdpCount:%2d " "fbCount:%2d \n", mCurrentFrame.layerCount, mCurrentFrame.mdpCount, mCurrentFrame.fbCount); dumpsys_log(buf,"needsFBRedraw:%3s pipesUsed:%2d MaxPipesPerMixer: %d \n", (mCurrentFrame.needsRedraw? "YES" : "NO"), mCurrentFrame.mdpCount, sMaxPipesPerMixer); dumpsys_log(buf," --------------------------------------------- \n"); dumpsys_log(buf," listIdx | cached? | mdpIndex | comptype | Z \n"); dumpsys_log(buf," --------------------------------------------- \n"); for(int index = 0; index < mCurrentFrame.layerCount; index++ ) dumpsys_log(buf," %7d | %7s | %8d | %9s | %2d \n", index, (mCurrentFrame.isFBComposed[index] ? "YES" : "NO"), mCurrentFrame.layerToMDP[index], (mCurrentFrame.isFBComposed[index] ? (mCurrentFrame.drop[index] ? "DROP" : (mCurrentFrame.needsRedraw ? "GLES" : "CACHE")) : "MDP"), (mCurrentFrame.isFBComposed[index] ? mCurrentFrame.fbZ : mCurrentFrame.mdpToLayer[mCurrentFrame.layerToMDP[index]].pipeInfo->zOrder)); dumpsys_log(buf,"\n"); } bool MDPComp::init(hwc_context_t *ctx) { if(!ctx) { ALOGE("%s: Invalid hwc context!!",__FUNCTION__); return false; } char property[PROPERTY_VALUE_MAX]; sEnabled = false; if((property_get("persist.hwc.mdpcomp.enable", property, NULL) > 0) && (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { sEnabled = true; } sEnableMixedMode = true; if((property_get("debug.mdpcomp.mixedmode.disable", property, NULL) > 0) && (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { sEnableMixedMode = false; } if(property_get("debug.mdpcomp.logs", property, NULL) > 0) { if(atoi(property) != 0) sDebugLogs = true; } // We read from drivers if panel supports partial updating // and we enable partial update computations if supported. // Keeping this property to disable partial update for // debugging by setting below property to 0 & only 0. property_get("persist.hwc.partialupdate", property, "-1"); if((atoi(property) != 0) && qdutils::MDPVersion::getInstance().isPartialUpdateEnabled()) { sEnablePartialFrameUpdate = true; } ALOGE_IF(isDebug(), "%s: Partial Update applicable?: %d",__FUNCTION__, sEnablePartialFrameUpdate); sMaxPipesPerMixer = MAX_PIPES_PER_MIXER; if(property_get("debug.mdpcomp.maxpermixer", property, "-1") > 0) { int val = atoi(property); if(val >= 0) sMaxPipesPerMixer = min(val, MAX_PIPES_PER_MIXER); } if(ctx->mMDP.panel != MIPI_CMD_PANEL) { // Idle invalidation is not necessary on command mode panels long idle_timeout = DEFAULT_IDLE_TIME; if(property_get("debug.mdpcomp.idletime", property, NULL) > 0) { if(atoi(property) != 0) idle_timeout = atoi(property); } //create Idle Invalidator only when not disabled through property if(idle_timeout != -1) idleInvalidator = IdleInvalidator::getInstance(); if(idleInvalidator == NULL) { ALOGE("%s: failed to instantiate idleInvalidator object", __FUNCTION__); } else { idleInvalidator->init(timeout_handler, ctx, idle_timeout); } } if((property_get("debug.mdpcomp.4k2kSplit", property, "0") > 0) && (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { sEnable4k2kYUVSplit = true; } if ((property_get("persist.hwc.ptor.enable", property, NULL) > 0) && ((!strncasecmp(property, "true", PROPERTY_VALUE_MAX )) || (!strncmp(property, "1", PROPERTY_VALUE_MAX )))) { ctx->mCopyBit[HWC_DISPLAY_PRIMARY] = new CopyBit(ctx, HWC_DISPLAY_PRIMARY); } return true; } void MDPComp::reset(hwc_context_t *ctx) { const int numLayers = ctx->listStats[mDpy].numAppLayers; mCurrentFrame.reset(numLayers); ctx->mOverlay->clear(mDpy); ctx->mLayerRotMap[mDpy]->clear(); ctx->listStats[mDpy].roi.x = 0; ctx->listStats[mDpy].roi.y = 0; ctx->listStats[mDpy].roi.w = (int)ctx->dpyAttr[mDpy].xres; ctx->listStats[mDpy].roi.h = (int)ctx->dpyAttr[mDpy].yres; memset(&mCurrentFrame.drop, 0, sizeof(mCurrentFrame.drop)); mCurrentFrame.dropCount = 0; } void MDPComp::reset() { mPrevModeOn = mModeOn; mModeOn = false; } void MDPComp::timeout_handler(void *udata) { struct hwc_context_t* ctx = (struct hwc_context_t*)(udata); bool handleTimeout = false; if(!ctx) { ALOGE("%s: received empty data in timer callback", __FUNCTION__); return; } Locker::Autolock _l(ctx->mDrawLock); /* Handle timeout event only if the previous composition on any display is MDP or MIXED*/ for(int i = 0; i < HWC_NUM_DISPLAY_TYPES; i++) { if(ctx->mMDPComp[i]) handleTimeout = ctx->mMDPComp[i]->isMDPComp() || handleTimeout; } if(!handleTimeout) { ALOGD_IF(isDebug(), "%s:Do not handle this timeout", __FUNCTION__); return; } if(!ctx->proc) { ALOGE("%s: HWC proc not registered", __FUNCTION__); return; } sIdleFallBack = true; /* Trigger SF to redraw the current frame */ ctx->proc->invalidate(ctx->proc); } void MDPComp::setMDPCompLayerFlags(hwc_context_t *ctx, hwc_display_contents_1_t* list) { LayerProp *layerProp = ctx->layerProp[mDpy]; for(int index = 0; index < ctx->listStats[mDpy].numAppLayers; index++) { hwc_layer_1_t* layer = &(list->hwLayers[index]); if(!mCurrentFrame.isFBComposed[index]) { layerProp[index].mFlags |= HWC_MDPCOMP; layer->compositionType = HWC_OVERLAY; layer->hints |= HWC_HINT_CLEAR_FB; } else { /* Drop the layer when its already present in FB OR when it lies * outside frame's ROI */ if(!mCurrentFrame.needsRedraw || mCurrentFrame.drop[index]) { layer->compositionType = HWC_OVERLAY; } } } } void MDPComp::setRedraw(hwc_context_t *ctx, hwc_display_contents_1_t* list) { mCurrentFrame.needsRedraw = false; if(!mCachedFrame.isSameFrame(mCurrentFrame, list) || (list->flags & HWC_GEOMETRY_CHANGED) || isSkipPresent(ctx, mDpy)) { mCurrentFrame.needsRedraw = true; } } MDPComp::FrameInfo::FrameInfo() { memset(&mdpToLayer, 0, sizeof(mdpToLayer)); reset(0); } void MDPComp::FrameInfo::reset(const int& numLayers) { for(int i = 0; i < MAX_PIPES_PER_MIXER; i++) { if(mdpToLayer[i].pipeInfo) { delete mdpToLayer[i].pipeInfo; mdpToLayer[i].pipeInfo = NULL; //We dont own the rotator mdpToLayer[i].rot = NULL; } } memset(&mdpToLayer, 0, sizeof(mdpToLayer)); memset(&layerToMDP, -1, sizeof(layerToMDP)); memset(&isFBComposed, 1, sizeof(isFBComposed)); layerCount = numLayers; fbCount = numLayers; mdpCount = 0; needsRedraw = true; fbZ = -1; } void MDPComp::FrameInfo::map() { // populate layer and MDP maps int mdpIdx = 0; for(int idx = 0; idx < layerCount; idx++) { if(!isFBComposed[idx]) { mdpToLayer[mdpIdx].listIndex = idx; layerToMDP[idx] = mdpIdx++; } } } MDPComp::LayerCache::LayerCache() { reset(); } void MDPComp::LayerCache::reset() { memset(&isFBComposed, true, sizeof(isFBComposed)); memset(&drop, false, sizeof(drop)); layerCount = 0; } void MDPComp::LayerCache::updateCounts(const FrameInfo& curFrame) { layerCount = curFrame.layerCount; memcpy(&isFBComposed, &curFrame.isFBComposed, sizeof(isFBComposed)); memcpy(&drop, &curFrame.drop, sizeof(drop)); } bool MDPComp::LayerCache::isSameFrame(const FrameInfo& curFrame, hwc_display_contents_1_t* list) { if(layerCount != curFrame.layerCount) return false; for(int i = 0; i < curFrame.layerCount; i++) { if((curFrame.isFBComposed[i] != isFBComposed[i]) || (curFrame.drop[i] != drop[i])) { return false; } hwc_layer_1_t const* layer = &list->hwLayers[i]; if(curFrame.isFBComposed[i] && layerUpdating(layer)) { return false; } } return true; } bool MDPComp::LayerCache::isSameFrame(hwc_context_t *ctx, int dpy, hwc_display_contents_1_t* list) { if(layerCount != ctx->listStats[dpy].numAppLayers) return false; if((list->flags & HWC_GEOMETRY_CHANGED) || isSkipPresent(ctx, dpy)) { return false; } for(int i = 0; i < layerCount; i++) { hwc_layer_1_t const* layer = &list->hwLayers[i]; if(layerUpdating(layer)) return false; } return true; } bool MDPComp::isSupportedForMDPComp(hwc_context_t *ctx, hwc_layer_1_t* layer) { private_handle_t *hnd = (private_handle_t *)layer->handle; if((not isYuvBuffer(hnd) and has90Transform(layer)) or (not isValidDimension(ctx,layer)) || isSkipLayer(layer)) { //More conditions here, sRGB+Blend etc return false; } return true; } bool MDPComp::isValidDimension(hwc_context_t *ctx, hwc_layer_1_t *layer) { const int dpy = HWC_DISPLAY_PRIMARY; private_handle_t *hnd = (private_handle_t *)layer->handle; if(!hnd) { if (layer->flags & HWC_COLOR_FILL) { // Color layer return true; } ALOGD_IF(isDebug(), "%s: layer handle is NULL", __FUNCTION__); return false; } //XXX: Investigate doing this with pixel phase on MDSS if(!isSecureBuffer(hnd) && isNonIntegralSourceCrop(layer->sourceCropf)) return false; int hw_w = ctx->dpyAttr[mDpy].xres; int hw_h = ctx->dpyAttr[mDpy].yres; hwc_rect_t crop = integerizeSourceCrop(layer->sourceCropf); hwc_rect_t dst = layer->displayFrame; int crop_w = crop.right - crop.left; int crop_h = crop.bottom - crop.top; int dst_w = dst.right - dst.left; int dst_h = dst.bottom - dst.top; float w_dscale = ceilf((float)crop_w / (float)dst_w); float h_dscale = ceilf((float)crop_h / (float)dst_h); /* Workaround for MDP HW limitation in DSI command mode panels where * FPS will not go beyond 30 if buffers on RGB pipes are of width or height * less than 5 pixels * There also is a HW limilation in MDP, minimum block size is 2x2 * Fallback to GPU if height is less than 2. */ if((crop_w < 5)||(crop_h < 5)) return false; if((w_dscale > 1.0f) || (h_dscale > 1.0f)) { const uint32_t downscale = qdutils::MDPVersion::getInstance().getMaxMDPDownscale(); if(ctx->mMDP.version >= qdutils::MDSS_V5) { /* Workaround for downscales larger than 4x. * Will be removed once decimator block is enabled for MDSS */ if(!qdutils::MDPVersion::getInstance().supportsDecimation()) { if(crop_w > MAX_DISPLAY_DIM || w_dscale > downscale || h_dscale > downscale) return false; } else { if(w_dscale > 64 || h_dscale > 64) return false; } } else { //A-family if(w_dscale > downscale || h_dscale > downscale) return false; } } return true; } ovutils::eDest MDPComp::getMdpPipe(hwc_context_t *ctx, ePipeType type, int mixer) { overlay::Overlay& ov = *ctx->mOverlay; ovutils::eDest mdp_pipe = ovutils::OV_INVALID; switch(type) { case MDPCOMP_OV_DMA: mdp_pipe = ov.nextPipe(ovutils::OV_MDP_PIPE_DMA, mDpy, mixer, Overlay::FORMAT_RGB); if(mdp_pipe != ovutils::OV_INVALID) { return mdp_pipe; } case MDPCOMP_OV_ANY: case MDPCOMP_OV_RGB: mdp_pipe = ov.nextPipe(ovutils::OV_MDP_PIPE_RGB, mDpy, mixer, Overlay::FORMAT_RGB); if(mdp_pipe != ovutils::OV_INVALID) { return mdp_pipe; } if(type == MDPCOMP_OV_RGB) { //Requested only for RGB pipe break; } case MDPCOMP_OV_VG: return ov.nextPipe(ovutils::OV_MDP_PIPE_VG, mDpy, mixer, Overlay::FORMAT_YUV); default: ALOGE("%s: Invalid pipe type",__FUNCTION__); return ovutils::OV_INVALID; }; return ovutils::OV_INVALID; } bool MDPComp::isFrameDoable(hwc_context_t *ctx) { bool ret = true; const int numAppLayers = ctx->listStats[mDpy].numAppLayers; if(!isEnabled()) { ALOGD_IF(isDebug(),"%s: MDP Comp. not enabled.", __FUNCTION__); ret = false; } else if(qdutils::MDPVersion::getInstance().is8x26() && ctx->mVideoTransFlag && isSecondaryConnected(ctx)) { //1 Padding round to shift pipes across mixers ALOGD_IF(isDebug(),"%s: MDP Comp. video transition padding round", __FUNCTION__); ret = false; } else if(qdutils::MDPVersion::getInstance().is8x26() && !mDpy && isSecondaryAnimating(ctx) && (isYuvPresent(ctx,HWC_DISPLAY_EXTERNAL) || isYuvPresent(ctx,HWC_DISPLAY_VIRTUAL))) { ALOGD_IF(isDebug(),"%s: Display animation in progress", __FUNCTION__); ret = false; } else if(isSecondaryConfiguring(ctx)) { ALOGD_IF( isDebug(),"%s: External Display connection is pending", __FUNCTION__); ret = false; } else if(ctx->isPaddingRound) { ALOGD_IF(isDebug(), "%s: padding round invoked for dpy %d", __FUNCTION__,mDpy); ret = false; } return ret; } /* * 1) Identify layers that are not visible in the updating ROI and drop them * from composition. * 2) If we have a scaling layers which needs cropping against generated ROI. * Reset ROI to full resolution. */ bool MDPComp::validateAndApplyROI(hwc_context_t *ctx, hwc_display_contents_1_t* list, hwc_rect_t roi) { int numAppLayers = ctx->listStats[mDpy].numAppLayers; if(!isValidRect(roi)) return false; hwc_rect_t visibleRect = roi; for(int i = numAppLayers - 1; i >= 0; i--){ if(!isValidRect(visibleRect)) { mCurrentFrame.drop[i] = true; mCurrentFrame.dropCount++; continue; } const hwc_layer_1_t* layer = &list->hwLayers[i]; hwc_rect_t dstRect = layer->displayFrame; hwc_rect_t srcRect = integerizeSourceCrop(layer->sourceCropf); int transform = layer->transform; hwc_rect_t res = getIntersection(visibleRect, dstRect); int res_w = res.right - res.left; int res_h = res.bottom - res.top; int dst_w = dstRect.right - dstRect.left; int dst_h = dstRect.bottom - dstRect.top; if(!isValidRect(res)) { mCurrentFrame.drop[i] = true; mCurrentFrame.dropCount++; }else { /* Reset frame ROI when any layer which needs scaling also needs ROI * cropping */ if((res_w != dst_w || res_h != dst_h) && needsScaling (layer)) { ALOGI("%s: Resetting ROI due to scaling", __FUNCTION__); memset(&mCurrentFrame.drop, 0, sizeof(mCurrentFrame.drop)); mCurrentFrame.dropCount = 0; return false; } /* deduct any opaque region from visibleRect */ if (layer->blending == HWC_BLENDING_NONE && layer->planeAlpha == 0xFF) visibleRect = deductRect(visibleRect, res); } } return true; } bool MDPComp::canDoPartialUpdate(hwc_context_t *ctx, hwc_display_contents_1_t* list){ if(!qdutils::MDPVersion::getInstance().isPartialUpdateEnabled() || mDpy || isSkipPresent(ctx, mDpy) || (list->flags & HWC_GEOMETRY_CHANGED)|| isDisplaySplit(ctx, mDpy)) { return false; } if(ctx->listStats[mDpy].secureUI) return false; return true; } /* Calculate ROI for the frame by accounting all the layer's dispalyFrame which * are updating. If DirtyRegion is applicable, calculate it by accounting all * the changing layer's dirtyRegion. */ void MDPComp::generateROI(hwc_context_t *ctx, hwc_display_contents_1_t* list) { int numAppLayers = ctx->listStats[mDpy].numAppLayers; if(!canDoPartialUpdate(ctx, list)) return; struct hwc_rect roi = (struct hwc_rect){0, 0, 0, 0}; hwc_rect fullFrame = (struct hwc_rect) {0, 0,(int)ctx->dpyAttr[mDpy].xres, (int)ctx->dpyAttr[mDpy].yres}; for(int index = 0; index < numAppLayers; index++ ) { hwc_layer_1_t* layer = &list->hwLayers[index]; if (layerUpdating(layer) || isYuvBuffer((private_handle_t *)layer->handle)) { hwc_rect_t updatingRect = layer->displayFrame; if(!needsScaling(layer) && !layer->transform && (!isYuvBuffer((private_handle_t *)layer->handle))) { updatingRect = calculateDirtyRect(layer, fullFrame); } roi = getUnion(roi, updatingRect); } } // Align ROI coordinates to panel restrictions roi = sanitizeROI(roi, fullFrame); if(!validateAndApplyROI(ctx, list, roi)) roi = fullFrame; ctx->listStats[mDpy].roi.x = roi.left; ctx->listStats[mDpy].roi.y = roi.top; ctx->listStats[mDpy].roi.w = roi.right - roi.left; ctx->listStats[mDpy].roi.h = roi.bottom - roi.top; ALOGD_IF(isDebug(),"%s: generated ROI: [%d, %d, %d, %d]", __FUNCTION__, roi.left, roi.top, roi.right, roi.bottom); } /* Checks for conditions where all the layers marked for MDP comp cannot be * bypassed. On such conditions we try to bypass atleast YUV layers */ bool MDPComp::tryFullFrame(hwc_context_t *ctx, hwc_display_contents_1_t* list){ const int numAppLayers = ctx->listStats[mDpy].numAppLayers; if(sIdleFallBack && !ctx->listStats[mDpy].secureUI) { ALOGD_IF(isDebug(), "%s: Idle fallback dpy %d",__FUNCTION__, mDpy); return false; } if(!mDpy && isSecondaryAnimating(ctx) && (isYuvPresent(ctx,HWC_DISPLAY_EXTERNAL) || isYuvPresent(ctx,HWC_DISPLAY_VIRTUAL)) ) { ALOGD_IF(isDebug(),"%s: Display animation in progress", __FUNCTION__); return false; } // check for action safe flag and downscale mode which requires scaling. if(ctx->dpyAttr[mDpy].mActionSafePresent || ctx->dpyAttr[mDpy].mDownScaleMode) { ALOGD_IF(isDebug(), "%s: Scaling needed for this frame",__FUNCTION__); return false; } for(int i = 0; i < numAppLayers; ++i) { hwc_layer_1_t* layer = &list->hwLayers[i]; private_handle_t *hnd = (private_handle_t *)layer->handle; if(isYuvBuffer(hnd) && has90Transform(layer)) { if(!canUseRotator(ctx, mDpy)) { ALOGD_IF(isDebug(), "%s: Can't use rotator for dpy %d", __FUNCTION__, mDpy); return false; } } //For 8x26 with panel width>1k, if RGB layer needs HFLIP fail mdp comp // may not need it if Gfx pre-rotation can handle all flips & rotations int transform = (layer->flags & HWC_COLOR_FILL) ? 0 : layer->transform; if(qdutils::MDPVersion::getInstance().is8x26() && (ctx->dpyAttr[mDpy].xres > 1024) && (transform & HWC_TRANSFORM_FLIP_H) && (!isYuvBuffer(hnd))) return false; } if(ctx->mAD->isDoable()) { return false; } //If all above hard conditions are met we can do full or partial MDP comp. bool ret = false; if(fullMDPComp(ctx, list)) { ret = true; } else if(fullMDPCompWithPTOR(ctx, list)) { ret = true; } else if(partialMDPComp(ctx, list)) { ret = true; } return ret; } bool MDPComp::fullMDPComp(hwc_context_t *ctx, hwc_display_contents_1_t* list) { //Will benefit presentation / secondary-only layer. if((mDpy > HWC_DISPLAY_PRIMARY) && (list->numHwLayers - 1) > MAX_SEC_LAYERS) { ALOGD_IF(isDebug(), "%s: Exceeds max secondary pipes",__FUNCTION__); return false; } const int numAppLayers = ctx->listStats[mDpy].numAppLayers; for(int i = 0; i < numAppLayers; i++) { hwc_layer_1_t* layer = &list->hwLayers[i]; if(not isSupportedForMDPComp(ctx, layer)) { ALOGD_IF(isDebug(), "%s: Unsupported layer in list",__FUNCTION__); return false; } } mCurrentFrame.fbCount = 0; memcpy(&mCurrentFrame.isFBComposed, &mCurrentFrame.drop, sizeof(mCurrentFrame.isFBComposed)); mCurrentFrame.mdpCount = mCurrentFrame.layerCount - mCurrentFrame.fbCount - mCurrentFrame.dropCount; if(sEnable4k2kYUVSplit){ adjustForSourceSplit(ctx, list); } if(!postHeuristicsHandling(ctx, list)) { ALOGD_IF(isDebug(), "post heuristic handling failed"); reset(ctx); return false; } return true; } /* Full MDP Composition with Peripheral Tiny Overlap Removal. * MDP bandwidth limitations can be avoided, if the overlap region * covered by the smallest layer at a higher z-order, gets composed * by Copybit on a render buffer, which can be queued to MDP. */ bool MDPComp::fullMDPCompWithPTOR(hwc_context_t *ctx, hwc_display_contents_1_t* list) { const int numAppLayers = ctx->listStats[mDpy].numAppLayers; const int stagesForMDP = min(sMaxPipesPerMixer, ctx->mOverlay->availablePipes(mDpy, Overlay::MIXER_DEFAULT)); // Hard checks where we cannot use this mode if (mDpy || !ctx->mCopyBit[mDpy] || !ctx->mIsPTOREnabled) { ALOGD_IF(isDebug(), "%s: Feature not supported!", __FUNCTION__); return false; } // Frame level checks if ((numAppLayers > stagesForMDP) || isSkipPresent(ctx, mDpy) || isYuvPresent(ctx, mDpy) || mCurrentFrame.dropCount || isSecurePresent(ctx, mDpy)) { ALOGD_IF(isDebug(), "%s: Frame not supported!", __FUNCTION__); return false; } // MDP comp checks for(int i = 0; i < numAppLayers; i++) { hwc_layer_1_t* layer = &list->hwLayers[i]; if(not isSupportedForMDPComp(ctx, layer)) { ALOGD_IF(isDebug(), "%s: Unsupported layer in list",__FUNCTION__); return false; } } /* We cannot use this composition mode, if: 1. A below layer needs scaling. 2. Overlap is not peripheral to display. 3. Overlap or a below layer has 90 degree transform. 4. Overlap area > (1/3 * FrameBuffer) area, based on Perf inputs. */ int minLayerIndex[MAX_PTOR_LAYERS] = { -1, -1}; hwc_rect_t overlapRect[MAX_PTOR_LAYERS]; memset(overlapRect, 0, sizeof(overlapRect)); int layerPixelCount, minPixelCount = 0; int numPTORLayersFound = 0; for (int i = numAppLayers-1; (i >= 0 && numPTORLayersFound < MAX_PTOR_LAYERS); i--) { hwc_layer_1_t* layer = &list->hwLayers[i]; hwc_rect_t crop = integerizeSourceCrop(layer->sourceCropf); hwc_rect_t dispFrame = layer->displayFrame; layerPixelCount = (crop.right - crop.left) * (crop.bottom - crop.top); // PTOR layer should be peripheral and cannot have transform if (!isPeripheral(dispFrame, ctx->mViewFrame[mDpy]) || has90Transform(layer)) { continue; } if((3 * (layerPixelCount + minPixelCount)) > ((int)ctx->dpyAttr[mDpy].xres * (int)ctx->dpyAttr[mDpy].yres)) { // Overlap area > (1/3 * FrameBuffer) area, based on Perf inputs. continue; } bool found = false; for (int j = i-1; j >= 0; j--) { // Check if the layers below this layer qualifies for PTOR comp hwc_layer_1_t* layer = &list->hwLayers[j]; hwc_rect_t disFrame = layer->displayFrame; // Layer below PTOR is intersecting and has 90 degree transform or // needs scaling cannot be supported. if (isValidRect(getIntersection(dispFrame, disFrame))) { if (has90Transform(layer) || needsScaling(layer)) { found = false; break; } found = true; } } // Store the minLayer Index if(found) { minLayerIndex[numPTORLayersFound] = i; overlapRect[numPTORLayersFound] = list->hwLayers[i].displayFrame; minPixelCount += layerPixelCount; numPTORLayersFound++; } } // No overlap layers if (!numPTORLayersFound) return false; // Store the displayFrame and the sourceCrops of the layers hwc_rect_t displayFrame[numAppLayers]; hwc_rect_t sourceCrop[numAppLayers]; for(int i = 0; i < numAppLayers; i++) { hwc_layer_1_t* layer = &list->hwLayers[i]; displayFrame[i] = layer->displayFrame; sourceCrop[i] = integerizeSourceCrop(layer->sourceCropf); } /** * It's possible that 2 PTOR layers might have overlapping. * In such case, remove the intersection(again if peripheral) * from the lower PTOR layer to avoid overlapping. * If intersection is not on peripheral then compromise * by reducing number of PTOR layers. **/ hwc_rect_t commonRect = getIntersection(overlapRect[0], overlapRect[1]); if(isValidRect(commonRect)) { overlapRect[1] = deductRect(overlapRect[1], commonRect); list->hwLayers[minLayerIndex[1]].displayFrame = overlapRect[1]; } ctx->mPtorInfo.count = numPTORLayersFound; for(int i = 0; i < MAX_PTOR_LAYERS; i++) { ctx->mPtorInfo.layerIndex[i] = minLayerIndex[i]; } if (!ctx->mCopyBit[mDpy]->prepareOverlap(ctx, list)) { // reset PTOR ctx->mPtorInfo.count = 0; if(isValidRect(commonRect)) { // If PTORs are intersecting restore displayframe of PTOR[1] // before returning, as we have modified it above. list->hwLayers[minLayerIndex[1]].displayFrame = displayFrame[minLayerIndex[1]]; } return false; } private_handle_t *renderBuf = ctx->mCopyBit[mDpy]->getCurrentRenderBuffer(); Vector layerWhf; // To store w,h,f of PTOR layers // Store the blending mode, planeAlpha, and transform of PTOR layers int32_t blending[numPTORLayersFound]; uint8_t planeAlpha[numPTORLayersFound]; uint32_t transform[numPTORLayersFound]; for(int j = 0; j < numPTORLayersFound; j++) { int index = ctx->mPtorInfo.layerIndex[j]; // Update src crop of PTOR layer hwc_layer_1_t* layer = &list->hwLayers[index]; layer->sourceCropf.left = (float)ctx->mPtorInfo.displayFrame[j].left; layer->sourceCropf.top = (float)ctx->mPtorInfo.displayFrame[j].top; layer->sourceCropf.right = (float)ctx->mPtorInfo.displayFrame[j].right; layer->sourceCropf.bottom =(float)ctx->mPtorInfo.displayFrame[j].bottom; // Store & update w, h, format of PTOR layer private_handle_t *hnd = (private_handle_t *)layer->handle; Whf whf(hnd->width, hnd->height, hnd->format, hnd->size); layerWhf.insertAt(whf, j); hnd->width = renderBuf->width; hnd->height = renderBuf->height; hnd->format = renderBuf->format; // Store & update blending mode, planeAlpha and transform of PTOR layer blending[j] = layer->blending; planeAlpha[j] = layer->planeAlpha; transform[j] = layer->transform; layer->blending = HWC_BLENDING_NONE; layer->planeAlpha = 0xFF; layer->transform = 0; // Remove overlap from crop & displayFrame of below layers for (int i = 0; i < index && index !=-1; i++) { layer = &list->hwLayers[i]; if(!isValidRect(getIntersection(layer->displayFrame, overlapRect[j]))) { continue; } // Update layer attributes hwc_rect_t srcCrop = integerizeSourceCrop(layer->sourceCropf); hwc_rect_t destRect = deductRect(layer->displayFrame, getIntersection(layer->displayFrame, overlapRect[j])); qhwc::calculate_crop_rects(srcCrop, layer->displayFrame, destRect, layer->transform); layer->sourceCropf.left = (float)srcCrop.left; layer->sourceCropf.top = (float)srcCrop.top; layer->sourceCropf.right = (float)srcCrop.right; layer->sourceCropf.bottom = (float)srcCrop.bottom; } } mCurrentFrame.mdpCount = numAppLayers; mCurrentFrame.fbCount = 0; mCurrentFrame.fbZ = -1; for (int j = 0; j < numAppLayers; j++) { if(isValidRect(list->hwLayers[j].displayFrame)) { mCurrentFrame.isFBComposed[j] = false; } else { mCurrentFrame.mdpCount--; mCurrentFrame.drop[j] = true; } } bool result = postHeuristicsHandling(ctx, list); // Restore layer attributes for(int i = 0; i < numAppLayers; i++) { hwc_layer_1_t* layer = &list->hwLayers[i]; layer->displayFrame = displayFrame[i]; layer->sourceCropf.left = (float)sourceCrop[i].left; layer->sourceCropf.top = (float)sourceCrop[i].top; layer->sourceCropf.right = (float)sourceCrop[i].right; layer->sourceCropf.bottom = (float)sourceCrop[i].bottom; } // Restore w,h,f, blending attributes, and transform of PTOR layers for (int i = 0; i < numPTORLayersFound; i++) { int idx = ctx->mPtorInfo.layerIndex[i]; hwc_layer_1_t* layer = &list->hwLayers[idx]; private_handle_t *hnd = (private_handle_t *)list->hwLayers[idx].handle; Whf whf = layerWhf.itemAt(i); hnd->width = whf.w; hnd->height = whf.h; hnd->format = whf.format; layer->blending = blending[i]; layer->planeAlpha = planeAlpha[i]; layer->transform = transform[i]; } if (!result) { // reset PTOR ctx->mPtorInfo.count = 0; reset(ctx); } else { ALOGD_IF(isDebug(), "%s: PTOR Indexes: %d and %d", __FUNCTION__, ctx->mPtorInfo.layerIndex[0], ctx->mPtorInfo.layerIndex[1]); } ALOGD_IF(isDebug(), "%s: Postheuristics %s!", __FUNCTION__, (result ? "successful" : "failed")); return result; } bool MDPComp::partialMDPComp(hwc_context_t *ctx, hwc_display_contents_1_t* list) { if(!sEnableMixedMode) { //Mixed mode is disabled. No need to even try caching. return false; } bool ret = false; if(isSkipPresent(ctx, mDpy) or list->flags & HWC_GEOMETRY_CHANGED) { //Try load based first ret = loadBasedComp(ctx, list) or cacheBasedComp(ctx, list); } else { ret = cacheBasedComp(ctx, list) or loadBasedComp(ctx, list); } return ret; } bool MDPComp::cacheBasedComp(hwc_context_t *ctx, hwc_display_contents_1_t* list) { int numAppLayers = ctx->listStats[mDpy].numAppLayers; mCurrentFrame.reset(numAppLayers); updateLayerCache(ctx, list, mCurrentFrame); //If an MDP marked layer is unsupported cannot do partial MDP Comp for(int i = 0; i < numAppLayers; i++) { if(!mCurrentFrame.isFBComposed[i]) { hwc_layer_1_t* layer = &list->hwLayers[i]; if(not isSupportedForMDPComp(ctx, layer)) { ALOGD_IF(isDebug(), "%s: Unsupported layer in list", __FUNCTION__); reset(ctx); return false; } } } updateYUV(ctx, list, false /*secure only*/, mCurrentFrame); bool ret = markLayersForCaching(ctx, list); //sets up fbZ also if(!ret) { ALOGD_IF(isDebug(),"%s: batching failed, dpy %d",__FUNCTION__, mDpy); reset(ctx); return false; } int mdpCount = mCurrentFrame.mdpCount; if(sEnable4k2kYUVSplit){ adjustForSourceSplit(ctx, list); } //Will benefit cases where a video has non-updating background. if((mDpy > HWC_DISPLAY_PRIMARY) and (mdpCount > MAX_SEC_LAYERS)) { ALOGD_IF(isDebug(), "%s: Exceeds max secondary pipes",__FUNCTION__); reset(ctx); return false; } if(!postHeuristicsHandling(ctx, list)) { ALOGD_IF(isDebug(), "post heuristic handling failed"); reset(ctx); return false; } return true; } bool MDPComp::loadBasedComp(hwc_context_t *ctx, hwc_display_contents_1_t* list) { if(not isLoadBasedCompDoable(ctx, list)) { return false; } const int numAppLayers = ctx->listStats[mDpy].numAppLayers; const int numNonDroppedLayers = numAppLayers - mCurrentFrame.dropCount; const int stagesForMDP = min(sMaxPipesPerMixer, ctx->mOverlay->availablePipes(mDpy, Overlay::MIXER_DEFAULT)); int mdpBatchSize = stagesForMDP - 1; //1 stage for FB int fbBatchSize = numNonDroppedLayers - mdpBatchSize; int lastMDPSupportedIndex = numAppLayers; int dropCount = 0; //Find the minimum MDP batch size for(int i = 0; i < numAppLayers;i++) { if(mCurrentFrame.drop[i]) { dropCount++; continue; } hwc_layer_1_t* layer = &list->hwLayers[i]; if(not isSupportedForMDPComp(ctx, layer)) { lastMDPSupportedIndex = i; mdpBatchSize = min(i - dropCount, stagesForMDP - 1); fbBatchSize = numNonDroppedLayers - mdpBatchSize; break; } } ALOGD_IF(isDebug(), "%s:Before optimizing fbBatch, mdpbatch %d, fbbatch %d " "dropped %d", __FUNCTION__, mdpBatchSize, fbBatchSize, mCurrentFrame.dropCount); //Start at a point where the fb batch should at least have 2 layers, for //this mode to be justified. while(fbBatchSize < 2) { ++fbBatchSize; --mdpBatchSize; } //If there are no layers for MDP, this mode doesnt make sense. if(mdpBatchSize < 1) { ALOGD_IF(isDebug(), "%s: No MDP layers after optimizing for fbBatch", __FUNCTION__); return false; } mCurrentFrame.reset(numAppLayers); //Try with successively smaller mdp batch sizes until we succeed or reach 1 while(mdpBatchSize > 0) { //Mark layers for MDP comp int mdpBatchLeft = mdpBatchSize; for(int i = 0; i < lastMDPSupportedIndex and mdpBatchLeft; i++) { if(mCurrentFrame.drop[i]) { continue; } mCurrentFrame.isFBComposed[i] = false; --mdpBatchLeft; } mCurrentFrame.fbZ = mdpBatchSize; mCurrentFrame.fbCount = fbBatchSize; mCurrentFrame.mdpCount = mdpBatchSize; ALOGD_IF(isDebug(), "%s:Trying with: mdpbatch %d fbbatch %d dropped %d", __FUNCTION__, mdpBatchSize, fbBatchSize, mCurrentFrame.dropCount); if(postHeuristicsHandling(ctx, list)) { ALOGD_IF(isDebug(), "%s: Postheuristics handling succeeded", __FUNCTION__); return true; } reset(ctx); --mdpBatchSize; ++fbBatchSize; } return false; } bool MDPComp::isLoadBasedCompDoable(hwc_context_t *ctx, hwc_display_contents_1_t* /*list*/) { if(mDpy or isSecurePresent(ctx, mDpy)) { return false; } return true; } bool MDPComp::tryVideoOnly(hwc_context_t *ctx, hwc_display_contents_1_t* list) { const bool secureOnly = true; return videoOnlyComp(ctx, list, not secureOnly) or videoOnlyComp(ctx, list, secureOnly); } bool MDPComp::videoOnlyComp(hwc_context_t *ctx, hwc_display_contents_1_t* list, bool secureOnly) { int numAppLayers = ctx->listStats[mDpy].numAppLayers; mCurrentFrame.reset(numAppLayers); updateYUV(ctx, list, secureOnly, mCurrentFrame); int mdpCount = mCurrentFrame.mdpCount; if(!isYuvPresent(ctx, mDpy) or (mdpCount == 0)) { reset(ctx); return false; } /* Bail out if we are processing only secured video layers * and we dont have any */ if(!isSecurePresent(ctx, mDpy) && secureOnly){ reset(ctx); return false; } if(mCurrentFrame.fbCount) mCurrentFrame.fbZ = mCurrentFrame.mdpCount; if(sEnable4k2kYUVSplit){ adjustForSourceSplit(ctx, list); } if(!postHeuristicsHandling(ctx, list)) { ALOGD_IF(isDebug(), "post heuristic handling failed"); if(errno == ENOBUFS) { ALOGD_IF(isDebug(), "SMP Allocation failed"); //On SMP allocation failure in video only comp add padding round ctx->isPaddingRound = true; } reset(ctx); return false; } return true; } /* Checks for conditions where YUV layers cannot be bypassed */ bool MDPComp::isYUVDoable(hwc_context_t* ctx, hwc_layer_1_t* layer) { if(isSkipLayer(layer)) { ALOGD_IF(isDebug(), "%s: Video marked SKIP dpy %d", __FUNCTION__, mDpy); return false; } if(layer->transform & HWC_TRANSFORM_ROT_90 && !canUseRotator(ctx,mDpy)) { ALOGD_IF(isDebug(), "%s: no free DMA pipe",__FUNCTION__); return false; } if(isSecuring(ctx, layer)) { ALOGD_IF(isDebug(), "%s: MDP securing is active", __FUNCTION__); return false; } if(!isValidDimension(ctx, layer)) { ALOGD_IF(isDebug(), "%s: Buffer is of invalid width", __FUNCTION__); return false; } if(layer->planeAlpha < 0xFF) { ALOGD_IF(isDebug(), "%s: Cannot handle YUV layer with plane alpha\ in video only mode", __FUNCTION__); return false; } return true; } /* starts at fromIndex and check for each layer to find * if it it has overlapping with any Updating layer above it in zorder * till the end of the batch. returns true if it finds any intersection */ bool MDPComp::canPushBatchToTop(const hwc_display_contents_1_t* list, int fromIndex, int toIndex) { for(int i = fromIndex; i < toIndex; i++) { if(mCurrentFrame.isFBComposed[i] && !mCurrentFrame.drop[i]) { if(intersectingUpdatingLayers(list, i+1, toIndex, i)) { return false; } } } return true; } /* Checks if given layer at targetLayerIndex has any * intersection with all the updating layers in beween * fromIndex and toIndex. Returns true if it finds intersectiion */ bool MDPComp::intersectingUpdatingLayers(const hwc_display_contents_1_t* list, int fromIndex, int toIndex, int targetLayerIndex) { for(int i = fromIndex; i <= toIndex; i++) { if(!mCurrentFrame.isFBComposed[i]) { if(areLayersIntersecting(&list->hwLayers[i], &list->hwLayers[targetLayerIndex])) { return true; } } } return false; } int MDPComp::getBatch(hwc_display_contents_1_t* list, int& maxBatchStart, int& maxBatchEnd, int& maxBatchCount) { int i = 0; int fbZOrder =-1; int droppedLayerCt = 0; while (i < mCurrentFrame.layerCount) { int batchCount = 0; int batchStart = i; int batchEnd = i; /* Adjust batch Z order with the dropped layers so far */ int fbZ = batchStart - droppedLayerCt; int firstZReverseIndex = -1; int updatingLayersAbove = 0;//Updating layer count in middle of batch while(i < mCurrentFrame.layerCount) { if(!mCurrentFrame.isFBComposed[i]) { if(!batchCount) { i++; break; } updatingLayersAbove++; i++; continue; } else { if(mCurrentFrame.drop[i]) { i++; droppedLayerCt++; continue; } else if(updatingLayersAbove <= 0) { batchCount++; batchEnd = i; i++; continue; } else { //Layer is FBComposed, not a drop & updatingLayer > 0 // We have a valid updating layer already. If layer-i not // have overlapping with all updating layers in between // batch-start and i, then we can add layer i to batch. if(!intersectingUpdatingLayers(list, batchStart, i-1, i)) { batchCount++; batchEnd = i; i++; continue; } else if(canPushBatchToTop(list, batchStart, i)) { //If All the non-updating layers with in this batch //does not have intersection with the updating layers //above in z-order, then we can safely move the batch to //higher z-order. Increment fbZ as it is moving up. if( firstZReverseIndex < 0) { firstZReverseIndex = i; } batchCount++; batchEnd = i; fbZ += updatingLayersAbove; i++; updatingLayersAbove = 0; continue; } else { //both failed.start the loop again from here. if(firstZReverseIndex >= 0) { i = firstZReverseIndex; } break; } } } } if(batchCount > maxBatchCount) { maxBatchCount = batchCount; maxBatchStart = batchStart; maxBatchEnd = batchEnd; fbZOrder = fbZ; } } return fbZOrder; } bool MDPComp::markLayersForCaching(hwc_context_t* ctx, hwc_display_contents_1_t* list) { /* Idea is to keep as many non-updating(cached) layers in FB and * send rest of them through MDP. This is done in 2 steps. * 1. Find the maximum contiguous batch of non-updating layers. * 2. See if we can improve this batch size for caching by adding * opaque layers around the batch, if they don't have * any overlapping with the updating layers in between. * NEVER mark an updating layer for caching. * But cached ones can be marked for MDP */ int maxBatchStart = -1; int maxBatchEnd = -1; int maxBatchCount = 0; int fbZ = -1; /* Nothing is cached. No batching needed */ if(mCurrentFrame.fbCount == 0) { return true; } /* No MDP comp layers, try to use other comp modes */ if(mCurrentFrame.mdpCount == 0) { return false; } fbZ = getBatch(list, maxBatchStart, maxBatchEnd, maxBatchCount); /* reset rest of the layers lying inside ROI for MDP comp */ for(int i = 0; i < mCurrentFrame.layerCount; i++) { hwc_layer_1_t* layer = &list->hwLayers[i]; if((i < maxBatchStart || i > maxBatchEnd) && mCurrentFrame.isFBComposed[i]){ if(!mCurrentFrame.drop[i]){ //If an unsupported layer is being attempted to //be pulled out we should fail if(not isSupportedForMDPComp(ctx, layer)) { return false; } mCurrentFrame.isFBComposed[i] = false; } } } // update the frame data mCurrentFrame.fbZ = fbZ; mCurrentFrame.fbCount = maxBatchCount; mCurrentFrame.mdpCount = mCurrentFrame.layerCount - mCurrentFrame.fbCount - mCurrentFrame.dropCount; ALOGD_IF(isDebug(),"%s: cached count: %d",__FUNCTION__, mCurrentFrame.fbCount); return true; } void MDPComp::updateLayerCache(hwc_context_t* ctx, hwc_display_contents_1_t* list, FrameInfo& frame) { int numAppLayers = ctx->listStats[mDpy].numAppLayers; int fbCount = 0; for(int i = 0; i < numAppLayers; i++) { hwc_layer_1_t * layer = &list->hwLayers[i]; if (!layerUpdating(layer)) { if(!frame.drop[i]) fbCount++; frame.isFBComposed[i] = true; } else { frame.isFBComposed[i] = false; } } frame.fbCount = fbCount; frame.mdpCount = frame.layerCount - frame.fbCount - frame.dropCount; ALOGD_IF(isDebug(),"%s: MDP count: %d FB count %d drop count: %d", __FUNCTION__, frame.mdpCount, frame.fbCount, frame.dropCount); } void MDPComp::updateYUV(hwc_context_t* ctx, hwc_display_contents_1_t* list, bool secureOnly, FrameInfo& frame) { int nYuvCount = ctx->listStats[mDpy].yuvCount; for(int index = 0;index < nYuvCount; index++){ int nYuvIndex = ctx->listStats[mDpy].yuvIndices[index]; hwc_layer_1_t* layer = &list->hwLayers[nYuvIndex]; if(!isYUVDoable(ctx, layer)) { if(!frame.isFBComposed[nYuvIndex]) { frame.isFBComposed[nYuvIndex] = true; frame.fbCount++; } } else { if(frame.isFBComposed[nYuvIndex]) { private_handle_t *hnd = (private_handle_t *)layer->handle; if(!secureOnly || isSecureBuffer(hnd)) { frame.isFBComposed[nYuvIndex] = false; frame.fbCount--; } } } } frame.mdpCount = frame.layerCount - frame.fbCount - frame.dropCount; ALOGD_IF(isDebug(),"%s: fb count: %d",__FUNCTION__, frame.fbCount); } bool MDPComp::postHeuristicsHandling(hwc_context_t *ctx, hwc_display_contents_1_t* list) { //Capability checks if(!resourceCheck(ctx, list)) { ALOGD_IF(isDebug(), "%s: resource check failed", __FUNCTION__); return false; } //Limitations checks if(!hwLimitationsCheck(ctx, list)) { ALOGD_IF(isDebug(), "%s: HW limitations",__FUNCTION__); return false; } //Configure framebuffer first if applicable if(mCurrentFrame.fbZ >= 0) { if(!ctx->mFBUpdate[mDpy]->prepare(ctx, list, mCurrentFrame.fbZ)) { ALOGD_IF(isDebug(), "%s configure framebuffer failed", __FUNCTION__); return false; } } mCurrentFrame.map(); if(!allocLayerPipes(ctx, list)) { ALOGD_IF(isDebug(), "%s: Unable to allocate MDP pipes", __FUNCTION__); return false; } for (int index = 0, mdpNextZOrder = 0; index < mCurrentFrame.layerCount; index++) { if(!mCurrentFrame.isFBComposed[index]) { int mdpIndex = mCurrentFrame.layerToMDP[index]; hwc_layer_1_t* layer = &list->hwLayers[index]; //Leave fbZ for framebuffer. CACHE/GLES layers go here. if(mdpNextZOrder == mCurrentFrame.fbZ) { mdpNextZOrder++; } MdpPipeInfo* cur_pipe = mCurrentFrame.mdpToLayer[mdpIndex].pipeInfo; cur_pipe->zOrder = mdpNextZOrder++; private_handle_t *hnd = (private_handle_t *)layer->handle; if(is4kx2kYuvBuffer(hnd) && sEnable4k2kYUVSplit){ if(configure4k2kYuv(ctx, layer, mCurrentFrame.mdpToLayer[mdpIndex]) != 0 ){ ALOGD_IF(isDebug(), "%s: Failed to configure split pipes \ for layer %d",__FUNCTION__, index); return false; } else{ mdpNextZOrder++; } continue; } if(configure(ctx, layer, mCurrentFrame.mdpToLayer[mdpIndex]) != 0 ){ ALOGD_IF(isDebug(), "%s: Failed to configure overlay for \ layer %d",__FUNCTION__, index); return false; } } } if(!ctx->mOverlay->validateAndSet(mDpy, ctx->dpyAttr[mDpy].fd)) { ALOGD_IF(isDebug(), "%s: Failed to validate and set overlay for dpy %d" ,__FUNCTION__, mDpy); return false; } setRedraw(ctx, list); return true; } bool MDPComp::resourceCheck(hwc_context_t * /*ctx*/, hwc_display_contents_1_t * /*list*/) { const bool fbUsed = mCurrentFrame.fbCount; if(mCurrentFrame.mdpCount > sMaxPipesPerMixer - fbUsed) { ALOGD_IF(isDebug(), "%s: Exceeds MAX_PIPES_PER_MIXER",__FUNCTION__); return false; } return true; } bool MDPComp::hwLimitationsCheck(hwc_context_t* ctx, hwc_display_contents_1_t* list) { //A-family hw limitation: //If a layer need alpha scaling, MDP can not support. if(ctx->mMDP.version < qdutils::MDSS_V5) { for(int i = 0; i < mCurrentFrame.layerCount; ++i) { if(!mCurrentFrame.isFBComposed[i] && isAlphaScaled( &list->hwLayers[i])) { ALOGD_IF(isDebug(), "%s:frame needs alphaScaling",__FUNCTION__); return false; } } } // On 8x26 & 8974 hw, we have a limitation of downscaling+blending. //If multiple layers requires downscaling and also they are overlapping //fall back to GPU since MDSS can not handle it. if(qdutils::MDPVersion::getInstance().is8x74v2() || qdutils::MDPVersion::getInstance().is8x26()) { for(int i = 0; i < mCurrentFrame.layerCount-1; ++i) { hwc_layer_1_t* botLayer = &list->hwLayers[i]; if(!mCurrentFrame.isFBComposed[i] && isDownscaleRequired(botLayer)) { //if layer-i is marked for MDP and needs downscaling //check if any MDP layer on top of i & overlaps with layer-i for(int j = i+1; j < mCurrentFrame.layerCount; ++j) { hwc_layer_1_t* topLayer = &list->hwLayers[j]; if(!mCurrentFrame.isFBComposed[j] && isDownscaleRequired(topLayer)) { hwc_rect_t r = getIntersection(botLayer->displayFrame, topLayer->displayFrame); if(isValidRect(r)) return false; } } } } } return true; } void MDPComp::setDynRefreshRate(hwc_context_t *ctx, hwc_display_contents_1_t* list) { //For primary display, set the dynamic refreshrate if(!mDpy && qdutils::MDPVersion::getInstance().isDynFpsSupported() && ctx->mUseMetaDataRefreshRate) { FrameInfo frame; frame.reset(mCurrentFrame.layerCount); memset(&frame.drop, 0, sizeof(frame.drop)); frame.dropCount = 0; ALOGD_IF(isDebug(), "%s: Update Cache and YUVInfo for Dyn Refresh Rate", __FUNCTION__); updateLayerCache(ctx, list, frame); updateYUV(ctx, list, false /*secure only*/, frame); uint32_t refreshRate = ctx->dpyAttr[mDpy].refreshRate; MDPVersion& mdpHw = MDPVersion::getInstance(); if(sIdleFallBack) { //Set minimum panel refresh rate during idle timeout refreshRate = mdpHw.getMinFpsSupported(); } else if((ctx->listStats[mDpy].yuvCount == frame.mdpCount) || (frame.layerCount == 1)) { //Set the new fresh rate, if there is only one updating YUV layer //or there is one single RGB layer with this request refreshRate = ctx->listStats[mDpy].refreshRateRequest; } setRefreshRate(ctx, mDpy, refreshRate); } } int MDPComp::prepare(hwc_context_t *ctx, hwc_display_contents_1_t* list) { int ret = 0; if(!ctx || !list) { ALOGE("%s: Invalid context or list",__FUNCTION__); mCachedFrame.reset(); return -1; } const int numLayers = ctx->listStats[mDpy].numAppLayers; MDPVersion& mdpVersion = qdutils::MDPVersion::getInstance(); // reset PTOR if(!mDpy) memset(&(ctx->mPtorInfo), 0, sizeof(ctx->mPtorInfo)); //reset old data mCurrentFrame.reset(numLayers); memset(&mCurrentFrame.drop, 0, sizeof(mCurrentFrame.drop)); mCurrentFrame.dropCount = 0; //Do not cache the information for next draw cycle. if(numLayers > MAX_NUM_APP_LAYERS or (!numLayers)) { ALOGI("%s: Unsupported layer count for mdp composition", __FUNCTION__); mCachedFrame.reset(); #ifdef DYNAMIC_FPS setDynRefreshRate(ctx, list); #endif return -1; } // Detect the start of animation and fall back to GPU only once to cache // all the layers in FB and display FB content untill animation completes. if(ctx->listStats[mDpy].isDisplayAnimating) { mCurrentFrame.needsRedraw = false; if(ctx->mAnimationState[mDpy] == ANIMATION_STOPPED) { mCurrentFrame.needsRedraw = true; ctx->mAnimationState[mDpy] = ANIMATION_STARTED; } setMDPCompLayerFlags(ctx, list); mCachedFrame.updateCounts(mCurrentFrame); #ifdef DYNAMIC_FPS setDynRefreshRate(ctx, list); #endif ret = -1; return ret; } else { ctx->mAnimationState[mDpy] = ANIMATION_STOPPED; } if(!mDpy and !isSecondaryConnected(ctx) and !mPrevModeOn and mCachedFrame.isSameFrame(ctx,mDpy,list)) { ALOGD_IF(isDebug(),"%s: Avoid new composition",__FUNCTION__); mCurrentFrame.needsRedraw = false; setMDPCompLayerFlags(ctx, list); mCachedFrame.updateCounts(mCurrentFrame); return -1; } //Hard conditions, if not met, cannot do MDP comp if(isFrameDoable(ctx)) { generateROI(ctx, list); mModeOn = tryFullFrame(ctx, list) || tryVideoOnly(ctx, list); if(mModeOn) { setMDPCompLayerFlags(ctx, list); } else { reset(ctx); memset(&mCurrentFrame.drop, 0, sizeof(mCurrentFrame.drop)); mCurrentFrame.dropCount = 0; ret = -1; } } else { ALOGD_IF( isDebug(),"%s: MDP Comp not possible for this frame", __FUNCTION__); ret = -1; } if(isDebug()) { ALOGD("GEOMETRY change: %d", (list->flags & HWC_GEOMETRY_CHANGED)); android::String8 sDump(""); dump(sDump); ALOGD("%s",sDump.string()); } #ifdef DYNAMIC_FPS setDynRefreshRate(ctx, list); #endif mCachedFrame.updateCounts(mCurrentFrame); return ret; } bool MDPComp::allocSplitVGPipesfor4k2k(hwc_context_t *ctx, hwc_display_contents_1_t* list, int index) { bool bRet = true; hwc_layer_1_t* layer = &list->hwLayers[index]; private_handle_t *hnd = (private_handle_t *)layer->handle; int mdpIndex = mCurrentFrame.layerToMDP[index]; PipeLayerPair& info = mCurrentFrame.mdpToLayer[mdpIndex]; info.pipeInfo = new MdpYUVPipeInfo; info.rot = NULL; MdpYUVPipeInfo& pipe_info = *(MdpYUVPipeInfo*)info.pipeInfo; ePipeType type = MDPCOMP_OV_VG; pipe_info.lIndex = ovutils::OV_INVALID; pipe_info.rIndex = ovutils::OV_INVALID; pipe_info.lIndex = getMdpPipe(ctx, type, Overlay::MIXER_DEFAULT); if(pipe_info.lIndex == ovutils::OV_INVALID){ bRet = false; ALOGD_IF(isDebug(),"%s: allocating first VG pipe failed", __FUNCTION__); } pipe_info.rIndex = getMdpPipe(ctx, type, Overlay::MIXER_DEFAULT); if(pipe_info.rIndex == ovutils::OV_INVALID){ bRet = false; ALOGD_IF(isDebug(),"%s: allocating second VG pipe failed", __FUNCTION__); } return bRet; } int MDPComp::drawOverlap(hwc_context_t *ctx, hwc_display_contents_1_t* list) { int fd = -1; if (ctx->mPtorInfo.isActive()) { fd = ctx->mCopyBit[mDpy]->drawOverlap(ctx, list); if (fd < 0) { ALOGD_IF(isDebug(),"%s: failed", __FUNCTION__); } } return fd; } //=============MDPCompNonSplit=================================================== void MDPCompNonSplit::adjustForSourceSplit(hwc_context_t *ctx, hwc_display_contents_1_t* list){ //As we split 4kx2k yuv layer and program to 2 VG pipes //(if available) increase mdpcount accordingly mCurrentFrame.mdpCount += ctx->listStats[mDpy].yuv4k2kCount; //If 4k2k Yuv layer split is possible, and if //fbz is above 4k2k layer, increment fb zorder by 1 //as we split 4k2k layer and increment zorder for right half //of the layer if(mCurrentFrame.fbZ >= 0) { for (int index = 0, mdpNextZOrder = 0; index < mCurrentFrame.layerCount; index++) { if(!mCurrentFrame.isFBComposed[index]) { if(mdpNextZOrder == mCurrentFrame.fbZ) { mdpNextZOrder++; } mdpNextZOrder++; hwc_layer_1_t* layer = &list->hwLayers[index]; private_handle_t *hnd = (private_handle_t *)layer->handle; if(is4kx2kYuvBuffer(hnd)) { if(mdpNextZOrder <= mCurrentFrame.fbZ) mCurrentFrame.fbZ += 1; mdpNextZOrder++; //As we split 4kx2k yuv layer and program to 2 VG pipes //(if available) increase mdpcount by 1. mCurrentFrame.mdpCount++; } } } } } /* * Configures pipe(s) for MDP composition */ int MDPCompNonSplit::configure(hwc_context_t *ctx, hwc_layer_1_t *layer, PipeLayerPair& PipeLayerPair) { MdpPipeInfoNonSplit& mdp_info = *(static_cast(PipeLayerPair.pipeInfo)); eMdpFlags mdpFlags = ovutils::OV_MDP_FLAGS_NONE; eZorder zOrder = static_cast(mdp_info.zOrder); eIsFg isFg = IS_FG_OFF; eDest dest = mdp_info.index; ALOGD_IF(isDebug(),"%s: configuring: layer: %p z_order: %d dest_pipe: %d", __FUNCTION__, layer, zOrder, dest); return configureNonSplit(ctx, layer, mDpy, mdpFlags, zOrder, isFg, dest, &PipeLayerPair.rot); } bool MDPCompNonSplit::allocLayerPipes(hwc_context_t *ctx, hwc_display_contents_1_t* list) { for(int index = 0; index < mCurrentFrame.layerCount; index++) { if(mCurrentFrame.isFBComposed[index]) continue; hwc_layer_1_t* layer = &list->hwLayers[index]; private_handle_t *hnd = (private_handle_t *)layer->handle; if(is4kx2kYuvBuffer(hnd) && sEnable4k2kYUVSplit){ if(allocSplitVGPipesfor4k2k(ctx, list, index)){ continue; } } int mdpIndex = mCurrentFrame.layerToMDP[index]; PipeLayerPair& info = mCurrentFrame.mdpToLayer[mdpIndex]; info.pipeInfo = new MdpPipeInfoNonSplit; info.rot = NULL; MdpPipeInfoNonSplit& pipe_info = *(MdpPipeInfoNonSplit*)info.pipeInfo; ePipeType type = MDPCOMP_OV_ANY; if(isYuvBuffer(hnd)) { type = MDPCOMP_OV_VG; } else if(qdutils::MDPVersion::getInstance().is8x26() && (ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres > 1024)) { if(qhwc::needsScaling(layer)) type = MDPCOMP_OV_RGB; } else if(!qhwc::needsScaling(layer) && Overlay::getDMAMode() != Overlay::DMA_BLOCK_MODE && ctx->mMDP.version >= qdutils::MDSS_V5) { type = MDPCOMP_OV_DMA; } // for 8x26, never allow primary display occupy DMA pipe // when external display is connected if(qdutils::MDPVersion::getInstance().is8x26() && ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isActive && ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected && !ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isPause && mDpy == HWC_DISPLAY_PRIMARY && type == MDPCOMP_OV_DMA) { type = MDPCOMP_OV_RGB; } pipe_info.index = getMdpPipe(ctx, type, Overlay::MIXER_DEFAULT); if(pipe_info.index == ovutils::OV_INVALID) { ALOGD_IF(isDebug(), "%s: Unable to get pipe type = %d", __FUNCTION__, (int) type); return false; } } return true; } int MDPCompNonSplit::configure4k2kYuv(hwc_context_t *ctx, hwc_layer_1_t *layer, PipeLayerPair& PipeLayerPair) { MdpYUVPipeInfo& mdp_info = *(static_cast(PipeLayerPair.pipeInfo)); eZorder zOrder = static_cast(mdp_info.zOrder); eIsFg isFg = IS_FG_OFF; eMdpFlags mdpFlagsL = ovutils::OV_MDP_FLAGS_NONE; eDest lDest = mdp_info.lIndex; eDest rDest = mdp_info.rIndex; return configureSourceSplit(ctx, layer, mDpy, mdpFlagsL, zOrder, isFg, lDest, rDest, &PipeLayerPair.rot); } bool MDPCompNonSplit::draw(hwc_context_t *ctx, hwc_display_contents_1_t* list) { if(!isEnabled() or !mModeOn) { ALOGD_IF(isDebug(),"%s: MDP Comp not enabled/configured", __FUNCTION__); return true; } overlay::Overlay& ov = *ctx->mOverlay; LayerProp *layerProp = ctx->layerProp[mDpy]; int numHwLayers = ctx->listStats[mDpy].numAppLayers; for(int i = 0; i < numHwLayers && mCurrentFrame.mdpCount; i++ ) { if(mCurrentFrame.isFBComposed[i]) continue; hwc_layer_1_t *layer = &list->hwLayers[i]; private_handle_t *hnd = (private_handle_t *)layer->handle; if(!hnd) { if (!(layer->flags & HWC_COLOR_FILL)) { ALOGE("%s handle null", __FUNCTION__); return false; } // No PLAY for Color layer layerProp[i].mFlags &= ~HWC_MDPCOMP; continue; } int mdpIndex = mCurrentFrame.layerToMDP[i]; if(is4kx2kYuvBuffer(hnd) && sEnable4k2kYUVSplit) { MdpYUVPipeInfo& pipe_info = *(MdpYUVPipeInfo*)mCurrentFrame.mdpToLayer[mdpIndex].pipeInfo; Rotator *rot = mCurrentFrame.mdpToLayer[mdpIndex].rot; ovutils::eDest indexL = pipe_info.lIndex; ovutils::eDest indexR = pipe_info.rIndex; int fd = hnd->fd; uint32_t offset = hnd->offset; if(rot) { rot->queueBuffer(fd, offset); fd = rot->getDstMemId(); offset = rot->getDstOffset(); } if(indexL != ovutils::OV_INVALID) { ovutils::eDest destL = (ovutils::eDest)indexL; ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, indexL ); if (!ov.queueBuffer(fd, offset, destL)) { ALOGE("%s: queueBuffer failed for display:%d", __FUNCTION__, mDpy); return false; } } if(indexR != ovutils::OV_INVALID) { ovutils::eDest destR = (ovutils::eDest)indexR; ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, indexR ); if (!ov.queueBuffer(fd, offset, destR)) { ALOGE("%s: queueBuffer failed for display:%d", __FUNCTION__, mDpy); return false; } } } else{ MdpPipeInfoNonSplit& pipe_info = *(MdpPipeInfoNonSplit*)mCurrentFrame.mdpToLayer[mdpIndex].pipeInfo; ovutils::eDest dest = pipe_info.index; if(dest == ovutils::OV_INVALID) { ALOGE("%s: Invalid pipe index (%d)", __FUNCTION__, dest); return false; } if(!(layerProp[i].mFlags & HWC_MDPCOMP)) { continue; } int fd = hnd->fd; uint32_t offset = (uint32_t)hnd->offset; int index = ctx->mPtorInfo.getPTORArrayIndex(i); if (!mDpy && (index != -1)) { hnd = ctx->mCopyBit[mDpy]->getCurrentRenderBuffer(); fd = hnd->fd; offset = 0; } ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, dest ); Rotator *rot = mCurrentFrame.mdpToLayer[mdpIndex].rot; if(rot) { if(!rot->queueBuffer(fd, offset)) return false; fd = rot->getDstMemId(); offset = rot->getDstOffset(); } if (!ov.queueBuffer(fd, offset, dest)) { ALOGE("%s: queueBuffer failed for display:%d ", __FUNCTION__, mDpy); return false; } } layerProp[i].mFlags &= ~HWC_MDPCOMP; } return true; } //=============MDPCompSplit=================================================== void MDPCompSplit::adjustForSourceSplit(hwc_context_t *ctx, hwc_display_contents_1_t* list){ //if 4kx2k yuv layer is totally present in either in left half //or right half then try splitting the yuv layer to avoid decimation const int lSplit = getLeftSplit(ctx, mDpy); if(mCurrentFrame.fbZ >= 0) { for (int index = 0, mdpNextZOrder = 0; index < mCurrentFrame.layerCount; index++) { if(!mCurrentFrame.isFBComposed[index]) { if(mdpNextZOrder == mCurrentFrame.fbZ) { mdpNextZOrder++; } mdpNextZOrder++; hwc_layer_1_t* layer = &list->hwLayers[index]; private_handle_t *hnd = (private_handle_t *)layer->handle; if(is4kx2kYuvBuffer(hnd)) { hwc_rect_t dst = layer->displayFrame; if((dst.left > lSplit) || (dst.right < lSplit)) { mCurrentFrame.mdpCount += 1; } if(mdpNextZOrder <= mCurrentFrame.fbZ) mCurrentFrame.fbZ += 1; mdpNextZOrder++; } } } } } bool MDPCompSplit::acquireMDPPipes(hwc_context_t *ctx, hwc_layer_1_t* layer, MdpPipeInfoSplit& pipe_info, ePipeType type) { const int xres = ctx->dpyAttr[mDpy].xres; const int lSplit = getLeftSplit(ctx, mDpy); hwc_rect_t dst = layer->displayFrame; pipe_info.lIndex = ovutils::OV_INVALID; pipe_info.rIndex = ovutils::OV_INVALID; if (dst.left < lSplit) { pipe_info.lIndex = getMdpPipe(ctx, type, Overlay::MIXER_LEFT); if(pipe_info.lIndex == ovutils::OV_INVALID) return false; } if(dst.right > lSplit) { pipe_info.rIndex = getMdpPipe(ctx, type, Overlay::MIXER_RIGHT); if(pipe_info.rIndex == ovutils::OV_INVALID) return false; } return true; } bool MDPCompSplit::allocLayerPipes(hwc_context_t *ctx, hwc_display_contents_1_t* list) { for(int index = 0 ; index < mCurrentFrame.layerCount; index++) { if(mCurrentFrame.isFBComposed[index]) continue; hwc_layer_1_t* layer = &list->hwLayers[index]; private_handle_t *hnd = (private_handle_t *)layer->handle; hwc_rect_t dst = layer->displayFrame; const int lSplit = getLeftSplit(ctx, mDpy); if(is4kx2kYuvBuffer(hnd) && sEnable4k2kYUVSplit){ if((dst.left > lSplit)||(dst.right < lSplit)){ if(allocSplitVGPipesfor4k2k(ctx, list, index)){ continue; } } } int mdpIndex = mCurrentFrame.layerToMDP[index]; PipeLayerPair& info = mCurrentFrame.mdpToLayer[mdpIndex]; info.pipeInfo = new MdpPipeInfoSplit; info.rot = NULL; MdpPipeInfoSplit& pipe_info = *(MdpPipeInfoSplit*)info.pipeInfo; ePipeType type = MDPCOMP_OV_ANY; if(isYuvBuffer(hnd)) { type = MDPCOMP_OV_VG; } else if(!qhwc::needsScalingWithSplit(ctx, layer, mDpy) && Overlay::getDMAMode() != Overlay::DMA_BLOCK_MODE && ctx->mMDP.version >= qdutils::MDSS_V5) { type = MDPCOMP_OV_DMA; } if(!acquireMDPPipes(ctx, layer, pipe_info, type)) { ALOGD_IF(isDebug(), "%s: Unable to get pipe for type = %d", __FUNCTION__, (int) type); return false; } } return true; } int MDPCompSplit::configure4k2kYuv(hwc_context_t *ctx, hwc_layer_1_t *layer, PipeLayerPair& PipeLayerPair) { const int lSplit = getLeftSplit(ctx, mDpy); hwc_rect_t dst = layer->displayFrame; if((dst.left > lSplit)||(dst.right < lSplit)){ MdpYUVPipeInfo& mdp_info = *(static_cast(PipeLayerPair.pipeInfo)); eZorder zOrder = static_cast(mdp_info.zOrder); eIsFg isFg = IS_FG_OFF; eMdpFlags mdpFlagsL = ovutils::OV_MDP_FLAGS_NONE; eDest lDest = mdp_info.lIndex; eDest rDest = mdp_info.rIndex; return configureSourceSplit(ctx, layer, mDpy, mdpFlagsL, zOrder, isFg, lDest, rDest, &PipeLayerPair.rot); } else{ return configure(ctx, layer, PipeLayerPair); } } /* * Configures pipe(s) for MDP composition */ int MDPCompSplit::configure(hwc_context_t *ctx, hwc_layer_1_t *layer, PipeLayerPair& PipeLayerPair) { MdpPipeInfoSplit& mdp_info = *(static_cast(PipeLayerPair.pipeInfo)); eZorder zOrder = static_cast(mdp_info.zOrder); eIsFg isFg = IS_FG_OFF; eMdpFlags mdpFlagsL = ovutils::OV_MDP_FLAGS_NONE; eDest lDest = mdp_info.lIndex; eDest rDest = mdp_info.rIndex; ALOGD_IF(isDebug(),"%s: configuring: layer: %p z_order: %d dest_pipeL: %d" "dest_pipeR: %d",__FUNCTION__, layer, zOrder, lDest, rDest); return configureSplit(ctx, layer, mDpy, mdpFlagsL, zOrder, isFg, lDest, rDest, &PipeLayerPair.rot); } bool MDPCompSplit::draw(hwc_context_t *ctx, hwc_display_contents_1_t* list) { if(!isEnabled() or !mModeOn) { ALOGD_IF(isDebug(),"%s: MDP Comp not enabled/configured", __FUNCTION__); return true; } overlay::Overlay& ov = *ctx->mOverlay; LayerProp *layerProp = ctx->layerProp[mDpy]; int numHwLayers = ctx->listStats[mDpy].numAppLayers; for(int i = 0; i < numHwLayers && mCurrentFrame.mdpCount; i++ ) { if(mCurrentFrame.isFBComposed[i]) continue; hwc_layer_1_t *layer = &list->hwLayers[i]; private_handle_t *hnd = (private_handle_t *)layer->handle; if(!hnd) { ALOGE("%s handle null", __FUNCTION__); return false; } if(!(layerProp[i].mFlags & HWC_MDPCOMP)) { continue; } int mdpIndex = mCurrentFrame.layerToMDP[i]; if(is4kx2kYuvBuffer(hnd) && sEnable4k2kYUVSplit) { MdpYUVPipeInfo& pipe_info = *(MdpYUVPipeInfo*)mCurrentFrame.mdpToLayer[mdpIndex].pipeInfo; Rotator *rot = mCurrentFrame.mdpToLayer[mdpIndex].rot; ovutils::eDest indexL = pipe_info.lIndex; ovutils::eDest indexR = pipe_info.rIndex; int fd = hnd->fd; uint32_t offset = hnd->offset; if(rot) { rot->queueBuffer(fd, offset); fd = rot->getDstMemId(); offset = rot->getDstOffset(); } if(indexL != ovutils::OV_INVALID) { ovutils::eDest destL = (ovutils::eDest)indexL; ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, indexL ); if (!ov.queueBuffer(fd, offset, destL)) { ALOGE("%s: queueBuffer failed for display:%d", __FUNCTION__, mDpy); return false; } } if(indexR != ovutils::OV_INVALID) { ovutils::eDest destR = (ovutils::eDest)indexR; ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, indexR ); if (!ov.queueBuffer(fd, offset, destR)) { ALOGE("%s: queueBuffer failed for display:%d", __FUNCTION__, mDpy); return false; } } } else{ MdpPipeInfoSplit& pipe_info = *(MdpPipeInfoSplit*)mCurrentFrame.mdpToLayer[mdpIndex].pipeInfo; Rotator *rot = mCurrentFrame.mdpToLayer[mdpIndex].rot; ovutils::eDest indexL = pipe_info.lIndex; ovutils::eDest indexR = pipe_info.rIndex; int fd = hnd->fd; uint32_t offset = (uint32_t)hnd->offset; int index = ctx->mPtorInfo.getPTORArrayIndex(i); if (!mDpy && (index != -1)) { hnd = ctx->mCopyBit[mDpy]->getCurrentRenderBuffer(); fd = hnd->fd; offset = 0; } if(ctx->mAD->draw(ctx, fd, offset)) { fd = ctx->mAD->getDstFd(ctx); offset = ctx->mAD->getDstOffset(ctx); } if(rot) { rot->queueBuffer(fd, offset); fd = rot->getDstMemId(); offset = rot->getDstOffset(); } //************* play left mixer ********** if(indexL != ovutils::OV_INVALID) { ovutils::eDest destL = (ovutils::eDest)indexL; ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, indexL ); if (!ov.queueBuffer(fd, offset, destL)) { ALOGE("%s: queueBuffer failed for left mixer", __FUNCTION__); return false; } } //************* play right mixer ********** if(indexR != ovutils::OV_INVALID) { ovutils::eDest destR = (ovutils::eDest)indexR; ALOGD_IF(isDebug(),"%s: MDP Comp: Drawing layer: %p hnd: %p \ using pipe: %d", __FUNCTION__, layer, hnd, indexR ); if (!ov.queueBuffer(fd, offset, destR)) { ALOGE("%s: queueBuffer failed for right mixer", __FUNCTION__); return false; } } } layerProp[i].mFlags &= ~HWC_MDPCOMP; } return true; } }; //namespace