Merge pull request #322 from avTranscoder/fix/stop_process_even_if_the_wrapper_expects_more_data

valnoel · web-flow · commit 406013bd2331 · 2020-08-12T11:59:00.000+02:00
Fix: stop the process even if the wrapper expects more data
diff --git a/src/AvTranscoder/file/OutputFile.cpp b/src/AvTranscoder/file/OutputFile.cpp
@@ -188,7 +188,7 @@ bool OutputFile::beginWrap()
 IOutputStream::EWrappingStatus OutputFile::wrap(const CodedData& data, const size_t streamIndex)
 {
     if(!data.getSize())
-        return IOutputStream::eWrappingSuccess;
+        return IOutputStream::eWrappingSkip;
 
     LOG_DEBUG("Wrap on stream " << streamIndex << " (" << data.getSize() << " bytes for frame "
                                 << _frameCount.at(streamIndex) << ")")
diff --git a/src/AvTranscoder/stream/IOutputStream.hpp b/src/AvTranscoder/stream/IOutputStream.hpp
@@ -16,9 +16,10 @@ class AvExport IOutputStream
      **/
     enum EWrappingStatus
     {
-        eWrappingSuccess = 0,
-        eWrappingWaitingForData,
-        eWrappingError,
+        eWrappingSuccess = 0,    ///< The wrapping succeeded
+        eWrappingWaitingForData, ///< The wrapper expects more data to complete the writing process
+        eWrappingSkip,           ///< The wrapper receives empty data, so nothing is written
+        eWrappingError,          ///< An error occurred during the wrapping process
     };
 
     virtual ~IOutputStream(){};
diff --git a/src/AvTranscoder/transcoder/StreamTranscoder.cpp b/src/AvTranscoder/transcoder/StreamTranscoder.cpp
@@ -597,7 +597,7 @@ void StreamTranscoder::preProcessCodecLatency()
         _currentDecoder = NULL;
 }
 
-bool StreamTranscoder::processFrame()
+IOutputStream::EWrappingStatus StreamTranscoder::processFrame()
 {
     std::string msg = "Current process case of the stream is a ";
     switch(getProcessCase())
@@ -677,7 +677,7 @@ bool StreamTranscoder::processFrame()
     return processTranscode();
 }
 
-bool StreamTranscoder::processRewrap()
+IOutputStream::EWrappingStatus StreamTranscoder::processRewrap()
 {
     assert(_inputStreams.size() == 1);
     assert(_outputStream != NULL);
@@ -692,25 +692,13 @@ bool StreamTranscoder::processRewrap()
             switchToGeneratorDecoder();
             return processTranscode();
         }
-        return false;
+        return IOutputStream::eWrappingError;
     }
 
-    const IOutputStream::EWrappingStatus wrappingStatus = _outputStream->wrap(data);
-    switch(wrappingStatus)
-    {
-        case IOutputStream::eWrappingSuccess:
-            return true;
-        case IOutputStream::eWrappingWaitingForData:
-            // the wrapper needs more data to write the current packet
-            return processFrame();
-        case IOutputStream::eWrappingError:
-            return false;
-    }
-
-    return true;
+    return _outputStream->wrap(data);
 }
 
-bool StreamTranscoder::processTranscode()
+IOutputStream::EWrappingStatus StreamTranscoder::processTranscode()
 {
     assert(_outputStream != NULL);
     assert(_currentDecoder != NULL);
@@ -840,25 +828,13 @@ bool StreamTranscoder::processTranscode()
                 }
                 return processTranscode();
             }
-            return false;
+            return IOutputStream::eWrappingError;
         }
     }
 
     // Wrap
     LOG_DEBUG("wrap (" << data.getSize() << " bytes)")
-    const IOutputStream::EWrappingStatus wrappingStatus = _outputStream->wrap(data);
-    switch(wrappingStatus)
-    {
-        case IOutputStream::eWrappingSuccess:
-            return true;
-        case IOutputStream::eWrappingWaitingForData:
-            // the wrapper needs more data to write the current packet
-            return processFrame();
-        case IOutputStream::eWrappingError:
-            return false;
-    }
-
-    return true;
+    return _outputStream->wrap(data);
 }
 
 void StreamTranscoder::switchToGeneratorDecoder()
