mpegenc.c

Go to the documentation of this file.

/*
 * MPEG-1/2 muxer
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
#include "config_components.h"
 
#include <stdint.h>
 
#include "libavutil/attributes.h"
#include "libavutil/fifo.h"
#include "libavutil/log.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
 
#include "libavcodec/put_bits.h"
 
#include "avformat.h"
#include "avio_internal.h"
#include "internal.h"
#include "mpeg.h"
#include "mux.h"
 
#define MAX_PAYLOAD_SIZE 4096
 
typedef struct PacketDesc {
    int64_t pts;
    int64_t dts;
    int size;
    int unwritten_size;
    struct PacketDesc *next;
} PacketDesc;
 
typedef struct StreamInfo {
    AVFifo *fifo;
    uint8_t id;
    int max_buffer_size; /* in bytes */
    int buffer_index;
    PacketDesc *predecode_packet; /* start of packet queue */
    PacketDesc *last_packet;      /* end of packet queue */
    PacketDesc *premux_packet;
    int packet_number;
    uint8_t lpcm_header[3];
    int lpcm_align;
    int bytes_to_iframe;
    int align_iframe;
    int64_t vobu_start_pts;
} StreamInfo;
 
typedef struct MpegMuxContext {
    const AVClass *class;
    int packet_size; /* required packet size */
    int packet_number;
    int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
    int system_header_freq;
    int system_header_size;
    int user_mux_rate; /* bitrate in units of bits/s */
    int mux_rate; /* bitrate in units of 50 bytes/s */
    /* stream info */
    int audio_bound;
    int video_bound;
    int is_mpeg2;
    int is_vcd;
    int is_svcd;
    int is_dvd;
    int64_t last_scr; /* current system clock */
 
    int64_t vcd_padding_bitrate_num;
    int64_t vcd_padding_bytes_written;
 
    int preload;
} MpegMuxContext;
 
extern const FFOutputFormat ff_mpeg1vcd_muxer;
extern const FFOutputFormat ff_mpeg2dvd_muxer;
extern const FFOutputFormat ff_mpeg2svcd_muxer;
extern const FFOutputFormat ff_mpeg2vob_muxer;
 
static int put_pack_header(AVFormatContext *ctx, uint8_t *buf,
                           int64_t timestamp)
{
    MpegMuxContext *s = ctx->priv_data;
    PutBitContext pb;
 
    init_put_bits(&pb, buf, 128);
 
    put_bits32(&pb, PACK_START_CODE);
    if (s->is_mpeg2)
        put_bits(&pb, 2, 0x1);
    else
        put_bits(&pb, 4, 0x2);
    put_bits(&pb,  3, (uint32_t)((timestamp >> 30) & 0x07));
    put_bits(&pb,  1, 1);
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
    put_bits(&pb,  1, 1);
    put_bits(&pb, 15, (uint32_t)((timestamp)       & 0x7fff));
    put_bits(&pb,  1, 1);
    if (s->is_mpeg2)
        /* clock extension */
        put_bits(&pb, 9, 0);
    put_bits(&pb, 1, 1);
    put_bits(&pb, 22, s->mux_rate);
    put_bits(&pb, 1, 1);
    if (s->is_mpeg2) {
        put_bits(&pb, 1, 1);
        put_bits(&pb, 5, 0x1f); /* reserved */
        put_bits(&pb, 3, 0); /* stuffing length */
    }
    flush_put_bits(&pb);
    return put_bits_ptr(&pb) - pb.buf;
}
 
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,
                             int only_for_stream_id)
{
    MpegMuxContext *s = ctx->priv_data;
    int size, i, private_stream_coded, id;
    PutBitContext pb;
 
    init_put_bits(&pb, buf, 128);
 
    put_bits32(&pb, SYSTEM_HEADER_START_CODE);
    put_bits(&pb, 16, 0);
    put_bits(&pb, 1, 1);
 
    /* maximum bit rate of the multiplexed stream */
    put_bits(&pb, 22, s->mux_rate);
    put_bits(&pb, 1, 1); /* marker */
    if (s->is_vcd && only_for_stream_id == VIDEO_ID) {
        /* This header applies only to the video stream
         * (see VCD standard p. IV-7) */
        put_bits(&pb, 6, 0);
    } else
        put_bits(&pb, 6, s->audio_bound);
 
    if (s->is_vcd) {
        /* see VCD standard, p. IV-7 */
        put_bits(&pb, 1, 0);
        put_bits(&pb, 1, 1);
    } else {
        put_bits(&pb, 1, 0); /* variable bitrate */
        put_bits(&pb, 1, 0); /* nonconstrained bitstream */
    }
 
    if (s->is_vcd || s->is_dvd) {
        /* see VCD standard p IV-7 */
        put_bits(&pb, 1, 1); /* audio locked */
        put_bits(&pb, 1, 1); /* video locked */
    } else {
        put_bits(&pb, 1, 0); /* audio locked */
        put_bits(&pb, 1, 0); /* video locked */
    }
 
    put_bits(&pb, 1, 1); /* marker */
 
    if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
        /* This header applies only to the audio stream
         * (see VCD standard p. IV-7) */
        put_bits(&pb, 5, 0);
    } else
        put_bits(&pb, 5, s->video_bound);
 
    if (s->is_dvd) {
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
        put_bits(&pb, 7, 0x7f); /* reserved byte */
    } else
        put_bits(&pb, 8, 0xff); /* reserved byte */
 
    /* DVD-Video Stream_bound entries
     * id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
     * id (0xB8) audio, maximum P-STD for any MPEG audio (0xC0 to 0xC7) streams. If there are none set to 4096 (32x128). (P-STD_buffer_bound_scale = 0)
     * id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
     * id (0xBF) private stream 2, NAV packs, set to 2x1024. */
    if (s->is_dvd) {
 
        int P_STD_max_video = 0;
        int P_STD_max_mpeg_audio = 0;
        int P_STD_max_mpeg_PS1 = 0;
 
        for (i = 0; i < ctx->nb_streams; i++) {
            StreamInfo *stream = ctx->streams[i]->priv_data;
 
            id = stream->id;
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
            } else if (id >= 0xc0 && id <= 0xc7 &&
                       stream->max_buffer_size > P_STD_max_mpeg_audio) {
                P_STD_max_mpeg_audio = stream->max_buffer_size;
            } else if (id == 0xe0 &&
                       stream->max_buffer_size > P_STD_max_video) {
                P_STD_max_video = stream->max_buffer_size;
            }
        }
 
        /* video */
        put_bits(&pb, 8, 0xb9); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 1);
        put_bits(&pb, 13, P_STD_max_video / 1024);
 
        /* audio */
        if (P_STD_max_mpeg_audio == 0)
            P_STD_max_mpeg_audio = 4096;
        put_bits(&pb, 8, 0xb8); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 0);
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
 
        /* private stream 1 */
        put_bits(&pb, 8, 0xbd); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 0);
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
 
        /* private stream 2 */
        put_bits(&pb, 8, 0xbf); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 1);
        put_bits(&pb, 13, 2);
    } else {
        /* audio stream info */
        private_stream_coded = 0;
        for (i = 0; i < ctx->nb_streams; i++) {
            StreamInfo *stream = ctx->streams[i]->priv_data;
 
            /* For VCDs, only include the stream info for the stream
             * that the pack which contains this system belongs to.
             * (see VCD standard p. IV-7) */
            if (!s->is_vcd || stream->id == only_for_stream_id ||
                only_for_stream_id == 0) {
                id = stream->id;
                if (id < 0xc0) {
                    /* special case for private streams (AC-3 uses that) */
                    if (private_stream_coded)
                        continue;
                    private_stream_coded = 1;
                    id = 0xbd;
                }
                put_bits(&pb, 8, id);         /* stream ID */
                put_bits(&pb, 2, 3);
                if (id < 0xe0) {
                    /* audio */
                    put_bits(&pb, 1, 0);
                    put_bits(&pb, 13, stream->max_buffer_size / 128);
                } else {
                    /* video */
                    put_bits(&pb, 1, 1);
                    put_bits(&pb, 13, stream->max_buffer_size / 1024);
                }
            }
        }
    }
 
    flush_put_bits(&pb);
    size = put_bits_ptr(&pb) - pb.buf;
    /* patch packet size */
    AV_WB16(buf + 4, size - 6);
 
    return size;
}
 
