avTranscoder · valnoel · Nov 12, 2014 · Nov 12, 2014 · Nov 12, 2014 · Nov 12, 2014
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -4,7 +4,7 @@ project(AvTranscoder)
 
 # Set AvTranscoder versions
 set(AVTRANSCODER_VERSION_MAJOR "0")
-set(AVTRANSCODER_VERSION_MINOR "3")
+set(AVTRANSCODER_VERSION_MINOR "4")
 set(AVTRANSCODER_VERSION_MICRO "0")
 set(AVTRANSCODER_VERSION ${AVTRANSCODER_VERSION_MAJOR}.${AVTRANSCODER_VERSION_MINOR}.${AVTRANSCODER_VERSION_MICRO})
 

diff --git a/README.md b/README.md
@@ -1,10 +1,48 @@
 # avTranscoder
 
-C++ API for LibAV / FFMpeg
+C++ API for Libav / FFmpeg
 
-Based on LibAV/FFMpeg libraries to support various video formats, avTranscoder provides the high level API to re-wrap or transcode media easily.
+Based on Libav/FFmpeg libraries to support various video and audio formats, avTranscoder provides the high level API to re-wrap or transcode media easily.
 
-You can also use its Java & Python bindings for simpler integration in your own projects.
+#### What you need to know
+* C++ library
+* Java and Python bindings generated with SWIG
+* multiplateform (Linux, MAC, Windows)
+* your call to be based on Libav, FFmpeg, or your custom fork of one of these librairies
+
+#### How to use
+Check out applications contained in the project to see examples of how to use the library in C++, Java or Python.
+
+To encode, avTranscoder manipulates profiles.
+A profile is a text file which discribes, with a set of key-value, what we want as output for the format, the video, or the audio.
+You can create your own profiles and export a variable called ```AVPROFILES``` to indicate the path to them.
+
+The minimum format profile is:
+```
+avProfileName=profileName
+avProfileLongName=profileLongName
+avProfileType=avProfileTypeFormat
+format=formatName 
+```
+
+The minimum video profile is:
+```
+avProfileName=profileName
+avProfileLongName=profileLongName
+avProfileType=avProfileTypeVideo
+codec=codecName
+pix_fmt=pixelFormat
+r=frameRate
+```
+
+The minimum audio profile is:
+```
+avProfileName=profileName
+avProfileLongName=profileLongName
+avProfileType=avProfileTypeAudio
+codec=codecName
+sample_fmt=sampleFormat
+```
 
 #### Continuous Integration
 
@@ -26,8 +64,16 @@ You can also use its Java & Python bindings for simpler integration in your own
 Python tests using nosetests.
 
 Create environment variables to use your files in tests.
-* AVTRANSCODER_TEST_AUDIO_FILE
-* AVTRANSCODER_TEST_VIDEO_FILE
+* ```AVTRANSCODER_TEST_AUDIO_FILE```
+* ```AVTRANSCODER_TEST_VIDEO_FILE```
+
+Note: for continuous integration, we launch tests with media files contained in ```avTranscoder-data``` repository.
+
+Launch the tests:
+```
+cd test/pyTest
+nosetests
+```
 
 #### Packaging
 

diff --git a/app/avMeta/avMeta.cpp b/app/avMeta/avMeta.cpp
@@ -1,5 +1,5 @@
 #include <AvTranscoder/file/InputFile.hpp>
-#include <AvTranscoder/mediaProperty/printMediaProperty.hpp>
+#include <AvTranscoder/mediaProperty/print.hpp>
 
 #include <AvTranscoder/progress/NoDisplayProgress.hpp>
 
@@ -16,7 +16,7 @@ int main( int argc, char** argv )
 	avtranscoder::NoDisplayProgress p;
 
 	avtranscoder::InputFile input( argv[1] );
-	input.analyse( p, avtranscoder::InputFile::eAnalyseLevelFull );
+	input.analyse( p, avtranscoder::eAnalyseLevelFirstGop );
 
 	// a simply metadata display
 	std::cout << input;

diff --git a/app/avTranscoder/avTranscoder.cpp b/app/avTranscoder/avTranscoder.cpp
@@ -28,7 +28,7 @@ void transcodeVideo( const char* inputfilename, const char* outputFilename )
 	InputFile input( inputfilename );
 	input.analyse( p );
 