diff --git a/src/AvTranscoder/transcoder/StreamTranscoder.hpp b/src/AvTranscoder/transcoder/StreamTranscoder.hpp
@@ -69,7 +69,7 @@ class AvExport StreamTranscoder
      * @brief process a single frame for the current stream
      * @return the process status result
      */
-    bool processFrame();
+    IOutputStream::EWrappingStatus processFrame();
 
     //@{
     // Switch current decoder.
@@ -139,8 +139,8 @@ class AvExport StreamTranscoder
     void addDecoder(const InputStreamDesc& inputStreamDesc, IInputStream& inputStream);
     void addGenerator(const InputStreamDesc& inputStreamDesc, const ProfileLoader::Profile& profile);
 
-    bool processRewrap();
-    bool processTranscode();
+    IOutputStream::EWrappingStatus processRewrap();
+    IOutputStream::EWrappingStatus processTranscode();
 
 private:
     std::vector<InputStreamDesc> _inputStreamDesc; ///< Description of the data to extract from the input stream.
diff --git a/src/AvTranscoder/transcoder/Transcoder.cpp b/src/AvTranscoder/transcoder/Transcoder.cpp
@@ -19,6 +19,7 @@ Transcoder::Transcoder(IOutputFile& outputFile)
     , _profileLoader(true)
     , _eProcessMethod(eProcessMethodLongest)
     , _mainStreamIndex(0)
+    , _processedFrames(0)
     , _outputDuration(0)
 {
 }
@@ -159,27 +160,86 @@ void Transcoder::preProcessCodecLatency()
 }
 
 bool Transcoder::processFrame()
+{
+    NoDisplayProgress progress;
+    return processFrame(progress);
+}
+
+bool Transcoder::processFrame(IProgress& progress)
 {
     if(_streamTranscoders.size() == 0)
         return false;
 
     // For each stream, process a frame
+    bool result = true;
     for(size_t streamIndex = 0; streamIndex < _streamTranscoders.size(); ++streamIndex)
     {
-        LOG_DEBUG("Process stream " << streamIndex + 1 << "/" << _streamTranscoders.size())
+        if(!processFrame(progress, streamIndex))
+            result = false;
+    }
+    return result;
+}
 
-        // if a stream failed to process
-        if(!_streamTranscoders.at(streamIndex)->processFrame())
-        {
+bool Transcoder::processFrame(IProgress& progress, const size_t& streamIndex)
+{
+    LOG_DEBUG("Process stream " << streamIndex + 1 << "/" << _streamTranscoders.size())
+
+    IOutputStream::EWrappingStatus status = _streamTranscoders.at(streamIndex)->processFrame();
+    switch(status)
+    {
+        case IOutputStream::eWrappingSuccess:
+            if(streamIndex == 0)
+                _processedFrames++;
+
+            if(!continueProcess(progress))
+                return false;
+            return true;
+
+        case IOutputStream::eWrappingWaitingForData:
+            // the wrapper needs more data to write the current packet
+            if(streamIndex == 0)
+                _processedFrames++;
+
+            if(!continueProcess(progress))
+                return false;
+
+            return processFrame(progress, streamIndex);
+
+        case IOutputStream::eWrappingSkip:
+            return true;
+
+        case IOutputStream::eWrappingError:
+            // if a stream failed to process
             LOG_WARN("Failed to process the stream transcoder at index " << streamIndex)
 
             // if this is the end of the main stream
-            if(streamIndex == _mainStreamIndex) {
+            if(streamIndex == _mainStreamIndex)
                 LOG_INFO("End of process because the main stream at index " << _mainStreamIndex << " failed to process a new frame.")
-                return false;
-            }
-        }
+
+            return false;
     }
+}
+
+bool Transcoder::continueProcess(IProgress& progress) {
+    const float expectedOutputDuration = getExpectedOutputDuration();
+    const float progressDuration = getCurrentOutputDuration();
+
+    // check if JobStatusCancel
+    if(progress.progress((progressDuration > expectedOutputDuration) ? expectedOutputDuration : progressDuration,
+                         expectedOutputDuration) == eJobStatusCancel)
+    {
+        LOG_INFO("End of process because the job was canceled.")
+        return false;
+    }
+
+    // check progressDuration
+    if(_eProcessMethod == eProcessMethodBasedOnDuration && progressDuration >= expectedOutputDuration)
+    {
+        LOG_INFO("End of process because the output program duration ("
+                 << progressDuration << "s) is equal or upper than " << expectedOutputDuration << "s.")
+        return false;
+    }
+
     return true;
 }
 
