avTranscoder · valnoel · Nov 24, 2015 · Nov 17, 2015 · Nov 17, 2015 · Nov 17, 2015
diff --git a/src/AvTranscoder/file/InputFile.cpp b/src/AvTranscoder/file/InputFile.cpp
@@ -67,6 +67,9 @@ bool InputFile::readNextPacket( CodedData& data, const size_t streamIndex )
 			return false;
 		}
 
+		// Add Stream info to the packet
+		data.refAVStream( _formatContext.getAVStream( streamIndex ) );
+
 		// if the packet stream is the expected one
 		// return the packet data
 		const int packetStreamIndex = data.getAVPacket().stream_index;

diff --git a/src/AvTranscoder/file/OutputFile.cpp b/src/AvTranscoder/file/OutputFile.cpp
@@ -104,7 +104,17 @@ IOutputStream& OutputFile::addDataStream( const DataCodec& dataDesc )
 IOutputStream& OutputFile::getStream( const size_t streamIndex )
 {
 	if( streamIndex >= _outputStreams.size() )
-		throw std::runtime_error( "unable to get output stream (out of range)" );
+	{
+		std::stringstream msg;
+		msg << "Unable to get the stream ";
+		msg << streamIndex;
+		msg << ": the OutputFile '";
+		msg << getFilename();
+		msg << "' has only ";
+		msg << _outputStreams.size();
+		msg << " streams.";
+		throw std::runtime_error( msg.str() );
+	}
 	return *_outputStreams.at( streamIndex );
 }
 
