Transcoder: removed check of progress duration as a stop condition

Clement Champetier · Clement Champetier · commit 046f6db95869 · 2016-07-11T21:37:39.000+02:00
Use _mainStreamIndex attribute in all process methods to stop the
process.
diff --git a/src/AvTranscoder/transcoder/Transcoder.cpp b/src/AvTranscoder/transcoder/Transcoder.cpp
@@ -243,6 +243,12 @@ bool Transcoder::processFrame()
         {
             LOG_WARN("Failed to process stream " << streamIndex)
             ++nbStreamProcessStatusFailed;
+
+            // if this is the end of the main stream
+            if(streamIndex == _mainStreamIndex) {
+                LOG_INFO("End of process because the main stream at index " << _mainStreamIndex << " failed to process a new frame.")
+                return false;
+            }
         }
     }
 
@@ -302,14 +308,6 @@ ProcessStat Transcoder::process(IProgress& progress)
             LOG_INFO("End of process because the job was canceled.")
             break;
         }
-
-        // check progressDuration
-        if(progressDuration >= expectedOutputDuration)
-        {
-            LOG_INFO("End of process because the output program duration ("
-                     << progressDuration << "s) is equal or upper than " << expectedOutputDuration << "s.")
-            break;
-        }
     }
 
     _outputFile.endWrap();
@@ -498,32 +496,43 @@ ProfileLoader::Profile Transcoder::getProfileFromFile(InputFile& inputFile, cons
     return profile;
 }
 
-float Transcoder::getStreamDuration(size_t indexStream) const
+float Transcoder::getStreamDuration(const size_t indexStream) const
 {
     return _streamTranscoders.at(indexStream)->getDuration();
 }
 
-float Transcoder::getMinTotalDuration() const
+float Transcoder::getMinTotalDuration()
 {
     float minTotalDuration = std::numeric_limits<float>::max();
-    for(size_t i = 0; i < _streamTranscoders.size(); ++i)
+    for(size_t streamIndex = 0; streamIndex < _streamTranscoders.size(); ++streamIndex)
     {
-        minTotalDuration = std::min(getStreamDuration(i), minTotalDuration);
+        const float streamDuration = getStreamDuration(streamIndex);
+        if(std::min(streamDuration, minTotalDuration) == streamDuration) 
+        {
+            minTotalDuration = streamDuration;
+            _mainStreamIndex = streamIndex;
+        }
+        
     }
     return minTotalDuration;
 }
 
-float Transcoder::getMaxTotalDuration() const
+float Transcoder::getMaxTotalDuration()
 {
     float maxTotalDuration = 0;
-    for(size_t i = 0; i < _streamTranscoders.size(); ++i)
+    for(size_t streamIndex = 0; streamIndex < _streamTranscoders.size(); ++streamIndex)
     {
-        maxTotalDuration = std::max(getStreamDuration(i), maxTotalDuration);
+        const float streamDuration = getStreamDuration(streamIndex);
+        if(std::max(streamDuration, maxTotalDuration) == streamDuration)
+        {
+            maxTotalDuration = streamDuration;
+            _mainStreamIndex = streamIndex;
+        }
     }
     return maxTotalDuration;
 }
 