@@ -205,36 +265,15 @@ ProcessStat Transcoder::process(IProgress& progress)
     const float expectedOutputDuration = getExpectedOutputDuration();
     LOG_INFO("The expected output duration of the program will be " << expectedOutputDuration << "s.")
 
-    size_t frame = 0;
     bool frameProcessed = true;
     while(frameProcessed)
     {
-        LOG_DEBUG("Process frame " << frame)
-        frameProcessed = processFrame();
-        ++frame;
-
-        const float progressDuration = getCurrentOutputDuration();
-
-        // check if JobStatusCancel
-        if(progress.progress((progressDuration > expectedOutputDuration) ? expectedOutputDuration : progressDuration,
-                             expectedOutputDuration) == eJobStatusCancel)
-        {
-            LOG_INFO("End of process because the job was canceled.")
-            break;
-        }
-
-        // check progressDuration
-        if(_eProcessMethod == eProcessMethodBasedOnDuration && progressDuration >= expectedOutputDuration)
-        {
-            LOG_INFO("End of process because the output program duration ("
-                     << progressDuration << "s) is equal or upper than " << expectedOutputDuration << "s.")
-            break;
-        }
+        LOG_INFO("Process frame " << _processedFrames);
+        frameProcessed = processFrame(progress);
     }
 
     _outputFile.endWrap();
-
-    LOG_INFO("End of process: " << ++frame << " frames processed")
+    LOG_INFO("End of process: " << ++_processedFrames << " frames processed")
 
     LOG_INFO("Get process statistics")
     ProcessStat processStat;
diff --git a/src/AvTranscoder/transcoder/Transcoder.hpp b/src/AvTranscoder/transcoder/Transcoder.hpp
@@ -95,9 +95,11 @@ class AvExport Transcoder
 
     /**
      * @brief Process the next frame of all streams.
+     * @param progress: choose a progress, or create your own in C++ or in bindings by inherit IProgress class.
      * @return if a frame was processed or not.
      */
-    bool processFrame();
+    bool processFrame(IProgress& progress);
+    bool processFrame(); ///< Call processFrame with no display of progression
 
     /**
      * @brief Process all the streams, and ended the process depending on the transcode politic.
@@ -190,6 +192,19 @@ class AvExport Transcoder
      */
     void manageSwitchToGenerator();
 
+    /**
+     * @brief Process the next frame of the specified stream.
+     * @return whether a frame was processed or not.
+     */
+    bool processFrame(IProgress& progress, const size_t& streamIndex);
+
+    /**
+     * @brief Check whether the process is canceled or not, and whether the process reached the ending condition.
+     * @note The progress is updated in this function.
+     * @return whether the process must continue or stop.
+     */
+    bool continueProcess(IProgress& progress);
+
     /**
      * @brief Fill the given ProcessStat to summarize the process.
      */
@@ -205,10 +220,11 @@ class AvExport Transcoder
     ProfileLoader _profileLoader; ///< Objet to get existing profiles, and add new ones for the Transcoder.
 
     EProcessMethod _eProcessMethod; ///< Processing policy
-    size_t
-        _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.
+
+    size_t _mainStreamIndex;  ///< Index of stream used to stop the process.
+    size_t _processedFrames;  ///< Counter for the number of processed frames.
+
+    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
`@@ -188,7 +188,7 @@ bool OutputFile::beginWrap()`
`188`	`188`	`IOutputStream::EWrappingStatus OutputFile::wrap(const CodedData& data, const size_t streamIndex)`
`189`	`189`	`{`
`190`	`190`	`if(!data.getSize())`
`191`		`- return IOutputStream::eWrappingSuccess;`
	`191`	`+ return IOutputStream::eWrappingSkip;`