@@ -166,16 +176,46 @@ IOutputStream::EWrappingStatus OutputFile::wrap( const CodedData& data, const si
 
 	LOG_DEBUG( "Wrap on stream " << streamIndex << " (" << data.getSize() << " bytes for frame " << _frameCount.at( streamIndex ) << ")" )
 
+	// Packet to wrap
 	AVPacket packet;
 	av_init_packet( &packet );
 	packet.stream_index = streamIndex;
 	packet.data = (uint8_t*)data.getData();
 	packet.size = data.getSize();
+	packet.flags = data.getAVPacket().flags;
 
-	_formatContext.writeFrame( packet );
+	// copy timing information
+	if( ! _outputStreams.at( streamIndex )->isPTSGenerated() )
+	{
+		if( data.getAVStream() != NULL )
+		{
+			const AVRational& srcTimeBase = data.getAVStream()->time_base;
+			const AVRational& dstTimeBase = _formatContext.getAVStream( streamIndex ).time_base;
+			// duration
+			packet.duration = av_rescale_q( data.getAVPacket().duration, srcTimeBase, dstTimeBase );
+			// pts
+			if( data.getAVPacket().pts != AV_NOPTS_VALUE )
+				packet.pts = av_rescale_q( data.getAVPacket().pts, srcTimeBase, dstTimeBase );
+			else
+				packet.pts = AV_NOPTS_VALUE;
+			// dts
+			packet.dts = av_rescale_q( data.getAVPacket().dts, srcTimeBase, dstTimeBase );
+		}
+		// add stream PTS if already incremented
+		const int currentStreamPTS = _outputStreams.at( streamIndex )->getStreamPTS();
+		if( packet.pts != AV_NOPTS_VALUE && packet.pts < currentStreamPTS )
+		{
+			packet.pts += currentStreamPTS;
+			packet.dts += currentStreamPTS;
+		}
+	}
 
-	// free packet.side_data, set packet.data to NULL and packet.size to 0
-	av_free_packet( &packet );
+	// copy duration of packet wrapped
+	// @see OutputStream
+	const_cast<CodedData&>(data).getAVPacket().duration = packet.duration;
+
+	// Write packet
+	_formatContext.writeFrame( packet );
 
 	const double currentStreamDuration = _outputStreams.at( streamIndex )->getStreamDuration();
 	if( currentStreamDuration < _previousProcessedStreamDuration )

diff --git a/src/AvTranscoder/frame/Frame.cpp b/src/AvTranscoder/frame/Frame.cpp
@@ -6,28 +6,33 @@ namespace avtranscoder
 {
 
 Frame::Frame()
+	: _avStream( NULL )
 {
 	initAVPacket();
 }
 
 Frame::Frame( const size_t dataSize )
+	: _avStream( NULL )
 {
 	av_new_packet( &_packet, dataSize );
 }
 
 Frame::Frame( const AVPacket& avPacket )
+	: _avStream( NULL )
 {
 	copyAVPacket( avPacket );
 }
 
 Frame::Frame( const Frame& other )
 {
 	copyAVPacket( other.getAVPacket() );
+	_avStream = other.getAVStream();
 }
 
 Frame& Frame::operator=( const Frame& other )
 {
 	copyAVPacket( other.getAVPacket() );
+	_avStream = other.getAVStream();
 	return *this;
 }
 

diff --git a/src/AvTranscoder/frame/Frame.hpp b/src/AvTranscoder/frame/Frame.hpp
@@ -7,6 +7,8 @@ extern "C" {
 #include <libavcodec/avcodec.h>
 }
 
+struct AVStream;
+
 namespace avtranscoder
 {
 
@@ -33,6 +35,7 @@ class AvExport Frame
 	/// Free buffer of data
 	~Frame();
 
+	void refAVStream( const AVStream& avStream ) { _avStream = &avStream; }
 	/// Resize data buffer
 	void resize( const size_t newSize );
 
@@ -58,6 +61,11 @@ class AvExport Frame
 	size_t getSize() const { return _packet.size; }
 
 #ifndef SWIG
+	/**
+	 * @return the AVStream which contains the packet
+	 * @note may be NULL in case of generated packets
+	 */
+	const AVStream* getAVStream() const { return _avStream; }
 	AVPacket& getAVPacket() { return _packet; }
 	const AVPacket& getAVPacket() const { return _packet; }
 	const unsigned char* getData() const { return _packet.data; }
@@ -69,6 +77,9 @@ class AvExport Frame
 
 private:
 	AVPacket _packet;
+
+	// Stream which contains the packet
+	const AVStream* _avStream;  //< Has link (no ownership)
 };
 
 // Typedef to represent buffer of coded data.

diff --git a/src/AvTranscoder/mediaProperty/StreamProperties.cpp b/src/AvTranscoder/mediaProperty/StreamProperties.cpp
@@ -29,18 +29,13 @@ Rational StreamProperties::getTimeBase() const
 {
 	if( ! _formatContext )
 		throw std::runtime_error( "unknown format context" );
-
-	Rational timeBase = {
-		_formatContext->streams[_streamIndex]->time_base.num,
-		_formatContext->streams[_streamIndex]->time_base.den,
-	};
-	return timeBase;
+	return _formatContext->streams[_streamIndex]->time_base;
 }
 
 float StreamProperties::getDuration() const
 {
-	Rational timeBase = getTimeBase();
-	return ( timeBase.num / (float) timeBase.den ) * _formatContext->streams[_streamIndex]->duration;
+	const Rational timeBase = getTimeBase();
+	return av_q2d( timeBase ) * _formatContext->streams[_streamIndex]->duration;
 }
 
 AVMediaType StreamProperties::getStreamType() const

diff --git a/src/AvTranscoder/stream/OutputStream.cpp b/src/AvTranscoder/stream/OutputStream.cpp
@@ -13,6 +13,8 @@ OutputStream::OutputStream( OutputFile& outputFile, const size_t streamIndex )
 	, _outputAVStream( outputFile.getFormatContext().getAVStream( streamIndex ) )
 	, _streamIndex( streamIndex )
 	, _wrappedPacketsDuration( 0 )
+	, _lastWrappedPacketDuration( 0 )
+	, _isPTSGenerated( false )
 {
 }
 
@@ -28,14 +30,8 @@ float OutputStream::getStreamDuration() const
 		return 0.f;
 	}
 
-	// if stream PTS is not set, use the duration of all packets wrapped
-	if( ! outputPTS.val )
-	{
-		LOG_WARN( "PTS generation when outputting stream " << _streamIndex << " is not set." )
-		if( _wrappedPacketsDuration )
-			return av_q2d( _outputAVStream.codec->time_base ) * _wrappedPacketsDuration;
-	}
-
+	if( _wrappedPacketsDuration )
+		return av_q2d( outputTimeBase ) * _wrappedPacketsDuration;
 #if AVTRANSCODER_FFMPEG_DEPENDENCY && LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(55, 40, 100)
 	// returns the pts of the last muxed packet, converted from timebase to seconds
 	return av_q2d( outputTimeBase ) * av_stream_get_end_pts( &_outputAVStream );
@@ -49,13 +45,61 @@ size_t OutputStream::getNbFrames() const
 	return _outputAVStream.nb_frames;
 }
 
