avTranscoder · MarcAntoine-Arnaud · Jul 18, 2014 · Jul 17, 2014 · Jul 17, 2014 · Jul 17, 2014
diff --git a/SConstruct b/SConstruct
@@ -128,6 +128,11 @@ resampleLibraryName = 'avresample'
 if not conf.CheckLibWithHeader('avutil', 'libavutil/avutil.h', 'c'):
     sys.exit( 0 )
 
+if not conf.CheckLibWithHeader('avresample', 'libavresample/avresample.h', 'c'):
+    if conf.CheckLibWithHeader('swresample', 'libswresample/swresample.h', 'c'):
+        resampleLibraryFlag = '-DFF_RESAMPLE_LIBRARY'
+        resampleLibraryName = 'swresample'
+
 if not conf.CheckLibWithHeader('avcodec', 'libavcodec/avcodec.h', 'c'):
     sys.exit( 0 )
 
@@ -137,10 +142,6 @@ if not conf.CheckLibWithHeader('avformat', 'libavformat/avformat.h', 'c'):
 if not conf.CheckLibWithHeader('swscale', 'libswscale/swscale.h', 'c'):
     sys.exit( 0 )
 
-if not conf.CheckLibWithHeader('avresample', 'libavresample/avresample.h', 'c'):
-    if conf.CheckLibWithHeader('swresample', 'libswresample/swresample.h', 'c'):
-        resampleLibraryFlag = '-DFF_RESAMPLE_LIBRARY'
-        resampleLibraryName = 'swresample'
 
 env.Append(
     CXXFLAGS = resampleLibraryFlag

diff --git a/app/genericProcessor/genericProcessor.cpp b/app/genericProcessor/genericProcessor.cpp
@@ -8,7 +8,8 @@
 #include <sstream>
 #include <cstdlib>
 
-bool verbose = false;
+// bool verbose = false;
+bool verbose = true;
 
 void parseConfigFile( const std::string& configFilename, avtranscoder::Transcoder& transcoder, avtranscoder::Profile& profile )
 {
@@ -26,9 +27,29 @@ void parseConfigFile( const std::string& configFilename, avtranscoder::Transcode
 			{
 				std::string transcodeProfile;
 				std::getline( is_line, transcodeProfile );
+
+				std::stringstream ss( streamId );
+				size_t streamIndex = 0;
+				char separator;
+				int subStreamIndex = -1;
+				ss >> streamIndex;
+				ss >> separator;
+				if( separator == '.' )
+					ss >> subStreamIndex;
+
 				if( verbose )
-					std::cout << filename << " ( " << streamId <<  " ) : " << transcodeProfile << std::endl;
-				transcoder.add( filename, atoi( streamId.c_str() ), transcodeProfile );
+				{
+					std::cout << ( filename.length() ? filename : "dummy stream" );
+					std::cout << " ( " << streamIndex;
+					if( subStreamIndex > -1 )
+						std::cout << " | " << subStreamIndex << " ";
+					std::cout << " ) : ";
+					std::cout << ( transcodeProfile.length() ? transcodeProfile : "rewrap" );
+					std::cout << std::endl;
+				}
+
+				transcoder.add( filename, streamIndex, subStreamIndex, transcodeProfile );
+
 			}
 		}
 	}

diff --git a/src/AvTranscoder/CodedStream/AvInputStream.cpp b/src/AvTranscoder/CodedStream/AvInputStream.cpp
@@ -36,8 +36,16 @@ AvInputStream::AvInputStream( InputFile& inputFile, const size_t streamIndex )
 		, _streamIndex( streamIndex )
 		, _bufferized( false )
 {
-	if( _inputFile->getFormatContext().streams[_streamIndex]->codec->codec_type == AVMEDIA_TYPE_AUDIO )
-		_inputFile->getFormatContext().streams[_streamIndex]->codec->block_align = 5760;
+	AVCodecContext* context = _inputFile->getFormatContext().streams[_streamIndex]->codec;
+	if( context->codec_type == AVMEDIA_TYPE_AUDIO )
+	{
+		double outputFps = 25;
+		size_t bytePerSample = av_get_bytes_per_sample( context->sample_fmt );
+
+		context->block_align = 1.0 * context->sample_rate * context->channels * bytePerSample / outputFps;
+		// std::cout << "channels " << context->channel_layout << std::endl;
+		// std::cout << "audio buffer read size " << context->block_align << std::endl;
+	}
 }
 
 AvInputStream::~AvInputStream( )

diff --git a/src/AvTranscoder/DatasStructures/AudioDesc.cpp b/src/AvTranscoder/DatasStructures/AudioDesc.cpp
@@ -188,7 +188,7 @@ void AudioDesc::set( const std::string& key, const std::string& value )
 std::string AudioDesc::getAudioCodec() const
 {
 	assert( m_codecContext != NULL );
-	return m_codecContext->codec_name;
+	return avcodec_descriptor_get( m_codecContext->codec_id )->name;
 }
 
 AVCodecID AudioDesc::getAudioCodecId() const
@@ -197,7 +197,6 @@ AVCodecID AudioDesc::getAudioCodecId() const
 	return m_codecContext->codec_id;
 }
 