static int get_system_header_size(AVFormatContext *ctx)
{
    int buf_index, i, private_stream_coded;
    StreamInfo *stream;
    MpegMuxContext *s = ctx->priv_data;
 
    if (s->is_dvd)
        return 18; // DVD-Video system headers are 18 bytes fixed length.
 
    buf_index = 12;
    private_stream_coded = 0;
    for (i = 0; i < ctx->nb_streams; i++) {
        stream = ctx->streams[i]->priv_data;
        if (stream->id < 0xc0) {
            if (private_stream_coded)
                continue;
            private_stream_coded = 1;
        }
        buf_index += 3;
    }
    return buf_index;
}
 
static av_cold int mpeg_mux_init(AVFormatContext *ctx)
{
    MpegMuxContext *s = ctx->priv_data;
    int bitrate, i, mpa_id, mpv_id, h264_id, mps_id, ac3_id, dts_id, lpcm_id, j;
    AVStream *st;
    StreamInfo *stream;
    int audio_bitrate;
    int video_bitrate;
 
    s->packet_number = 0;
    s->is_vcd   =  (CONFIG_MPEG1VCD_MUXER  && ctx->oformat == &ff_mpeg1vcd_muxer.p);
    s->is_svcd  =  (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer.p);
    s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER  && ctx->oformat == &ff_mpeg2vob_muxer.p) ||
                   (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &ff_mpeg2dvd_muxer.p) ||
                   (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer.p));
    s->is_dvd   =  (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &ff_mpeg2dvd_muxer.p);
 
    if (ctx->packet_size) {
        if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
            av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
                   ctx->packet_size);
            return AVERROR(EINVAL);
        }
        s->packet_size = ctx->packet_size;
    } else
        s->packet_size = 2048;
    if (ctx->max_delay < 0)     /* Not set by the caller */
        ctx->max_delay = AV_TIME_BASE*7/10;
 
    s->vcd_padding_bytes_written = 0;
    s->vcd_padding_bitrate_num   = 0;
 
    s->audio_bound = 0;
    s->video_bound = 0;
 
    mpa_id  = AUDIO_ID;
    ac3_id  = AC3_ID;
    dts_id  = DTS_ID;
    mpv_id  = VIDEO_ID;
    h264_id = H264_ID;
    mps_id  = SUB_ID;
    lpcm_id = LPCM_ID;
 
    for (i = 0; i < ctx->nb_streams; i++) {
        st     = ctx->streams[i];
        stream = av_mallocz(sizeof(StreamInfo));
        if (!stream)
            return AVERROR(ENOMEM);
        st->priv_data = stream;
 
        avpriv_set_pts_info(st, 64, 1, 90000);
 
        switch (st->codecpar->codec_type) {
        case AVMEDIA_TYPE_AUDIO:
            if (!s->is_mpeg2 &&
                (st->codecpar->codec_id == AV_CODEC_ID_AC3 ||
                 st->codecpar->codec_id == AV_CODEC_ID_DTS ||
                 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ||
                 st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD))
                 av_log(ctx, AV_LOG_WARNING,
                        "%s in MPEG-1 system streams is not widely supported, "
                        "consider using the vob or the dvd muxer "
                        "to force a MPEG-2 program stream.\n",
                        avcodec_get_name(st->codecpar->codec_id));
            if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
                stream->id = ac3_id++;
            } else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {
                stream->id = dts_id++;
            } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
                stream->id = lpcm_id++;
                for (j = 0; j < 4; j++) {
                    if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
                        break;
                }
                if (j == 4) {
                    int sr;
                    av_log(ctx, AV_LOG_ERROR, "Invalid sampling rate for PCM stream.\n");
                    av_log(ctx, AV_LOG_INFO, "Allowed sampling rates:");
                    for (sr = 0; sr < 4; sr++)
                         av_log(ctx, AV_LOG_INFO, " %d", lpcm_freq_tab[sr]);
                    av_log(ctx, AV_LOG_INFO, "\n");
                    return AVERROR(EINVAL);
                }
                if (st->codecpar->ch_layout.nb_channels > 8) {
                    av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");
                    return AVERROR(EINVAL);
                }
                stream->lpcm_header[0] = 0x0c;
                stream->lpcm_header[1] = (st->codecpar->ch_layout.nb_channels - 1) | (j << 4);
                stream->lpcm_header[2] = 0x80;
                stream->lpcm_align     = st->codecpar->ch_layout.nb_channels * 2;
            } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
                int freq;
 
                switch (st->codecpar->sample_rate) {
                case 48000: freq = 0; break;
                case 96000: freq = 1; break;
                case 44100: freq = 2; break;
                case 32000: freq = 3; break;
                default:
                    av_log(ctx, AV_LOG_ERROR, "Unsupported sample rate.\n");
                    return AVERROR(EINVAL);
                }
 
                stream->lpcm_header[0] = 0x0c;
                stream->lpcm_header[1] = (freq << 4) |
                                         (((st->codecpar->bits_per_coded_sample - 16) / 4) << 6) |
                                         st->codecpar->ch_layout.nb_channels - 1;
                stream->lpcm_header[2] = 0x80;
                stream->id = lpcm_id++;
                stream->lpcm_align = st->codecpar->ch_layout.nb_channels * st->codecpar->bits_per_coded_sample / 8;
            } else if (st->codecpar->codec_id == AV_CODEC_ID_MLP ||
                       st->codecpar->codec_id == AV_CODEC_ID_TRUEHD) {
                       av_log(ctx, AV_LOG_ERROR, "Support for muxing audio codec %s not implemented.\n",
                              avcodec_get_name(st->codecpar->codec_id));
                       return AVERROR_PATCHWELCOME;
            } else if (st->codecpar->codec_id != AV_CODEC_ID_MP1 &&
                       st->codecpar->codec_id != AV_CODEC_ID_MP2 &&
                       st->codecpar->codec_id != AV_CODEC_ID_MP3) {
                       av_log(ctx, AV_LOG_ERROR, "Unsupported audio codec. Must be one of mp1, mp2, mp3, 16-bit pcm_dvd, pcm_s16be, ac3 or dts.\n");
                       return AVERROR(EINVAL);
            } else {
                stream->id = mpa_id++;
            }
 
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
             * Right now it is also used for everything else. */
            stream->max_buffer_size = 4 * 1024;
            s->audio_bound++;
            break;
        case AVMEDIA_TYPE_VIDEO: {
            const AVPacketSideData *sd;
            AVCPBProperties *props = NULL;
            if (st->codecpar->codec_id == AV_CODEC_ID_H264)
                stream->id = h264_id++;
            else
                stream->id = mpv_id++;
 
            sd = av_packet_side_data_get(st->codecpar->coded_side_data,
                                         st->codecpar->nb_coded_side_data,
                                         AV_PKT_DATA_CPB_PROPERTIES);
            if (sd)
                props = (AVCPBProperties*)sd->data;
            if (props && props->buffer_size)
                stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
            else {
                av_log(ctx, AV_LOG_WARNING,
                       "VBV buffer size not set, using default size of 230KB\n"
                       "If you want the mpeg file to be compliant to some specification\n"
                       "Like DVD, VCD or others, make sure you set the correct buffer size\n");
                // FIXME: this is probably too small as default
                stream->max_buffer_size = 230 * 1024;
            }
            if (stream->max_buffer_size > 1024 * 8191) {
                av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
                stream->max_buffer_size = 1024 * 8191;
            }
            s->video_bound++;
            break;
        }
        case AVMEDIA_TYPE_SUBTITLE:
            stream->id              = mps_id++;
            stream->max_buffer_size = 16 * 1024;
            break;
        default:
            av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
                   av_get_media_type_string(st->codecpar->codec_type), i);
            return AVERROR(EINVAL);
        }
        stream->fifo = av_fifo_alloc2(16, 1, 0);
        if (!stream->fifo)
            return AVERROR(ENOMEM);
    }
    bitrate       = 0;
    audio_bitrate = 0;
    video_bitrate = 0;
    for (i = 0; i < ctx->nb_streams; i++) {
        const AVPacketSideData *sd;
        AVCPBProperties *props = NULL;
        int codec_rate;
        st     = ctx->streams[i];
        stream = (StreamInfo *)st->priv_data;
 
        sd = av_packet_side_data_get(st->codecpar->coded_side_data,
                                     st->codecpar->nb_coded_side_data,
                                     AV_PKT_DATA_CPB_PROPERTIES);
        if (sd)
            props = (AVCPBProperties*)sd->data;
        if (props)
            codec_rate = props->max_bitrate;
        else
            codec_rate = st->codecpar->bit_rate;
 
        if (!codec_rate)
            codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
 
        bitrate += codec_rate;
 
        if ((stream->id & 0xe0) == AUDIO_ID)
            audio_bitrate += codec_rate;
        else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
            video_bitrate += codec_rate;
    }
 
    if (s->user_mux_rate) {
        s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
    } else {
        /* we increase slightly the bitrate to take into account the
         * headers. XXX: compute it exactly */
        bitrate    += bitrate / 20;
        bitrate    += 10000;
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
        if (s->mux_rate >= (1<<22)) {
            av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
            s->mux_rate = (1<<22) - 1;
        }
    }
 
    if (s->is_vcd) {
        int64_t overhead_rate;
 
        /* The VCD standard mandates that the mux_rate field is 3528
         * (see standard p. IV-6).
         * The value is actually "wrong", i.e. if you calculate
         * it using the normal formula and the 75 sectors per second transfer
         * rate you get a different value because the real pack size is 2324,
         * not 2352. But the standard explicitly specifies that the mux_rate
         * field in the header must have this value. */
        // s->mux_rate = 2352 * 75 / 50;    /* = 3528 */
 
        /* The VCD standard states that the muxed stream must be
         * exactly 75 packs / second (the data rate of a single speed cdrom).
         * Since the video bitrate (probably 1150000 bits/sec) will be below
         * the theoretical maximum we have to add some padding packets
         * to make up for the lower data rate.
         * (cf. VCD standard p. IV-6 ) */
 
        /* Add the header overhead to the data rate.
         * 2279 data bytes per audio pack, 2294 data bytes per video pack */
        overhead_rate  = audio_bitrate * 2294LL * (2324 - 2279);
        overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
 
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
        s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
#define VCD_PADDING_BITRATE_DEN (2279 * 2294)
    }
 
    if (s->is_vcd || s->is_mpeg2)
        /* every packet */
        s->pack_header_freq = 1;
    else
        /* every 2 seconds */
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
 
    /* the above seems to make pack_header_freq zero sometimes */
    if (s->pack_header_freq == 0)
        s->pack_header_freq = 1;
 
    if (s->is_mpeg2)
        /* every 200 packets. Need to look at the spec.  */
        s->system_header_freq = s->pack_header_freq * 40;
    else if (s->is_vcd)
        /* the standard mandates that there are only two system headers
         * in the whole file: one in the first packet of each stream.
         * (see standard p. IV-7 and IV-8) */
        s->system_header_freq = 0x7fffffff;
    else
        s->system_header_freq = s->pack_header_freq * 5;
 
    for (i = 0; i < ctx->nb_streams; i++) {
        stream                = ctx->streams[i]->priv_data;
        stream->packet_number = 0;
    }
    s->system_header_size = get_system_header_size(ctx);
    s->last_scr           = AV_NOPTS_VALUE;
    return 0;
}
 
