liboverlay: Refactor, bug-fixes, upgrade.
* Fix memory leak during copying pipe objects.
* Remove unused / unnecessary code.
* setMemoryId API is merged with queueBuffer.
* setParameter API is setTransform now.
* Rotator upgraded to:
--Allow different rotator hardware types.
--Remove dependency on MDP code.
--Allocate memory only during first playback,
close when the associated pipe is closed.
* Have single commit implementation.
* Include new format types.
* Remove WAIT and CHANNEL enums and usage. Replace BypassPipe with
GenericPipe. Client expected to set alignments and parameters.
Add transform combination enums.
* Allow APIs to be called in any order. Do transform calcs in commit.
Move ext type setter and getter functions.
* Add calculations for 180 transform.
* Add secure session support in rotator
* Implement all rotations in terms of H flip, V flip and 90 rotation.
Change-Id: I34a9a2a0f1255b3467a0abbaa254d0b584e901ce
diff --git a/liboverlay/overlayRotator.cpp b/liboverlay/overlayRotator.cpp
index 30c5ea5..306e28f 100644
--- a/liboverlay/overlayRotator.cpp
+++ b/liboverlay/overlayRotator.cpp
@@ -17,72 +17,110 @@
#include "overlayRotator.h"
#include "overlayUtils.h"
-#include "overlayMdp.h"
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::setFlags(const utils::eMdpFlags& flags) {
+ mRotImgInfo.secure = 0;
+ if(flags & utils::OV_MDP_SECURE_OVERLAY_SESSION)
+ mRotImgInfo.secure = 1;
+}
+
+void MdpRot::setTransform(const utils::eTransform& rot, const bool& rotUsed)
+{
+ mOrientation = rot;
+ int r = utils::getMdpOrient(rot);
+ ALOGE_IF(DEBUG_OVERLAY, "%s: r=%d", __FUNCTION__, r);
+ setRotations(r);
+ setDisable();
+ if(rotUsed) {
+ setEnable();
+ }
+}
+
+void MdpRot::doTransform() {
+ switch(mOrientation) {
+ case utils::OVERLAY_TRANSFORM_ROT_90:
+ case utils::OVERLAY_TRANSFORM_ROT_90_FLIP_H:
+ case utils::OVERLAY_TRANSFORM_ROT_90_FLIP_V:
+ case utils::OVERLAY_TRANSFORM_ROT_270:
+ utils::swap(mRotImgInfo.dst.width, mRotImgInfo.dst.height);
+ break;
+ default:
+ break;
+ }
+}
+
+bool MdpRot::commit() {
+ doTransform();
+ 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;
OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i");
- if(!mem.open(numbufs, bufsz)){
+ if(!mem.open(numbufs, bufsz, mRotImgInfo.secure)){
ALOGE("%s: Failed to open", __func__);
mem.close();
return false;
@@ -91,25 +129,12 @@
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 +156,78 @@
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;
+ mOrientation = utils::OVERLAY_TRANSFORM_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 ==");
}
}