avTranscoder · valnoel · Nov 3, 2016 · Oct 26, 2016 · Oct 26, 2016 · Oct 26, 2016
diff --git a/app/avProcessor/avProcessor.cpp b/app/avProcessor/avProcessor.cpp
@@ -28,7 +28,7 @@ void parseConfigFile(const std::string& configFilename, avtranscoder::Transcoder
 
                 std::stringstream ss(streamId);
                 size_t streamIndex = 0;
-                char separator;
+                char separator = 'x';
                 std::vector<size_t> channelIndexArray;
                 ss >> streamIndex;
                 ss >> separator;

diff --git a/src/AvTranscoder/codec/AudioCodec.cpp b/src/AvTranscoder/codec/AudioCodec.cpp
@@ -1,5 +1,7 @@
 #include "AudioCodec.hpp"
 
+#include <AvTranscoder/util.hpp>
+
 #include <cmath>
 #include <cassert>
 
@@ -24,7 +26,7 @@ AudioCodec::AudioCodec(const ECodecType type, AVCodecContext& avCodecContext)
 AudioFrameDesc AudioCodec::getAudioFrameDesc() const
 {
     assert(_avCodecContext != NULL);
-    return AudioFrameDesc(_avCodecContext->sample_rate, _avCodecContext->channels, _avCodecContext->sample_fmt);
+    return AudioFrameDesc(_avCodecContext->sample_rate, _avCodecContext->channels, getSampleFormatName(_avCodecContext->sample_fmt));
 }
 
 void AudioCodec::setAudioParameters(const AudioFrameDesc& audioFrameDesc)

diff --git a/src/AvTranscoder/codec/ICodec.cpp b/src/AvTranscoder/codec/ICodec.cpp
@@ -49,7 +49,7 @@ ICodec::~ICodec()
     if(!_isCodecContextAllocated)
         return;
 
-    av_free(_avCodecContext);
+    avcodec_free_context(&_avCodecContext);
     _avCodecContext = NULL;
 }
 
@@ -148,7 +148,8 @@ void ICodec::allocateContext()
     _avCodecContext = avcodec_alloc_context3(_avCodec);
     if(!_avCodecContext)
     {
-        throw std::runtime_error("Unable to allocate the codecContext and set its fields to default values");
+        LOG_ERROR("Unable to allocate the codecContext and set its fields to default values.")
+        throw std::bad_alloc();
     }
     _avCodecContext->codec = _avCodec;
 }

diff --git a/src/AvTranscoder/codec/VideoCodec.cpp b/src/AvTranscoder/codec/VideoCodec.cpp
@@ -1,5 +1,7 @@
 #include "VideoCodec.hpp"
 
+#include <AvTranscoder/util.hpp>
+
 #include <cmath>
 #include <cassert>
 