static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
{
    avio_w8(pb, (id << 4) |  (((timestamp >> 30) & 0x07)   << 1) | 1);
    avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
    avio_wb16(pb, (uint16_t)((((timestamp)       & 0x7fff) << 1) | 1));
}
 
/* return the number of padding bytes that should be inserted into
 * the multiplexed stream. */
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
{
    MpegMuxContext *s = ctx->priv_data;
    int pad_bytes = 0;
 
    if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
        int64_t full_pad_bytes;
 
        // FIXME: this is wrong
        full_pad_bytes =
            av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
        pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
 
        if (pad_bytes < 0)
            /* might happen if we have already padded to a later timestamp. This
             * can occur if another stream has already advanced further. */
            pad_bytes = 0;
    }
 
    return pad_bytes;
}
 
/* Write an MPEG padding packet header. */
static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
                               int packet_bytes)
{
    MpegMuxContext *s = ctx->priv_data;
 
    avio_wb32(pb, PADDING_STREAM);
    avio_wb16(pb, packet_bytes - 6);
    if (!s->is_mpeg2) {
        avio_w8(pb, 0x0f);
        packet_bytes -= 7;
    } else
        packet_bytes -= 6;
 
    ffio_fill(pb, 0xff, packet_bytes);
}
 
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
{
    int nb_frames        = 0;
    PacketDesc *pkt_desc = stream->premux_packet;
 
    while (len > 0) {
        if (pkt_desc->size == pkt_desc->unwritten_size)
            nb_frames++;
        len     -= pkt_desc->unwritten_size;
        pkt_desc = pkt_desc->next;
    }
 
    return nb_frames;
}
 
