FilterGraph: remove useless areInputAudioFrames() method

Valentin NOEL · Valentin NOEL · commit 969c6c3b4378 · 2017-09-07T15:48:31.000+02:00
Replace it by a simple AudioFrameBuffer vector empty() test, since
buffers are initialized only for audio frames (into the addInBuffer()
method)
And rename _inputAudioFramesBuffer attribute to _inputAudioFrameBuffers
diff --git a/src/AvTranscoder/filter/FilterGraph.cpp b/src/AvTranscoder/filter/FilterGraph.cpp
@@ -133,7 +133,7 @@ FilterGraph::FilterGraph(const ICodec& codec)
 
 FilterGraph::~FilterGraph()
 {
-    _inputAudioFramesBuffer.clear();
+    _inputAudioFrameBuffers.clear();
     for(std::vector<Filter*>::iterator it = _filters.begin(); it < _filters.end(); ++it)
     {
         delete(*it);
@@ -145,7 +145,7 @@ size_t FilterGraph::getAvailableFrameSize(const std::vector<IFrame*>& inputs, co
 {
     size_t frameSize = inputs.at(index)->getDataSize();
     if(frameSize == 0)
-        frameSize = _inputAudioFramesBuffer.at(index).getDataSize();
+        frameSize = _inputAudioFrameBuffers.at(index).getDataSize();
     return frameSize;
 }
 
@@ -166,10 +166,10 @@ size_t FilterGraph::getMinInputFrameSize(const std::vector<IFrame*>& inputs)
 
 bool FilterGraph::hasBufferedFrames()
 {
-    if(!_inputAudioFramesBuffer.size())
+    if(!_inputAudioFrameBuffers.size())
         return false;
 
-    for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFramesBuffer.begin(); it != _inputAudioFramesBuffer.end(); ++it)
+    for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFrameBuffers.begin(); it != _inputAudioFrameBuffers.end(); ++it)
     {
         if(it->isEmpty())
             return false;
@@ -179,17 +179,10 @@ bool FilterGraph::hasBufferedFrames()
 
 bool FilterGraph::hasBufferedFrames(const size_t index)
 {
-    if(index >= _inputAudioFramesBuffer.size())
+    if(index >= _inputAudioFrameBuffers.size())
         return false;
 
-    return !_inputAudioFramesBuffer.at(index).isEmpty();
-}
-
-bool FilterGraph::areInputAudioFrames(const std::vector<IFrame*>& inputs)
-{
-    if(!inputs.size())
-        return false;
-    return typeid(*(inputs.at(0))) == typeid(AudioFrame);
+    return !_inputAudioFrameBuffers.at(index).isEmpty();
 }
 
 bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)
@@ -208,10 +201,10 @@ bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)
 
 bool FilterGraph::areFrameBuffersEmpty()
 {
-    if(!_inputAudioFramesBuffer.size())
+    if(!_inputAudioFrameBuffers.size())
         return true;
 
-    for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFramesBuffer.begin(); it != _inputAudioFramesBuffer.end(); ++it)
+    for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFrameBuffers.begin(); it != _inputAudioFrameBuffers.end(); ++it)
     {
         if(!it->isEmpty())
             return false;
@@ -226,7 +219,7 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)
         init(inputs, output);
 
     // Check whether we can bypass the input audio buffers
-    const bool bypassBuffers = !areInputAudioFrames(inputs) || (areInputFrameSizesEqual(inputs) && areFrameBuffersEmpty());
+    const bool bypassBuffers = _inputAudioFrameBuffers.empty() || (areInputFrameSizesEqual(inputs) && areFrameBuffersEmpty());
     size_t minInputFrameSize = 0;
 
     if(!bypassBuffers)
@@ -236,10 +229,10 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)
         {
             if(!inputs.at(index)->getDataSize())
             {
-                LOG_DEBUG("Empty frame from filter graph input " << index << ". Remaining audio frames in buffer: " << _inputAudioFramesBuffer.at(index).getBufferSize());
+                LOG_DEBUG("Empty frame from filter graph input " << index << ". Remaining audio frames in buffer: " << _inputAudioFrameBuffers.at(index).getBufferSize());
                 continue;
             }
-            _inputAudioFramesBuffer.at(index).addFrame(inputs.at(index));
+            _inputAudioFrameBuffers.at(index).addFrame(inputs.at(index));
         }
 
         // Get the minimum input frames size