@@ -24,7 +26,7 @@ VideoCodec::VideoCodec(const ECodecType type, AVCodecContext& avCodecContext)
 VideoFrameDesc VideoCodec::getVideoFrameDesc() const
 {
     assert(_avCodecContext != NULL);
-    VideoFrameDesc videoFrameDesc(_avCodecContext->width, _avCodecContext->height, _avCodecContext->pix_fmt);
+    VideoFrameDesc videoFrameDesc(_avCodecContext->width, _avCodecContext->height, getPixelFormatName(_avCodecContext->pix_fmt));
     double fps = 1.0 * _avCodecContext->time_base.den / (_avCodecContext->time_base.num * _avCodecContext->ticks_per_frame);
     if(!std::isinf(fps))
         videoFrameDesc._fps = fps;

diff --git a/src/AvTranscoder/data/coded/CodedData.cpp b/src/AvTranscoder/data/coded/CodedData.cpp
@@ -14,7 +14,12 @@ CodedData::CodedData()
 CodedData::CodedData(const size_t dataSize)
     : _avStream(NULL)
 {
-    av_new_packet(&_packet, dataSize);
+    const int err = av_new_packet(&_packet, dataSize);
+    if(err != 0)
+    {
+        LOG_ERROR("Unable to allocate the payload of a packet and initialize its fields with default values: " << getDescriptionFromErrorCode(err))
+        throw std::bad_alloc();
+    }
 }
 
 CodedData::CodedData(const AVPacket& avPacket)

diff --git a/src/AvTranscoder/data/data.i b/src/AvTranscoder/data/data.i
@@ -2,12 +2,12 @@
 
 %{
 #include <AvTranscoder/data/coded/CodedData.hpp>
-#include <AvTranscoder/data/decoded/Frame.hpp>
+#include <AvTranscoder/data/decoded/IFrame.hpp>
 #include <AvTranscoder/data/decoded/VideoFrame.hpp>
 #include <AvTranscoder/data/decoded/AudioFrame.hpp>
 %}
 
 %include <AvTranscoder/data/coded/CodedData.hpp>
-%include <AvTranscoder/data/decoded/Frame.hpp>
+%include <AvTranscoder/data/decoded/IFrame.hpp>
 %include <AvTranscoder/data/decoded/VideoFrame.hpp>
 %include <AvTranscoder/data/decoded/AudioFrame.hpp>
diff --git a/src/AvTranscoder/data/decoded/AudioFrame.cpp b/src/AvTranscoder/data/decoded/AudioFrame.cpp
@@ -12,18 +12,19 @@ extern "C" {
 namespace avtranscoder
 {
 
-AudioFrameDesc::AudioFrameDesc(const size_t sampleRate, const size_t nbChannels, const AVSampleFormat sampleFormat)
+AudioFrameDesc::AudioFrameDesc(const size_t sampleRate, const size_t nbChannels, const std::string& sampleFormatName)
     : _sampleRate(sampleRate)
     , _nbChannels(nbChannels)
-    , _sampleFormat(sampleFormat)
+    , _sampleFormat(getAVSampleFormat(sampleFormatName))
 {
 }
 
-AudioFrameDesc::AudioFrameDesc(const size_t sampleRate, const size_t nbChannels, const std::string& sampleFormatName)
-    : _sampleRate(sampleRate)
-    , _nbChannels(nbChannels)
-    , _sampleFormat(getAVSampleFormat(sampleFormatName))
+AudioFrameDesc::AudioFrameDesc(const ProfileLoader::Profile& profile)
+    : _sampleRate(0)
+    , _nbChannels(0)
+    , _sampleFormat(AV_SAMPLE_FMT_NONE)
 {
+    setParameters(profile);
 }
 
 void AudioFrameDesc::setParameters(const ProfileLoader::Profile& profile)
@@ -39,15 +40,19 @@ void AudioFrameDesc::setParameters(const ProfileLoader::Profile& profile)
         _sampleFormat = getAVSampleFormat(profile.find(constants::avProfileSampleFormat)->second.c_str());
 }
 
-AudioFrame::AudioFrame(const AudioFrameDesc& ref)
-    : Frame()
+AudioFrame::AudioFrame(const AudioFrameDesc& desc, const bool forceDataAllocation)
+    : IFrame()
+    , _desc(desc)
 {
-    allocateAVSample(ref);
-}
+    // Set Frame properties
+    av_frame_set_sample_rate(_frame, desc._sampleRate);
+    av_frame_set_channels(_frame, desc._nbChannels);
+    av_frame_set_channel_layout(_frame, av_get_default_channel_layout(desc._nbChannels));
+    _frame->format = desc._sampleFormat;
+    _frame->nb_samples = getDefaultNbSamples();
 
-AudioFrame::AudioFrame(const Frame& otherFrame)
-    : Frame(otherFrame)
-{
+    if(forceDataAllocation)
+        allocateData();
 }
 
 std::string AudioFrame::getChannelLayoutDesc() const
@@ -57,75 +62,95 @@ std::string AudioFrame::getChannelLayoutDesc() const
     return std::string(buf);
 }
 
-size_t AudioFrame::getSize() const
+AudioFrame::~AudioFrame()
+{
+    if(_frame->buf[0])
+        av_frame_unref(_frame);
+    if(_dataAllocated)
+        freeData();
+}
+
+size_t AudioFrame::getBytesPerSample() const
+{
+    return av_get_bytes_per_sample(getSampleFormat());
+}
+
+size_t AudioFrame::getDataSize() const
 {
     if(getSampleFormat() == AV_SAMPLE_FMT_NONE)
     {
         LOG_WARN("Incorrect sample format when get size of audio frame: return a size of 0.")
         return 0;
     }
 
-    const size_t size = getNbSamplesPerChannel() * getNbChannels() * av_get_bytes_per_sample(getSampleFormat());
+    const size_t size = getNbSamplesPerChannel() * getNbChannels() * getBytesPerSample();
     if(size == 0)
     {
         std::stringstream msg;
         msg << "Unable to determine audio buffer size:" << std::endl;
         msg << "nb sample per channel = " << getNbSamplesPerChannel() << std::endl;
         msg << "channels = " << getNbChannels() << std::endl;
-        msg << "bytes per sample = " << av_get_bytes_per_sample(getSampleFormat()) << std::endl;
+        msg << "bytes per sample = " << getBytesPerSample() << std::endl;
         throw std::runtime_error(msg.str());
     }
     return size;
 }
 
-void AudioFrame::allocateAVSample(const AudioFrameDesc& desc)
+void AudioFrame::allocateData()
 {
+    if(_dataAllocated)
+        LOG_WARN("The AudioFrame seems to already have allocated data. This could lead to memory leaks.")
+
     // Set Frame properties
-    av_frame_set_sample_rate(_frame, desc._sampleRate);
-    av_frame_set_channels(_frame, desc._nbChannels);
-    av_frame_set_channel_layout(_frame, av_get_default_channel_layout(desc._nbChannels));
-    _frame->format = desc._sampleFormat;
-    _frame->nb_samples = desc._sampleRate / 25.; // cannot be known before calling avcodec_decode_audio4
+    av_frame_set_sample_rate(_frame, _desc._sampleRate);
+    av_frame_set_channels(_frame, _desc._nbChannels);
+    av_frame_set_channel_layout(_frame, av_get_default_channel_layout(_desc._nbChannels));
+    _frame->format = _desc._sampleFormat;
+    if(_frame->nb_samples == 0)
+        _frame->nb_samples = getDefaultNbSamples();
 
     // Allocate data
     const int align = 0;
     const int ret =
-        av_samples_alloc(_frame->data, _frame->linesize, _frame->channels, _frame->nb_samples, desc._sampleFormat, align);
+        av_samples_alloc(_frame->data, _frame->linesize, _frame->channels, _frame->nb_samples, _desc._sampleFormat, align);
     if(ret < 0)
     {
-        std::stringstream os;
-        os << "Unable to allocate an audio frame of ";
-        os << "sample rate = " << _frame->sample_rate << ", ";
-        os << "nb channels = " << _frame->channels << ", ";
-        os << "channel layout = " << av_get_channel_name(_frame->channels) << ", ";
-        os << "nb samples = " << _frame->nb_samples << ", ";
-        os << "sample format = " << getSampleFormatName(desc._sampleFormat);
-        throw std::runtime_error(os.str());
+        const std::string formatName = getSampleFormatName(_desc._sampleFormat);
+        std::stringstream msg;
+        msg << "Unable to allocate an audio frame of ";
+        msg << "sample rate = " << _frame->sample_rate << ", ";
+        msg << "nb channels = " << _frame->channels << ", ";
+        msg << "channel layout = " << av_get_channel_name(_frame->channels) << ", ";
+        msg << "nb samples = " << _frame->nb_samples << ", ";
+        msg << "sample format = " << (formatName.empty() ? "none" : formatName);
+        LOG_ERROR(msg.str())
+        throw std::bad_alloc();
     }
+    _dataAllocated = true;
 }
 
-void AudioFrame::assign(const unsigned char value)
+void AudioFrame::freeData()
 {
-    // Create the audio buffer
-    // The buffer will be freed in destructor of based class
-    const int audioSize = getSize();
-    unsigned char* audioBuffer = new unsigned char[audioSize];
-    memset(audioBuffer, value, audioSize);
-
-    // Fill the picture
-    assign(audioBuffer);
+    av_freep(&_frame->data[0]);
+    _dataAllocated = false;
 }
 
-void AudioFrame::assign(const unsigned char* ptrValue)
+void AudioFrame::assignBuffer(const unsigned char* ptrValue)
 {
     const int align = 0;
     const int ret = av_samples_fill_arrays(_frame->data, _frame->linesize, ptrValue, getNbChannels(),
                                            getNbSamplesPerChannel(), getSampleFormat(), align);
     if(ret < 0)
     {
-        std::stringstream os;
-        os << "Unable to assign an audio buffer: " << getDescriptionFromErrorCode(ret);
-        throw std::runtime_error(os.str());
+        std::stringstream msg;
+        msg << "Unable to assign an audio buffer: " << getDescriptionFromErrorCode(ret);
+        throw std::runtime_error(msg.str());
     }
 }
+
+size_t AudioFrame::getDefaultNbSamples() const
+{
+    return _desc._sampleRate / 25.;
+}
+
 }