static int fifo_avio_wrapper(void *opaque, void *buf, size_t *nb_elems)
{
    avio_write(opaque, buf, *nb_elems);
    return 0;
}
 
/* flush the packet on stream stream_index */
static int flush_packet(AVFormatContext *ctx, int stream_index,
                        int64_t pts, int64_t dts, int64_t scr, int trailer_size)
{
    MpegMuxContext *s  = ctx->priv_data;
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
    uint8_t *buf_ptr;
    int size, payload_size, startcode, id, stuffing_size, header_len;
    int packet_size;
    uint8_t buffer[128];
    int zero_trail_bytes = 0;
    int pad_packet_bytes = 0;
    int pes_flags;
    /* "general" pack without data specific to one stream? */
    int general_pack = 0;
    int nb_frames;
 
    id = stream->id;
 
    av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
 
    buf_ptr = buffer;
 
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
        /* output pack and systems header if needed */
        size        = put_pack_header(ctx, buf_ptr, scr);
        buf_ptr    += size;
        s->last_scr = scr;
 
        if (s->is_vcd) {
            /* there is exactly one system header for each stream in a VCD MPEG,
             * One in the very first video packet and one in the very first
             * audio packet (see VCD standard p. IV-7 and IV-8). */
 
            if (stream->packet_number == 0) {
                size     = put_system_header(ctx, buf_ptr, id);
                buf_ptr += size;
            }
        } else if (s->is_dvd) {
            if (stream->align_iframe || s->packet_number == 0) {
                int PES_bytes_to_fill = s->packet_size - size - 10;
 
                if (pts != AV_NOPTS_VALUE) {
                    if (dts != pts)
                        PES_bytes_to_fill -= 5 + 5;
                    else
                        PES_bytes_to_fill -= 5;
                }
 
                if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
                    size     = put_system_header(ctx, buf_ptr, 0);
                    buf_ptr += size;
                    size     = buf_ptr - buffer;
                    avio_write(ctx->pb, buffer, size);
 
                    avio_wb32(ctx->pb, PRIVATE_STREAM_2);
                    avio_wb16(ctx->pb, 0x03d4);     // length
                    avio_w8(ctx->pb, 0x00);         // substream ID, 00=PCI
                    ffio_fill(ctx->pb, 0x00, 979);
 
                    avio_wb32(ctx->pb, PRIVATE_STREAM_2);
                    avio_wb16(ctx->pb, 0x03fa);     // length
                    avio_w8(ctx->pb, 0x01);         // substream ID, 01=DSI
                    ffio_fill(ctx->pb, 0x00, 1017);
 
                    memset(buffer, 0, 128);
                    buf_ptr = buffer;
                    s->packet_number++;
                    stream->align_iframe = 0;
                    // FIXME: rounding and first few bytes of each packet
                    scr        += s->packet_size * 90000LL /
                                  (s->mux_rate * 50LL);
                    size        = put_pack_header(ctx, buf_ptr, scr);
                    s->last_scr = scr;
                    buf_ptr    += size;
                    /* GOP Start */
                } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
                    pad_packet_bytes = PES_bytes_to_fill -
                                       stream->bytes_to_iframe;
                }
            }
        } else {
            if ((s->packet_number % s->system_header_freq) == 0) {
                size     = put_system_header(ctx, buf_ptr, 0);
                buf_ptr += size;
            }
        }
    }
    size = buf_ptr - buffer;
    avio_write(ctx->pb, buffer, size);
 
    packet_size = s->packet_size - size;
 
    if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
        /* The VCD standard demands that 20 zero bytes follow
         * each audio pack (see standard p. IV-8). */
        zero_trail_bytes += 20;
 
    if ((s->is_vcd && stream->packet_number == 0) ||
        (s->is_svcd && s->packet_number == 0)) {
        /* for VCD the first pack of each stream contains only the pack header,
         * the system header and lots of padding (see VCD standard p. IV-6).
         * In the case of an audio pack, 20 zero bytes are also added at
         * the end. */
        /* For SVCD we fill the very first pack to increase compatibility with
         * some DVD players. Not mandated by the standard. */
        if (s->is_svcd)
            /* the system header refers to both streams and no stream data */
            general_pack = 1;
        pad_packet_bytes = packet_size - zero_trail_bytes;
    }
 
    packet_size -= pad_packet_bytes + zero_trail_bytes;
 
    if (packet_size > 0) {
        size_t fifo_data;
        /* packet header size */
        packet_size -= 6;
 
        /* packet header */
        if (s->is_mpeg2) {
            header_len = 3;
            if (stream->packet_number == 0)
                header_len += 3; /* PES extension */
            header_len += 1; /* obligatory stuffing byte */
        } else {
            header_len = 0;
        }
        if (pts != AV_NOPTS_VALUE) {
            if (dts != pts)
                header_len += 5 + 5;
            else
                header_len += 5;
        } else {
            if (!s->is_mpeg2)
                header_len++;
        }
 
        payload_size = packet_size - header_len;
        if (id < 0xc0) {
            startcode     = PRIVATE_STREAM_1;
            payload_size -= 1;
            if (id >= 0x40) {
                payload_size -= 3;
                if (id >= 0xa0)
                    payload_size -= 3;
            }
        } else {
            startcode = 0x100 + id;
        }
 
        stuffing_size = payload_size - av_fifo_can_read(stream->fifo);
 
        // first byte does not fit -> reset pts/dts + stuffing
        if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
            int timestamp_len = 0;
            if (dts != pts)
                timestamp_len += 5;
            if (pts != AV_NOPTS_VALUE)
                timestamp_len += s->is_mpeg2 ? 5 : 4;
            pts         =
            dts         = AV_NOPTS_VALUE;
            header_len -= timestamp_len;
            if (s->is_dvd && stream->align_iframe) {
                pad_packet_bytes += timestamp_len;
                packet_size      -= timestamp_len;
            } else {
                payload_size += timestamp_len;
            }
            stuffing_size += timestamp_len;
            if (payload_size > trailer_size)
                stuffing_size += payload_size - trailer_size;
        }
 
        // can't use padding, so use stuffing
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
            packet_size  += pad_packet_bytes;
            payload_size += pad_packet_bytes; // undo the previous adjustment
            if (stuffing_size < 0)
                stuffing_size = pad_packet_bytes;
            else
                stuffing_size += pad_packet_bytes;
            pad_packet_bytes = 0;
        }
 
        if (stuffing_size < 0)
            stuffing_size = 0;
 
        if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
            if (payload_size < av_fifo_can_read(stream->fifo))
                stuffing_size += payload_size % stream->lpcm_align;
        }
 
        if (stuffing_size > 16) {   /* <=16 for MPEG-1, <=32 for MPEG-2 */
            pad_packet_bytes += stuffing_size;
            packet_size      -= stuffing_size;
            payload_size     -= stuffing_size;
            stuffing_size     = 0;
        }
 
        nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
 
        avio_wb32(ctx->pb, startcode);
 
        avio_wb16(ctx->pb, packet_size);
 
        if (!s->is_mpeg2)
            ffio_fill(ctx->pb, 0xff, stuffing_size);
 
        if (s->is_mpeg2) {
            avio_w8(ctx->pb, 0x80); /* mpeg2 id */
 
            pes_flags = 0;
 
            if (pts != AV_NOPTS_VALUE) {
                pes_flags |= 0x80;
                if (dts != pts)
                    pes_flags |= 0x40;
            }
 
            /* Both the MPEG-2 and the SVCD standards demand that the
             * P-STD_buffer_size field be included in the first packet of
             * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
             * and MPEG-2 standard 2.7.7) */
            if (stream->packet_number == 0)
                pes_flags |= 0x01;
 
            avio_w8(ctx->pb, pes_flags); /* flags */
            avio_w8(ctx->pb, header_len - 3 + stuffing_size);
 
            if (pes_flags & 0x80)  /* write pts */
                put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
            if (pes_flags & 0x40)  /* write dts */
                put_timestamp(ctx->pb, 0x01, dts);
 
            if (pes_flags & 0x01) {  /* write pes extension */
                avio_w8(ctx->pb, 0x10); /* flags */
 
                /* P-STD buffer info */
                if ((id & 0xe0) == AUDIO_ID)
                    avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
                else
                    avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
            }
        } else {
            if (pts != AV_NOPTS_VALUE) {
                if (dts != pts) {
                    put_timestamp(ctx->pb, 0x03, pts);
                    put_timestamp(ctx->pb, 0x01, dts);
                } else {
                    put_timestamp(ctx->pb, 0x02, pts);
                }
            } else {
                avio_w8(ctx->pb, 0x0f);
            }
        }
 
        if (s->is_mpeg2) {
            /* special stuffing byte that is always written
             * to prevent accidental generation of start codes. */
            avio_w8(ctx->pb, 0xff);
 
            ffio_fill(ctx->pb, 0xff, stuffing_size);
        }
 
        if (startcode == PRIVATE_STREAM_1) {
            avio_w8(ctx->pb, id);
            if (id >= 0xa0) {
                /* LPCM (XXX: check nb_frames) */
                avio_w8(ctx->pb, 7);
                avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
                avio_w8(ctx->pb, stream->lpcm_header[0]);
                avio_w8(ctx->pb, stream->lpcm_header[1]);
                avio_w8(ctx->pb, stream->lpcm_header[2]);
            } else if (id >= 0x40) {
                /* AC-3 */
                avio_w8(ctx->pb, nb_frames);
                avio_wb16(ctx->pb, trailer_size + 1);
            }
        }
 
        /* output data */
        fifo_data = payload_size - stuffing_size;
        av_assert0(fifo_data <= av_fifo_can_read(stream->fifo));
        av_fifo_read_to_cb(stream->fifo, fifo_avio_wrapper, ctx->pb, &fifo_data);
        stream->bytes_to_iframe -= fifo_data;
    } else {
        payload_size  =
        stuffing_size = 0;
    }
 
    if (pad_packet_bytes > 0)
        put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
 
    ffio_fill(ctx->pb, 0x00, zero_trail_bytes);
 
    avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
 
    s->packet_number++;
 
    /* only increase the stream packet number if this pack actually contains
     * something that is specific to this stream! I.e. a dedicated header
     * or some data. */
    if (!general_pack)
        stream->packet_number++;
 
    return payload_size - stuffing_size;
}
 
