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