Конвертация аудио сэмплов wasapi в AVFrame FFmpeg и C++

       wfex    @0x207c182fe30  WAVEFORMATEXTENSIBLE
            Format  @0x207c182fe30  tWAVEFORMATEX
                cbSize  22  unsigned short
                nAvgBytesPerSec 384000  unsigned long
                nBlockAlign 8   unsigned short
                nChannels   2   unsigned short
                nSamplesPerSec  48000   unsigned long
                wBitsPerSample  32  unsigned short
                wFormatTag  65534   unsigned short
            Samples @0x207c182fe42  WAVEFORMATEXTENSIBLE::<unnamed-type-Samples>
                wReserved   32  unsigned short
                wSamplesPerBlock    32  unsigned short
                wValidBitsPerSample 32  unsigned short
            SubFormat   @0x207c182fe48  _GUID
                Data1   3   unsigned long
                Data2   0   unsigned short
                Data3   16  unsigned short
                Data4   "�\000\000�\0008�q" unsigned char[8]
                                128 0x80    unsigned char
                        '\0'    0   0x00    unsigned char
                        '\0'    0   0x00    unsigned char
                        'ª'     170 0xaa    unsigned char
                        '\0'    0   0x00    unsigned char
                        '8'     56  0x38    unsigned char
                                155 0x9b    unsigned char
                        'q'     113 0x71    unsigned char
            dwChannelMask   3   unsigned long

DWORD AudioCapture::recordAudio()
{
    HRESULT hr;
    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    hr = pCaptureClient->GetNextPacketSize(&packetLength);
    if (FAILED(hr))
    {
        printf("Faild to get next data packet size\n");
        return hr;
    }
    while (packetLength != 0)
    {
        // Get the available data in the shared buffer.
        hr = pCaptureClient->GetBuffer(&pData, &numFramesAvailable, &flags, &pos, &ts);
        if (FAILED(hr))
        {
            printf("Faild to get buffer\n");
            return hr;
        }
        if (flags & AUDCLNT_BUFFERFLAGS_SILENT)
        {
             pData = NULL;  // Tell CopyData to write silence.
             BYTE * buffer = new BYTE[(numFramesAvailable * pwfx->nBlockAlign)];
             memcpy(buffer, 0, numFramesAvailable * pwfx->nBlockAlign);
             m_curAudioData.push_back({buffer, numFramesAvailable, ts});
        }
        else
        {
            BYTE * buffer = new BYTE[(numFramesAvailable * pwfx->nBlockAlign)];
            memcpy(buffer, pData, numFramesAvailable * pwfx->nBlockAlign);
            m_curAudioData.push_back({buffer, numFramesAvailable, ts});
        }
 
        hr = pCaptureClient->ReleaseBuffer(numFramesAvailable);
        if (FAILED(hr)) {
            printf("Faild to release buffer\n");
            return hr;
        }
 
        hr = pCaptureClient->GetNextPacketSize(&packetLength);
        if (FAILED(hr)) {
            printf("Faild to get next data packet size\n");
            return hr;
        }
    }
    return 0;
}

AVStream * VideoEncoder::AddAudioStream(AVFormatContext *pContext, AVCodecID codec_id)
{
    AVCodecContext *pCodecCxt = NULL;
    AVStream *pStream = NULL;
 
    // Try create stream.
    pStream = avformat_new_stream(pContext, NULL);
    if (!pStream)
    {
        printf("Cannot add new audio stream\n");
        return NULL;
    }
 
    // Codec.
    pCodecCxt = pStream->codec;
    pCodecCxt->codec_id = codec_id;
    pCodecCxt->codec_type = AVMEDIA_TYPE_AUDIO;
    // Set format
    pCodecCxt->bit_rate    = mWFX->wBitsPerSample;
    pCodecCxt->sample_rate = mWFX->nSamplesPerSec;
    pCodecCxt->channels    = mWFX->nChannels; // mono
    pCodecCxt->sample_fmt  = AV_SAMPLE_FMT_FLTP;
 
    // Some formats want stream headers to be separate.
    if(pContext->oformat->flags & AVFMT_GLOBALHEADER)
    {
        pCodecCxt->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    }
 
    /*nSizeAudioEncodeBuffer = 4 * MAX_AUDIO_PACKET_SIZE;
    if (pAudioEncodeBuffer == NULL)
    {
        pAudioEncodeBuffer = (uint8_t * )av_malloc(nSizeAudioEncodeBuffer);
    }*/
 
    mSamples = (uint8_t*)av_malloc(2 * mBufferSize);
    mSamplesEnd = mSamples + mBufferSize;
    mCurrentFrame = mSamples;
 
    return pStream;
}
 
