Merge pull request #484 from cchampet/dev_AudioVideoAvTranscoder0.5.10

AudioVideo: up to v4.4

Author: cchampet

plugins/image/io/AudioVideo/avTranscoder

@@ -190,6 +190,13 @@ avtranscoder::ProfileLoader::Profile LibAVParams::getCorrespondingProfile( const
 			if( libavOption.getDefaultInt() == paramInt->getValue() && libavOption.getName() != kOptionThreads )
 				continue;
 
+			// FFmpeg threads option has a default value of 1.
+			// Our threads parameter has a default value of 0.
+			// If 0, do not use it to set the decoding/encoding profile:
+			// avTranscoder will automatically set the number of threads according to the codec.
+			if( libavOption.getName() == kOptionThreads && paramInt->getValue() == kOptionThreadsValue )
+				continue;
+
 			libavOptionValue = boost::to_string( paramInt->getValue() );
 			optionsNameAndValue.insert( std::make_pair( libavOptionName, libavOptionValue ) );
 			continue;
@@ -462,7 +469,7 @@ void addOptionsToGroup( OFX::ImageEffectDescriptor& desc, OFX::GroupParamDescrip
 					name == kPrefixAudio + kOptionThreads )
 				{
 					OFX::IntParamDescriptor* intParam = desc.defineIntParam( name );
-					intParam->setDefault( 0 ); // autodetect a suitable number of threads to use 
+					intParam->setDefault( kOptionThreadsValue );
 					intParam->setRange( 0, std::numeric_limits<int>::max() );
 					intParam->setDisplayRange( 0, 64 );
 					param = intParam;

plugins/image/io/AudioVideo/src/common/util.cpp

@@ -29,6 +29,7 @@ static const std::string kPrefixGroup     = "g_";
 static const std::string kPrefixFlag      = "_flag_";
 
 static const std::string kOptionThreads = "threads";
+static const size_t kOptionThreadsValue = 0;  ///< Autodetect a suitable number of threads to use
 
 /**
  * @brief Use this class to get libav Options about format, video, and audio.

plugins/image/io/AudioVideo/src/common/util.hpp

@@ -1,5 +1,5 @@
 #define OFXPLUGIN_VERSION_MAJOR 4
-#define OFXPLUGIN_VERSION_MINOR 3
+#define OFXPLUGIN_VERSION_MINOR 4
 
 #include <tuttle/plugin/Plugin.hpp>
 #include "reader/AVReaderPluginFactory.hpp"

plugins/image/io/AudioVideo/src/mainEntry.cpp

@@ -28,13 +28,15 @@ AVReaderPlugin::AVReaderPlugin( OfxImageEffectHandle handle )
 	, _paramFormatDetailCustom( common::kPrefixFormat, AV_OPT_FLAG_DECODING_PARAM, true )
 	, _paramVideoDetailCustom( common::kPrefixVideo, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM, true )
 	, _inputFile( NULL )
-	, _inputStreamVideo( NULL )
+	, _inputStream( NULL )
+	, _inputDecoder( NULL )
 	, _sourceImage( NULL )
 	, _imageToDecode( NULL )
 	, _lastInputFilePath( "" )
 	, _lastVideoStreamIndex( 0 )
 	, _lastFrame( -1 )
 	, _initVideo( false )
+	, _isSetUp( false )
 {
 	_clipDst = fetchClip( kOfxImageEffectOutputClipName );
 
@@ -79,12 +81,14 @@ void AVReaderPlugin::ensureVideoIsOpen()
 {
 	const std::string& filepath = _paramFilepath->getValue();
 	const size_t videoStreamIndex = _paramVideoStreamIndex->getValue();
-	 
-	if( _lastInputFilePath == filepath && // already opened
-		! _lastInputFilePath.empty() && // not the first time...
-		_lastVideoStreamIndex == videoStreamIndex )
+
+	// if the given file is already opened
+	if( _lastInputFilePath == filepath &&
+	    ! _lastInputFilePath.empty() &&
+	    _lastVideoStreamIndex == videoStreamIndex )
 		return;
-	
+
+	// if the given file does not exist
 	if( filepath == "" || ! boost::filesystem::exists( filepath ) )
 	{
 		cleanInputFile();
@@ -97,21 +101,24 @@ void AVReaderPlugin::ensureVideoIsOpen()
 		// set and analyse inputFile
 		_inputFile.reset( new avtranscoder::InputFile( filepath ) );
 		_lastInputFilePath = filepath;
+
+		// launch deep analyse to get info of first gop
 		avtranscoder::NoDisplayProgress progress;
 		_inputFile->analyse( progress, avtranscoder::eAnalyseLevelFirstGop );
 
-		// get streamId of the video stream
+		// get index of the video stream
 		if( videoStreamIndex >= _inputFile->getProperties().getVideoProperties().size() )
 		{
 			throw std::runtime_error( "the stream index doesn't exist in the input file" );
 		}
 		_lastVideoStreamIndex = videoStreamIndex;
 
-		// buffered video stream at _indexVideoStream
-		_inputFile->activateStream( _paramVideoStreamIndex->getValue() );
+		// buffered the selected video stream
+		_inputStream = &_inputFile->getStream( _inputFile->getProperties().getVideoProperties().at(videoStreamIndex).getStreamIndex() );
+		_inputStream->activate();
 
-		// set video stream
-		_inputStreamVideo.reset( new avtranscoder::VideoDecoder( _inputFile->getStream( _paramVideoStreamIndex->getValue() ) ) );
+		// set video decoder
+		_inputDecoder.reset( new avtranscoder::VideoDecoder( *_inputStream ) );
 	}
 	catch( std::exception& e )
 	{
@@ -126,7 +133,7 @@ void AVReaderPlugin::ensureVideoIsOpen()
 void AVReaderPlugin::cleanInputFile()
 {
 	_inputFile.reset();
-	_inputStreamVideo.reset();
+	_inputDecoder.reset();
 	_sourceImage.reset();
 	_imageToDecode.reset();
 	_lastInputFilePath = "";
@@ -291,7 +298,7 @@ void AVReaderPlugin::changedParam( const OFX::InstanceChangedArgs& args, const s
 
 			// update unknown of Metadata tab
 			std::string unknownValue( "" );
-			BOOST_FOREACH( const avtranscoder::UnknownProperties& unknownStream, params._inputProperties->getUnknownPropertiesProperties() )
+			BOOST_FOREACH( const avtranscoder::UnknownProperties& unknownStream, params._inputProperties->getUnknownProperties() )
 			{
 				unknownValue += "::::: UNKNOWN STREAM ::::: \n";
 				BOOST_FOREACH( const PropertyPair& pair, unknownStream.getPropertiesAsVector() )
@@ -477,6 +484,11 @@ void AVReaderPlugin::beginSequenceRender( const OFX::BeginSequenceRenderArgument
 {
 	ReaderPlugin::beginSequenceRender( args );
 
+	// To be sure to execute the following code only once
+	// Optimization in some hosts when rendering several frames (nuke...)
+	if( _isSetUp )
+		return;
+
 	ensureVideoIsOpen();
 
 	AVReaderParams params = getProcessParams();
@@ -486,34 +498,38 @@ void AVReaderPlugin::beginSequenceRender( const OFX::BeginSequenceRenderArgument
 	formatProfile[ avtranscoder::constants::avProfileIdentificator ] = "customFormatPreset";
 	formatProfile[ avtranscoder::constants::avProfileIdentificatorHuman ] = "Custom format preset";
 	formatProfile[ avtranscoder::constants::avProfileType ] = avtranscoder::constants::avProfileTypeFormat;
+	formatProfile[ avtranscoder::constants::avProfileFormat ] = params._inputFormatName;
 	// format options
 	const avtranscoder::ProfileLoader::Profile formatCommonProfile = _paramFormatCustom.getCorrespondingProfile();
 	formatProfile.insert( formatCommonProfile.begin(), formatCommonProfile.end() );
 	// format detail options
 	const avtranscoder::ProfileLoader::Profile formatDetailProfile = _paramFormatDetailCustom.getCorrespondingProfile( params._inputFormatName );
 	formatProfile.insert( formatDetailProfile.begin(), formatDetailProfile.end() );
-	_inputFile->setProfile( formatProfile );
+	_inputFile->setupUnwrapping( formatProfile );
 
 	// set video decoder
 	avtranscoder::ProfileLoader::Profile videoProfile;
 	videoProfile[ avtranscoder::constants::avProfileIdentificator ] = "customVideoPreset";
 	videoProfile[ avtranscoder::constants::avProfileIdentificatorHuman ] = "Custom video preset";
 	videoProfile[ avtranscoder::constants::avProfileType ] = avtranscoder::constants::avProfileTypeVideo;
+	videoProfile[ avtranscoder::constants::avProfileCodec ] = params._inputVideoProperties->getCodecName();
 	// video options
 	const avtranscoder::ProfileLoader::Profile videoCommonProfile = _paramVideoCustom.getCorrespondingProfile();
 	videoProfile.insert( videoCommonProfile.begin(), videoCommonProfile.end() );
 	// video detail options
 	const avtranscoder::ProfileLoader::Profile videoDetailProfile = _paramVideoDetailCustom.getCorrespondingProfile( params._inputVideoProperties->getCodecName() );
 	videoProfile.insert( videoDetailProfile.begin(), videoDetailProfile.end() );
-	_inputStreamVideo->setupDecoder( videoProfile );
+	_inputDecoder->setupDecoder( videoProfile );
 
 	// get source image
-	const avtranscoder::VideoFrameDesc sourceImageDesc( _inputFile->getStream( _paramVideoStreamIndex->getValue() ).getVideoCodec().getVideoFrameDesc() );
+	const avtranscoder::VideoFrameDesc sourceImageDesc( _inputStream->getVideoCodec().getVideoFrameDesc() );
 	_sourceImage.reset( new avtranscoder::VideoFrame( sourceImageDesc ) );
 
 	// get image to decode
 	const avtranscoder::VideoFrameDesc imageToDecodeDesc( sourceImageDesc.getWidth(), sourceImageDesc.getHeight(), "rgb24" );
 	_imageToDecode.reset( new avtranscoder::VideoFrame( imageToDecodeDesc ) );
+
+	_isSetUp = true;
 }
 
 void AVReaderPlugin::render( const OFX::RenderArguments& args )

plugins/image/io/AudioVideo/src/reader/AVReaderPlugin.cpp

@@ -38,7 +38,16 @@ class AVReaderPlugin : public ReaderPlugin
 	AVReaderPlugin( OfxImageEffectHandle handle );
 
 public:
+	/**
+	 * @brief Open and analyse the InputFile. 
+	 * Create a Stream and its corresponding Decoder for the first video stream of the given file.
+	 * @note Do nothing if the InputFile and the videoStream are already set
+	 */
 	void ensureVideoIsOpen();
+
+	/**
+	 * @brief Clear all attributes related to unwrapping / decoding.
+	 */
 	void cleanInputFile();
 
 	AVReaderParams getProcessParams() const;
@@ -66,7 +75,7 @@ class AVReaderPlugin : public ReaderPlugin
 	// do not need to delete these, the ImageEffect is managing them for us
 	OFX::Clip*         _clipDst;           ///< Destination image clip
 
-	OFX::IntParam* _paramVideoStreamIndex; ///< video stream index
+	OFX::IntParam* _paramVideoStreamIndex; ///< human readable video stream index (from 0 to x)
 	OFX::BooleanParam* _paramUseCustomSAR; ///< Keep sample aspect ratio
 	OFX::DoubleParam*  _paramCustomSAR;    ///< Custom SAR to use
 
@@ -88,9 +97,10 @@ class AVReaderPlugin : public ReaderPlugin
 	OFX::BooleanParam* _paramVerbose;
 
 	boost::scoped_ptr<avtranscoder::InputFile> _inputFile;
-	boost::scoped_ptr<avtranscoder::VideoDecoder> _inputStreamVideo;
+	boost::scoped_ptr<avtranscoder::VideoDecoder> _inputDecoder;
 	boost::scoped_ptr<avtranscoder::VideoFrame> _sourceImage;
 	boost::scoped_ptr<avtranscoder::VideoFrame> _imageToDecode;
+	avtranscoder::InputStream* _inputStream;  ///< Has link (InputFile has ownership)
 
 	avtranscoder::VideoTransform _colorTransform;
 
@@ -99,7 +109,8 @@ class AVReaderPlugin : public ReaderPlugin
 
 	int _lastFrame;
 
-	bool _initVideo;
+	bool _initVideo;  ///< Is the video init
+	bool _isSetUp;  ///< Is the unwrapping and decoding setup
 };
 
 }

