// 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;
}
int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer,
const int& dpy, eMdpFlags& mdpFlagsL, const eZorder& z,
const eIsFg& isFg, const eDest& lDest, const eDest& rDest,
Rotator **rot) {
private_handle_t *hnd = (private_handle_t *)layer->handle;
if(!hnd) {
ALOGE("%s: layer handle is NULL", __FUNCTION__);
return -1;
}
MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
int hw_w = ctx->dpyAttr[dpy].xres;
int hw_h = ctx->dpyAttr[dpy].yres;
hwc_rect_t crop = layer->sourceCrop;
hwc_rect_t dst = layer->displayFrame;
int transform = layer->transform;
eTransform orient = static_cast<eTransform>(transform);
const int downscale = 0;
int rotFlags = ROT_FLAGS_NONE;
Whf whf(getWidth(hnd), getHeight(hnd),
getMdpFormat(hnd->format), hnd->size);
setMdpFlags(layer, mdpFlagsL);
trimLayer(ctx, dpy, transform, crop, dst);
if(isYuvBuffer(hnd) && (transform & HWC_TRANSFORM_ROT_90)) {
(*rot) = ctx->mRotMgr->getNext();
if((*rot) == NULL) return -1;
//Configure rotator for pre-rotation
Whf origWhf(hnd->width, hnd->height,
getMdpFormat(hnd->format), hnd->size);
if(configRotator(*rot, whf, origWhf, mdpFlagsL, orient, downscale) < 0)
return -1;
ctx->mLayerRotMap[dpy]->add(layer, *rot);
whf.format = (*rot)->getDstFormat();
updateSource(orient, whf, crop);
rotFlags |= ROT_PREROTATED;
}
eMdpFlags mdpFlagsR = mdpFlagsL;
setMdpFlags(mdpFlagsR, OV_MDSS_MDP_RIGHT_MIXER);
hwc_rect_t tmp_cropL, tmp_dstL;
hwc_rect_t tmp_cropR, tmp_dstR;
if(lDest != OV_INVALID) {
tmp_cropL = crop;
tmp_dstL = dst;
hwc_rect_t scissor = {0, 0, hw_w/2, hw_h };
qhwc::calculate_crop_rects(tmp_cropL, tmp_dstL, scissor, 0);
}
if(rDest != OV_INVALID) {
tmp_cropR = crop;
tmp_dstR = dst;
hwc_rect_t scissor = {hw_w/2, 0, hw_w, hw_h };
qhwc::calculate_crop_rects(tmp_cropR, tmp_dstR, scissor, 0);
}
//When buffer is flipped, contents of mixer config also needs to swapped.
//Not needed if the layer is confined to one half of the screen.
//If rotator has been used then it has also done the flips, so ignore them.
if((orient & OVERLAY_TRANSFORM_FLIP_V) && lDest != OV_INVALID
&& rDest != OV_INVALID && rot == NULL) {
hwc_rect_t new_cropR;
new_cropR.left = tmp_cropL.left;
new_cropR.right = new_cropR.left + (tmp_cropR.right - tmp_cropR.left);
hwc_rect_t new_cropL;
new_cropL.left = new_cropR.right;
new_cropL.right = tmp_cropR.right;
tmp_cropL.left = new_cropL.left;
tmp_cropL.right = new_cropL.right;
tmp_cropR.left = new_cropR.left;
tmp_cropR.right = new_cropR.right;
}
//For the mdp, since either we are pre-rotating or MDP does flips
orient = OVERLAY_TRANSFORM_0;
transform = 0;
//configure left mixer
if(lDest != OV_INVALID) {
PipeArgs pargL(mdpFlagsL, whf, z, isFg,
static_cast<eRotFlags>(rotFlags), layer->planeAlpha,
(ovutils::eBlending) getBlending(layer->blending));
if(configMdp(ctx->mOverlay, pargL, orient,
tmp_cropL, tmp_dstL, metadata, lDest) < 0) {
ALOGE("%s: commit failed for left mixer config", __FUNCTION__);
return -1;
}
}
//configure right mixer
if(rDest != OV_INVALID) {
PipeArgs pargR(mdpFlagsR, whf, z, isFg,
static_cast<eRotFlags>(rotFlags), layer->planeAlpha,
(ovutils::eBlending) getBlending(layer->blending));
tmp_dstR.right = tmp_dstR.right - tmp_dstR.left;
tmp_dstR.left = 0;
if(configMdp(ctx->mOverlay, pargR, orient,
tmp_cropR, tmp_dstR, metadata, rDest) < 0) {
ALOGE("%s: commit failed for right mixer config", __FUNCTION__);
return -1;
}
}
return 0;
}
// Configure
bool FBUpdateSplit::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)) {
/* External only layer present */
int extOnlyLayerIndex = ctx->listStats[mDpy].extOnlyLayerIndex;
if(extOnlyLayerIndex != -1) {
layer = &list->hwLayers[extOnlyLayerIndex];
layer->compositionType = HWC_OVERLAY;
}
ovutils::Whf info(mAlignedFBWidth, mAlignedFBHeight,
ovutils::getMdpFormat(HAL_PIXEL_FORMAT_RGBA_8888,
mTileEnabled));
overlay::Overlay& ov = *(ctx->mOverlay);
ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_BLEND_FG_PREMULT;
ovutils::eZorder zOrder = static_cast<ovutils::eZorder>(fbZorder);
ovutils::eTransform orient =
static_cast<ovutils::eTransform>(layer->transform);
const int hw_w = ctx->dpyAttr[mDpy].xres;
const int hw_h = ctx->dpyAttr[mDpy].yres;
const int lSplit = getLeftSplit(ctx, mDpy);
mDestLeft = ovutils::OV_INVALID;
mDestRight = ovutils::OV_INVALID;
hwc_rect_t sourceCrop = fbUpdatingRect;
hwc_rect_t displayFrame = fbUpdatingRect;
ret = true;
Overlay::PipeSpecs pipeSpecs;
pipeSpecs.formatClass = Overlay::FORMAT_RGB;
pipeSpecs.needsScaling = qhwc::needsScaling(layer);
pipeSpecs.dpy = mDpy;
pipeSpecs.fb = true;
/* Configure left pipe */
if(displayFrame.left < lSplit) {
pipeSpecs.mixer = Overlay::MIXER_LEFT;
ovutils::eDest destL = ov.getPipe(pipeSpecs);
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;
}
mDestLeft = destL;
//XXX: FB layer plane alpha is currently sent as zero from
//surfaceflinger
ovutils::PipeArgs pargL(mdpFlags,
info,
zOrder,
ovutils::IS_FG_OFF,
ovutils::ROT_FLAGS_NONE,
ovutils::DEFAULT_PLANE_ALPHA,
(ovutils::eBlending)
getBlending(layer->blending));
hwc_rect_t cropL = sourceCrop;
hwc_rect_t dstL = displayFrame;
hwc_rect_t scissorL = {0, 0, lSplit, hw_h };
qhwc::calculate_crop_rects(cropL, dstL, scissorL, 0);
if (configMdp(ctx->mOverlay, pargL, orient, cropL,
dstL, NULL, destL)< 0) {
ALOGE("%s: configMdp fails for left FB", __FUNCTION__);
ret = false;
}
}
/* Configure right pipe */
if(displayFrame.right > lSplit) {
pipeSpecs.mixer = Overlay::MIXER_RIGHT;
ovutils::eDest destR = ov.getPipe(pipeSpecs);
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;
}
mDestRight = destR;
ovutils::eMdpFlags mdpFlagsR = mdpFlags;
ovutils::setMdpFlags(mdpFlagsR, ovutils::OV_MDSS_MDP_RIGHT_MIXER);
//XXX: FB layer plane alpha is currently sent as zero from
//surfaceflinger
ovutils::PipeArgs pargR(mdpFlagsR,
info,
zOrder,
ovutils::IS_FG_OFF,
ovutils::ROT_FLAGS_NONE,
ovutils::DEFAULT_PLANE_ALPHA,
(ovutils::eBlending)
getBlending(layer->blending));
hwc_rect_t cropR = sourceCrop;
hwc_rect_t dstR = displayFrame;
hwc_rect_t scissorR = {lSplit, 0, hw_w, hw_h };
qhwc::calculate_crop_rects(cropR, dstR, scissorR, 0);
dstR.left -= lSplit;
dstR.right -= lSplit;
if (configMdp(ctx->mOverlay, pargR, orient, cropR,
dstR, NULL, destR) < 0) {
ALOGE("%s: configMdp fails for right FB", __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;
}