Muxing and Demuxing

These examples demonstrate working with media containers using libavformat. They show how to mux encoded streams into container files and demux containers to access individual streams.

Muxing Example

The muxing example generates synthetic audio and video streams, encodes them, and muxes them into an output container file.

Output Context Setup

/* allocate the output media context */
avformat_alloc_output_context2(&oc, NULL, NULL, filename);
if (!oc) {
    printf("Could not deduce output format from file extension: using MPEG.\n");
    avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
}
if (!oc)
    return 1;

fmt = oc->oformat;

Adding Streams

static void add_stream(OutputStream *ost, AVFormatContext *oc,
                       const AVCodec **codec,
                       enum AVCodecID codec_id)
{
    AVCodecContext *c;

    /* find the encoder */
    *codec = avcodec_find_encoder(codec_id);
    if (!(*codec)) {
        fprintf(stderr, "Could not find encoder for '%s'\n",
                avcodec_get_name(codec_id));
        exit(1);
    }

    ost->tmp_pkt = av_packet_alloc();
    ost->st = avformat_new_stream(oc, NULL);
    if (!ost->st) {
        fprintf(stderr, "Could not allocate stream\n");
        exit(1);
    }
    ost->st->id = oc->nb_streams-1;
    c = avcodec_alloc_context3(*codec);
    ost->enc = c;

    switch ((*codec)->type) {
    case AVMEDIA_TYPE_AUDIO:
        c->sample_fmt  = (*codec)->sample_fmts ? (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
        c->bit_rate    = 64000;
        c->sample_rate = 44100;
        av_channel_layout_copy(&c->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO);
        ost->st->time_base = (AVRational){ 1, c->sample_rate };
        break;

    case AVMEDIA_TYPE_VIDEO:
        c->codec_id = codec_id;
        c->bit_rate = 400000;
        c->width    = 352;
        c->height   = 288;
        ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE };
        c->time_base       = ost->st->time_base;
        c->gop_size      = 12;
        c->pix_fmt       = STREAM_PIX_FMT;
        break;
    }

    /* Some formats want stream headers to be separate. */
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
}

Writing Frames

static int write_frame(AVFormatContext *fmt_ctx, AVCodecContext *c,
                       AVStream *st, AVFrame *frame, AVPacket *pkt)
{
    int ret;

    // send the frame to the encoder
    ret = avcodec_send_frame(c, frame);
    if (ret < 0) {
        fprintf(stderr, "Error sending a frame to the encoder: %s\n",
                av_err2str(ret));
        exit(1);
    }

    while (ret >= 0) {
        ret = avcodec_receive_packet(c, pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            fprintf(stderr, "Error encoding a frame: %s\n", av_err2str(ret));
            exit(1);
        }

        /* rescale output packet timestamp values from codec to stream timebase */
        av_packet_rescale_ts(pkt, c->time_base, st->time_base);
        pkt->stream_index = st->index;

        /* Write the compressed frame to the media file. */
        log_packet(fmt_ctx, pkt);
        ret = av_interleaved_write_frame(fmt_ctx, pkt);
        if (ret < 0) {
            fprintf(stderr, "Error while writing output packet: %s\n", av_err2str(ret));
            exit(1);
        }
    }

    return ret == AVERROR_EOF ? 1 : 0;
}

Writing Header and Trailer

/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
    ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Could not open '%s': %s\n", filename, av_err2str(ret));
        return 1;
    }
}

/* Write the stream header, if any. */
ret = avformat_write_header(oc, &opt);
if (ret < 0) {
    fprintf(stderr, "Error occurred when opening output file: %s\n", av_err2str(ret));
    return 1;
}

/* ... encode and write frames ... */

av_write_trailer(oc);

if (!(fmt->flags & AVFMT_NOFILE))
    avio_closep(&oc->pb);

avformat_free_context(oc);

Demuxing Example

The demuxing example opens a media file, demuxes it, decodes both audio and video, and writes raw output files.

Opening Input File

/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
    fprintf(stderr, "Could not open source file %s\n", src_filename);
    exit(1);
}

/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
    fprintf(stderr, "Could not find stream information\n");
    exit(1);
}

Opening Codec Context

