Пакетирование аудио данных типа pcm_alaw в mka аудиофайл, используя ffmpeg API

А что если запустить ffmpeg как процесс и кормить его буфером alaw через stdin?

dd if=/dev/urandom | ffmpeg -f alaw -i pipe: -c:a copy -f matroska  data.mka

Красивый шум пакуется без проблем.

А ещё ffmpeg сам умеет подключаться к rtp. Можно просто держать его в сабпроцессе.

Задача моего проекта заключается в том, чтобы просто взять pcm_alaw данные и запаковать их в контейнер, формата mka.

С такой формулировкой, самым простым вариантом будет скармливать весь поток ffmpeg'у и «демуксить» его встроенной заглушкой для сырого кодека; а потом просто муксить дорожку из потока в mkv «как есть», без перекодирования:

// build : g++ -g3 -O0 -std=c++17 -lavformat -lavutil -lavcodec  ./av_muxrecorder.cpp -o muxer
// run   : ./muxer rawData foo.mka

#include <iostream>
#include <fstream>
#include <memory>
#include <cassert>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/error.h>
#include <libavutil/log.h>
}

#undef av_err2str
#define av_err2str(errnum) \
  av_make_error_string((char*)alloca(AV_ERROR_MAX_STRING_SIZE), AV_ERROR_MAX_STRING_SIZE, errnum)

using namespace std::string_literals;

template <>
struct std::default_delete<AVFormatContext> {
    void operator()(AVFormatContext* p) const noexcept { avformat_free_context(p); }
};

template <>
struct std::default_delete<AVCodecContext> {
    void operator()(AVCodecContext* p) const noexcept { avcodec_free_context(&p); }
};

template <>
struct std::default_delete<AVIOContext> {
    void operator()(AVIOContext* p) const noexcept { 
        if (p) { av_freep(&p->buffer); }
        avio_context_free(&p);
    }
};

class MuxRecorder {
    std::unique_ptr<AVFormatContext> inCtx;
    std::unique_ptr<AVIOContext> inIOCtx;
    std::unique_ptr<AVCodecContext> inCodecCtx;
    AVStream* inStream;

    std::shared_ptr<AVFormatContext> outCtx;
    AVStream* outStream;

    const uint8_t *curData;
    size_t curSz;
    bool isFinished;

public:
  MuxRecorder (AVInputFormat *fmt, AVDictionary **inOpts);
  void setOutput (std::shared_ptr<AVFormatContext> outCtx_);

  void processData(const uint8_t *data, size_t sz);
  void finalize();

protected:
  void doProcessStream();

private:
  /// служебная функция, используется как callback в AVIOContext
  static int readPacket(void *opaque, uint8_t *buf, int sz);
};

MuxRecorder::MuxRecorder (AVInputFormat *fmt, AVDictionary **inOpts)
  :curData(0),
   curSz(0),
   isFinished(0)
{
  int rc;

  const size_t ioBufSz = 4096; // должен быть не меньше, чем размер пакета кодека,
    // может быть самостоятельно увеличен libav
  uint8_t *ioCtxBuffer = (uint8_t*)av_malloc(ioBufSz);
  if(!ioCtxBuffer) throw std::bad_alloc();

  inIOCtx.reset(avio_alloc_context(
        /* buffer */ ioCtxBuffer, /* buffer_size */ ioBufSz, /* write_flag */0, 
        /* user_data */ this,
        /* read  */ &MuxRecorder::readPacket,
        /* write */ 0,
        /* seek  */ 0));

  if (!inIOCtx) {
    av_free(ioCtxBuffer);
    throw std::bad_alloc();
  } // В сллучае успеха inIOCtx принимает владение буфером ioCtxBuffer


  /********* Создание контекста для демультиплексера формата ***********/
  
  // для pcml это будет просто заглушка
  AVFormatContext *fmtCtx = avformat_alloc_context();
  if(!fmtCtx) throw std::bad_alloc();
  fmtCtx->pb = inIOCtx.get();
  // TODO: для более сложных форматов это должно делаться в processData()
  rc = avformat_open_input(&fmtCtx, 0, fmt, inOpts);
  if (rc < 0) {
    // avformat_open_input() освобождает fmtCtx при неудаче
    throw std::runtime_error( "Failed to open input: "s.append(av_err2str(rc)) );
  }
  inCtx.reset(fmtCtx);

  if (inCtx->nb_streams != 1) { // для простого формата поток должен быть один
    throw std::runtime_error("Input has several streams");
  }

  inStream = inCtx->streams[0];

  /********* Определение кодека входного потока ************************/
  // для сырых кодеков, в частности, pcml это формальность,
  // id должен совпдать с fmt->raw_codec_id
  AVCodec *inCodec = avcodec_find_decoder(inStream->codecpar->codec_id);
  if (!inCodec) {
    throw std::runtime_error("Couldn't find codec for input stream");
  }

  inCodecCtx.reset(avcodec_alloc_context3(inCodec));
  if(!inCodecCtx) throw std::bad_alloc();

  avcodec_parameters_to_context (inCodecCtx.get(), inStream->codecpar);
  rc = avcodec_open2(inCodecCtx.get(), inCodec, inOpts);
  if (rc < 0) {
    throw std::runtime_error( "Failed to open codec context: "s.append(av_err2str(rc)) );
  }
}

