Improve Stream class to be binary compatible

Add "*" to pixel format when it is not native in App
This commit is contained in:
jfmcarreira committed 2018-02-03 03:01:21 +00:00
1 parent 5b91c91b90
commit ee24e5a7d3
9 files changed
+165 -202

No files matched your search

+3 -36
View File
@@ -30,10 +30,6 @@
#include <string>
#include <vector>
// ====================================================================================================================
// Basic type redefinition
// ====================================================================================================================
typedef void Void;
typedef bool Bool;
@@ -49,52 +45,23 @@ typedef float Float;
typedef unsigned char UInt8;
typedef unsigned int UInt16;
typedef std::string String;
typedef UShort Pel; ///< 16-bit pixel type
typedef UChar Byte;
// ====================================================================================================================
// 64-bit integer type
// ====================================================================================================================
typedef std::string String;
#ifdef _MSC_VER
typedef __int64 Int64;
#if _MSC_VER <= 1200 // MS VC6
typedef __int64 UInt64; // MS VC6 does not support unsigned __int64 to double conversion
#else
typedef unsigned __int64 UInt64;
#endif
#else
typedef long long Int64;
typedef unsigned long long UInt64;
#endif
// ====================================================================================================================
// Type definition
// ====================================================================================================================
typedef UShort Pel; ///< 16-bit pixel type
typedef UChar Byte;
// ====================================================================================================================
// Limits definition
// ====================================================================================================================
// #define MAX_UINT 0xFFFFFFFFU ///< max. value of unsigned
// 32-bit integer
// #define MAX_INT 2147483647 ///< max. value of signed
// 32-bit integer
// #define MAX_INT64 0x7FFFFFFFFFFFFFFFLL ///< max. value of
// signed 64-bit integer
// #define MAX_DOUBLE 1.7e+308 ///< max. value of
// double-type value
// ====================================================================================================================
// PlaYUVer definitions
// ====================================================================================================================
enum LOG_LEVEL
{
LOG_INFO = 1,
+9 -13
View File
@@ -214,19 +214,15 @@ template PlaYUVerOptions& PlaYUVerOptions::operator()( const String& name, std::
template PlaYUVerOptions& PlaYUVerOptions::operator()( const String& name, std::vector<String>& storage,
const String& desc );
/**
* Add option described by name to the parent Options list,
* with desc as an optional help description
* instead of storing the value somewhere, a function of type
* FunctionOption::Func is called. It is upto this function to correctly
* handle evaluating the option's value.
*/
// PlaYUVerOptions& PlaYUVerOptions::operator()( const String& name,
// FunctionOption::Func *func, const String& desc )
// {
// addOption( new FunctionOption( name, parent, func, desc ) );
// return *this;
// }
PlaYUVerOptions::Option::Option()
: opt( 0 ) {}
PlaYUVerOptions::Option::~Option()
{
if( opt )
delete opt;
}
PlaYUVerOptions::PlaYUVerOptions( const String& name )
{
m_cOptionGroupName = name;
+2 -20
View File
@@ -69,18 +69,12 @@ class PlaYUVerOptions
public:
struct Option
{
Option()
: opt( 0 ) {}
~Option()
{
if( opt )
delete opt;
}
Option();
~Option();
std::list<String> opt_long;
std::list<String> opt_short;
OptionBase* opt;
};
typedef std::list<Option*> OptionsList;
PlaYUVerOptions( const String& name = "" );
@@ -119,19 +113,7 @@ public:
template <typename T>
PlaYUVerOptions& operator()( const String& name, T& storage, const String& desc );
/**
* Add option described by name to the parent Options list,
* with desc as an optional help description
* instead of storing the value somewhere, a function of type
* OptionFunc::Func is called. It is upto this function to correctly
* handle evaluating the option's value.
*/
// PlaYUVerOptions&
// operator()( const String& name, OptionFunc::Func *func, const String&
// desc );
Bool checkListingOpts();
//Void listModules();
private:
typedef std::map<String, OptionsList> OptionMap;
+132 -107
View File
@@ -86,6 +86,33 @@ private:
inline Int prevIndex() { return m_uiIndex - 1 < 0 ? m_apcFrameBuffer.size() - 1 : m_uiIndex - 1; }
};
class PlaYUVerStreamPrivate
{
public:
Bool isInit;
Bool isInput;
PlaYUVerStreamHandlerIf* handler;
CreateStreamHandlerFn pfctCreateHandler;
PlaYUVerStreamBufferPrivate* frameBuffer;
String cFilename;
Int64 iCurrFrameNum;
Bool bLoadAll;
PlaYUVerStreamPrivate()
{
isInit = false;
pfctCreateHandler = NULL;
handler = NULL;
isInput = true;
bLoadAll = false;
iCurrFrameNum = -1;
cFilename = "";
}
};
std::vector<PlaYUVerSupportedFormat> PlaYUVerStream::supportedReadFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
@@ -186,14 +213,8 @@ CreateStreamHandlerFn PlaYUVerStream::findStreamHandler( String strFilename, boo
}
PlaYUVerStream::PlaYUVerStream()
: d( new PlaYUVerStreamPrivate )
{
m_bInit = false;
m_pfctCreateHandler = NULL;
m_pcHandler = NULL;
m_bIsInput = true;
m_bLoadAll = false;
m_iCurrFrameNum = -1;
m_cFilename = "";
}
PlaYUVerStream::~PlaYUVerStream()
@@ -203,11 +224,11 @@ PlaYUVerStream::~PlaYUVerStream()
String PlaYUVerStream::getFormatName()
{
return !m_pcHandler ? "" : m_pcHandler->getFormatName();
return !d->handler ? "" : d->handler->getFormatName();
}
String PlaYUVerStream::getCodecName()
{
return !m_pcHandler ? "" : m_pcHandler->getCodecName();
return !d->handler ? "" : d->handler->getCodecName();
}
Bool PlaYUVerStream::open( String filename, String resolution, String input_format_name, UInt bitsPel, Int endianness,
@@ -239,174 +260,178 @@ Bool PlaYUVerStream::open( String filename, String resolution, String input_form
Bool PlaYUVerStream::open( String filename, UInt width, UInt height, Int input_format, UInt bitsPel, Int endianness,
UInt frame_rate, Bool bInput )
{
if( m_bInit )
if( d->isInit )
{
close();
}
m_bInit = false;
m_bIsInput = bInput;
d->isInit = false;
d->isInput = bInput;
m_pfctCreateHandler = PlaYUVerStream::findStreamHandler( filename, m_bIsInput );
if( !m_pfctCreateHandler )
d->pfctCreateHandler = PlaYUVerStream::findStreamHandler( filename, d->isInput );
if( !d->pfctCreateHandler )
{
throw PlaYUVerFailure( "PlaYUVerStream", "Invalid handler" );
}
m_pcHandler = m_pfctCreateHandler();
d->handler = d->pfctCreateHandler();
if( !m_pcHandler )
if( !d->handler )
{
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot create handler" );
}
m_cFilename = filename;
d->cFilename = filename;
m_pcHandler->m_cFilename = filename;
m_pcHandler->m_uiWidth = width;
m_pcHandler->m_uiHeight = height;
m_pcHandler->m_iPixelFormat = input_format;
m_pcHandler->m_uiBitsPerPixel = bitsPel;
m_pcHandler->m_iEndianness = endianness;
m_pcHandler->m_dFrameRate = frame_rate;
d->handler->m_cFilename = filename;
d->handler->m_uiWidth = width;
d->handler->m_uiHeight = height;
d->handler->m_iPixelFormat = input_format;
d->handler->m_uiBitsPerPixel = bitsPel;
d->handler->m_iEndianness = endianness;
d->handler->m_dFrameRate = frame_rate;
if( !m_pcHandler->openHandler( m_cFilename, m_bIsInput ) )
if( !d->handler->openHandler( d->cFilename, d->isInput ) )
{
close();
return m_bInit;
return d->isInit;
}
if( m_pcHandler->m_uiWidth <= 0 || m_pcHandler->m_uiHeight <= 0 || m_pcHandler->m_iPixelFormat < 0 )
if( d->handler->m_uiWidth <= 0 || d->handler->m_uiHeight <= 0 || d->handler->m_iPixelFormat < 0 )
{
close();
throw PlaYUVerFailure( "PlaYUVerStream", "Incorrect configuration: width, height or pixel format" );
return m_bInit;
return d->isInit;
}
// Keep past, current and future frames
try
{
m_frameBuffer =
new PlaYUVerStreamBufferPrivate( m_bIsInput ? 3 : 1, m_pcHandler->m_uiWidth, m_pcHandler->m_uiHeight,
m_pcHandler->m_iPixelFormat, m_pcHandler->m_uiBitsPerPixel );
d->frameBuffer = new PlaYUVerStreamBufferPrivate( d->isInput ? 3 : 1, d->handler->m_uiWidth, d->handler->m_uiHeight,
d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel );
}
catch( PlaYUVerFailure& e )
{
close();
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot allocated frame buffer" );
return m_bInit;
return d->isInit;
}
m_pcHandler->m_uiNBytesPerFrame = m_frameBuffer->current()->getBytesPerFrame();
d->handler->m_uiNBytesPerFrame = d->frameBuffer->current()->getBytesPerFrame();
// Some handlers need to know how long is a frame to get frame number
m_pcHandler->calculateFrameNumber();
d->handler->calculateFrameNumber();
if( m_bIsInput && m_pcHandler->m_uiTotalNumberFrames == 0 )
if( d->isInput && d->handler->m_uiTotalNumberFrames == 0 )
{
close();
throw PlaYUVerFailure( "PlaYUVerStream", "Incorrect configuration: less than one frame" );
return m_bInit;
return d->isInit;
}
if( !m_pcHandler->configureBuffer( m_frameBuffer->current() ) )
if( !d->handler->configureBuffer( d->frameBuffer->current() ) )
{
close();
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot allocated buffers" );
return m_bInit;
return d->isInit;
}
m_iCurrFrameNum = -1;
m_bInit = true;
d->iCurrFrameNum = -1;
d->isInit = true;
seekInput( 0 );
m_bInit = true;
return m_bInit;
d->isInit = true;
return d->isInit;
}
Bool PlaYUVerStream::reload()
{
m_pcHandler->closeHandler();
if( !m_pcHandler->openHandler( m_cFilename, m_bIsInput ) )
d->handler->closeHandler();
if( !d->handler->openHandler( d->cFilename, d->isInput ) )
{
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot open stream " + m_cFilename + " with the " +
String( m_pcHandler->m_pchHandlerName ) + " handler" );
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot open stream " + d->cFilename + " with the " +
String( d->handler->m_pchHandlerName ) + " handler" );
}
m_pcHandler->m_uiNBytesPerFrame = m_frameBuffer->current()->getBytesPerFrame();
m_pcHandler->calculateFrameNumber();
m_pcHandler->configureBuffer( m_frameBuffer->current() );
d->handler->m_uiNBytesPerFrame = d->frameBuffer->current()->getBytesPerFrame();
d->handler->calculateFrameNumber();
d->handler->configureBuffer( d->frameBuffer->current() );
if( m_pcHandler->m_uiWidth <= 0 || m_pcHandler->m_uiHeight <= 0 || m_pcHandler->m_iPixelFormat < 0 ||
m_pcHandler->m_uiBitsPerPixel == 0 || m_pcHandler->m_uiTotalNumberFrames == 0 )
if( d->handler->m_uiWidth <= 0 || d->handler->m_uiHeight <= 0 || d->handler->m_iPixelFormat < 0 ||
d->handler->m_uiBitsPerPixel == 0 || d->handler->m_uiTotalNumberFrames == 0 )
{
return false;
}
if( UInt( m_iCurrFrameNum ) >= m_pcHandler->m_uiTotalNumberFrames )
if( UInt( d->iCurrFrameNum ) >= d->handler->m_uiTotalNumberFrames )
{
m_iCurrFrameNum = 0;
d->iCurrFrameNum = 0;
}
Int currFrameNum = m_iCurrFrameNum;
m_iCurrFrameNum = -1;
Int currFrameNum = d->iCurrFrameNum;
d->iCurrFrameNum = -1;
seekInput( currFrameNum );
return true;
}
Void PlaYUVerStream::close()
{
if( !m_bInit )
if( !d->isInit )
return;
m_pcHandler->closeHandler();
m_pcHandler->Delete();
d->handler->closeHandler();
d->handler->Delete();
delete m_frameBuffer;
delete d->frameBuffer;
m_bLoadAll = false;
m_bInit = false;
d->bLoadAll = false;
d->isInit = false;
}
String PlaYUVerStream::getFileName()
{
return m_cFilename;
return d->cFilename;
}
Bool PlaYUVerStream::isNative()
{
return d->handler->m_bNative;
}
UInt PlaYUVerStream::getFrameNum()
{
return m_pcHandler->m_uiTotalNumberFrames;
return d->handler->m_uiTotalNumberFrames;
}
UInt PlaYUVerStream::getWidth() const
{
return m_pcHandler->m_uiWidth;
return d->handler->m_uiWidth;
}
UInt PlaYUVerStream::getHeight() const
{
return m_pcHandler->m_uiHeight;
return d->handler->m_uiHeight;
}
Int PlaYUVerStream::getEndianess() const
{
return m_pcHandler->m_iEndianness;
return d->handler->m_iEndianness;
}
Double PlaYUVerStream::getFrameRate()
{
return m_pcHandler->m_dFrameRate;
return d->handler->m_dFrameRate;
}
Int PlaYUVerStream::getCurrFrameNum()
{
return m_iCurrFrameNum;
return d->iCurrFrameNum;
}
Void PlaYUVerStream::getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rBitsPerPel, Int& rEndianness,
UInt& rFrameRate )
{
if( m_bInit )
if( d->isInit )
{
rWidth = m_pcHandler->m_uiWidth;
rHeight = m_pcHandler->m_uiHeight;
rInputFormat = m_pcHandler->m_iPixelFormat;
rBitsPerPel = m_pcHandler->m_uiBitsPerPixel;
rEndianness = m_pcHandler->m_iEndianness;
rFrameRate = m_pcHandler->m_dFrameRate;
rWidth = d->handler->m_uiWidth;
rHeight = d->handler->m_uiHeight;
rInputFormat = d->handler->m_iPixelFormat;
rBitsPerPel = d->handler->m_uiBitsPerPixel;
rEndianness = d->handler->m_iEndianness;
rFrameRate = d->handler->m_dFrameRate;
}
else
{
@@ -421,12 +446,12 @@ Void PlaYUVerStream::getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat,
Void PlaYUVerStream::loadAll()
{
if( m_bLoadAll || !m_bIsInput )
if( d->bLoadAll || !d->isInput )
return;
try
{
m_frameBuffer->increase( m_pcHandler->m_uiTotalNumberFrames );
d->frameBuffer->increase( d->handler->m_uiTotalNumberFrames );
}
catch( PlaYUVerFailure& e )
{
@@ -435,12 +460,12 @@ Void PlaYUVerStream::loadAll()
}
seekInput( 0 );
for( UInt i = 2; i < m_frameBuffer->size(); i++ )
for( UInt i = 2; i < d->frameBuffer->size(); i++ )
{
readFrame( m_frameBuffer->frame( i ) );
readFrame( d->frameBuffer->frame( i ) );
}
m_bLoadAll = true;
m_iCurrFrameNum = 0;
d->bLoadAll = true;
d->iCurrFrameNum = 0;
}
Void PlaYUVerStream::getDuration( Int* duration_array )
@@ -468,13 +493,13 @@ Void PlaYUVerStream::getDuration( Int* duration_array )
Bool PlaYUVerStream::readFrame( PlaYUVerFrame* frame )
{
if( !m_bInit || !m_bIsInput || m_pcHandler->m_uiCurrFrameFileIdx >= m_pcHandler->m_uiTotalNumberFrames )
if( !d->isInit || !d->isInput || d->handler->m_uiCurrFrameFileIdx >= d->handler->m_uiTotalNumberFrames )
return false;
if( m_bLoadAll )
if( d->bLoadAll )
return true;
if( !m_pcHandler->read( frame ) )
if( !d->handler->read( frame ) )
{
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot read frame from stream" );
return false;
@@ -484,12 +509,12 @@ Bool PlaYUVerStream::readFrame( PlaYUVerFrame* frame )
Void PlaYUVerStream::writeFrame()
{
writeFrame( m_frameBuffer->current() );
writeFrame( d->frameBuffer->current() );
}
Void PlaYUVerStream::writeFrame( PlaYUVerFrame* pcFrame )
{
if( !m_pcHandler->write( pcFrame ) )
if( !d->handler->write( pcFrame ) )
{
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot write frame into the stream" );
}
@@ -498,7 +523,7 @@ Void PlaYUVerStream::writeFrame( PlaYUVerFrame* pcFrame )
Bool PlaYUVerStream::saveFrame( const String& filename )
{
return saveFrame( filename, m_frameBuffer->current() );
return saveFrame( filename, d->frameBuffer->current() );
}
Bool PlaYUVerStream::saveFrame( const String& filename, PlaYUVerFrame* saveFrame )
@@ -518,10 +543,10 @@ Bool PlaYUVerStream::setNextFrame()
{
Bool bEndOfSeq = false;
if( m_iCurrFrameNum + 1 < Int64( m_pcHandler->m_uiTotalNumberFrames ) )
if( d->iCurrFrameNum + 1 < Int64( d->handler->m_uiTotalNumberFrames ) )
{
m_frameBuffer->setNextFrame();
m_iCurrFrameNum++;
d->frameBuffer->setNextFrame();
d->iCurrFrameNum++;
}
else
{
@@ -532,44 +557,44 @@ Bool PlaYUVerStream::setNextFrame()
Void PlaYUVerStream::readNextFrame()
{
readFrame( m_frameBuffer->next() );
readFrame( d->frameBuffer->next() );
}
Void PlaYUVerStream::readNextFrameFillRGBBuffer()
{
readNextFrame();
m_frameBuffer->next()->fillRGBBuffer();
d->frameBuffer->next()->fillRGBBuffer();
return;
}
PlaYUVerFrame* PlaYUVerStream::getCurrFrame( PlaYUVerFrame* pyuv_image )
{
if( pyuv_image == NULL )
pyuv_image = new PlaYUVerFrame( m_frameBuffer->current() );
pyuv_image = new PlaYUVerFrame( d->frameBuffer->current() );
else
pyuv_image->copyFrom( m_frameBuffer->current() );
pyuv_image->copyFrom( d->frameBuffer->current() );
return pyuv_image;
}
PlaYUVerFrame* PlaYUVerStream::getCurrFrame()
{
return m_frameBuffer->current();
return d->frameBuffer->current();
}
Bool PlaYUVerStream::seekInputRelative( Bool bIsFoward )
{
if( !m_bInit || !m_bIsInput )
if( !d->isInit || !d->isInput )
return false;
Bool bRet = false;
if( bIsFoward )
{
bRet = !setNextFrame();
readFrame( m_frameBuffer->next() );
readFrame( d->frameBuffer->next() );
}
else
{
UInt64 newFrameNum = m_iCurrFrameNum - 1;
UInt64 newFrameNum = d->iCurrFrameNum - 1;
bRet = seekInput( newFrameNum );
}
return bRet;
@@ -577,26 +602,26 @@ Bool PlaYUVerStream::seekInputRelative( Bool bIsFoward )
Bool PlaYUVerStream::seekInput( UInt64 new_frame_num )
{
if( !m_bInit || new_frame_num >= m_pcHandler->m_uiTotalNumberFrames || Int64( new_frame_num ) == m_iCurrFrameNum )
if( !d->isInit || new_frame_num >= d->handler->m_uiTotalNumberFrames || Int64( new_frame_num ) == d->iCurrFrameNum )
return false;
m_iCurrFrameNum = new_frame_num;
d->iCurrFrameNum = new_frame_num;
if( m_bLoadAll )
if( d->bLoadAll )
{
m_frameBuffer->setIndex( m_iCurrFrameNum );
d->frameBuffer->setIndex( d->iCurrFrameNum );
return true;
}
if( !m_pcHandler->seek( m_iCurrFrameNum ) )
if( !d->handler->seek( d->iCurrFrameNum ) )
{
throw PlaYUVerFailure( "PlaYUVerStream", "Cannot seek file into desired position" );
}
m_frameBuffer->setIndex( 0 );
readFrame( m_frameBuffer->current() );
if( m_pcHandler->m_uiTotalNumberFrames > 1 )
readFrame( m_frameBuffer->next() );
d->frameBuffer->setIndex( 0 );
readFrame( d->frameBuffer->current() );
if( d->handler->m_uiTotalNumberFrames > 1 )
readFrame( d->frameBuffer->next() );
return true;
}
+10 -21
View File
@@ -28,15 +28,8 @@
#include "PlaYUVerDefs.h"
class PlaYUVerFrame;
class PlaYUVerStreamPrivate;
class PlaYUVerStreamHandlerIf;
class PlaYUVerStreamBufferPrivate;
typedef struct
{
String shortName;
UInt uiWidth;
UInt uiHeight;
} PlaYUVerStdResolution;
typedef PlaYUVerStreamHandlerIf* ( *CreateStreamHandlerFn )( void );
@@ -47,9 +40,15 @@ typedef struct
std::vector<String> getExts();
String formatPattern;
CreateStreamHandlerFn formatFct;
} PlaYUVerSupportedFormat;
typedef struct
{
String shortName;
UInt uiWidth;
UInt uiHeight;
} PlaYUVerStdResolution;
/**
* \class PlaYUVerStream
* \ingroup PlaYUVerLib PlaYUVerLib_Stream
@@ -87,6 +86,7 @@ public:
Bool reload();
Void close();
Bool isNative();
String getFileName();
UInt getFrameNum();
UInt getWidth() const;
@@ -116,24 +116,13 @@ public:
Bool seekInputRelative( Bool bIsFoward );
Bool seekInput( UInt64 new_frame_num );
Bool isInit() { return m_bInit; }
Void getDuration( Int* duration_array );
private:
Bool readFrame( PlaYUVerFrame* frame );
private:
Bool m_bInit;
CreateStreamHandlerFn m_pfctCreateHandler;
PlaYUVerStreamHandlerIf* m_pcHandler;
Bool m_bIsInput;
String m_cFilename;
Int64 m_iCurrFrameNum;
Bool m_bLoadAll;
PlaYUVerStreamBufferPrivate* m_frameBuffer;
PlaYUVerStreamPrivate* d;
};
#endif // __PLAYUVERSTREAM_H__
+2
View File
@@ -72,6 +72,7 @@ class PlaYUVerStreamHandlerIf
public:
PlaYUVerStreamHandlerIf()
: m_bIsInput( true )
, m_bNative( true )
, m_uiCurrFrameFileIdx( 0 )
, m_uiWidth( 0 )
, m_uiHeight( 0 )
@@ -105,6 +106,7 @@ protected:
String m_strFormatName;
String m_strCodecName;
Bool m_bIsInput;
Bool m_bNative;
UInt64 m_uiCurrFrameFileIdx;
String m_cFilename;
UInt m_uiWidth;
+4 -4
View File
@@ -43,6 +43,7 @@ std::vector<PlaYUVerSupportedFormat> StreamHandlerLibav::supportedReadFormats()
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Joint Photographic Experts Group", "jpg,jpeg" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Windows Bitmap", "bmp" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Tagged Image File Format", "tiff" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, " Graphics Interchange Format", "gif" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Audio video interleaved", "avi" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Windows media video", "wmv" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "MPEG-4", "mp4" );
@@ -174,7 +175,6 @@ Bool StreamHandlerLibav::openHandler( String strFilename, Bool bInput )
/**
* Auxiliar conversation to re-use similar pixfmt
*/
m_bRequiresConvertion = false;
Int auxPixFmt = m_ffPixFmt;
switch( m_ffPixFmt )
{
@@ -211,7 +211,7 @@ Bool StreamHandlerLibav::openHandler( String strFilename, Bool bInput )
{
Int newPelFmt = PlaYUVerFrame::findPixelFormat( "YUV444p" );
m_iPixelFormat = newPelFmt;
m_bRequiresConvertion = true;
m_bNative = false;
//throw PlaYUVerFailure( "StreamHandlerLibav", "Cannot open file using FFmpeg libs - unsupported pixel format" );
//return false;
}
@@ -250,7 +250,7 @@ Bool StreamHandlerLibav::openHandler( String strFilename, Bool bInput )
return false;
}
if( m_bRequiresConvertion )
if( !m_bNative )
{
AVPixelFormat newAvFmt = AVPixelFormat( g_PlaYUVerPixFmtDescriptorsMap.at( m_iPixelFormat ).ffmpegPelFormat );
@@ -388,7 +388,7 @@ Bool StreamHandlerLibav::read( PlaYUVerFrame* pcFrame )
if( bGotFrame )
{
AVFrame* decFrame = m_cFrame;
if( m_bRequiresConvertion )
if( !m_bNative )
{
sws_scale( m_ScalerCtx, (const uint8_t* const*)decFrame->data, decFrame->linesize, 0,
decFrame->height, (uint8_t* const*)m_cConvertedFrame->data, m_cConvertedFrame->linesize );
-1
View File
@@ -93,7 +93,6 @@ private:
UInt64 m_uiSecs;
UInt64 m_uiMicroSec;
Bool m_bRequiresConvertion;
AVFrame* m_cConvertedFrame;
};