-	input.readStream( input.getProperties().videoStreams.at( 0 ).streamId );
+	input.activateStream( input.getProperties().getVideoProperties().at( 0 ).getStreamId() );
 
 	// init video decoders
 	AvInputVideo inputVideo( input.getStream( 0 ) );

diff --git a/app/avplay/AvReader.hpp b/app/avplay/AvReader.hpp
@@ -5,7 +5,7 @@
 #include <AvTranscoder/essenceStream/AvInputAudio.hpp>
 #include <AvTranscoder/essenceStream/AvInputVideo.hpp>
 #include <AvTranscoder/transform/VideoTransform.hpp>
-#include <AvTranscoder/mediaProperty/printMediaProperty.hpp>
+#include <AvTranscoder/mediaProperty/print.hpp>
 
 #include <AvTranscoder/progress/ConsoleProgress.hpp>
 
@@ -23,9 +23,9 @@ class AvReader : public Reader
 		avtranscoder::ConsoleProgress p;
 
 		_inputFile.analyse( p );
-		_videoStream = _inputFile.getProperties().videoStreams.at(0).streamId;
+		_videoStream = _inputFile.getProperties().getVideoProperties().at(0).getStreamId();
 
-		_inputFile.readStream( _videoStream );
+		_inputFile.activateStream( _videoStream );
 
 		_inputVideo = new avtranscoder::AvInputVideo( _inputFile.getStream( _videoStream ) );
 
@@ -58,17 +58,17 @@ class AvReader : public Reader
 
 	size_t getWidth()
 	{
-		return _inputFile.getProperties().videoStreams.at(0).width;
+		return _inputFile.getProperties().getVideoProperties().at(0).getWidth();
 	};
 
 	size_t getHeight()
 	{
-		return _inputFile.getProperties().videoStreams.at(0).height;
+		return _inputFile.getProperties().getVideoProperties().at(0).getHeight();
 	}
 
 	size_t getComponents()
 	{
-		return _inputFile.getProperties().videoStreams.at(0).componentsCount;
+		return _inputFile.getProperties().getVideoProperties().at(0).getComponentsCount();
 	}
 
 	size_t getBitDepth()

diff --git a/app/genericProcessor/genericProcessor.cpp b/app/genericProcessor/genericProcessor.cpp
@@ -114,14 +114,11 @@ int main( int argc, char** argv )
 		// set verbose of all stream
 		transcoder.setVerbose( verbose );
 		transcoder.setProcessMethod( avtranscoder::eProcessMethodLongest );
-		transcoder.init();
 
 		if( verbose )
 			std::cout << "start Transcode" << std::endl;
 
 		avtranscoder::ConsoleProgress progress;
-
-		// video re-wrapping or transcoding if necessary
 		transcoder.process( progress );
 
 		std::cout << std::endl;