void MuxRecorder::setOutput (std::shared_ptr<AVFormatContext> outCtx_) {
  outCtx.swap(outCtx_);

  // добавить поток данных в файл
  outStream = avformat_new_stream(outCtx.get(), NULL);
  if(!outStream) { throw std::bad_alloc(); }
  int rc = avcodec_parameters_copy(outStream->codecpar, inStream->codecpar);
  if (rc < 0) {
    throw std::runtime_error("Failed to copy parameters: "s.append(av_err2str(rc)));
  }
  outStream->codecpar->codec_tag = 0;
}

void MuxRecorder::finalize() {
  isFinished = 1;
  doProcessStream(); // обработать остаток входных данных

  // Закрытие контекста входных данных. 
  AVFormatContext *fmtCtx = inCtx.release();
  avformat_close_input(&fmtCtx);
}

void MuxRecorder::processData(const uint8_t *data, size_t sz) {
  // В некотором роде хак т.к. при любой ошибке в readPacket() 
  // (в том числе и EAGAIN) ffmpeg устанавливает этот флаг в своих нутрах
  if(inIOCtx->error == AVERROR(EAGAIN)) {
      inIOCtx->eof_reached = 0;
  }

  curData = data;
  curSz   = sz;

  doProcessStream(); // собственно обработать данные из буыера

  assert(curSz == 0); // к этому моменту ffmpeg должен вычитаться всё
}


void MuxRecorder::doProcessStream() {
  AVPacket pkt;

  while(1) {
    int rc = av_read_frame(inCtx.get(), &pkt);
    if(rc == AVERROR(EAGAIN) || rc == AVERROR_EOF ) {
      break;
    } else if (rc<0) {
      throw std::runtime_error("Failed to read packet: "s.append(av_err2str(rc)));
    } else if(pkt.stream_index == inStream->index) { //< проверка для галочки
        /* copy packet */
        pkt.pts = av_rescale_q_rnd( pkt.pts, inStream->time_base, outStream->time_base,
                               (enum AVRounding) (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX) );
        pkt.dts = av_rescale_q_rnd( pkt.dts, inStream->time_base, outStream->time_base,
                               (enum AVRounding) (AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX) );
        pkt.duration = av_rescale_q(pkt.duration, inStream->time_base, outStream->time_base);
        pkt.pos = -1;
        rc = av_interleaved_write_frame(outCtx.get(), &pkt);
        if (rc < 0) {
          av_packet_unref(&pkt);
            throw std::runtime_error("Failed to mux packet into output stream: "s
                     .append(av_err2str(rc)));
        }
        av_packet_unref(&pkt);
    }
  }
}

int MuxRecorder::readPacket(void *opaque, uint8_t *buf, int sz) {
  MuxRecorder* self = (MuxRecorder*) opaque;

  if(self->curData && self->curSz) {
    sz = std::min(sz,(int) self->curSz);
    memcpy(buf, self->curData, sz);
    self->curSz -= sz;
    self->curData += sz;
    return sz;
  } else if(self->isFinished) {
    return AVERROR_EOF;
  } else {
    return AVERROR(EAGAIN);
  }
}

/*######## Helper functions #########################################*/

