android/android_hardware_qcom_display
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
jellybean
android_hardware_qcom_display/liboverlay/overlayState.h
Prashant Surana cc5cb1781c Add support for PIP, picture in picture feature 
Add a new state and required implementation in new overlay to support playback
of two videos using overlay.
Add a new class VideoPIP to handle the pip feature.

Change-Id: Ibce7044bc1216cba77bd952e191aed5472ed6737
2012-09-12 23:07:49 -05:00

605 lines
21 KiB
C++
Raw Permalink Blame History

/*
* 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.
*/
#ifndef OVERLAY_STATE_H
#define OVERLAY_STATE_H
#include "overlayUtils.h"
#include "overlayImpl.h"
#include "overlayRotator.h"
#include "pipes/overlayGenPipe.h"
#include "pipes/overlayVideoExtPipe.h"
#include "pipes/overlayUIMirrorPipe.h"
#include "pipes/overlay3DPipe.h"
namespace overlay {
/*
* Used by Overlay class. Invokes each event
* */
class OverlayState : utils::NoCopy {
public:
/*ctor*/
explicit OverlayState();
/*dtor*/
~OverlayState();
/* return current state */
utils::eOverlayState state() const;
/* Hard reset to a new state. If the state is the same
* as the current one, it would be a no-op */
OverlayImplBase* reset(utils::eOverlayState s);
/* Caller pass the state to the handleEvent function.
* The input is the current OverlayImplBase*, and output is
* a pointer to (possibly new) instance of OverlayImplBase
* The eFormat can be 2D/3D etc. */
OverlayImplBase* handleEvent(utils::eOverlayState s,
OverlayImplBase* ov);
/* Dump */
void dump() const;
private:
/* Transitions from a state to a state. Default behavior is to move from an
* old state to CLOSED and from CLOSED to a new state. Any impl wishing to
* copy pipes should specialize this call */
template<utils::eOverlayState FROM_STATE, utils::eOverlayState TO_STATE>
OverlayImplBase* handle_from_to(OverlayImplBase* ov);
/* Just a convenient intermediate function to bring down the number of
* combinations arising from multiple states */
template<utils::eOverlayState FROM_STATE>
OverlayImplBase* handle_from(utils::eOverlayState toState,
OverlayImplBase* ov);
/* Substitues for partially specialized templated handle functions since the
* standard doesn't allow partial specialization of functions */
template<utils::eOverlayState FROM_STATE>
OverlayImplBase* handle_xxx_to_CLOSED(OverlayImplBase* ov);
template<utils::eOverlayState TO_STATE>
OverlayImplBase* handle_CLOSED_to_xxx(OverlayImplBase* ov);
/* States here */
utils::eOverlayState mState;
};
//------------------------State Traits --------------------------
// primary has nothing
template <int STATE> struct StateTraits {};
/*
* For 3D_xxx we need channel ID besides the FBx since
* get crop/position 3D need that to determine pos/crop
* info.
* */
template <> struct StateTraits<utils::OV_2D_VIDEO_ON_PANEL>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0; //prim video
typedef overlay::NullPipe pipe1; // place holder
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_2D_VIDEO_ON_PANEL_TV>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0; //prim video
typedef overlay::VideoExtPipe pipe1; //ext video
typedef overlay::GenericPipe<utils::EXTERNAL> pipe2; //ext subtitle
typedef Rotator rot0;
typedef Rotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_2D_VIDEO_ON_TV>
{
typedef overlay::NullPipe pipe0; //nothing on primary with mdp
typedef overlay::VideoExtPipe pipe1; //ext video
typedef overlay::GenericPipe<utils::EXTERNAL> pipe2; //ext subtitle
typedef NullRotator rot0;
typedef Rotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_3D_VIDEO_ON_2D_PANEL>
{
typedef overlay::M3DPrimaryPipe<utils::OV_PIPE0> pipe0;
typedef overlay::NullPipe pipe1; // place holder
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0> ovimpl;
};
template <> struct StateTraits<utils::OV_3D_VIDEO_ON_3D_PANEL>
{
typedef overlay::S3DPrimaryPipe<utils::OV_PIPE0> pipe0;
typedef overlay::S3DPrimaryPipe<utils::OV_PIPE1> pipe1;
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef Rotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1> ovimpl;
};
template <> struct StateTraits<utils::OV_3D_VIDEO_ON_3D_TV>
{
typedef overlay::S3DExtPipe<utils::OV_PIPE0> pipe0;
typedef overlay::S3DExtPipe<utils::OV_PIPE1> pipe1;
typedef overlay::NullPipe pipe2; // place holder
typedef NullRotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1> ovimpl;
};
template <> struct StateTraits<utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV>
{
typedef overlay::M3DPrimaryPipe<utils::OV_PIPE0> pipe0;
typedef overlay::M3DExtPipe<utils::OV_PIPE1> pipe1;
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1> ovimpl;
};
template <> struct StateTraits<utils::OV_2D_PIP_VIDEO_ON_PANEL>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0; //prim video
typedef overlay::GenericPipe<utils::PRIMARY> pipe1; //PIP video
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef Rotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1> ovimpl;
};
template <> struct StateTraits<utils::OV_UI_MIRROR>
{
typedef overlay::UIMirrorPipe pipe0;
typedef overlay::NullPipe pipe1; // place holder
typedef overlay::NullPipe pipe2; // place holder
typedef Rotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_2D_TRUE_UI_MIRROR>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0;
typedef overlay::VideoExtPipe pipe1;
typedef overlay::UIMirrorPipe pipe2;
typedef Rotator rot0;
typedef Rotator rot1;
typedef Rotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_BYPASS_1_LAYER>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0;
typedef overlay::NullPipe pipe1; // place holder
typedef overlay::NullPipe pipe2; // place holder
typedef NullRotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_BYPASS_2_LAYER>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0;
typedef overlay::GenericPipe<utils::PRIMARY> pipe1;
typedef overlay::NullPipe pipe2; // place holder
typedef NullRotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_BYPASS_3_LAYER>
{
typedef overlay::GenericPipe<utils::PRIMARY> pipe0;
typedef overlay::GenericPipe<utils::PRIMARY> pipe1;
typedef overlay::GenericPipe<utils::PRIMARY> pipe2;
typedef NullRotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
template <> struct StateTraits<utils::OV_DUAL_DISP>
{
typedef overlay::GenericPipe<utils::EXTERNAL> pipe0;
typedef overlay::NullPipe pipe1;
typedef overlay::NullPipe pipe2;
typedef NullRotator rot0;
typedef NullRotator rot1;
typedef NullRotator rot2;
typedef overlay::OverlayImpl<pipe0, pipe1, pipe2> ovimpl;
};
//------------------------Inlines --------------------------------
inline OverlayState::OverlayState() : mState(utils::OV_CLOSED){}
inline OverlayState::~OverlayState() {}
inline utils::eOverlayState OverlayState::state() const { return mState; }
inline OverlayImplBase* OverlayState::reset(utils::eOverlayState s) {
return handleEvent(s, 0);
}
inline void OverlayState::dump() const {
ALOGE("== Dump state %d start/end ==", mState);
}
inline OverlayImplBase* OverlayState::handleEvent(utils::eOverlayState toState,
OverlayImplBase* ov)
{
OverlayImplBase* newov = ov; // at least, we return the same
if (mState != toState) {
ALOGD_IF(DEBUG_OVERLAY, "%s: state changed %s-->%s",
__FUNCTION__, getStateString(mState), getStateString(toState));
} else {
ALOGD_IF(DEBUG_OVERLAY, "%s: no state change, state=%s",
__FUNCTION__, getStateString(toState));
return newov;
}
switch(mState)
{
case utils::OV_CLOSED:
newov = handle_from<utils::OV_CLOSED>(toState, ov);
break;
case utils::OV_2D_VIDEO_ON_PANEL:
newov = handle_from<utils::OV_2D_VIDEO_ON_PANEL>(toState, ov);
break;
case utils::OV_2D_VIDEO_ON_PANEL_TV:
newov = handle_from<utils::OV_2D_VIDEO_ON_PANEL_TV>(toState, ov);
break;
case utils::OV_2D_VIDEO_ON_TV:
newov = handle_from<utils::OV_2D_VIDEO_ON_TV>(toState, ov);
break;
case utils::OV_3D_VIDEO_ON_2D_PANEL:
newov = handle_from<utils::OV_3D_VIDEO_ON_2D_PANEL>(toState, ov);
break;
case utils::OV_3D_VIDEO_ON_3D_PANEL:
newov = handle_from<utils::OV_3D_VIDEO_ON_3D_PANEL>(toState, ov);
break;
case utils::OV_3D_VIDEO_ON_3D_TV:
newov = handle_from<utils::OV_3D_VIDEO_ON_3D_TV>(toState, ov);
break;
case utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV:
newov = handle_from<utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV>(toState,
ov);
break;
case utils::OV_2D_PIP_VIDEO_ON_PANEL:
newov = handle_from<utils::OV_2D_PIP_VIDEO_ON_PANEL>(toState,ov);
break;
case utils::OV_UI_MIRROR:
newov = handle_from<utils::OV_UI_MIRROR>(toState, ov);
break;
case utils::OV_2D_TRUE_UI_MIRROR:
newov = handle_from<utils::OV_2D_TRUE_UI_MIRROR>(toState, ov);
break;
case utils::OV_BYPASS_1_LAYER:
newov = handle_from<utils::OV_BYPASS_1_LAYER>(toState, ov);
break;
case utils::OV_BYPASS_2_LAYER:
newov = handle_from<utils::OV_BYPASS_2_LAYER>(toState, ov);
break;
case utils::OV_BYPASS_3_LAYER:
newov = handle_from<utils::OV_BYPASS_3_LAYER>(toState, ov);
break;
case utils::OV_DUAL_DISP:
newov = handle_from<utils::OV_DUAL_DISP>(toState, ov);
break;
default:
OVASSERT(1 == 0, "%s: unknown state = %d", __FUNCTION__, mState);
}
return newov;
}
template <utils::eOverlayState FROM_STATE>
inline OverlayImplBase* OverlayState::handle_from(utils::eOverlayState toState,
OverlayImplBase* ov) {
switch(toState)
{
case utils::OV_CLOSED:
ov = handle_xxx_to_CLOSED<FROM_STATE>(ov);
break;
case utils::OV_2D_VIDEO_ON_PANEL:
ov = handle_from_to<FROM_STATE, utils::OV_2D_VIDEO_ON_PANEL>(ov);
break;
case utils::OV_2D_VIDEO_ON_PANEL_TV:
ov = handle_from_to<FROM_STATE, utils::OV_2D_VIDEO_ON_PANEL_TV>(ov);
break;
case utils::OV_2D_VIDEO_ON_TV:
ov = handle_from_to<FROM_STATE, utils::OV_2D_VIDEO_ON_TV>(ov);
break;
case utils::OV_3D_VIDEO_ON_2D_PANEL:
ov = handle_from_to<FROM_STATE, utils::OV_3D_VIDEO_ON_2D_PANEL>(ov);
break;
case utils::OV_3D_VIDEO_ON_3D_PANEL:
ov = handle_from_to<FROM_STATE, utils::OV_3D_VIDEO_ON_3D_PANEL>(ov);
break;
case utils::OV_3D_VIDEO_ON_3D_TV:
ov = handle_from_to<FROM_STATE, utils::OV_3D_VIDEO_ON_3D_TV>(ov);
break;
case utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV:
ov = handle_from_to<FROM_STATE,
utils::OV_3D_VIDEO_ON_2D_PANEL_2D_TV>(ov);
break;
case utils::OV_2D_PIP_VIDEO_ON_PANEL:
ov = handle_from_to<FROM_STATE, utils::OV_2D_PIP_VIDEO_ON_PANEL>(ov);
break;
case utils::OV_UI_MIRROR:
ov = handle_from_to<FROM_STATE, utils::OV_UI_MIRROR>(ov);
break;
case utils::OV_2D_TRUE_UI_MIRROR:
ov = handle_from_to<FROM_STATE, utils::OV_2D_TRUE_UI_MIRROR>(ov);
break;
case utils::OV_BYPASS_1_LAYER:
ov = handle_from_to<FROM_STATE, utils::OV_BYPASS_1_LAYER>(ov);
break;
case utils::OV_BYPASS_2_LAYER:
ov = handle_from_to<FROM_STATE, utils::OV_BYPASS_2_LAYER>(ov);
break;
case utils::OV_BYPASS_3_LAYER:
ov = handle_from_to<FROM_STATE, utils::OV_BYPASS_3_LAYER>(ov);
break;
case utils::OV_DUAL_DISP:
ov = handle_from_to<FROM_STATE, utils::OV_DUAL_DISP>(ov);
break;
default:
OVASSERT(1 == 0, "%s: unknown state = %d", __FUNCTION__, toState);
}
mState = toState;
return ov;
}
/* Transition default from any to any. Does in two steps.
* Moves from OLD to CLOSED and then from CLOSED to NEW
*/
template<utils::eOverlayState FROM_STATE, utils::eOverlayState TO_STATE>
inline OverlayImplBase* OverlayState::handle_from_to(OverlayImplBase* ov) {
handle_xxx_to_CLOSED<FROM_STATE>(ov);
return handle_CLOSED_to_xxx<TO_STATE>(ov);
}
//---------------Specializations-------------
/* Transition from CLOSED to ANY */
template<utils::eOverlayState TO_STATE>
inline OverlayImplBase* OverlayState::handle_CLOSED_to_xxx(
OverlayImplBase* /*ignored*/) {
//If going from CLOSED to CLOSED, nothing to do.
if(TO_STATE == utils::OV_CLOSED) return NULL;
ALOGD("FROM_STATE = %s TO_STATE = %s",
utils::getStateString(utils::OV_CLOSED),
utils::getStateString(TO_STATE));
OverlayImplBase* ov = new typename StateTraits<TO_STATE>::ovimpl;
RotatorBase* rot0 = new typename StateTraits<TO_STATE>::rot0;
RotatorBase* rot1 = new typename StateTraits<TO_STATE>::rot1;
RotatorBase* rot2 = new typename StateTraits<TO_STATE>::rot2;
if(!ov->init(rot0, rot1, rot2)) {
ALOGE("Overlay failed to init in state %d", TO_STATE);
return 0;
}
return ov;
}
/* Transition from ANY to CLOSED */
template<utils::eOverlayState FROM_STATE>
inline OverlayImplBase* OverlayState::handle_xxx_to_CLOSED(OverlayImplBase* ov)
{
//If going from CLOSED to CLOSED, nothing to do.
if(FROM_STATE == utils::OV_CLOSED) return NULL;
ALOGD("FROM_STATE = %s TO_STATE = %s",
utils::getStateString(FROM_STATE),
utils::getStateString(utils::OV_CLOSED));
OVASSERT(ov, "%s: ov is null", __FUNCTION__);
if(!ov->close()) {
ALOGE("%s: Failed to ov close", __FUNCTION__);
}
delete ov;
ov = 0;
return 0;
}
/* Transition from 2D_VIDEO_ON_PANEL to 2D_VIDEO_ON_PANEL_TV */
template<>
inline OverlayImplBase* OverlayState::handle_from_to<
utils::OV_2D_VIDEO_ON_PANEL,
utils::OV_2D_VIDEO_ON_PANEL_TV>(
OverlayImplBase* ov) {
OVASSERT(ov, "%s: ov is null", __FUNCTION__);
ALOGD("FROM_STATE = %s TO_STATE = %s",
utils::getStateString(utils::OV_2D_VIDEO_ON_PANEL),
utils::getStateString(utils::OV_2D_VIDEO_ON_PANEL_TV));
// Create new ovimpl based on new state
typedef StateTraits<utils::OV_2D_VIDEO_ON_PANEL_TV> NewState;
OverlayImplBase* newov = new NewState::ovimpl;
//copy pipe0/rot0 (primary video)
newov->copyOvPipe(ov, utils::OV_PIPE0);
//close old pipe1, create new pipe1
ov->closePipe(utils::OV_PIPE1);
RotatorBase* rot1 = new NewState::rot1;
newov->initPipe(rot1, utils::OV_PIPE1);
//close old pipe2, create new pipe2
ov->closePipe(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
delete ov;
ov = 0;
return newov;
}
/* Transition from 2D_VIDEO_ON_PANEL_TV to 2D_VIDEO_ON_PANEL */
template<>
inline OverlayImplBase* OverlayState::handle_from_to<
utils::OV_2D_VIDEO_ON_PANEL_TV,
utils::OV_2D_VIDEO_ON_PANEL>(
OverlayImplBase* ov) {
OVASSERT(ov, "%s: ov is null", __FUNCTION__);
ALOGD("FROM_STATE = %s TO_STATE = %s",
utils::getStateString(utils::OV_2D_VIDEO_ON_PANEL_TV),
utils::getStateString(utils::OV_2D_VIDEO_ON_PANEL));
// Create new ovimpl based on new state
typedef StateTraits<utils::OV_2D_VIDEO_ON_PANEL> NewState;
OverlayImplBase* newov = new NewState::ovimpl;
//copy pipe0/rot0 (primary video)
newov->copyOvPipe(ov, utils::OV_PIPE0);
//close old pipe1, create new pipe1
ov->closePipe(utils::OV_PIPE1);
RotatorBase* rot1 = new NewState::rot1;
newov->initPipe(rot1, utils::OV_PIPE1);
//close old pipe2, create new pipe2
ov->closePipe(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
delete ov;
ov = 0;
return newov;
}
/* Transition from 2D_VIDEO_ON_PANEL_TV to 2D_VIDEO_ON_TV */
template<>
inline OverlayImplBase* OverlayState::handle_from_to<
utils::OV_2D_VIDEO_ON_PANEL_TV,
utils::OV_2D_VIDEO_ON_TV>(
OverlayImplBase* ov) {
OVASSERT(ov, "%s: ov is null", __FUNCTION__);
ALOGD("FROM_STATE = %s TO_STATE = %s",
utils::getStateString(utils::OV_2D_VIDEO_ON_PANEL_TV),
utils::getStateString(utils::OV_2D_VIDEO_ON_TV));
// Create new ovimpl based on new state
typedef StateTraits<utils::OV_2D_VIDEO_ON_TV> NewState;
OverlayImplBase* newov = new NewState::ovimpl;
//close old pipe0, create new pipe0
ov->closePipe(utils::OV_PIPE0);
RotatorBase* rot0 = new NewState::rot0;
newov->initPipe(rot0, utils::OV_PIPE0);
//copy pipe1/rot1 (ext video)
newov->copyOvPipe(ov, utils::OV_PIPE1);
//copy pipe2/rot2 (ext cc)
newov->copyOvPipe(ov, utils::OV_PIPE2);
// All pipes are copied or deleted so no more need for previous ovimpl
delete ov;
ov = 0;
return newov;
}
/* Transition from 2D_VIDEO_ON_TV to 2D_VIDEO_ON_PANEL_TV */
template<>
inline OverlayImplBase* OverlayState::handle_from_to<
utils::OV_2D_VIDEO_ON_TV,
utils::OV_2D_VIDEO_ON_PANEL_TV>(
OverlayImplBase* ov) {
OVASSERT(ov, "%s: ov is null", __FUNCTION__);
ALOGD("FROM_STATE = %s TO_STATE = %s",
utils::getStateString(utils::OV_2D_VIDEO_ON_TV),
utils::getStateString(utils::OV_2D_VIDEO_ON_PANEL_TV));
// Create new ovimpl based on new state
typedef StateTraits<utils::OV_2D_VIDEO_ON_PANEL_TV> NewState;
OverlayImplBase* newov = new NewState::ovimpl;
//close old pipe0, create new pipe0
ov->closePipe(utils::OV_PIPE0);
RotatorBase* rot0 = new NewState::rot0;
newov->initPipe(rot0, utils::OV_PIPE0);
//copy pipe1/rot1 (ext video)
newov->copyOvPipe(ov, utils::OV_PIPE1);
//copy pipe2/rot2 (ext cc)
newov->copyOvPipe(ov, utils::OV_PIPE2);
// All pipes are copied or deleted so no more need for previous ovimpl
delete ov;
ov = 0;
return newov;
}
} // overlay
#endif // OVERLAY_STATE_H
Reference in New Issue View Git Blame Copy Permalink