jfmcarreira/calyp
1
0 Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Finish three stream handlers: Raw, OpenCv, Libav

Browse Source
This commit is contained in:
jfmcarreira committed 2016-04-02 01:36:52 +01:00
1 parent 5f9533b212
commit 2ab86e5aee
12 files changed
+289 -257
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

lib/CMakeLists.txt
+1 -1
View File
@@ -22,7 +22,7 @@ IF( USE_FFMPEG )
ENDIF()
IF( USE_OPENCV )
LIST( APPEND PlaYUVer_Lib_SRCS LibOpenCVHandler.cpp )
LIST( APPEND PlaYUVer_Lib_SRCS StreamHandlerOpenCV.cpp )
ENDIF()
lib/LibOpenCVHandler.cpp
-69
View File
@@ -1,69 +0,0 @@
/* This file is a part of plaYUVer project
* Copyright (C) 2014-2015 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 LibOpenCVHandler.cpp
* \ingroup PlaYUVerLib
* \brief Interface with opencv lib
*/
#include <cstdio>
#include "LibOpenCVHandler.h"
#include "PlaYUVerFrame.h"
#include "PlaYUVerFramePixelFormats.h"
#include "LibMemory.h"
namespace plaYUVer
{
std::vector<PlaYUVerSupportedFormat> LibOpenCVHandler::supportedReadFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
REGIST_PLAYUVER_SUPPORTED_FMT( "Portable Grayscale Map ", "pgm" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Portable Network Graphics", "png" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Joint Photographic Experts Group", "jpg" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Windows Bitmap", "bmp" );
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
std::vector<PlaYUVerSupportedFormat> LibOpenCVHandler::supportedWriteFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
std::vector<PlaYUVerSupportedFormat> LibOpenCVHandler::supportedSaveFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
APPEND_PLAYUVER_SUPPORTED_FMT( LibOpenCVHandler, Read );
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
PlaYUVerFrame* LibOpenCVHandler::loadFrame( std::string filename )
{
return NULL;
}
Bool LibOpenCVHandler::saveFrame( PlaYUVerFrame* pcFrame, std::string filename )
{
cv::Mat* pcCvFrame = pcFrame->getCvMat();
return cv::imwrite( filename, *pcCvFrame );
}
} // NAMESPACE
lib/PlaYUVerFrame.cpp
+36 -26
View File
@@ -33,7 +33,7 @@
#include "StreamHandlerLibav.h"
#endif
#ifdef USE_OPENCV
#include "LibOpenCVHandler.h"
#include "StreamHandlerOpenCV.h"
#endif
#ifdef USE_PIXFC
#include "pixfc-sse.h"
@@ -74,14 +74,14 @@ std::vector<std::string> PlaYUVerFrame::supportedPixelFormatListNames( Int color
return formatsList;
}
PlaYUVerFrame::PlaYUVerFrame( UInt width, UInt height, Int pelFormat, Int bitsPixel )
PlaYUVerFrame::PlaYUVerFrame( UInt width, UInt height, Int pelFormat, Int bitsPixel, Int endianness )
{
init( width, height, pelFormat, bitsPixel );
init( width, height, pelFormat, bitsPixel, endianness );
}
PlaYUVerFrame::PlaYUVerFrame( PlaYUVerFrame *other, Bool bCopy )
{
init( other->getWidth(), other->getHeight(), other->getPelFormat(), other->getBitsPel() );
init( other->getWidth(), other->getHeight(), other->getPelFormat(), other->getBitsPel(), other->getEndianness() );
copyFrom( other );
}
@@ -105,7 +105,7 @@ PlaYUVerFrame::PlaYUVerFrame( PlaYUVerFrame *other, UInt posX, UInt posY, UInt a
areaHeight++;
}
init( areaWidth, areaHeight, other->getPelFormat(), other->getBitsPel() );
init( areaWidth, areaHeight, other->getPelFormat(), other->getBitsPel(), other->getEndianness() );
copyFrom( other, posX, posY );
}
@@ -138,10 +138,10 @@ static Int getMem3ImageComponents( Pel**** array3D, Int dim1, Int dim2, Int log2
total_mem_size += getMem2D<Pel*>( array3D, dim0, dim1 );
if( ( ( *array3D )[0][0] = ( Pel* )xCallocMem( mem_size, sizeof(Pel) ) ) == NULL )
if( ( ( *array3D )[0][0] = ( Pel* )xCallocMem( mem_size, sizeof( Pel ) ) ) == NULL )
printf( "getMem3DImageComponents: array1D" );
total_mem_size += mem_size * sizeof(Pel);
total_mem_size += mem_size * sizeof( Pel );
// Luma
for( i = 1; i < dim1; i++ )
@@ -163,7 +163,7 @@ static Int getMem3ImageComponents( Pel**** array3D, Int dim1, Int dim2, Int log2
return total_mem_size;
}
Void PlaYUVerFrame::init( UInt width, UInt height, Int pel_format, Int bitsPixel )
Void PlaYUVerFrame::init( UInt width, UInt height, Int pel_format, Int bitsPixel, Int endianness )
{
m_bInit = false;
m_pppcInputPel = NULL;
@@ -173,6 +173,11 @@ Void PlaYUVerFrame::init( UInt width, UInt height, Int pel_format, Int bitsPixel
m_iPixelFormat = pel_format;
m_iNumberChannels = 3;
m_uiBitsPel = bitsPixel > 8 ? bitsPixel : 8;
m_iEndianness = endianness;
if( m_uiBitsPel > 8 && m_iEndianness == -1 )
{
throw "Invalid endianness type for Bits per Pixel greater than 8";
}
m_uiHalfPelValue = 1 << ( m_uiBitsPel - 1 );
if( m_uiWidth == 0 || m_uiHeight == 0 || m_iPixelFormat == -1 || bitsPixel > 16 )
@@ -364,7 +369,7 @@ Void PlaYUVerFrame::copyFrom( PlaYUVerFrame* input_frame )
return;
m_bHasRGBPel = false;
m_bHasHistogram = false;
memcpy( *m_pppcInputPel[LUMA], input_frame->getPelBufferYUV()[LUMA][0], getBytesPerFrame() * sizeof(Pel) );
memcpy( *m_pppcInputPel[LUMA], input_frame->getPelBufferYUV()[LUMA][0], getBytesPerFrame() * sizeof( Pel ) );
}
Void PlaYUVerFrame::copyFrom( PlaYUVerFrame* input_frame, UInt xPos, UInt yPos )
@@ -378,18 +383,23 @@ Void PlaYUVerFrame::copyFrom( PlaYUVerFrame* input_frame, UInt xPos, UInt yPos )
Int ratioW = ch > 0 ? m_pcPelFormat->log2ChromaHeight : 0;
for( UInt i = 0; i < CHROMASHIFT( m_uiHeight, ratioH ); i++ )
{
memcpy( m_pppcInputPel[ch][i], &( pInput[ch][( yPos >> ratioH ) + i][( xPos >> ratioW )] ), ( m_uiWidth >> ratioW ) * sizeof(Pel) );
memcpy( m_pppcInputPel[ch][i], &( pInput[ch][( yPos >> ratioH ) + i][( xPos >> ratioW )] ), ( m_uiWidth >> ratioW ) * sizeof( Pel ) );
}
}
m_bHasRGBPel = false;
m_bHasHistogram = false;
}
Void PlaYUVerFrame::frameFromBuffer( Byte *Buff, UInt64 uiBuffSize, Int endianess )
Void PlaYUVerFrame::frameFromBuffer( Byte *Buff, UInt64 uiBuffSize )
{
if( uiBuffSize != getBytesPerFrame() )
return;
frameFromBuffer( Buff );
}
Void PlaYUVerFrame::frameFromBuffer( Byte *Buff )
{
Byte* ppBuff[MAX_NUMBER_PLANES];
Byte* pTmpBuff;
Pel* pPel;
@@ -398,7 +408,7 @@ Void PlaYUVerFrame::frameFromBuffer( Byte *Buff, UInt64 uiBuffSize, Int endianes
Int ratioH, ratioW, step;
UInt i, ch, b;
if( endianess == 1 )
if( m_iEndianness == 1 )
{
shiftInput = 8;
shiftOutput = 0;
@@ -913,11 +923,11 @@ Void PlaYUVerFrame::openPixfc()
#ifdef USE_PIXFC
m_pcPixfc = NULL;
PixFcPixelFormat input_format = PixFcYUV420P;
PixFcFlag flags = (PixFcFlag)(PixFcFlag_Default + PixFcFlag_NNbResamplingOnly);
PixFcFlag flags = ( PixFcFlag )( PixFcFlag_Default + PixFcFlag_NNbResamplingOnly );
UInt input_row_size = m_uiWidth;
if (create_pixfc(&m_pcPixfc, input_format, PixFcRGB24, m_uiWidth, m_uiHeight, input_row_size, m_uiWidth * 3, flags ) != 0)
if( create_pixfc( &m_pcPixfc, input_format, PixFcRGB24, m_uiWidth, m_uiHeight, input_row_size, m_uiWidth * 3, flags ) != 0 )
{
fprintf(stderr, "Error creating struct pixfc\n");
fprintf( stderr, "Error creating struct pixfc\n" );
m_pcPixfc = NULL;
return;
}
@@ -928,7 +938,7 @@ Void PlaYUVerFrame::closePixfc()
{
#ifdef USE_PIXFC
if( m_pcPixfc )
destroy_pixfc(m_pcPixfc);
destroy_pixfc( m_pcPixfc );
#endif
}
@@ -937,20 +947,20 @@ Void PlaYUVerFrame::FrametoRGB8Pixfc()
#ifdef USE_PIXFC
switch( m_iPixelFormat )
{
case YUV420p:
m_pcPixfc->convert(m_pcPixfc, m_pppcInputPel, m_pcRGB32);
case YUV420p:
m_pcPixfc->convert( m_pcPixfc, m_pppcInputPel, m_pcRGB32 );
break;
case YUV422p:
case YUV422p:
break;
case YUV444p:
case YUYV422:
m_pcPixfc->convert(m_pcPixfc, m_pppcInputPel, m_pcRGB32);
case YUV444p:
case YUYV422:
m_pcPixfc->convert( m_pcPixfc, m_pppcInputPel, m_pcRGB32 );
break;
case GRAY:
case GRAY:
break;
case RGB8:
case RGB8:
break;
default:
default:
// No action.
break;
}
@@ -1020,7 +1030,7 @@ Void PlaYUVerFrame::fromCvMat( cv::Mat* pcCvFrame )
if( !m_bInit )
{
init( pcCvFrame->cols, pcCvFrame->rows, m_iPixelFormat, 8 );
init( pcCvFrame->cols, pcCvFrame->rows, m_iPixelFormat, 8, -1 );
}
m_bHasRGBPel = false;
lib/PlaYUVerFrame.h
+10 -5
View File
@@ -115,7 +115,7 @@ public:
*
* @note this function might misbehave if the pixel format enum is not correct
*/
PlaYUVerFrame( UInt width, UInt height, Int pelFormat = 0, Int bitsPixel = 8 );
PlaYUVerFrame( UInt width, UInt height, Int pelFormat = 0, Int bitsPixel = 8, Int endianness = -1 );
/**
* Creates and new frame with the configuration of an
@@ -158,7 +158,10 @@ public:
{
return m_uiBitsPel;
}
Int getEndianness() const
{
return m_iEndianness;
}
Pel*** getPelBufferYUV() const
{
return m_pppcInputPel;
@@ -207,11 +210,12 @@ public:
PlaYUVerPixel getPixelValue( Int xPos, Int yPos );
PlaYUVerPixel getPixelValue( Int xPos, Int yPos, PlaYUVerPixel::ColorSpace eColorSpace );
Void setPixelValue( Int xPos, Int yPos, PlaYUVerPixel pixel );
Void copyFrom( PlaYUVerFrame* );
Void copyFrom( PlaYUVerFrame*, UInt, UInt );
Void frameFromBuffer( Byte*, UInt64, Int );
Void frameFromBuffer( Byte*, UInt64 );
Void frameFromBuffer( Byte* );
Void frameToBuffer( Byte* );
Void fillRGBBuffer();
@@ -297,6 +301,7 @@ private:
Int m_iPixelFormat; //!< Pixel format number (it follows the list of supported pixel formats)
Int m_iNumberChannels; //!< Number of channels
UInt m_uiBitsPel; //!< Bits per pixel/channel
Int m_iEndianness; //!< Endiannes of bytes
UInt m_uiHalfPelValue; //!< Bits per pixel/channel
Pel*** m_pppcInputPel;
@@ -328,7 +333,7 @@ private:
* @param pel_format pixel format index (always use PixelFormats enum)
*
*/
Void init( UInt width, UInt height, Int pel_format, Int bitsPixel );
Void init( UInt width, UInt height, Int pel_format, Int bitsPixel, Int endianness );
Void openPixfc();
Void closePixfc();
lib/PlaYUVerStream.cpp
+62 -113
View File
@@ -30,12 +30,13 @@
#include "PlaYUVerStream.h"
#include "PlaYUVerStreamHandlerIf.h"
#include "StreamHandlerRaw.h"
#include "StreamHandlerPortable.h"
#ifdef USE_FFMPEG
#include "StreamHandlerLibav.h"
#endif
#ifdef USE_OPENCV
#include "LibOpenCVHandler.h"
#include "StreamHandlerOpenCV.h"
#endif
namespace plaYUVer
@@ -44,8 +45,8 @@ namespace plaYUVer
std::vector<PlaYUVerSupportedFormat> PlaYUVerStream::supportedReadFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
REGIST_PLAYUVER_SUPPORTED_FMT( "Raw Video", "yuv" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Raw Video", "gray" );
REGIST_PLAYUVER_SUPPORTED_FMT( &PlaYUVerRawHandler::Create, "Raw Video", "yuv" );
REGIST_PLAYUVER_SUPPORTED_FMT( &PlaYUVerRawHandler::Create, "Raw Video", "gray" );
#ifdef USE_FFMPEG
APPEND_PLAYUVER_SUPPORTED_FMT( StreamHandlerLibav, Read );
#endif
@@ -58,7 +59,7 @@ std::vector<PlaYUVerSupportedFormat> PlaYUVerStream::supportedReadFormats()
std::vector<PlaYUVerSupportedFormat> PlaYUVerStream::supportedWriteFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
REGIST_PLAYUVER_SUPPORTED_FMT( "Raw Video", "yuv" );
REGIST_PLAYUVER_SUPPORTED_FMT( &PlaYUVerRawHandler::Create, "Raw Video", "yuv" );
#ifdef USE_FFMPEG
APPEND_PLAYUVER_SUPPORTED_FMT( StreamHandlerLibav, Write );
#endif
@@ -73,7 +74,7 @@ std::vector<PlaYUVerSupportedFormat> PlaYUVerStream::supportedSaveFormats()
APPEND_PLAYUVER_SUPPORTED_FMT( StreamHandlerLibav, Save );
#endif
#ifdef USE_OPENCV
APPEND_PLAYUVER_SUPPORTED_FMT( LibOpenCVHandler, Save );
APPEND_PLAYUVER_SUPPORTED_FMT( StreamHandlerOpenCV, Save );
#endif
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
@@ -129,18 +130,11 @@ PlaYUVerStream::PlaYUVerStream()
m_uiFrameBufferSize = 2;
m_uiFrameBufferIndex = 0;
m_uiCurrFrameFileIdx = 0;
// #ifdef USE_FFMPEG
// m_cLibAvContext = new StreamHandlerLibav;
// #endif
}
PlaYUVerStream::~PlaYUVerStream()
{
close();
// #ifdef USE_FFMPEG
// if( m_cLibAvContext )
// delete m_cLibAvContext;
// #endif
}
std::string PlaYUVerStream::getFormatName()
@@ -152,57 +146,6 @@ std::string PlaYUVerStream::getCodecName()
return !m_pcStreamHandler ? "" : m_pcStreamHandler->getCodecName();
}
Void PlaYUVerStream::findHandler()
{
m_iStreamHandler = INVALID_HANDLER;
// if( m_uiBitsPerPixel != 8 )
// {
// m_iStreamHandler = YUV_IO;
// return;
// }
std::string currExt = m_cFilename.substr( m_cFilename.find_last_of( "." ) + 1 );
currExt = lowercase( currExt );
if( m_bIsInput )
{
#ifdef USE_FFMPEG
std::vector<PlaYUVerSupportedFormat> supportedFmts = StreamHandlerLibav::supportedReadFormats();
for( UInt i = 0; i < supportedFmts.size(); i++ )
{
if( supportedFmts[i].formatExt == currExt )
{
//m_cFormatName = uppercase( supportedFmts[i].formatExt );
m_iStreamHandler = FFMPEG;
return;
}
}
#endif
if( m_iStreamHandler == INVALID_HANDLER )
m_iStreamHandler = YUV_IO;
}
else
{
#ifdef USE_FFMPEG
std::vector<PlaYUVerSupportedFormat> supportedFmts = StreamHandlerLibav::supportedWriteFormats();
for( UInt i = 0; i < supportedFmts.size(); i++ )
{
if( supportedFmts[i].formatExt == currExt )
{
// m_cFormatName = uppercase( supportedFmts[i].formatExt );
m_iStreamHandler = FFMPEG;
return;
}
}
#endif
if( currExt == "yuv" )
{
m_iStreamHandler = YUV_IO;
}
}
}
Bool PlaYUVerStream::open( std::string filename, std::string resolution, std::string input_format_name, UInt bitsPel, Int endianness, UInt frame_rate, Bool bInput )
{
UInt width;
@@ -248,43 +191,55 @@ Bool PlaYUVerStream::open( std::string filename, UInt width, UInt height, Int in
std::copy( m_cFilename.begin(), m_cFilename.end(), m_pchFilename );
m_pchFilename[m_cFilename.size()] = '\0'; // don't forget the terminating 0
findHandler();
if( m_iStreamHandler == INVALID_HANDLER )
m_iStreamHandler = INVALID_HANDLER;
std::string currExt = m_cFilename.substr( m_cFilename.find_last_of( "." ) + 1 );
currExt = lowercase( currExt );
std::vector<PlaYUVerSupportedFormat> supportedFmts;
if( m_bIsInput )
{
close();
throw "Invalid file format";
return m_bInit;
supportedFmts = supportedReadFormats();
}
m_uiFrameBufferSize = m_bIsInput ? 2 : 1;
#ifdef USE_OPENCV
if( m_iStreamHandler == OPENCV_HANDLER )
else
{
m_pcCurrFrame = LibOpenCVHandler::loadFrame( m_cFilename );
if( m_pcCurrFrame )
supportedFmts = supportedWriteFormats();
}
for( UInt i = 0; i < supportedFmts.size(); i++ )
{
if( supportedFmts[i].formatExt == currExt )
{
m_uiWidth = m_pcCurrFrame->getWidth();
m_uiHeight = m_pcCurrFrame->getHeight();
m_iPixelFormat = m_pcCurrFrame->getPelFormat();
m_pfctCreateHandler = supportedFmts[i].formatFct;
break;
}
m_pcNextFrame = NULL;
m_uiFrameBufferSize = 0;
m_uiFrameBufferIndex = 0;
m_uiTotalFrameNum = 1;
}
#endif
#ifdef USE_FFMPEG
if( m_iStreamHandler == FFMPEG )
{
m_pcStreamHandler = new StreamHandlerLibav;
}
#endif
if( m_iStreamHandler == YUV_IO )
{
m_pcStreamHandler = new PlaYUVerRawHandler;
}
// if( m_iStreamHandler == INVALID_HANDLER )
// {
// close();
// throw "Invalid file format";
// return m_bInit;
// }
// #ifdef USE_OPENCV
// if( m_iStreamHandler == OPENCV_HANDLER )
// {
// m_pcCurrFrame = LibOpenCVHandler::loadFrame( m_cFilename );
// if( m_pcCurrFrame )
// {
// m_uiWidth = m_pcCurrFrame->getWidth();
// m_uiHeight = m_pcCurrFrame->getHeight();
// m_iPixelFormat = m_pcCurrFrame->getPelFormat();
// }
// m_pcNextFrame = NULL;
// m_uiFrameBufferSize = 0;
// m_uiFrameBufferIndex = 0;
// m_uiTotalFrameNum = 1;
// }
// #endif
m_pcStreamHandler = m_pfctCreateHandler();
if( !m_pcStreamHandler )
{
@@ -307,12 +262,14 @@ Bool PlaYUVerStream::open( std::string filename, UInt width, UInt height, Int in
return m_bInit;
}
m_uiFrameBufferSize = m_bIsInput ? 2 : 1;
getMem1D<PlaYUVerFrame*>( &m_ppcFrameBuffer, m_uiFrameBufferSize );
for( UInt i = 0; i < m_uiFrameBufferSize; i++ )
{
try
{
m_ppcFrameBuffer[i] = new PlaYUVerFrame( m_uiWidth, m_uiHeight, m_iPixelFormat, m_uiBitsPerPixel );
m_ppcFrameBuffer[i] = new PlaYUVerFrame( m_uiWidth, m_uiHeight, m_iPixelFormat, m_uiBitsPerPixel, m_iEndianness );
}
catch( const char *msg )
{
@@ -338,7 +295,7 @@ Bool PlaYUVerStream::open( std::string filename, UInt width, UInt height, Int in
return m_bInit;
}
if( !getMem1D<Byte>( &m_pStreamBuffer, m_pcCurrFrame->getBytesPerFrame() ) )
if( !m_pcStreamHandler->configureBuffer( m_pcCurrFrame ) )
{
close();
throw "[PlaYUVerStream] Cannot allocated memory";
@@ -530,15 +487,12 @@ Void PlaYUVerStream::readFrame()
return;
}
UInt64 uiByterPerFrame = m_pcNextFrame->getBytesPerFrame();
if( !m_pcStreamHandler->read( m_pStreamBuffer ) )
if( !m_pcStreamHandler->read( m_pcNextFrame ) )
{
throw "[PlaYUVerStream] Cannot read file";
return;
}
m_pcNextFrame->frameFromBuffer( m_pStreamBuffer, uiByterPerFrame, m_iEndianness );
m_uiCurrFrameFileIdx++;
return;
@@ -551,13 +505,9 @@ Void PlaYUVerStream::writeFrame()
Void PlaYUVerStream::writeFrame( PlaYUVerFrame *pcFrame )
{
if( m_iStreamHandler == YUV_IO )
if( !m_pcStreamHandler->write( pcFrame ) )
{
pcFrame->frameToBuffer( m_pStreamBuffer );
if( !m_pcStreamHandler->write( m_pStreamBuffer ) )
{
throw "[PlaYUVerStream] Cannot write into the file";
}
throw "[PlaYUVerStream] Cannot write into the file";
}
return;
}
@@ -572,7 +522,6 @@ Bool PlaYUVerStream::saveFrame( const std::string& filename, PlaYUVerFrame *save
Int iFileFormat = INVALID_HANDLER;
std::string fmtExt;
//std::string currExt = QFileInfo( qtString ).suffix().toStdString();
std::string currExt = filename.substr( filename.find_last_of( "." ) + 1 );
std::vector<PlaYUVerSupportedFormat> supportedFmts = PlaYUVerStream::supportedSaveFormats();
@@ -607,12 +556,12 @@ Bool PlaYUVerStream::saveFrame( const std::string& filename, PlaYUVerFrame *save
return qimg.save( qtString );
}
#endif
#ifdef USE_OPENCV
else
{
return LibOpenCVHandler::saveFrame( saveFrame, filename );
}
#endif
// #ifdef USE_OPENCV
// else
// {
// return LibOpenCVHandler::saveFrame( saveFrame, filename );
// }
// #endif
}
return false;
}
lib/PlaYUVerStream.h
+7 -5
View File
@@ -35,7 +35,6 @@
namespace plaYUVer
{
class StreamHandlerLibav;
class LibOpenCVHandler;
class PlaYUVerStreamHandlerIf;
@@ -46,10 +45,14 @@ typedef struct
UInt uiHeight;
} PlaYUVerStdResolution;
typedef PlaYUVerStreamHandlerIf* (*CreateStreamHandlerFn)( void );
typedef struct
{
std::string formatName;
std::string formatExt;
CreateStreamHandlerFn formatFct;
} PlaYUVerSupportedFormat;
#define INI_REGIST_PLAYUVER_SUPPORTED_FMT \
@@ -59,9 +62,10 @@ typedef struct
#define END_REGIST_PLAYUVER_SUPPORTED_FMT \
return formatsList;
#define REGIST_PLAYUVER_SUPPORTED_FMT( name, ext ) \
#define REGIST_PLAYUVER_SUPPORTED_FMT( handler, name, ext ) \
formatElem.formatName = name; \
formatElem.formatExt = lowercase( ext ); \
formatElem.formatFct = handler; \
formatsList.push_back( formatElem );
#define APPEND_PLAYUVER_SUPPORTED_FMT( class_name, fct ) \
@@ -176,8 +180,8 @@ private:
TOTAL_HANDLERR
};
Int m_iStreamHandler;
CreateStreamHandlerFn m_pfctCreateHandler;
PlaYUVerStreamHandlerIf* m_pcStreamHandler;
StreamHandlerLibav* m_cLibAvContext;
std::string m_cFilename;
Char* m_pchFilename;
@@ -200,8 +204,6 @@ private:
UInt m_uiFrameBufferIndex;
UInt64 m_uiCurrFrameFileIdx;
Void findHandler();
};
} // NAMESPACE
lib/PlaYUVerStreamHandlerIf.h
+16 -6
View File
@@ -26,13 +26,16 @@
#define __PLAYUVERSTREAMHANDLERIF_H__
#include "PlaYUVerDefs.h"
// #include <iostream>
// #include <fstream>
// #include <cstdio>
#include "LibMemory.h"
namespace plaYUVer
{
#define REGISTER_STREAM_HANDLER(X) \
public: \
static PlaYUVerStreamHandlerIf* Create() { return new X(); } \
void Delete() { delete this; }
/**
* \class PlaYUVerStreamHandlerIf
* \ingroup PlaYUVerLib PlaYUVerLib_Stream
@@ -45,16 +48,21 @@ public:
{
m_bIsInput = true;
}
~PlaYUVerStreamHandlerIf()
virtual ~PlaYUVerStreamHandlerIf()
{
}
virtual Bool openHandler( std::string strFilename, Bool bInput ) = 0;
virtual UInt64 calculateFrameNumber() = 0;
virtual Void closeHandler() = 0;
virtual Bool read( Byte* pchBuffer ) = 0;
virtual Bool write( Byte* pchBuffer ) = 0;
virtual Bool read( PlaYUVerFrame* pcFrame ) = 0;
virtual Bool write( PlaYUVerFrame* pcFrame ) = 0;
virtual Bool seek( UInt64 iFrameNum ) = 0;
virtual Bool configureBuffer( PlaYUVerFrame* pcFrame )
{
return getMem1D<Byte>( &m_pStreamBuffer, pcFrame->getBytesPerFrame() );
}
virtual Void getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rBitsPerPel, Int& rEndianness, Double& rFrameRate )
{
return;
@@ -71,8 +79,10 @@ public:
{
return m_strCodecName;
}
protected:
Bool m_bIsInput;
Byte* m_pStreamBuffer;
UInt64 m_uiNBytesPerFrame;
std::string m_strFormatName;
std::string m_strCodecName;
lib/StreamHandlerLibav.cpp
+17 -17
View File
@@ -35,16 +35,16 @@ namespace plaYUVer
std::vector<PlaYUVerSupportedFormat> StreamHandlerLibav::supportedReadFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
REGIST_PLAYUVER_SUPPORTED_FMT( "Portable Grayscale Map", "pgm" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Portable Network Graphics", "png" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Joint Photographic Experts Group", "jpg" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Windows Bitmap", "bmp" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Audio video interleaved", "avi" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Windows media video", "wmv" );
REGIST_PLAYUVER_SUPPORTED_FMT( "MPEG4", "mp4" );
REGIST_PLAYUVER_SUPPORTED_FMT( "Matroska Multimedia Container", "mkv" );
REGIST_PLAYUVER_SUPPORTED_FMT( "H.264 streams", "h264" );
REGIST_PLAYUVER_SUPPORTED_FMT( "HEVC streams", "hevc" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Portable Grayscale Map", "pgm" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Portable Network Graphics", "png" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Joint Photographic Experts Group", "jpg" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Windows Bitmap", "bmp" );
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, "MPEG4", "mp4" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "Matroska Multimedia Container", "mkv" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "H.264 streams", "h264" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerLibav::Create, "HEVC streams", "hevc" );
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
@@ -96,8 +96,6 @@ static int open_codec_context( int *stream_idx, AVFormatContext *m_cFmtCtx, enum
return 0;
}
// Bool StreamHandlerLibav::initAvFormat( const char* filename, UInt& width, UInt& height, Int& pixel_format, UInt& bits_pel, Int& endianness, Double& frame_rate,
// UInt64& num_frames )
Bool StreamHandlerLibav::openHandler( std::string strFilename, Bool bInput )
{
const char* filename = strFilename.c_str();
@@ -331,7 +329,7 @@ Bool StreamHandlerLibav::decodeVideoPkt()
return got_frame > 0 ? true : false;
}
Bool StreamHandlerLibav::read( Byte* pchBuffer )
Bool StreamHandlerLibav::read( PlaYUVerFrame* pcFrame )
{
Bool bGotFrame = false;
AVPacket orig_pkt = pkt;
@@ -364,20 +362,22 @@ Bool StreamHandlerLibav::read( Byte* pchBuffer )
if( bGotFrame )
{
av_image_copy_to_buffer( m_pchFrameBuffer, m_uiFrameBufferSize, m_cFrame->data, m_cFrame->linesize, m_cCodecCtx->pix_fmt, m_cCodecCtx->width,
m_cCodecCtx->height, 1 );
av_image_copy_to_buffer( pchBuffer, m_uiFrameBufferSize, m_cFrame->data, m_cFrame->linesize, m_cCodecCtx->pix_fmt, m_cCodecCtx->width,
// av_image_copy_to_buffer( m_pchFrameBuffer, m_uiFrameBufferSize, m_cFrame->data, m_cFrame->linesize, m_cCodecCtx->pix_fmt, m_cCodecCtx->width,
// m_cCodecCtx->height, 1 );
av_image_copy_to_buffer( m_pStreamBuffer, m_uiFrameBufferSize, m_cFrame->data, m_cFrame->linesize, m_cCodecCtx->pix_fmt, m_cCodecCtx->width,
m_cCodecCtx->height, 1 );
if( orig_pkt.size )
av_free_packet( &orig_pkt );
pcFrame->frameFromBuffer( m_pStreamBuffer );
return true;
}
return false;
}
Bool StreamHandlerLibav::write( Byte* pchBuffer )
Bool StreamHandlerLibav::write( PlaYUVerFrame* pcFrame )
{
return false;
}
lib/StreamHandlerLibav.h
+7 -3
View File
@@ -56,6 +56,8 @@ namespace plaYUVer
class StreamHandlerLibav: public PlaYUVerStreamHandlerIf
{
REGISTER_STREAM_HANDLER( StreamHandlerLibav )
public:
static std::vector<PlaYUVerSupportedFormat> supportedReadFormats();
@@ -65,14 +67,16 @@ public:
StreamHandlerLibav()
{
}
~StreamHandlerLibav()
{
}
Bool openHandler( std::string strFilename, Bool bInput );
// Bool initAvFormat( const char* filename, UInt& width, UInt& height, Int& pixel_format, UInt& bits_pel, Int& endianness, Double& frame_rate, UInt64& num_frames );
Void closeHandler();
UInt64 calculateFrameNumber();
Bool seek( UInt64 iFrameNum );
Bool read( Byte* pchBuffer );
Bool write( Byte* pchBuffer );
Bool read( PlaYUVerFrame* pcFrame );
Bool write( PlaYUVerFrame* pcFrame );
Void getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rBitsPerPel, Int& rEndianness, Double& rFrameRate );
lib/StreamHandlerOpenCV.cpp
+100
View File
@@ -0,0 +1,100 @@
/* This file is a part of plaYUVer project
* Copyright (C) 2014-2015 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 StreamHandlerOpenCV.cpp
* \ingroup PlaYUVerLib
* \brief Interface with opencv lib
*/
#include <cstdio>
#include "StreamHandlerOpenCV.h"
#include "PlaYUVerFrame.h"
#include "PlaYUVerFramePixelFormats.h"
#include "LibMemory.h"
namespace plaYUVer
{
std::vector<PlaYUVerSupportedFormat> StreamHandlerOpenCV::supportedReadFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerOpenCV::Create, "Portable Grayscale Map ", "pgm" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerOpenCV::Create, "Portable Network Graphics", "png" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerOpenCV::Create, "Joint Photographic Experts Group", "jpg" );
REGIST_PLAYUVER_SUPPORTED_FMT( &StreamHandlerOpenCV::Create, "Windows Bitmap", "bmp" );
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
std::vector<PlaYUVerSupportedFormat> StreamHandlerOpenCV::supportedWriteFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
std::vector<PlaYUVerSupportedFormat> StreamHandlerOpenCV::supportedSaveFormats()
{
INI_REGIST_PLAYUVER_SUPPORTED_FMT;
// APPEND_PLAYUVER_SUPPORTED_FMT( StreamHandlerOpenCV, Read );
END_REGIST_PLAYUVER_SUPPORTED_FMT;
}
Bool StreamHandlerOpenCV::openHandler( std::string strFilename, Bool bInput )
{
m_cFilename = m_cFilename;
return true;
}
Void StreamHandlerOpenCV::closeHandler()
{
}
Void StreamHandlerOpenCV::getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rBitsPerPel, Int& rEndianness, Double& rFrameRate )
{
// rWidth = m_uiWidth;
// rHeight = m_uiHeight;
// rInputFormat = m_iPixelFormat;
// rBitsPerPel = m_uiBitsPerPixel;
// rEndianness = m_iEndianness;
rFrameRate = 1;
}
UInt64 StreamHandlerOpenCV::calculateFrameNumber()
{
return 1;
}
Bool StreamHandlerOpenCV::seek( UInt64 iFrameNum )
{
return true;
}
Bool StreamHandlerOpenCV::read( PlaYUVerFrame* pcFrame )
{
return false;
}
Bool StreamHandlerOpenCV::write( PlaYUVerFrame* pcFrame )
{
cv::Mat* pcCvFrame = pcFrame->getCvMat();
return cv::imwrite( m_cFilename.c_str(), *pcCvFrame );
}
} // NAMESPACE
lib/LibOpenCVHandler.h → lib/StreamHandlerOpenCV.h
+22 -8
View File
@@ -18,13 +18,13 @@
*/
/**
* \file LibOpenCVHandler.h
* \file StreamHandlerOpenCV.h
* \ingroup PlaYUVerLib
* \brief Interface with opencv lib
*/
#ifndef __LIBOPENCVHANDLER_H__
#define __LIBOPENCVHANDLER_H__
#ifndef __STREAMHANDLEROPENCV_H__
#define __STREAMHANDLEROPENCV_H__
#include <inttypes.h>
#include <vector>
@@ -32,29 +32,43 @@
#include <opencv2/opencv.hpp>
#include "PlaYUVerDefs.h"
#include "PlaYUVerStream.h"
#include "PlaYUVerStreamHandlerIf.h"
namespace plaYUVer
{
class PlaYUVerFrame;
class LibOpenCVHandler
class StreamHandlerOpenCV: public PlaYUVerStreamHandlerIf
{
REGISTER_STREAM_HANDLER( StreamHandlerOpenCV )
public:
static std::vector<PlaYUVerSupportedFormat> supportedReadFormats();
static std::vector<PlaYUVerSupportedFormat> supportedWriteFormats();
static std::vector<PlaYUVerSupportedFormat> supportedSaveFormats();
LibOpenCVHandler()
StreamHandlerOpenCV()
{
}
~StreamHandlerOpenCV()
{
}
static PlaYUVerFrame* loadFrame( std::string filename );
static Bool saveFrame( PlaYUVerFrame* pcFrame, std::string filename );
Bool openHandler( std::string strFilename, Bool bInput );
Void closeHandler();
UInt64 calculateFrameNumber();
Bool seek( UInt64 iFrameNum );
Bool read( PlaYUVerFrame* pcFrame );
Bool write( PlaYUVerFrame* pcFrame );
Void getFormat( UInt& rWidth, UInt& rHeight, Int& rInputFormat, UInt& rBitsPerPel, Int& rEndianness, Double& rFrameRate );
private:
std::string m_cFilename;
};
} // NAMESPACE
#endif // __LIBOPENCVHANDLER_H__
#endif // __STREAMHANDLEROPENCV_H__
lib/StreamHandlerRaw.h
+11 -4
View File
@@ -38,9 +38,14 @@ namespace plaYUVer
*/
class PlaYUVerRawHandler: public PlaYUVerStreamHandlerIf
{
REGISTER_STREAM_HANDLER( PlaYUVerRawHandler )
private:
FILE* m_pFile; /**< The input file pointer >*/
public:
PlaYUVerRawHandler() {}
~PlaYUVerRawHandler() {}
Bool openHandler( std::string strFilename, Bool bInput )
{
@@ -78,16 +83,18 @@ public:
}
return false;
}
Bool read( Byte* pchBuffer )
Bool read( PlaYUVerFrame* pcFrame )
{
UInt64 processed_bytes = fread( pchBuffer, sizeof( Byte ), m_uiNBytesPerFrame, m_pFile );
UInt64 processed_bytes = fread( m_pStreamBuffer, sizeof( Byte ), m_uiNBytesPerFrame, m_pFile );
if( processed_bytes != m_uiNBytesPerFrame )
return false;
pcFrame->frameFromBuffer( m_pStreamBuffer );
return true;
}
Bool write( Byte* pchBuffer )
Bool write( PlaYUVerFrame* pcFrame )
{
UInt64 processed_bytes = fwrite( pchBuffer, sizeof( Byte ), m_uiNBytesPerFrame, m_pFile );
pcFrame->frameToBuffer( m_pStreamBuffer );
UInt64 processed_bytes = fwrite( m_pStreamBuffer, sizeof( Byte ), m_uiNBytesPerFrame, m_pFile );
if( processed_bytes != m_uiNBytesPerFrame )
return false;
return true;