qcom/display: Update HALs
- Update the display HAL from Code Aurora Forum
- Add updated overlay library
- Enable HWC with basic video going through overlay
- Cleanup some files
Change-Id: I65c687c51be458cee71213c79e03eeda962d9086
diff --git a/libhwcomposer/hwc_overlay.cpp b/libhwcomposer/hwc_overlay.cpp
new file mode 100644
index 0000000..00f53e9
--- /dev/null
+++ b/libhwcomposer/hwc_overlay.cpp
@@ -0,0 +1,294 @@
+/*
+ * 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