liboverlay/overlayRotator.cpp

/*
* Copyright (C) 2008 The Android Open Source Project
* Copyright (c) 2010-2012, Code Aurora Forum. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include "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;
}

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);
    }

    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;
}

} // utils

bool MdpRot::open()
{
    if(!mFd.open(Res::rotPath, O_RDWR)){
        ALOGE("MdpRot failed to open %s", Res::rotPath);
        return false;
    }
    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)){
        ALOGE("%s: Failed to open", __func__);
        mem.close();
        return false;
    }

    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)) {
        if(!mdp_wrapper::endRotator(mFd.getFD(), getSessId())) {
            ALOGE("Mdp Rot error endRotator, fd=%d sessId=%d",
                    mFd.getFD(), getSessId());
            success = false;
        }
    }
    if (!mFd.close()) {
        ALOGE("Mdp Rot error closing fd");
        success = false;
    }
    if (!mMem.close()) {
        ALOGE("Mdp Rot error closing mem");
        success = false;
    }
    reset();
    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) {
    // 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);
        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)) {
        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;
    }
    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;
}

bool MdpRot::prepareQueueBuf(uint32_t offset) {
    // FIXME if it fails, what happens to the above current item?
    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.offset = offset;
        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");
            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__);
        }
    }
    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 ==");
}
}