AudioFrameBuffer::AudioFrameBuffer(const AudioFrameDesc& audioFrameDesc)

: _audioFrameDesc(audioFrameDesc)

, _frameQueue()

, _totalDataSize(0)

, _positionInFrontFrame(0)

{

}

AudioFrameBuffer::~AudioFrameBuffer()

{

for(size_t i = 0; i < _frameQueue.size(); ++i)

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);

// Copy the input frame to store it into the queue

AudioFrame* newAudioFrame = new AudioFrame(_audioFrameDesc, false);

const size_t expectedNbSamples = frame->getDataSize() / (newAudioFrame->getNbChannels() * newAudioFrame->getBytesPerSample());

newAudioFrame->setNbSamplesPerChannel(expectedNbSamples);

newAudioFrame->allocateData();

newAudioFrame->copyData(*frame);

_totalDataSize += newAudioFrame->getDataSize();

_frameQueue.push(newAudioFrame);

}

void AudioFrameBuffer::popFrame()

{

_frameQueue.pop();

LOG_DEBUG("Pop frame from buffer. Remaining frames in buffer: " << _frameQueue.size());

}

IFrame* AudioFrameBuffer::getFrame(const size_t size)

{

LOG_DEBUG("Get a " << size << " bytes frame from a " << _totalDataSize << " bytes frame buffer");

IFrame* next = _frameQueue.front();

const size_t nextFrameSize = next->getDataSize();

// If no expected size, or if the expected size equals the front frame of the queue (with no offset)

if(size == 0 || (size == nextFrameSize && _positionInFrontFrame == 0))

{

// Directly return the front frame of the queue

_totalDataSize -= nextFrameSize;

popFrame();

return next;

}

// Create a new frame

AudioFrame* newAudioFrame = new AudioFrame(_audioFrameDesc, false);

const size_t expectedNbSamples = size / (newAudioFrame->getNbChannels() * newAudioFrame->getBytesPerSample());

newAudioFrame->setNbSamplesPerChannel(expectedNbSamples);

newAudioFrame->allocateData();

// Concatenate frames data

size_t extractedDataSize = 0;

unsigned char* outputData = new unsigned char[size];

while(extractedDataSize != size && _frameQueue.size() != 0)

{

// Get the front frame from queue

next = _frameQueue.front();

size_t remainingDataInFrontFrame = next->getDataSize() - _positionInFrontFrame;

// Compute the data size to get from the frame

size_t dataToGet = size - extractedDataSize;

if(dataToGet > remainingDataInFrontFrame)

dataToGet = remainingDataInFrontFrame;

// Copy the data from the frame to temporal buffer

for(size_t i = 0; i < dataToGet; i++)

outputData[extractedDataSize++] = next->getData()[0][_positionInFrontFrame + i];

if(dataToGet < remainingDataInFrontFrame)

{

// Set new position into front frame

_positionInFrontFrame += dataToGet;

}

else

{

// The whole front frame has been read, so pop it from queue

popFrame();

_positionInFrontFrame = 0;

}

}

_totalDataSize -= extractedDataSize;

newAudioFrame->assignBuffer(outputData);

return newAudioFrame;

}

IFrame* AudioFrameBuffer::getFrameSampleNb(const size_t sampleNb)

{

const size_t expectedSize = sampleNb * getBytesPerSample();

return getFrame(expectedSize);

}

_inputAudioFrameBuffers.clear();

size_t FilterGraph::getAvailableFrameSize(const std::vector<IFrame*>& inputs, const size_t& index)

{

size_t frameSize = inputs.at(index)->getDataSize();

if(frameSize == 0)

frameSize = _inputAudioFrameBuffers.at(index).getDataSize();

return frameSize;

}

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 minFrameSamplesNb = getAvailableFrameSamplesNb(inputs, 0);

for(size_t index = 1; index < inputs.size(); ++index)

{

const size_t availableFrameSampleNb = getAvailableFrameSamplesNb(inputs, index);

if(minFrameSamplesNb > availableFrameSampleNb)

minFrameSamplesNb = availableFrameSampleNb;

}

return minFrameSamplesNb;

}

bool FilterGraph::hasBufferedFrames()

{

if(!_inputAudioFrameBuffers.size())

return false;

for(std::vector<AudioFrameBuffer>::iterator it = _inputAudioFrameBuffers.begin(); it != _inputAudioFrameBuffers.end(); ++it)

{

if(it->isEmpty())

return false;

}

return true;

}

bool FilterGraph::hasBufferedFrames(const size_t index)

{

if(index >= _inputAudioFrameBuffers.size())

return false;

return !_inputAudioFrameBuffers.at(index).isEmpty();

}

bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)

{

if(!inputs.size() || inputs.size() == 1)

return true;

const int frameSize = inputs.at(0)->getDataSize();

for(size_t index = 1; index < inputs.size(); ++index)

{

if(frameSize != inputs.at(index)->getDataSize())

{

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;

}

bool FilterGraph::areFrameBuffersEmpty()

{

if(!_inputAudioFrameBuffers.size())

return true;

for(std::vector<AudioFrameBuffer>::iterator it = _inputAudioFrameBuffers.begin(); it != _inputAudioFrameBuffers.end(); ++it)

{

if(!it->isEmpty())

return false;

}

return true;

}

// Init the filter graph

// Check whether we can bypass the input audio buffers

const bool bypassBuffers = _inputAudioFrameBuffers.empty() || (areInputFrameSizesEqual(inputs) && areFrameBuffersEmpty());

size_t minInputFrameSamplesNb = 0;

if(!bypassBuffers)

{

// Fill the frame buffer with inputs

for(size_t index = 0; index < inputs.size(); ++index)

{

if(!inputs.at(index)->getDataSize())

{

LOG_DEBUG("Empty frame from filter graph input " << index << ". Remaining audio frames in buffer: " << _inputAudioFrameBuffers.at(index).getBufferSize());

continue;

}

_inputAudioFrameBuffers.at(index).addFrame(inputs.at(index));

}

// Get the minimum input frames size

minInputFrameSamplesNb = getMinInputFrameSamplesNb(inputs);

}

// Setup input frames into the filter graph

// Retrieve frame from buffer or directly from input

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);

// Pull filtered data from the filter graph

const AudioFrameDesc audioFrameDesc(audioFrame->getSampleRate(),

audioFrame->getNbChannels(),

getSampleFormatName(audioFrame->getSampleFormat()));

_inputAudioFrameBuffers.insert(_inputAudioFrameBuffers.begin(), AudioFrameBuffer(audioFrameDesc));