@@ -251,7 +244,7 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)
     for(size_t index = 0; index < inputs.size(); ++index)
     {
         // Retrieve frame from buffer or directly from input
-        IFrame* inputFrame = (bypassBuffers)? inputs.at(index) : _inputAudioFramesBuffer.at(index).getFrame(minInputFrameSize);
+        IFrame* inputFrame = (bypassBuffers)? inputs.at(index) : _inputAudioFrameBuffers.at(index).getFrame(minInputFrameSize);
         const int ret = av_buffersrc_add_frame_flags(_filters.at(index)->getAVFilterContext(), &inputFrame->getAVFrame(), AV_BUFFERSRC_FLAG_PUSH);
 
         if(ret < 0)
@@ -363,7 +356,7 @@ void FilterGraph::addInBuffer(const std::vector<IFrame*>& inputs)
             const AudioFrameDesc audioFrameDesc(audioFrame->getSampleRate(),
                                                 audioFrame->getNbChannels(),
                                                 getSampleFormatName(audioFrame->getSampleFormat()));
-            _inputAudioFramesBuffer.push_back(AudioFramebuffer(audioFrameDesc));
+            _inputAudioFrameBuffers.push_back(AudioFramebuffer(audioFrameDesc));
         }
         // video frame
         else if((*it)->isVideoFrame())
diff --git a/src/AvTranscoder/filter/FilterGraph.hpp b/src/AvTranscoder/filter/FilterGraph.hpp
@@ -143,7 +143,6 @@ class AvExport FilterGraph
      */
     size_t getMinInputFrameSize(const std::vector<IFrame*>& inputs);
 
-    bool areInputAudioFrames(const std::vector<IFrame*>& inputs);
     bool areInputFrameSizesEqual(const std::vector<IFrame*>& inputs);
     bool areFrameBuffersEmpty();
 
@@ -152,7 +151,7 @@ class AvExport FilterGraph
     std::vector<Filter*> _filters; ///< List of filters to process.
     const ICodec& _codec;          ///< Codec of the stream on which the filters will be applied.
 
