Создать аудиофайл и заполнить его полезной нагрузкой пакета RTP с помощью ffmpeg

Моя задача-извлечь полезную нагрузку пакета RTP и сохранить ее в виде аудио файла. В моем случае я получаю полезную нагрузку типа 8 (PCMA). Я обрабатываю пакеты RTP и храню всю полезную нагрузку в отдельном буфере. После этого, я должен обработать этот буфер и создать аудио файл. И тут появляется проблема :(

Во-первых, в спецификации написано, что в полезной нагрузке 8, звуковые образцы сохраняются в размере U8 (битрейт / тактовая частота = 64000 / 8000). Но я даже не могу найти декодер для такого размера выборки. В чем может быть проблема ?

Во-вторых, если я создаю синтетический звук, я не могу записать его в формате MKA.

В качестве шпаргалки я использую эту ссылку.

Основываясь на этом примере, я написал нечто подобное:

AudioGenerater.h

class AudioGenerater
{
public:

    enum AudioFormatType
    {
        AudioFormat_WAV,
        AudioFormat_MP3
    };

public:

    AudioGenerater();
   ~AudioGenerater() = default;

    void generateAudioFileWithOptions(
            QString        fileName,
            QByteArray     pcmData,
            AVCodecID      codecID,
            int            channel,
            int            bitRate,
            int            sampleRate,
            AVSampleFormat format);

private:

    // init Format
    bool initFormat(QString audioFileName);

private:

    AVCodec         *m_AudioCodec        = nullptr;
    AVCodecContext  *m_AudioCodecContext = nullptr;
    AVFormatContext *m_FormatContext     = nullptr;
    AVOutputFormat  *m_OutputFormat      = nullptr;
};

AudioGenerater.cpp

AudioGenerater::AudioGenerater()
{
    av_register_all();
    avcodec_register_all();
}

bool AudioGenerater::initFormat(QString audioFileName)
{
     // Create an output Format context
    int result = avformat_alloc_output_context2(&m_FormatContext, nullptr, nullptr, audioFileName.toLocal8Bit().data());
    if (result < 0) {
        return false;
    }

    m_OutputFormat = m_FormatContext->oformat;

     // Create an audio stream
    AVStream *audioStream = avformat_new_stream(m_FormatContext, m_AudioCodec);
    if (audioStream == nullptr) {
        avformat_free_context(m_FormatContext);
        return false;
    }

     // Set the parameters in the stream
    audioStream->id = m_FormatContext->nb_streams - 1;
    audioStream->time_base = { 1, 64000 };
    result = avcodec_parameters_from_context(audioStream->codecpar, m_AudioCodecContext);
    if (result < 0) {
        avformat_free_context(m_FormatContext);
        return false;
    }

     // Print FormatContext information
    av_dump_format(m_FormatContext, 0, audioFileName.toLocal8Bit().data(), 1);

     // Open file IO
    if (!(m_OutputFormat->flags & AVFMT_NOFILE)) {
        result = avio_open(&m_FormatContext->pb, audioFileName.toLocal8Bit().data(), AVIO_FLAG_WRITE);
        if (result < 0) {
            avformat_free_context(m_FormatContext);
            return false;
        }
    }

    return true;
}

void AudioGenerater::generateAudioFileWithOptions(
        QString _fileName,
        QByteArray _pcmData,
        AVCodecID _codecID,
        int _channel,
        int _bitRate,
        int _sampleRate,
        AVSampleFormat _format)
{
    AVCodecID codecID = _codecID;
    // Find Codec
    m_AudioCodec = avcodec_find_encoder(codecID);
    if (m_AudioCodec == nullptr) {
        return;
    }

     // Create an encoder context
    m_AudioCodecContext = avcodec_alloc_context3(m_AudioCodec);
    if (m_AudioCodecContext == nullptr){
        return;
    }

        // Setting parameters
    m_AudioCodecContext->bit_rate    = _bitRate;
    m_AudioCodecContext->sample_rate = _sampleRate;
    m_AudioCodecContext->sample_fmt  = _format;
    m_AudioCodecContext->channels    = _channel;


    m_AudioCodecContext->channel_layout = av_get_default_channel_layout(_channel);
    m_AudioCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

     // Turn on the encoder
    int result = avcodec_open2(m_AudioCodecContext, m_AudioCodec, nullptr);
    if (result < 0) {
        avcodec_free_context(&m_AudioCodecContext);
        if (m_FormatContext != nullptr)
            avformat_free_context(m_FormatContext);
        return;
    }

     // Create a package
    if (!initFormat(_fileName)) {
        avcodec_free_context(&m_AudioCodecContext);
        if (m_FormatContext != nullptr)
            avformat_free_context(m_FormatContext);
        return;
    }

     // write to the file header
    result = avformat_write_header(m_FormatContext, nullptr);
    if (result < 0) {
        avcodec_free_context(&m_AudioCodecContext);
        if (m_FormatContext != nullptr)
            avformat_free_context(m_FormatContext);
        return;
    }

     // Create Frame
    AVFrame *frame = av_frame_alloc();
    if (frame == nullptr) {
        avcodec_free_context(&m_AudioCodecContext);
        if (m_FormatContext != nullptr)
            avformat_free_context(m_FormatContext);
        return;
    }

    int nb_samples = 0;
    if (m_AudioCodecContext->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE) {
        nb_samples = 10000;
    }
    else {
        nb_samples = m_AudioCodecContext->frame_size;
    }

    // Set the parameters of the Frame
    frame->nb_samples = nb_samples;
    frame->format = m_AudioCodecContext->sample_fmt;
    frame->channel_layout = m_AudioCodecContext->channel_layout;

    // Apply for data memory
    result = av_frame_get_buffer(frame, 0);
    if (result < 0)
    {
        av_frame_free(&frame); {
            avcodec_free_context(&m_AudioCodecContext);
            if (m_FormatContext != nullptr)
                avformat_free_context(m_FormatContext);
            return;
        }
    }

    // Set the Frame to be writable
    result = av_frame_make_writable(frame);
    if (result < 0)
    {
        av_frame_free(&frame); {
            avcodec_free_context(&m_AudioCodecContext);
            if (m_FormatContext != nullptr)
                avformat_free_context(m_FormatContext);
            return;
        }
    }

    int perFrameDataSize = frame->linesize[0];
    int count = _pcmData.size() / perFrameDataSize;
    bool needAddOne = false;
    if (_pcmData.size() % perFrameDataSize != 0)
    {
        count++;
        needAddOne = true;
    }

    int frameCount = 0;
    for (int i = 0; i < count; ++i)
    {
         // Create a Packet
        AVPacket *pkt = av_packet_alloc();
        if (pkt == nullptr) {
            avcodec_free_context(&m_AudioCodecContext);
            if (m_FormatContext != nullptr)
                avformat_free_context(m_FormatContext);
            return;
        }
        av_init_packet(pkt);

        if (i == count - 1)
            perFrameDataSize = _pcmData.size() % perFrameDataSize;

        // Synthesize WAV files
       memset(frame->data[0], 0, perFrameDataSize);
       memcpy(frame->data[0], &(_pcmData.data()[perFrameDataSize * i]), perFrameDataSize);


        frame->pts = frameCount++;
         // send Frame
        result = avcodec_send_frame(m_AudioCodecContext, frame);
        if (result < 0)
            continue;

         // Receive the encoded Packet
        result = avcodec_receive_packet(m_AudioCodecContext, pkt);
        if (result < 0)
        {
            av_packet_free(&pkt);
            continue;
        }

         // write to file
        av_packet_rescale_ts(pkt, m_AudioCodecContext->time_base, m_FormatContext->streams[0]->time_base);
        pkt->stream_index = 0;
        result = av_interleaved_write_frame(m_FormatContext, pkt);
        if (result < 0)
            continue;

        av_packet_free(&pkt);
    }

     // write to the end of the file
    av_write_trailer(m_FormatContext);
     // Close file IO
    avio_closep(&m_FormatContext->pb);
    // Release Frame memory
    av_frame_free(&frame);

    avcodec_free_context(&m_AudioCodecContext);
    if (m_FormatContext != nullptr)
        avformat_free_context(m_FormatContext);
}

main.cpp

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    AudioGenerater generator;
    
    av_log_set_level(AV_LOG_DEBUG);
    av_log_set_flags(av_log_get_flags());
    
    QFile file("pcma.raw");
    if (!file.open(QIODevice::ReadOnly)) {
        return EXIT_FAILURE;
    }
    QByteArray pcmaData(file.readAll());
    
    generator.generateAudioFileWithOptions(
                "test.mka",
                pcmaData,
                AV_CODEC_ID_PCM_ALAW,
                1, 64000, 8000,
                AV_SAMPLE_FMT_U8);

    return a.exec();
}

После того, как я запускаю программу, я получаю вот такую ошибку:

[pcm_alaw @ 0x19229a0] Specified sample format u8 is invalid or not supported

Но если я установлю формат s16p вместо U8:

generator.generateAudioFileWithOptions(
                "test.mka",
                pcmaData,
                AV_CODEC_ID_PCM_ALAW,
                1, 64000, 8000,
                AV_SAMPLE_FMT_S16P);

Я получаю вдвое более быструю звуковую дорожку, с большим количеством шума. Мне нужна последовательная инструкция, для кодирования необработанных аудио данных в аудиофайл.