You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
465 lines
15 KiB
465 lines
15 KiB
/* |
|
* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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_M3D_EXT_PIPE_H |
|
#define OVERLAY_M3D_EXT_PIPE_H |
|
|
|
#include "overlayGenPipe.h" |
|
#include "overlayUtils.h" |
|
|
|
namespace overlay { |
|
|
|
///////////// M3DExt Pipe //////////////////////////// |
|
/** |
|
* A specific impl of GenericPipe for 3D. |
|
* Whenever needed to have a pass through - we do it. |
|
* If there is a special need for special/diff behavior |
|
* do it here |
|
* PANEL is always EXTERNAL for this pipe. |
|
* CHAN = 0,1 it's either Channel 1 or channel 2 needed for |
|
* 3D crop and position */ |
|
template <int CHAN> |
|
class M3DExtPipe : utils::NoCopy { |
|
public: |
|
/* Please look at overlayGenPipe.h for info */ |
|
explicit M3DExtPipe(); |
|
~M3DExtPipe(); |
|
bool init(RotatorBase* rot); |
|
bool close(); |
|
bool commit(); |
|
bool queueBuffer(int fd, uint32_t offset); |
|
bool setCrop(const utils::Dim& d); |
|
bool setPosition(const utils::Dim& dim); |
|
bool setTransform(const utils::eTransform& param); |
|
bool setSource(const utils::PipeArgs& args); |
|
void dump() const; |
|
private: |
|
overlay::GenericPipe<utils::EXTERNAL> mM3d; |
|
// Cache the M3D format |
|
uint32_t mM3Dfmt; |
|
}; |
|
|
|
///////////// M3DPrimary Pipe //////////////////////////// |
|
/** |
|
* A specific impl of GenericPipe for 3D. |
|
* Whenever needed to have a pass through - we do it. |
|
* If there is a special need for special/diff behavior |
|
* do it here |
|
* PANEL is always PRIMARY for this pipe. |
|
* CHAN = 0,1 it's either Channel 1 or channel 2 needed for |
|
* 3D crop and position */ |
|
template <int CHAN> |
|
class M3DPrimaryPipe : utils::NoCopy { |
|
public: |
|
/* Please look at overlayGenPipe.h for info */ |
|
explicit M3DPrimaryPipe(); |
|
~M3DPrimaryPipe(); |
|
bool init(RotatorBase* rot); |
|
bool close(); |
|
bool commit(); |
|
bool queueBuffer(int fd, uint32_t offset); |
|
bool setCrop(const utils::Dim& d); |
|
bool setPosition(const utils::Dim& dim); |
|
bool setTransform(const utils::eTransform& param); |
|
bool setSource(const utils::PipeArgs& args); |
|
void dump() const; |
|
private: |
|
overlay::GenericPipe<utils::PRIMARY> mM3d; |
|
// Cache the M3D format |
|
uint32_t mM3Dfmt; |
|
}; |
|
|
|
///////////// S3DExt Pipe //////////////////////////////// |
|
/** |
|
* A specific impl of GenericPipe for 3D. |
|
* Whenever needed to have a pass through - we do it. |
|
* If there is a special need for special/diff behavior |
|
* do it here. |
|
* PANEL is always EXTERNAL for this pipe. |
|
* CHAN = 0,1 it's either Channel 1 or channel 2 needed for |
|
* 3D crop and position */ |
|
template <int CHAN> |
|
class S3DExtPipe : utils::NoCopy { |
|
public: |
|
/* Please look at overlayGenPipe.h for info */ |
|
explicit S3DExtPipe(); |
|
~S3DExtPipe(); |
|
bool init(RotatorBase* rot); |
|
bool close(); |
|
bool commit(); |
|
bool queueBuffer(int fd, uint32_t offset); |
|
bool setCrop(const utils::Dim& d); |
|
bool setPosition(const utils::Dim& dim); |
|
bool setTransform(const utils::eTransform& param); |
|
bool setSource(const utils::PipeArgs& args); |
|
void dump() const; |
|
private: |
|
overlay::GenericPipe<utils::EXTERNAL> mS3d; |
|
// Cache the 3D format |
|
uint32_t mS3Dfmt; |
|
}; |
|
|
|
///////////// S3DPrimary Pipe //////////////////////////// |
|
/** |
|
* A specific impl of GenericPipe for 3D. |
|
* Whenever needed to have a pass through - we do it. |
|
* If there is a special need for special/diff behavior |
|
* do it here |
|
* PANEL is always PRIMARY for this pipe. |
|
* CHAN = 0,1 it's either Channel 1 or channel 2 needed for |
|
* 3D crop and position */ |
|
template <int CHAN> |
|
class S3DPrimaryPipe : utils::NoCopy { |
|
public: |
|
/* Please look at overlayGenPipe.h for info */ |
|
explicit S3DPrimaryPipe(); |
|
~S3DPrimaryPipe(); |
|
bool init(RotatorBase* rot); |
|
bool close(); |
|
bool commit(); |
|
bool queueBuffer(int fd, uint32_t offset); |
|
bool setCrop(const utils::Dim& d); |
|
bool setPosition(const utils::Dim& dim); |
|
bool setTransform(const utils::eTransform& param); |
|
bool setSource(const utils::PipeArgs& args); |
|
void dump() const; |
|
private: |
|
/* needed for 3D related IOCTL */ |
|
MdpCtrl3D mCtrl3D; |
|
overlay::GenericPipe<utils::PRIMARY> mS3d; |
|
// Cache the 3D format |
|
uint32_t mS3Dfmt; |
|
}; |
|
|
|
|
|
|
|
|
|
//------------------------Inlines and Templates-------------------------- |
|
|
|
|
|
///////////// M3DExt Pipe //////////////////////////// |
|
template <int CHAN> |
|
inline M3DExtPipe<CHAN>::M3DExtPipe() : mM3Dfmt(0) {} |
|
template <int CHAN> |
|
inline M3DExtPipe<CHAN>::~M3DExtPipe() { close(); } |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::init(RotatorBase* rot) { |
|
ALOGE_IF(DEBUG_OVERLAY, "M3DExtPipe init"); |
|
if(!mM3d.init(rot)) { |
|
ALOGE("3Dpipe failed to init"); |
|
return false; |
|
} |
|
return true; |
|
} |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::close() { |
|
return mM3d.close(); |
|
} |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::commit() { return mM3d.commit(); } |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::queueBuffer(int fd, uint32_t offset) { |
|
return mM3d.queueBuffer(fd, offset); |
|
} |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::setCrop(const utils::Dim& d) { |
|
utils::Dim _dim; |
|
if(!utils::getCropS3D<CHAN>(d, _dim, mM3Dfmt)){ |
|
ALOGE("M3DExtPipe setCrop failed to getCropS3D"); |
|
_dim = d; |
|
} |
|
return mM3d.setCrop(_dim); |
|
} |
|
|
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::setPosition(const utils::Dim& d) { |
|
utils::Dim _dim; |
|
// original setPositionHandleState has getPositionS3D(...,true) |
|
// which means format is HAL_3D_OUT_SBS_MASK |
|
// HAL_3D_OUT_SBS_MASK is 0x1000 >> 12 == 0x1 as the orig |
|
// code suggets |
|
utils::Whf _whf(mM3d.getScreenInfo().mFBWidth, |
|
mM3d.getScreenInfo().mFBHeight, |
|
mM3Dfmt); |
|
if(!utils::getPositionS3D<CHAN>(_whf, _dim)) { |
|
ALOGE("S3DPrimaryPipe setPosition err in getPositionS3D"); |
|
_dim = d; |
|
} |
|
return mM3d.setPosition(_dim); |
|
} |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::setTransform(const utils::eTransform& param) { |
|
return mM3d.setTransform(param); |
|
} |
|
template <int CHAN> |
|
inline bool M3DExtPipe<CHAN>::setSource(const utils::PipeArgs& args) |
|
{ |
|
// extract 3D fmt |
|
mM3Dfmt = utils::format3DInput(utils::getS3DFormat(args.whf.format)) | |
|
utils::HAL_3D_OUT_MONOS_MASK; |
|
return mM3d.setSource(args); |
|
} |
|
template <int CHAN> |
|
inline void M3DExtPipe<CHAN>::dump() const { |
|
ALOGE("M3DExtPipe Pipe fmt=%d", mM3Dfmt); |
|
mM3d.dump(); |
|
} |
|
|
|
|
|
///////////// M3DPrimary Pipe //////////////////////////// |
|
template <int CHAN> |
|
inline M3DPrimaryPipe<CHAN>::M3DPrimaryPipe() : mM3Dfmt(0) {} |
|
template <int CHAN> |
|
inline M3DPrimaryPipe<CHAN>::~M3DPrimaryPipe() { close(); } |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::init(RotatorBase* rot) { |
|
ALOGE_IF(DEBUG_OVERLAY, "M3DPrimaryPipe init"); |
|
if(!mM3d.init(rot)) { |
|
ALOGE("3Dpipe failed to init"); |
|
return false; |
|
} |
|
return true; |
|
} |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::close() { |
|
return mM3d.close(); |
|
} |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::commit() { return mM3d.commit(); } |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::queueBuffer(int fd, uint32_t offset) { |
|
return mM3d.queueBuffer(fd, offset); |
|
} |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::setCrop(const utils::Dim& d) { |
|
utils::Dim _dim; |
|
if(!utils::getCropS3D<CHAN>(d, _dim, mM3Dfmt)){ |
|
ALOGE("M3DPrimaryPipe setCrop failed to getCropS3D"); |
|
_dim = d; |
|
} |
|
return mM3d.setCrop(_dim); |
|
} |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::setPosition(const utils::Dim& d) { |
|
return mM3d.setPosition(d); |
|
} |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::setTransform(const utils::eTransform& param) { |
|
return mM3d.setTransform(param); |
|
} |
|
template <int CHAN> |
|
inline bool M3DPrimaryPipe<CHAN>::setSource(const utils::PipeArgs& args) |
|
{ |
|
// extract 3D fmt |
|
mM3Dfmt = utils::format3DInput(utils::getS3DFormat(args.whf.format)) | |
|
utils::HAL_3D_OUT_MONOS_MASK; |
|
return mM3d.setSource(args); |
|
} |
|
template <int CHAN> |
|
inline void M3DPrimaryPipe<CHAN>::dump() const { |
|
ALOGE("M3DPrimaryPipe Pipe fmt=%d", mM3Dfmt); |
|
mM3d.dump(); |
|
} |
|
|
|
///////////// S3DExt Pipe //////////////////////////////// |
|
template <int CHAN> |
|
inline S3DExtPipe<CHAN>::S3DExtPipe() : mS3Dfmt(0) {} |
|
template <int CHAN> |
|
inline S3DExtPipe<CHAN>::~S3DExtPipe() { close(); } |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::init(RotatorBase* rot) { |
|
ALOGE_IF(DEBUG_OVERLAY, "S3DExtPipe init"); |
|
if(!mS3d.init(rot)) { |
|
ALOGE("3Dpipe failed to init"); |
|
return false; |
|
} |
|
return true; |
|
} |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::close() { |
|
if(!utils::send3DInfoPacket(0)) { |
|
ALOGE("S3DExtPipe close failed send3D info packet"); |
|
} |
|
return mS3d.close(); |
|
} |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::commit() { return mS3d.commit(); } |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::queueBuffer(int fd, uint32_t offset) { |
|
return mS3d.queueBuffer(fd, offset); |
|
} |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::setCrop(const utils::Dim& d) { |
|
utils::Dim _dim; |
|
if(!utils::getCropS3D<CHAN>(d, _dim, mS3Dfmt)){ |
|
ALOGE("S3DExtPipe setCrop failed to getCropS3D"); |
|
_dim = d; |
|
} |
|
return mS3d.setCrop(_dim); |
|
} |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::setPosition(const utils::Dim& d) |
|
{ |
|
utils::Dim _dim; |
|
utils::Whf _whf(mS3d.getScreenInfo().mFBWidth, |
|
mS3d.getScreenInfo().mFBHeight, |
|
mS3Dfmt); |
|
if(!utils::getPositionS3D<CHAN>(_whf, _dim)) { |
|
ALOGE("S3DExtPipe setPosition err in getPositionS3D"); |
|
_dim = d; |
|
} |
|
return mS3d.setPosition(_dim); |
|
} |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::setTransform(const utils::eTransform& param) { |
|
return mS3d.setTransform(param); |
|
} |
|
template <int CHAN> |
|
inline bool S3DExtPipe<CHAN>::setSource(const utils::PipeArgs& args) { |
|
mS3Dfmt = utils::getS3DFormat(args.whf.format); |
|
return mS3d.setSource(args); |
|
} |
|
template <int CHAN> |
|
inline void S3DExtPipe<CHAN>::dump() const { |
|
ALOGE("S3DExtPipe Pipe fmt=%d", mS3Dfmt); |
|
mS3d.dump(); |
|
} |
|
|
|
///////////// S3DPrimary Pipe //////////////////////////// |
|
template <int CHAN> |
|
inline S3DPrimaryPipe<CHAN>::S3DPrimaryPipe() : mS3Dfmt(0) {} |
|
template <int CHAN> |
|
inline S3DPrimaryPipe<CHAN>::~S3DPrimaryPipe() { close(); } |
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::init(RotatorBase* rot) { |
|
ALOGE_IF(DEBUG_OVERLAY, "S3DPrimaryPipe init"); |
|
if(!mS3d.init(rot)) { |
|
ALOGE("3Dpipe failed to init"); |
|
return false; |
|
} |
|
// set the ctrl fd |
|
mCtrl3D.setFd(mS3d.getCtrlFd()); |
|
return true; |
|
} |
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::close() { |
|
if(!utils::enableBarrier(0)) { |
|
ALOGE("S3DExtPipe close failed enable barrier"); |
|
} |
|
mCtrl3D.close(); |
|
return mS3d.close(); |
|
} |
|
|
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::commit() { |
|
uint32_t fmt = mS3Dfmt & utils::OUTPUT_3D_MASK; |
|
if(!utils::send3DInfoPacket(fmt)){ |
|
ALOGE("Error S3DExtPipe start error send3DInfoPacket %d", fmt); |
|
return false; |
|
} |
|
return mS3d.commit(); |
|
} |
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::queueBuffer(int fd, uint32_t offset) { |
|
return mS3d.queueBuffer(fd, offset); |
|
} |
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::setCrop(const utils::Dim& d) { |
|
utils::Dim _dim; |
|
if(!utils::getCropS3D<CHAN>(d, _dim, mS3Dfmt)){ |
|
ALOGE("S3DPrimaryPipe setCrop failed to getCropS3D"); |
|
_dim = d; |
|
} |
|
return mS3d.setCrop(_dim); |
|
} |
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::setPosition(const utils::Dim& d) |
|
{ |
|
utils::Whf fbwhf(mS3d.getScreenInfo().mFBWidth, |
|
mS3d.getScreenInfo().mFBHeight, |
|
0 /* fmt dont care*/); |
|
mCtrl3D.setWh(fbwhf); |
|
if(!mCtrl3D.useVirtualFB()) { |
|
ALOGE("Failed to use VFB on %d (non fatal)", utils::FB0); |
|
return false; |
|
} |
|
utils::Dim _dim; |
|
// original setPositionHandleState has getPositionS3D(...,true) |
|
// which means format is HAL_3D_OUT_SBS_MASK |
|
// HAL_3D_OUT_SBS_MASK is 0x1000 >> 12 == 0x1 as the orig |
|
// code suggets |
|
utils::Whf _whf(d.w, d.h, utils::HAL_3D_OUT_SBS_MASK); |
|
if(!utils::getPositionS3D<CHAN>(_whf, _dim)) { |
|
ALOGE("S3DPrimaryPipe setPosition err in getPositionS3D"); |
|
_dim = d; |
|
} |
|
return mS3d.setPosition(_dim); |
|
} |
|
|
|
/* for S3DPrimaryPipe, we need to have barriers once |
|
* So the easiest way to achieve it, is to make sure FB0 is having it before |
|
* setParam is running */ |
|
template <> |
|
inline bool S3DPrimaryPipe<utils::OV_PIPE0>::setTransform( |
|
const utils::eTransform& param) { |
|
uint32_t barrier=0; |
|
switch(param) { |
|
case utils::OVERLAY_TRANSFORM_ROT_90: |
|
case utils::OVERLAY_TRANSFORM_ROT_270: |
|
barrier = utils::BARRIER_LAND; |
|
break; |
|
default: |
|
barrier = utils::BARRIER_PORT; |
|
break; |
|
} |
|
if(!utils::enableBarrier(barrier)) { |
|
ALOGE("S3DPrimaryPipe setTransform failed to enable barrier"); |
|
} |
|
return mS3d.setTransform(param); |
|
} |
|
|
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::setTransform(const utils::eTransform& param) { |
|
return mS3d.setTransform(param); |
|
} |
|
template <int CHAN> |
|
inline bool S3DPrimaryPipe<CHAN>::setSource(const utils::PipeArgs& args) |
|
{ |
|
mS3Dfmt = utils::getS3DFormat(args.whf.format); |
|
return mS3d.setSource(args); |
|
} |
|
template <int CHAN> |
|
inline void S3DPrimaryPipe<CHAN>::dump() const { |
|
ALOGE("S3DPrimaryPipe Pipe fmt=%d", mS3Dfmt); |
|
mS3d.dump(); |
|
} |
|
|
|
} // overlay |
|
|
|
#endif // OVERLAY_M3D_EXT_PIPE_H
|
|
|