bool VideoEncoder::OpenAudio(AVFormatContext *pContext, AVStream *pStream)
{
    AVCodecContext *pCodecCxt = NULL;
    AVCodec *pCodec = NULL;
    pCodecCxt = pStream->codec;
 
    // Find the audio encoder.
    pCodec = avcodec_find_encoder(pCodecCxt->codec_id);
    if (!pCodec)
    {
        printf("Cannot open audio codec\n");
        return false;
    }
 
    // Open it.
    if (avcodec_open2(pCodecCxt, pCodec, NULL) < 0)
    {
        printf("Cannot open audio codec\n");
        return false;
    }
 
    return true;
}

auto wfex = reinterpret_cast<const WAVEFORMATEXTENSIBLE*>(pwfx);
const auto format = wfex->SubFormat;
 
printf("Guid = {%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX}",
    format.Data1, format.Data2, format.Data3,
    format.Data4[0], format.Data4[1], format.Data4[2], format.Data4[3],
    format.Data4[4], format.Data4[5], format.Data4[6], format.Data4[7]);

         /* create resampler context */
         ost->swr_ctx = swr_alloc();
         if (!ost->swr_ctx) {
             fprintf(stderr, "Could not allocate resampler context\n");
             exit(1);
         }
 
         /* set options */
         av_opt_set_int       (ost->swr_ctx, "in_channel_count",   c->channels,       0);
         av_opt_set_int       (ost->swr_ctx, "in_sample_rate",     c->sample_rate,    0);
         av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0);
         av_opt_set_int       (ost->swr_ctx, "out_channel_count",  c->channels,       0);
         av_opt_set_int       (ost->swr_ctx, "out_sample_rate",    c->sample_rate,    0);
         av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
 
         /* initialize the resampling context */
         if ((ret = swr_init(ost->swr_ctx)) < 0) {
             fprintf(stderr, "Failed to initialize the resampling context\n");
             exit(1);
         }

static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)
{//...
             /* convert to destination format */
             ret = swr_convert(ost->swr_ctx,
                               ost->frame->data, dst_nb_samples,
                               (const uint8_t **)frame->data, frame->nb_samples);
             if (ret < 0) {
                 fprintf(stderr, "Error while converting\n");
                 exit(1);
             }

         /* create resampler context */
         ost->swr_ctx = swr_alloc(); // создаём контекст, но он пока ещё пустой, его нужно будет наполнить
         if (!ost->swr_ctx) {
             fprintf(stderr, "Could not allocate resampler context\n");
             exit(1);
         }
 
         /* set options */
         // опции - это такая текстовая мэпа внутри контекста, содержит ключи и значения для клучей
         // первый аргумент - контекст
         // второй аргумент - ключ, если начинается с in, то относится к входному формату, out - к выходному
         // третий аргумент - значение для ключа
         av_opt_set_int       (ost->swr_ctx, "in_channel_count",   c->channels,       0); // количество каналов исходного формата
         av_opt_set_int       (ost->swr_ctx, "in_sample_rate",     c->sample_rate,    0); // частота дискретизации исходного
         av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0); // формат семпла исходного
         av_opt_set_int       (ost->swr_ctx, "out_channel_count",  c->channels,       0); // аналогично, только для выхода
         av_opt_set_int       (ost->swr_ctx, "out_sample_rate",    c->sample_rate,    0);
         av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
 
         /* initialize the resampling context */
         // теперь применяем текстовую мэпу, реально считываем настройки форматов и готовим контекст
         if ((ret = swr_init(ost->swr_ctx)) < 0) {
             fprintf(stderr, "Failed to initialize the resampling context\n");
             exit(1);
         }

