android/android_hardware_qcom_display
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge "liboverlay: Refactor, bug-fixes, upgrade." into jb

Browse Source
This commit is contained in:
Linux Build Service Account 2012-07-13 22:40:58 -07:00 committed by QuIC Gerrit Code Review
commit ac01712091
21 changed files with 1180 additions and 2555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
libhwcomposer/hwc_overlay.cpp
View File

@ -137,14 +137,6 @@ bool prepareOverlay(hwc_context_t *ctx, hwc_layer_t *layer)
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,
@ -167,36 +159,22 @@ bool prepareOverlay(hwc_context_t *ctx, hwc_layer_t *layer)
}
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;
}
ov.setSource(pargs, dest);
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;
}
ov.setCrop(dcrop, dest);
ov.setTransform(orient, dest);
int orientation = 0;
ovutils::Dim dim;
@ -207,11 +185,8 @@ bool prepareOverlay(hwc_context_t *ctx, hwc_layer_t *layer)
dim.h = (displayFrame.bottom - displayFrame.top);
dim.o = orientation;
ret = ov.setPosition(dim, dest);
if (!ret) {
ALOGE("%s: setPosition failed", __FUNCTION__);
return ret;
}
ov.setPosition(dim, dest);
if (!ov.commit(dest)) {
ALOGE("%s: commit fails", __FUNCTION__);
return false;
@ -247,18 +222,14 @@ bool drawLayerUsingOverlay(hwc_context_t *ctx, hwc_layer_t *layer)
// - 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)) {
if (!ov.queueBuffer(hnd->fd, hnd->offset, ovutils::OV_PIPE1)) {
ALOGE("%s: queueBuffer failed for external", __FUNCTION__);
ret = false;
}
// Play primary
if (!ov.queueBuffer(hnd->offset, ovutils::OV_PIPE0)) {
if (!ov.queueBuffer(hnd->fd, hnd->offset, ovutils::OV_PIPE0)) {
ALOGE("%s: queueBuffer failed for primary", __FUNCTION__);
ret = false;
}
@ -272,8 +243,7 @@ bool drawLayerUsingOverlay(hwc_context_t *ctx, hwc_layer_t *layer)
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)) {
if (!ov.queueBuffer(hnd->fd, hnd->offset, ovutils::OV_PIPE_ALL)) {
ALOGE("%s: queueBuffer failed", __FUNCTION__);
ret = false;
}

67
liboverlay/mdpWrapper.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@ -76,7 +76,7 @@ bool getOverlay(int fd, mdp_overlay& ov);
bool play(int fd, msmfb_overlay_data& od);
/* MSMFB_OVERLAY_PLAY_WAIT */
bool playWait(int fd, msmfb_overlay_data& od);
bool waitForVsync(int fd, msmfb_overlay_data& od);
/* MSMFB_OVERLAY_3D */
bool set3D(int fd, msmfb_overlay_3d& ov);
@ -102,96 +102,108 @@ void dump(const char* const s, const fb_var_screeninfo& vinfo);
//---------------Inlines -------------------------------------
inline bool getFScreenInfo(int fd, fb_fix_screeninfo& finfo) {
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
ALOGE("Failed to call ioctl FBIOGET_FSCREENINFO err=%d", errno);
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) < 0) {
ALOGE("Failed to call ioctl FBIOGET_FSCREENINFO err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool getVScreenInfo(int fd, fb_var_screeninfo& vinfo) {
if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
ALOGE("Failed to call ioctl FBIOGET_VSCREENINFO err=%d", errno);
if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo) < 0) {
ALOGE("Failed to call ioctl FBIOGET_VSCREENINFO err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool setVScreenInfo(int fd, fb_var_screeninfo& vinfo) {
if (ioctl(fd, FBIOPUT_VSCREENINFO, &vinfo) == -1) {
ALOGE("Failed to call ioctl FBIOPUT_VSCREENINFO err=%d", errno);
if (ioctl(fd, FBIOPUT_VSCREENINFO, &vinfo) < 0) {
ALOGE("Failed to call ioctl FBIOPUT_VSCREENINFO err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool startRotator(int fd, msm_rotator_img_info& rot) {
if (ioctl(fd, MSM_ROTATOR_IOCTL_START, &rot) == -1){
ALOGE("Failed to call ioctl MSM_ROTATOR_IOCTL_START err=%d", errno);
if (ioctl(fd, MSM_ROTATOR_IOCTL_START, &rot) < 0){
ALOGE("Failed to call ioctl MSM_ROTATOR_IOCTL_START err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool rotate(int fd, msm_rotator_data_info& rot) {
if (ioctl(fd, MSM_ROTATOR_IOCTL_ROTATE, &rot) == -1) {
ALOGE("Failed to call ioctl MSM_ROTATOR_IOCTL_ROTATE err=%d", errno);
if (ioctl(fd, MSM_ROTATOR_IOCTL_ROTATE, &rot) < 0) {
ALOGE("Failed to call ioctl MSM_ROTATOR_IOCTL_ROTATE err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool setOverlay(int fd, mdp_overlay& ov) {
if (ioctl(fd, MSMFB_OVERLAY_SET, &ov) == -1) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_SET err=%d", errno);
if (ioctl(fd, MSMFB_OVERLAY_SET, &ov) < 0) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_SET err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool endRotator(int fd, int sessionId) {
if (ioctl(fd, MSM_ROTATOR_IOCTL_FINISH, &sessionId) == -1) {
ALOGE("Failed to call ioctl MSM_ROTATOR_IOCTL_FINISH err=%d", errno);
if (ioctl(fd, MSM_ROTATOR_IOCTL_FINISH, &sessionId) < 0) {
ALOGE("Failed to call ioctl MSM_ROTATOR_IOCTL_FINISH err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool unsetOverlay(int fd, int ovId) {
if (ioctl(fd, MSMFB_OVERLAY_UNSET, &ovId) == -1) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_UNSET err=%d", errno);
if (ioctl(fd, MSMFB_OVERLAY_UNSET, &ovId) < 0) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_UNSET err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool getOverlay(int fd, mdp_overlay& ov) {
if (ioctl(fd, MSMFB_OVERLAY_GET, &ov) == -1) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_GET err=%d", errno);
if (ioctl(fd, MSMFB_OVERLAY_GET, &ov) < 0) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_GET err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool play(int fd, msmfb_overlay_data& od) {
if (ioctl(fd, MSMFB_OVERLAY_PLAY, &od) == -1) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_PLAY err=%d", errno);
if (ioctl(fd, MSMFB_OVERLAY_PLAY, &od) < 0) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_PLAY err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool playWait(int fd, msmfb_overlay_data& od) {
if (ioctl(fd, MSMFB_OVERLAY_PLAY_WAIT, &od) == -1) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_PLAY_WAIT err=%d", errno);
inline bool waitForVsync(int fd, msmfb_overlay_data& od) {
if (ioctl(fd, MSMFB_OVERLAY_PLAY_WAIT, &od) < 0) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_PLAY_WAIT err=%s",
strerror(errno));
return false;
}
return true;
}
inline bool set3D(int fd, msmfb_overlay_3d& ov) {
if (ioctl(fd, MSMFB_OVERLAY_3D, &ov) == -1) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_3D err=%d", errno);
if (ioctl(fd, MSMFB_OVERLAY_3D, &ov) < 0) {
ALOGE("Failed to call ioctl MSMFB_OVERLAY_3D err=%s",
strerror(errno));
return false;
}
return true;
@ -262,7 +274,6 @@ inline void dump(const char* const s, const fb_var_screeninfo& vinfo) {
s, vinfo.xres, vinfo.yres);
}
} // mdp_wrapper
} // overlay

173
liboverlay/overlay.cpp
View File

@ -31,10 +31,8 @@
#include "overlayImpl.h"
#include "overlay.h"
// MDP related FIXME move to state
#include "overlayMdp.h"
#include "overlayCtrlData.h"
#include "overlayRotator.h"
namespace overlay {
@ -42,64 +40,16 @@ Overlay::Overlay(): mOv(0) {
}
Overlay::~Overlay() {
if(mState.state() == utils::OV_CLOSED) return;
close();
mOv = mState.handleEvent(utils::OV_CLOSED, mOv);
delete mOv;
mOv = 0;
}
bool Overlay::open() {
// We need an empty open to just open the bare minimum for business
return true;
}
void Overlay::reset(){
if(mOv && !mOv->close()) {
ALOGE("%s Overlay failed", __FUNCTION__);
}
delete mOv;
mOv = 0;
}
bool Overlay::close()
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_CLOSED:
// try to close any partially opened items
break;
case utils::OV_2D_VIDEO_ON_PANEL:
case utils::OV_2D_VIDEO_ON_PANEL_TV:
case utils::OV_3D_VIDEO_ON_2D_PANEL:
case utils::OV_3D_VIDEO_ON_3D_PANEL:
case utils::OV_3D_VIDEO_ON_3D_TV:
case utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV:
case utils::OV_UI_MIRROR:
case utils::OV_2D_TRUE_UI_MIRROR:
case utils::OV_BYPASS_1_LAYER:
case utils::OV_BYPASS_2_LAYER:
case utils::OV_BYPASS_3_LAYER:
mOv = mState.handleEvent(utils::OV_CLOSED, mOv);
this->reset();
break;
default:
OVASSERT(false, "close Unknown state %d", st);
return false;
}
return true;
}
bool Overlay::commit(utils::eDest dest)
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
@ -125,13 +75,12 @@ bool Overlay::commit(utils::eDest dest)
return true;
}
bool Overlay::queueBuffer(uint32_t offset,
bool Overlay::queueBuffer(int fd, uint32_t offset,
utils::eDest dest)
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
@ -145,39 +94,7 @@ bool Overlay::queueBuffer(uint32_t offset,
case utils::OV_BYPASS_1_LAYER:
case utils::OV_BYPASS_2_LAYER:
case utils::OV_BYPASS_3_LAYER:
if(!mOv->queueBuffer(offset, dest)) {
ALOGE("Overlay %s failed", __FUNCTION__);
return false;
}
break;
default:
OVASSERT(false, "%s Unknown state %d", __FUNCTION__, st);
return false;
}
return true;
}
bool Overlay::dequeueBuffer(void*& buf,
utils::eDest dest)
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
case utils::OV_2D_VIDEO_ON_PANEL_TV:
case utils::OV_3D_VIDEO_ON_2D_PANEL:
case utils::OV_3D_VIDEO_ON_3D_PANEL:
case utils::OV_3D_VIDEO_ON_3D_TV:
case utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV:
case utils::OV_UI_MIRROR:
case utils::OV_2D_TRUE_UI_MIRROR:
case utils::OV_BYPASS_1_LAYER:
case utils::OV_BYPASS_2_LAYER:
case utils::OV_BYPASS_3_LAYER:
if(!mOv->dequeueBuffer(buf, dest)) {
if(!mOv->queueBuffer(fd, offset, dest)) {
ALOGE("Overlay %s failed", __FUNCTION__);
return false;
}
@ -194,7 +111,6 @@ bool Overlay::waitForVsync(utils::eDest dest)
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
@ -226,7 +142,6 @@ bool Overlay::setCrop(const utils::Dim& d,
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
@ -257,7 +172,6 @@ bool Overlay::setPosition(const utils::Dim& d,
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
@ -282,13 +196,13 @@ bool Overlay::setPosition(const utils::Dim& d,
}
return true;
}
bool Overlay::setParameter(const utils::Params& param,
bool Overlay::setTransform(const int orient,
utils::eDest dest)
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eTransform transform =
static_cast<utils::eTransform>(orient);
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
@ -302,7 +216,7 @@ bool Overlay::setParameter(const utils::Params& param,
case utils::OV_BYPASS_1_LAYER:
case utils::OV_BYPASS_2_LAYER:
case utils::OV_BYPASS_3_LAYER:
if(!mOv->setParameter(param, dest)) {
if(!mOv->setTransform(transform, dest)) {
ALOGE("Overlay %s failed", __FUNCTION__);
return false;
}
@ -313,25 +227,19 @@ bool Overlay::setParameter(const utils::Params& param,
}
return true;
}
bool Overlay::setSource(const utils::PipeArgs args[utils::MAX_PIPES],
utils::eDest dest)
{
// FIXME that one needs to move to the state machine class
utils::PipeArgs margs[utils::MAX_PIPES] = {
args[0], args[1], args[2] };
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_CLOSED:
// if we get setSource when we are closed, then
// we will assume tranistion to OV_2D_VIDEO_ON_PANEL
// returns overlay
mOv = mState.handle_closed(utils::OV_2D_VIDEO_ON_PANEL);
if (!mOv) {
ALOGE("Overlay %s failed", __FUNCTION__);
this->reset(); // cleanup
return false;
}
ALOGE("Overlay %s failed, state is OV_CLOSED, set state first",
__FUNCTION__);
return false;
break;
case utils::OV_2D_VIDEO_ON_PANEL:
case utils::OV_3D_VIDEO_ON_2D_PANEL:
@ -351,7 +259,7 @@ bool Overlay::setSource(const utils::PipeArgs args[utils::MAX_PIPES],
margs[utils::CHANNEL_1].wait = utils::NO_WAIT;
break;
case utils::OV_2D_TRUE_UI_MIRROR:
// Set zorder -- external VG pipe (video) gets 0, RGB pipe (UI) gets 1
// Set zorder, external VG pipe (video) gets 0, RGB pipe (UI) gets 1
margs[utils::CHANNEL_1].zorder = utils::ZORDER_0;
margs[utils::CHANNEL_2].zorder = utils::ZORDER_1;
// External VG (video) and RGB (UI) pipe set to be no wait
@ -371,39 +279,12 @@ bool Overlay::setSource(const utils::PipeArgs args[utils::MAX_PIPES],
return true;
}
void Overlay::setMemoryId(int id, utils::eDest dest)
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME that one needs to move to the state machine class
utils::eOverlayState st = mState.state();
switch (st) {
case utils::OV_2D_VIDEO_ON_PANEL:
case utils::OV_2D_VIDEO_ON_PANEL_TV:
case utils::OV_3D_VIDEO_ON_2D_PANEL:
case utils::OV_3D_VIDEO_ON_3D_PANEL:
case utils::OV_3D_VIDEO_ON_3D_TV:
case utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV:
case utils::OV_UI_MIRROR:
case utils::OV_2D_TRUE_UI_MIRROR:
case utils::OV_BYPASS_1_LAYER:
case utils::OV_BYPASS_2_LAYER:
case utils::OV_BYPASS_3_LAYER:
mOv->setMemoryId(id, dest);
break;
default:
OVASSERT(false, "setMemId Unknown state %d", st);
}
}
void Overlay::dump() const
{
OVASSERT(mOv,
"%s Overlay and Rotator should be init at this point",
__FUNCTION__);
// FIXME dump tate object, factory
ALOGE("== Dump Overlay start ==");
mState.dump();
mOv->dump();
@ -426,30 +307,4 @@ Overlay* Overlay::getInstance() {
return sInstance;
}
/**** NullPipe ****/
bool NullPipe::open(RotatorBase*) {
ALOGE_IF(DEBUG_OVERLAY, "NullPipe open");
return true;
}
bool NullPipe::close() { return true; }
bool NullPipe::commit() { return true; }
bool NullPipe::start(const utils::PipeArgs&) { return true; }
bool NullPipe::setCrop(const utils::Dim&) { return true; }
bool NullPipe::setPosition(const utils::Dim&) { return true; }
bool NullPipe::setParameter(const utils::Params&) { return true; }
bool NullPipe::setSource(const utils::PipeArgs&) { return true; }
bool NullPipe::queueBuffer(uint32_t offset) { return true; }
bool NullPipe::dequeueBuffer(void*&) { return true; }
bool NullPipe::waitForVsync() { return true; }
void NullPipe::setMemoryId(int) {}
// NullPipe will return by val here as opposed to other Pipes.
utils::PipeArgs NullPipe::getArgs() const { return utils::PipeArgs(); }
utils::eOverlayPipeType NullPipe::getOvPipeType() const {
return utils::OV_PIPE_TYPE_NULL;
}
void NullPipe::dump() const {
ALOGE("== NullPipe (null) start/end ==");
}
} // overlay

25
liboverlay/overlay.h
View File

@ -43,31 +43,22 @@ public:
/* Overlay related func */
/* We need an empty open to just open the bare minimum for
* business. */
bool open();
/* close rotator, state, overlayimpl*/
bool close();
/* Following is the same as the pure virt interface in ov impl */
bool commit(utils::eDest dest = utils::OV_PIPE_ALL);
bool queueBuffer(uint32_t offset,
bool setSource(const utils::PipeArgs args[utils::MAX_PIPES],
utils::eDest dest = utils::OV_PIPE_ALL);
bool dequeueBuffer(void*& buf,
utils::eDest dest = utils::OV_PIPE_ALL);
bool waitForVsync(utils::eDest dest = utils::OV_PIPE1);
bool setCrop(const utils::Dim& d,
utils::eDest dest = utils::OV_PIPE_ALL);
bool setTransform(const int orientation,
utils::eDest dest = utils::OV_PIPE_ALL);
bool setPosition(const utils::Dim& dim,
utils::eDest dest = utils::OV_PIPE_ALL);
bool setParameter(const utils::Params& param,
bool commit(utils::eDest dest = utils::OV_PIPE_ALL);
bool queueBuffer(int fd, uint32_t offset,
utils::eDest dest = utils::OV_PIPE_ALL);
bool setSource(const utils::PipeArgs args[utils::MAX_PIPES],
utils::eDest dest = utils::OV_PIPE_ALL);
void setMemoryId(int id, utils::eDest dest = utils::OV_PIPE_ALL);
bool waitForVsync(utils::eDest dest = utils::OV_PIPE1);
void dump() const;
/* state related functions */

159
liboverlay/overlayCtrl.cpp
View File

@ -18,14 +18,14 @@
#include <cutils/properties.h>
#include "overlayCtrlData.h"
#include "fb_priv.h"
#include "gralloc_priv.h" //for interlace
namespace overlay{
bool Ctrl::open(uint32_t fbnum,
RotatorBase* rot) {
// MDP/FD open
if(!mMdp.open(fbnum)) {
ALOGE("Ctrl failed to open fbnum=%d", fbnum);
bool Ctrl::init(uint32_t fbnum) {
// MDP/FD init
if(!mMdp.init(fbnum)) {
ALOGE("Ctrl failed to init fbnum=%d", fbnum);
return false;
}
@ -34,127 +34,12 @@ bool Ctrl::open(uint32_t fbnum,
return false;
}
OVASSERT(rot, "rot is null");
mRot = rot;
// rot should be already opened
return true;
}
bool Ctrl::start(const utils::PipeArgs& args)
{
int colorFormat = utils::getColorFormat(args.whf.format);
utils::eMdpFlags flags = args.mdpFlags;
//XXX: Support for interlaced content
if (0) {
setMdpFlags(flags, utils::OV_MDP_DEINTERLACE);
// Get the actual format
colorFormat = args.whf.format ^ HAL_PIXEL_FORMAT_INTERLACE;
}
utils::Whf hwwhf(args.whf);
int fmt = utils::getMdpFormat(colorFormat);
// FIXME format should probably be int and not uint
if (fmt < 0) {
ALOGE("Ctrl failed getMdpFormat unsopported "
"colorFormat=%d format=%d flags=%d",
colorFormat, fmt, flags);
return false;
}
hwwhf.format = fmt;
// devices should be already opened
// (by calling open earlier in the flow)
const utils::PipeArgs newargs(flags, // mdp flags
args.orientation, // trans
hwwhf,
args.wait,
args.zorder,
args.isFg,
args.rotFlags);
if (!setInfo(newargs)) {
ALOGE("Ctrl failed to setInfo mdpflags=%d wait=%d zorder=%d",
newargs.mdpFlags, newargs.wait, newargs.zorder);
hwwhf.dump();
return false;
}
// FIXME, can we remove that and have it in
// setSource only when source changed?
if(!mRot->start(newargs)) {
ALOGE("Ctrl failed to start Rotation session");
return false;
}
// if geom is different, we need to prepare a new rot buffers.
// remap on demand when the current orientation is 90,180, etc.
// and the prev orientation was 0. It means we go from orient
if(!mRot->remap(utils::ROT_NUM_BUFS, newargs)) {
ALOGE("%s Error in remapping", __FUNCTION__);
}
if(!mMdp.set()) {
ALOGE("Ctrl start failed set overlay");
return false;
}
// cache the src to be the current mCrop vals
mCrop.w = hwwhf.w;
mCrop.h = hwwhf.h;
return true;
}
inline void Ctrl::updateSource(RotatorBase* r,
const utils::PipeArgs& args,
utils::ScreenInfo& info)
{
mMdp.updateSource(r, args, info);
}
bool Ctrl::setSource(const utils::PipeArgs& args)
{
mMdp.setWait(args.wait);
utils::PipeArgs newargs(args);
utils::Whf whf(args.whf);
// check geom change
if(mOvBufInfo != whf) {
// whf.format is given as HAL, that is why it is
// needed to be MDP fmt.
whf.format = utils::getColorFormat(whf.format);
int fmt = utils::getMdpFormat(whf.format);
OVASSERT(-1 != fmt, "Ctrl setSource format is -1");
whf.format = fmt;
newargs.whf = whf;
updateSource(mRot, newargs, mInfo);
mMdp.setUserData(0);
if(!mRot->start(newargs)) {
ALOGE("%s failed start rot", __FUNCTION__);
return false;
}
// if geom is different, we need to prepare a new rot buffers.
// remap on demand when the current orientation is 90,180, etc.
// and the prev orientation was 0. It means we go from orient
if(!mRot->remap(utils::ROT_NUM_BUFS, newargs)) {
ALOGE("%s Error in remapping", __FUNCTION__);
}
}
// needed for setSource
mOrient = args.orientation;
// cache last whf from gralloc hnd
mOvBufInfo = args.whf;
// orign impl is returning false here
// because they will close the overlay and reopen it.
// New design would not do that.
return true;
return mMdp.setSource(args);
}
bool Ctrl::setPosition(const utils::Dim& dim)
@ -172,41 +57,21 @@ bool Ctrl::setPosition(const utils::Dim& dim)
return true;
}
bool Ctrl::setParameter(const utils::Params& p)
bool Ctrl::setTransform(const utils::eTransform& orient, const bool& rotUsed)
{
if (utils::OVERLAY_TRANSFORM == p.param &&
p.value == mMdp.getUserData()) {
// nothing to do here
return true;
}
utils::eTransform trns = static_cast<utils::eTransform>(p.value);
switch (p.param) {
case utils::OVERLAY_DITHER:
// nothing here today
ALOGE("Ctrl setParameter OVERLAY_DITHER not impl");
return true;
case utils::OVERLAY_TRANSFORM:
if(!mRot->overlayTransform(mMdp, trns)) {
ALOGE("Ctrl setParameter failed Rot overlayTransform");
return false;
}
break;
default:
ALOGE("Ctrl setParameter unknown param %d", p.param);
return false;
if(!mMdp.setTransform(orient, rotUsed)) {
ALOGE("Ctrl setTransform failed for Mdp");
return false;
}
return true;
}
bool Ctrl::setCrop(const utils::Dim& d)
{
// FIXME check channel validity
if(!mMdp.setCrop(d)) {
ALOGE("Data setCrop failed in MDP setCrop");
return false;
}
mCrop = d;
return true;
}
@ -224,11 +89,9 @@ utils::Dim Ctrl::getAspectRatio(const utils::Whf& whf) const
}
if (inWhf.w * fbHeight > fbWidth * inWhf.h) {
inWhf.h = fbWidth * inWhf.h / inWhf.w;
utils::even_out(inWhf.h);
inWhf.w = fbWidth;
} else if (inWhf.w * fbHeight < fbWidth * inWhf.h) {
inWhf.w = fbHeight * inWhf.w / inWhf.h;
utils::even_out(inWhf.w);
inWhf.h = fbHeight;
} else {
inWhf.w = fbWidth;
@ -339,10 +202,8 @@ utils::Dim Ctrl::getAspectRatio(const utils::Dim& dim) const {
void Ctrl::dump() const {
ALOGE("== Dump Ctrl start ==");
ALOGE("orient=%d", mOrient);
mInfo.dump("mInfo");
mMdp.dump();
mRot->dump();
ALOGE("== Dump Ctrl end ==");
}

186
liboverlay/overlayCtrlData.h
View File

@ -38,65 +38,40 @@ namespace ovutils = overlay::utils;
namespace overlay {
// FIXME make int to be uint32 whenever possible
class RotatorBase;
/*
* FIXME do we want rot to be template parameter?
* It's already using inheritance...
*
* Sequence to use:
* open
* init
* start
* setXXX
* close
*
* Can call setRot anytime to replace rotator on-the-fly
* */
class Ctrl : utils::NoCopy {
public:
/* ctor */
explicit Ctrl();
/* dtor close */
~Ctrl();
/* should open devices? or start()? */
bool open(uint32_t fbnum, RotatorBase* rot);
/* init fd etc*/
bool init(uint32_t fbnum);
/* close underlying mdp */
bool close();
/* Invoke methods for opening underlying devices
* flags - PIPE SHARED
* wait - WAIT, NO_WAIT */
bool start(const utils::PipeArgs& args);
/* Dynamically set rotator*/
void setRot(RotatorBase* rot);
/* set mdp posision using dim */
bool setPosition(const utils::Dim& dim);
/* set param using Params (param,value pair) */
bool setParameter(const utils::Params& p);
/* set source using whf, orient and wait flag */
bool setSource(const utils::PipeArgs& args);
/* set crop info and pass it down to mdp */
bool setCrop(const utils::Dim& d);
/* set orientation */
bool setTransform(const utils::eTransform& p, const bool&);
/* set mdp position using dim */
bool setPosition(const utils::Dim& dim);
/* mdp set overlay/commit changes */
bool commit();
/* ctrl id */
int getId() const;
int getPipeId() const;
/* ctrl fd */
int getFd() const;
bool getRotSessId(int& id) const;
utils::Dim getAspectRatio(const utils::Whf& whf) const;
utils::Dim getAspectRatio(const utils::Dim& dim) const;
@ -113,40 +88,14 @@ private:
/* Retrieve screen info from underlying mdp */
bool getScreenInfo(utils::ScreenInfo& info);
/* calls underlying mdp set info */
bool setInfo(const utils::PipeArgs& args);
/* given whf, update src */
void updateSource(RotatorBase* r,
const utils::PipeArgs& args,
utils::ScreenInfo& info);
// mdp ctrl struct(info e.g.)
MdpCtrl mMdp;
// Rotator
RotatorBase* mRot;
/* Cache cropped value */
utils::Dim mCrop;
/* Screen info */
utils::ScreenInfo mInfo;
/* orientation cache FIXME */
utils::eTransform mOrient;
/* Cache last known whfz.
* That would help us compare to a previous
* source that was submitted */
utils::Whf mOvBufInfo;
};
/*
* MDP = DataMdp, ROT = CtrlMdp usually since Rotator<>
* is instansiated with Ctrl data structure.
* */
class Data : utils::NoCopy {
public:
/* init, reset */
@ -155,44 +104,30 @@ public:
/* calls close */
~Data();
/* should open devices? or start()? */
bool open(uint32_t fbnum, RotatorBase* rot);
/* init fd etc */
bool init(uint32_t fbnum);
/* calls underlying mdp close */
bool close();
/* set the rotator */
void setRot(RotatorBase* rot);
/* set memory id in the mdp struct */
void setMemoryId(int id);
/* set overlay id in the mdp struct */
void setId(int id);
/* set overlay pipe id in the mdp struct */
void setPipeId(int id);
/* get overlay id in the mdp struct */
int getId() const;
int getPipeId() const;
/* queue buffer to the overlay */
bool queueBuffer(uint32_t offset);
bool queueBuffer(int fd, uint32_t offset);
/* wait for vsync to be done */
bool waitForVsync();
/* sump the state of the obj */
void dump() const;
private:
/* play wrapper */
bool play();
/* playWait wrapper */
bool playWait();
// mdp data struct
MdpData mMdp;
// Rotator
RotatorBase* mRot;
};
/* This class just creates a Ctrl Data pair to be used by a pipe.
@ -207,7 +142,7 @@ struct CtrlData {
//-------------Inlines-------------------------------
inline Ctrl::Ctrl() : mRot(0), mOrient(utils::OVERLAY_TRANSFORM_0) {
inline Ctrl::Ctrl() {
mMdp.reset();
}
@ -216,7 +151,6 @@ inline Ctrl::~Ctrl() {
}
inline bool Ctrl::close() {
// do not close the rotator
if(!mMdp.close())
return false;
return true;
@ -238,70 +172,37 @@ inline bool Ctrl::getScreenInfo(utils::ScreenInfo& info) {
return true;
}
inline bool Ctrl::setInfo(const utils::PipeArgs& args)
{
// FIXME set flags, zorder and wait separtly
if(!mMdp.setInfo(mRot, args, mInfo)){
ALOGE("Ctrl failed to setInfo wait=%d mdpflags=%d "
"zorder=%d", args.wait, args.mdpFlags, args.zorder);
return false;
}
return true;
}
inline int Ctrl::getId() const {
// FIXME check channel up?
return mMdp.getId();
inline int Ctrl::getPipeId() const {
return mMdp.getPipeId();
}
inline int Ctrl::getFd() const {
// FIXME check channel up?
return mMdp.getFd();
}
inline bool Ctrl::getRotSessId(int& id) const {
// FIXME check channel up?
// should be -1 in case of no rot session active
id = mRot->getSessId();
return true;
}
inline utils::ScreenInfo Ctrl::getScreenInfo() const {
return mInfo;
}
inline utils::Dim Ctrl::getCrop() const {
return mCrop;
return mMdp.getSrcRectDim();
}
inline Data::Data() : mRot(0) {
inline Data::Data() {
mMdp.reset();
}
inline Data::~Data() { close(); }
inline void Data::setRot(RotatorBase* rot) { mRot = rot; }
inline void Data::setPipeId(int id) { mMdp.setPipeId(id); }
inline void Data::setMemoryId(int id) { mMdp.setMemoryId(id); }
inline int Data::getPipeId() const { return mMdp.getPipeId(); }
// really a reqid
inline void Data::setId(int id) { mMdp.setId(id); }
inline int Data::getId() const { return mMdp.getId(); }
inline bool Data::open(uint32_t fbnum,
RotatorBase* rot) {
if(!mMdp.open(fbnum)) {
ALOGE("Data cannot open mdp");
inline bool Data::init(uint32_t fbnum) {
if(!mMdp.init(fbnum)) {
ALOGE("Data cannot init mdp");
return false;
}
OVASSERT(rot, "rot is null");
mRot = rot;
// rotator should be already opened here
return true;
}
@ -313,49 +214,22 @@ inline bool Data::close() {
return true;
}
inline bool Data::queueBuffer(uint32_t offset) {
// FIXME asserts on state validity
mMdp.setOffset(offset);
mRot->setRotDataSrcMemId(mMdp.getMemoryId());
// will play if succeeded
if(!mRot->prepareQueueBuf(offset)) {
ALOGE("Data failed to prepareQueueBuf");
return false;
}
// Play can go either from mdp or rot
if(!this->play()){
ALOGE("Data error in MDP/ROT play");
return false;
}
return true;
inline bool Data::queueBuffer(int fd, uint32_t offset) {
return mMdp.play(fd, offset);
}
inline bool Data::waitForVsync() {
// Call mdp playWait
if(!this->playWait()){
ALOGE("Error in MDP playWait");
// Call mdp waitForVsync
if(!mMdp.waitForVsync()){
ALOGE("Error in MDP %s", __FUNCTION__);
return false;
}
return true;
}
inline bool Data::play() {
int fd = mMdp.getFd();
return mRot->enabled() ? mRot->play(fd) : mMdp.play();
}
inline bool Data::playWait() {
return mMdp.playWait();
}
inline void Data::dump() const {
ALOGE("== Dump Data MDP start ==");
mMdp.dump();
mRot->dump();
ALOGE("== Dump Data MDP end ==");
}

248
liboverlay/overlayImpl.h
View File

@ -33,8 +33,6 @@
#include "overlayUtils.h"
#include "overlayRotator.h"
// FIXME make int to be uint32 whenever possible
namespace overlay {
// Interface only. No member, no definiton (except ~ which can
@ -44,8 +42,8 @@ public:
/* empty dtor. can be =0 with cpp impl*/
virtual ~OverlayImplBase() {}
/* Open pipe/rot for one dest */
virtual bool openPipe(RotatorBase* rot, utils::eDest dest) = 0;
/* Init pipe/rot for one dest */
virtual bool initPipe(RotatorBase* rot, utils::eDest dest) = 0;
/* Close pipe/rot for all specified dest */
virtual bool closePipe(utils::eDest dest) = 0;
@ -53,12 +51,10 @@ public:
/* Copy specified pipe/rot from ov passed in (used by state machine only) */
virtual bool copyOvPipe(OverlayImplBase* ov, utils::eDest dest) = 0;
/* TODO open func customized for RGBx pipes */
/* Open all pipes
* To open just one pipe, use openPipe()
/* Init all pipes
* To init just one pipe, use initPipe()
* */
virtual bool open(RotatorBase* rot0,
virtual bool init(RotatorBase* rot0,
RotatorBase* rot1,
RotatorBase* rot2) = 0;
@ -72,12 +68,8 @@ public:
* */
virtual bool commit(utils::eDest dest = utils::OV_PIPE_ALL) = 0;
/* Queue buffer with offset*/
virtual bool queueBuffer(uint32_t offset,
utils::eDest dest = utils::OV_PIPE_ALL) = 0;
/* For RGBx pipes, dequeue buffer (that is fb chunk)*/
virtual bool dequeueBuffer(void*& buf,
/* Queue buffer with fd from an offset*/
virtual bool queueBuffer(int fd, uint32_t offset,
utils::eDest dest = utils::OV_PIPE_ALL) = 0;
/* Wait for vsync to be done on dest */
@ -93,16 +85,13 @@ public:
/* Set parameters - usually needed for Rotator, but would
* be passed down the stack as well */
virtual bool setParameter(const utils::Params& param,
virtual bool setTransform(const utils::eTransform& param,
utils::eDest dest = utils::OV_PIPE_ALL) = 0;
/* Set new source including orientation */
virtual bool setSource(const utils::PipeArgs[utils::MAX_PIPES],
utils::eDest dest = utils::OV_PIPE_ALL) = 0;
/* set memory id to the underlying pipes */
virtual void setMemoryId(int id, utils::eDest dest = utils::OV_PIPE_ALL) = 0;
/* Get the overlay pipe type */
virtual utils::eOverlayPipeType getOvPipeType(utils::eDest dest) const = 0;
@ -112,22 +101,21 @@ public:
class NullPipe {
public:
/* TODO open func customized for RGBx pipes */
bool open(RotatorBase* rot);
bool close();
bool start(const utils::PipeArgs& args);
bool commit();
bool setCrop(const utils::Dim& d);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setSource(const utils::PipeArgs& args);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool waitForVsync();
void setMemoryId(int id);
utils::PipeArgs getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
bool init(RotatorBase* rot) { return true; }
bool close() { return true; }
bool start(const utils::PipeArgs& args) { return true; }
bool commit() { return true; }
bool setCrop(const utils::Dim& d) { return true; }
bool setPosition(const utils::Dim& dim) { return true; }
bool setTransform(const utils::eTransform& param) { return true; }
bool setSource(const utils::PipeArgs& args) { return true; }
bool queueBuffer(int fd, uint32_t offset) { return true; }
bool waitForVsync() { return true; }
// NullPipe will return by val here as opposed to other Pipes.
utils::eOverlayPipeType getOvPipeType() const {
return utils::OV_PIPE_TYPE_NULL;
}
void dump() const {}
};
/*
@ -143,7 +131,6 @@ public:
/* ctor */
OverlayImpl();
OverlayImpl(P0* p0, P1* p1, P2* p2);
/*
* Comments of the below functions are the same as the one
@ -151,12 +138,11 @@ public:
* */
virtual ~OverlayImpl();
virtual bool openPipe(RotatorBase* rot, utils::eDest dest);
virtual bool initPipe(RotatorBase* rot, utils::eDest dest);
virtual bool closePipe(utils::eDest dest);
virtual bool copyOvPipe(OverlayImplBase* ov, utils::eDest dest);
/* TODO open func customized for RGBx pipes */
virtual bool open(RotatorBase* rot0,
virtual bool init(RotatorBase* rot0,
RotatorBase* rot1,
RotatorBase* rot2);
virtual bool close();
@ -165,16 +151,13 @@ public:
utils::eDest dest = utils::OV_PIPE_ALL);
virtual bool setPosition(const utils::Dim& dim,
utils::eDest dest = utils::OV_PIPE_ALL);
virtual bool setParameter(const utils::Params& param,
virtual bool setTransform(const utils::eTransform& param,
utils::eDest dest = utils::OV_PIPE_ALL);
virtual bool setSource(const utils::PipeArgs[utils::MAX_PIPES],
utils::eDest dest = utils::OV_PIPE_ALL);
virtual bool queueBuffer(uint32_t offset,
utils::eDest dest = utils::OV_PIPE_ALL);
virtual bool dequeueBuffer(void*& buf,
virtual bool queueBuffer(int fd, uint32_t offset,
utils::eDest dest = utils::OV_PIPE_ALL);
virtual bool waitForVsync(utils::eDest dest = utils::OV_PIPE1);
virtual void setMemoryId(int id, utils::eDest dest = utils::OV_PIPE_ALL);
virtual utils::eOverlayPipeType getOvPipeType(utils::eDest dest) const;
virtual void dump() const;
@ -197,74 +180,97 @@ private:
//-----------Inlines and Template defn---------------------------------
/**** OverlayImpl ****/
template <class P0, class P1, class P2>
OverlayImpl<P0, P1, P2>::OverlayImpl() :
mPipe0(new P0), mPipe1(new P1), mPipe2(new P2),
mPipe0(0), mPipe1(0), mPipe2(0),
mRotP0(0), mRotP1(0), mRotP2(0)
{}
template <class P0, class P1, class P2>
OverlayImpl<P0, P1, P2>::OverlayImpl(P0* p0, P1* p1, P2* p2) :
mPipe0(p0), mPipe1(p1), mPipe2(p2),
mRotP0(0), mRotP1(0), mRotP2(0)
{}
{
//Do not create a pipe here.
//Either initPipe can create a pipe OR
//copyOvPipe can assign a pipe.
}
template <class P0, class P1, class P2>
OverlayImpl<P0, P1, P2>::~OverlayImpl()
{
// no op in the meantime. needed to be clean
// since state machine will do delete. so we
// do not want to close/delete pipes here
//Do not delete pipes.
//closePipe will close and delete.
}
/* Open only one pipe/rot pair per call */
/* Init only one pipe/rot pair per call */
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::openPipe(RotatorBase* rot, utils::eDest dest)
bool OverlayImpl<P0, P1, P2>::initPipe(RotatorBase* rot, utils::eDest dest)
{
OVASSERT(rot, "%s: OverlayImpl rot is null", __FUNCTION__);
OVASSERT(utils::isValidDest(dest), "%s: OverlayImpl invalid dest=%d",
__FUNCTION__, dest);
// Need to down case rotator to mdp one.
// we assume p0/p1/p2/px all use the _same_ underlying mdp structure.
// FIXME STATIC_ASSERT here
bool ret = true;
if (utils::OV_PIPE0 & dest) {
OVASSERT(mPipe0, "%s: OverlayImpl pipe0 is null", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "Open pipe0");
ret = mPipe0->open(rot);
ALOGE_IF(DEBUG_OVERLAY, "init pipe0");
mRotP0 = rot;
ret = mRotP0->init();
if(!ret) {
ALOGE("%s: OverlayImpl pipe0 failed to open", __FUNCTION__);
ALOGE("%s: OverlayImpl rot0 failed to init", __FUNCTION__);
return false;
}
mPipe0 = new P0();
OVASSERT(mPipe0, "%s: OverlayImpl pipe0 is null", __FUNCTION__);
ret = mPipe0->init(rot);
if(!ret) {
ALOGE("%s: OverlayImpl pipe0 failed to init", __FUNCTION__);
return false;
}
return ret;
}
if (utils::OV_PIPE1 & dest) {
OVASSERT(mPipe1, "%s: OverlayImpl pipe1 is null", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "Open pipe1");
ret = mPipe1->open(rot);
ALOGE_IF(DEBUG_OVERLAY, "init pipe1");
mRotP1 = rot;
ret = mRotP1->init();
if(!ret) {
ALOGE("%s: OverlayImpl pipe1 failed to open", __FUNCTION__);
ALOGE("%s: OverlayImpl rot1 failed to init", __FUNCTION__);
return false;
}
mPipe1 = new P1();
OVASSERT(mPipe1, "%s: OverlayImpl pipe1 is null", __FUNCTION__);
ret = mPipe1->init(rot);
if(!ret) {
ALOGE("%s: OverlayImpl pipe1 failed to init", __FUNCTION__);
return false;
}
return ret;
}
if (utils::OV_PIPE2 & dest) {
OVASSERT(mPipe2, "%s: OverlayImpl pipe2 is null", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "Open pipe2");
ret = mPipe2->open(rot);
ALOGE_IF(DEBUG_OVERLAY, "init pipe2");
mRotP2 = rot;
ret = mRotP2->init();
if(!ret) {
ALOGE("%s: OverlayImpl pipe2 failed to open", __FUNCTION__);
ALOGE("%s: OverlayImpl rot2 failed to init", __FUNCTION__);
return false;
}
mPipe2 = new P2();
OVASSERT(mPipe2, "%s: OverlayImpl pipe2 is null", __FUNCTION__);
ret = mPipe2->init(rot);
if(!ret) {
ALOGE("%s: OverlayImpl pipe2 failed to init", __FUNCTION__);
return false;
}
return ret;
}
@ -356,44 +362,48 @@ bool OverlayImpl<P0, P1, P2>::copyOvPipe(OverlayImplBase* ov,
if (utils::OV_PIPE0 & dest) {
mPipe0 = ovimpl->mPipe0;
mRotP0 = ovimpl->mRotP0;
ovimpl->mPipe0 = 0;
ovimpl->mRotP0 = 0;
}
if (utils::OV_PIPE1 & dest) {
mPipe1 = ovimpl->mPipe1;
mRotP1 = ovimpl->mRotP1;
ovimpl->mPipe1 = 0;
ovimpl->mRotP1 = 0;
}
if (utils::OV_PIPE2 & dest) {
mPipe2 = ovimpl->mPipe2;
mRotP2 = ovimpl->mRotP2;
ovimpl->mPipe2 = 0;
ovimpl->mRotP2 = 0;
}
return true;
}
/* TODO open func customized for RGBx pipes */
/* Open all pipes/rot */
/* Init all pipes/rot */
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::open(RotatorBase* rot0,
bool OverlayImpl<P0, P1, P2>::init(RotatorBase* rot0,
RotatorBase* rot1,
RotatorBase* rot2)
{
if (!this->openPipe(rot0, utils::OV_PIPE0)) {
if (!this->initPipe(rot0, utils::OV_PIPE0)) {
if (!this->close()) {
ALOGE("%s: failed to close at least one pipe", __FUNCTION__);
}
return false;
}
if (!this->openPipe(rot1, utils::OV_PIPE1)) {
if (!this->initPipe(rot1, utils::OV_PIPE1)) {
if (!this->close()) {
ALOGE("%s: failed to close at least one pipe", __FUNCTION__);
}
return false;
}
if (!this->openPipe(rot2, utils::OV_PIPE2)) {
if (!this->initPipe(rot2, utils::OV_PIPE2)) {
if (!this->close()) {
ALOGE("%s: failed to close at least one pipe", __FUNCTION__);
}
@ -509,7 +519,7 @@ bool OverlayImpl<P0, P1, P2>::setPosition(const utils::Dim& d,
}
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::setParameter(const utils::Params& param,
bool OverlayImpl<P0, P1, P2>::setTransform(const utils::eTransform& param,
utils::eDest dest)
{
OVASSERT(mPipe0 && mPipe1 && mPipe2,
@ -517,21 +527,21 @@ bool OverlayImpl<P0, P1, P2>::setParameter(const utils::Params& param,
__FUNCTION__, mPipe0, mPipe1, mPipe2);
if (utils::OV_PIPE0 & dest) {
if(!mPipe0->setParameter(param)) {
if(!mPipe0->setTransform(param)) {
ALOGE("OverlayImpl p0 failed to setparam");
return false;
}
}
if (utils::OV_PIPE1 & dest) {
if(!mPipe1->setParameter(param)) {
if(!mPipe1->setTransform(param)) {
ALOGE("OverlayImpl p1 failed to setparam");
return false;
}
}
if (utils::OV_PIPE2 & dest) {
if(!mPipe2->setParameter(param)) {
if(!mPipe2->setTransform(param)) {
ALOGE("OverlayImpl p2 failed to setparam");
return false;
}
@ -541,7 +551,8 @@ bool OverlayImpl<P0, P1, P2>::setParameter(const utils::Params& param,
}
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::setSource(const utils::PipeArgs args[utils::MAX_PIPES],
bool OverlayImpl<P0, P1, P2>::setSource(
const utils::PipeArgs args[utils::MAX_PIPES],
utils::eDest dest)
{
OVASSERT(mPipe0 && mPipe1 && mPipe2,
@ -573,28 +584,29 @@ bool OverlayImpl<P0, P1, P2>::setSource(const utils::PipeArgs args[utils::MAX_PI
}
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::queueBuffer(uint32_t offset, utils::eDest dest)
bool OverlayImpl<P0, P1, P2>::queueBuffer(int fd, uint32_t offset,
utils::eDest dest)
{
OVASSERT(mPipe0 && mPipe1 && mPipe2,
"%s: Pipes are null p0=%p p1=%p p2=%p",
__FUNCTION__, mPipe0, mPipe1, mPipe2);
if (utils::OV_PIPE0 & dest) {
if(!mPipe0->queueBuffer(offset)) {
if(!mPipe0->queueBuffer(fd, offset)) {
ALOGE("OverlayImpl p0 failed to queueBuffer");
return false;
}
}
if (utils::OV_PIPE1 & dest) {
if(!mPipe1->queueBuffer(offset)) {
if(!mPipe1->queueBuffer(fd, offset)) {
ALOGE("OverlayImpl p1 failed to queueBuffer");
return false;
}
}
if (utils::OV_PIPE2 & dest) {
if(!mPipe2->queueBuffer(offset)) {
if(!mPipe2->queueBuffer(fd, offset)) {
ALOGE("OverlayImpl p2 failed to queueBuffer");
return false;
}
@ -603,37 +615,6 @@ bool OverlayImpl<P0, P1, P2>::queueBuffer(uint32_t offset, utils::eDest dest)
return true;
}
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::dequeueBuffer(void*& buf, utils::eDest dest)
{
OVASSERT(mPipe0 && mPipe1 && mPipe2,
"%s: Pipes are null p0=%p p1=%p p2=%p",
__FUNCTION__, mPipe0, mPipe1, mPipe2);
if (utils::OV_PIPE0 & dest) {
if(!mPipe0->dequeueBuffer(buf)) {
ALOGE("OverlayImpl p0 failed to dequeueBuffer");
return false;
}
}
if (utils::OV_PIPE1 & dest) {
if(!mPipe1->dequeueBuffer(buf)) {
ALOGE("OverlayImpl p1 failed to dequeueBuffer");
return false;
}
}
if (utils::OV_PIPE2 & dest) {
if(!mPipe2->dequeueBuffer(buf)) {
ALOGE("OverlayImpl p2 failed to dequeueBuffer");
return false;
}
}
return true;
}
template <class P0, class P1, class P2>
bool OverlayImpl<P0, P1, P2>::waitForVsync(utils::eDest dest)
{
@ -666,27 +647,8 @@ bool OverlayImpl<P0, P1, P2>::waitForVsync(utils::eDest dest)
}
template <class P0, class P1, class P2>
void OverlayImpl<P0, P1, P2>::setMemoryId(int id, utils::eDest dest)
{
OVASSERT(mPipe0 && mPipe1 && mPipe2,
"%s: Pipes are null p0=%p p1=%p p2=%p",
__FUNCTION__, mPipe0, mPipe1, mPipe2);
if (utils::OV_PIPE0 & dest) {
mPipe0->setMemoryId(id);
}
if (utils::OV_PIPE1 & dest) {
mPipe1->setMemoryId(id);
}
if (utils::OV_PIPE2 & dest) {
mPipe2->setMemoryId(id);
}
}
template <class P0, class P1, class P2>
utils::eOverlayPipeType OverlayImpl<P0, P1, P2>::getOvPipeType(utils::eDest dest) const
utils::eOverlayPipeType OverlayImpl<P0, P1, P2>::getOvPipeType(
utils::eDest dest) const
{
OVASSERT(utils::isValidDest(dest), "%s: OverlayImpl invalid dest=%d",
__FUNCTION__, dest);

253
liboverlay/overlayMdp.cpp
View File

@ -23,11 +23,11 @@
namespace ovutils = overlay::utils;
namespace overlay {
bool MdpCtrl::open(uint32_t fbnum) {
// FD open
bool MdpCtrl::init(uint32_t fbnum) {
// FD init
if(!utils::openDev(mFd, fbnum,
Res::devTemplate, O_RDWR)){
ALOGE("Ctrl failed to open fbnum=%d", fbnum);
Res::fbPath, O_RDWR)){
ALOGE("Ctrl failed to init fbnum=%d", fbnum);
return false;
}
return true;
@ -36,12 +36,13 @@ bool MdpCtrl::open(uint32_t fbnum) {
void MdpCtrl::reset() {
utils::memset0(mOVInfo);
utils::memset0(mLkgo);
mOVInfo.id = -1;
mLkgo.id = -1;
mOVInfo.id = MSMFB_NEW_REQUEST;
mLkgo.id = MSMFB_NEW_REQUEST;
}
bool MdpCtrl::close() {
if(-1 == static_cast<int>(mOVInfo.id)) return true;
if(MSMFB_NEW_REQUEST == static_cast<int>(mOVInfo.id))
return true;
if(!mdp_wrapper::unsetOverlay(mFd.getFD(), mOVInfo.id)) {
ALOGE("MdpCtrl close error in unset");
return false;
@ -81,43 +82,114 @@ bool MdpCtrl::get() {
return true;
}
// that is the second part of original setParameter function
void MdpCtrl::setSrcFormat(const utils::Whf& whf) {
//By default mdp src format is the same as buffer's
mOVInfo.src.format = whf.format;
//If rotation is used and input formats are tiled then output of rotator is
//non-tiled.
// FIXME mRotInfo.enable = 1; for enable
if (getUserData()) { // if rotations enabled in MdpCtrl
if (whf.format == MDP_Y_CRCB_H2V2_TILE)
mOVInfo.src.format = MDP_Y_CRCB_H2V2;
else if (whf.format == MDP_Y_CBCR_H2V2_TILE)
mOVInfo.src.format = MDP_Y_CBCR_H2V2;
return;
//Adjust width, height, format if rotator is used.
void MdpCtrl::adjustSrcWhf(const bool& rotUsed) {
if(rotUsed) {
utils::Whf whf = getSrcWhf();
if(whf.format == MDP_Y_CRCB_H2V2_TILE ||
whf.format == MDP_Y_CBCR_H2V2_TILE) {
whf.w = utils::alignup(whf.w, 64);
whf.h = utils::alignup(whf.h, 32);
}
//For example: If original format is tiled, rotator outputs non-tiled,
//so update mdp's src fmt to that.
whf.format = utils::getRotOutFmt(whf.format);
setSrcWhf(whf);
}
}
bool MdpCtrl::set() {
if(!this->ovChanged()) {
return true; // nothing todo here.
}
if(!mdp_wrapper::setOverlay(mFd.getFD(), mOVInfo)) {
ALOGE("MdpCtrl failed to setOverlay, restoring last known "
"good ov info");
mdp_wrapper::dump("== Bad OVInfo is: ", mOVInfo);
mdp_wrapper::dump("== Last good known OVInfo is: ", mLkgo);
this->restore();
// FIXME, do we need to set the old one?
return false;
}
this->save();
return true;
}
bool MdpCtrl::setSource(const utils::PipeArgs& args) {
setSrcWhf(args.whf);
//TODO These are hardcoded. Can be moved out of setSource.
mOVInfo.alpha = 0xff;
mOVInfo.transp_mask = 0xffffffff;
//TODO These calls should ideally be a part of setPipeParams API
setFlags(args.mdpFlags);
setZ(args.zorder);
setWait(args.wait);
setIsFg(args.isFg);
return true;
}
bool MdpCtrl::setCrop(const utils::Dim& d) {
setSrcRectDim(d);
return true;
}
bool MdpCtrl::setTransform(const utils::eTransform& orient,
const bool& rotUsed) {
int rot = utils::getMdpOrient(orient);
setUserData(rot);
adjustSrcWhf(rotUsed);
setRotationFlags();
switch(static_cast<int>(orient)) {
case utils::OVERLAY_TRANSFORM_0:
case utils::OVERLAY_TRANSFORM_FLIP_H:
case utils::OVERLAY_TRANSFORM_FLIP_V:
case utils::OVERLAY_TRANSFORM_ROT_180:
//No calculations required
break;
case utils::OVERLAY_TRANSFORM_ROT_90:
case (utils::OVERLAY_TRANSFORM_ROT_90|utils::OVERLAY_TRANSFORM_FLIP_H):
case (utils::OVERLAY_TRANSFORM_ROT_90|utils::OVERLAY_TRANSFORM_FLIP_V):
overlayTransFlipRot90();
break;
case utils::OVERLAY_TRANSFORM_ROT_270:
overlayTransFlipRot270();
break;
default:
ALOGE("%s: Error due to unknown rot value", __FUNCTION__);
return false;
}
return true;
}
void MdpCtrl::overlayTransFlipRot90()
{
utils::Dim d = getSrcRectDim();
utils::Whf whf = getSrcWhf();
int tmp = d.x;
d.x = compute(whf.h,
d.y,
d.h);
d.y = tmp;
setSrcRectDim(d);
swapSrcWH();
swapSrcRectWH();
}
void MdpCtrl::overlayTransFlipRot270()
{
utils::Dim d = getSrcRectDim();
utils::Whf whf = getSrcWhf();
int tmp = d.y;
d.y = compute(whf.w,
d.x,
d.w);
d.x = tmp;
setSrcRectDim(d);
swapSrcWH();
swapSrcRectWH();
}
bool MdpCtrl::setPosition(const overlay::utils::Dim& d,
int fbw, int fbh)
{
@ -129,7 +201,7 @@ bool MdpCtrl::setPosition(const overlay::utils::Dim& d,
ovutils::Dim dim(d);
ovutils::Dim ovsrcdim = getSrcRectDim();
// Scaling of upto a max of 8 times supported
// Scaling of upto a max of 20 times supported
if(dim.w >(ovsrcdim.w * ovutils::HW_OV_MAGNIFICATION_LIMIT)){
dim.w = ovutils::HW_OV_MAGNIFICATION_LIMIT * ovsrcdim.w;
dim.x = (fbw - dim.w) / 2;
@ -139,135 +211,12 @@ bool MdpCtrl::setPosition(const overlay::utils::Dim& d,
dim.y = (fbh - dim.h) / 2;
}
//dim.even_out();
setDstRectDim(dim);
return true;
}
void MdpCtrl::updateSource(RotatorBase* r,
const utils::PipeArgs& args,
const utils::ScreenInfo& info) {
utils::Whf whf(args.whf);
mOVInfo.src.width = whf.w;
mOVInfo.src.height = whf.h;
mOVInfo.src_rect.x = 0;
mOVInfo.src_rect.y = 0;
mOVInfo.dst_rect.x = 0;
mOVInfo.dst_rect.y = 0;
mOVInfo.dst_rect.w = whf.w;
mOVInfo.dst_rect.h = whf.h;
mOVInfo.src.format = whf.format;
if(whf.format == MDP_Y_CRCB_H2V2_TILE ||
(whf.format == MDP_Y_CBCR_H2V2_TILE)) {
// passing by value, setInfo fills it and return by val
mOVInfo = r->setInfo(args, mOVInfo);
} else {
mOVInfo.src_rect.w = whf.w;
mOVInfo.src_rect.h = whf.h;
}
if (whf.w > info.mFBWidth)
mOVInfo.dst_rect.w = info.mFBWidth;
if (whf.h > info.mFBHeight)
mOVInfo.dst_rect.h = info.mFBHeight;
mSize = whf.size;
}
bool MdpCtrl::setInfo(RotatorBase* r,
const utils::PipeArgs& args,
const utils::ScreenInfo& info)
{
// new request
utils::Whf whf(args.whf);
mOVInfo.id = MSMFB_NEW_REQUEST;
updateSource(r, args, info);
setUserData(0);
mOVInfo.alpha = 0xff;
mOVInfo.transp_mask = 0xffffffff;
setZ(args.zorder);
setFlags(args.mdpFlags);
setWait(args.wait);
setIsFg(args.isFg);
mSize = whf.size;
return true;
}
bool MdpCtrl::setCrop(const utils::Dim& cdim) {
utils::Dim d(cdim);
const utils::Whf ovwhf = getSrcWhf();
int udata = getUserData();
switch(udata) {
case MDP_ROT_NOP:
break; // nothing to do here
case MDP_ROT_90:
case MDP_ROT_90 | MDP_FLIP_UD:
case MDP_ROT_90 | MDP_FLIP_LR:
{
if (ovwhf.w < (d.y + d.h)) {
ALOGE("MdpCtrl setCrop failed ROT 90 udata=%d",
udata);
d.dump();
this->dump();
return false;
}
uint32_t tmp = d.x;
d.x = ovwhf.w - (d.y + d.h);
d.y = tmp;
utils::swap(d.w, d.h);
}break;
case MDP_ROT_270:
{
if (ovwhf.h < (d.x + d.w)) {
ALOGE("MdpCtrl setCrop failed ROT 270 udata=%d",
udata);
d.dump();
this->dump();
return false;
}
uint32_t tmp = d.y;
d.y = ovwhf.h - (d.x + d.w);
d.x = tmp;
utils::swap(d.w, d.h);
}break;
case MDP_ROT_180:
{
if ((ovwhf.h < (d.y + d.h)) ||
(ovwhf.w < ( d.x + d.w))) {
ALOGE("MdpCtrl setCrop failed ROT 180 udata=%d",
udata);
d.dump();
this->dump();
return false;
}
d.x = ovwhf.w - (d.x + d.w);
d.y = ovwhf.h - (d.y + d.h);
}break;
default:
if(!(udata & (MDP_FLIP_UD | MDP_FLIP_LR))) {
ALOGE("MdpCtrl setCrop unknown rot %d", udata);
return false;
}
}
if(getSrcRectDim() == d) {
return true; // Nothing to do here
}
utils::normalizeCrop(d.x, d.w);
utils::normalizeCrop(d.y, d.h);
setSrcRectDim(d);
return true;
}
void MdpCtrl::dump() const {
ALOGE("== Dump MdpCtrl start ==");
ALOGE("size=%d", mSize);
mFd.dump();
mdp_wrapper::dump("mOVInfo", mOVInfo);
ALOGE("== Dump MdpCtrl end ==");

153
liboverlay/overlayMdp.h
View File

@ -22,12 +22,9 @@
#include "overlayUtils.h"
#include "mdpWrapper.h"
#include "overlayRotator.h"
namespace overlay{
class RotatorBase;
/*
* Mdp Ctrl holds corresponding fd and MDP related struct.
* It is simple wrapper to MDP services
@ -40,20 +37,20 @@ public:
/* dtor close */
~MdpCtrl();
/* Open underlying device using fbnum */
bool open(uint32_t fbnum);
/* init underlying device using fbnum */
bool init(uint32_t fbnum);
/* unset overlay, reset and close fd */
bool close();
/* reset and set ov id to -1*/
/* reset and set ov id to -1 / MSMFB_NEW_REQUEST */
void reset();
/* get orient / user_data[0] */
int getOrient() const;
/* returns session id */
int getId() const;
int getPipeId() const;
/* returns the fd associated to ctrl*/
int getFd() const;
@ -71,16 +68,6 @@ public:
/* set flags to mdp structure */
void setFlags(int f);
/* code taken from OverlayControlChannel::setOverlayInformation */
bool setInfo(RotatorBase* r,
const utils::PipeArgs& args,
const utils::ScreenInfo& info);
/* given whf, update src */
void updateSource(RotatorBase* r,
const utils::PipeArgs& args,
const utils::ScreenInfo& info);
/* set z order */
void setZ(utils::eZorder z);
@ -102,8 +89,8 @@ public:
/* set src whf */
void setSrcWhf(const utils::Whf& whf);
/* set source format based on rot info */
void setSrcFormat(const utils::Whf& whf);
/* adjust source width height format based on rot info */
void adjustSrcWhf(const bool& rotUsed);
/* swap src w/h*/
void swapSrcWH();
@ -128,7 +115,7 @@ public:
void setUserData(int v);
/* return true if current overlay is different
* than lask known good overlay */
* than last known good overlay */
bool ovChanged() const;
/* save mOVInfo to be last known good ov*/
@ -137,6 +124,9 @@ public:
/* restore last known good ov to be the current */
void restore();
/* Sets the source total width, height, format */
bool setSource(const utils::PipeArgs& pargs);
/*
* Sets ROI, the unpadded region, for source buffer.
* Should be called before a setPosition, for small clips.
@ -144,6 +134,8 @@ public:
*/
bool setCrop(const utils::Dim& d);
bool setTransform(const utils::eTransform& orient, const bool& rotUsed);
/* given a dim and w/h, set overlay dim */
bool setPosition(const utils::Dim& dim, int w, int h);
@ -152,8 +144,13 @@ public:
/* dump state of the object */
void dump() const;
private:
/* helper functions for overlayTransform */
void overlayTransFlipRot90();
void overlayTransFlipRot270();
/* last good known ov info */
mdp_overlay mLkgo;
@ -162,9 +159,6 @@ private:
/* FD for the mdp fbnum */
OvFD mFd;
/* cached size FIXME do we need it? */
uint32_t mSize;
};
@ -201,8 +195,8 @@ public:
/* dtor close*/
~MdpData();
/* open FD */
bool open(uint32_t fbnum);
/* init FD */
bool init(uint32_t fbnum);
/* memset0 the underlying mdp object */
void reset();
@ -210,29 +204,23 @@ public:
/* close fd, and reset */
bool close();
/* Set FD / memid */
void setMemoryId(int id);
/* set id of mdp data */
void setId(int id);
void setPipeId(int id);
/* return ses id of data */
int getId() const;
int getPipeId() const;
/* get underlying fd*/
int getFd() const;
/* get memory_id */
int getMemoryId() const;
/* set offset in underlying mdp obj */
void setOffset(uint32_t o);
int getSrcMemoryId() const;
/* calls wrapper play */
bool play();
bool play(int fd, uint32_t offset);
/* calls wrapper playWait */
bool playWait();
/* calls wrapper waitForVsync */
bool waitForVsync();
/* dump state of the object */
void dump() const;
@ -247,21 +235,22 @@ private:
//--------------Inlines---------------------------------
namespace utils {
inline bool openDev(OvFD& fd, int fb,
const char* const s,
int flags) {
return overlay::open(fd, fb, Res::devTemplate, O_RDWR);
}
inline bool openDev(OvFD& fd, int fbnum,
const char* const devpath,
int flags) {
return overlay::open(fd, fbnum, devpath, flags);
}
}
namespace {
// just a helper func for common operations x-(y+z)
int compute(uint32_t x, uint32_t y, uint32_t z) {
return x-(y+z);
}
}
template <class T>
inline void init(T& t) {
memset(&t, 0, sizeof(T));
}
///// MdpCtrl //////
inline MdpCtrl::MdpCtrl() : mSize(0) {
inline MdpCtrl::MdpCtrl() {
reset();
}
@ -273,7 +262,7 @@ inline int MdpCtrl::getOrient() const {
return getUserData();
}
inline int MdpCtrl::getId() const {
inline int MdpCtrl::getPipeId() const {
return mOVInfo.id;
}
@ -310,27 +299,25 @@ inline bool MdpCtrl::ovChanged() const {
}
inline void MdpCtrl::save() {
if(static_cast<ssize_t>(mOVInfo.id) == -1) {
if(static_cast<ssize_t>(mOVInfo.id) == MSMFB_NEW_REQUEST) {
ALOGE("MdpCtrl current ov has id -1, will not save");
// FIXME dump both?
return;
}
mLkgo = mOVInfo;
}
inline void MdpCtrl::restore() {
if(static_cast<ssize_t>(mLkgo.id) == -1) {
if(static_cast<ssize_t>(mLkgo.id) == MSMFB_NEW_REQUEST) {
ALOGE("MdpCtrl Lkgo ov has id -1, will not restore");
// FIXME dump both?
return;
}
mOVInfo = mLkgo;
}
inline overlay::utils::Whf MdpCtrl::getSrcWhf() const {
return utils::Whf(mOVInfo.src.width,
mOVInfo.src.height,
mOVInfo.src.format);
return utils::Whf( mOVInfo.src.width,
mOVInfo.src.height,
mOVInfo.src.format);
}
inline void MdpCtrl::setSrcWhf(const overlay::utils::Whf& whf) {
@ -340,10 +327,10 @@ inline void MdpCtrl::setSrcWhf(const overlay::utils::Whf& whf) {
}
inline overlay::utils::Dim MdpCtrl::getSrcRectDim() const {
return utils::Dim(mOVInfo.src_rect.x,
mOVInfo.src_rect.y,
mOVInfo.src_rect.w,
mOVInfo.src_rect.h);
return utils::Dim( mOVInfo.src_rect.x,
mOVInfo.src_rect.y,
mOVInfo.src_rect.w,
mOVInfo.src_rect.h);
}
inline void MdpCtrl::setSrcRectDim(const overlay::utils::Dim d) {
@ -354,10 +341,10 @@ inline void MdpCtrl::setSrcRectDim(const overlay::utils::Dim d) {
}
inline overlay::utils::Dim MdpCtrl::getDstRectDim() const {
return utils::Dim(mOVInfo.dst_rect.x,
mOVInfo.dst_rect.y,
mOVInfo.dst_rect.w,
mOVInfo.dst_rect.h);
return utils::Dim( mOVInfo.dst_rect.x,
mOVInfo.dst_rect.y,
mOVInfo.dst_rect.w,
mOVInfo.dst_rect.h);
}
inline void MdpCtrl::setDstRectDim(const overlay::utils::Dim d) {
@ -379,14 +366,15 @@ inline void MdpCtrl::setRotationFlags() {
mOVInfo.flags &= ~MDP_SOURCE_ROTATED_90;
}
inline void MdpCtrl::swapSrcWH() {
utils::swap(mOVInfo.src.width,
mOVInfo.src.height); }
mOVInfo.src.height);
}
inline void MdpCtrl::swapSrcRectWH() {
utils::swap(mOVInfo.src_rect.h,
mOVInfo.src_rect.w); }
utils::swap(mOVInfo.src_rect.w,
mOVInfo.src_rect.h);
}
/////// MdpCtrl3D //////
@ -434,10 +422,10 @@ inline MdpData::MdpData() { reset(); }
inline MdpData::~MdpData() { close(); }
inline bool MdpData::open(uint32_t fbnum) {
// FD open
if(!utils::openDev(mFd, fbnum, Res::devTemplate, O_RDWR)){
ALOGE("Ctrl failed to open fbnum=%d", fbnum);
inline bool MdpData::init(uint32_t fbnum) {
// FD init
if(!utils::openDev(mFd, fbnum, Res::fbPath, O_RDWR)){
ALOGE("Ctrl failed to init fbnum=%d", fbnum);
return false;
}
return true;
@ -457,28 +445,29 @@ inline bool MdpData::close() {
return true;
}
inline void MdpData::setMemoryId(int id) { mOvData.data.memory_id = id; }
inline int MdpData::getMemoryId() const { return mOvData.data.memory_id; }
inline int MdpData::getSrcMemoryId() const { return mOvData.data.memory_id; }
inline void MdpData::setId(int id) { mOvData.id = id; }
inline void MdpData::setPipeId(int id) { mOvData.id = id; }
inline int MdpData::getId() const { return mOvData.id; }
inline int MdpData::getPipeId() const { return mOvData.id; }
inline int MdpData::getFd() const { return mFd.getFD(); }
inline void MdpData::setOffset(uint32_t o) { mOvData.data.offset = o; }
inline bool MdpData::play() {
inline bool MdpData::play(int fd, uint32_t offset) {
mOvData.data.memory_id = fd;
mOvData.data.offset = offset;
if(!mdp_wrapper::play(mFd.getFD(), mOvData)){
ALOGE("MdpData failed to play");
dump();
return false;
}
return true;
}
inline bool MdpData::playWait() {
if(!mdp_wrapper::playWait(mFd.getFD(), mOvData)){
ALOGE("MdpData failed to playWait");
inline bool MdpData::waitForVsync() {
if(!mdp_wrapper::waitForVsync(mFd.getFD(), mOvData)){
ALOGE("%s failed", __FUNCTION__);
dump();
return false;
}
return true;

15
liboverlay/overlayMem.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@ -118,9 +118,7 @@ inline bool OvMem::open(uint32_t numbufs,
uint32_t bufSz, int flags)
{
alloc_data data;
//XXX: secure buffers and IOMMU heap
int allocFlags = GRALLOC_USAGE_PRIVATE_MM_HEAP |
GRALLOC_USAGE_PRIVATE_DO_NOT_MAP;
int allocFlags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP;
int err = 0;
OVASSERT(numbufs && bufSz, "numbufs=%d bufSz=%d", numbufs, bufSz);
@ -138,6 +136,7 @@ inline bool OvMem::open(uint32_t numbufs,
err = mAlloc->allocate(data, allocFlags, 0);
if (err != 0) {
ALOGE("OvMem: error allocating memory");
return false;
}
mFd = data.fd;
@ -159,6 +158,7 @@ inline bool OvMem::close()
ret = memalloc->free_buffer(mBaseAddr, mBufSz * mNumBuffers, 0, mFd);
if (ret != 0) {
ALOGE("OvMem: error freeing buffer");
return false;
}
mFd = -1;
@ -166,7 +166,7 @@ inline bool OvMem::close()
mAllocType = 0;
mBufSz = 0;
mNumBuffers = 0;
return ret;
return true;
}
inline bool OvMem::valid() const
@ -196,8 +196,9 @@ inline uint32_t OvMem::numBufs() const
inline void OvMem::dump() const
{
ALOGE("%s: fd=%d addr=%p type=%d bufsz=%u",
__FUNCTION__, mFd, mBaseAddr, mAllocType, mBufSz);
ALOGE("== Dump OvMem start ==");
ALOGE("fd=%d addr=%p type=%d bufsz=%u", mFd, mBaseAddr, mAllocType, mBufSz);
ALOGE("== Dump OvMem end ==");
}
} // overlay

392
liboverlay/overlayRotator.cpp
View File

@ -23,59 +23,87 @@ namespace ovutils = overlay::utils;
namespace overlay {
namespace utils {
inline mdp_overlay setInfoNullRot(const utils::PipeArgs& args,
const mdp_overlay& o)
{
mdp_overlay ov = o;
utils::Whf whf(args.whf);
utils::Dim d(utils::getSrcRectDim(ov));
d.w = whf.w - (utils::alignup(whf.w, 64) - whf.w);
d.h = whf.h - (utils::alignup(whf.h, 32) - whf.h);
utils::setSrcRectDim(ov, d);
return ov;
int IRotatorHw::getRotatorHwType() {
//TODO figure out based on ioctl
return TYPE_MDP;
}
inline mdp_overlay setInfoRot(const utils::PipeArgs& args,
const mdp_overlay& o)
{
/* If there are no orientation, then we use setInfoRot
* That is even if we are a real rotator object (not null)
* Note, that if args.rotFlags are ENABLED
* it means we would still like to have rot
* even though it is ROT_0 */
if(OVERLAY_TRANSFORM_0 == args.orientation &&
utils::ROT_FLAG_ENABLED != args.rotFlags) {
return setInfoNullRot(args, o);
bool RotMem::close() {
bool ret = true;
for(uint32_t i=0; i < RotMem::MAX_ROT_MEM; ++i) {
// skip current, and if valid, close
if(m[i].valid()) {
if(m[i].close() == false) {
ALOGE("%s error in closing rot mem %d", __FUNCTION__, i);
ret = false;
}
}
}
mdp_overlay ov = o;
utils::Whf whf(args.whf);
utils::Dim d(utils::getSrcRectDim(ov));
d.w = whf.w;
d.h = whf.h;
utils::Whf localwhf (utils::getSrcWhf(ov));
localwhf.w = utils::alignup(whf.w, 64);
localwhf.h = utils::alignup(whf.h, 32);
d.x = localwhf.w - whf.w;
d.y = localwhf.h - whf.h;
utils::setSrcRectDim(ov, d);
utils::setSrcWhf(ov, localwhf);
return ov;
return ret;
}
} // utils
bool MdpRot::open()
bool MdpRot::init()
{
if(!mFd.open(Res::rotPath, O_RDWR)){
ALOGE("MdpRot failed to open %s", Res::rotPath);
ALOGE("MdpRot failed to init %s", Res::rotPath);
return false;
}
return true;
}
void MdpRot::setSource(const overlay::utils::Whf& awhf) {
utils::Whf whf(awhf);
mRotImgInfo.src.format = whf.format;
if(whf.format == MDP_Y_CRCB_H2V2_TILE ||
whf.format == MDP_Y_CBCR_H2V2_TILE) {
whf.w = utils::alignup(awhf.w, 64);
whf.h = utils::alignup(awhf.h, 32);
}
mRotImgInfo.src.width = whf.w;
mRotImgInfo.src.height = whf.h;
mRotImgInfo.src_rect.w = whf.w;
mRotImgInfo.src_rect.h = whf.h;
mRotImgInfo.dst.width = whf.w;
mRotImgInfo.dst.height = whf.h;
mBufSize = awhf.size;
}
void MdpRot::setTransform(const utils::eTransform& rot, const bool& rotUsed)
{
int r = utils::getMdpOrient(rot);
ALOGE_IF(DEBUG_OVERLAY, "%s: r=%d", __FUNCTION__, r);
this->setRotations(r);
this->setDisable();
if(rotUsed) {
this->setEnable();
}
switch(static_cast<int>(rot)) {
case utils::OVERLAY_TRANSFORM_ROT_90:
case (utils::OVERLAY_TRANSFORM_ROT_90|utils::OVERLAY_TRANSFORM_FLIP_H):
case (utils::OVERLAY_TRANSFORM_ROT_90|utils::OVERLAY_TRANSFORM_FLIP_V):
case utils::OVERLAY_TRANSFORM_ROT_270:
utils::swap(mRotImgInfo.dst.width, mRotImgInfo.dst.height);
break;
default:
break;
}
}
bool MdpRot::commit() {
if(!overlay::mdp_wrapper::startRotator(mFd.getFD(), mRotImgInfo)) {
ALOGE("MdpRot commit failed");
dump();
return false;
}
mRotDataInfo.session_id = mRotImgInfo.session_id;
return true;
}
bool MdpRot::open_i(uint32_t numbufs, uint32_t bufsz)
{
OvMem mem;
@ -91,25 +119,12 @@ bool MdpRot::open_i(uint32_t numbufs, uint32_t bufsz)
OVASSERT(MAP_FAILED != mem.addr(), "MAP failed");
OVASSERT(mem.getFD() != -1, "getFd is -1");
mData.data.memory_id = mem.getFD();
mRotDataInfo.dst.memory_id = mem.getFD();
mRotDataInfo.dst.offset = 0;
mMem.curr().m = mem;
return true;
}
bool MdpRot::RotMem::close() {
bool ret = true;
for(uint32_t i=0; i < RotMem::MAX_ROT_MEM; ++i) {
// skip current, and if valid, close
if(m[i].valid() && (m[i].close() != 0)) {
ALOGE("%s error in closing prev rot mem %d", __FUNCTION__, i);
ret = false;
}
}
return ret;
}
bool MdpRot::close() {
bool success = true;
if(mFd.valid() && (getSessId() > 0)) {
@ -131,300 +146,77 @@ bool MdpRot::close() {
return success;
}
bool MdpRot::unmapNonCurrent() {
bool ret = true;
for(uint32_t i=0; i < RotMem::MAX_ROT_MEM; ++i) {
// skip current, and if valid, close
if(i != mMem._curr % RotMem::MAX_ROT_MEM &&
mMem.m[i].valid() &&
!mMem.m[i].close()) {
ALOGE("%s error in closing prev rot mem %d", __FUNCTION__, i);
ret = false;
}
}
return ret;
}
bool MdpRot::remap(uint32_t numbufs,
const utils::PipeArgs& args) {
bool MdpRot::remap(uint32_t numbufs) {
// if current size changed, remap
if(args.whf.size == mMem.curr().size()) {
ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, args.whf.size);
return true;
}
// remap only if we have orientation.
// If rotFlags are ENABLED, it means we need rotation bufs
// even when orientation is 0
if(utils::OVERLAY_TRANSFORM_0 == args.orientation &&
utils::ROT_FLAG_ENABLED != args.rotFlags) {
ALOGE_IF(DEBUG_OVERLAY, "%s: orientation=%d, rotFlags=%d",
__FUNCTION__, args.orientation, args.rotFlags);
if(mBufSize == mMem.curr().size()) {
ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, mBufSize);
return true;
}
ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__);
OVASSERT(!mMem.prev().valid(), "Prev should not be valid");
// remap and have the current to be the new one.
// ++mMem will make curr to be prev, and prev will be curr
++mMem;
if(!open_i(numbufs, args.whf.size)) {
if(!open_i(numbufs, mBufSize)) {
ALOGE("%s Error could not open", __FUNCTION__);
return false;
}
OVASSERT(numbufs <= ROT_MAX_BUF_OFFSET,
"Numbufs %d > ROT_MAX_BUF_OFFSET", numbufs);
for (uint32_t i = 0; i < numbufs; ++i) {
mMem.curr().mRotOffset[i] = i * args.whf.size;
mMem.curr().mRotOffset[i] = i * mBufSize;
}
return true;
}
bool MdpRot::start() {
if(!overlay::mdp_wrapper::startRotator(mFd.getFD(), mRotImgInfo)) {
ALOGE("MdpRot start failed");
this->dump();
return false;
}
mRotDataInfo.session_id = mRotImgInfo.session_id;
return true;
}
void MdpRot::reset() {
ovutils::memset0(mRotImgInfo);
ovutils::memset0(mRotDataInfo);
ovutils::memset0(mData);
ovutils::memset0(mMem.curr().mRotOffset);
ovutils::memset0(mMem.prev().mRotOffset);
mMem.curr().mCurrOffset = 0;
mMem.prev().mCurrOffset = 0;
isSrcFB = false;
mBufSize = 0;
}
bool MdpRot::prepareQueueBuf(uint32_t offset) {
// FIXME if it fails, what happens to the above current item?
bool MdpRot::queueBuffer(int fd, uint32_t offset) {
if(enabled()) {
OVASSERT(mMem.curr().m.numBufs(),
"prepareQueueBuf numbufs is 0");
// If the rotator source is FB
if(isSrcFB) {
mRotDataInfo.src.flags |= MDP_MEMORY_ID_TYPE_FB;
}
mRotDataInfo.src.memory_id = fd;
mRotDataInfo.src.offset = offset;
remap(RotMem::Mem::ROT_NUM_BUFS);
OVASSERT(mMem.curr().m.numBufs(),
"queueBuffer numbufs is 0");
mRotDataInfo.dst.offset =
mMem.curr().mRotOffset[mMem.curr().mCurrOffset];
mMem.curr().mCurrOffset =
(mMem.curr().mCurrOffset + 1) % mMem.curr().m.numBufs();
if(!overlay::mdp_wrapper::rotate(mFd.getFD(), mRotDataInfo)) {
ALOGE("MdpRot failed rotate");
dump();
return false;
}
mData.data.offset = mRotDataInfo.dst.offset;
}
return true;
}
bool MdpRot::play(int fd) {
if(!overlay::mdp_wrapper::play(fd, mData)) {
ALOGE("MdpRot failed to play with fd=%d", fd);
return false;
}
// if the prev mem is valid, we need to close
if(mMem.prev().valid()) {
// FIXME FIXME FIXME if no wait for vsync the above
// play will return immediatly and might cause
// tearing when prev.close is called.
if(!mMem.prev().close()) {
ALOGE("%s error in closing prev rot mem", __FUNCTION__);
// if the prev mem is valid, we need to close
if(mMem.prev().valid()) {
// FIXME if no wait for vsync the above
// play will return immediatly and might cause
// tearing when prev.close is called.
if(!mMem.prev().close()) {
ALOGE("%s error in closing prev rot mem", __FUNCTION__);
return false;
}
}
}
return true;
}
///// Null Rot ////
mdp_overlay NullRotator::setInfo(
const utils::PipeArgs& args,
const mdp_overlay& o) {
return utils::setInfoNullRot(args, o);
}
///// Rotator ////
mdp_overlay Rotator::setInfo(
const utils::PipeArgs& args,
const mdp_overlay& o)
{
return utils::setInfoRot(args, o);
}
bool Rotator::overlayTransform(MdpCtrl& mdp,
utils::eTransform& rot)
{
ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, rot);
switch(int(rot)) {
case 0:
case HAL_TRANSFORM_FLIP_H:
case HAL_TRANSFORM_FLIP_V:
overlayTransFlipHV(mdp, rot);
break;
case HAL_TRANSFORM_ROT_90:
case (HAL_TRANSFORM_ROT_90|HAL_TRANSFORM_FLIP_H):
case (HAL_TRANSFORM_ROT_90|HAL_TRANSFORM_FLIP_V):
overlayTransFlipRot90(mdp, rot);
break;
case HAL_TRANSFORM_ROT_180:
overlayTransFlipRot180(mdp);
break;
case HAL_TRANSFORM_ROT_270:
overlayTransFlipRot270(mdp);
break;
default:
ALOGE("%s: Error due to unknown rot value %d", __FUNCTION__, rot);
return false;
}
/* everything below is rotation related */
int r = utils::getMdpOrient(rot);
ALOGE_IF(DEBUG_OVERLAY, "%s: r=%d", __FUNCTION__, r);
if (r == -1) {
ALOGE("Ctrl setParameter rot it -1");
return false;
}
// Need to have both in sync
mdp.setUserData(r);
this->setRotations(r);
this->setDisable();
if(r) {
this->setEnable();
}
/* set src format using rotation info
* e.g. (12-->5 in case of rotation) */
mdp.setSrcFormat(this->getSrcWhf());
// based on 90/270 set flags
mdp.setRotationFlags();
return true;
}
void Rotator::overlayTransFlipHV(MdpCtrl& mdp,
utils::eTransform& rot)
{
int val = mdp.getUserData();
ALOGE_IF(DEBUG_OVERLAY, "%s: prev=%d", __FUNCTION__, val);
utils::Dim d = mdp.getSrcRectDim();
utils::Whf whf = mdp.getSrcWhf();
if (val == MDP_ROT_90) {
int tmp = d.y;
d.y = compute(whf.w,
d.x,
d.w);
d.x = tmp;
mdp.setSrcRectDim(d);
utils::swapOVRotWidthHeight(mRot, mdp);
}
else if (val == MDP_ROT_270) {
int tmp = d.x;
d.x = compute(whf.h,
d.y,
d.h);
d.y = tmp;
mdp.setSrcRectDim(d);
utils::swapOVRotWidthHeight(mRot, mdp);
}
}
void Rotator::overlayTransFlipRot90(MdpCtrl& mdp,
utils::eTransform& rot)
{
int val = mdp.getUserData();
ALOGE_IF(DEBUG_OVERLAY, "%s: prev=%d", __FUNCTION__, val);
utils::Dim d = mdp.getSrcRectDim();
utils::Whf whf = mdp.getSrcWhf();
if (val == MDP_ROT_270) {
d.x = compute(whf.w,
d.x,
d.w);
d.y = compute(whf.h,
d.y,
d.h);
}
else if (val == MDP_ROT_NOP || val == MDP_ROT_180) {
int tmp = d.x;
d.x = compute(whf.h,
d.y,
d.h);
d.y = tmp;
mdp.setSrcRectDim(d);
utils::swapOVRotWidthHeight(mRot, mdp);
}
}
void Rotator::overlayTransFlipRot180(MdpCtrl& mdp)
{
int val = mdp.getUserData();
ALOGE_IF(DEBUG_OVERLAY, "%s: prev=%d", __FUNCTION__, val);
utils::Dim d = mdp.getSrcRectDim();
utils::Whf whf = mdp.getSrcWhf();
if (val == MDP_ROT_270) {
int tmp = d.y;
d.y = compute(whf.w,
d.x,
d.w);
d.x = tmp;
mdp.setSrcRectDim(d);
utils::swapOVRotWidthHeight(mRot, mdp);
}
else if (val == MDP_ROT_90) {
int tmp = d.x;
d.x = compute(whf.h,
d.y,
d.h);
d.y = tmp;
mdp.setSrcRectDim(d);
utils::swapOVRotWidthHeight(mRot, mdp);
}
}
void Rotator::overlayTransFlipRot270(MdpCtrl& mdp)
{
int val = mdp.getUserData();
ALOGE_IF(DEBUG_OVERLAY, "%s: prev=%d", __FUNCTION__, val);
utils::Dim d = mdp.getSrcRectDim();
utils::Whf whf = mdp.getSrcWhf();
if (val == MDP_ROT_90) {
d.y = compute(whf.h,
d.y,
d.h);
d.x = compute(whf.w,
d.x,
d.w);
}
else if (val == MDP_ROT_NOP || val == MDP_ROT_180) {
int tmp = d.y;
d.y = compute(whf.w,
d.x,
d.w);
d.x = tmp;
mdp.setSrcRectDim(d);
utils::swapOVRotWidthHeight(mRot, mdp);
}
}
void MdpRot::dump() const {
ALOGE("== Dump MdpRot start ==");
mFd.dump();
mMem.curr().m.dump();
mdp_wrapper::dump("mRotImgInfo", mRotImgInfo);
mdp_wrapper::dump("mRotDataInfo", mRotDataInfo);
mdp_wrapper::dump("mData", mData);
ALOGE("== Dump MdpRot end ==");
}
}

711
liboverlay/overlayRotator.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@ -27,8 +27,8 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef OVERLAY_ROTATOR_H
#define OVERLAY_ROTATOR_H
#ifndef OVERlAY_ROTATOR_H
#define OVERlAY_ROTATOR_H
#include <stdlib.h>
@ -37,158 +37,107 @@
#include "overlayMem.h"
namespace overlay {
class MdpCtrl;
class IRotatorHw;
/*
* MDP rot holds MDP's rotation related structures.
*
* */
class MdpRot {
public:
/* ctor */
explicit MdpRot();
/* open fd for rotator. map bufs is defered */
bool open();
/* remap rot buffers */
bool remap(uint32_t numbufs, const utils::PipeArgs& args);
/* Unmap everything that is not current */
bool unmapNonCurrent();
/* close fd, mem */
bool close();
/* reset underlying data, basically memset 0 */
void reset();
/* calls underlying wrappers to start rotator */
bool start();
/* start underlying but use given whf and flags */
bool start(const utils::PipeArgs& args);
/* start underlying but use given whf and flags.
* Has the ability to parameterize the dst fmt */
template <int ROT_OUT_FMT>
bool start(const utils::PipeArgs& args);
/* assign memory id to mdp structure */
void setDataMemId(int fd);
void setRotDataSrcMemId(int fd);
/* Mark src as FB (non-ION) */
void setSrcFB(bool);
/* get dst (for offset and memory id) non-virt */
int getDstMemId() const;
uint32_t getDstOffset() const;
/* set enable/disable flag */
void setEnable();
void setDisable();
bool enabled() const;
/* set rotator flag*/
void setRotations(uint32_t r);
/* set the req data id in mData */
void setDataReqId(int id);
/* swap rot info dst w/h */
void swapDstWH();
/* returns a copy of src whf */
utils::Whf getSrcWhf() const;
/* setup rotator data before queue buf calls
* call play if rotate call succeed. return false if failed */
bool prepareQueueBuf(uint32_t offset);
/* call play on mdp*/
bool play(int fd);
/* set src whf */
void setSrcWhf(const utils::Whf& whf);
/* returns rotator session id */
int getSessId() const;
/* dump the state of the object */
void dump() const;
private:
bool open_i(uint32_t numbufs, uint32_t bufsz);
/* max buf no for offset */
enum { ROT_MAX_BUF_OFFSET = 2 };
/* rot info*/
msm_rotator_img_info mRotImgInfo;
/* rot data */
msm_rotator_data_info mRotDataInfo;
/* data needed for rotator */
msmfb_overlay_data mData;
/* rotator fd */
OvFD mFd;
/* Array of memory map for rotator
* The array enable us to change rot buffers/mapping
* on the fly*/
struct RotMem {
enum {MAX_ROT_MEM = 2};
struct Mem {
Mem() : mCurrOffset(0) {utils::memset0(mRotOffset); }
bool valid() { return m.valid(); }
bool close() { return m.close(); }
uint32_t size() const { return m.bufSz(); }
/* rotator data info dst offset */
uint32_t mRotOffset[ROT_MAX_BUF_OFFSET];
/* current offset slot from mRotOffset */
uint32_t mCurrOffset;
OvMem m;
};
RotMem() : _curr(0) {}
Mem& curr() { return m[_curr % MAX_ROT_MEM]; }
const Mem& curr() const { return m[_curr % MAX_ROT_MEM]; }
Mem& prev() { return m[(_curr+1) % MAX_ROT_MEM]; }
RotMem& operator++() { ++_curr; return *this; }
bool close();
uint32_t _curr;
Mem m[MAX_ROT_MEM];
} mMem;
bool isSrcFB;
};
/*
* RotatorBase. No memebers, just interface.
* ~ can also be =0 with empty impl in cpp.
* RotatorBase. No members, just interface.
* can also be =0 with empty impl in cpp.
* */
class RotatorBase {
public:
/* Most of the below are No op funcs for RotatorBase */
virtual ~RotatorBase() {}
virtual bool open() = 0;
virtual bool remap(uint32_t numbufs, const utils::PipeArgs& args) = 0;
virtual bool init() = 0;
virtual bool close() = 0;
virtual bool start(const utils::PipeArgs& args) = 0;
virtual bool start() = 0;
virtual mdp_overlay setInfo(const utils::PipeArgs& args,
const mdp_overlay& o) = 0;
virtual bool overlayTransform(MdpCtrl& mdp,
utils::eTransform& rot) = 0;
virtual void setSrcWhf(const utils::Whf& wfh) = 0;
virtual utils::Whf getSrcWhf() const = 0;
virtual void setRotations(uint32_t r) = 0;
virtual void setDataReqId(int id) = 0;
virtual bool prepareQueueBuf(uint32_t offset) = 0;
virtual bool play(int fd) = 0;
virtual void setSource(const utils::Whf& wfh) = 0;
virtual void setTransform(const utils::eTransform& rot,
const bool& rotUsed) = 0;
virtual bool commit() = 0;
virtual bool queueBuffer(int fd, uint32_t offset) = 0;
virtual void setEnable() = 0;
virtual void setDisable() = 0;
virtual bool enabled() const = 0;
virtual void setDataMemId(int fd) = 0;
virtual void setRotDataSrcMemId(int fd) = 0;
virtual void setRotations(uint32_t r) = 0;
virtual void setSrcFB(bool) = 0;
virtual bool enabled() const = 0;
virtual int getSessId() const = 0;
virtual int getDstMemId() const = 0;
virtual uint32_t getDstOffset() const = 0;
virtual void dump() const = 0;
protected:
//Hardware specific rotator impl.
IRotatorHw *mRot;
};
/*
* Rotator Hw Interface. Any hardware specific implementation should inherit
* from this.
*/
class IRotatorHw {
public:
/* Most of the below are No op funcs for RotatorBase */
virtual ~IRotatorHw() {}
/* init fd for rotator. map bufs is defered */
virtual bool init() = 0;
/* close fd, mem */
virtual bool close() = 0;
/* set src */
virtual void setSource(const utils::Whf& wfh) = 0;
/* Set rotation and calculate */
virtual void setTransform(const utils::eTransform& rot,
const bool& rotUsed) = 0;
/* calls underlying wrappers to start rotator */
virtual bool commit() = 0;
/* Lazy buffer allocation. queue buffer */
virtual bool queueBuffer(int fd, uint32_t offset) = 0;
/* set enable/disable flag */
virtual void setEnable() = 0;
virtual void setDisable() = 0;
/* set rotator flag*/
virtual void setRotations(uint32_t r) = 0;
/* Mark src as FB (non-ION) */
virtual void setSrcFB(bool) = 0;
/* Retusn true if rotator enabled */
virtual bool enabled() const = 0;
/* returns rotator session id */
virtual int getSessId() const = 0;
/* get dst (for offset and memory id) non-virt */
virtual int getDstMemId() const = 0;
virtual uint32_t getDstOffset() const = 0;
/* dump the state of the object */
virtual void dump() const = 0;
enum { TYPE_MDP, TYPE_MDSS };
/*Returns rotator h/w type */
static int getRotatorHwType();
};
/*
* Actual Rotator impl.
* */
class Rotator : public RotatorBase
{
public:
explicit Rotator();
virtual ~Rotator();
virtual bool init();
virtual bool close();
virtual void setSource(const utils::Whf& wfh);
virtual void setTransform(const utils::eTransform& rot,
const bool& rotUsed);
virtual bool commit();
virtual void setRotations(uint32_t r);
virtual void setSrcFB(bool);
virtual int getDstMemId() const;
virtual uint32_t getDstOffset() const;
virtual void setEnable();
virtual void setDisable();
virtual bool enabled () const;
virtual int getSessId() const;
virtual bool queueBuffer(int fd, uint32_t offset);
virtual void dump() const;
};
/*
@ -198,357 +147,209 @@ class NullRotator : public RotatorBase {
public:
/* Most of the below are No op funcs for RotatorBase */
virtual ~NullRotator();
virtual bool open();
virtual bool remap(uint32_t numbufs, const utils::PipeArgs& args);
virtual bool init();
virtual bool close();
virtual bool start(const utils::PipeArgs& args);
virtual bool start();
/* null rotator behavior should set info in a specific way */
virtual mdp_overlay setInfo(const utils::PipeArgs& args,
const mdp_overlay& o);
virtual bool overlayTransform(MdpCtrl& o,
utils::eTransform& rot);
virtual void setSrcWhf(const utils::Whf& wfh);
virtual utils::Whf getSrcWhf() const;
virtual void setSource(const utils::Whf& wfh);
virtual void setTransform(const utils::eTransform& rot,
const bool& rotUsed);
virtual bool commit();
virtual void setRotations(uint32_t r);
virtual void setDataReqId(int id);
virtual bool prepareQueueBuf(uint32_t offset);
virtual bool play(int fd);
virtual bool queueBuffer(int fd, uint32_t offset);
virtual void setEnable();
virtual void setDisable();
virtual bool enabled () const;
virtual void setDataMemId(int fd);
virtual void setRotDataSrcMemId(int fd);
virtual void setSrcFB(bool);
virtual int getSessId() const;
virtual int getDstMemId() const;
virtual uint32_t getDstOffset() const;
virtual void dump() const;
};
/*
Manages the case where new rotator memory needs to be
allocated, before previous is freed, due to resolution change etc. If we make
rotator memory to be always max size, irrespctive of source resolution then
we don't need this RotMem wrapper. The inner class is sufficient.
*/
struct RotMem {
// Max rotator memory allocations
enum { MAX_ROT_MEM = 2};
//Manages the rotator buffer offsets.
struct Mem {
Mem() : mCurrOffset(0) {utils::memset0(mRotOffset); }
bool valid() { return m.valid(); }
bool close() { return m.close(); }
uint32_t size() const { return m.bufSz(); }
// Max rotator buffers
enum { ROT_NUM_BUFS = 2 };
// rotator data info dst offset
uint32_t mRotOffset[ROT_NUM_BUFS];
// current offset slot from mRotOffset
uint32_t mCurrOffset;
OvMem m;
};
RotMem() : _curr(0) {}
Mem& curr() { return m[_curr % MAX_ROT_MEM]; }
const Mem& curr() const { return m[_curr % MAX_ROT_MEM]; }
Mem& prev() { return m[(_curr+1) % MAX_ROT_MEM]; }
RotMem& operator++() { ++_curr; return *this; }
bool close();
uint32_t _curr;
Mem m[MAX_ROT_MEM];
};
/*
* Rotator impl.
* MDP rot holds MDP's rotation related structures.
*
* */
class Rotator : public RotatorBase
{
class MdpRot : public IRotatorHw {
public:
/* construct underlying object */
explicit Rotator();
/* close underlying rot */
virtual ~Rotator();
/* calls underlying open */
virtual bool open();
/* remap rot buffers */
virtual bool remap(uint32_t numbufs, const utils::PipeArgs& args);
/* calls underlying close */
virtual bool close();
/* calls underlying start */
virtual bool start();
/* calls underlying start with whf and flags */
virtual bool start(const utils::PipeArgs& args);
/* non virtual - calls underlying start with whf and flags.
* Has the ability to parameterize the dst */
template <int ROT_OUT_FMT>
bool start(const utils::PipeArgs& args);
/* Unmap everything that is not current */
bool unmapNonCurrent();
/* set info using whf and given mdp */
virtual mdp_overlay setInfo(const utils::PipeArgs& args,
const mdp_overlay& o);
/* transform function for the MDP */
virtual bool overlayTransform(MdpCtrl& mdp,
utils::eTransform& rot);
/* set src whf */
virtual void setSrcWhf(const utils::Whf& wfh);
/* set Rotations */
virtual void setRotations(uint32_t r);
/* set the req data id in mData */
virtual void setDataReqId(int id);
/* set memory_id */
virtual void setDataMemId(int fd);
virtual void setRotDataSrcMemId(int fd);
/* Mark the src for rotator as FB. usually set by UI mirroing cases */
virtual void setSrcFB(bool);
/* get dst (for offset and memory id) non-virt */
explicit MdpRot();
~MdpRot();
bool init();
bool close();
void setSource(const utils::Whf& whf);
void setTransform(const utils::eTransform& rot,
const bool& rotUsed);
bool commit();
bool queueBuffer(int fd, uint32_t offset);
void setEnable();
void setDisable();
void setRotations(uint32_t r);
void setSrcFB(bool);
bool enabled() const;
int getSessId() const;
int getDstMemId() const;
uint32_t getDstOffset() const;
void dump() const;
/* set enable/disable flag */
virtual void setEnable();
virtual void setDisable();
virtual bool enabled () const;
/* return rotator sess id */
virtual int getSessId() const;
/* return a copy of src whf*/
virtual utils::Whf getSrcWhf() const;
/* prepare rot for queue buf*/
virtual bool prepareQueueBuf(uint32_t offset);
/* call play on mdp*/
virtual bool play(int fd);
/* dump the state of the object */
virtual void dump() const;
private:
/* helper functions for overlayTransform */
void overlayTransFlipHV(MdpCtrl& mdp,
utils::eTransform& rot);
void overlayTransFlipRot90(MdpCtrl& mdp,
utils::eTransform& rot);
void overlayTransFlipRot180(MdpCtrl& mdp);
void overlayTransFlipRot270(MdpCtrl& mdp);
/* remap rot buffers */
bool remap(uint32_t numbufs);
bool open_i(uint32_t numbufs, uint32_t bufsz);
/* reset underlying data, basically memset 0 */
void reset();
/* underlying rotator MDP object */
MdpRot mRot;
/* rot info*/
msm_rotator_img_info mRotImgInfo;
/* rot data */
msm_rotator_data_info mRotDataInfo;
/* rotator fd */
OvFD mFd;
/* Rotator memory manager */
RotMem mMem;
/* Single Rotator buffer size */
uint32_t mBufSize;
};
//--------------inlines------------------------------------
//// MdpRot ////
inline MdpRot::MdpRot() { reset(); }
inline bool MdpRot::start(const utils::PipeArgs& args) {
return this->start<utils::ROT_OUT_FMT_DEFAULT>(args);
///// Rotator /////
inline Rotator::Rotator() {
int type = IRotatorHw::getRotatorHwType();
if(type == IRotatorHw::TYPE_MDP) {
mRot = new MdpRot(); //will do reset
} else if(type == IRotatorHw::TYPE_MDSS) {
//TODO create mdss specific rotator
} else {
ALOGE("%s Unknown h/w type %d", __FUNCTION__, type);
}
}
inline Rotator::~Rotator() {
delete mRot; //will do close
}
inline bool Rotator::init() {
if(!mRot->init()) {
ALOGE("Rotator::init failed");
return false;
}
return true;
}
inline bool Rotator::close() {
return mRot->close();
}
inline void Rotator::setSource(const utils::Whf& whf) {
mRot->setSource(whf);
}
inline void Rotator::setTransform(const utils::eTransform& rot,
const bool& rotUsed)
{
mRot->setTransform(rot, rotUsed);
}
inline bool Rotator::commit() {
return mRot->commit();
}
inline void Rotator::setEnable(){ mRot->setEnable(); }
inline void Rotator::setDisable(){ mRot->setDisable(); }
inline bool Rotator::enabled() const { return mRot->enabled(); }
inline void Rotator::setSrcFB(bool mark) { mRot->setSrcFB(mark); }
inline int Rotator::getDstMemId() const {
return mRot->getDstMemId();
}
inline uint32_t Rotator::getDstOffset() const {
return mRot->getDstOffset();
}
inline void Rotator::setRotations(uint32_t rot) {
mRot->setRotations (rot);
}
inline int Rotator::getSessId() const {
return mRot->getSessId();
}
inline void Rotator::dump() const {
ALOGE("== Dump Rotator start ==");
mRot->dump();
ALOGE("== Dump Rotator end ==");
}
inline bool Rotator::queueBuffer(int fd, uint32_t offset) {
return mRot->queueBuffer(fd, offset);
}
inline void MdpRot::setDataMemId(int fd) { mData.data.memory_id = fd; }
inline void MdpRot::setRotDataSrcMemId(int fd) {
mRotDataInfo.src.memory_id = fd; }
///// Null Rotator /////
inline NullRotator::~NullRotator() {}
inline bool NullRotator::init() { return true; }
inline bool NullRotator::close() { return true; }
inline bool NullRotator::commit() { return true; }
inline void NullRotator::setSource(const utils::Whf& wfh) {}
inline void NullRotator::setTransform(const utils::eTransform& rot, const bool&)
{}
inline void NullRotator::setRotations(uint32_t) {}
inline void NullRotator::setEnable() {}
inline void NullRotator::setDisable() {}
inline bool NullRotator::enabled() const { return false; }
inline int NullRotator::getSessId() const { return -1; }
inline bool NullRotator::queueBuffer(int fd, uint32_t offset) { return true; }
inline void NullRotator::setSrcFB(bool) {}
inline int NullRotator::getDstMemId() const { return -1; }
inline uint32_t NullRotator::getDstOffset() const { return 0;}
inline void NullRotator::dump() const {
ALOGE("== Dump NullRotator dump (null) start/end ==");
}
//// MdpRot ////
inline MdpRot::MdpRot() { reset(); }
inline MdpRot::~MdpRot() { close(); }
inline void MdpRot::setEnable() { mRotImgInfo.enable = 1; }
inline void MdpRot::setDisable() { mRotImgInfo.enable = 0; }
inline bool MdpRot::enabled() const { return mRotImgInfo.enable; }
inline void MdpRot::setRotations(uint32_t r) { mRotImgInfo.rotations = r; }
inline void MdpRot::setDataReqId(int id) { mData.id = id; }
inline void MdpRot::swapDstWH() {
overlay::utils::swap(mRotImgInfo.dst.width,
mRotImgInfo.dst.height); }
inline overlay::utils::Whf MdpRot::getSrcWhf() const {
return overlay::utils::Whf(mRotImgInfo.src.width,
mRotImgInfo.src.height,
mRotImgInfo.src.format);
}
inline int MdpRot::getDstMemId() const {
return mRotDataInfo.dst.memory_id;
}
inline uint32_t MdpRot::getDstOffset() const {
return mRotDataInfo.dst.offset;
}
inline void MdpRot::setSrcWhf(const overlay::utils::Whf& whf) {
mRotImgInfo.src.width = whf.w;
mRotImgInfo.src.height = whf.h;
mRotImgInfo.src.format = whf.format;
}
inline int MdpRot::getSessId() const { return mRotImgInfo.session_id; }
inline void MdpRot::setSrcFB(bool mark) { isSrcFB = mark; }
///// Null Rotator /////
inline NullRotator::~NullRotator() {}
inline bool NullRotator::open() {
return true; }
inline bool NullRotator::remap(uint32_t numbufs,
const utils::PipeArgs& args){
return true; }
inline bool NullRotator::close() { return true; }
inline bool NullRotator::start(const utils::PipeArgs& args)
{ return true; }
inline bool NullRotator::start() { return true; }
inline bool NullRotator::overlayTransform(MdpCtrl& o,
utils::eTransform& rot)
{ return true; }
inline void NullRotator::setSrcWhf(const overlay::utils::Whf& wfh) {}
inline void NullRotator::setRotations(uint32_t) {}
inline void NullRotator::setDataReqId(int id) {}
inline void NullRotator::setEnable() {}
inline void NullRotator::setDisable() {}
inline bool NullRotator::enabled() const { return false; }
inline int NullRotator::getSessId() const { return -1; }
inline overlay::utils::Whf NullRotator::getSrcWhf() const {
return overlay::utils::Whf(); }
inline bool NullRotator::prepareQueueBuf(uint32_t offset)
{ return true; }
inline bool NullRotator::play(int fd)
{ return true; }
inline void NullRotator::setDataMemId(int fd) {}
inline void NullRotator::setRotDataSrcMemId(int fd) {}
inline void NullRotator::setSrcFB(bool) {}
inline void NullRotator::dump() const {
ALOGE("== Dump NullRotator dump (null) start/end ==");
inline void MdpRot::setSrcFB(bool set) {
if(set)
mRotDataInfo.src.flags |= MDP_MEMORY_ID_TYPE_FB;
}
///// Rotator /////
inline Rotator::Rotator() { }
inline Rotator::~Rotator() {
mRot.close(); // also will do reset
}
inline bool Rotator::open() {
if(!mRot.open()) {
ALOGE("Rotator::open failed");
return false;
}
return true;
}
template <int ROT_OUT_FMT>
inline bool Rotator::start(const utils::PipeArgs& args) {
return mRot.start<ROT_OUT_FMT>(args);
}
inline bool Rotator::remap(uint32_t numbufs,
const utils::PipeArgs& args){
if(!mRot.remap(numbufs, args)) {
ALOGE("%s failed", __FUNCTION__);
return false;
}
return true;
}
inline bool Rotator::close() {
return mRot.close();
}
inline bool Rotator::start() {
return mRot.start();
}
inline bool Rotator::start(const utils::PipeArgs& args) {
return mRot.start(args);
}
inline bool Rotator::unmapNonCurrent() {
return mRot.unmapNonCurrent();
}
inline void Rotator::setEnable(){ mRot.setEnable(); }
inline void Rotator::setDisable(){ mRot.setDisable(); }
inline bool Rotator::enabled() const { return mRot.enabled(); }
inline void Rotator::setDataMemId(int fd) {
mRot.setDataMemId(fd); }
inline void Rotator::setRotDataSrcMemId(int fd) {
mRot.setRotDataSrcMemId(fd);
}
inline void Rotator::setSrcFB(bool mark) { mRot.setSrcFB(mark); }
inline int Rotator::getDstMemId() const {
return mRot.getDstMemId();
}
inline uint32_t Rotator::getDstOffset() const {
return mRot.getDstOffset();
}
inline void Rotator::setDataReqId(int id) {
mRot.setDataReqId(id);
}
inline void Rotator::setSrcWhf(
const overlay::utils::Whf& whf) {
mRot.setSrcWhf(whf);
}
inline void Rotator::setRotations(uint32_t rot) {
mRot.setRotations (rot);
}
inline int Rotator::getSessId() const {
return mRot.getSessId(); }
inline void Rotator::dump() const {
ALOGE("== Dump Rotator start ==");
mRot.dump();
ALOGE("== Dump Rotator end ==");
}
inline overlay::utils::Whf Rotator::getSrcWhf() const {
return mRot.getSrcWhf(); }
inline bool Rotator::prepareQueueBuf(uint32_t offset)
{
return mRot.prepareQueueBuf(offset);
}
inline bool Rotator::play(int fd)
{
return mRot.play(fd);
}
template <int ROT_OUT_FMT>
bool MdpRot::start(const utils::PipeArgs& args) {
// Do nothing when no orientation
if(utils::OVERLAY_TRANSFORM_0 == args.orientation &&
utils::ROT_FLAG_ENABLED != args.rotFlags) {
return true;
}
utils::Whf whf(args.whf);
mRotImgInfo.src.format = whf.format;
mRotImgInfo.src.width = whf.w;
mRotImgInfo.src.height = whf.h;
mRotImgInfo.src_rect.w = whf.w;
mRotImgInfo.src_rect.h = whf.h;
mRotImgInfo.dst.width = whf.w;
mRotImgInfo.dst.height = whf.h;
if(whf.format == MDP_Y_CRCB_H2V2_TILE ||
whf.format == MDP_Y_CBCR_H2V2_TILE) {
mRotImgInfo.src.width = utils::alignup(whf.w, 64);
mRotImgInfo.src.height = utils::alignup(whf.h, 32);
mRotImgInfo.src_rect.w = utils::alignup(whf.w, 64);
mRotImgInfo.src_rect.h = utils::alignup(whf.h, 32);
mRotImgInfo.dst.width = utils::alignup(whf.w, 64);
mRotImgInfo.dst.height = utils::alignup(whf.h, 32);
mRotImgInfo.dst.format = MDP_Y_CRCB_H2V2;
}
// either utils::getRotOutFmt(whf.format); or supplied fmt
// utils::RotOutFmt<ROT_OUT_FMT_DEFAULT>::fmt;
mRotImgInfo.dst.format = utils::RotOutFmt<ROT_OUT_FMT>::fmt(whf.format);
mRotImgInfo.dst_x = 0;
mRotImgInfo.dst_y = 0;
mRotImgInfo.src_rect.x = 0;
mRotImgInfo.src_rect.y = 0;
mRotImgInfo.rotations = 0;
// ROT_FLAG_DISABLED / ENABLED
// Refer to overlayUtils.h eRotFlags
// for more info
mRotImgInfo.enable = args.rotFlags;
mRotImgInfo.session_id = mRotImgInfo.session_id ?
mRotImgInfo.session_id : 0;
return start();
}
} // overlay
namespace {
// just a helper func for Rotator common operations x-(y+z)
int compute(uint32_t x, uint32_t y, uint32_t z) {
return x-(y+z);
}
}
#endif // OVERLAY_ROTATOR_H
#endif // OVERlAY_ROTATOR_H

22
liboverlay/overlayState.h
View File

@ -35,21 +35,16 @@
#include "overlayRotator.h"
#include "pipes/overlayGenPipe.h"
#include "pipes/overlayBypassPipe.h"
#include "pipes/overlayHdmiPipe.h"
#include "pipes/overlayVideoExtPipe.h"
#include "pipes/overlayUIMirrorPipe.h"
#include "pipes/overlay3DPipe.h"
// FIXME make int to be uint32 whenever possible
namespace overlay {
/*
* Used by Overlay class. Invokes each event
* */
/* TODO case of RGBx will call mOv open with diff
* params customized for RGBx pipes */
class OverlayState : utils::NoCopy {
public:
/**/
@ -153,11 +148,11 @@ template <> struct StateTraits<utils::OV_2D_VIDEO_ON_PANEL>
template <> struct StateTraits<utils::OV_2D_VIDEO_ON_PANEL_TV>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0;
typedef overlay::HdmiPipe pipe1;
typedef overlay::VideoExtPipe pipe1;
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef NullRotator rot1;
typedef Rotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1> ovimpl;
@ -231,11 +226,11 @@ template <> struct StateTraits<utils::OV_UI_MIRROR>
template <> struct StateTraits<utils::OV_2D_TRUE_UI_MIRROR>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0;
typedef overlay::HdmiPipe pipe1;
typedef overlay::VideoExtPipe pipe1;
typedef overlay::UIMirrorPipe pipe2;
typedef Rotator rot0;
typedef NullRotator rot1;
typedef Rotator rot1;
typedef Rotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
@ -310,8 +305,8 @@ inline OverlayImplBase* handle_closed_to_xxx()
RotatorBase* rot0 = new typename StateTraits<STATE>::rot0;
RotatorBase* rot1 = new typename StateTraits<STATE>::rot1;
RotatorBase* rot2 = new typename StateTraits<STATE>::rot2;
if(!ov->open(rot0, rot1, rot2)) {
ALOGE("Overlay failed to open in state %d", STATE);
if(!ov->init(rot0, rot1, rot2)) {
ALOGE("Overlay failed to init in state %d", STATE);
return 0;
}
return ov;
@ -329,7 +324,7 @@ inline OverlayImplBase* handle_xxx_to_closed(OverlayImplBase* ov)
return 0;
}
/* Hard transitions from any state to any state will close and then open */
/* Hard transitions from any state to any state will close and then init */
template <int STATE>
inline OverlayImplBase* handle_xxx_to_xxx(OverlayImplBase* ov)
{
@ -392,6 +387,7 @@ inline OverlayImplBase* OverlayState::handleEvent(utils::eOverlayState newState,
// FIXME, how to communicate bad transition?
// Should we have bool returned from transition func?
// This is also a very good interview question.
return newov;
}

139
liboverlay/overlayTransitions.cpp
View File

@ -42,12 +42,12 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DPanel(
// Create new ovimpl based on new state
typedef StateTraits<utils::OV_2D_VIDEO_ON_PANEL> NewState;
OverlayImplBase* newov = new NewState::ovimpl;
OverlayImplBase* newov = new NewState::ovimpl();
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (GenericPipe)
@ -55,10 +55,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DPanel(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (GenericPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (GenericPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (GenericPipe)", __FUNCTION__);
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
RotatorBase* rot0 = new NewState::rot0;
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (NullPipe)
@ -66,10 +66,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DPanel(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (NullPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (NullPipe)", __FUNCTION__);
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
RotatorBase* rot1 = new NewState::rot1;
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (NullPipe)
@ -77,10 +77,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DPanel(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (NullPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (NullPipe)", __FUNCTION__);
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
RotatorBase* rot2 = new NewState::rot2;
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -106,7 +106,7 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DTV(
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (GenericPipe)
@ -114,21 +114,21 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DTV(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (GenericPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (GenericPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (GenericPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (HdmiPipe)
if (ov->getOvPipeType(utils::OV_PIPE1) == utils::OV_PIPE_TYPE_HDMI) {
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (HdmiPipe)", __FUNCTION__);
// pipe1/rot1 (VideoExtPipe)
if (ov->getOvPipeType(utils::OV_PIPE1) == utils::OV_PIPE_TYPE_VIDEO_EXT) {
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (VideoExtPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (HdmiPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (VideoExtPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (NullPipe)
@ -136,10 +136,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_2DTV(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (NullPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -162,21 +162,22 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DPanel(
typedef StateTraits<utils::OV_3D_VIDEO_ON_2D_PANEL> NewState;
OverlayImplBase* newov = new NewState::ovimpl;
//===========================================================
//=================================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
//===========================================================
// - If pipe matches, copy from previous into new ovimpl.
// (which also makes previous pipe ref 0, so nobody can use)
// - Otherwise init pipe for new ovimpl and delete from previous
//=================================================================
// pipe0/rot0 (M3DPrimaryPipe)
if (ov->getOvPipeType(utils::OV_PIPE0) == utils::OV_PIPE_TYPE_M3D_PRIMARY) {
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (M3DPrimaryPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (M3DPrimaryPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (M3DPrimaryPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (NullPipe)
@ -184,10 +185,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DPanel(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (NullPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (NullPipe)
@ -195,10 +196,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DPanel(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (NullPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -224,7 +225,7 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DTV(
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (M3DPrimaryPipe)
@ -232,10 +233,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DTV(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (M3DPrimaryPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (M3DPrimaryPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (M3DPrimaryPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (M3DExtPipe)
@ -243,10 +244,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DTV(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (M3DExtPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (M3DExtPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (M3DExtPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (NullPipe)
@ -254,10 +255,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_3D_2DTV(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (NullPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -283,7 +284,7 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_trueUI_Mirror(
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (GenericPipe)
@ -291,21 +292,21 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_trueUI_Mirror(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (GenericPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (GenericPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (GenericPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (HdmiPipe)
if (ov->getOvPipeType(utils::OV_PIPE1) == utils::OV_PIPE_TYPE_HDMI) {
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (HdmiPipe)", __FUNCTION__);
// pipe1/rot1 (VideoExtPipe)
if (ov->getOvPipeType(utils::OV_PIPE1) == utils::OV_PIPE_TYPE_VIDEO_EXT) {
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (VideoExtPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (HdmiPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (VideoExtPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (UIMirrorPipe)
@ -313,10 +314,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_2D_trueUI_Mirror(
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (UIMirrorPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (UIMirrorPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (UIMirrorPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -341,7 +342,7 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass1(OverlayImplBase* ov)
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (BypassPipe)
@ -349,10 +350,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass1(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (BypassPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (BypassPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (BypassPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (NullPipe)
@ -360,10 +361,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass1(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (NullPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (NullPipe)
@ -371,10 +372,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass1(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (NullPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -399,7 +400,7 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass2(OverlayImplBase* ov)
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (BypassPipe)
@ -407,10 +408,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass2(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (BypassPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (BypassPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (BypassPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (BypassPipe)
@ -418,10 +419,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass2(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (BypassPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (BypassPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (BypassPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (NullPipe)
@ -429,10 +430,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass2(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (NullPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (NullPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (NullPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl
@ -457,7 +458,7 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass3(OverlayImplBase* ov)
//===========================================================
// For each pipe:
// - If pipe matches, copy from previous into new ovimpl
// - Otherwise open for new and delete from previous ovimpl
// - Otherwise init for new and delete from previous ovimpl
//===========================================================
// pipe0/rot0 (BypassPipe)
@ -465,10 +466,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass3(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe0 (BypassPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE0);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe0 (BypassPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe0 (BypassPipe)", __FUNCTION__);
RotatorBase* rot0 = new NewState::rot0;
ov->closePipe(utils::OV_PIPE0);
newov->openPipe(rot0, utils::OV_PIPE0);
newov->initPipe(rot0, utils::OV_PIPE0);
}
// pipe1/rot1 (BypassPipe)
@ -476,10 +477,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass3(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe1 (BypassPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE1);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe1 (BypassPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe1 (BypassPipe)", __FUNCTION__);
RotatorBase* rot1 = new NewState::rot1;
ov->closePipe(utils::OV_PIPE1);
newov->openPipe(rot1, utils::OV_PIPE1);
newov->initPipe(rot1, utils::OV_PIPE1);
}
// pipe2/rot2 (BypassPipe)
@ -487,10 +488,10 @@ OverlayImplBase* OverlayState::handle_xxx_to_bypass3(OverlayImplBase* ov)
ALOGE_IF(DEBUG_OVERLAY, "%s: Copy pipe2 (BypassPipe)", __FUNCTION__);
newov->copyOvPipe(ov, utils::OV_PIPE2);
} else {
ALOGE_IF(DEBUG_OVERLAY, "%s: Open pipe2 (BypassPipe)", __FUNCTION__);
ALOGE_IF(DEBUG_OVERLAY, "%s: init pipe2 (BypassPipe)", __FUNCTION__);
RotatorBase* rot2 = new NewState::rot2;
ov->closePipe(utils::OV_PIPE2);
newov->openPipe(rot2, utils::OV_PIPE2);
newov->initPipe(rot2, utils::OV_PIPE2);
}
// All pipes are copied or deleted so no more need for previous ovimpl

76
liboverlay/overlayUtils.cpp
View File

@ -70,7 +70,7 @@ struct IOFile {
namespace overlay {
//----------From class Res ------------------------------
const char* const Res::devTemplate = "/dev/graphics/fb%u";
const char* const Res::fbPath = "/dev/graphics/fb%u";
const char* const Res::rotPath = "/dev/msm_rotator";
const char* const Res::format3DFile =
"/sys/class/graphics/fb1/format_3d";
@ -92,7 +92,7 @@ FrameBufferInfo::FrameBufferInfo() {
OvFD mFd;
// Use open defined in overlayFD file to open fd for fb0
if(!overlay::open(mFd, 0, Res::devTemplate)) {
if(!overlay::open(mFd, 0, Res::fbPath)) {
ALOGE("FrameBufferInfo: failed to open fd");
return;
}
@ -146,41 +146,6 @@ bool FrameBufferInfo::supportTrueMirroring() const {
}
//--------------------------------------------------------
uint32_t getSize(const Whf& whf) {
int aligned_height=0, pitch=0;
uint32_t size = whf.w * whf.h;
switch (whf.format) {
case MDP_RGBA_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
size *= 4;
break;
case MDP_RGB_565:
case MDP_Y_CBCR_H2V1:
size *= 2;
break;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
size = (size * 3) / 2;
break;
case MDP_Y_CRCB_H2V2_TILE:
case MDP_Y_CBCR_H2V2_TILE:
aligned_height = align(whf.h , 32);
pitch = align(whf.w, 128);
size = pitch * aligned_height;
size = align(size, 8192);
aligned_height = align(whf.h >> 1, 32);
size += pitch * aligned_height;
size = align(size, 8192);
break;
default:
ALOGE("getSize unknown format %d", whf.format);
return 0;
}
return size;
}
int getMdpFormat(int format) {
switch (format) {
@ -205,7 +170,7 @@ int getMdpFormat(int format) {
case HAL_PIXEL_FORMAT_YV12:
return MDP_Y_CR_CB_H2V2;
default:
ALOGE("Error getMdpFormat format=%d", format);
ALOGE("Error getMdpFormat format=0x%x", format);
return -1;
}
// not reached
@ -229,7 +194,7 @@ bool is3DTV() {
bool isPanel3D() {
OvFD fd;
if(!overlay::open(fd, 0 /*fb*/, Res::devTemplate)){
if(!overlay::open(fd, 0 /*fb*/, Res::fbPath)){
ALOGE("isPanel3D Can't open framebuffer 0");
return false;
}
@ -299,39 +264,6 @@ uint32_t getS3DFormat(uint32_t fmt) {
return fmt3D;
}
void normalizeCrop(uint32_t& xy, uint32_t& wh) {
if (xy & 0x0001) {
// x or y is odd, increment it's value
xy += 1;
// Since we've incremented x(y), we need to decrement
// w(h) accordingly
if (wh & 0x0001) {
// w or h is odd, decrement it by 1, to make it even
even_out(wh);
} else {
// w(h) is already even, hence we decrement by 2
wh -=2;
}
} else {
even_out(wh);
}
}
void scale(mdp_overlay& ov)
{
/* Scaling of upto a max of 8 times supported */
overlay::utils::Dim dst(overlay::utils::getDstRectDim(ov));
overlay::utils::Dim src(overlay::utils::getSrcRectDim(ov));
if(dst.w >(src.w * overlay::utils::HW_OV_MAGNIFICATION_LIMIT)) {
dst.w = overlay::utils::HW_OV_MAGNIFICATION_LIMIT * src.w;
}
if(dst.h >(src.h * overlay::utils::HW_OV_MAGNIFICATION_LIMIT)) {
dst.h = overlay::utils::HW_OV_MAGNIFICATION_LIMIT * src.h;
}
setDstRectDim(dst, ov);
}
} // utils
} // overlay

215
liboverlay/overlayUtils.h
View File

@ -42,7 +42,7 @@
#include <sys/stat.h>
#include <sys/types.h>
#include <utils/Log.h>
#include "gralloc_priv.h" //for interlace
/*
*
* Collection of utilities functions/structs/enums etc...
@ -70,12 +70,6 @@ class Overlay;
namespace utils {
struct Whf;
struct Dim;
template <class T>
inline void even_out(T& x) { if (x & 0x0001) --x; }
inline uint32_t getBit(uint32_t x, uint32_t mask) {
return (x & mask);
}
inline uint32_t setBit(uint32_t x, uint32_t mask) {
return (x | mask);
@ -89,7 +83,7 @@ inline uint32_t clrBit(uint32_t x, uint32_t mask) {
* and assignment operator private
*
* Usage:
* * class SomeClass : utils::NoCopy {...};
* class SomeClass : utils::NoCopy {...};
*/
class NoCopy {
protected:
@ -147,7 +141,14 @@ enum { BARRIER_LAND = 1,
BARRIER_PORT = 2 };
inline uint32_t format3D(uint32_t x) { return x & 0xFF000; }
inline uint32_t colorFormat(uint32_t x) { return x & 0xFFF; }
inline uint32_t colorFormat(uint32_t fmt) {
/*TODO enable this block only if format has interlace / 3D info in top bits.
if(fmt & INTERLACE_MASK) {
fmt = fmt ^ HAL_PIXEL_FORMAT_INTERLACE;
}
fmt = fmt & 0xFFF;*/
return fmt;
}
inline uint32_t format3DOutput(uint32_t x) {
return (x & 0xF000) >> SHIFT_OUT_3D; }
inline uint32_t format3DInput(uint32_t x) { return x & 0xF0000; }
@ -160,12 +161,15 @@ bool usePanel3D();
bool send3DInfoPacket (uint32_t fmt);
bool enableBarrier (uint32_t orientation);
uint32_t getS3DFormat(uint32_t fmt);
template <int CHAN>
bool getPositionS3D(const Whf& whf, Dim& out);
bool getPositionS3D(const Whf& whf, Dim& out);
template <int CHAN>
bool getCropS3D(const Dim& in, Dim& out, uint32_t fmt);
bool getCropS3D(const Dim& in, Dim& out, uint32_t fmt);
template <class Type>
void swapWidthHeight(Type& width, Type& height);
void swapWidthHeight(Type& width, Type& height);
struct Dim {
Dim () : x(0), y(0),
@ -193,13 +197,6 @@ struct Dim {
return !operator==(d);
}
void even_out() {
utils::even_out(x);
utils::even_out(y);
utils::even_out(w);
utils::even_out(h);
}
void dump() const;
uint32_t x;
uint32_t y;
@ -227,26 +224,12 @@ struct Whf {
void dump() const;
uint32_t w;
uint32_t h;
// FIXME need to be int32_t ?
uint32_t format;
uint32_t size;
};
enum { MAX_PATH_LEN = 256 };
enum eParams {
OVERLAY_DITHER,
OVERLAY_TRANSFORM,
OVERLAY_TRANSFORM_UI
};
struct Params{
Params(eParams p, int v) : param(p), value(v) {}
eParams param;
int value;
};
/**
* Rotator flags: not to be confused with orientation flags.
* Ususally, you want to open the rotator to make sure it is
@ -267,10 +250,6 @@ enum eRotFlags {
ROT_FLAG_ENABLED = 1 // needed in rot
};
/* Used for rotator open.
* FIXME that is default, might be configs */
enum { ROT_NUM_BUFS = 2 };
/* Wait/No wait for waiting for vsync
* WAIT - wait for vsync, ignore fb (no need to compose w/ fb)
* NO_WAIT - do not wait for vsync and return immediatly since
@ -299,14 +278,16 @@ enum eMdpFlags {
OV_MDP_PIPE_SHARE = MDP_OV_PIPE_SHARE,
OV_MDP_DEINTERLACE = MDP_DEINTERLACE,
OV_MDP_PLAY_NOWAIT = MDP_OV_PLAY_NOWAIT,
OV_MDP_SECURE_OVERLAY_SESSION = MDP_SECURE_OVERLAY_SESSION
OV_MDP_SECURE_OVERLAY_SESSION = MDP_SECURE_OVERLAY_SESSION,
OV_MDP_SOURCE_ROTATED_90 = MDP_SOURCE_ROTATED_90,
OV_MDP_MEMORY_ID_TYPE_FB = MDP_MEMORY_ID_TYPE_FB,
};
enum eOverlayPipeType {
OV_PIPE_TYPE_NULL,
OV_PIPE_TYPE_BYPASS,
OV_PIPE_TYPE_GENERIC,
OV_PIPE_TYPE_HDMI,
OV_PIPE_TYPE_VIDEO_EXT,
OV_PIPE_TYPE_M3D_EXTERNAL,
OV_PIPE_TYPE_M3D_PRIMARY,
OV_PIPE_TYPE_RGB,
@ -388,18 +369,15 @@ struct PlayInfo {
// Used to consolidate pipe params
struct PipeArgs {
PipeArgs() : mdpFlags(OV_MDP_FLAGS_NONE),
orientation(OVERLAY_TRANSFORM_0),
wait(NO_WAIT),
zorder(Z_SYSTEM_ALLOC),
isFg(IS_FG_OFF),
rotFlags(ROT_FLAG_DISABLED){
}
PipeArgs(eMdpFlags f, eTransform o,
Whf _whf, eWait w,
PipeArgs(eMdpFlags f, Whf _whf, eWait w,
eZorder z, eIsFg fg, eRotFlags r) :
mdpFlags(f),
orientation(o),
whf(_whf),
wait(w),
zorder(z),
@ -408,7 +386,6 @@ struct PipeArgs {
}
eMdpFlags mdpFlags; // for mdp_overlay flags PIPE_SHARE, NO_WAIT, etc
eTransform orientation; // FIXME docs
Whf whf;
eWait wait; // flags WAIT/NO_WAIT
eZorder zorder; // stage number
@ -524,8 +501,6 @@ int getRotOutFmt(uint32_t format);
* rotation is 90, 180 etc
* It returns MDP related enum/define that match rot+flip*/
int getMdpOrient(eTransform rotation);
uint32_t getSize(const Whf& whf);
uint32_t getSizeByMdp(const Whf& whf);
const char* getFormatString(uint32_t format);
const char* getStateString(eOverlayState state);
@ -534,16 +509,6 @@ inline int setWait(eWait wait, int flags) {
flags &= ~MDP_OV_PLAY_NOWAIT :
flags |= MDP_OV_PLAY_NOWAIT;
}
/* possible overlay formats libhardware/include/hardware/hardware.h */
enum eFormat {
OVERLAY_FORMAT_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888,
OVERLAY_FORMAT_RGB_565 = HAL_PIXEL_FORMAT_RGB_565,
OVERLAY_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888,
OVERLAY_FORMAT_YCbYCr_422_I = 0x14,
OVERLAY_FORMAT_CbYCrY_422_I = 0x16,
OVERLAY_FORMAT_DEFAULT = 99 // The actual color format is
// determined by the overlay
};
// Cannot use HW_OVERLAY_MAGNIFICATION_LIMIT, since at the time
// of integration, HW_OVERLAY_MAGNIFICATION_LIMIT was a define
@ -551,25 +516,8 @@ enum { HW_OV_MAGNIFICATION_LIMIT = 20,
HW_OV_MINIFICATION_LIMIT = 8
};
inline bool rotated(int orie) {
return (orie == OVERLAY_TRANSFORM_ROT_90 ||
orie == OVERLAY_TRANSFORM_ROT_270);
}
/* used by crop funcs in order to
* normalizes the crop values to be all even */
void normalizeCrop(uint32_t& xy, uint32_t& wh);
template <class T>
inline void memset0(T& t) { ::memset(&t, 0, sizeof(T)); }
template <class ROT, class MDP>
inline void swapOVRotWidthHeight(ROT& rot, MDP& mdp)
{
mdp.swapSrcWH();
mdp.swapSrcRectWH();
rot.swapDstWH();
}
inline void memset0(T& t) { ::memset(&t, 0, sizeof(T)); }
template <class T> inline void swap ( T& a, T& b )
{
@ -587,35 +535,6 @@ inline int align(int value, int a) {
return a ? ((value + (a-1)) & ~(a-1)) : value;
}
template <class MDP>
inline utils::Dim getSrcRectDim(const MDP& ov) {
return utils::Dim(ov.src_rect.x,
ov.src_rect.y,
ov.src_rect.w,
ov.src_rect.h);
}
template <class MDP>
inline utils::Whf getSrcWhf(const MDP& ov) {
return utils::Whf(ov.src.width,
ov.src.height,
ov.src.format);
}
template <class MDP>
inline void setSrcRectDim(MDP& ov, const utils::Dim& d) {
ov.src_rect.x = d.x;
ov.src_rect.y = d.y;
ov.src_rect.w = d.w;
ov.src_rect.h = d.h;
}
template <class MDP>
inline void setSrcWhf(MDP& ov, const utils::Whf& whf) {
ov.src.width = whf.w;
ov.src.height = whf.h;
ov.src.format = whf.format;
}
enum eRotOutFmt {
ROT_OUT_FMT_DEFAULT,
ROT_OUT_FMT_Y_CRCB_H2V2
@ -691,21 +610,30 @@ inline const char* getFormatString(uint32_t format){
"MDP_RGB_565",
"MDP_XRGB_8888",
"MDP_Y_CBCR_H2V2",
"MDP_Y_CBCR_H2V2_ADRENO",
"MDP_ARGB_8888",
"MDP_RGB_888",
"MDP_Y_CRCB_H2V2",
"MDP_YCRYCB_H2V1",
"MDP_Y_CRCB_H2V1",
"MDP_Y_CBCR_H2V1",
"MDP_Y_CRCB_H1V2",
"MDP_Y_CBCR_H1V2",
"MDP_RGBA_8888",
"MDP_BGRA_8888",
"MDP_RGBX_8888",
"MDP_Y_CRCB_H2V2_TILE",
"MDP_Y_CBCR_H2V2_TILE",
"MDP_Y_CR_CB_H2V2",
"MDP_Y_CR_CB_GH2V2",
"MDP_Y_CB_CR_H2V2",
"MDP_IMGTYPE_LIMIT",
"MDP_Y_CRCB_H1V1",
"MDP_Y_CBCR_H1V1",
"MDP_YCRCB_H1V1",
"MDP_YCBCR_H1V1",
"MDP_BGR_565",
"MDP_IMGTYPE_LIMIT",
"MDP_RGB_BORDERFILL",
"MDP_FB_FORMAT",
"MDP_IMGTYPE_LIMIT2"
};
@ -746,15 +674,6 @@ inline const char* getStateString(eOverlayState state){
return "BAD_STATE";
}
inline uint32_t getSizeByMdp(const Whf& whf) {
Whf _whf(whf);
int fmt = getMdpFormat(whf.format);
OVASSERT(-1 != fmt, "getSizeByMdp error in format %d",
whf.format);
_whf.format = fmt;
return getSize(_whf);
}
inline void Whf::dump() const {
ALOGE("== Dump WHF w=%d h=%d f=%d s=%d start/end ==",
w, h, format, size);
@ -766,7 +685,7 @@ inline void Dim::dump() const {
inline int getMdpOrient(eTransform rotation) {
ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, rotation);
switch(int(rotation))
switch(static_cast<int>(rotation))
{
case OVERLAY_TRANSFORM_0 : return 0;
case HAL_TRANSFORM_FLIP_V: return MDP_FLIP_UD;
@ -779,8 +698,8 @@ inline int getMdpOrient(eTransform rotation) {
case HAL_TRANSFORM_ROT_180: return MDP_ROT_180;
case HAL_TRANSFORM_ROT_270: return MDP_ROT_270;
default:
ALOGE("%s: invalid rotation value (value = 0x%x",
__FUNCTION__, rotation);
ALOGE("%s: invalid rotation value (value = 0x%x",
__FUNCTION__, rotation);
}
return -1;
}
@ -801,28 +720,11 @@ inline int getRotOutFmt(uint32_t format) {
return -1;
}
template<>
struct RotOutFmt<ROT_OUT_FMT_DEFAULT>
{
static inline int fmt(uint32_t format) {
return getRotOutFmt(format);
}
};
template<>
struct RotOutFmt<ROT_OUT_FMT_Y_CRCB_H2V2>
{
static inline int fmt(uint32_t) {
return MDP_Y_CRCB_H2V2;
}
};
inline uint32_t getColorFormat(uint32_t format)
{
//XXX: Earlier this used to mask the format
//to check for interlaced or 3D. Just return
//the format now
return format;
return (format == HAL_PIXEL_FORMAT_YV12) ?
format : colorFormat(format);
}
// FB0
@ -937,43 +839,6 @@ inline void ScreenInfo::dump(const char* const s) const {
s, mFBWidth, mFBHeight, mFBbpp, mFBystride);
}
inline void setSrcRectDim(const overlay::utils::Dim d,
mdp_overlay& ov) {
ov.src_rect.x = d.x;
ov.src_rect.y = d.y;
ov.src_rect.w = d.w;
ov.src_rect.h = d.h;
}
inline void setDstRectDim(const overlay::utils::Dim d,
mdp_overlay& ov) {
ov.dst_rect.x = d.x;
ov.dst_rect.y = d.y;
ov.dst_rect.w = d.w;
ov.dst_rect.h = d.h;
}
inline overlay::utils::Whf getSrcWhf(const mdp_overlay& ov) {
return overlay::utils::Whf(ov.src.width,
ov.src.height,
ov.src.format);
}
inline overlay::utils::Dim getSrcRectDim(const mdp_overlay& ov) {
return overlay::utils::Dim(ov.src_rect.x,
ov.src_rect.y,
ov.src_rect.w,
ov.src_rect.h);
}
inline overlay::utils::Dim getDstRectDim(const mdp_overlay& ov) {
return overlay::utils::Dim(ov.dst_rect.x,
ov.dst_rect.y,
ov.dst_rect.w,
ov.dst_rect.h);
}
} // namespace utils ends
//--------------------Class Res stuff (namespace overlay only) -----------
@ -981,7 +846,7 @@ inline overlay::utils::Dim getDstRectDim(const mdp_overlay& ov) {
class Res {
public:
// /dev/graphics/fb%u
static const char* const devTemplate;
static const char* const fbPath;
// /dev/msm_rotator
static const char* const rotPath;
// /sys/class/graphics/fb1/format_3d
@ -1060,7 +925,9 @@ inline OvFD::OvFD() : mFD (INVAL) {
mPath[0] = 0;
}
inline OvFD::~OvFD() { /* no op in the meantime */ }
inline OvFD::~OvFD() {
//no op since copy() can be used to share fd, in 3d cases.
}
inline bool OvFD::open(const char* const dev, int flags)
{

262
liboverlay/pipes/overlay3DPipe.h
View File

@ -50,20 +50,15 @@ public:
/* Please look at overlayGenPipe.h for info */
explicit M3DExtPipe();
~M3DExtPipe();
bool open(RotatorBase* rot);
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& d);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
@ -87,20 +82,15 @@ public:
/* Please look at overlayGenPipe.h for info */
explicit M3DPrimaryPipe();
~M3DPrimaryPipe();
bool open(RotatorBase* rot);
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& d);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
@ -124,20 +114,15 @@ public:
/* Please look at overlayGenPipe.h for info */
explicit S3DExtPipe();
~S3DExtPipe();
bool open(RotatorBase* rot);
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& d);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
@ -161,20 +146,15 @@ public:
/* Please look at overlayGenPipe.h for info */
explicit S3DPrimaryPipe();
~S3DPrimaryPipe();
bool open(RotatorBase* rot);
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& d);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
@ -197,10 +177,10 @@ inline M3DExtPipe<CHAN>::M3DExtPipe() : mM3Dfmt(0) {}
template <int CHAN>
inline M3DExtPipe<CHAN>::~M3DExtPipe() { close(); }
template <int CHAN>
inline bool M3DExtPipe<CHAN>::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "M3DExtPipe open");
if(!mM3d.open(rot)) {
ALOGE("3Dpipe failed to open");
inline bool M3DExtPipe<CHAN>::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "M3DExtPipe init");
if(!mM3d.init(rot)) {
ALOGE("3Dpipe failed to init");
return false;
}
return true;
@ -212,15 +192,9 @@ inline bool M3DExtPipe<CHAN>::close() {
template <int CHAN>
inline bool M3DExtPipe<CHAN>::commit() { return mM3d.commit(); }
template <int CHAN>
inline void M3DExtPipe<CHAN>::setId(int id) { mM3d.setId(id); }
template <int CHAN>
inline void M3DExtPipe<CHAN>::setMemoryId(int id) { mM3d.setMemoryId(id); }
template <int CHAN>
inline bool M3DExtPipe<CHAN>::queueBuffer(uint32_t offset) {
return mM3d.queueBuffer(offset); }
template <int CHAN>
inline bool M3DExtPipe<CHAN>::dequeueBuffer(void*& buf) {
return mM3d.dequeueBuffer(buf); }
inline bool M3DExtPipe<CHAN>::queueBuffer(int fd, uint32_t offset) {
return mM3d.queueBuffer(fd, offset);
}
template <int CHAN>
inline bool M3DExtPipe<CHAN>::waitForVsync() {
return mM3d.waitForVsync(); }
@ -233,14 +207,7 @@ inline bool M3DExtPipe<CHAN>::setCrop(const utils::Dim& d) {
}
return mM3d.setCrop(_dim);
}
template <int CHAN>
inline bool M3DExtPipe<CHAN>::start(const utils::PipeArgs& args) {
if(!mM3d.start(args)) {
ALOGE("M3DExtPipe start failed");
return false;
}
return true;
}
template <int CHAN>
inline bool M3DExtPipe<CHAN>::setPosition(const utils::Dim& d) {
utils::Dim _dim;
@ -258,8 +225,8 @@ inline bool M3DExtPipe<CHAN>::setPosition(const utils::Dim& d) {
return mM3d.setPosition(_dim);
}
template <int CHAN>
inline bool M3DExtPipe<CHAN>::setParameter(const utils::Params& param) {
return mM3d.setParameter(param);
inline bool M3DExtPipe<CHAN>::setTransform(const utils::eTransform& param) {
return mM3d.setTransform(param);
}
template <int CHAN>
inline bool M3DExtPipe<CHAN>::setSource(const utils::PipeArgs& args)
@ -267,19 +234,9 @@ inline bool M3DExtPipe<CHAN>::setSource(const utils::PipeArgs& args)
// extract 3D fmt
mM3Dfmt = utils::format3DInput(utils::getS3DFormat(args.whf.format)) |
utils::HAL_3D_OUT_MONOS_MASK;
if(mM3d.isClosed()){
if(!this->start(args)) {
ALOGE("M3DExtPipe setSource failed to start");
return false;
}
}
return mM3d.setSource(args);
}
template <int CHAN>
inline const utils::PipeArgs& M3DExtPipe<CHAN>::getArgs() const {
return mM3d.getArgs();
}
template <int CHAN>
inline utils::eOverlayPipeType M3DExtPipe<CHAN>::getOvPipeType() const {
return utils::OV_PIPE_TYPE_M3D_EXTERNAL;
}
@ -296,10 +253,10 @@ inline M3DPrimaryPipe<CHAN>::M3DPrimaryPipe() : mM3Dfmt(0) {}
template <int CHAN>
inline M3DPrimaryPipe<CHAN>::~M3DPrimaryPipe() { close(); }
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "M3DPrimaryPipe open");
if(!mM3d.open(rot)) {
ALOGE("3Dpipe failed to open");
inline bool M3DPrimaryPipe<CHAN>::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "M3DPrimaryPipe init");
if(!mM3d.init(rot)) {
ALOGE("3Dpipe failed to init");
return false;
}
return true;
@ -311,15 +268,9 @@ inline bool M3DPrimaryPipe<CHAN>::close() {
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::commit() { return mM3d.commit(); }
template <int CHAN>
inline void M3DPrimaryPipe<CHAN>::setId(int id) { mM3d.setId(id); }
template <int CHAN>
inline void M3DPrimaryPipe<CHAN>::setMemoryId(int id) { mM3d.setMemoryId(id); }
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::queueBuffer(uint32_t offset) {
return mM3d.queueBuffer(offset); }
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::dequeueBuffer(void*& buf) {
return mM3d.dequeueBuffer(buf); }
inline bool M3DPrimaryPipe<CHAN>::queueBuffer(int fd, uint32_t offset) {
return mM3d.queueBuffer(fd, offset);
}
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::waitForVsync() {
return mM3d.waitForVsync(); }
@ -333,20 +284,12 @@ inline bool M3DPrimaryPipe<CHAN>::setCrop(const utils::Dim& d) {
return mM3d.setCrop(_dim);
}
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::start(const utils::PipeArgs& args) {
if(!mM3d.start(args)) {
ALOGE("M3DPrimaryPipe start failed");
return false;
}
return true;
}
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::setPosition(const utils::Dim& d) {
return mM3d.setPosition(d);
}
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::setParameter(const utils::Params& param) {
return mM3d.setParameter(param);
inline bool M3DPrimaryPipe<CHAN>::setTransform(const utils::eTransform& param) {
return mM3d.setTransform(param);
}
template <int CHAN>
inline bool M3DPrimaryPipe<CHAN>::setSource(const utils::PipeArgs& args)
@ -354,19 +297,9 @@ inline bool M3DPrimaryPipe<CHAN>::setSource(const utils::PipeArgs& args)
// extract 3D fmt
mM3Dfmt = utils::format3DInput(utils::getS3DFormat(args.whf.format)) |
utils::HAL_3D_OUT_MONOS_MASK;
if (mM3d.isClosed()) {
if (!this->start(args)) {
ALOGE("M3DPrimaryPipe setSource failed to start");
return false;
}
}
return mM3d.setSource(args);
}
template <int CHAN>
inline const utils::PipeArgs& M3DPrimaryPipe<CHAN>::getArgs() const {
return mM3d.getArgs();
}
template <int CHAN>
inline utils::eOverlayPipeType M3DPrimaryPipe<CHAN>::getOvPipeType() const {
return utils::OV_PIPE_TYPE_M3D_PRIMARY;
}
@ -382,10 +315,10 @@ inline S3DExtPipe<CHAN>::S3DExtPipe() : mS3Dfmt(0) {}
template <int CHAN>
inline S3DExtPipe<CHAN>::~S3DExtPipe() { close(); }
template <int CHAN>
inline bool S3DExtPipe<CHAN>::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "S3DExtPipe open");
if(!mS3d.open(rot)) {
ALOGE("3Dpipe failed to open");
inline bool S3DExtPipe<CHAN>::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "S3DExtPipe init");
if(!mS3d.init(rot)) {
ALOGE("3Dpipe failed to init");
return false;
}
return true;
@ -400,16 +333,9 @@ inline bool S3DExtPipe<CHAN>::close() {
template <int CHAN>
inline bool S3DExtPipe<CHAN>::commit() { return mS3d.commit(); }
template <int CHAN>
inline void S3DExtPipe<CHAN>::setId(int id) { mS3d.setId(id); }
template <int CHAN>
inline void S3DExtPipe<CHAN>::setMemoryId(int id) { mS3d.setMemoryId(id); }
template <int CHAN>
inline bool S3DExtPipe<CHAN>::queueBuffer(uint32_t offset) {
//this->dump();
return mS3d.queueBuffer(offset); }
template <int CHAN>
inline bool S3DExtPipe<CHAN>::dequeueBuffer(void*& buf) {
return mS3d.dequeueBuffer(buf); }
inline bool S3DExtPipe<CHAN>::queueBuffer(int fd, uint32_t offset) {
return mS3d.queueBuffer(fd, offset);
}
template <int CHAN>
inline bool S3DExtPipe<CHAN>::waitForVsync() {
return mS3d.waitForVsync(); }
@ -423,20 +349,6 @@ inline bool S3DExtPipe<CHAN>::setCrop(const utils::Dim& d) {
return mS3d.setCrop(_dim);
}
template <int CHAN>
inline bool S3DExtPipe<CHAN>::start(const utils::PipeArgs& args) {
OVASSERT(mS3Dfmt, "S3DExtPipe mS3Dfmt should not be 0 here");
if(!mS3d.start(args)) {
ALOGE("S3DExtPipe start failed");
return false;
}
uint32_t fmt = mS3Dfmt & utils::OUTPUT_3D_MASK;
if(!utils::send3DInfoPacket(fmt)){
ALOGE("Error S3DExtPipe start error send3DInfoPacket %d", fmt);
return false;
}
return true;
}
template <int CHAN>
inline bool S3DExtPipe<CHAN>::setPosition(const utils::Dim& d)
{
utils::Dim _dim;
@ -450,25 +362,15 @@ inline bool S3DExtPipe<CHAN>::setPosition(const utils::Dim& d)
return mS3d.setPosition(_dim);
}
template <int CHAN>
inline bool S3DExtPipe<CHAN>::setParameter(const utils::Params& param) {
return mS3d.setParameter(param);
inline bool S3DExtPipe<CHAN>::setTransform(const utils::eTransform& param) {
return mS3d.setTransform(param);
}
template <int CHAN>
inline bool S3DExtPipe<CHAN>::setSource(const utils::PipeArgs& args) {
mS3Dfmt = utils::getS3DFormat(args.whf.format);
if(mS3d.isClosed()){
if(!this->start(args)) {
ALOGE("S3DExtPipe setSource failed to start");
return false;
}
}
return mS3d.setSource(args);
}
template <int CHAN>
inline const utils::PipeArgs& S3DExtPipe<CHAN>::getArgs() const {
return mS3d.getArgs();
}
template <int CHAN>
inline utils::eOverlayPipeType S3DExtPipe<CHAN>::getOvPipeType() const {
return utils::OV_PIPE_TYPE_S3D_EXTERNAL;
}
@ -484,10 +386,10 @@ inline S3DPrimaryPipe<CHAN>::S3DPrimaryPipe() : mS3Dfmt(0) {}
template <int CHAN>
inline S3DPrimaryPipe<CHAN>::~S3DPrimaryPipe() { close(); }
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "S3DPrimaryPipe open");
if(!mS3d.open(rot)) {
ALOGE("3Dpipe failed to open");
inline bool S3DPrimaryPipe<CHAN>::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "S3DPrimaryPipe init");
if(!mS3d.init(rot)) {
ALOGE("3Dpipe failed to init");
return false;
}
// set the ctrl fd
@ -502,18 +404,20 @@ inline bool S3DPrimaryPipe<CHAN>::close() {
mCtrl3D.close();
return mS3d.close();
}
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::commit() { return mS3d.commit(); }
inline bool S3DPrimaryPipe<CHAN>::commit() {
uint32_t fmt = mS3Dfmt & utils::OUTPUT_3D_MASK;
if(!utils::send3DInfoPacket(fmt)){
ALOGE("Error S3DExtPipe start error send3DInfoPacket %d", fmt);
return false;
}
return mS3d.commit();
}
template <int CHAN>
inline void S3DPrimaryPipe<CHAN>::setId(int id) { mS3d.setId(id); }
template <int CHAN>
inline void S3DPrimaryPipe<CHAN>::setMemoryId(int id) { mS3d.setMemoryId(id); }
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::queueBuffer(uint32_t offset) {
return mS3d.queueBuffer(offset); }
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::dequeueBuffer(void*& buf) {
return mS3d.dequeueBuffer(buf); }
inline bool S3DPrimaryPipe<CHAN>::queueBuffer(int fd, uint32_t offset) {
return mS3d.queueBuffer(fd, offset);
}
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::waitForVsync() {
return mS3d.waitForVsync(); }
@ -527,14 +431,6 @@ inline bool S3DPrimaryPipe<CHAN>::setCrop(const utils::Dim& d) {
return mS3d.setCrop(_dim);
}
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::start(const utils::PipeArgs& args) {
if(!mS3d.start(args)) {
ALOGE("S3DPrimaryPipe start failed");
return false;
}
return true;
}
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::setPosition(const utils::Dim& d)
{
utils::Whf fbwhf(mS3d.getScreenInfo().mFBWidth,
@ -562,47 +458,35 @@ inline bool S3DPrimaryPipe<CHAN>::setPosition(const utils::Dim& d)
* So the easiest way to achieve it, is to make sure FB0 is having it before
* setParam is running */
template <>
inline bool S3DPrimaryPipe<utils::OV_PIPE0>::setParameter(
const utils::Params& param) {
if(utils::OVERLAY_TRANSFORM == param.param){
uint32_t barrier=0;
switch(param.value) {
case HAL_TRANSFORM_ROT_90:
case HAL_TRANSFORM_ROT_270:
barrier = utils::BARRIER_LAND;
break;
default:
barrier = utils::BARRIER_PORT;
break;
}
if(!utils::enableBarrier(barrier)) {
ALOGE("S3DPrimaryPipe setParameter failed to enable barrier");
}
inline bool S3DPrimaryPipe<utils::OV_PIPE0>::setTransform(
const utils::eTransform& param) {
uint32_t barrier=0;
switch(param) {
case utils::OVERLAY_TRANSFORM_ROT_90:
case utils::OVERLAY_TRANSFORM_ROT_270:
barrier = utils::BARRIER_LAND;
break;
default:
barrier = utils::BARRIER_PORT;
break;
}
return mS3d.setParameter(param);
if(!utils::enableBarrier(barrier)) {
ALOGE("S3DPrimaryPipe setTransform failed to enable barrier");
}
return mS3d.setTransform(param);
}
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::setParameter(const utils::Params& param) {
return mS3d.setParameter(param);
inline bool S3DPrimaryPipe<CHAN>::setTransform(const utils::eTransform& param) {
return mS3d.setTransform(param);
}
template <int CHAN>
inline bool S3DPrimaryPipe<CHAN>::setSource(const utils::PipeArgs& args)
{
mS3Dfmt = utils::getS3DFormat(args.whf.format);
if(mS3d.isClosed()){
if(!this->start(args)) {
ALOGE("S3DPrimaryPipe setSource failed to start");
return false;
}
}
return mS3d.setSource(args);
}
template <int CHAN>
inline const utils::PipeArgs& S3DPrimaryPipe<CHAN>::getArgs() const {
return mS3d.getArgs();
}
template <int CHAN>
inline utils::eOverlayPipeType S3DPrimaryPipe<CHAN>::getOvPipeType() const {
return utils::OV_PIPE_TYPE_S3D_PRIMARY;
}

60
liboverlay/pipes/overlayBypassPipe.h
View File

@ -49,20 +49,15 @@ public:
/* Please look at overlayGenPipe.h for info */
explicit BypassPipe();
~BypassPipe();
bool open(RotatorBase* rot);
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& dim);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
@ -83,9 +78,9 @@ inline BypassPipe<PipeType, IsFg, Wait, Zorder>::~BypassPipe() {
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "BypassPipe open");
return mBypass.open(rot);
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "BypassPipe init");
return mBypass.init(rot);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
@ -102,28 +97,9 @@ inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::commit() {
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline void BypassPipe<PipeType, IsFg, Wait, Zorder>::setId(int id) {
mBypass.setId(id);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline void BypassPipe<PipeType, IsFg, Wait, Zorder>::setMemoryId(int id) {
mBypass.setMemoryId(id);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::queueBuffer(
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::queueBuffer(int fd,
uint32_t offset) {
return mBypass.queueBuffer(offset);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::dequeueBuffer(
void*& buf) {
return mBypass.dequeueBuffer(buf);
return mBypass.queueBuffer(fd, offset);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
@ -139,13 +115,6 @@ inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::setCrop(
return mBypass.setCrop(dim);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::start(
const utils::PipeArgs& args) {
return mBypass.start(args);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::setPosition(
@ -155,9 +124,9 @@ inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::setPosition(
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::setParameter(
const utils::Params& param) {
return mBypass.setParameter(param);
inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::setTransform(
const utils::eTransform& param) {
return mBypass.setTransform(param);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
@ -187,13 +156,6 @@ inline bool BypassPipe<PipeType, IsFg, Wait, Zorder>::setSource(
return mBypass.setSource(arg);
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline const utils::PipeArgs& BypassPipe<PipeType, IsFg, Wait,
Zorder>::getArgs() const {
return mBypass.getArgs();
}
template <utils::eMdpPipeType PipeType, utils::eIsFg IsFg, utils::eWait Wait,
utils::eZorder Zorder>
inline utils::eOverlayPipeType BypassPipe<PipeType, IsFg, Wait,

330
liboverlay/pipes/overlayGenPipe.h
View File

@ -34,65 +34,38 @@
#include "overlayRotator.h"
#include "overlayCtrlData.h"
// FIXME make int to be uint32 whenever possible
namespace overlay {
template <int PANEL>
class GenericPipe : utils::NoCopy {
public:
/* ctor init */
/* ctor */
explicit GenericPipe();
/* dtor close */
/* dtor */
~GenericPipe();
/* CTRL/DATA/ROT open */
bool open(RotatorBase* rot);
/* CTRL/DATA init. Not owning rotator, will not init it */
bool init(RotatorBase* rot);
/* CTRL/DATA close. Not owning rotator, will not close it */
bool close();
/* Control APIs */
/* set source using whf, orient and wait flag */
bool setSource(const utils::PipeArgs& args);
/* set crop a.k.a the region of interest */
bool setCrop(const utils::Dim& d);
/* set orientation*/
bool setTransform(const utils::eTransform& param);
/* set mdp posision using dim */
bool setPosition(const utils::Dim& dim);
/* commit changes to the overlay "set"*/
bool commit();
/* "Data" related interface */
/* set ID directly to data channel */
void setId(int id);
/* Set FD / memid */
void setMemoryId(int id);
/* Data APIs */
/* queue buffer to the overlay */
bool queueBuffer(uint32_t offset);
/* dequeue buffer to the overlay NOTSUPPORTED */
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
/* wait for vsync to be done */
bool waitForVsync();
/* set crop data FIXME setROI (Region Of Intrest) */
bool setCrop(const utils::Dim& d);
/* "Ctrl" related interface */
/*
* Start a session, opens the rotator
* FIXME, we might want to open the rotator separately
*/
bool start(const utils::PipeArgs& args);
/* set mdp posision using dim */
bool setPosition(const utils::Dim& dim);
/* set param using Params (param,value pair) */
bool setParameter(const utils::Params& param);
/* set source using whf, orient and wait flag */
bool setSource(const utils::PipeArgs& args);
/* return cached startup args */
const utils::PipeArgs& getArgs() const;
@ -123,10 +96,8 @@ public:
/* dump the state of the object */
void dump() const;
private:
/* set Closed channel */
/* set Closed pipe */
bool setClosed();
// kick off rotator.
bool startRotator();
/* Ctrl/Data aggregator */
CtrlData mCtrlData;
@ -141,15 +112,23 @@ private:
* Can point to NullRotator or to Rotator*/
RotatorBase* mRot;
/* my flags */
enum { CLOSED = 1<<0 };
uint32_t mFlags;
//Whether rotator is used for 0-rot or otherwise
bool mRotUsed;
/* Pipe open or closed */
enum ePipeState {
CLOSED,
OPEN
};
ePipeState pipeState;
};
//------------------------Inlines and Templates ----------------------
template <int PANEL>
GenericPipe<PANEL>::GenericPipe() : mRot(0), mFlags(CLOSED) {}
GenericPipe<PANEL>::GenericPipe() : mRot(0), mRotUsed(false),
pipeState(CLOSED) {
}
template <int PANEL>
GenericPipe<PANEL>::~GenericPipe() {
@ -157,33 +136,42 @@ GenericPipe<PANEL>::~GenericPipe() {
}
template <int PANEL>
bool GenericPipe<PANEL>::open(RotatorBase* rot)
bool GenericPipe<PANEL>::init(RotatorBase* rot)
{
ALOGE_IF(DEBUG_OVERLAY, "GenericPipe init");
OVASSERT(rot, "rot is null");
// open ctrl and data
// init ctrl and data
uint32_t fbnum = utils::getFBForPanel(PANEL);
ALOGE_IF(DEBUG_OVERLAY, "GenericPipe open");
if(!mCtrlData.ctrl.open(fbnum, rot)) {
ALOGE("GenericPipe failed to open ctrl");
if(!mCtrlData.ctrl.init(fbnum)) {
ALOGE("GenericPipe failed to init ctrl");
return false;
}
if(!mCtrlData.data.open(fbnum, rot)) {
ALOGE("GenericPipe failed to open data");
if(!mCtrlData.data.init(fbnum)) {
ALOGE("GenericPipe failed to init data");
return false;
}
//Cache the rot ref. Ownership is with OverlayImpl.
mRot = rot;
// NOTE: we won't have the flags as non CLOSED since we
// consider the pipe opened for business only when we call
// start()
mRotUsed = false;
// NOTE:init() on the rot is called by OverlayImpl
// Pipes only have to worry about using rot, and not init or close.
return true;
}
template <int PANEL>
bool GenericPipe<PANEL>::close() {
if(isClosed()) return true;
if(isClosed())
return true;
bool ret = true;
if(!mCtrlData.ctrl.close()) {
ALOGE("GenericPipe failed to close ctrl");
ret = false;
@ -192,153 +180,117 @@ bool GenericPipe<PANEL>::close() {
ALOGE("GenericPipe failed to close data");
ret = false;
}
// NOTE:close() on the rot is called by OverlayImpl
// Pipes only have to worry about using rot, and not init or close.
setClosed();
return ret;
}
template <int PANEL>
inline bool GenericPipe<PANEL>::commit(){
OVASSERT(isOpen(), "State is closed, cannot commit");
return mCtrlData.ctrl.commit();
inline bool GenericPipe<PANEL>::setSource(
const utils::PipeArgs& args)
{
utils::PipeArgs newargs(args);
//Interlace video handling.
if(newargs.whf.format & INTERLACE_MASK) {
setMdpFlags(newargs.mdpFlags, utils::OV_MDP_DEINTERLACE);
}
utils::Whf whf(newargs.whf);
//Extract HAL format from lower bytes. Deinterlace if interlaced.
whf.format = utils::getColorFormat(whf.format);
//Get MDP equivalent of HAL format.
whf.format = utils::getMdpFormat(whf.format);
newargs.whf = whf;
//Cache if user wants 0-rotation
mRotUsed = newargs.rotFlags & utils::ROT_FLAG_ENABLED;
mRot->setSource(newargs.whf);
return mCtrlData.ctrl.setSource(newargs);
}
template <int PANEL>
inline void GenericPipe<PANEL>::setMemoryId(int id) {
OVASSERT(isOpen(), "State is closed, cannot setMemoryId");
mCtrlData.data.setMemoryId(id);
inline bool GenericPipe<PANEL>::setCrop(
const overlay::utils::Dim& d) {
return mCtrlData.ctrl.setCrop(d);
}
template <int PANEL>
inline void GenericPipe<PANEL>::setId(int id) {
mCtrlData.data.setId(id); }
inline bool GenericPipe<PANEL>::setTransform(
const utils::eTransform& orient)
{
//Rotation could be enabled by user for zero-rot or the layer could have
//some transform. Mark rotation enabled in either case.
mRotUsed |= (orient != utils::OVERLAY_TRANSFORM_0);
mRot->setTransform(orient, mRotUsed);
return mCtrlData.ctrl.setTransform(orient, mRotUsed);
}
template <int PANEL>
inline bool GenericPipe<PANEL>::setPosition(const utils::Dim& d)
{
return mCtrlData.ctrl.setPosition(d);
}
template <int PANEL>
inline bool GenericPipe<PANEL>::commit() {
bool ret = false;
//If wanting to use rotator, start it.
if(mRotUsed) {
if(!mRot->commit()) {
ALOGE("GenPipe Rotator commit failed");
return false;
}
}
ret = mCtrlData.ctrl.commit();
pipeState = ret ? OPEN : CLOSED;
return ret;
}
template <int PANEL>
inline bool GenericPipe<PANEL>::queueBuffer(int fd, uint32_t offset) {
//TODO Move pipe-id transfer to CtrlData class. Make ctrl and data private.
OVASSERT(isOpen(), "State is closed, cannot queueBuffer");
int pipeId = mCtrlData.ctrl.getPipeId();
OVASSERT(-1 != pipeId, "Ctrl ID should not be -1");
// set pipe id from ctrl to data
mCtrlData.data.setPipeId(pipeId);
int finalFd = fd;
uint32_t finalOffset = offset;
//If rotator is to be used, queue to it, so it can ROTATE.
if(mRotUsed) {
if(!mRot->queueBuffer(fd, offset)) {
ALOGE("GenPipe Rotator play failed");
return false;
}
//Configure MDP's source buffer as the current output buffer of rotator
if(mRot->getDstMemId() != -1) {
finalFd = mRot->getDstMemId();
finalOffset = mRot->getDstOffset();
} else {
//Could be -1 for NullRotator, if queue above succeeds.
//Need an actual rotator. Modify overlay State Traits.
//Not fatal, keep queuing to MDP without rotation.
ALOGE("Null rotator in use, where an actual is required");
}
}
return mCtrlData.data.queueBuffer(finalFd, finalOffset);
}
template <int PANEL>
inline int GenericPipe<PANEL>::getCtrlFd() const {
return mCtrlData.ctrl.getFd();
}
template <int PANEL>
inline bool GenericPipe<PANEL>::setCrop(
const overlay::utils::Dim& d) {
OVASSERT(isOpen(), "State is closed, cannot setCrop");
return mCtrlData.ctrl.setCrop(d);
}
template <int PANEL>
bool GenericPipe<PANEL>::start(const utils::PipeArgs& args)
{
/* open before your start control rotator */
uint32_t sz = args.whf.size; //utils::getSizeByMdp(args.whf);
OVASSERT(sz, "GenericPipe sz=%d", sz);
if(!mRot->open()) {
ALOGE("GenericPipe start failed to open rot");
return false;
}
if(!mCtrlData.ctrl.start(args)){
ALOGE("GenericPipe failed to start");
return false;
}
int ctrlId = mCtrlData.ctrl.getId();
OVASSERT(-1 != ctrlId, "Ctrl ID should not be -1");
// set ID requeset to assoc ctrl to data
setId(ctrlId);
// set ID request to assoc MDP data to ROT MDP data
mRot->setDataReqId(mCtrlData.data.getId());
// cache the args for future reference.
mArgs = args;
// we got here so we are open+start and good to go
mFlags = 0; // clear flags from CLOSED
// TODO make it more robust when more flags
// are added
return true;
}
template <int PANEL>
inline const utils::PipeArgs& GenericPipe<PANEL>::getArgs() const
{
return mArgs;
}
template <int PANEL>
bool GenericPipe<PANEL>::startRotator() {
// kick off rotator
if(!mRot->start()) {
ALOGE("GenericPipe failed to start rotator");
return false;
}
return true;
}
template <int PANEL>
inline bool GenericPipe<PANEL>::queueBuffer(uint32_t offset) {
OVASSERT(isOpen(), "State is closed, cannot queueBuffer");
return mCtrlData.data.queueBuffer(offset);
}
template <int PANEL>
inline bool GenericPipe<PANEL>::dequeueBuffer(void*&) {
OVASSERT(isOpen(), "State is closed, cannot dequeueBuffer");
// can also set error to NOTSUPPORTED in the future
return false;
}
template <int PANEL>
inline bool GenericPipe<PANEL>::waitForVsync() {
OVASSERT(isOpen(), "State is closed, cannot waitForVsync");
return mCtrlData.data.waitForVsync();
}
template <int PANEL>
inline bool GenericPipe<PANEL>::setPosition(const utils::Dim& dim)
{
OVASSERT(isOpen(), "State is closed, cannot setPosition");
return mCtrlData.ctrl.setPosition(dim);
}
template <int PANEL>
inline bool GenericPipe<PANEL>::setParameter(
const utils::Params& param)
{
OVASSERT(isOpen(), "State is closed, cannot setParameter");
// Currently setParameter would start rotator
if(!mCtrlData.ctrl.setParameter(param)) {
ALOGE("GenericPipe failed to setparam");
return false;
}
// if rot flags are ENABLED it means we would always
// like to have rot. Even with 0 rot. (solves tearing)
if(utils::ROT_FLAG_ENABLED == mArgs.rotFlags) {
mRot->setEnable();
}
return startRotator();
}
template <int PANEL>
inline bool GenericPipe<PANEL>::setSource(
const utils::PipeArgs& args)
{
// cache the recent args.
mArgs = args;
// setSource is the 1st thing that is being called on a pipe.
// If pipe is closed, we should start everything.
// we assume it is being opened with the correct FDs.
if(isClosed()) {
if(!this->start(args)) {
ALOGE("GenericPipe setSource failed to start");
return false;
}
return true;
}
return mCtrlData.ctrl.setSource(args);
}
template <int PANEL>
inline utils::Dim GenericPipe<PANEL>::getAspectRatio(
const utils::Whf& whf) const
@ -374,7 +326,7 @@ template <int PANEL>
void GenericPipe<PANEL>::dump() const
{
ALOGE("== Dump Generic pipe start ==");
ALOGE("flags=0x%x", mFlags);
ALOGE("pipe state = %d", (int)pipeState);
OVASSERT(mRot, "GenericPipe should have a valid Rot");
mCtrlData.ctrl.dump();
mCtrlData.data.dump();
@ -384,20 +336,20 @@ void GenericPipe<PANEL>::dump() const
template <int PANEL>
inline bool GenericPipe<PANEL>::isClosed() const {
return utils::getBit(mFlags, CLOSED);
return (pipeState == CLOSED);
}
template <int PANEL>
inline bool GenericPipe<PANEL>::isOpen() const {
return !isClosed();
return (pipeState == OPEN);
}
template <int PANEL>
inline bool GenericPipe<PANEL>::setClosed() {
return utils::setBit(mFlags, CLOSED);
pipeState = CLOSED;
return true;
}
} //namespace overlay
#endif // OVERLAY_GENERIC_PIPE_H

106
liboverlay/pipes/overlayUIMirrorPipe.h
View File

@ -46,74 +46,61 @@ public:
/* Please look at overlayGenPipe.h for info */
explicit UIMirrorPipe();
~UIMirrorPipe();
bool open(RotatorBase* rot);
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& dim);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
overlay::GenericPipe<ovutils::EXTERNAL> mUI;
utils::eTransform mPrimFBOr; //Primary FB's orientation
};
//----------------------------Inlines -----------------------------
inline UIMirrorPipe::UIMirrorPipe() {}
inline UIMirrorPipe::UIMirrorPipe() { mPrimFBOr = utils::OVERLAY_TRANSFORM_0; }
inline UIMirrorPipe::~UIMirrorPipe() { close(); }
inline bool UIMirrorPipe::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "UIMirrorPipe open");
bool ret = mUI.open(rot);
//If source to rotator is framebuffer, which is the case we UI Mirror pipe,
//we need to inform driver during playback. Since FB does not use ION.
inline bool UIMirrorPipe::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "UIMirrorPipe init");
bool ret = mUI.init(rot);
//If source to rotator is FB, which is the case with UI Mirror pipe,
//we need to inform driver during playback, since FB does not use ION.
rot->setSrcFB(true);
return ret;
}
inline bool UIMirrorPipe::close() { return mUI.close(); }
inline bool UIMirrorPipe::commit() { return mUI.commit(); }
inline void UIMirrorPipe::setId(int id) { mUI.setId(id); }
inline void UIMirrorPipe::setMemoryId(int id) { mUI.setMemoryId(id); }
inline bool UIMirrorPipe::queueBuffer(uint32_t offset) {
return mUI.queueBuffer(offset); }
inline bool UIMirrorPipe::dequeueBuffer(void*& buf) {
return mUI.dequeueBuffer(buf); }
inline bool UIMirrorPipe::queueBuffer(int fd, uint32_t offset) {
return mUI.queueBuffer(fd, offset);
}
inline bool UIMirrorPipe::waitForVsync() {
return mUI.waitForVsync(); }
inline bool UIMirrorPipe::setCrop(const utils::Dim& dim) {
return mUI.setCrop(dim); }
inline bool UIMirrorPipe::start(const utils::PipeArgs& args) {
if(!mUI.start(args)) {
ALOGE("%s failed to start", __FUNCTION__);
return false;
}
return true;
}
inline bool UIMirrorPipe::setPosition(const utils::Dim& dim) {
inline bool UIMirrorPipe::setPosition(const utils::Dim& dim) {
ovutils::Dim pdim;
switch (dim.o) {
case 0:
case HAL_TRANSFORM_ROT_180:
//using utils::eTransform;
switch (mPrimFBOr) {
case utils::OVERLAY_TRANSFORM_0:
case utils::OVERLAY_TRANSFORM_ROT_180:
{
ovutils::Whf whf(dim.x, dim.y, 0);
ovutils::Whf whf(dim.w, dim.h, 0);
pdim = mUI.getAspectRatio(whf);
break;
}
case HAL_TRANSFORM_ROT_90:
case HAL_TRANSFORM_ROT_270:
case utils::OVERLAY_TRANSFORM_ROT_90:
case utils::OVERLAY_TRANSFORM_ROT_270:
{
// Calculate the Aspectratio for the UI in the landscape mode
// Width and height will be swapped as there is rotation
ovutils::Whf whf(dim.y, dim.x, 0);
ovutils::Whf whf(dim.h, dim.w, 0);
pdim = mUI.getAspectRatio(whf);
break;
}
@ -121,43 +108,43 @@ inline bool UIMirrorPipe::setPosition(const utils::Dim& dim) {
ALOGE("%s: Unknown orientation %d", __FUNCTION__, dim.o);
return false;
}
ovutils::even_out(pdim.x);
ovutils::even_out(pdim.y);
ovutils::even_out(pdim.w);
ovutils::even_out(pdim.h);
return mUI.setPosition(pdim);
}
inline bool UIMirrorPipe::setParameter(const utils::Params& param) {
OVASSERT(utils::OVERLAY_TRANSFORM_UI == param.param,
"%p Expecting OVERLAY_TRANSFORM_UI", __FUNCTION__);
inline bool UIMirrorPipe::setTransform(const utils::eTransform& param) {
int orientation = param.value;
//Cache the primary FB orientation, since the TV's will be 0, we need this
//info to translate later.
mPrimFBOr = param;
utils::eTransform transform = param;
// Figure out orientation to transform to
switch (param.value) {
case 0:
orientation = 0;
switch (param) {
case utils::OVERLAY_TRANSFORM_0:
transform = utils::OVERLAY_TRANSFORM_0;
break;
case HAL_TRANSFORM_ROT_180:
orientation = HAL_TRANSFORM_ROT_180;
case utils::OVERLAY_TRANSFORM_ROT_180:
//If prim FB is drawn 180 rotated, rotate by additional 180 to make
//it to 0, which is TV's orientation.
transform = utils::OVERLAY_TRANSFORM_ROT_180;
break;
case HAL_TRANSFORM_ROT_90:
orientation = HAL_TRANSFORM_ROT_270;
case utils::OVERLAY_TRANSFORM_ROT_90:
//If prim FB is drawn 90 rotated, rotate by additional 270 to make
//it to 0, which is TV's orientation.
transform = utils::OVERLAY_TRANSFORM_ROT_270;
break;
case HAL_TRANSFORM_ROT_270:
orientation = HAL_TRANSFORM_ROT_90;
case utils::OVERLAY_TRANSFORM_ROT_270:
//If prim FB is drawn 270 rotated, rotate by additional 90 to make
//it to 0, which is TV's orientation.
transform = utils::OVERLAY_TRANSFORM_ROT_90;
break;
default:
ALOGE("%s: Unknown orientation %d", __FUNCTION__, param.value);
ALOGE("%s: Unknown orientation %d", __FUNCTION__,
static_cast<int>(param));
return false;
}
ovutils::eTransform transform =
static_cast<ovutils::eTransform>(orientation);
const ovutils::Params prms (ovutils::OVERLAY_TRANSFORM, transform);
return mUI.setParameter(prms);
return mUI.setTransform(transform);
}
inline bool UIMirrorPipe::setSource(const utils::PipeArgs& args) {
@ -175,9 +162,6 @@ inline bool UIMirrorPipe::setSource(const utils::PipeArgs& args) {
return mUI.setSource(arg);
}
inline const utils::PipeArgs& UIMirrorPipe::getArgs() const {
return mUI.getArgs();
}
inline utils::eOverlayPipeType UIMirrorPipe::getOvPipeType() const {
return utils::OV_PIPE_TYPE_UI_MIRROR;
}

95
liboverlay/pipes/overlayHdmiPipe.h → liboverlay/pipes/overlayVideoExtPipe.h
View File

@ -27,8 +27,8 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef OVERLAY_HDMI_PIPE_H
#define OVERLAY_HDMI_PIPE_H
#ifndef OVERLAY_VIDEO_EXT_PIPE_H
#define OVERLAY_VIDEO_EXT_PIPE_H
#include "overlayGenPipe.h"
#include "overlayUtils.h"
@ -41,88 +41,79 @@ namespace overlay {
/* A specific impl of GenericPipe
* Whenever needed to have a pass through - we do it.
* If there is a special need for a different behavior - do it here */
class HdmiPipe : utils::NoCopy {
class VideoExtPipe : utils::NoCopy {
public:
/* Please look at overlayGenPipe.h for info */
explicit HdmiPipe();
~HdmiPipe();
bool open(RotatorBase* rot);
explicit VideoExtPipe();
~VideoExtPipe();
bool init(RotatorBase* rot);
bool close();
bool commit();
void setId(int id);
void setMemoryId(int id);
bool queueBuffer(uint32_t offset);
bool dequeueBuffer(void*& buf);
bool queueBuffer(int fd, uint32_t offset);
bool waitForVsync();
bool setCrop(const utils::Dim& dim);
bool start(const utils::PipeArgs& args);
bool setPosition(const utils::Dim& dim);
bool setParameter(const utils::Params& param);
bool setTransform(const utils::eTransform& param);
bool setSource(const utils::PipeArgs& args);
const utils::PipeArgs& getArgs() const;
utils::eOverlayPipeType getOvPipeType() const;
void dump() const;
private:
overlay::GenericPipe<ovutils::EXTERNAL> mHdmi;
overlay::GenericPipe<ovutils::EXTERNAL> mVideoExt;
};
//------------------Inlines -----------------------------
inline HdmiPipe::HdmiPipe() {}
inline HdmiPipe::~HdmiPipe() { close(); }
inline bool HdmiPipe::open(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "HdmiPipe open");
return mHdmi.open(rot);
inline VideoExtPipe::VideoExtPipe() {}
inline VideoExtPipe::~VideoExtPipe() { close(); }
inline bool VideoExtPipe::init(RotatorBase* rot) {
ALOGE_IF(DEBUG_OVERLAY, "VideoExtPipe init");
return mVideoExt.init(rot);
}
inline bool HdmiPipe::close() { return mHdmi.close(); }
inline bool HdmiPipe::commit() { return mHdmi.commit(); }
inline void HdmiPipe::setId(int id) { mHdmi.setId(id); }
inline void HdmiPipe::setMemoryId(int id) { mHdmi.setMemoryId(id); }
inline bool HdmiPipe::queueBuffer(uint32_t offset) {
return mHdmi.queueBuffer(offset); }
inline bool HdmiPipe::dequeueBuffer(void*& buf) {
return mHdmi.dequeueBuffer(buf); }
inline bool HdmiPipe::waitForVsync() {
return mHdmi.waitForVsync(); }
inline bool HdmiPipe::setCrop(const utils::Dim& dim) {
return mHdmi.setCrop(dim); }
inline bool HdmiPipe::start(const utils::PipeArgs& args) {
return mHdmi.start(args); }
inline bool HdmiPipe::setPosition(const utils::Dim& dim)
inline bool VideoExtPipe::close() { return mVideoExt.close(); }
inline bool VideoExtPipe::commit() { return mVideoExt.commit(); }
inline bool VideoExtPipe::queueBuffer(int fd, uint32_t offset) {
return mVideoExt.queueBuffer(fd, offset);
}
inline bool VideoExtPipe::waitForVsync() {
return mVideoExt.waitForVsync();
}
inline bool VideoExtPipe::setCrop(const utils::Dim& dim) {
return mVideoExt.setCrop(dim);
}
inline bool VideoExtPipe::setPosition(const utils::Dim& dim)
{
utils::Dim d;
// Need to change dim to aspect ratio
if (utils::FrameBufferInfo::getInstance()->supportTrueMirroring()) {
// Use dim info to calculate aspect ratio for true UI mirroring
d = mHdmi.getAspectRatio(dim);
d = mVideoExt.getAspectRatio(dim);
} else {
// Use cached crop data to get aspect ratio
utils::Dim crop = mHdmi.getCrop();
utils::Dim crop = mVideoExt.getCrop();
utils::Whf whf(crop.w, crop.h, 0);
d = mHdmi.getAspectRatio(whf);
d = mVideoExt.getAspectRatio(whf);
}
ALOGE_IF(DEBUG_OVERLAY, "Calculated aspect ratio for HDMI: x=%d, y=%d, w=%d, h=%d, o=%d",
ALOGE_IF(DEBUG_OVERLAY, "Calculated aspect ratio for EXT: x=%d, y=%d, w=%d,"
"h=%d, o=%d",
d.x, d.y, d.w, d.h, d.o);
return mHdmi.setPosition(d);
return mVideoExt.setPosition(d);
}
inline bool HdmiPipe::setParameter(const utils::Params& param) {
return mHdmi.setParameter(param); }
inline bool HdmiPipe::setSource(const utils::PipeArgs& args) {
inline bool VideoExtPipe::setTransform(const utils::eTransform& param) {
return mVideoExt.setTransform(param);
}
inline bool VideoExtPipe::setSource(const utils::PipeArgs& args) {
utils::PipeArgs arg(args);
return mHdmi.setSource(arg);
return mVideoExt.setSource(arg);
}
inline const utils::PipeArgs& HdmiPipe::getArgs() const {
return mHdmi.getArgs();
inline utils::eOverlayPipeType VideoExtPipe::getOvPipeType() const {
return utils::OV_PIPE_TYPE_VIDEO_EXT;
}
inline utils::eOverlayPipeType HdmiPipe::getOvPipeType() const {
return utils::OV_PIPE_TYPE_HDMI;
}
inline void HdmiPipe::dump() const {
ALOGE("HDMI Pipe");
mHdmi.dump();
inline void VideoExtPipe::dump() const {
ALOGE("Video Ext Pipe");
mVideoExt.dump();
}
} // overlay
#endif // OVERLAY_HDMI_PIPE_H
#endif // OVERLAY_VIDEO_EXT_PIPE_H