+int OutputStream::getStreamPTS() const
+{
+	const AVFrac& outputPTS = _outputAVStream.pts;
+	return ( outputPTS.val + ( outputPTS.num / outputPTS.den ) );
+}
+
 IOutputStream::EWrappingStatus OutputStream::wrap( const CodedData& data )
 {
+	// If stream PTS will be generated at rewrap time
+	if( ! _isPTSGenerated && (data.getAVPacket().pts == 0 || data.getAVPacket().pts == AV_NOPTS_VALUE) && data.getAVPacket().dts == AV_NOPTS_VALUE )
+	{
+		LOG_WARN( "PTS of output stream " << _streamIndex << " is generated at rewrap time." )
+		_isPTSGenerated = true;
+	}
+
 	// wrap packet
 	IOutputStream::EWrappingStatus status = _outputFile.wrap( data, _streamIndex );
 
-	// append duration of the packet to the stream
-	_wrappedPacketsDuration += data.getAVPacket().duration;
+	// Store duration of the last packet wrapped
+	if( data.getAVPacket().duration != 0  && data.getAVPacket().duration != _lastWrappedPacketDuration )
+		_lastWrappedPacketDuration = data.getAVPacket().duration;
+
+	// Append duration of the packet to the stream
+	if( data.getAVPacket().duration )
+		_wrappedPacketsDuration += data.getAVPacket().duration;
+	else
+	{
+		switch( _outputAVStream.codec->codec_type )
+		{
+			case AVMEDIA_TYPE_VIDEO:
+			{
+				_wrappedPacketsDuration += _lastWrappedPacketDuration;
+				break;
+			}
+			case AVMEDIA_TYPE_AUDIO:
+			{
+				Rational audioPacketDuration;
+				audioPacketDuration.num = 0;
+				audioPacketDuration.den = 0;
+				const int frame_size = av_get_audio_frame_duration(_outputAVStream.codec, data.getSize());
+				if( frame_size <= 0 || _outputAVStream.codec->sample_rate <= 0 )
+					break;
+				audioPacketDuration.num = frame_size;
+				audioPacketDuration.den = _outputAVStream.codec->sample_rate;
+				_wrappedPacketsDuration += av_rescale(
+						1,
+						audioPacketDuration.num * (int64_t)_outputAVStream.time_base.den * _outputAVStream.codec->ticks_per_frame,
+						audioPacketDuration.den * (int64_t)_outputAVStream.time_base.num
+					);
+				break;
+			}
+			default:
+				break;
+		}
+	}
 
 	return status;
 }

diff --git a/src/AvTranscoder/stream/OutputStream.hpp b/src/AvTranscoder/stream/OutputStream.hpp
@@ -18,7 +18,9 @@ class AvExport OutputStream : public IOutputStream
 	size_t getStreamIndex() const { return _streamIndex; }
 	float getStreamDuration() const;
 	size_t getNbFrames() const;  ///< If audio stream, returns number of packets
+	int getStreamPTS() const;  ///< Get current AVStream PTS
 
+	bool isPTSGenerated() const { return _isPTSGenerated; }
 	IOutputStream::EWrappingStatus wrap( const CodedData& data );
 
 private:
@@ -27,12 +29,14 @@ class AvExport OutputStream : public IOutputStream
 
 	size_t _streamIndex;  ///<  Index of the stream in the output file
 
-	/**
-	 * @brief This will help us to getStreamDuration if PTS of outputStream is not properly set during wrapping.
-	 * It corresponds to the addition of the duration of all packets wrapped by this stream.
-	 * @see getStreamDuration
-	 */
-	size_t _wrappedPacketsDuration;
+	//@{
+	// @brief These attributes will help us to get the stream duration.
+	// @see ffmpeg hack: https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/mux.c#L585
+	// @see getStreamDuration
+	size_t _wrappedPacketsDuration;  //< the addition of the duration of all packets wrapped by this stream.
+	int _lastWrappedPacketDuration;  //< The duration of the last packet wrapped by this stream.
+	bool _isPTSGenerated;  //< Is the PTS generated by ffmpeg/libav (in case of generator for example)
+	//@}
 };
 
 }