diff --git a/src/AvTranscoder/ProfileLoader.hpp b/src/AvTranscoder/ProfileLoader.hpp
@@ -13,8 +13,8 @@ namespace avtranscoder
 
 namespace constants
 {
-	const std::string avProfileIdentificator = "avProfile";
-	const std::string avProfileIdentificatorHuman = "avProfileLong";
+	const std::string avProfileIdentificator = "avProfileName";
+	const std::string avProfileIdentificatorHuman = "avProfileLongName";
 	const std::string avProfileType = "avProfileType";
 	const std::string avProfileTypeFormat = "avProfileTypeFormat";
 	const std::string avProfileTypeVideo = "avProfileTypeVideo";

diff --git a/src/AvTranscoder/avTranscoder.i b/src/AvTranscoder/avTranscoder.i
@@ -15,18 +15,11 @@
 %{
 #include <AvTranscoder/ProfileLoader.hpp>
 
-#include <AvTranscoder/frame/Pixel.hpp>
-#include <AvTranscoder/frame/Frame.hpp>
-#include <AvTranscoder/frame/VideoFrame.hpp>
-#include <AvTranscoder/frame/AudioFrame.hpp>
-
 #include <AvTranscoder/codec/ICodec.hpp>
 #include <AvTranscoder/codec/VideoCodec.hpp>
 #include <AvTranscoder/codec/AudioCodec.hpp>
 #include <AvTranscoder/codec/DataCodec.hpp>
 
-#include <AvTranscoder/mediaProperty/mediaProperty.hpp>
-
 #include <AvTranscoder/codedStream/IOutputStream.hpp>
 #include <AvTranscoder/codedStream/AvOutputStream.hpp>
 
@@ -43,43 +36,28 @@
 #include <AvTranscoder/essenceStream/GeneratorVideo.hpp>
 #include <AvTranscoder/essenceStream/GeneratorAudio.hpp>
 
-#include <AvTranscoder/file/InputFile.hpp>
-#include <AvTranscoder/file/OutputFile.hpp>
-
 #include <AvTranscoder/transcoder/StreamTranscoder.hpp>
 #include <AvTranscoder/transcoder/Transcoder.hpp>
 %}
 
-namespace std {	
+namespace std {
 %template(IntPair)         pair< size_t, size_t >;
-%template(VideoVector)     vector< avtranscoder::VideoProperties >;
-%template(AudioVector)     vector< avtranscoder::AudioProperties >;
-%template(MetadataPair)    pair< string, string >;
-%template(MetadatasVector) vector< pair< string, string > >;
-%template(GopPair)         pair< char, bool >;
-%template(GopVector)       vector< pair< char, bool > >;
-%template(ChannelVector)   vector< avtranscoder::Channel >;
 %template(ProfileMap)      map< string, string >;
 %template(ProfilesVector)  vector< map< string, string > >;
 %template(DataBuffer)      std::vector< unsigned char >;
 }
 
 %include "AvTranscoder/progress/progress.i"
+%include "AvTranscoder/mediaProperty/mediaProperty.i"
+%include "AvTranscoder/frame/frame.i"
 
 %include <AvTranscoder/ProfileLoader.hpp>
 
-%include <AvTranscoder/frame/Pixel.hpp>
-%include <AvTranscoder/frame/Frame.hpp>
-%include <AvTranscoder/frame/VideoFrame.hpp>
-%include <AvTranscoder/frame/AudioFrame.hpp>
-
 %include <AvTranscoder/codec/ICodec.hpp>
 %include <AvTranscoder/codec/VideoCodec.hpp>
 %include <AvTranscoder/codec/AudioCodec.hpp>
 %include <AvTranscoder/codec/DataCodec.hpp>
 
-%include <AvTranscoder/mediaProperty/mediaProperty.hpp>
-
 %include <AvTranscoder/codedStream/IOutputStream.hpp>
 %include <AvTranscoder/codedStream/AvOutputStream.hpp>
 
@@ -96,8 +74,7 @@ namespace std {
 %include <AvTranscoder/essenceStream/GeneratorVideo.hpp>
 %include <AvTranscoder/essenceStream/GeneratorAudio.hpp>
 
-%include <AvTranscoder/file/InputFile.hpp>
-%include <AvTranscoder/file/OutputFile.hpp>
+%include "AvTranscoder/file/file.i"
 
 %include <AvTranscoder/transcoder/StreamTranscoder.hpp>
 %include <AvTranscoder/transcoder/Transcoder.hpp>
diff --git a/src/AvTranscoder/codedStream/AvInputStream.cpp b/src/AvTranscoder/codedStream/AvInputStream.cpp
@@ -17,8 +17,9 @@ AvInputStream::AvInputStream( InputFile& inputFile, const size_t streamIndex )
 	: IInputStream( )
 	, _inputFile( &inputFile )
 	, _codec( NULL )
+	, _streamCache()
 	, _streamIndex( streamIndex )
-	, _bufferized( false )
+	, _isActivated( false )
 {
 	AVCodecContext* context = _inputFile->getFormatContext().streams[_streamIndex]->codec;
 
@@ -35,13 +36,6 @@ AvInputStream::AvInputStream( InputFile& inputFile, const size_t streamIndex )
 		}
 		case 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;
-
 			AudioCodec* audioCodec = new AudioCodec( eCodecTypeDecoder, context->codec_id );
 			audioCodec->setAudioParameters( context->sample_rate, context->channels, context->sample_fmt );
 
@@ -64,8 +58,9 @@ AvInputStream::AvInputStream( const AvInputStream& inputStream )
 	: IInputStream( )
 	, _inputFile( inputStream._inputFile )
 	, _codec( inputStream._codec )
+	, _streamCache()
 	, _streamIndex( inputStream._streamIndex )
-	, _bufferized( inputStream._bufferized )
+	, _isActivated( inputStream._isActivated )
 {
 }
 
@@ -76,46 +71,33 @@ AvInputStream::~AvInputStream( )
 
 bool AvInputStream::readNextPacket( CodedData& data )
 {
-	if( ! _bufferized )
-		throw std::runtime_error( "Can't read packet on non-bufferized input stream." );
-
-	if( _streamCache.empty() )
-		_inputFile->readNextPacket( _streamIndex );
-
-	if( _streamCache.empty() )
-		return false;
+	if( ! _isActivated )
+		throw std::runtime_error( "Can't read packet on non-activated input stream." );
 
-	_streamCache.front().getBuffer().swap( data.getBuffer() );
-
-	_streamCache.erase( _streamCache.begin() );
+	// if packet is already cached
+	if( ! _streamCache.empty() )
+	{
+		_streamCache.front().getBuffer().swap( data.getBuffer() );
+		_streamCache.pop();
+	}
+	// else read next packet
+	else
+	{
+		return _inputFile->readNextPacket( data, _streamIndex ) && _streamCache.empty();
+	}
 
 	return true;
 }
 
 void AvInputStream::addPacket( AVPacket& packet )
 {
-	//std::cout << "add packet for stream " << _streamIndex << std::endl;
-	CodedData data;
-	_streamCache.push_back( data );
-
-	if( ! _bufferized )
+	// Do not cache data if the stream is declared as unused in process
+	if( ! _isActivated )
 		return;
 
-	// is it possible to remove this copy ?
-	// using : av_packet_unref ?
-	_streamCache.back().getBuffer().resize( packet.size );
-	if( packet.size != 0 )
-		memcpy( _streamCache.back().getPtr(), packet.data, packet.size );
-
-	// std::vector<unsigned char> tmpData( 0,0 );
-	// &tmpData[0] = packet.data;
-	// tmpData.size( packet.size );
-
-	// remove reference on packet because it's passed to CodedData
-	// packet.data = NULL;
-	// packet.size = 0;
-
-	// std::cout << this << " buffer size " << _streamCache.size() << std::endl;
+	CodedData data;
+	_streamCache.push( data );
+	_streamCache.back().copyData( packet.data, packet.size );
 }
 
 VideoCodec& AvInputStream::getVideoCodec()
@@ -166,7 +148,7 @@ double AvInputStream::getDuration() const
 
 void AvInputStream::clearBuffering()
 {
-	_streamCache.clear();
+	_streamCache = std::queue<CodedData>();
 }
 
 AVStream* AvInputStream::getAVStream() const

diff --git a/src/AvTranscoder/codedStream/AvInputStream.hpp b/src/AvTranscoder/codedStream/AvInputStream.hpp
@@ -3,6 +3,8 @@
 
 #include "IInputStream.hpp"
 
+#include <queue>
+
 struct AVStream;
 
 namespace avtranscoder
@@ -33,8 +35,8 @@ class AvExport AvInputStream : public IInputStream
 
 	void addPacket( AVPacket& packet );
 
-	void setBufferred( const bool bufferized ){ _bufferized = bufferized; };
-	bool getBufferred() const { return _bufferized; };
+	void activate( const bool activate = true ){ _isActivated = activate; };
+	bool isActivated() const { return _isActivated; };
 
 	void clearBuffering();
 
@@ -45,10 +47,10 @@ class AvExport AvInputStream : public IInputStream
 	InputFile* _inputFile;  ///< Has link (no ownership)
 	ICodec* _codec;  ///< Has ownership
 
-	std::vector<CodedData> _streamCache;
+	std::queue<CodedData> _streamCache;  ///< Cache of packet data already read and corresponding to this stream
 
 	size_t _streamIndex;  ///<  Index of the stream in the input file
-	bool _bufferized;  ///< If the stream is bufferized
+	bool _isActivated;  ///< If the stream is activated, data read from it will be buffered
 };
 
 }