dca07219a9
Fix memory leak during copying pipe objects. Remove unused / unnecessary code. setMemoryId API is merged with queueBuffer. setParameter API is setTransform now. Rotator upgraded to: --Allow different rotator hardware types. --Remove dependency on MDP code. --Allocate memory only during first playback, close when the associated pipe is closed. Have single commit implementation. Include new format types. Change-Id: I28d87179c7ec9c0b97721a9ff17f1526da98b714
502 lines
16 KiB
C++
502 lines
16 KiB
C++
/*
|
|
* 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_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 waitForVsync();
|
|
bool setCrop(const utils::Dim& d);
|
|
bool setPosition(const utils::Dim& dim);
|
|
bool setTransform(const utils::eTransform& param);
|
|
bool setSource(const utils::PipeArgs& args);
|
|
utils::eOverlayPipeType getOvPipeType() const;
|
|
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 waitForVsync();
|
|
bool setCrop(const utils::Dim& d);
|
|
bool setPosition(const utils::Dim& dim);
|
|
bool setTransform(const utils::eTransform& param);
|
|
bool setSource(const utils::PipeArgs& args);
|
|
utils::eOverlayPipeType getOvPipeType() const;
|
|
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 waitForVsync();
|
|
bool setCrop(const utils::Dim& d);
|
|
bool setPosition(const utils::Dim& dim);
|
|
bool setTransform(const utils::eTransform& param);
|
|
bool setSource(const utils::PipeArgs& args);
|
|
utils::eOverlayPipeType getOvPipeType() const;
|
|
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 waitForVsync();
|
|
bool setCrop(const utils::Dim& d);
|
|
bool setPosition(const utils::Dim& dim);
|
|
bool setTransform(const utils::eTransform& param);
|
|
bool setSource(const utils::PipeArgs& args);
|
|
utils::eOverlayPipeType getOvPipeType() const;
|
|
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>::waitForVsync() {
|
|
return mM3d.waitForVsync(); }
|
|
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 utils::eOverlayPipeType M3DExtPipe<CHAN>::getOvPipeType() const {
|
|
return utils::OV_PIPE_TYPE_M3D_EXTERNAL;
|
|
}
|
|
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>::waitForVsync() {
|
|
return mM3d.waitForVsync(); }
|
|
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 utils::eOverlayPipeType M3DPrimaryPipe<CHAN>::getOvPipeType() const {
|
|
return utils::OV_PIPE_TYPE_M3D_PRIMARY;
|
|
}
|
|
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>::waitForVsync() {
|
|
return mS3d.waitForVsync(); }
|
|
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 utils::eOverlayPipeType S3DExtPipe<CHAN>::getOvPipeType() const {
|
|
return utils::OV_PIPE_TYPE_S3D_EXTERNAL;
|
|
}
|
|
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>::waitForVsync() {
|
|
return mS3d.waitForVsync(); }
|
|
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 utils::eOverlayPipeType S3DPrimaryPipe<CHAN>::getOvPipeType() const {
|
|
return utils::OV_PIPE_TYPE_S3D_PRIMARY;
|
|
}
|
|
template <int CHAN>
|
|
inline void S3DPrimaryPipe<CHAN>::dump() const {
|
|
ALOGE("S3DPrimaryPipe Pipe fmt=%d", mS3Dfmt);
|
|
mS3d.dump();
|
|
}
|
|
|
|
} // overlay
|
|
|
|
#endif // OVERLAY_M3D_EXT_PIPE_H
|