diff --git a/src/AvTranscoder/transcoder/StreamTranscoder.cpp b/src/AvTranscoder/transcoder/StreamTranscoder.cpp
@@ -319,15 +319,14 @@ void StreamTranscoder::preProcessCodecLatency()
 {
 	if( ! _outputEncoder )
 	{
-		std::stringstream os;
-		os << "No output encoder found for stream ";		
+		std::stringstream msg;
+		msg << "No encoder found for input stream ";
 		if( getProcessCase() == eProcessCaseGenerator )
-			os << "generator";
+			msg << "generator";
 		else
-			os << _inputStream->getStreamIndex();
-		os << ": will not preProcessCodecLatency.";
-		LOG_INFO( os.str() )
-
+			msg << _inputStream->getStreamIndex();
+		msg << ": will not preProcessCodecLatency.";
+		LOG_WARN( msg.str() )
 		return;
 	}
 
@@ -408,7 +407,7 @@ bool StreamTranscoder::processRewrap()
 	LOG_DEBUG( "StreamTranscoder::processRewrap" )
 
 	// if switched to generator, process frame
-	if( _currentDecoder == _generator )
+	if( _currentDecoder && _currentDecoder == _generator )
 	{
 		return processTranscode();
 	}

diff --git a/src/AvTranscoder/transcoder/StreamTranscoder.hpp b/src/AvTranscoder/transcoder/StreamTranscoder.hpp
@@ -70,10 +70,10 @@ class AvExport StreamTranscoder
 	 */
 	float getDuration() const;
 
-	/// Returns a reference to the current decoder (from input file or from generator)
-	IDecoder& getCurrentDecoder() const { return *_currentDecoder; }
-	/// Returns a reference to the encoder
-	IEncoder& getEncoder() const { return *_outputEncoder; }
+	/// Returns a pointer to the current decoder (from input file or from generator)
+	IDecoder* getCurrentDecoder() const { return _currentDecoder; }
+	/// Returns a pointer to the encoder
+	IEncoder* getEncoder() const { return _outputEncoder; }
 
 	/// Returns a reference to the object which transforms the decoded data
 	ITransform& getTransform() const { return *_transform; }

diff --git a/src/AvTranscoder/transcoder/Transcoder.cpp b/src/AvTranscoder/transcoder/Transcoder.cpp
@@ -241,14 +241,14 @@ ProcessStat Transcoder::process( IProgress& progress )
 
 	preProcessCodecLatency();
 
-	const double outputDuration = getOutputDuration();
+	const float outputDuration = getOutputDuration();
 	LOG_INFO( "Output duration of the process will be " << outputDuration << "s." )
 
 	size_t frame = 0;
 	bool frameProcessed = true;
 	while( frameProcessed )
 	{
-		const double progressDuration = _outputFile.getStream( 0 ).getStreamDuration();
+		const float progressDuration = _outputFile.getStream( 0 ).getStreamDuration();
 
 		// check if JobStatusCancel
 		if( progress.progress( ( progressDuration > outputDuration ) ? outputDuration : progressDuration, outputDuration ) == eJobStatusCancel )
@@ -528,11 +528,15 @@ void Transcoder::fillProcessStat( ProcessStat& processStat )
 			case AVMEDIA_TYPE_VIDEO:
 			{
 				VideoStat videoStat( stream.getStreamDuration(), stream.getNbFrames() );
-				const AVCodecContext& encoderContext = _streamTranscoders.at( streamIndex )->getEncoder().getCodec().getAVCodecContext();
-				if( encoderContext.coded_frame && ( encoderContext.flags & CODEC_FLAG_PSNR) )
+				IEncoder* encoder = _streamTranscoders.at( streamIndex )->getEncoder();
+				if( encoder )
 				{
-					videoStat._quality = encoderContext.coded_frame->quality;
-					videoStat._psnr = VideoStat::psnr( encoderContext.coded_frame->error[0] / ( encoderContext.width * encoderContext.height * 255.0 * 255.0 ) );
+					const AVCodecContext& encoderContext = encoder->getCodec().getAVCodecContext();
+					if( encoderContext.coded_frame && ( encoderContext.flags & CODEC_FLAG_PSNR) )
+					{
+						videoStat._quality = encoderContext.coded_frame->quality;
+						videoStat._psnr = VideoStat::psnr( encoderContext.coded_frame->error[0] / ( encoderContext.width * encoderContext.height * 255.0 * 255.0 ) );
+					}
 				}
 				processStat.addVideoStat( streamIndex, videoStat );
 				break;

diff --git a/test/pyTest/__init__.py b/test/pyTest/__init__.py
@@ -0,0 +1,4 @@
+from pyAvTranscoder import avtranscoder as av
+
+av.preloadCodecsAndFormats()
+av.Logger.setLogLevel(av.AV_LOG_WARNING)