FilterGraph: fix audio frames management with different sample formats

Valentin NOEL · Valentin NOEL · commit 2dcdc1c04284 · 2017-09-08T14:07:44.000+02:00
Comparing the frame sizes in samples (instead of bytes)
diff --git a/src/AvTranscoder/filter/FilterGraph.cpp b/src/AvTranscoder/filter/FilterGraph.cpp
@@ -36,6 +36,11 @@ AudioFrameBuffer::~AudioFrameBuffer()
         popFrame();
 }
 
+size_t AudioFrameBuffer::getBytesPerSample()
+{
+    return av_get_bytes_per_sample(_audioFrameDesc._sampleFormat);
+}
+
 void AudioFrameBuffer::addFrame(IFrame* frame)
 {
     LOG_DEBUG("Add a new " << frame->getDataSize() << " bytes frame to frame buffer. New buffer size: " << _frameQueue.size() + 1);
@@ -113,6 +118,12 @@ IFrame* AudioFrameBuffer::getFrame(const size_t size)
     return newAudioFrame;
 }
 
+IFrame* AudioFrameBuffer::getFrameSampleNb(const size_t sampleNb)
+{
+    const size_t expectedSize = sampleNb * getBytesPerSample();
+    return getFrame(expectedSize);
+}
+
 
 
 /******************
@@ -149,19 +160,29 @@ size_t FilterGraph::getAvailableFrameSize(const std::vector<IFrame*>& inputs, co
     return frameSize;
 }
 
-size_t FilterGraph::getMinInputFrameSize(const std::vector<IFrame*>& inputs)
+size_t FilterGraph::getAvailableFrameSamplesNb(const std::vector<IFrame*>& inputs, const size_t& index)
+{
+    if(_inputAudioFrameBuffers.empty())
+        throw std::runtime_error("Cannot compute filter graph input samples number for non-audio frames.");
+
+    const size_t bytesPerSample = _inputAudioFrameBuffers.at(index).getBytesPerSample();
+    const size_t availableSamplesNb = getAvailableFrameSize(inputs, index) / bytesPerSample;
+    return availableSamplesNb;
+}
+
+size_t FilterGraph::getMinInputFrameSamplesNb(const std::vector<IFrame*>& inputs)
 {
     if(!inputs.size())
         return 0;
 
-    size_t minFrameSize = getAvailableFrameSize(inputs, 0);
+    size_t minFrameSamplesNb = getAvailableFrameSamplesNb(inputs, 0);
     for(size_t index = 1; index < inputs.size(); ++index)
     {
-        const size_t availableFrameSize = getAvailableFrameSize(inputs, index);
-        if(minFrameSize > availableFrameSize)
-            minFrameSize = availableFrameSize;
+        const size_t availableFrameSampleNb = getAvailableFrameSamplesNb(inputs, index);
+        if(minFrameSamplesNb > availableFrameSampleNb)
+            minFrameSamplesNb = availableFrameSampleNb;
     }
-    return minFrameSize;
+    return minFrameSamplesNb;
 }
 
 bool FilterGraph::hasBufferedFrames()
@@ -194,7 +215,16 @@ bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)
     for(size_t index = 1; index < inputs.size(); ++index)
     {
         if(frameSize != inputs.at(index)->getDataSize())
-            return false;
+        {
+            if(_inputAudioFrameBuffers.empty())
+                return false;
+            else
+            {
+                const size_t refSampleNb = frameSize / _inputAudioFrameBuffers.at(0).getBytesPerSample();
+                const size_t sampleNb = inputs.at(index)->getDataSize() / _inputAudioFrameBuffers.at(index).getBytesPerSample();
+                return (refSampleNb == sampleNb);
+            }
+        }
     }
     return true;
 }
@@ -220,7 +250,7 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)
 
     // Check whether we can bypass the input audio buffers
     const bool bypassBuffers = _inputAudioFrameBuffers.empty() || (areInputFrameSizesEqual(inputs) && areFrameBuffersEmpty());
-    size_t minInputFrameSize = 0;
+    size_t minInputFrameSamplesNb = 0;
 
     if(!bypassBuffers)
     {
@@ -236,15 +266,15 @@ void FilterGraph::process(const std::vector<IFrame*>& inputs, IFrame& output)
         }
 
         // Get the minimum input frames size
-        minInputFrameSize = getMinInputFrameSize(inputs);
+        minInputFrameSamplesNb = getMinInputFrameSamplesNb(inputs);
     }
 
 
     // Setup input frames into the filter graph
     for(size_t index = 0; index < inputs.size(); ++index)
     {
         // Retrieve frame from buffer or directly from input
-        IFrame* inputFrame = (bypassBuffers)? inputs.at(index) : _inputAudioFrameBuffers.at(index).getFrame(minInputFrameSize);
+        IFrame* inputFrame = (bypassBuffers)? inputs.at(index) : _inputAudioFrameBuffers.at(index).getFrameSampleNb(minInputFrameSamplesNb);
         const int ret = av_buffersrc_add_frame_flags(_filters.at(index)->getAVFilterContext(), &inputFrame->getAVFrame(), AV_BUFFERSRC_FLAG_PUSH);
 
         if(ret < 0)
diff --git a/src/AvTranscoder/filter/FilterGraph.hpp b/src/AvTranscoder/filter/FilterGraph.hpp
@@ -39,6 +39,10 @@ class AudioFrameBuffer
      * @brief Return the number of frames contained in the buffer.
      */
     size_t getBufferSize() const { return _frameQueue.size(); }
+    /**
+     * @brief Return the number of bytes by sample from the internal AudioFrameDesc.
+     */
+    size_t getBytesPerSample();
 
     /**
      * @brief Push a frame at the end of the buffer.
@@ -50,6 +54,7 @@ class AudioFrameBuffer
      * If no size is specified, the whole first IFrame pointer is returned.
      */
     IFrame* getFrame(const size_t size = 0);
+    IFrame* getFrameSampleNb(const size_t sampleNb);
 
 private:
     void popFrame();
@@ -138,10 +143,11 @@ class AvExport FilterGraph
      * @brief Return the input frame size if not null, or the available size into the corresponding frame buffer
      */
     size_t getAvailableFrameSize(const std::vector<IFrame*>& inputs, const size_t& index);
+    size_t getAvailableFrameSamplesNb(const std::vector<IFrame*>& inputs, const size_t& index);
     /**
-     * @brief Get the minimum size between input frames, or available frame buffers
+     * @brief Get the minimum samples number between input frames, or available frame buffers
      */
-    size_t getMinInputFrameSize(const std::vector<IFrame*>& inputs);
+    size_t getMinInputFrameSamplesNb(const std::vector<IFrame*>& inputs);
 
     bool areInputFrameSizesEqual(const std::vector<IFrame*>& inputs);
     bool areFrameBuffersEmpty();