static int open_codec_context(int *stream_idx,
                              AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, enum AVMediaType type)
{
    int ret, stream_index;
    AVStream *st;
    const AVCodec *dec = NULL;

    ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not find %s stream in input file '%s'\n",
                av_get_media_type_string(type), src_filename);
        return ret;
    } else {
        stream_index = ret;
        st = fmt_ctx->streams[stream_index];

        /* find decoder for the stream */
        dec = avcodec_find_decoder(st->codecpar->codec_id);
        if (!dec) {
            fprintf(stderr, "Failed to find %s codec\n", av_get_media_type_string(type));
            return AVERROR(EINVAL);
        }

        /* Allocate a codec context for the decoder */
        *dec_ctx = avcodec_alloc_context3(dec);
        if (!*dec_ctx) {
            fprintf(stderr, "Failed to allocate the %s codec context\n",
                    av_get_media_type_string(type));
            return AVERROR(ENOMEM);
        }

        /* Copy codec parameters from input stream to output codec context */
        if ((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) < 0) {
            fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n",
                    av_get_media_type_string(type));
            return ret;
        }

        /* Init the decoders */
        if ((ret = avcodec_open2(*dec_ctx, dec, NULL)) < 0) {
            fprintf(stderr, "Failed to open %s codec\n", av_get_media_type_string(type));
            return ret;
        }
        *stream_idx = stream_index;
    }

    return 0;
}

Reading and Decoding

/* read frames from the file */
while (av_read_frame(fmt_ctx, pkt) >= 0) {
    // check if the packet belongs to a stream we are interested in
    if (pkt->stream_index == video_stream_idx)
        ret = decode_packet(video_dec_ctx, pkt);
    else if (pkt->stream_index == audio_stream_idx)
        ret = decode_packet(audio_dec_ctx, pkt);
    av_packet_unref(pkt);
    if (ret < 0)
        break;
}

/* flush the decoders */
if (video_dec_ctx)
    decode_packet(video_dec_ctx, NULL);
if (audio_dec_ctx)
    decode_packet(audio_dec_ctx, NULL);

Remuxing Example

The remux example copies streams from one container to another without transcoding:

for (i = 0; i < ifmt_ctx->nb_streams; i++) {
    AVStream *out_stream;
    AVStream *in_stream = ifmt_ctx->streams[i];
    AVCodecParameters *in_codecpar = in_stream->codecpar;

    if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
        in_codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
        in_codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
        stream_mapping[i] = -1;
        continue;
    }

    stream_mapping[i] = stream_index++;

    out_stream = avformat_new_stream(ofmt_ctx, NULL);
    ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
    out_stream->codecpar->codec_tag = 0;
}

while (1) {
    AVStream *in_stream, *out_stream;

    ret = av_read_frame(ifmt_ctx, pkt);
    if (ret < 0)
        break;

    in_stream  = ifmt_ctx->streams[pkt->stream_index];
    if (pkt->stream_index >= stream_mapping_size ||
        stream_mapping[pkt->stream_index] < 0) {
        av_packet_unref(pkt);
        continue;
    }

    pkt->stream_index = stream_mapping[pkt->stream_index];
    out_stream = ofmt_ctx->streams[pkt->stream_index];

    /* copy packet */
    av_packet_rescale_ts(pkt, in_stream->time_base, out_stream->time_base);
    pkt->pos = -1;

    ret = av_interleaved_write_frame(ofmt_ctx, pkt);
}

Key Patterns

Format Detection

FFmpeg automatically detects input formats and can guess output formats from file extensions.

Stream Mapping

When remuxing, maintain a mapping between input and output stream indices.

Time Base Conversion

Always rescale timestamps when moving packets between contexts:

av_packet_rescale_ts(pkt, in_time_base, out_time_base);

Interleaved Writing

Use av_interleaved_write_frame() to automatically interleave packets from multiple streams.

Usage

Muxing

./mux output.mp4

Demuxing

./demux_decode input.mp4 video.raw audio.raw

Remuxing

./remux input.mkv output.mp4

Transcoding - Full transcode pipeline
Audio Encoding - Generate streams for muxing
Video Encoding - Generate streams for muxing

Core Libraries

API Examples

Muxing and Demuxing

Muxing Example

Output Context Setup

Adding Streams

Writing Frames

Writing Header and Trailer

Demuxing Example

Opening Input File

Opening Codec Context

Reading and Decoding

Remuxing Example

Key Patterns

Format Detection

Stream Mapping

Time Base Conversion

Interleaved Writing

Usage

Muxing

Demuxing

Remuxing

Build docs developers (and LLMs) love

Core Libraries

API Examples

​Muxing Example

​Output Context Setup

​Adding Streams

​Writing Frames

​Writing Header and Trailer

​Demuxing Example

​Opening Input File

​Opening Codec Context

​Reading and Decoding

​Remuxing Example

​Key Patterns

​Format Detection

​Stream Mapping

​Time Base Conversion

​Interleaved Writing

​Usage

​Muxing

​Demuxing

​Remuxing

​Related Examples

Build docs developers (and LLMs) love

Muxing Example

Output Context Setup

Adding Streams

Writing Frames

Writing Header and Trailer

Demuxing Example

Opening Input File

Opening Codec Context

Reading and Decoding

Remuxing Example

Key Patterns

Format Detection

Stream Mapping

Time Base Conversion

Interleaved Writing

Usage

Muxing

Demuxing

Remuxing

Related Examples