static void put_vcd_padding_sector(AVFormatContext *ctx)
{
    /* There are two ways to do this padding: writing a sector/pack
     * of 0 values, or writing an MPEG padding pack. Both seem to
     * work with most decoders, BUT the VCD standard only allows a 0-sector
     * (see standard p. IV-4, IV-5).
     * So a 0-sector it is... */
 
    MpegMuxContext *s = ctx->priv_data;
 
    ffio_fill(ctx->pb, 0, s->packet_size);
 
    s->vcd_padding_bytes_written += s->packet_size;
 
    avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
 
    /* increasing the packet number is correct. The SCR of the following packs
     * is calculated from the packet_number and it has to include the padding
     * sector (it represents the sector index, not the MPEG pack index)
     * (see VCD standard p. IV-6) */
    s->packet_number++;
}
 
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
{
    int i;
 
    for (i = 0; i < ctx->nb_streams; i++) {
        AVStream *st = ctx->streams[i];
        StreamInfo *stream = st->priv_data;
        PacketDesc *pkt_desc;
 
        while ((pkt_desc = stream->predecode_packet) &&
               scr > pkt_desc->dts) { // FIXME: > vs >=
            if (stream->buffer_index < pkt_desc->size ||
                stream->predecode_packet == stream->premux_packet) {
                av_log(ctx, AV_LOG_ERROR,
                       "buffer underflow st=%d bufi=%d size=%d\n",
                       i, stream->buffer_index, pkt_desc->size);
                break;
            }
            stream->buffer_index    -= pkt_desc->size;
            stream->predecode_packet = pkt_desc->next;
            if (!stream->predecode_packet)
                stream->last_packet = NULL;
            av_freep(&pkt_desc);
        }
    }
 
    return 0;
}
 