plugins/image/io/AudioVideo/src/reader/AVReaderPlugin.hpp

@@ -26,13 +26,13 @@ void AVReaderProcess<View>::setup( const OFX::RenderArguments& args )
 	if( ( _plugin._lastFrame + 1 ) != args.time )
 	{
 		_plugin._inputFile->seekAtFrame( args.time );
-		_plugin._inputStreamVideo->flushDecoder();
+		_plugin._inputDecoder->flushDecoder();
 	}
 
 	_plugin._lastFrame = args.time;
 
 	// Fetch output image
-	if( ! _plugin._inputStreamVideo->decodeNextFrame( *_plugin._sourceImage ) )
+	if( ! _plugin._inputDecoder->decodeNextFrame( *_plugin._sourceImage ) )
 	{
 		BOOST_THROW_EXCEPTION( exception::Failed()
 		    << exception::user() + "Can't open the frame at time " + args.time
@@ -113,10 +113,10 @@ View& AVReaderProcess<View>::readImage( View& dst, avtranscoder::VideoFrame& ima
 {
 	typedef typename FileView::value_type Pixel;
 
-	size_t width = image.desc().getWidth();
-	size_t height = image.desc().getHeight();
-	avtranscoder::PixelProperties pixel = _plugin._inputFile->getProperties().getVideoProperties().at( _plugin._paramVideoStreamIndex->getValue() ).getPixelProperties();
-	size_t rowSizeInBytes = pixel.getNbComponents() * width;
+	const size_t width = image.desc().getWidth();
+	const size_t height = image.desc().getHeight();
+	const avtranscoder::PixelProperties pixel = _plugin._inputFile->getProperties().getVideoProperties().at( _plugin._paramVideoStreamIndex->getValue() ).getPixelProperties();
+	const size_t rowSizeInBytes = pixel.getNbComponents() * width;
 
 	FileView avSrcView = interleaved_view( 
 		width, height,

plugins/image/io/AudioVideo/src/reader/AVReaderProcess.tcc

@@ -1019,7 +1019,7 @@ void AVWriterPlugin::render( const OFX::RenderArguments& args )
 		cleanProfile( profile, common::kPrefixFormat );
 
 		// set format profile (need to be done after beginWrap when muxing)
-		_outputFile->setProfile( profile );
+		_outputFile->setupWrapping( profile );
 
 		// manage codec lantancy
 		_transcoder->preProcessCodecLatency();