-
 const size_t AudioDesc::getSampleRate() const
 {
 	assert( m_codecContext != NULL );
@@ -224,6 +223,7 @@ AudioFrameDesc AudioDesc::getFrameDesc() const
 	audioFrameDesc.setChannels( m_codecContext->channels );
 	audioFrameDesc.setSampleRate( m_codecContext->sample_rate );
 	audioFrameDesc.setSampleFormat( m_codecContext->sample_fmt );
+	// audioFrameDesc.setFps( 25 );
 
 	return audioFrameDesc;
 }

diff --git a/src/AvTranscoder/DatasStructures/Frame.hpp b/src/AvTranscoder/DatasStructures/Frame.hpp
@@ -9,7 +9,7 @@
 namespace avtranscoder
 {
 
-typedef std::vector< unsigned char> DataBuffer;
+typedef std::vector< unsigned char > DataBuffer;
 
 class AvExport Frame
 {

diff --git a/src/AvTranscoder/DatasStructures/Pixel.cpp b/src/AvTranscoder/DatasStructures/Pixel.cpp
@@ -14,7 +14,12 @@ extern "C" {
 namespace avtranscoder
 {
 
-Pixel::Pixel( const AVPixelFormat avpixelFormat )
+Pixel::Pixel( const std::string& avPixelFormat )
+{
+	init( av_get_pix_fmt( avPixelFormat.c_str() ) );
+}
+
+Pixel::Pixel( const AVPixelFormat avPixelFormat )
 	: m_pixelSize  ( 24 )
 	, m_components ( 3 )
 	, m_componentType ( eComponentYuv )
@@ -23,33 +28,7 @@ Pixel::Pixel( const AVPixelFormat avpixelFormat )
 	, m_withAlpha  ( false )
 	, m_planar     ( true )
 {
-	const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get( avpixelFormat );
-	setBitsPerPixel   ( av_get_bits_per_pixel( pix_desc ) );
-	setBigEndian      ( pix_desc->flags & PIX_FMT_BE );
-	setComponents     ( pix_desc->nb_components );
-	setAlpha          ( pix_desc->flags & PIX_FMT_ALPHA );
-	setPlanar         ( ( pix_desc->flags & PIX_FMT_PLANAR ) != 0 );
-
-	if( pix_desc->nb_components == 1 )
-		setColorComponents( eComponentGray );
-
-	if( pix_desc->flags & PIX_FMT_RGB )
-		setColorComponents( eComponentRgb );
-	else
-		setColorComponents( eComponentYuv );
-
-	setSubsampling( eSubsamplingNone );
-
-	if( ( pix_desc->log2_chroma_w == true ) &&
-		( pix_desc->log2_chroma_h == false ) )
-	{
-		setSubsampling( eSubsampling422 );
-	}
-	if( ( pix_desc->log2_chroma_w == true ) &&
-		( pix_desc->log2_chroma_h == true ) )
-	{
-		setSubsampling( eSubsampling420 );
-	}
+	init( avPixelFormat );
 }
 
 AVPixelFormat Pixel::findPixel() const
@@ -85,6 +64,37 @@ AVPixelFormat Pixel::findPixel() const
 	return AV_PIX_FMT_NONE;
 }
 
+void Pixel::init( const AVPixelFormat avPixelFormat )
+{
+	const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get( avPixelFormat );
+	setBitsPerPixel   ( av_get_bits_per_pixel( pix_desc ) );
+	setBigEndian      ( pix_desc->flags & PIX_FMT_BE );
+	setComponents     ( pix_desc->nb_components );
+	setAlpha          ( pix_desc->flags & PIX_FMT_ALPHA );
+	setPlanar         ( ( pix_desc->flags & PIX_FMT_PLANAR ) != 0 );
+
+	if( pix_desc->nb_components == 1 )
+		setColorComponents( eComponentGray );
+
+	if( pix_desc->flags & PIX_FMT_RGB )
+		setColorComponents( eComponentRgb );
+	else
+		setColorComponents( eComponentYuv );
+
+	setSubsampling( eSubsamplingNone );
+
+	if( ( pix_desc->log2_chroma_w == true ) &&
+		( pix_desc->log2_chroma_h == false ) )
+	{
+		setSubsampling( eSubsampling422 );
+	}
+	if( ( pix_desc->log2_chroma_w == true ) &&
+		( pix_desc->log2_chroma_h == true ) )
+	{
+		setSubsampling( eSubsampling420 );
+	}
+}
+
 bool Pixel::asCorrectColorComponents( const AVPixFmtDescriptor* pix_desc, const EComponentType componentType ) const 
 {
 	if( componentType == eComponentRgb && pix_desc->flags & PIX_FMT_RGB )

diff --git a/src/AvTranscoder/DatasStructures/Pixel.hpp b/src/AvTranscoder/DatasStructures/Pixel.hpp
@@ -44,7 +44,9 @@ class Pixel
 	, m_planar     ( true )
 	{ }
 
-	Pixel( const AVPixelFormat avpixelFormat );
+	Pixel( const std::string& avPixelFormat );
+
+	Pixel( const AVPixelFormat avPixelFormat );
 
 	void setBitsPerPixel   ( const size_t pixelSize ) { m_pixelSize = pixelSize; }
 	void setBigEndian      ( const bool endianess ) { m_endianess = endianess; }
@@ -65,6 +67,8 @@ class Pixel
 	AVPixelFormat    findPixel() const;
 
 private:
+	void init( const AVPixelFormat avPixelFormat );
+
 	bool asCorrectColorComponents( const AVPixFmtDescriptor* pix_desc, const EComponentType componentType ) const;
 	bool asCorrectSubsampling( const AVPixFmtDescriptor* pix_desc, const ESubsamplingType subsamplingType ) const;
 

diff --git a/src/AvTranscoder/DatasStructures/VideoDesc.cpp b/src/AvTranscoder/DatasStructures/VideoDesc.cpp
@@ -78,7 +78,7 @@ void VideoDesc::setTimeBase( const size_t num, const size_t den, const size_t ti
 std::string VideoDesc::getVideoCodec() const
 {
 	assert( m_codecContext != NULL );
-	return m_codecContext->codec_name;
+	return avcodec_descriptor_get( m_codecContext->codec_id )->name;
 }
 
 AVCodecID VideoDesc::getVideoCodecId() const

diff --git a/src/AvTranscoder/EssenceStream/DummyAudio.cpp b/src/AvTranscoder/EssenceStream/DummyAudio.cpp
@@ -15,9 +15,10 @@ DummyAudio::~DummyAudio( )
 {
 }
 
-void DummyAudio::setAudioDesc( AudioDesc& audioDesc )
+void DummyAudio::setAudioDesc( const AudioDesc& audioDesc )
 {
 	_audioDesc = audioDesc;
+
 	_frameDesc.setSampleRate  ( _audioDesc.getCodecContext()->sample_rate );
 	_frameDesc.setChannels    ( _audioDesc.getCodecContext()->channels );
 	_frameDesc.setFps         ( 25.0 );
@@ -47,28 +48,9 @@ bool DummyAudio::readNextFrame( Frame& frameBuffer )
 	return true;
 }
 
-bool DummyAudio::readNextFrame( std::vector<Frame>& frameBuffer )
+bool DummyAudio::readNextFrame( Frame& frameBuffer, const size_t subStreamIndex )
 {
-	if( frameBuffer.size() != _frameDesc.getChannels() )
-	{
-		frameBuffer.resize( _frameDesc.getChannels() );
-	}
-
-	size_t dataSizeOneChannel = _frameDesc.getDataSize() / _frameDesc.getChannels();
-	int fill_char = (
-		_frameDesc.getSampleFormat() == AV_SAMPLE_FMT_U8 ||
-		_frameDesc.getSampleFormat() == AV_SAMPLE_FMT_U8P
-		) ? 0x80 : 0x00;
-
-	for( size_t channel = 0; channel < _frameDesc.getChannels(); ++channel )
-	{
-		AudioFrame& audioFrameBuffer = static_cast<AudioFrame&>( frameBuffer.at( channel ) );
-		audioFrameBuffer.setNbSamples( 1.0 * _frameDesc.getSampleRate() / _frameDesc.getFps() );
-		frameBuffer.at( channel).getBuffer().resize( dataSizeOneChannel );
-		memset( frameBuffer.at( channel).getPtr(), fill_char, frameBuffer.at( channel).getSize() );
-	}
-
-	return true;
+	return false;
 }
 
 }
diff --git a/src/AvTranscoder/EssenceStream/DummyAudio.hpp b/src/AvTranscoder/EssenceStream/DummyAudio.hpp
@@ -17,17 +17,17 @@ class AvExport DummyAudio : public InputEssence
 	~DummyAudio( );
 
 	// Stream properties
-	void setAudioDesc( AudioDesc& audioDesc );
+	void setAudioDesc( const AudioDesc& audioDesc );
 
 	AudioDesc getAudioDesc() const;
 
 	void setup() {}
 
 	bool readNextFrame( Frame& frameBuffer );
-	bool readNextFrame( std::vector<Frame>& frameBuffer );
+	bool readNextFrame( Frame& frameBuffer, const size_t subStreamIndex );
 
 private:
-	AudioDesc _audioDesc;
+	AudioDesc      _audioDesc;
 	AudioFrameDesc _frameDesc;
 };
 

diff --git a/src/AvTranscoder/EssenceStream/DummyVideo.cpp b/src/AvTranscoder/EssenceStream/DummyVideo.cpp
@@ -8,7 +8,7 @@ namespace avtranscoder
 
 DummyVideo::DummyVideo( )
 	: InputEssence( )
-	, numberOfView( 1 )
+	, _numberOfView( 1 )
 {
 }
 
@@ -37,19 +37,9 @@ bool DummyVideo::readNextFrame( Frame& frameBuffer )
 	return true;
 }
 
-bool DummyVideo::readNextFrame( std::vector<Frame>& frameBuffer )
+bool DummyVideo::readNextFrame( Frame& frameBuffer, const size_t subStreamIndex )
 {
-	if( frameBuffer.size() != numberOfView )
-	{
-		frameBuffer.resize( numberOfView );
-	}
-
-	for( size_t view = 0; view < numberOfView; ++view )
-	{
-		readNextFrame( frameBuffer.at( view ) );
-	}
-
-	return true;
+	return false;
 }
 
 }
diff --git a/src/AvTranscoder/EssenceStream/DummyVideo.hpp b/src/AvTranscoder/EssenceStream/DummyVideo.hpp
@@ -24,13 +24,13 @@ class AvExport DummyVideo : public InputEssence
 	void setup() {}
 
 	bool readNextFrame( Frame& frameBuffer );
-	bool readNextFrame( std::vector<Frame>& frameBuffer );
+	bool readNextFrame( Frame& frameBuffer, const size_t subStreamIndex );
 
 private:
 	VideoDesc _videoDesc;
 	ImageDesc _imageDesc;
 
-	size_t numberOfView;
+	size_t    _numberOfView;
 };
 
 }