std::unique_ptr<AVFormatContext> openOutfile (const char *ofname) {
  // открыть поток для файла
  AVFormatContext *fmtCtx=0;
  int rc = avformat_alloc_output_context2(&fmtCtx, NULL, NULL, ofname);
  if(rc<0) {
    throw std::runtime_error("failed to crate context for output file: "s.append(av_err2str(rc)));
  }

  if (!(fmtCtx->oformat->flags & AVFMT_NOFILE)) {
    rc = avio_open(&fmtCtx->pb, ofname, AVIO_FLAG_WRITE);
    if (rc < 0) {
      throw std::runtime_error("failed to open output file ("s.append(ofname)
              .append("): ").append(av_err2str(rc)));
      fprintf(stderr, "Could not open output file '%s'", ofname);
    }
  }

  return std::unique_ptr<AVFormatContext>(fmtCtx);
};

/*######## main() example ###########################################*/

int main ( int argc, char *argv[] ) {

  if(argc!=3) {
    std::cerr << "Usage: " << argv [0] << " <infile> <outfile>" << std::endl;
    return EXIT_FAILURE;
  }
  const char *ifname = argv[1];
  const char *ofname = argv[2];

  int rc, rv = EXIT_SUCCESS;

  av_log_set_level(AV_LOG_TRACE);

  AVInputFormat *fmt = av_find_input_format("alaw");
  assert (fmt);

  AVDictionary *inOpts = 0;
  // Sets the sample rate of the output file.
  av_dict_set(&inOpts, "sample_rate", "8000", 0);
  // Sets the number of channels for the output file.
  av_dict_set(&inOpts, "channels", "1", 0);

  try {
    constexpr size_t bufSz = 1024;
    uint8_t buf[bufSz];

    
    MuxRecorder sr(fmt, &inOpts);
    std::shared_ptr<AVFormatContext> outCtx{openOutfile(ofname)};

    sr.setOutput(outCtx);
    av_dict_free (&inOpts);

    rc = avformat_write_header(outCtx.get(), 0);

    if(rc< 0) {
      throw std::runtime_error("Failed to write output header: "s.append(av_err2str(rc)) );
    }

    std::ifstream is(ifname, std::ios::binary | std::ios::in);
    if(!is) {
      throw std::runtime_error("Failed to open input file: "s.append(strerror(errno)));
    }

    do {
      is.read((char*)buf, bufSz);
      sr.processData(buf, is.gcount());
    } while (is);

    sr.finalize();
    
    rc = av_write_trailer(outCtx.get());
    if(rc<0) {
      throw std::runtime_error( "Failed to finalize output file: "s.append(av_err2str(rc)) );
    }
  } catch(std::exception &e) {
    av_dict_free (&inOpts);
    std::cerr << e.what() << std::endl;
    rv = EXIT_FAILURE;
  }

  return rv;
}
// PS:
//
// I'm the author of this code snippet and hereby grant it to public domain.
// Я, автор данного отрывка кода, передаю его в общественное достояние.

Некоторые замечания:

• Данные на вход можно подавать произвольными фрагментами, у ffmpeg есть внутренняя буферезация, так что всё должно работать независимо от размера блока.
• Не особо отлаживал, так что возможны ошибки.
• Отдельно стоит проверить на утечки памяти.
• Не должно составить сложности упаковывать несколько дорожек в один контейнер (в том числе видео).
• В качестве поддерживаемого потока на вход MuxRecorder'у должно быть возможно подать любой, поддерживаемый ffmpeg (с видео также не должно возникнуть проблем).
• Если перекодирование всё же необходимо, то на данный пример можно накрутить вариант с ресампленгом, как в примере transcode_aac.c/ответе @bbdd.

Полезные ссылки:

• Относительно хороший обзор последовательности обработки данных в libav: ffmpeg-libav-tutorial
• Пример чтения из памяти в ffmpeg: avio_reading.c
• Пример муксинга потоков: remuxing.c

Благодаря комментарию пользователя Fat-Zer, было определено, что лучше всего использовать для определения кодека - av_guess_codec() функцию, которая в свою очередь, автоматически подбирает нужный идентификатор кодека.

Определённости ради, я не говорил, что так делать «лучше всего». Я просто обозначил, что так поступает ffmpeg, если пользователь не указал кодек. И можно использовать любой кодек на свой выбор. ИМХО, в своём полноценном приложении, этот выбор надо или дать пользователю, или сделать заранее самому, а не полагаться на то, как был собран ffmpeg.