| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * Copyright (C) 2012, Code Aurora Forum. All rights reserved. |
| * |
| * 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 "hwc_utils.h" |
| |
| namespace qhwc { |
| // Determine overlay state based on decoded video info |
| static ovutils::eOverlayState determineOverlayState(hwc_context_t* ctx, |
| uint32_t bypassLayer, |
| uint32_t format) |
| { |
| ovutils::eOverlayState state = ovutils::OV_CLOSED; |
| |
| // Sanity check |
| if (!ctx) { |
| ALOGE("%s: NULL ctx", __FUNCTION__); |
| return state; |
| } |
| |
| overlay::Overlay& ov = *(ctx->mOverlay); |
| state = ov.getState(); |
| |
| // If there are any bypassLayers, state is based on number of layers |
| if ((bypassLayer > 0) && (ctx->hdmiEnabled == EXT_TYPE_NONE)) { |
| if (bypassLayer == 1) { |
| state = ovutils::OV_BYPASS_1_LAYER; |
| } else if (bypassLayer == 2) { |
| state = ovutils::OV_BYPASS_2_LAYER; |
| } else if (bypassLayer == 3) { |
| state = ovutils::OV_BYPASS_3_LAYER; |
| } |
| return state; |
| } |
| |
| // RGB is ambiguous for determining overlay state |
| if (ovutils::isRgb(ovutils::getMdpFormat(format))) { |
| return state; |
| } |
| |
| // Content type is either 2D or 3D |
| uint32_t fmt3D = 0;//XXX: 3D - ovutils::getS3DFormat(format); |
| |
| // Determine state based on the external display, content type, and hw type |
| if (ctx->hdmiEnabled == EXT_TYPE_HDMI) { |
| // External display is HDMI |
| if (fmt3D) { |
| // Content type is 3D |
| if (ovutils::is3DTV()) { |
| // TV panel type is 3D |
| state = ovutils::OV_3D_VIDEO_ON_3D_TV; |
| } else { |
| // TV panel type is 2D |
| state = ovutils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV; |
| } |
| } else { |
| // Content type is 2D |
| if (ovutils::FrameBufferInfo::getInstance()->supportTrueMirroring()) { |
| // True UI mirroring is supported |
| state = ovutils::OV_2D_TRUE_UI_MIRROR; |
| } else { |
| // True UI mirroring is not supported |
| state = ovutils::OV_2D_VIDEO_ON_PANEL_TV; |
| } |
| } |
| } else if (ctx->hdmiEnabled == EXT_TYPE_WIFI) { |
| // External display is Wifi (currently unsupported) |
| ALOGE("%s: WIFI external display is unsupported", __FUNCTION__); |
| return state; |
| } else { |
| // No external display (primary panel only) |
| if (fmt3D) { |
| // Content type is 3D |
| if (ovutils::usePanel3D()) { |
| // Primary panel type is 3D |
| state = ovutils::OV_3D_VIDEO_ON_3D_PANEL; |
| } else { |
| // Primary panel type is 2D |
| state = ovutils::OV_3D_VIDEO_ON_2D_PANEL; |
| } |
| } else { |
| // Content type is 2D |
| state = ovutils::OV_2D_VIDEO_ON_PANEL; |
| } |
| } |
| |
| return state; |
| } |
| |
| void setOverlayState(hwc_context_t *ctx, ovutils::eOverlayState state) |
| { |
| if (!ctx) { |
| ALOGE("%s: NULL ctx", __FUNCTION__); |
| return; |
| } |
| |
| overlay::Overlay *ov = ctx->mOverlay; |
| if (!ov) { |
| ALOGE("%s: NULL OV object", __FUNCTION__); |
| return; |
| } |
| ov->setState(state); |
| } |
| |
| bool prepareOverlay(hwc_context_t *ctx, hwc_layer_t *layer) |
| { |
| bool ret = false; |
| if (LIKELY(ctx->mOverlay)) { |
| private_handle_t *hnd = (private_handle_t *)layer->handle; |
| overlay::Overlay& ov = *(ctx->mOverlay); |
| ovutils::Whf info(hnd->width, hnd->height, hnd->format, hnd->size); |
| |
| // Set overlay state |
| ovutils::eOverlayState state = determineOverlayState(ctx, 0, info.format); |
| setOverlayState(ctx, state); |
| |
| ovutils::eDest dest = ovutils::OV_PIPE_ALL; |
| |
| // In the true UI mirroring case, video needs to go to OV_PIPE0 (for |
| // primary) and OV_PIPE1 (for external) |
| if (state == ovutils::OV_2D_TRUE_UI_MIRROR) { |
| dest = static_cast<ovutils::eDest>( |
| ovutils::OV_PIPE0 | ovutils::OV_PIPE1); |
| } |
| |
| // Order order order |
| // setSource - just setting source |
| // setParameter - changes src w/h/f accordingly |
| // setCrop - ROI - that is src_rect |
| // setPosition - need to do scaling |
| // commit - commit changes to mdp driver |
| // queueBuffer - not here, happens when draw is called |
| |
| ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_FLAGS_NONE; |
| if (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) { |
| ovutils::setMdpFlags(mdpFlags, |
| ovutils::OV_MDP_SECURE_OVERLAY_SESSION); |
| } |
| |
| // FIXME: Use source orientation for TV when source is portrait |
| int transform = layer->transform & FINAL_TRANSFORM_MASK; |
| ovutils::eTransform orient = |
| static_cast<ovutils::eTransform>(transform); |
| |
| ovutils::eWait waitFlag = ovutils::NO_WAIT; |
| if (ctx->skipComposition == true) { |
| waitFlag = ovutils::WAIT; |
| } |
| |
| ovutils::eIsFg isFgFlag = ovutils::IS_FG_OFF; |
| if (ctx->numHwLayers == 1) { |
| isFgFlag = ovutils::IS_FG_SET; |
| } |
| |
| ovutils::PipeArgs parg(mdpFlags, |
| orient, |
| info, |
| waitFlag, |
| ovutils::ZORDER_0, |
| isFgFlag, |
| ovutils::ROT_FLAG_DISABLED); |
| ovutils::PipeArgs pargs[ovutils::MAX_PIPES] = { parg, parg, parg }; |
| ret = ov.setSource(pargs, dest); |
| if (!ret) { |
| ALOGE("%s: setSource failed", __FUNCTION__); |
| return ret; |
| } |
| |
| const ovutils::Params prms (ovutils::OVERLAY_TRANSFORM, orient); |
| ret = ov.setParameter(prms, dest); |
| if (!ret) { |
| ALOGE("%s: setParameter failed transform %x", __FUNCTION__, orient); |
| return ret; |
| } |
| |
| hwc_rect_t sourceCrop = layer->sourceCrop; |
| // x,y,w,h |
| ovutils::Dim dcrop(sourceCrop.left, sourceCrop.top, // x, y |
| sourceCrop.right - sourceCrop.left, // w |
| sourceCrop.bottom - sourceCrop.top);// h |
| ret = ov.setCrop(dcrop, dest); |
| if (!ret) { |
| ALOGE("%s: setCrop failed", __FUNCTION__); |
| return ret; |
| } |
| |
| int orientation = 0; |
| ovutils::Dim dim; |
| hwc_rect_t displayFrame = layer->displayFrame; |
| dim.x = displayFrame.left; |
| dim.y = displayFrame.top; |
| dim.w = (displayFrame.right - displayFrame.left); |
| dim.h = (displayFrame.bottom - displayFrame.top); |
| dim.o = orientation; |
| |
| ret = ov.setPosition(dim, dest); |
| if (!ret) { |
| ALOGE("%s: setPosition failed", __FUNCTION__); |
| return ret; |
| } |
| if (!ov.commit(dest)) { |
| ALOGE("%s: commit fails", __FUNCTION__); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool drawLayerUsingOverlay(hwc_context_t *ctx, hwc_layer_t *layer) |
| { |
| private_handle_t *hnd = (private_handle_t *)layer->handle; |
| |
| // Lock this buffer for read. |
| ctx->qbuf->lockAndAdd(hnd); |
| bool ret = true; |
| overlay::Overlay& ov = *(ctx->mOverlay); |
| ovutils::eOverlayState state = ov.getState(); |
| |
| // Differentiate between states that need to wait for vsync |
| switch (state) { |
| case ovutils::OV_2D_VIDEO_ON_PANEL_TV: |
| case ovutils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV: |
| case ovutils::OV_2D_TRUE_UI_MIRROR: |
| // If displaying on both primary and external, must play each |
| // pipe individually since wait for vsync needs to be done at |
| // the end. Do the following: |
| // - Play external |
| // - Play primary |
| // - Wait for external vsync to be done |
| // NOTE: In these states |
| // - primary VG = OV_PIPE0 |
| // - external VG = OV_PIPE1 |
| // - external RGB = OV_PIPE2 |
| // - Only in true UI mirroring case, played by fb |
| |
| // Same FD for both primary and external VG pipes |
| ov.setMemoryId(hnd->fd, static_cast<ovutils::eDest>( |
| ovutils::OV_PIPE0 | ovutils::OV_PIPE1)); |
| |
| // Play external |
| if (!ov.queueBuffer(hnd->offset, ovutils::OV_PIPE1)) { |
| ALOGE("%s: queueBuffer failed for external", __FUNCTION__); |
| ret = false; |
| } |
| |
| // Play primary |
| if (!ov.queueBuffer(hnd->offset, ovutils::OV_PIPE0)) { |
| ALOGE("%s: queueBuffer failed for primary", __FUNCTION__); |
| ret = false; |
| } |
| |
| // Wait for external vsync to be done |
| if (!ov.waitForVsync(ovutils::OV_PIPE1)) { |
| ALOGE("%s: waitForVsync failed for external", __FUNCTION__); |
| ret = false; |
| } |
| break; |
| default: |
| // In most cases, displaying only to one (primary or external) |
| // so use OV_PIPE_ALL since overlay will ignore NullPipes |
| ov.setMemoryId(hnd->fd, ovutils::OV_PIPE_ALL); |
| if (!ov.queueBuffer(hnd->offset, ovutils::OV_PIPE_ALL)) { |
| ALOGE("%s: queueBuffer failed", __FUNCTION__); |
| ret = false; |
| } |
| break; |
| } |
| |
| if (!ret) { |
| ALOGE("%s: failed", __FUNCTION__); |
| } |
| return ret; |
| } |
| |
| void cleanOverlays(hwc_context_t *ctx ) |
| { |
| //XXX: handle for HDMI |
| if(0 == ctx->yuvBufferCount) |
| setOverlayState(ctx, ovutils::OV_CLOSED); |
| } |
| }; //namespace qhwc |