/*
* Copyright (c) 2011-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.
*/

#include "overlayUtils.h"
#include "overlayImpl.h"
#include "overlay.h"

// MDP related FIXME move to state
#include "overlayMdp.h"
#include "overlayCtrlData.h"
#include "overlayRotator.h"

namespace overlay {

Overlay::Overlay(): mOv(0) {
}

Overlay::~Overlay() {
    if(mState.state() == utils::OV_CLOSED) return;
    close();
    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:
        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->commit(dest)) {
                ALOGE("Overlay %s failed", __FUNCTION__);
                return false;
            }
            break;
        default:
            OVASSERT(false, "%s Unknown state %d", __FUNCTION__, st);
            return false;
    }
    return true;
}

bool Overlay::queueBuffer(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:
        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->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)) {
                ALOGE("Overlay %s failed", __FUNCTION__);
                return false;
            }
            break;
        default:
            OVASSERT(false, "%s Unknown state %d", __FUNCTION__, st);
            return false;
    }
    return true;
}

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:
        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->waitForVsync(dest)) {
                ALOGE("Overlay %s failed", __FUNCTION__);
                return false;
            }
            break;
        default:
            OVASSERT(false, "%s Unknown state %d", __FUNCTION__, st);
            return false;
    }
    return true;
}

bool Overlay::setCrop(const utils::Dim& d,
        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->setCrop(d, dest)) {
                ALOGE("Overlay %s failed", __FUNCTION__);
                return false;
            }
            break;
        default:
            OVASSERT(false, "%s Unknown state %d", __FUNCTION__, st);
            return false;
    }
    return true;
}
bool Overlay::setPosition(const utils::Dim& d,
        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->setPosition(d, dest)) {
                ALOGE("Overlay %s failed", __FUNCTION__);
                return false;
            }
            break;
        default:
            OVASSERT(false, "setPos Unknown state %d", st);
            return false;
    }
    return true;
}
bool Overlay::setParameter(const utils::Params& param,
        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->setParameter(param, dest)) {
                ALOGE("Overlay %s failed", __FUNCTION__);
                return false;
            }
            break;
        default:
            OVASSERT(false, "%s Unknown state %d", __FUNCTION__ , st);
            return false;
    }
    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;
            }
            break;
        case utils::OV_2D_VIDEO_ON_PANEL:
        case utils::OV_3D_VIDEO_ON_2D_PANEL:
        case utils::OV_UI_MIRROR:
        case utils::OV_BYPASS_1_LAYER:
        case utils::OV_BYPASS_2_LAYER:
        case utils::OV_BYPASS_3_LAYER:
            // no tweaking
            break;
        case utils::OV_3D_VIDEO_ON_3D_PANEL:
        case utils::OV_3D_VIDEO_ON_3D_TV:
            margs[utils::CHANNEL_1].zorder = utils::ZORDER_1;
            break;
        case utils::OV_2D_VIDEO_ON_PANEL_TV:
        case utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV:
            // If displaying on both, external VG pipe set to be no wait
            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
            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
            margs[utils::CHANNEL_0].wait = utils::WAIT;
            margs[utils::CHANNEL_1].wait = utils::NO_WAIT;
            margs[utils::CHANNEL_2].wait = utils::NO_WAIT;
            break;
        default:
            OVASSERT(false, "%s Unknown state %d", __FUNCTION__, st);
            return false;
    }

    if (!mOv->setSource(margs, dest)) {
        ALOGE("Overlay %s failed", __FUNCTION__);
        return false;
    }

    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();
    ALOGE("== Dump Overlay end ==");
}

void Overlay::setState(utils::eOverlayState s) {
    mOv = mState.handleEvent(s, mOv);
}

utils::eOverlayState Overlay::getState() const {
    return mState.state();
}

Overlay *Overlay::sInstance = 0;

Overlay* Overlay::getInstance() {
    if(sInstance == NULL)
        sInstance = new Overlay();
    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