static int output_packet(AVFormatContext *ctx, int flush)
{
    MpegMuxContext *s = ctx->priv_data;
    AVStream *st;
    StreamInfo *stream;
    int i, avail_space = 0, es_size, trailer_size;
    int best_i = -1;
    int best_score = INT_MIN;
    int ignore_constraints = 0;
    int ignore_delay = 0;
    int64_t scr = s->last_scr;
    PacketDesc *timestamp_packet;
    const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
 
retry:
    for (i = 0; i < ctx->nb_streams; i++) {
        AVStream *st = ctx->streams[i];
        StreamInfo *stream = st->priv_data;
        const size_t avail_data = av_fifo_can_read(stream->fifo);
        const int space = stream->max_buffer_size - stream->buffer_index;
        int rel_space = 1024LL * space / stream->max_buffer_size;
        PacketDesc *next_pkt = stream->premux_packet;
 
        /* for subtitle, a single PES packet must be generated,
         * so we flush after every single subtitle packet */
        if (s->packet_size > avail_data && !flush
            && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
            return 0;
        if (avail_data == 0)
            continue;
        av_assert0(avail_data > 0);
 
        if (space < s->packet_size && !ignore_constraints)
            continue;
 
        if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
            continue;
        if (   stream->predecode_packet
            && stream->predecode_packet->size > stream->buffer_index)
            rel_space += 1<<28;
        if (rel_space > best_score) {
            best_score  = rel_space;
            best_i      = i;
            avail_space = space;
        }
    }
 
    if (best_i < 0) {
        int64_t best_dts = INT64_MAX;
        int has_premux = 0;
 
        for (i = 0; i < ctx->nb_streams; i++) {
            AVStream *st = ctx->streams[i];
            StreamInfo *stream = st->priv_data;
            PacketDesc *pkt_desc = stream->predecode_packet;
            if (pkt_desc && pkt_desc->dts < best_dts)
                best_dts = pkt_desc->dts;
            has_premux |= !!stream->premux_packet;
        }
 
        if (best_dts < INT64_MAX) {
            av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
                    scr / 90000.0, best_dts / 90000.0);
 
            if (scr >= best_dts + 1 && !ignore_constraints) {
                av_log(ctx, AV_LOG_ERROR,
                    "packet too large, ignoring buffer limits to mux it\n");
                ignore_constraints = 1;
            }
            scr = FFMAX(best_dts + 1, scr);
            if (remove_decoded_packets(ctx, scr) < 0)
                return -1;
        } else if (has_premux && flush) {
            av_log(ctx, AV_LOG_ERROR,
                  "delay too large, ignoring ...\n");
            ignore_delay = 1;
            ignore_constraints = 1;
        } else
            return 0;
 
        goto retry;
    }
 
    av_assert0(best_i >= 0);
 
    st     = ctx->streams[best_i];
    stream = st->priv_data;
 
    av_assert0(av_fifo_can_read(stream->fifo) > 0);
 
    av_assert0(avail_space >= s->packet_size || ignore_constraints);
 
    timestamp_packet = stream->premux_packet;
    if (timestamp_packet->unwritten_size == timestamp_packet->size) {
        trailer_size = 0;
    } else {
        trailer_size     = timestamp_packet->unwritten_size;
        timestamp_packet = timestamp_packet->next;
    }
 
    if (timestamp_packet) {
        av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
                timestamp_packet->dts / 90000.0,
                timestamp_packet->pts / 90000.0,
                scr / 90000.0, best_i);
        es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
                               timestamp_packet->dts, scr, trailer_size);
    } else {
        av_assert0(av_fifo_can_read(stream->fifo) == trailer_size);
        es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
                               trailer_size);
    }
 
    if (s->is_vcd) {
        /* Write one or more padding sectors, if necessary, to reach
         * the constant overall bitrate. */
        int vcd_pad_bytes;
 
        // FIXME: pts cannot be correct here
        while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
            put_vcd_padding_sector(ctx);
            // FIXME: rounding and first few bytes of each packet
            s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
        }
    }
 
    stream->buffer_index += es_size;
    // FIXME: rounding and first few bytes of each packet
    s->last_scr          += s->packet_size * 90000LL / (s->mux_rate * 50LL);
 
    while (stream->premux_packet &&
           stream->premux_packet->unwritten_size <= es_size) {
        es_size              -= stream->premux_packet->unwritten_size;
        stream->premux_packet = stream->premux_packet->next;
    }
    if (es_size) {
        av_assert0(stream->premux_packet);
        stream->premux_packet->unwritten_size -= es_size;
    }
 
    if (remove_decoded_packets(ctx, s->last_scr) < 0)
        return -1;
 
    return 1;
}
 
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
{
    int stream_index = pkt->stream_index;
    int size         = pkt->size;
    const uint8_t *buf = pkt->data;
    MpegMuxContext *s = ctx->priv_data;
    AVStream *st      = ctx->streams[stream_index];
    StreamInfo *stream = st->priv_data;
    int64_t pts, dts;
    PacketDesc *pkt_desc;
    int preload, ret;
    size_t can_write;
    const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
                          (pkt->flags & AV_PKT_FLAG_KEY);
 
    preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
 
    pts = pkt->pts;
    dts = pkt->dts;
 
    if (s->last_scr == AV_NOPTS_VALUE) {
        if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
            if (dts != AV_NOPTS_VALUE)
                s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
            s->last_scr = 0;
        } else {
            s->last_scr = dts - preload;
            s->preload = 0;
        }
        preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
        av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
    }
 
    if (dts != AV_NOPTS_VALUE) dts += preload;
    if (pts != AV_NOPTS_VALUE) pts += preload;
 
    av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
            dts / 90000.0, pts / 90000.0, pkt->flags,
            pkt->stream_index, pts != AV_NOPTS_VALUE);
 
    if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
        if (size < 3) {
            av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
            return AVERROR(EINVAL);
        }
 
        /* Skip first 3 bytes of packet data, which comprise PCM header
           and will be written fresh by this muxer. */
        buf += 3;
        size -= 3;
    }
 
    /* Enlarge the FIFO before adding a new PacketDesc
     * in order to avoid inconsistencies on failure. */
    can_write = av_fifo_can_write(stream->fifo);
    if (can_write < size) {
        ret = av_fifo_grow2(stream->fifo, size - can_write);
        if (ret < 0)
            return ret;
    }
    pkt_desc                 = av_mallocz(sizeof(PacketDesc));
    if (!pkt_desc)
        return AVERROR(ENOMEM);
    if (!stream->predecode_packet) {
        stream->predecode_packet  = pkt_desc;
    } else
        stream->last_packet->next = pkt_desc;
    stream->last_packet = pkt_desc;
    if (!stream->premux_packet)
        stream->premux_packet = pkt_desc;
    pkt_desc->pts            = pts;
    pkt_desc->dts            = dts;
    pkt_desc->unwritten_size =
    pkt_desc->size           = size;
 
    if (s->is_dvd) {
        // min VOBU length 0.4 seconds (mpucoder)
        if (is_iframe &&
            (s->packet_number == 0 || pts != AV_NOPTS_VALUE &&
             (pts - stream->vobu_start_pts >= 36000))) {
            stream->bytes_to_iframe = av_fifo_can_read(stream->fifo);
            stream->align_iframe    = 1;
            stream->vobu_start_pts  = pts;
        }
    }
 
    av_fifo_write(stream->fifo, buf, size);
 
    for (;;) {
        int ret = output_packet(ctx, 0);
        if (ret <= 0)
            return ret;
    }
}
 