-    std::vector<AudioFramebuffer> _inputAudioFramesBuffer;
+    std::vector<AudioFramebuffer> _inputAudioFrameBuffers;
 
     /**
      * @brief Is the FilterGraph initialized.

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ FilterGraph::FilterGraph(const ICodec& codec)`
`133`	`133`
`134`	`134`	`FilterGraph::~FilterGraph()`
`135`	`135`	`{`
`136`		`- _inputAudioFramesBuffer.clear();`
	`136`	`+ _inputAudioFrameBuffers.clear();`
`137`	`137`	`for(std::vector<Filter*>::iterator it = _filters.begin(); it < _filters.end(); ++it)`
`138`	`138`	`{`
`139`	`139`	`delete(*it);`
`@@ -145,7 +145,7 @@ size_t FilterGraph::getAvailableFrameSize(const std::vector<IFrame*>& inputs, co`
`145`	`145`	`{`
`146`	`146`	`size_t frameSize = inputs.at(index)->getDataSize();`
`147`	`147`	`if(frameSize == 0)`
`148`		`- frameSize = _inputAudioFramesBuffer.at(index).getDataSize();`
	`148`	`+ frameSize = _inputAudioFrameBuffers.at(index).getDataSize();`
`149`	`149`	`return frameSize;`
`150`	`150`	`}`
`151`	`151`
`@@ -166,10 +166,10 @@ size_t FilterGraph::getMinInputFrameSize(const std::vector<IFrame*>& inputs)`
`166`	`166`
`167`	`167`	`bool FilterGraph::hasBufferedFrames()`
`168`	`168`	`{`
`169`		`- if(!_inputAudioFramesBuffer.size())`
	`169`	`+ if(!_inputAudioFrameBuffers.size())`
`170`	`170`	`return false;`
`171`	`171`
`172`		`- for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFramesBuffer.begin(); it != _inputAudioFramesBuffer.end(); ++it)`
	`172`	`+ for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFrameBuffers.begin(); it != _inputAudioFrameBuffers.end(); ++it)`
`173`	`173`	`{`
`174`	`174`	`if(it->isEmpty())`
`175`	`175`	`return false;`
`@@ -179,17 +179,10 @@ bool FilterGraph::hasBufferedFrames()`
`179`	`179`
`180`	`180`	`bool FilterGraph::hasBufferedFrames(const size_t index)`
`181`	`181`	`{`
`182`		`- if(index >= _inputAudioFramesBuffer.size())`
	`182`	`+ if(index >= _inputAudioFrameBuffers.size())`
`183`	`183`	`return false;`
`184`	`184`
`185`		`- return !_inputAudioFramesBuffer.at(index).isEmpty();`
`186`		`-}`
`187`		`-`
`188`		`-bool FilterGraph::areInputAudioFrames(const std::vector<IFrame*>& inputs)`
`189`		`-{`
`190`		`- if(!inputs.size())`
`191`		`- return false;`
`192`		`- return typeid(*(inputs.at(0))) == typeid(AudioFrame);`
	`185`	`+ return !_inputAudioFrameBuffers.at(index).isEmpty();`
`193`	`186`	`}`
`194`	`187`
`195`	`188`	`bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)`
`@@ -208,10 +201,10 @@ bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)`
`208`	`201`
`209`	`202`	`bool FilterGraph::areFrameBuffersEmpty()`
`210`	`203`	`{`
`211`		`- if(!_inputAudioFramesBuffer.size())`
	`204`	`+ if(!_inputAudioFrameBuffers.size())`
`212`	`205`	`return true;`
`213`	`206`
`214`		`- for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFramesBuffer.begin(); it != _inputAudioFramesBuffer.end(); ++it)`
	`207`	`+ for(std::vector<AudioFramebuffer>::iterator it = _inputAudioFrameBuffers.begin(); it != _inputAudioFrameBuffers.end(); ++it)`
`215`	`208`	`{`
`216`	`209`	`if(!it->isEmpty())`
`217`	`210`	`return false;`
`@@ -226,7 +219,7 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)`
`226`	`219`	`init(inputs, output);`
`227`	`220`
`228`	`221`	`// Check whether we can bypass the input audio buffers`
`229`		`- const bool bypassBuffers = !areInputAudioFrames(inputs) \|\| (areInputFrameSizesEqual(inputs) && areFrameBuffersEmpty());`
	`222`	`+ const bool bypassBuffers = _inputAudioFrameBuffers.empty() \|\| (areInputFrameSizesEqual(inputs) && areFrameBuffersEmpty());`
`230`	`223`	`size_t minInputFrameSize = 0;`
`231`	`224`
`232`	`225`	`if(!bypassBuffers)`
`@@ -236,10 +229,10 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)`
`236`	`229`	`{`
`237`	`230`	`if(!inputs.at(index)->getDataSize())`
`238`	`231`	`{`
`239`		`- LOG_DEBUG("Empty frame from filter graph input " << index << ". Remaining audio frames in buffer: " << _inputAudioFramesBuffer.at(index).getBufferSize());`
	`232`	`+ LOG_DEBUG("Empty frame from filter graph input " << index << ". Remaining audio frames in buffer: " << _inputAudioFrameBuffers.at(index).getBufferSize());`
`240`	`233`	`continue;`
`241`	`234`	`}`
`242`		`- _inputAudioFramesBuffer.at(index).addFrame(inputs.at(index));`
	`235`	`+ _inputAudioFrameBuffers.at(index).addFrame(inputs.at(index));`
`243`	`236`	`}`
`244`	`237`
`245`	`238`	`// Get the minimum input frames size`
`@@ -251,7 +244,7 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)`
`251`	`244`	`for(size_t index = 0; index < inputs.size(); ++index)`
`252`	`245`	`{`
`253`	`246`	`// Retrieve frame from buffer or directly from input`
`254`		`- IFrame* inputFrame = (bypassBuffers)? inputs.at(index) : _inputAudioFramesBuffer.at(index).getFrame(minInputFrameSize);`
	`247`	`+ IFrame* inputFrame = (bypassBuffers)? inputs.at(index) : _inputAudioFrameBuffers.at(index).getFrame(minInputFrameSize);`
`255`	`248`	`const int ret = av_buffersrc_add_frame_flags(_filters.at(index)->getAVFilterContext(), &inputFrame->getAVFrame(), AV_BUFFERSRC_FLAG_PUSH);`
`256`	`249`
`257`	`250`	`if(ret < 0)`
`@@ -363,7 +356,7 @@ void FilterGraph::addInBuffer(const std::vector<IFrame*>& inputs)`
`363`	`356`	`const AudioFrameDesc audioFrameDesc(audioFrame->getSampleRate(),`
`364`	`357`	`audioFrame->getNbChannels(),`
`365`	`358`	`getSampleFormatName(audioFrame->getSampleFormat()));`
`366`		`- _inputAudioFramesBuffer.push_back(AudioFramebuffer(audioFrameDesc));`
	`359`	`+ _inputAudioFrameBuffers.push_back(AudioFramebuffer(audioFrameDesc));`
`367`	`360`	`}`
`368`	`361`	`// video frame`
`369`	`362`	`else if((*it)->isVideoFrame())`