-float Transcoder::getExpectedOutputDuration() const
+float Transcoder::getExpectedOutputDuration()
 {
     switch(_eProcessMethod)
     {
diff --git a/src/AvTranscoder/transcoder/Transcoder.hpp b/src/AvTranscoder/transcoder/Transcoder.hpp
@@ -197,20 +197,22 @@ class AvExport Transcoder
     float getStreamDuration(size_t indexStream) const;
 
     /**
-    * @brief Get the duration of the shortest stream, in seconds
-    */
-    float getMinTotalDuration() const;
+     * @brief Get the duration of the shortest stream, in seconds
+     * @note Set the index of the main stream to stop the process at the end of the shortest stream.
+     */
+    float getMinTotalDuration();
 
     /**
      * @brief Get the duration of the longest stream, in seconds
+     * @note Set the index of the main stream to stop the process at the end of the longest stream.
      */
-    float getMaxTotalDuration() const;
+    float getMaxTotalDuration();
 
     /**
      * @brief Get the expected duration of the output program
      * @note Depends on the streams, the process method, and the main stream index.
      */
-    float getExpectedOutputDuration() const;
+    float getExpectedOutputDuration();
 
     /**
      * @brief Get the current duration of the output program
@@ -240,7 +242,7 @@ class AvExport Transcoder
 
     EProcessMethod _eProcessMethod; ///< Processing policy
     size_t
-        _mainStreamIndex;  ///< Index of stream used to stop the process of transcode in case of eProcessMethodBasedOnStream.
+        _mainStreamIndex;  ///< Index of stream used to stop the process.
     float _outputDuration; ///< Duration of output media used to stop the process of transcode in case of
     /// eProcessMethodBasedOnDuration.
 };

Original file line number	Diff line number	Diff line change
`@@ -243,6 +243,12 @@ bool Transcoder::processFrame()`
`243`	`243`	`{`
`244`	`244`	`LOG_WARN("Failed to process stream " << streamIndex)`
`245`	`245`	`++nbStreamProcessStatusFailed;`
	`246`	`+`
	`247`	`+ // if this is the end of the main stream`
	`248`	`+ if(streamIndex == _mainStreamIndex) {`
	`249`	`+ LOG_INFO("End of process because the main stream at index " << _mainStreamIndex << " failed to process a new frame.")`
	`250`	`+ return false;`
	`251`	`+ }`
`246`	`252`	`}`
`247`	`253`	`}`
`248`	`254`
`@@ -302,14 +308,6 @@ ProcessStat Transcoder::process(IProgress& progress)`
`302`	`308`	`LOG_INFO("End of process because the job was canceled.")`
`303`	`309`	`break;`
`304`	`310`	`}`
`305`		`-`
`306`		`- // check progressDuration`
`307`		`- if(progressDuration >= expectedOutputDuration)`
`308`		`- {`
`309`		`- LOG_INFO("End of process because the output program duration ("`
`310`		`- << progressDuration << "s) is equal or upper than " << expectedOutputDuration << "s.")`
`311`		`- break;`
`312`		`- }`
`313`	`311`	`}`
`314`	`312`
`315`	`313`	`_outputFile.endWrap();`
`@@ -498,32 +496,43 @@ ProfileLoader::Profile Transcoder::getProfileFromFile(InputFile& inputFile, cons`
`498`	`496`	`return profile;`
`499`	`497`	`}`
`500`	`498`
`501`		`-float Transcoder::getStreamDuration(size_t indexStream) const`
	`499`	`+float Transcoder::getStreamDuration(const size_t indexStream) const`
`502`	`500`	`{`
`503`	`501`	`return _streamTranscoders.at(indexStream)->getDuration();`
`504`	`502`	`}`
`505`	`503`
`506`		`-float Transcoder::getMinTotalDuration() const`
	`504`	`+float Transcoder::getMinTotalDuration()`
`507`	`505`	`{`
`508`	`506`	`float minTotalDuration = std::numeric_limits<float>::max();`
`509`		`- for(size_t i = 0; i < _streamTranscoders.size(); ++i)`
	`507`	`+ for(size_t streamIndex = 0; streamIndex < _streamTranscoders.size(); ++streamIndex)`
`510`	`508`	`{`
`511`		`- minTotalDuration = std::min(getStreamDuration(i), minTotalDuration);`
	`509`	`+ const float streamDuration = getStreamDuration(streamIndex);`
	`510`	`+ if(std::min(streamDuration, minTotalDuration) == streamDuration)`
	`511`	`+ {`
	`512`	`+ minTotalDuration = streamDuration;`
	`513`	`+ _mainStreamIndex = streamIndex;`
	`514`	`+ }`
	`515`	`+`
`512`	`516`	`}`
`513`	`517`	`return minTotalDuration;`
`514`	`518`	`}`
`515`	`519`
`516`		`-float Transcoder::getMaxTotalDuration() const`
	`520`	`+float Transcoder::getMaxTotalDuration()`
`517`	`521`	`{`
`518`	`522`	`float maxTotalDuration = 0;`
`519`		`- for(size_t i = 0; i < _streamTranscoders.size(); ++i)`
	`523`	`+ for(size_t streamIndex = 0; streamIndex < _streamTranscoders.size(); ++streamIndex)`
`520`	`524`	`{`
`521`		`- maxTotalDuration = std::max(getStreamDuration(i), maxTotalDuration);`
	`525`	`+ const float streamDuration = getStreamDuration(streamIndex);`
	`526`	`+ if(std::max(streamDuration, maxTotalDuration) == streamDuration)`
	`527`	`+ {`
	`528`	`+ maxTotalDuration = streamDuration;`
	`529`	`+ _mainStreamIndex = streamIndex;`
	`530`	`+ }`
`522`	`531`	`}`
`523`	`532`	`return maxTotalDuration;`
`524`	`533`	`}`
`525`	`534`
`526`		`-float Transcoder::getExpectedOutputDuration() const`
	`535`	`+float Transcoder::getExpectedOutputDuration()`
`527`	`536`	`{`
`528`	`537`	`switch(_eProcessMethod)`
`529`	`538`	`{`