liboverlay/overlayCtrlData.h

/*
* Copyright (c) 2012, 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
* met:
*    * Redistributions of source code must retain the above copyright
*      notice, this list of conditions and the following disclaimer.
*    * Redistributions in binary form must reproduce the above
*      copyright notice, this list of conditions and the following
*      disclaimer in the documentation and/or other materials provided
*      with the distribution.
*    * Neither the name of Code Aurora Forum, Inc. nor the names of its
*      contributors may be used to endorse or promote products derived
*      from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef OVERLAY_CTRLDATA_H
#define OVERLAY_CTRLDATA_H

#include "overlayUtils.h"
#include "overlayMdp.h"
#include "gralloc_priv.h" // INTERLACE_MASK

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

    /* 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);

    /* mdp set overlay/commit changes */
    bool commit();

    /* ctrl id */
    int  getId() 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;

    /* access for screen info */
    utils::ScreenInfo getScreenInfo() const;

    /* retrieve cached crop data */
    utils::Dim getCrop() const;

    /* dump the state of the object */
    void dump() const;

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 */
    explicit Data();

    /* calls close */
    ~Data();

    /* should open devices? or start()? */
    bool open(uint32_t fbnum, RotatorBase* rot);

    /* 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);

    /* get overlay id in the mdp struct */
    int getId() const;

    /* queue buffer to the overlay */
    bool queueBuffer(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.
 * Although this was legacy design, this separation still makes sense, since we
 * need to use the Ctrl channel in hwc_prepare (i.e config stage) and Data
 * channel in hwc_set (i.e draw stage)
 */
struct CtrlData {
    Ctrl ctrl;
    Data data;
};

//-------------Inlines-------------------------------

inline Ctrl::Ctrl() : mRot(0), mOrient(utils::OVERLAY_TRANSFORM_0) {
    mMdp.reset();
}

inline Ctrl::~Ctrl() {
    close();
}

inline bool Ctrl::close() {
    // do not close the rotator
    if(!mMdp.close())
        return false;
    return true;
}

inline bool Ctrl::commit() {
    if(!mMdp.set()) {
        ALOGE("Ctrl commit failed set overlay");
        return false;
    }
    return true;
}

inline bool Ctrl::getScreenInfo(utils::ScreenInfo& info) {
    if(!mMdp.getScreenInfo(info)){
        ALOGE("Ctrl failed to get screen info");
        return false;
    }
    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::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;
}



inline Data::Data() : mRot(0) {
    mMdp.reset();
}

inline Data::~Data() { close(); }

inline void Data::setRot(RotatorBase* rot) { mRot = rot; }

inline void Data::setMemoryId(int id) { mMdp.setMemoryId(id); }

// 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");
        return false;
    }

    OVASSERT(rot, "rot is null");
    mRot = rot;

    // rotator should be already opened here
    return true;
}

inline bool Data::close() {
    if(!mMdp.close()) {
        ALOGE("Data close failed");
        return false;
    }
    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::waitForVsync() {

    // Call mdp playWait
    if(!this->playWait()){
        ALOGE("Error in MDP playWait");
        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 ==");
}


} // overlay

#endif