`192`	`192`
`193`	`193`	`LOG_DEBUG("Wrap on stream " << streamIndex << " (" << data.getSize() << " bytes for frame "`
`194`	`194`	`<< _frameCount.at(streamIndex) << ")")`
Original file line number	Diff line number	Diff line change
`@@ -597,7 +597,7 @@ void StreamTranscoder::preProcessCodecLatency()`
`597`	`597`	`_currentDecoder = NULL;`
`598`	`598`	`}`
`599`	`599`
`600`		`-bool StreamTranscoder::processFrame()`
	`600`	`+IOutputStream::EWrappingStatus StreamTranscoder::processFrame()`
`601`	`601`	`{`
`602`	`602`	`std::string msg = "Current process case of the stream is a ";`
`603`	`603`	`switch(getProcessCase())`
`@@ -677,7 +677,7 @@ bool StreamTranscoder::processFrame()`
`677`	`677`	`return processTranscode();`
`678`	`678`	`}`
`679`	`679`
`680`		`-bool StreamTranscoder::processRewrap()`
	`680`	`+IOutputStream::EWrappingStatus StreamTranscoder::processRewrap()`
`681`	`681`	`{`
`682`	`682`	`assert(_inputStreams.size() == 1);`
`683`	`683`	`assert(_outputStream != NULL);`
`@@ -692,25 +692,13 @@ bool StreamTranscoder::processRewrap()`
`692`	`692`	`switchToGeneratorDecoder();`
`693`	`693`	`return processTranscode();`
`694`	`694`	`}`
`695`		`- return false;`
	`695`	`+ return IOutputStream::eWrappingError;`
`696`	`696`	`}`
`697`	`697`
`698`		`- const IOutputStream::EWrappingStatus wrappingStatus = _outputStream->wrap(data);`
`699`		`- switch(wrappingStatus)`
`700`		`- {`
`701`		`- case IOutputStream::eWrappingSuccess:`
`702`		`- return true;`
`703`		`- case IOutputStream::eWrappingWaitingForData:`
`704`		`- // the wrapper needs more data to write the current packet`
`705`		`- return processFrame();`
`706`		`- case IOutputStream::eWrappingError:`
`707`		`- return false;`
`708`		`- }`
`709`		`-`
`710`		`- return true;`
	`698`	`+ return _outputStream->wrap(data);`
`711`	`699`	`}`
`712`	`700`
`713`		`-bool StreamTranscoder::processTranscode()`
	`701`	`+IOutputStream::EWrappingStatus StreamTranscoder::processTranscode()`
`714`	`702`	`{`
`715`	`703`	`assert(_outputStream != NULL);`
`716`	`704`	`assert(_currentDecoder != NULL);`
`@@ -840,25 +828,13 @@ bool StreamTranscoder::processTranscode()`
`840`	`828`	`}`
`841`	`829`	`return processTranscode();`
`842`	`830`	`}`
`843`		`- return false;`
	`831`	`+ return IOutputStream::eWrappingError;`
`844`	`832`	`}`
`845`	`833`	`}`
`846`	`834`
`847`	`835`	`// Wrap`
`848`	`836`	`LOG_DEBUG("wrap (" << data.getSize() << " bytes)")`
`849`		`- const IOutputStream::EWrappingStatus wrappingStatus = _outputStream->wrap(data);`
`850`		`- switch(wrappingStatus)`
`851`		`- {`
`852`		`- case IOutputStream::eWrappingSuccess:`
`853`		`- return true;`
`854`		`- case IOutputStream::eWrappingWaitingForData:`
`855`		`- // the wrapper needs more data to write the current packet`
`856`		`- return processFrame();`
`857`		`- case IOutputStream::eWrappingError:`
`858`		`- return false;`
`859`		`- }`
`860`		`-`
`861`		`- return true;`
	`837`	`+ return _outputStream->wrap(data);`
`862`	`838`	`}`
`863`	`839`
`864`	`840`	`void StreamTranscoder::switchToGeneratorDecoder()`