diff --git a/src/AvTranscoder/data/decoded/AudioFrame.hpp b/src/AvTranscoder/data/decoded/AudioFrame.hpp
@@ -1,7 +1,7 @@
 #ifndef _AV_TRANSCODER_FRAME_AUDIO_FRAME_HPP_
 #define _AV_TRANSCODER_FRAME_AUDIO_FRAME_HPP_
 
-#include "Frame.hpp"
+#include "IFrame.hpp"
 #include <AvTranscoder/profile/ProfileLoader.hpp>
 
 namespace avtranscoder
@@ -14,9 +14,8 @@ namespace avtranscoder
 struct AvExport AudioFrameDesc
 {
 public:
-    AudioFrameDesc(const size_t sampleRate = 0, const size_t channels = 0,
-                   const AVSampleFormat sampleFormat = AV_SAMPLE_FMT_NONE);
     AudioFrameDesc(const size_t sampleRate, const size_t channels, const std::string& sampleFormatName);
+    AudioFrameDesc(const ProfileLoader::Profile& profile);
 
     /**
      * @brief Set the attributes from the given profile.
@@ -33,50 +32,59 @@ struct AvExport AudioFrameDesc
 /**
  * @brief This class describes decoded audio data.
  */
-class AvExport AudioFrame : public Frame
+class AvExport AudioFrame : public IFrame
 {
+private:
+    AudioFrame(const AudioFrame& otherFrame);
+    AudioFrame& operator=(const AudioFrame& otherFrame);
+
 public:
+    AudioFrame(const AudioFrameDesc& desc, const bool forceDataAllocation = true);
+    ~AudioFrame();
+
     /**
-     * @note Allocated data will be initialized to silence.
+     * @brief Allocated data will be initialized to silence.
+     * @warning The allocated data should be freed by the caller.
+     * @see freeData
      */
-    AudioFrame(const AudioFrameDesc& ref);
-    AudioFrame(const Frame& otherFrame);
+    void allocateData();
+    void freeData();
+    size_t getDataSize() const;
 
     size_t getSampleRate() const { return av_frame_get_sample_rate(_frame); }
     size_t getNbChannels() const { return av_frame_get_channels(_frame); }
     size_t getChannelLayout() const { return av_frame_get_channel_layout(_frame); }
     std::string getChannelLayoutDesc() const; ///< Get a description of a channel layout (example: '5.1').
     AVSampleFormat getSampleFormat() const { return static_cast<AVSampleFormat>(_frame->format); }
+    size_t getBytesPerSample() const;  ///< 0 if unknown sample format
     size_t getNbSamplesPerChannel() const { return _frame->nb_samples; }
-    AudioFrameDesc desc() const { return AudioFrameDesc(getSampleRate(), getNbChannels(), getSampleFormat()); }
-
-    size_t getSize() const; ///< in bytes
-
-    void setNbSamplesPerChannel(const size_t nbSamples) { _frame->nb_samples = nbSamples; }
 
     /**
-     * @brief Assign the given value to all the data of the audio frame.
+     * @brief This methods dynamically updates the size that the data buffer would occupy if allocated.
+     * @warning If the data buffer is already allocated, this could lead to memory leaks or seg fault.
      */
-    void assign(const unsigned char value);
+    void setNbSamplesPerChannel(const size_t nbSamples) { _frame->nb_samples = nbSamples; }
 
-    /**
-     * @brief Assign the given ptr of data to the data of the audio frame.
-     * @warning the given ptr should have the size of the audio frame..
-     * @see getSize
-     */
-    void assign(const unsigned char* ptrValue);
+    void assignBuffer(const unsigned char* ptrValue);
 
 private:
     /**
-     * @brief Allocate the audio buffer of the frame.
+     * @brief The number of samples of a frame cannot be known before calling avcodec_decode_audio4,
+     * and can be variable in a same stream. Because we need to allocate some frames without knowing this parameter,
+     * we access here a default number of samples.
+     * @note This value depends on the sample rate (example: 1920 samples at 48kHz).
+     * @return the number of samples of our default AudioFrame.
+     * @see setNbSamplesPerChannel
      */
-    void allocateAVSample(const AudioFrameDesc& ref);
+    size_t getDefaultNbSamples() const;
 
+private:
     /**
-     * @note To allocate new audio buffer if needed.
-     * @see allocateAVSample
+     * @brief Description of the frame to allocate.
+     * @warning This description could be different from the current frame (a decoder could have reseted it).
+     * We need to keep this description to allocate again the frame even if it was reseted.
      */
-    friend class AudioGenerator;
+    const AudioFrameDesc _desc;
 };
 }