static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)
{//...
             /* convert to destination format */
             ret = swr_convert(ost->swr_ctx, // контекст преобразования, который мы настраивали в начале
                               ost->frame->data, dst_nb_samples, // выходные данные, буфера и количество семплов
                               (const uint8_t **)frame->data, frame->nb_samples); // входные данные, буфера и количество семплов
             if (ret < 0) {
                 fprintf(stderr, "Error while converting\n");
                 exit(1);
             }

bool VideoEncoder::AddAudioSample(AVFormatContext * pFormatContext, AVStream * pStream, BYTE * audiodata, uint32_t sampleCount, uint64_t devicets)
{
    bool res = true;
 
    AVCodecContext * pCodecCxt = NULL;
    pCodecCxt = pStream->codec;
 
    //Создаю фрейм для входного формата
    AVFrame *  pFLTAudioFrame = NULL;
    pFLTAudioFrame = av_frame_alloc();
    pFLTAudioFrame ->nb_samples = sample_count;
    pFLTAudioFrame ->format = AV_SAMPLE_FMT_FLT;
    pFLTAudioFrame ->sample_rate = mWFX->nSamplesPerSec;
    pFLTAudioFrame ->channels = mWFX->nChannels;
    pFLTAudioFrame ->pkt_size =  pFLTAudioFrame->nb_samples*mWFX->nBlockAlign;
 
    av_samples_fill_arrays(pFLTAudioFrame ->data, pFLTAudioFrame ->linesize, (const uint8_t  *)data, pFLTAudioFrame->channels, pFLTAudioFrame ->nb_samples, AV_SAMPLE_FMT_FLT, 1);
 
    int dst_nb_samples = 0;
 
    dst_nb_samples = av_rescale_rnd(swr_get_delay(pSmplConvertCtx, pStream->codec->sample_rate) + pFLTAudioFrame->nb_samples, pStream->codec->sample_rate,  pStream->codec->sample_rate, AV_ROUND_UP);
    
    //Создаю исходный кадр
    AVFrame*  pFLTPAudioFrame = NULL;
    pFLTPAudioFrame = av_frame_alloc();
    pFLTPAudioFrame->nb_samples = pFLTAudioFrame->nb_samples;
    pFLTPAudioFrame->format = AV_SAMPLE_FMT_FLTP;
    pFLTPAudioFrame->sample_rate = pFLTAudioFrame->sample_rate;
    pFLTPAudioFrame->channels = pFLTAudioFrame->channels;
    pFLTPAudioFrame->pkt_size = pFLTAudioFrame->nb_samples*mWFX->nBlockAlign;
 
    //Конвертирую форматы
    swr_convert(pSmplConvertCtx, pFLTPAudioFrame->data, dst_nb_samples, (const uint8_t **)pFLTAudioFrame->data, pFLTAudioFrame->nb_samples);
 
 
    //Создаю пакет и дальше его записываю
    AVPacket pkt;
    av_init_packet(&pkt);
 
    pkt.data = pAudioEncodeBuffer;
    pkt.size = nSizeAudioEncodeBuffer;
    pkt.pts = av_rescale_q(pCodecCxt->coded_frame->pts, pCodecCxt->time_base, pStream->time_base);
 
    int gotOutput = 0;
    int ret = avcodec_encode_audio2(pCodecCxt, &pkt, pFLTPAudioFrame, &gotOutput);
    if (ret < 0)
    {
      std::cout << "Error encoding frame in line " << __LINE__ << std::endl;
      return false;
    }
    if (gotOutput)
    {
      if (av_interleaved_write_frame(pFormatContext, &pkt) != 0)
      {
          return false;
      }
      av_free_packet(&pkt);
    }
 
    do
    {
      ret = avcodec_encode_audio2(pCodecCxt, &pkt, NULL, &gotOutput);
      if (ret < 0)
      {
        std::cout << "Error encoding frame in line " << __LINE__ << std::endl;
        return false;
      }
      if (gotOutput)
      {
          if (av_interleaved_write_frame(pFormatContext, &pkt) != 0)
          {
              break;
          }
        av_free_packet(&pkt);
      }
 
    } while (gotOutput);
 
    return res;
}

    pSmplConvertCtx = swr_alloc();
    if (!pSmplConvertCtx)
    {
         fprintf(stderr, "Could not allocate resampler context\n");
         exit(1);
    }
 
    /* set options */
    av_opt_set_int       (pSmplConvertCtx, "in_channel_count",   pCodecCxt->channels,       0);
    av_opt_set_int       (pSmplConvertCtx, "in_sample_rate",     pCodecCxt->sample_rate,    0);
    av_opt_set_sample_fmt(pSmplConvertCtx, "in_sample_fmt",      AV_SAMPLE_FMT_FLT,         0);
    av_opt_set_int       (pSmplConvertCtx, "out_channel_count",  pCodecCxt->channels,       0);
    av_opt_set_int       (pSmplConvertCtx, "out_sample_rate",    pCodecCxt->sample_rate,    0);
    av_opt_set_sample_fmt(pSmplConvertCtx, "out_sample_fmt",     pCodecCxt->sample_fmt,     0);
 
    /* initialize the resampling context */
    if ((swr_init(pSmplConvertCtx)) < 0)
    {
        fprintf(stderr, "Failed to initialize the resampling context\n");
        exit(1);
    }
 
    nSizeAudioEncodeBuffer = av_samples_get_buffer_size(NULL, pCodecCxt->channels, pCodecCxt->sample_rate, pCodecCxt->sample_fmt, 0);
    if (pAudioEncodeBuffer == NULL)
    {
        pAudioEncodeBuffer = (uint8_t * )av_malloc(nSizeAudioEncodeBuffer);
    }

bool AddAudioSample(AVFormatContext * pFormatContext, AVStream * pStream, BYTE * audiodata, uint32_t sampleCount, uint64_t devicets)
{
    AVCodecContext * pCodecCxt = NULL;
    bool res = true;
 
    pCodecCxt = pStream->codec;
 
    AVFrame*  pFLTAudioFrame = NULL;
    pFLTAudioFrame = av_frame_alloc();
 
    AVFrame*  pFLTPAudioFrame = NULL;
    pFLTPAudioFrame = av_frame_alloc();
 
    ProcessData(pFLTAudioFrame, pFLTPAudioFrame, (uint8_t *)audiodata, sampleCount, devicets);
 
    swr_convert(pSmplConvertCtx, pFLTPAudioFrame->data, pFLTPAudioFrame->nb_samples, (const uint8_t **)pFLTAudioFrame->data, pFLTAudioFrame->nb_samples);
 
    AVPacket pkt;
    av_init_packet(&pkt);
 
    pkt.flags |= AV_PKT_FLAG_KEY;
    pkt.stream_index = pStream->index;
    pkt.data = pAudioEncodeBuffer;
    pkt.size = pFLTPAudioFrame->pkt_size;
 
    int gotOutput = 0;
    auto ret = avcodec_encode_audio2(pCodecCxt, &pkt, pFLTPAudioFrame, &gotOutput);
    if (ret < 0)
    {
        exit(1);
    }
    if (gotOutput)
    {
        pkt.pts = av_rescale_q(pCodecCxt->coded_frame->pts, pCodecCxt->time_base, pStream->time_base);
        ret = av_interleaved_write_frame(pFormatContext, &pkt);
        if (ret < 0)
        {
            exit(1);
        }
    }
 
    return res;
}
 
void ProcessData(AVFrame *inputframe, AVFrame *outputFrame, uint8_t* data, uint32_t sample_count, uint64_t device_ts)
{
    inputframe->nb_samples = sample_count;
    inputframe->format = AV_SAMPLE_FMT_FLT;
    inputframe->sample_rate = mWFX->nSamplesPerSec;
    inputframe->channels = mWFX->nChannels;
    inputframe->pkt_size = sample_count*mWFX->nBlockAlign;
 
    av_samples_fill_arrays(inputframe->data, inputframe->linesize, data, mWFX->nChannels, sample_count, AV_SAMPLE_FMT_FLT, 1);
 
    outputFrame->nb_samples = inputframe->nb_samples;
    outputFrame->format = AV_SAMPLE_FMT_FLTP;
    outputFrame->sample_rate = inputframe->sample_rate;
    outputFrame->channels = inputframe->channels;
    outputFrame->pkt_size = sample_count*mWFX->nBlockAlign;
 
    av_samples_fill_arrays(outputFrame->data, outputFrame->linesize, pAudioEncodeBuffer, mWFX->nChannels, sample_count, AV_SAMPLE_FMT_FLTP, 1);
}

//#pragma warning(disable : 4996)
//#pragma warning(disable : 4703)
 
#define _USE_MATH_DEFINES
#include "math.h"
 
//--------------------------------------------------------------------------
extern "C"
{
#include <libavformat/avformat.h>
#include <libswresample/swresample.h>
#include <libavutil/opt.h>
}
 
//--------------------------------------------------------------------------
const int channels = 2;
const int sample_rate = 48000;
const int sample_cnt = 1000;
 
//--------------------------------------------------------------------------
struct GlobalContext
{
    AVFrame* frame;
    AVFormatContext* format;
    AVCodecContext* codec;
    SwrContext* swr;
    long long pos;
};
 
//--------------------------------------------------------------------------
// заполнить буфер <buffer> звуковыми семплами в формате FLT
// <samples> - количество семплов помещаемых в буфер
//--------------------------------------------------------------------------
void GetSourceData(void* buffer, int samples)
{
    static int pos[4] = { 0, 0, 0, 0 };
    static int channels_freq[4] = { 500, 1000, 2000, 3000 };
    static double channels_ampl[4] = { 0.2, 0.5, 0.3, 0.8 };
 
    float* flt = (float*)buffer;
 
    for (int i = 0; i < samples; i++)
    {
        for (int j = 0; j < channels; j++)
        {
            *flt++ = float(channels_ampl[j] * sin(pos[j]++ * M_PI * channels_freq[j] / sample_rate));
        }
    }
}
 
//--------------------------------------------------------------------------
// инициализация энкодера
//--------------------------------------------------------------------------
void InitEncoder(GlobalContext& ctx)
{
    AVCodec* codec = avcodec_find_encoder_by_name("ac3");
    if (!codec)
    {
        printf("avcodec_find_encoder_by_name(AC3) - failed\n");
        exit(1);
    }
 
    ctx.codec = avcodec_alloc_context3(codec);
    if (!ctx.codec)
    {
        printf("avcodec_alloc_context3() - failed\n");
        exit(1);
    }
 
    ctx.codec->channels = channels;
    ctx.codec->channel_layout = av_get_default_channel_layout(channels);
    ctx.codec->sample_rate = sample_rate;
    ctx.codec->sample_fmt = codec->sample_fmts[0];// AV_SAMPLE_FMT_FLTP;
 
    if (avcodec_open2(ctx.codec, codec, NULL) < 0)
    {
        printf("avcodec_open2() - failed\n");
        exit(1);
    }
}
 
//--------------------------------------------------------------------------
// инициализация кадра звука для отправки в энкодер
//--------------------------------------------------------------------------
void InitFrame(GlobalContext& ctx)
{
    ctx.frame = av_frame_alloc();
 
    ctx.frame->format = ctx.codec->sample_fmt;
    ctx.frame->sample_rate = ctx.codec->sample_rate;
    ctx.frame->channels = ctx.codec->channels;
    ctx.frame->channel_layout = ctx.codec->channel_layout;
    ctx.frame->nb_samples = ctx.codec->frame_size;
 
    if (av_samples_alloc(ctx.frame->data, ctx.frame->linesize, ctx.frame->channels, ctx.frame->nb_samples, ctx.codec->sample_fmt, 0) < 0)
    {
        printf("av_samples_alloc() - failed\n");
        exit(1);
    }
}
 
//--------------------------------------------------------------------------
// инициализация преобразователя форматов
//--------------------------------------------------------------------------
void InitResampler(GlobalContext& ctx)
{
    ctx.swr = swr_alloc();
    if (!ctx.swr)
    {
        printf("Could not allocate resampler context\n");
        exit(1);
    }
 
    av_opt_set_int(ctx.swr, "in_channel_count", channels, 0);
    av_opt_set_int(ctx.swr, "in_sample_rate", sample_rate, 0);
    av_opt_set_sample_fmt(ctx.swr, "in_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
    av_opt_set_int(ctx.swr, "out_channel_count", channels, 0);
    av_opt_set_int(ctx.swr, "out_sample_rate", sample_rate, 0);
    av_opt_set_sample_fmt(ctx.swr, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
 
    if (swr_init(ctx.swr) < 0)
    {
        printf("Failed to initialize the resampling context\n");
        exit(1);
    }
}
 
//--------------------------------------------------------------------------
// инициализация записи в файл
//--------------------------------------------------------------------------
void InitFile(GlobalContext& ctx, const char* fileName)
{
    avformat_alloc_output_context2(&ctx.format, NULL, NULL, fileName);
    if (!ctx.format)
    {
        printf("avformat_alloc_output_context2() - failed\n");
        exit(1);
    }
 
    AVStream* stream = avformat_new_stream(ctx.format, 0);
    if (!stream)
    {
        printf("avformat_new_stream() - failed\n");
        exit(1);
    }
 
    avcodec_parameters_from_context(stream->codecpar, ctx.codec);
 
    av_dump_format(ctx.format, 0, fileName, 1);
 
    if (avio_open(&ctx.format->pb, fileName, AVIO_FLAG_WRITE) < 0)
    {
        printf("avio_open() - failed\n");
        exit(1);
    }
 
    avformat_write_header(ctx.format, NULL);
}
 
//--------------------------------------------------------------------------
// процедура преобразования формата, кодирования и записи одного кадра
//--------------------------------------------------------------------------
void Resample(GlobalContext& ctx, const void* buffer = 0, int samples = 0)
{
    int cnt = 0;
 
    // обработать один новый кадр звука
    if (buffer && samples)
    {
        // помещаем данные в контекст преобразования, но ничего не забираем (буферизация)
        swr_convert(ctx.swr, 0, 0, (const uint8_t**)&buffer, samples);
 
        // забираем данные из контекства преобразования нужными кодеку порциями
        while ((cnt = swr_get_out_samples(ctx.swr, 0)) >= ctx.codec->frame_size)
        {
            // преобразование
            cnt = swr_convert(ctx.swr, ctx.frame->data, ctx.codec->frame_size, 0, 0);
            if (cnt <= 0)
            {
                printf("swr_convert() - failed");
                exit(1);
            }
 
            AVPacket pkt = {};
            av_init_packet(&pkt);
 
            // тайм стемп по номеру семпла
            ctx.frame->pts = ctx.pos;
            ctx.pos += ctx.frame->nb_samples;
 
            // кодирование
            int gotPacket = 0;
            if (avcodec_encode_audio2(ctx.codec, &pkt, ctx.frame, &gotPacket) < 0)
            {
                printf("avcodec_encode_audio2() - failed");
                exit(1);
            }
 
            if (gotPacket)
            {
                // запись
                if (av_write_frame(ctx.format, &pkt) < 0)
                {
                    printf("av_write_frame() - failed");
                    exit(1);
                }
            }
 
            av_free_packet(&pkt);
        }
    }
    // завершение обработки, выполнить выталкивание данных
    else
    {
        AVPacket pkt = {};
        av_init_packet(&pkt);
 
        int gotPacket = 0;
 
        do
        {
            // кодирование (выталкивание)
            if (avcodec_encode_audio2(ctx.codec, &pkt, NULL, &gotPacket) < 0)
            {
                printf("av_write_frame() - failed");
                exit(1);
            }
 
            if (gotPacket)
            {
                // запись
                if (av_write_frame(ctx.format, &pkt) < 0)
                {
                    printf("av_write_frame() - failed");
                    exit(1);
                }
            }
 
            av_free_packet(&pkt);
 
        } while (gotPacket);
    }
}
 
//--------------------------------------------------------------------------
int main()
{
    GlobalContext ctx = {};
 
    av_register_all();
 
    InitEncoder(ctx);
    InitFrame(ctx);
    InitResampler(ctx);
    InitFile(ctx, "out.ac3");
 
    // буфер под исходные данные
    float* src_buffer = (float*) malloc(sizeof(float) * channels * sample_cnt);
 
    // основной рабочий цикл
    for (int i = 0; i < 1000; i++)
    {
        GetSourceData(src_buffer, sample_cnt);
        Resample(ctx, src_buffer, sample_cnt);
    }
 
    // выталкивание
    Resample(ctx);
 
    av_write_trailer(ctx.format);
 
    free(src_buffer);
    avformat_free_context(ctx.format);
    swr_free(&ctx.swr);
    av_frame_free(&ctx.frame);
    return 0;
}