699 lines
17 KiB
C++
699 lines
17 KiB
C++
/* This file is a part of plaYUVer project
|
|
* Copyright (C) 2014 by Luis Lucas (luisfrlucas@gmail.com)
|
|
* Joao Carreira (jfmcarreira@gmail.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
/**
|
|
* \file PlaYUVerStream.cpp
|
|
* \brief Input stream handling
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <cstdio>
|
|
#include "LibMemory.h"
|
|
#include "PlaYUVerStream.h"
|
|
#include <QImage>
|
|
#ifdef USE_FFMPEG
|
|
#include "LibAvContextHandle.h"
|
|
#endif
|
|
|
|
namespace plaYUVer
|
|
{
|
|
|
|
QDataStream& operator<<( QDataStream& out, const PlaYUVerStreamInfoVector& array )
|
|
{
|
|
PlaYUVerStreamInfo d;
|
|
out << array.size();
|
|
for( Int i = 0; i < array.size(); i++ )
|
|
{
|
|
d = array.at( i );
|
|
out << d.m_cFilename << d.m_uiWidth
|
|
<< d.m_uiHeight
|
|
<< d.m_iPelFormat
|
|
<< d.m_uiFrameRate;
|
|
|
|
}
|
|
return out;
|
|
}
|
|
|
|
QDataStream& operator>>( QDataStream& in, PlaYUVerStreamInfoVector& array )
|
|
{
|
|
PlaYUVerStreamInfo d;
|
|
Int array_size;
|
|
in >> array_size;
|
|
for( Int i = 0; i < array_size; i++ )
|
|
{
|
|
in >> d.m_cFilename;
|
|
in >> d.m_uiWidth;
|
|
in >> d.m_uiHeight;
|
|
in >> d.m_iPelFormat;
|
|
in >> d.m_uiFrameRate;
|
|
array.append( d );
|
|
}
|
|
return in;
|
|
}
|
|
|
|
Int findPlaYUVerStreamInfo( PlaYUVerStreamInfoVector array, QString filename )
|
|
{
|
|
for( Int i = 0; i < array.size(); i++ )
|
|
if( array.at( i ).m_cFilename == filename )
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
PlaYUVerStream::PlaYUVerStream()
|
|
{
|
|
m_bInit = false;
|
|
m_bIsInput = true;
|
|
m_bIsOpened = false;
|
|
m_bLoadAll = false;
|
|
m_iErrorStatus = 0;
|
|
|
|
m_pFile = NULL;
|
|
m_uiWidth = 0;
|
|
m_uiHeight = 0;
|
|
m_uiTotalFrameNum = 0;
|
|
m_iCurrFrameNum = -1;
|
|
m_iPixelFormat = -1;
|
|
m_uiFrameRate = 30;
|
|
m_iFileFormat = INVALID_INPUT;
|
|
m_pStreamBuffer = NULL;
|
|
m_cFilename = QString( "" );
|
|
m_cStreamInformationString = QString( "" );
|
|
m_pcCurrFrame = NULL;
|
|
m_pcNextFrame = NULL;
|
|
m_ppcFrameBuffer = NULL;
|
|
m_uiFrameBufferSize = 2;
|
|
m_uiFrameBufferIndex = 0;
|
|
m_uiAveragePlayInterval = 0;
|
|
#ifdef USE_FFMPEG
|
|
m_cLibAvContext = new LibAvContextHandle;
|
|
#endif
|
|
}
|
|
|
|
PlaYUVerStream::~PlaYUVerStream()
|
|
{
|
|
close();
|
|
}
|
|
|
|
Bool PlaYUVerStream::open( QString filename, UInt width, UInt height, Int input_format, UInt frame_rate, Bool bInput )
|
|
{
|
|
Bool avStatus = false;
|
|
|
|
if( m_bInit )
|
|
{
|
|
close();
|
|
}
|
|
|
|
m_bInit = false;
|
|
m_bIsInput = bInput;
|
|
m_cFilename = filename;
|
|
m_uiWidth = width;
|
|
m_uiHeight = height;
|
|
m_iPixelFormat = input_format;
|
|
m_uiFrameRate = frame_rate;
|
|
|
|
if( m_bIsInput )
|
|
{
|
|
m_iFileFormat = INVALID_INPUT;
|
|
|
|
QStringList formatsExt = PlaYUVerStream::supportedReadFormatsExt();
|
|
QString currExt = QFileInfo( filename ).suffix();
|
|
if( formatsExt.contains( currExt ) )
|
|
{
|
|
m_iFileFormat = formatsExt.indexOf( currExt );
|
|
}
|
|
if( m_iFileFormat == INVALID_INPUT )
|
|
{
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
m_cFormatName = PlaYUVerStream::supportedReadFormatsExt().at( m_iFileFormat ).toUpper();
|
|
|
|
#ifdef USE_FFMPEG
|
|
if( m_iFileFormat != YUVINPUT )
|
|
{
|
|
avStatus = m_cLibAvContext->initAvFormat( m_cFilename.toLocal8Bit().data(), m_uiWidth, m_uiHeight, m_iPixelFormat, m_uiFrameRate, m_uiTotalFrameNum );
|
|
m_cCodedName = QString::fromUtf8( m_cLibAvContext->getCodecName() ).toUpper();
|
|
}
|
|
#endif
|
|
#if 0
|
|
if( !avStatus )
|
|
{
|
|
switch( m_iFileFormat )
|
|
{
|
|
case PGMINPUT:
|
|
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
m_uiFrameBufferSize = 2;
|
|
}
|
|
else
|
|
{
|
|
m_iFileFormat = YUVOUTPUT;
|
|
m_uiFrameBufferSize = 1;
|
|
}
|
|
|
|
if( m_uiWidth <= 0 || m_uiHeight <= 0 || m_iPixelFormat < 0 )
|
|
{
|
|
qDebug( ) << "Incorrect configuration";
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
|
|
getMem1D<PlaYUVerFrame*>( &m_ppcFrameBuffer, m_uiFrameBufferSize );
|
|
for( UInt i = 0; i < m_uiFrameBufferSize; i++ )
|
|
{
|
|
m_ppcFrameBuffer[i] = new PlaYUVerFrame( m_uiWidth, m_uiHeight, m_iPixelFormat );
|
|
if( !m_ppcFrameBuffer[i] )
|
|
{
|
|
qDebug( ) << "Cannot allocated frame buffer";
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
}
|
|
m_uiFrameBufferIndex = 0;
|
|
m_pcCurrFrame = m_ppcFrameBuffer[m_uiFrameBufferIndex];
|
|
|
|
UInt64 frame_bytes_input = m_pcCurrFrame->getBytesPerFrame();
|
|
|
|
if( !avStatus )
|
|
{
|
|
if( !openFile() )
|
|
{
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
m_cFormatName = QString::fromUtf8( "YUV" );
|
|
m_cCodedName = QString::fromUtf8( "Raw Video" );
|
|
}
|
|
|
|
if( !avStatus && m_iFileFormat == YUVINPUT )
|
|
{
|
|
if( m_bIsInput )
|
|
{
|
|
fseek( m_pFile, 0, SEEK_END );
|
|
UInt64 fileSize = ftell( m_pFile );
|
|
#if 0
|
|
if( fileSize % frame_bytes_input )
|
|
{
|
|
Int remaining = fileSize % frame_bytes_input;
|
|
qDebug( ) << "Incorrect configuration: failed ( fileSize % frame_bytes_input = " << remaining << " )";
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
#endif
|
|
m_uiTotalFrameNum = fileSize / frame_bytes_input;
|
|
fseek( m_pFile, 0, SEEK_SET );
|
|
}
|
|
|
|
}
|
|
|
|
if( m_bIsInput && m_uiTotalFrameNum <= 0 )
|
|
{
|
|
qDebug( ) << "Incorrect configuration: less than one frame";
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
|
|
if( !getMem1D<Pel>( &m_pStreamBuffer, m_pcCurrFrame->getBytesPerFrame() ) )
|
|
{
|
|
close();
|
|
return m_bInit;
|
|
}
|
|
|
|
m_cStreamInformationString = QString( "[" );
|
|
m_cStreamInformationString.append( m_cFormatName );
|
|
m_cStreamInformationString.append( QString( " / " ) );
|
|
m_cStreamInformationString.append( m_cCodedName );
|
|
m_cStreamInformationString.append( QString( " / " ) );
|
|
m_cStreamInformationString.append( PlaYUVerFrame::supportedPixelFormatList().at( m_iPixelFormat ) );
|
|
m_cStreamInformationString.append( "] " );
|
|
m_cStreamInformationString.append( QFileInfo( m_cFilename ).fileName() );
|
|
|
|
m_sStreamInfo.m_cFilename = m_cFilename;
|
|
m_sStreamInfo.m_uiWidth = m_uiWidth;
|
|
m_sStreamInfo.m_uiHeight = m_uiHeight;
|
|
m_sStreamInfo.m_iPelFormat = m_iPixelFormat;
|
|
m_sStreamInfo.m_uiFrameRate = m_uiFrameRate;
|
|
|
|
m_iCurrFrameNum = -1;
|
|
|
|
m_bInit = true;
|
|
|
|
seekInput( 0 );
|
|
|
|
m_cTimer.start();
|
|
m_uiAveragePlayInterval = 0;
|
|
|
|
m_bInit = true;
|
|
return m_bInit;
|
|
}
|
|
|
|
Bool PlaYUVerStream::openFile()
|
|
{
|
|
m_pFile = NULL;
|
|
Char *filename = new char[m_cFilename.length() + 1];
|
|
memcpy( filename, m_cFilename.toUtf8().constData(), m_cFilename.length() + 1 * sizeof(char) );
|
|
m_pFile = fopen( filename, m_bIsInput ? "rb" : "wb" );
|
|
delete[] filename;
|
|
if( m_pFile == NULL )
|
|
{
|
|
return false;
|
|
}
|
|
fseek( m_pFile, m_iCurrFrameNum >= 0 ? m_iCurrFrameNum : 0, SEEK_SET );
|
|
return true;
|
|
}
|
|
|
|
Void PlaYUVerStream::closeFile()
|
|
{
|
|
if( m_pFile )
|
|
fclose( m_pFile );
|
|
}
|
|
|
|
Void PlaYUVerStream::close()
|
|
{
|
|
if( !m_bInit )
|
|
return;
|
|
|
|
closeFile();
|
|
|
|
#ifdef USE_FFMPEG
|
|
m_cLibAvContext->closeAvFormat();
|
|
#endif
|
|
|
|
if( m_ppcFrameBuffer )
|
|
{
|
|
for( UInt i = 0; i < m_uiFrameBufferSize; i++ )
|
|
{
|
|
if( m_ppcFrameBuffer[i] )
|
|
delete m_ppcFrameBuffer[i];
|
|
m_ppcFrameBuffer[i] = NULL;
|
|
}
|
|
freeMem1D<PlaYUVerFrame*>( m_ppcFrameBuffer );
|
|
m_ppcFrameBuffer = NULL;
|
|
}
|
|
|
|
if( m_pStreamBuffer )
|
|
freeMem1D<Pel>( m_pStreamBuffer );
|
|
|
|
qDebug( ) << "Frame read time: "
|
|
<< QString::number( 1000 / ( m_uiAveragePlayInterval + 1 ) )
|
|
<< " fps";
|
|
|
|
m_bLoadAll = false;
|
|
m_bInit = false;
|
|
}
|
|
|
|
Void PlaYUVerStream::getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rFrameRate )
|
|
{
|
|
if( m_bInit )
|
|
{
|
|
rWidth = m_uiWidth;
|
|
rHeight = m_uiHeight;
|
|
rInputFormat = m_iPixelFormat;
|
|
rFrameRate = m_uiFrameRate;
|
|
}
|
|
else
|
|
{
|
|
rWidth = 0;
|
|
rHeight = 0;
|
|
rInputFormat = PlaYUVerFrame::YUV420p;
|
|
rFrameRate = 30;
|
|
}
|
|
}
|
|
|
|
Bool PlaYUVerStream::guessFormat( QString filename, UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rFrameRate )
|
|
{
|
|
Bool bRet = false;
|
|
QString FilenameShort = QFileInfo( filename ).fileName();
|
|
QString fileExtension = QFileInfo( filename ).suffix();
|
|
if( !fileExtension.compare( "yuv" ) )
|
|
{
|
|
bRet = true;
|
|
// Guess pixel format
|
|
QStringList formats_list = PlaYUVerFrame::supportedPixelFormatList();
|
|
for( Int i = 0; i < formats_list.size(); i++ )
|
|
{
|
|
if( FilenameShort.contains( formats_list.at( i ), Qt::CaseInsensitive ) )
|
|
{
|
|
rInputFormat = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( rWidth == 0 || rHeight == 0 )
|
|
{
|
|
// Guess resolution - match resolution name
|
|
Int iMatch = -1;
|
|
QStringList stdResName = standardResolutionSizes().stringListName;
|
|
for( Int i = 0; i < stdResName.size(); i++ )
|
|
{
|
|
if( FilenameShort.contains( stdResName.at( i ) ) )
|
|
{
|
|
if( iMatch >= 0 )
|
|
{
|
|
if( stdResName.at( i ).size() > stdResName.at( iMatch ).size() )
|
|
{
|
|
iMatch = i;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iMatch = i;
|
|
}
|
|
}
|
|
}
|
|
if( iMatch >= 0 )
|
|
{
|
|
rWidth = standardResolutionSizes().sizeResolution.at( iMatch ).width();
|
|
rHeight = standardResolutionSizes().sizeResolution.at( iMatch ).height();
|
|
}
|
|
// Guess resolution - match %dx%d
|
|
#if( QT_VERSION_PLAYUVER == 5 )
|
|
QRegularExpressionMatch resolutionMatch = QRegularExpression( "_\\d*x\\d*" ).match( FilenameShort );
|
|
if( resolutionMatch.hasMatch() )
|
|
{
|
|
QString resolutionString = resolutionMatch.captured( 0 );
|
|
if( resolutionString.startsWith( "_" ) || resolutionString.endsWith( "_" ) )
|
|
{
|
|
resolutionString.remove( "_" );
|
|
QStringList resolutionArgs = resolutionString.split( "x" );
|
|
qDebug( ) << "Found resolution = " << resolutionArgs;
|
|
if( resolutionArgs.size() == 2 )
|
|
{
|
|
rWidth = resolutionArgs.at( 0 ).toUInt();
|
|
rHeight = resolutionArgs.at( 1 ).toUInt();
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Guess resolution by file size
|
|
if( rWidth == 0 && rHeight == 0 )
|
|
{
|
|
|
|
Char *filename_char = new char[filename.length() + 1];
|
|
memcpy( filename_char, filename.toUtf8().constData(), filename.length() + 1 * sizeof(char) );
|
|
FILE* pF = fopen( filename_char, "rb" );
|
|
fseek( pF, 0, SEEK_END );
|
|
UInt64 uiFileSize = ftell( pF );
|
|
fclose( pF );
|
|
delete[] filename_char;
|
|
|
|
if( pF != NULL )
|
|
{
|
|
Int count = 0, module, frame_bytes, match;
|
|
QVector<QSize> sizeResolution = standardResolutionSizes().sizeResolution;
|
|
for( Int i = 0; i < sizeResolution.size(); i++ )
|
|
{
|
|
frame_bytes = PlaYUVerFrame::getBytesPerFrame( sizeResolution.at( i ).width(), sizeResolution.at( i ).height(), rInputFormat );
|
|
module = uiFileSize % frame_bytes;
|
|
if( module == 0 )
|
|
{
|
|
match = i;
|
|
count++;
|
|
}
|
|
}
|
|
if( count == 1 )
|
|
{
|
|
rWidth = sizeResolution.at( match ).width();
|
|
rHeight = sizeResolution.at( match ).height();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if( rWidth > 0 && rHeight > 0 && rInputFormat >= 0 )
|
|
bRet = false;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
Void PlaYUVerStream::loadAll()
|
|
{
|
|
if( m_bLoadAll || !m_bIsInput )
|
|
return;
|
|
|
|
if( m_ppcFrameBuffer )
|
|
{
|
|
for( UInt i = 0; i < m_uiFrameBufferSize; i++ )
|
|
{
|
|
if( m_ppcFrameBuffer[i] )
|
|
delete m_ppcFrameBuffer[i];
|
|
m_ppcFrameBuffer[i] = NULL;
|
|
}
|
|
freeMem1D<PlaYUVerFrame*>( m_ppcFrameBuffer );
|
|
m_ppcFrameBuffer = NULL;
|
|
}
|
|
m_uiFrameBufferSize = m_uiTotalFrameNum;
|
|
getMem1D<PlaYUVerFrame*>( &m_ppcFrameBuffer, m_uiFrameBufferSize );
|
|
for( UInt i = 0; i < m_uiFrameBufferSize; i++ )
|
|
{
|
|
m_ppcFrameBuffer[i] = new PlaYUVerFrame( m_uiWidth, m_uiHeight, m_iPixelFormat );
|
|
if( !m_ppcFrameBuffer[i] )
|
|
{
|
|
close();
|
|
}
|
|
}
|
|
m_uiFrameBufferIndex = 0;
|
|
m_pcCurrFrame = m_ppcFrameBuffer[m_uiFrameBufferIndex];
|
|
m_iCurrFrameNum = -1;
|
|
seekInput( 0 );
|
|
setNextFrame();
|
|
for( UInt i = m_uiFrameBufferIndex; i < m_uiFrameBufferSize; i++ )
|
|
{
|
|
readFrame();
|
|
setNextFrame();
|
|
}
|
|
m_bLoadAll = true;
|
|
seekInput( 0 );
|
|
}
|
|
|
|
Void PlaYUVerStream::getDuration( Int* duration_array )
|
|
{
|
|
Int hours, mins, secs;
|
|
#ifdef USE_FFMPEG
|
|
if( m_cLibAvContext->getStatus() )
|
|
{
|
|
secs = m_cLibAvContext->getStreamDuration();
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
secs = m_uiTotalFrameNum / m_uiFrameRate;
|
|
}
|
|
mins = secs / 60;
|
|
secs %= 60;
|
|
hours = mins / 60;
|
|
mins %= 60;
|
|
*duration_array++ = hours;
|
|
*duration_array++ = mins;
|
|
*duration_array++ = secs;
|
|
}
|
|
|
|
Void PlaYUVerStream::readFrame()
|
|
{
|
|
if( !m_bInit || !m_bIsInput )
|
|
return;
|
|
|
|
if( m_iCurrFrameNum + 1 >= ( Int64 )m_uiTotalFrameNum )
|
|
{
|
|
m_iErrorStatus = LAST_FRAME;
|
|
m_pcNextFrame = NULL;
|
|
return;
|
|
}
|
|
|
|
if( m_bLoadAll )
|
|
{
|
|
return;
|
|
}
|
|
|
|
#ifdef USE_FFMPEG
|
|
if( m_cLibAvContext->getStatus() )
|
|
{
|
|
if( !m_cLibAvContext->decodeAvFormat() )
|
|
{
|
|
m_iErrorStatus = READING;
|
|
}
|
|
m_pcNextFrame->FrameFromBuffer( m_cLibAvContext->video_dst_data[0], m_iPixelFormat );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
UInt64 frame_bytes_input = m_pcNextFrame->getBytesPerFrame();
|
|
UInt64 bytes_read = fread( m_pStreamBuffer, sizeof(Pel), frame_bytes_input, m_pFile );
|
|
if( bytes_read != frame_bytes_input )
|
|
{
|
|
m_iErrorStatus = READING;
|
|
qDebug( ) << " Reading error !!!"
|
|
<< endl;
|
|
return;
|
|
}
|
|
m_pcNextFrame->FrameFromBuffer( m_pStreamBuffer, m_iPixelFormat );
|
|
}
|
|
//Int time = m_cTimer.elapsed();
|
|
//m_uiAveragePlayInterval = ( m_uiAveragePlayInterval + time) / 2;
|
|
m_pcNextFrame->FrametoRGB8();
|
|
return;
|
|
}
|
|
|
|
Void PlaYUVerStream::writeFrame()
|
|
{
|
|
UInt64 frame_bytes_input = m_pcCurrFrame->getBytesPerFrame();
|
|
m_pcCurrFrame->FrameToBuffer( m_pStreamBuffer );
|
|
UInt64 bytes_read = fwrite( m_pStreamBuffer, sizeof(Pel), frame_bytes_input, m_pFile );
|
|
if( bytes_read != frame_bytes_input )
|
|
{
|
|
m_iErrorStatus = WRITING;
|
|
}
|
|
return;
|
|
}
|
|
|
|
Void PlaYUVerStream::writeFrame( PlaYUVerFrame *pcFrame )
|
|
{
|
|
UInt64 frame_bytes_input = pcFrame->getBytesPerFrame();
|
|
pcFrame->FrameToBuffer( m_pStreamBuffer );
|
|
UInt64 bytes_read = fwrite( m_pStreamBuffer, sizeof(Pel), frame_bytes_input, m_pFile );
|
|
if( bytes_read != frame_bytes_input )
|
|
{
|
|
m_iErrorStatus = WRITING;
|
|
}
|
|
return;
|
|
}
|
|
|
|
Bool PlaYUVerStream::saveFrame( const QString& filename )
|
|
{
|
|
Int iFileFormat = INVALID_INPUT;
|
|
|
|
QStringList formatsExt = PlaYUVerStream::supportedReadFormatsExt();
|
|
QString currExt = QFileInfo( filename ).suffix();
|
|
if( formatsExt.contains( currExt ) )
|
|
{
|
|
iFileFormat = formatsExt.indexOf( currExt );
|
|
}
|
|
|
|
if( iFileFormat == YUVINPUT )
|
|
{
|
|
PlaYUVerStream auxFrameStream;
|
|
if( !auxFrameStream.open( filename, m_uiWidth, m_uiHeight, m_iPixelFormat, m_uiFrameRate, false ) )
|
|
{
|
|
return false;
|
|
}
|
|
auxFrameStream.writeFrame( m_pcCurrFrame );
|
|
auxFrameStream.close();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
m_pcCurrFrame->FrametoRGB8();
|
|
QImage qimg = QImage( m_pcCurrFrame->getQImageBuffer(), m_pcCurrFrame->getWidth(), m_pcCurrFrame->getHeight(), QImage::Format_RGB888 );
|
|
return qimg.save( filename );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Void PlaYUVerStream::setNextFrame()
|
|
{
|
|
if( m_pcNextFrame )
|
|
{
|
|
m_pcCurrFrame = m_pcNextFrame;
|
|
m_iCurrFrameNum++;
|
|
m_uiFrameBufferIndex++;
|
|
if( m_uiFrameBufferIndex == m_uiFrameBufferSize )
|
|
{
|
|
m_uiFrameBufferIndex = 0;
|
|
}
|
|
m_pcNextFrame = m_ppcFrameBuffer[m_uiFrameBufferIndex];
|
|
}
|
|
else
|
|
{
|
|
m_iErrorStatus = END_OF_SEQ;
|
|
seekInput( 0 );
|
|
}
|
|
}
|
|
|
|
PlaYUVerFrame* PlaYUVerStream::getCurrFrame( PlaYUVerFrame *pyuv_image )
|
|
{
|
|
if( pyuv_image == NULL )
|
|
pyuv_image = new PlaYUVerFrame( m_pcCurrFrame );
|
|
else
|
|
pyuv_image->copyFrom( m_pcCurrFrame );
|
|
return pyuv_image;
|
|
}
|
|
|
|
PlaYUVerFrame* PlaYUVerStream::getCurrFrame()
|
|
{
|
|
return m_pcCurrFrame;
|
|
}
|
|
|
|
Bool PlaYUVerStream::seekInput( UInt64 new_frame_num )
|
|
{
|
|
if( !m_bInit || new_frame_num < 0 || new_frame_num >= m_uiTotalFrameNum || ( Int64 )new_frame_num == m_iCurrFrameNum )
|
|
return false;
|
|
|
|
m_iCurrFrameNum = new_frame_num - 1;
|
|
|
|
if( m_bLoadAll )
|
|
{
|
|
m_uiFrameBufferIndex = new_frame_num;
|
|
m_pcNextFrame = m_ppcFrameBuffer[m_uiFrameBufferIndex];
|
|
setNextFrame();
|
|
return true;
|
|
}
|
|
#ifdef USE_FFMPEG
|
|
if( m_cLibAvContext->getStatus() )
|
|
{
|
|
m_cLibAvContext->seekAvFormat( new_frame_num );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
UInt64 frame_bytes_input = m_ppcFrameBuffer[0]->getBytesPerFrame();
|
|
UInt64 nbytes_seek = frame_bytes_input * new_frame_num;
|
|
fseek( m_pFile, nbytes_seek, SEEK_SET );
|
|
}
|
|
m_uiFrameBufferIndex = 0;
|
|
m_pcCurrFrame = m_pcNextFrame = m_ppcFrameBuffer[m_uiFrameBufferIndex];
|
|
|
|
readFrame();
|
|
setNextFrame();
|
|
if( m_uiTotalFrameNum > 1 )
|
|
readFrame();
|
|
return true;
|
|
}
|
|
|
|
Bool PlaYUVerStream::checkErrors( Int error_type )
|
|
{
|
|
if( m_iErrorStatus == error_type )
|
|
{
|
|
m_iErrorStatus = NO_STREAM_ERROR;
|
|
return true;
|
|
}
|
|
if( m_iErrorStatus == error_type )
|
|
{
|
|
m_iErrorStatus = NO_STREAM_ERROR;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // NAMESPACE
|