static int mpeg_mux_end(AVFormatContext *ctx)
{
    StreamInfo *stream;
    int i;
 
    for (;;) {
        int ret = output_packet(ctx, 1);
        if (ret < 0)
            return ret;
        else if (ret == 0)
            break;
    }
 
    /* End header according to MPEG-1 systems standard. We do not write
     * it as it is usually not needed by decoders and because it
     * complicates MPEG stream concatenation. */
    // avio_wb32(ctx->pb, ISO_11172_END_CODE);
 
    for (i = 0; i < ctx->nb_streams; i++) {
        stream = ctx->streams[i]->priv_data;
 
        av_assert0(av_fifo_can_read(stream->fifo) == 0);
    }
    return 0;
}
 
static void mpeg_mux_deinit(AVFormatContext *ctx)
{
    for (int i = 0; i < ctx->nb_streams; i++) {
        StreamInfo *stream = ctx->streams[i]->priv_data;
        if (!stream)
            continue;
        for (PacketDesc *pkt = stream->predecode_packet; pkt; ) {
            PacketDesc *tmp = pkt->next;
            av_free(pkt);
            pkt = tmp;
        }
        av_fifo_freep2(&stream->fifo);
    }
}
 
#define OFFSET(x) offsetof(MpegMuxContext, x)
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
    { "muxrate", "mux rate as bits/s", OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
    { "preload", "initial demux-decode delay in microseconds", OFFSET(preload),  AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
    { NULL },
};
 
static const AVClass mpeg_class = {
    .class_name = "mpeg/(s)vcd/vob/dvd muxer",
    .item_name  = av_default_item_name,
    .version    = LIBAVUTIL_VERSION_INT,
    .option     = options,
};
 
#if CONFIG_MPEG1SYSTEM_MUXER
const FFOutputFormat ff_mpeg1system_muxer = {
    .p.name            = "mpeg",
    .p.long_name       = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
    .p.mime_type       = "video/mpeg",
    .p.extensions      = "mpg,mpeg",
    .priv_data_size    = sizeof(MpegMuxContext),
    .p.audio_codec     = AV_CODEC_ID_MP2,
    .p.video_codec     = AV_CODEC_ID_MPEG1VIDEO,
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
    .deinit            = mpeg_mux_deinit,
    .p.priv_class      = &mpeg_class,
};
#endif
 
#if CONFIG_MPEG1VCD_MUXER
const FFOutputFormat ff_mpeg1vcd_muxer = {
    .p.name            = "vcd",
    .p.long_name       = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
    .p.mime_type       = "video/mpeg",
    .priv_data_size    = sizeof(MpegMuxContext),
    .p.audio_codec     = AV_CODEC_ID_MP2,
    .p.video_codec     = AV_CODEC_ID_MPEG1VIDEO,
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
    .deinit            = mpeg_mux_deinit,
    .p.priv_class      = &mpeg_class,
};
#endif
 
#if CONFIG_MPEG2VOB_MUXER
const FFOutputFormat ff_mpeg2vob_muxer = {
    .p.name            = "vob",
    .p.long_name       = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
    .p.mime_type       = "video/mpeg",
    .p.extensions      = "vob",
    .priv_data_size    = sizeof(MpegMuxContext),
    .p.audio_codec     = AV_CODEC_ID_MP2,
    .p.video_codec     = AV_CODEC_ID_MPEG2VIDEO,
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
    .deinit            = mpeg_mux_deinit,
    .p.priv_class      = &mpeg_class,
};
#endif
 
/* Same as mpeg2vob_mux except that the pack size is 2324 */
#if CONFIG_MPEG2SVCD_MUXER
const FFOutputFormat ff_mpeg2svcd_muxer = {
    .p.name            = "svcd",
    .p.long_name       = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
    .p.mime_type       = "video/mpeg",
    .p.extensions      = "vob",
    .priv_data_size    = sizeof(MpegMuxContext),
    .p.audio_codec     = AV_CODEC_ID_MP2,
    .p.video_codec     = AV_CODEC_ID_MPEG2VIDEO,
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
    .deinit            = mpeg_mux_deinit,
    .p.priv_class      = &mpeg_class,
};
#endif
 
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
#if CONFIG_MPEG2DVD_MUXER
const FFOutputFormat ff_mpeg2dvd_muxer = {
    .p.name            = "dvd",
    .p.long_name       = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
    .p.mime_type       = "video/mpeg",
    .p.extensions      = "dvd",
    .priv_data_size    = sizeof(MpegMuxContext),
    .p.audio_codec     = AV_CODEC_ID_MP2,
    .p.video_codec     = AV_CODEC_ID_MPEG2VIDEO,
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
    .deinit            = mpeg_mux_deinit,
    .p.priv_class      = &mpeg_class,
};
#endif