diff --git a/src/AvTranscoder/EssenceStream/InputAudio.cpp b/src/AvTranscoder/EssenceStream/InputAudio.cpp
@@ -133,26 +133,44 @@ bool InputAudio::readNextFrame( Frame& frameBuffer )
 	return true;
 }
 
-bool InputAudio::readNextFrame( std::vector<Frame>& frameBuffer )
+bool InputAudio::readNextFrame( Frame& frameBuffer, const size_t subStreamIndex )
 {
 	if( ! getNextFrame() )
 		return false;
 
-	size_t nbChannels = av_get_channel_layout_nb_channels( _frame->channel_layout );
+	size_t decodedSize = av_samples_get_buffer_size(NULL, 1,
+													_frame->nb_samples,
+													_codecContext->sample_fmt, 1);
+
+	size_t nbChannels = _codecContext->channels;
 	size_t bytePerSample = av_get_bytes_per_sample( (AVSampleFormat)_frame->format );
 
-	frameBuffer.resize( nbChannels );
+	AudioFrame& audioBuffer = static_cast<AudioFrame&>( frameBuffer );
+
+	// std::cout << "needed size " << audioBuffer.desc().getDataSize() << std::endl;
 
-	for( size_t channel = 0; channel < nbChannels; ++ channel )
+	// std::cout << _frame->nb_samples * bytePerSample << std::endl;
+	//audioBuffer.getBuffer().resize( _frame->nb_samples * bytePerSample );
+	audioBuffer.setNbSamples( _frame->nb_samples );
+
+	if( decodedSize )
 	{
-		AudioFrame& audioBuffer = static_cast<AudioFrame&>( frameBuffer.at( channel ) );
-		audioBuffer.setNbSamples( _frame->nb_samples );
+		if( audioBuffer.getSize() != decodedSize )
+			audioBuffer.getBuffer().resize( decodedSize, 0 );
 
 		unsigned char* src = *_frame->data;
 		unsigned char* dst = audioBuffer.getPtr();
 
+		src += ( nbChannels - 1 ) - ( subStreamIndex * bytePerSample );
+
+		// std::cout << "frame samples count " << _frame->nb_samples << std::endl;
+		// std::cout << "frame data size " << audioBuffer.getSize() << std::endl;
+
 		for( int sample = 0; sample < _frame->nb_samples; ++sample )
 		{
+			// std::cout << "sample " << sample << " ==| ";
+			// std::cout << "src " << static_cast<void *>(src) << " -> ";
+			// std::cout << "dst " << static_cast<void *>(dst) << std::endl;
 			memcpy( dst, src, bytePerSample );
 			dst += bytePerSample;
 			src += bytePerSample * nbChannels;