LineageOS/android_vendor_qcom_opensource_display-commonsys-intf
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
acf102021ab76bd75422273ffbf3a7f156634a8b
android_vendor_qcom_opensou…/libhwcomposer/hwc_video.cpp
Saurabh Shah acf102021a hwc/overlay: Video on 4k2k external, 4k2k rotation. 
-Add support for Video via overlay on 4k2k external panel.
-Add support for rotating videos on 4k2k panels. We use
pre-rotation in hwc to rotate a video into a single buffer,
irrespective of panel size. Then this buffer is fed to MDP.
Rotator objects are managed by the new RotMgr.
-Cleaup mdpcomp and overlay.

Change-Id: Ifb08534747e8e18b6c58dd8a3e1a9947409100f1
2013-03-13 10:24:31 -07:00

297 lines
8.4 KiB
C++
Raw Blame History

/*
* Copyright (C) 2010 The Android Open Source Project
* 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.
*/
#define VIDEO_DEBUG 0
#include <overlay.h>
#include "hwc_video.h"
#include "hwc_utils.h"
#include "qdMetaData.h"
#include "mdp_version.h"
#include <overlayRotator.h>
using overlay::Rotator;
namespace qhwc {
namespace ovutils = overlay::utils;
//===========IVideoOverlay=========================
IVideoOverlay* IVideoOverlay::getObject(const int& width, const int& dpy) {
if(width > MAX_DISPLAY_DIM) {
return new VideoOverlayHighRes(dpy);
}
return new VideoOverlayLowRes(dpy);
}
//===========VideoOverlayLowRes=========================
VideoOverlayLowRes::VideoOverlayLowRes(const int& dpy): IVideoOverlay(dpy) {}
//Cache stats, figure out the state, config overlay
bool VideoOverlayLowRes::prepare(hwc_context_t *ctx,
hwc_display_contents_1_t *list) {
if(ctx->listStats[mDpy].yuvCount > 1)
return false;
int yuvIndex = ctx->listStats[mDpy].yuvIndices[0];
int hw_w = ctx->dpyAttr[mDpy].xres;
mModeOn = false;
if(hw_w > MAX_DISPLAY_DIM) {
ALOGD_IF(VIDEO_DEBUG,"%s, \
Cannot use video path for High Res Panels", __FUNCTION__);
return false;
}
if(!ctx->mMDP.hasOverlay) {
ALOGD_IF(VIDEO_DEBUG,"%s, this hw doesnt support overlay", __FUNCTION__);
return false;
}
if(isSecuring(ctx)) {
ALOGD_IF(VIDEO_DEBUG,"%s: MDP Secure is active", __FUNCTION__);
return false;
}
if(yuvIndex == -1 || ctx->listStats[mDpy].yuvCount != 1) {
return false;
}
//index guaranteed to be not -1 at this point
hwc_layer_1_t *layer = &list->hwLayers[yuvIndex];
if (isSecureModePolicy(ctx->mMDP.version)) {
private_handle_t *hnd = (private_handle_t *)layer->handle;
if(ctx->mSecureMode) {
if (! isSecureBuffer(hnd)) {
ALOGD_IF(VIDEO_DEBUG, "%s: Handle non-secure video layer"
"during secure playback gracefully", __FUNCTION__);
return false;
}
} else {
if (isSecureBuffer(hnd)) {
ALOGD_IF(VIDEO_DEBUG, "%s: Handle secure video layer"
"during non-secure playback gracefully", __FUNCTION__);
return false;
}
}
}
if(configure(ctx, layer)) {
markFlags(layer);
mModeOn = true;
}
return mModeOn;
}
void VideoOverlayLowRes::markFlags(hwc_layer_1_t *layer) {
if(layer) {
layer->compositionType = HWC_OVERLAY;
layer->hints |= HWC_HINT_CLEAR_FB;
}
}
bool VideoOverlayLowRes::configure(hwc_context_t *ctx,
hwc_layer_1_t *layer) {
overlay::Overlay& ov = *(ctx->mOverlay);
private_handle_t *hnd = (private_handle_t *)layer->handle;
ovutils::Whf info(hnd->width, hnd->height,
ovutils::getMdpFormat(hnd->format), hnd->size);
//Request a VG pipe
ovutils::eDest dest = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, mDpy);
if(dest == ovutils::OV_INVALID) { //None available
return false;
}
mDest = dest;
ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_FLAGS_NONE;
ovutils::eZorder zOrder = ovutils::ZORDER_1;
ovutils::eIsFg isFg = ovutils::IS_FG_OFF;
if (ctx->listStats[mDpy].numAppLayers == 1) {
isFg = ovutils::IS_FG_SET;
}
return (configureLowRes(ctx, layer, mDpy, mdpFlags, zOrder, isFg, dest,
&mRot) == 0 );
}
bool VideoOverlayLowRes::draw(hwc_context_t *ctx,
hwc_display_contents_1_t *list) {
if(!mModeOn) {
return true;
}
int yuvIndex = ctx->listStats[mDpy].yuvIndices[0];
if(yuvIndex == -1) {
return true;
}
private_handle_t *hnd = (private_handle_t *)
list->hwLayers[yuvIndex].handle;
overlay::Overlay& ov = *(ctx->mOverlay);
int fd = hnd->fd;
uint32_t offset = hnd->offset;
Rotator *rot = mRot;
if(rot) {
if(!rot->queueBuffer(fd, offset))
return false;
fd = rot->getDstMemId();
offset = rot->getDstOffset();
}
if (!ov.queueBuffer(fd, offset, mDest)) {
ALOGE("%s: queueBuffer failed for dpy=%d", __FUNCTION__, mDpy);
return false;
}
return true;
}
//===========VideoOverlayHighRes=========================
VideoOverlayHighRes::VideoOverlayHighRes(const int& dpy): IVideoOverlay(dpy) {}
//Cache stats, figure out the state, config overlay
bool VideoOverlayHighRes::prepare(hwc_context_t *ctx,
hwc_display_contents_1_t *list) {
int yuvIndex = ctx->listStats[mDpy].yuvIndices[0];
int hw_w = ctx->dpyAttr[mDpy].xres;
mModeOn = false;
if(!ctx->mMDP.hasOverlay) {
ALOGD_IF(VIDEO_DEBUG,"%s, this hw doesnt support overlay", __FUNCTION__);
return false;
}
if(yuvIndex == -1 || ctx->listStats[mDpy].yuvCount != 1) {
return false;
}
//index guaranteed to be not -1 at this point
hwc_layer_1_t *layer = &list->hwLayers[yuvIndex];
if(configure(ctx, layer)) {
markFlags(layer);
mModeOn = true;
}
return mModeOn;
}
void VideoOverlayHighRes::markFlags(hwc_layer_1_t *layer) {
if(layer) {
layer->compositionType = HWC_OVERLAY;
layer->hints |= HWC_HINT_CLEAR_FB;
}
}
bool VideoOverlayHighRes::configure(hwc_context_t *ctx,
hwc_layer_1_t *layer) {
int hw_w = ctx->dpyAttr[mDpy].xres;
overlay::Overlay& ov = *(ctx->mOverlay);
private_handle_t *hnd = (private_handle_t *)layer->handle;
ovutils::Whf info(hnd->width, hnd->height,
ovutils::getMdpFormat(hnd->format), hnd->size);
//Request a VG pipe
mDestL = ovutils::OV_INVALID;
mDestR = ovutils::OV_INVALID;
hwc_rect_t dst = layer->displayFrame;
if(dst.left > hw_w/2) {
mDestR = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, mDpy);
if(mDestR == ovutils::OV_INVALID)
return false;
} else if (dst.right <= hw_w/2) {
mDestL = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, mDpy);
if(mDestL == ovutils::OV_INVALID)
return false;
} else {
mDestL = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, mDpy);
mDestR = ov.nextPipe(ovutils::OV_MDP_PIPE_VG, mDpy);
if(mDestL == ovutils::OV_INVALID ||
mDestR == ovutils::OV_INVALID)
return false;
}
ovutils::eMdpFlags mdpFlags = ovutils::OV_MDP_FLAGS_NONE;
ovutils::eZorder zOrder = ovutils::ZORDER_1;
ovutils::eIsFg isFg = ovutils::IS_FG_OFF;
if (ctx->listStats[mDpy].numAppLayers == 1) {
isFg = ovutils::IS_FG_SET;
}
return (configureHighRes(ctx, layer, mDpy, mdpFlags, zOrder, isFg, mDestL,
mDestR, &mRot) == 0 );
}
bool VideoOverlayHighRes::draw(hwc_context_t *ctx,
hwc_display_contents_1_t *list) {
if(!mModeOn) {
return true;
}
int yuvIndex = ctx->listStats[mDpy].yuvIndices[0];
if(yuvIndex == -1) {
return true;
}
private_handle_t *hnd = (private_handle_t *)
list->hwLayers[yuvIndex].handle;
overlay::Overlay& ov = *(ctx->mOverlay);
int fd = hnd->fd;
uint32_t offset = hnd->offset;
Rotator *rot = mRot;
if(rot) {
if(!rot->queueBuffer(fd, offset))
return false;
fd = rot->getDstMemId();
offset = rot->getDstOffset();
}
if(mDestL != ovutils::OV_INVALID) {
if (!ov.queueBuffer(fd, offset, mDestL)) {
ALOGE("%s: queueBuffer failed for dpy=%d's left mixer",
__FUNCTION__, mDpy);
return false;
}
}
if(mDestR != ovutils::OV_INVALID) {
if (!ov.queueBuffer(fd, offset, mDestR)) {
ALOGE("%s: queueBuffer failed for dpy=%d's right mixer"
, __FUNCTION__, mDpy);
return false;
}
}
return true;
}
}; //namespace qhwc
Reference in New Issue View Git Blame Copy Permalink