git.sesse.net Git - ffmpeg/blob - libavformat/mpegenc.c

   1 /*
   2  * MPEG1/2 muxer
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdint.h>
  23
  24 #include "libavutil/attributes.h"
  25 #include "libavutil/fifo.h"
  26 #include "libavutil/log.h"
  27 #include "libavutil/mathematics.h"
  28 #include "libavutil/opt.h"
  29 #include "libavcodec/put_bits.h"
  30 #include "avformat.h"
  31 #include "internal.h"
  32 #include "mpeg.h"
  33
  34 #define MAX_PAYLOAD_SIZE 4096
  35
  36 #undef NDEBUG
  37 #include <assert.h>
  38
  39 typedef struct PacketDesc {
  40     int64_t pts;
  41     int64_t dts;
  42     int size;
  43     int unwritten_size;
  44     int flags;
  45     struct PacketDesc *next;
  46 } PacketDesc;
  47
  48 typedef struct {
  49     AVFifoBuffer *fifo;
  50     uint8_t id;
  51     int max_buffer_size; /* in bytes */
  52     int buffer_index;
  53     PacketDesc *predecode_packet;
  54     PacketDesc *premux_packet;
  55     PacketDesc **next_packet;
  56     int packet_number;
  57     uint8_t lpcm_header[3];
  58     int lpcm_align;
  59     int bytes_to_iframe;
  60     int align_iframe;
  61     int64_t vobu_start_pts;
  62 } StreamInfo;
  63
  64 typedef struct {
  65     const AVClass *class;
  66     int packet_size; /* required packet size */
  67     int packet_number;
  68     int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
  69     int system_header_freq;
  70     int system_header_size;
  71     int user_mux_rate; /* bitrate in units of bits/s */
  72     int mux_rate; /* bitrate in units of 50 bytes/s */
  73     /* stream info */
  74     int audio_bound;
  75     int video_bound;
  76     int is_mpeg2;
  77     int is_vcd;
  78     int is_svcd;
  79     int is_dvd;
  80     int64_t last_scr; /* current system clock */
  81
  82     double vcd_padding_bitrate; //FIXME floats
  83     int64_t vcd_padding_bytes_written;
  84
  85     int preload;
  86 } MpegMuxContext;
  87
  88 extern AVOutputFormat ff_mpeg1vcd_muxer;
  89 extern AVOutputFormat ff_mpeg2dvd_muxer;
  90 extern AVOutputFormat ff_mpeg2svcd_muxer;
  91 extern AVOutputFormat ff_mpeg2vob_muxer;
  92
  93 static int put_pack_header(AVFormatContext *ctx,
  94                            uint8_t *buf, int64_t timestamp)
  95 {
  96     MpegMuxContext *s = ctx->priv_data;
  97     PutBitContext pb;
  98
  99     init_put_bits(&pb, buf, 128);
 100
 101     put_bits32(&pb, PACK_START_CODE);
 102     if (s->is_mpeg2) {
 103         put_bits(&pb, 2, 0x1);
 104     } else {
 105         put_bits(&pb, 4, 0x2);
 106     }
 107     put_bits(&pb, 3,  (uint32_t)((timestamp >> 30) & 0x07));
 108     put_bits(&pb, 1, 1);
 109     put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
 110     put_bits(&pb, 1, 1);
 111     put_bits(&pb, 15, (uint32_t)((timestamp      ) & 0x7fff));
 112     put_bits(&pb, 1, 1);
 113     if (s->is_mpeg2) {
 114         /* clock extension */
 115         put_bits(&pb, 9, 0);
 116     }
 117     put_bits(&pb, 1, 1);
 118     put_bits(&pb, 22, s->mux_rate);
 119     put_bits(&pb, 1, 1);
 120     if (s->is_mpeg2) {
 121         put_bits(&pb, 1, 1);
 122         put_bits(&pb, 5, 0x1f); /* reserved */
 123         put_bits(&pb, 3, 0); /* stuffing length */
 124     }
 125     flush_put_bits(&pb);
 126     return put_bits_ptr(&pb) - pb.buf;
 127 }
 128
 129 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
 130 {
 131     MpegMuxContext *s = ctx->priv_data;
 132     int size, i, private_stream_coded, id;
 133     PutBitContext pb;
 134
 135     init_put_bits(&pb, buf, 128);
 136
 137     put_bits32(&pb, SYSTEM_HEADER_START_CODE);
 138     put_bits(&pb, 16, 0);
 139     put_bits(&pb, 1, 1);
 140
 141     put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
 142     put_bits(&pb, 1, 1); /* marker */
 143     if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
 144         /* This header applies only to the video stream (see VCD standard p. IV-7)*/
 145         put_bits(&pb, 6, 0);
 146     } else
 147         put_bits(&pb, 6, s->audio_bound);
 148
 149     if (s->is_vcd) {
 150         /* see VCD standard, p. IV-7*/
 151         put_bits(&pb, 1, 0);
 152         put_bits(&pb, 1, 1);
 153     } else {
 154         put_bits(&pb, 1, 0); /* variable bitrate*/
 155         put_bits(&pb, 1, 0); /* non constrainted bit stream */
 156     }
 157
 158     if (s->is_vcd || s->is_dvd) {
 159         /* see VCD standard p IV-7 */
 160         put_bits(&pb, 1, 1); /* audio locked */
 161         put_bits(&pb, 1, 1); /* video locked */
 162     } else {
 163         put_bits(&pb, 1, 0); /* audio locked */
 164         put_bits(&pb, 1, 0); /* video locked */
 165     }
 166
 167     put_bits(&pb, 1, 1); /* marker */
 168
 169     if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
 170         /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
 171         put_bits(&pb, 5, 0);
 172     } else
 173         put_bits(&pb, 5, s->video_bound);
 174
 175     if (s->is_dvd) {
 176         put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
 177         put_bits(&pb, 7, 0x7f); /* reserved byte */
 178     } else
 179         put_bits(&pb, 8, 0xff); /* reserved byte */
 180
 181     /* DVD-Video Stream_bound entries
 182     id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
 183     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)
 184     id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
 185     id (0xBF) private stream 2, NAV packs, set to 2x1024. */
 186     if (s->is_dvd) {
 187
 188         int P_STD_max_video = 0;
 189         int P_STD_max_mpeg_audio = 0;
 190         int P_STD_max_mpeg_PS1 = 0;
 191
 192         for(i=0;i<ctx->nb_streams;i++) {
 193             StreamInfo *stream = ctx->streams[i]->priv_data;
 194
 195             id = stream->id;
 196             if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
 197                 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
 198             } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
 199                 P_STD_max_mpeg_audio = stream->max_buffer_size;
 200             } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
 201                 P_STD_max_video = stream->max_buffer_size;
 202             }
 203         }
 204
 205         /* video */
 206         put_bits(&pb, 8, 0xb9); /* stream ID */
 207         put_bits(&pb, 2, 3);
 208         put_bits(&pb, 1, 1);
 209         put_bits(&pb, 13, P_STD_max_video / 1024);
 210
 211         /* audio */
 212         if (P_STD_max_mpeg_audio == 0)
 213             P_STD_max_mpeg_audio = 4096;
 214         put_bits(&pb, 8, 0xb8); /* stream ID */
 215         put_bits(&pb, 2, 3);
 216         put_bits(&pb, 1, 0);
 217         put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
 218
 219         /* private stream 1 */
 220         put_bits(&pb, 8, 0xbd); /* stream ID */
 221         put_bits(&pb, 2, 3);
 222         put_bits(&pb, 1, 0);
 223         put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
 224
 225         /* private stream 2 */
 226         put_bits(&pb, 8, 0xbf); /* stream ID */
 227         put_bits(&pb, 2, 3);
 228         put_bits(&pb, 1, 1);
 229         put_bits(&pb, 13, 2);
 230     }
 231     else {
 232         /* audio stream info */
 233         private_stream_coded = 0;
 234         for(i=0;i<ctx->nb_streams;i++) {
 235             StreamInfo *stream = ctx->streams[i]->priv_data;
 236
 237
 238             /* For VCDs, only include the stream info for the stream
 239             that the pack which contains this system belongs to.
 240             (see VCD standard p. IV-7) */
 241             if ( !s->is_vcd || stream->id==only_for_stream_id
 242                 || only_for_stream_id==0) {
 243
 244                 id = stream->id;
 245                 if (id < 0xc0) {
 246                     /* special case for private streams (AC-3 uses that) */
 247                     if (private_stream_coded)
 248                         continue;
 249                     private_stream_coded = 1;
 250                     id = 0xbd;
 251                 }
 252                 put_bits(&pb, 8, id); /* stream ID */
 253                 put_bits(&pb, 2, 3);
 254                 if (id < 0xe0) {
 255                     /* audio */
 256                     put_bits(&pb, 1, 0);
 257                     put_bits(&pb, 13, stream->max_buffer_size / 128);
 258                 } else {
 259                     /* video */
 260                     put_bits(&pb, 1, 1);
 261                     put_bits(&pb, 13, stream->max_buffer_size / 1024);
 262                 }
 263             }
 264         }
 265     }
 266
 267     flush_put_bits(&pb);
 268     size = put_bits_ptr(&pb) - pb.buf;
 269     /* patch packet size */
 270     AV_WB16(buf + 4, size - 6);
 271
 272     return size;
 273 }
 274
 275 static int get_system_header_size(AVFormatContext *ctx)
 276 {
 277     int buf_index, i, private_stream_coded;
 278     StreamInfo *stream;
 279     MpegMuxContext *s = ctx->priv_data;
 280
 281     if (s->is_dvd)
 282        return 18; // DVD-Video system headers are 18 bytes fixed length.
 283
 284     buf_index = 12;
 285     private_stream_coded = 0;
 286     for(i=0;i<ctx->nb_streams;i++) {
 287         stream = ctx->streams[i]->priv_data;
 288         if (stream->id < 0xc0) {
 289             if (private_stream_coded)
 290                 continue;
 291             private_stream_coded = 1;
 292         }
 293         buf_index += 3;
 294     }
 295     return buf_index;
 296 }
 297
 298 static av_cold int mpeg_mux_init(AVFormatContext *ctx)
 299 {
 300     MpegMuxContext *s = ctx->priv_data;
 301     int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
 302     AVStream *st;
 303     StreamInfo *stream;
 304     int audio_bitrate;
 305     int video_bitrate;
 306
 307     s->packet_number = 0;
 308     s->is_vcd =    (CONFIG_MPEG1VCD_MUXER  && ctx->oformat == &ff_mpeg1vcd_muxer);
 309     s->is_svcd =   (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
 310     s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER  && ctx->oformat == &ff_mpeg2vob_muxer) ||
 311                    (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &ff_mpeg2dvd_muxer) ||
 312                    (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
 313     s->is_dvd =    (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &ff_mpeg2dvd_muxer);
 314
 315     if(ctx->packet_size) {
 316         if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
 317             av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
 318                    ctx->packet_size);
 319             goto fail;
 320         }
 321         s->packet_size = ctx->packet_size;
 322     } else
 323         s->packet_size = 2048;
 324     if (ctx->max_delay < 0) /* Not set by the caller */
 325         ctx->max_delay = 0.7*AV_TIME_BASE;
 326
 327     s->vcd_padding_bytes_written = 0;
 328     s->vcd_padding_bitrate=0;
 329
 330     s->audio_bound = 0;
 331     s->video_bound = 0;
 332     mpa_id = AUDIO_ID;
 333     ac3_id = AC3_ID;
 334     dts_id = DTS_ID;
 335     mpv_id = VIDEO_ID;
 336     mps_id = SUB_ID;
 337     lpcm_id = LPCM_ID;
 338     for(i=0;i<ctx->nb_streams;i++) {
 339         st = ctx->streams[i];
 340         stream = av_mallocz(sizeof(StreamInfo));
 341         if (!stream)
 342             goto fail;
 343         st->priv_data = stream;
 344
 345         avpriv_set_pts_info(st, 64, 1, 90000);
 346
 347         switch(st->codec->codec_type) {
 348         case AVMEDIA_TYPE_AUDIO:
 349             if (!s->is_mpeg2 &&
 350                 (st->codec->codec_id == AV_CODEC_ID_AC3 ||
 351                  st->codec->codec_id == AV_CODEC_ID_DTS ||
 352                  st->codec->codec_id == AV_CODEC_ID_PCM_S16BE))
 353                  av_log(ctx, AV_LOG_WARNING,
 354                         "%s in MPEG-1 system streams is not widely supported, "
 355                         "consider using the vob or the dvd muxer "
 356                         "to force a MPEG-2 program stream.\n",
 357                         avcodec_get_name(st->codec->codec_id));
 358             if        (st->codec->codec_id == AV_CODEC_ID_AC3) {
 359                 stream->id = ac3_id++;
 360             } else if (st->codec->codec_id == AV_CODEC_ID_DTS) {
 361                 stream->id = dts_id++;
 362             } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
 363                 stream->id = lpcm_id++;
 364                 for(j = 0; j < 4; j++) {
 365                     if (lpcm_freq_tab[j] == st->codec->sample_rate)
 366                         break;
 367                 }
 368                 if (j == 4)
 369                     goto fail;
 370                 if (st->codec->channels > 8)
 371                     return -1;
 372                 stream->lpcm_header[0] = 0x0c;
 373                 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
 374                 stream->lpcm_header[2] = 0x80;
 375                 stream->lpcm_align = st->codec->channels * 2;
 376             } else {
 377                 stream->id = mpa_id++;
 378             }
 379
 380             /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
 381                Right now it is also used for everything else.*/
 382             stream->max_buffer_size = 4 * 1024;
 383             s->audio_bound++;
 384             break;
 385         case AVMEDIA_TYPE_VIDEO:
 386             stream->id = mpv_id++;
 387             if (st->codec->rc_buffer_size)
 388                 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
 389             else {
 390                 av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, using default size of 130KB\n"
 391                                             "If you want the mpeg file to be compliant to some specification\n"
 392                                             "Like DVD, VCD or others, make sure you set the correct buffer size\n");
 393                 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
 394             }
 395             if (stream->max_buffer_size > 1024 * 8191) {
 396                 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
 397                 stream->max_buffer_size = 1024 * 8191;
 398             }
 399             s->video_bound++;
 400             break;
 401         case AVMEDIA_TYPE_SUBTITLE:
 402             stream->id = mps_id++;
 403             stream->max_buffer_size = 16 * 1024;
 404             break;
 405         default:
 406             return -1;
 407         }
 408         stream->fifo= av_fifo_alloc(16);
 409         if (!stream->fifo)
 410             goto fail;
 411     }
 412     bitrate = 0;
 413     audio_bitrate = 0;
 414     video_bitrate = 0;
 415     for(i=0;i<ctx->nb_streams;i++) {
 416         int codec_rate;
 417         st = ctx->streams[i];
 418         stream = (StreamInfo*) st->priv_data;
 419
 420         if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
 421             codec_rate= st->codec->rc_max_rate;
 422         else
 423             codec_rate= st->codec->bit_rate;
 424
 425         if(!codec_rate)
 426             codec_rate= (1<<21)*8*50/ctx->nb_streams;
 427
 428         bitrate += codec_rate;
 429
 430         if ((stream->id & 0xe0) == AUDIO_ID)
 431             audio_bitrate += codec_rate;
 432         else if (stream->id==VIDEO_ID)
 433             video_bitrate += codec_rate;
 434     }
 435
 436     if (s->user_mux_rate) {
 437         s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
 438     } else {
 439         /* we increase slightly the bitrate to take into account the
 440            headers. XXX: compute it exactly */
 441         bitrate += bitrate / 20;
 442         bitrate += 10000;
 443         s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
 444         if (s->mux_rate >= (1<<22)) {
 445             av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
 446             s->mux_rate = (1<<22) - 1;
 447         }
 448     }
 449
 450     if (s->is_vcd) {
 451         double overhead_rate;
 452
 453         /* The VCD standard mandates that the mux_rate field is 3528
 454            (see standard p. IV-6).
 455            The value is actually "wrong", i.e. if you calculate
 456            it using the normal formula and the 75 sectors per second transfer
 457            rate you get a different value because the real pack size is 2324,
 458            not 2352. But the standard explicitly specifies that the mux_rate
 459            field in the header must have this value.*/
 460 //        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
 461
 462         /* The VCD standard states that the muxed stream must be
 463            exactly 75 packs / second (the data rate of a single speed cdrom).
 464            Since the video bitrate (probably 1150000 bits/sec) will be below
 465            the theoretical maximum we have to add some padding packets
 466            to make up for the lower data rate.
 467            (cf. VCD standard p. IV-6 )*/
 468
 469         /* Add the header overhead to the data rate.
 470            2279 data bytes per audio pack, 2294 data bytes per video pack*/
 471         overhead_rate  = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
 472         overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
 473         overhead_rate *= 8;
 474
 475         /* Add padding so that the full bitrate is 2324*75 bytes/sec */
 476         s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
 477     }
 478
 479     if (s->is_vcd || s->is_mpeg2)
 480         /* every packet */
 481         s->pack_header_freq = 1;
 482     else
 483         /* every 2 seconds */
 484         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
 485
 486     /* the above seems to make pack_header_freq zero sometimes */
 487     if (s->pack_header_freq == 0)
 488        s->pack_header_freq = 1;
 489
 490     if (s->is_mpeg2)
 491         /* every 200 packets. Need to look at the spec.  */
 492         s->system_header_freq = s->pack_header_freq * 40;
 493     else if (s->is_vcd)
 494         /* the standard mandates that there are only two system headers
 495            in the whole file: one in the first packet of each stream.
 496            (see standard p. IV-7 and IV-8) */
 497         s->system_header_freq = 0x7fffffff;
 498     else
 499         s->system_header_freq = s->pack_header_freq * 5;
 500
 501     for(i=0;i<ctx->nb_streams;i++) {
 502         stream = ctx->streams[i]->priv_data;
 503         stream->packet_number = 0;
 504     }
 505     s->system_header_size = get_system_header_size(ctx);
 506     s->last_scr = AV_NOPTS_VALUE;
 507     return 0;
 508  fail:
 509     for(i=0;i<ctx->nb_streams;i++) {
 510         av_free(ctx->streams[i]->priv_data);
 511     }
 512     return AVERROR(ENOMEM);
 513 }
 514
 515 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
 516 {
 517     avio_w8(pb,
 518              (id << 4) |
 519              (((timestamp >> 30) & 0x07) << 1) |
 520              1);
 521     avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
 522     avio_wb16(pb, (uint16_t)((((timestamp      ) & 0x7fff) << 1) | 1));
 523 }
 524
 525
 526 /* return the number of padding bytes that should be inserted into
 527    the multiplexed stream.*/
 528 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
 529 {
 530     MpegMuxContext *s = ctx->priv_data;
 531     int pad_bytes = 0;
 532
 533     if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
 534     {
 535         int64_t full_pad_bytes;
 536
 537         full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
 538         pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
 539
 540         if (pad_bytes<0)
 541             /* might happen if we have already padded to a later timestamp. This
 542                can occur if another stream has already advanced further.*/
 543             pad_bytes=0;
 544     }
 545
 546     return pad_bytes;
 547 }
 548
 549
 550 /* Write an MPEG padding packet header. */
 551 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
 552 {
 553     MpegMuxContext *s = ctx->priv_data;
 554     int i;
 555
 556     avio_wb32(pb, PADDING_STREAM);
 557     avio_wb16(pb, packet_bytes - 6);
 558     if (!s->is_mpeg2) {
 559         avio_w8(pb, 0x0f);
 560         packet_bytes -= 7;
 561     } else
 562         packet_bytes -= 6;
 563
 564     for(i=0;i<packet_bytes;i++)
 565         avio_w8(pb, 0xff);
 566 }
 567
 568 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
 569     int nb_frames=0;
 570     PacketDesc *pkt_desc= stream->premux_packet;
 571
 572     while(len>0){
 573         if(pkt_desc->size == pkt_desc->unwritten_size)
 574             nb_frames++;
 575         len -= pkt_desc->unwritten_size;
 576         pkt_desc= pkt_desc->next;
 577     }
 578
 579     return nb_frames;
 580 }
 581
 582 /* flush the packet on stream stream_index */
 583 static int flush_packet(AVFormatContext *ctx, int stream_index,
 584                          int64_t pts, int64_t dts, int64_t scr, int trailer_size)
 585 {
 586     MpegMuxContext *s = ctx->priv_data;
 587     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
 588     uint8_t *buf_ptr;
 589     int size, payload_size, startcode, id, stuffing_size, i, header_len;
 590     int packet_size;
 591     uint8_t buffer[128];
 592     int zero_trail_bytes = 0;
 593     int pad_packet_bytes = 0;
 594     int pes_flags;
 595     int general_pack = 0;  /*"general" pack without data specific to one stream?*/
 596     int nb_frames;
 597
 598     id = stream->id;
 599
 600     av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
 601
 602     buf_ptr = buffer;
 603
 604     if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
 605         /* output pack and systems header if needed */
 606         size = put_pack_header(ctx, buf_ptr, scr);
 607         buf_ptr += size;
 608         s->last_scr= scr;
 609
 610         if (s->is_vcd) {
 611             /* there is exactly one system header for each stream in a VCD MPEG,
 612                One in the very first video packet and one in the very first
 613                audio packet (see VCD standard p. IV-7 and IV-8).*/
 614
 615             if (stream->packet_number==0) {
 616                 size = put_system_header(ctx, buf_ptr, id);
 617                 buf_ptr += size;
 618             }
 619         } else if (s->is_dvd) {
 620             if (stream->align_iframe || s->packet_number == 0){
 621                 int PES_bytes_to_fill = s->packet_size - size - 10;
 622
 623                 if (pts != AV_NOPTS_VALUE) {
 624                     if (dts != pts)
 625                         PES_bytes_to_fill -= 5 + 5;
 626                     else
 627                         PES_bytes_to_fill -= 5;
 628                 }
 629
 630                 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
 631                     size = put_system_header(ctx, buf_ptr, 0);
 632                     buf_ptr += size;
 633                     size = buf_ptr - buffer;
 634                     avio_write(ctx->pb, buffer, size);
 635
 636                     avio_wb32(ctx->pb, PRIVATE_STREAM_2);
 637                     avio_wb16(ctx->pb, 0x03d4);         // length
 638                     avio_w8(ctx->pb, 0x00);           // substream ID, 00=PCI
 639                     for (i = 0; i < 979; i++)
 640                         avio_w8(ctx->pb, 0x00);
 641
 642                     avio_wb32(ctx->pb, PRIVATE_STREAM_2);
 643                     avio_wb16(ctx->pb, 0x03fa);         // length
 644                     avio_w8(ctx->pb, 0x01);           // substream ID, 01=DSI
 645                     for (i = 0; i < 1017; i++)
 646                         avio_w8(ctx->pb, 0x00);
 647
 648                     memset(buffer, 0, 128);
 649                     buf_ptr = buffer;
 650                     s->packet_number++;
 651                     stream->align_iframe = 0;
 652                     scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
 653                     size = put_pack_header(ctx, buf_ptr, scr);
 654                     s->last_scr= scr;
 655                     buf_ptr += size;
 656                     /* GOP Start */
 657                 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
 658                     pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
 659                 }
 660             }
 661         } else {
 662             if ((s->packet_number % s->system_header_freq) == 0) {
 663                 size = put_system_header(ctx, buf_ptr, 0);
 664                 buf_ptr += size;
 665             }
 666         }
 667     }
 668     size = buf_ptr - buffer;
 669     avio_write(ctx->pb, buffer, size);
 670
 671     packet_size = s->packet_size - size;
 672
 673     if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
 674         /* The VCD standard demands that 20 zero bytes follow
 675            each audio pack (see standard p. IV-8).*/
 676         zero_trail_bytes += 20;
 677
 678     if ((s->is_vcd && stream->packet_number==0)
 679         || (s->is_svcd && s->packet_number==0)) {
 680         /* for VCD the first pack of each stream contains only the pack header,
 681            the system header and lots of padding (see VCD standard p. IV-6).
 682            In the case of an audio pack, 20 zero bytes are also added at
 683            the end.*/
 684         /* For SVCD we fill the very first pack to increase compatibility with
 685            some DVD players. Not mandated by the standard.*/
 686         if (s->is_svcd)
 687             general_pack = 1;    /* the system header refers to both streams and no stream data*/
 688         pad_packet_bytes = packet_size - zero_trail_bytes;
 689     }
 690
 691     packet_size -= pad_packet_bytes + zero_trail_bytes;
 692
 693     if (packet_size > 0) {
 694
 695         /* packet header size */
 696         packet_size -= 6;
 697
 698         /* packet header */
 699         if (s->is_mpeg2) {
 700             header_len = 3;
 701             if (stream->packet_number==0)
 702                 header_len += 3; /* PES extension */
 703             header_len += 1; /* obligatory stuffing byte */
 704         } else {
 705             header_len = 0;
 706         }
 707         if (pts != AV_NOPTS_VALUE) {
 708             if (dts != pts)
 709                 header_len += 5 + 5;
 710             else
 711                 header_len += 5;
 712         } else {
 713             if (!s->is_mpeg2)
 714                 header_len++;
 715         }
 716
 717         payload_size = packet_size - header_len;
 718         if (id < 0xc0) {
 719             startcode = PRIVATE_STREAM_1;
 720             payload_size -= 1;
 721             if (id >= 0x40) {
 722                 payload_size -= 3;
 723                 if (id >= 0xa0)
 724                     payload_size -= 3;
 725             }
 726         } else {
 727             startcode = 0x100 + id;
 728         }
 729
 730         stuffing_size = payload_size - av_fifo_size(stream->fifo);
 731
 732         // first byte does not fit -> reset pts/dts + stuffing
 733         if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
 734             int timestamp_len=0;
 735             if(dts != pts)
 736                 timestamp_len += 5;
 737             if(pts != AV_NOPTS_VALUE)
 738                 timestamp_len += s->is_mpeg2 ? 5 : 4;
 739             pts=dts= AV_NOPTS_VALUE;
 740             header_len -= timestamp_len;
 741             if (s->is_dvd && stream->align_iframe) {
 742                 pad_packet_bytes += timestamp_len;
 743                 packet_size  -= timestamp_len;
 744             } else {
 745                 payload_size += timestamp_len;
 746             }
 747             stuffing_size += timestamp_len;
 748             if(payload_size > trailer_size)
 749                 stuffing_size += payload_size - trailer_size;
 750         }
 751
 752         if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
 753             packet_size += pad_packet_bytes;
 754             payload_size += pad_packet_bytes; // undo the previous adjustment
 755             if (stuffing_size < 0) {
 756                 stuffing_size  = pad_packet_bytes;
 757             } else {
 758                 stuffing_size += pad_packet_bytes;
 759             }
 760             pad_packet_bytes = 0;
 761         }
 762
 763         if (stuffing_size < 0)
 764             stuffing_size = 0;
 765
 766         if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
 767             if (payload_size < av_fifo_size(stream->fifo))
 768                 stuffing_size += payload_size % stream->lpcm_align;
 769         }
 770
 771         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
 772             pad_packet_bytes += stuffing_size;
 773             packet_size      -= stuffing_size;
 774             payload_size     -= stuffing_size;
 775             stuffing_size = 0;
 776         }
 777
 778         nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
 779
 780         avio_wb32(ctx->pb, startcode);
 781
 782         avio_wb16(ctx->pb, packet_size);
 783
 784         if (!s->is_mpeg2)
 785             for(i=0;i<stuffing_size;i++)
 786                 avio_w8(ctx->pb, 0xff);
 787
 788         if (s->is_mpeg2) {
 789             avio_w8(ctx->pb, 0x80); /* mpeg2 id */
 790
 791             pes_flags=0;
 792
 793             if (pts != AV_NOPTS_VALUE) {
 794                 pes_flags |= 0x80;
 795                 if (dts != pts)
 796                     pes_flags |= 0x40;
 797             }
 798
 799             /* Both the MPEG-2 and the SVCD standards demand that the
 800                P-STD_buffer_size field be included in the first packet of
 801                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
 802                and MPEG-2 standard 2.7.7) */
 803             if (stream->packet_number == 0)
 804                 pes_flags |= 0x01;
 805
 806             avio_w8(ctx->pb, pes_flags); /* flags */
 807             avio_w8(ctx->pb, header_len - 3 + stuffing_size);
 808
 809             if (pes_flags & 0x80)  /*write pts*/
 810                 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
 811             if (pes_flags & 0x40)  /*write dts*/
 812                 put_timestamp(ctx->pb, 0x01, dts);
 813
 814             if (pes_flags & 0x01) {  /*write pes extension*/
 815                 avio_w8(ctx->pb, 0x10); /* flags */
 816
 817                 /* P-STD buffer info */
 818                 if ((id & 0xe0) == AUDIO_ID)
 819                     avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
 820                 else
 821                     avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
 822             }
 823
 824         } else {
 825             if (pts != AV_NOPTS_VALUE) {
 826                 if (dts != pts) {
 827                     put_timestamp(ctx->pb, 0x03, pts);
 828                     put_timestamp(ctx->pb, 0x01, dts);
 829                 } else {
 830                     put_timestamp(ctx->pb, 0x02, pts);
 831                 }
 832             } else {
 833                 avio_w8(ctx->pb, 0x0f);
 834             }
 835         }
 836
 837         if (s->is_mpeg2) {
 838             /* special stuffing byte that is always written
 839                to prevent accidental generation of start codes. */
 840             avio_w8(ctx->pb, 0xff);
 841
 842             for(i=0;i<stuffing_size;i++)
 843                 avio_w8(ctx->pb, 0xff);
 844         }
 845
 846         if (startcode == PRIVATE_STREAM_1) {
 847             avio_w8(ctx->pb, id);
 848             if (id >= 0xa0) {
 849                 /* LPCM (XXX: check nb_frames) */
 850                 avio_w8(ctx->pb, 7);
 851                 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
 852                 avio_w8(ctx->pb, stream->lpcm_header[0]);
 853                 avio_w8(ctx->pb, stream->lpcm_header[1]);
 854                 avio_w8(ctx->pb, stream->lpcm_header[2]);
 855             } else if (id >= 0x40) {
 856                 /* AC-3 */
 857                 avio_w8(ctx->pb, nb_frames);
 858                 avio_wb16(ctx->pb, trailer_size+1);
 859             }
 860         }
 861
 862         /* output data */
 863         assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
 864         av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, (void*)avio_write);
 865         stream->bytes_to_iframe -= payload_size - stuffing_size;
 866     }else{
 867         payload_size=
 868         stuffing_size= 0;
 869     }
 870
 871     if (pad_packet_bytes > 0)
 872         put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
 873
 874     for(i=0;i<zero_trail_bytes;i++)
 875         avio_w8(ctx->pb, 0x00);
 876
 877     avio_flush(ctx->pb);
 878
 879     s->packet_number++;
 880
 881     /* only increase the stream packet number if this pack actually contains
 882        something that is specific to this stream! I.e. a dedicated header
 883        or some data.*/
 884     if (!general_pack)
 885         stream->packet_number++;
 886
 887     return payload_size - stuffing_size;
 888 }
 889
 890 static void put_vcd_padding_sector(AVFormatContext *ctx)
 891 {
 892     /* There are two ways to do this padding: writing a sector/pack
 893        of 0 values, or writing an MPEG padding pack. Both seem to
 894        work with most decoders, BUT the VCD standard only allows a 0-sector
 895        (see standard p. IV-4, IV-5).
 896        So a 0-sector it is...*/
 897
 898     MpegMuxContext *s = ctx->priv_data;
 899     int i;
 900
 901     for(i=0;i<s->packet_size;i++)
 902         avio_w8(ctx->pb, 0);
 903
 904     s->vcd_padding_bytes_written += s->packet_size;
 905
 906     avio_flush(ctx->pb);
 907
 908     /* increasing the packet number is correct. The SCR of the following packs
 909        is calculated from the packet_number and it has to include the padding
 910        sector (it represents the sector index, not the MPEG pack index)
 911        (see VCD standard p. IV-6)*/
 912     s->packet_number++;
 913 }
 914
 915 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
 916 //    MpegMuxContext *s = ctx->priv_data;
 917     int i;
 918
 919     for(i=0; i<ctx->nb_streams; i++){
 920         AVStream *st = ctx->streams[i];
 921         StreamInfo *stream = st->priv_data;
 922         PacketDesc *pkt_desc;
 923
 924         while((pkt_desc= stream->predecode_packet)
 925               && scr > pkt_desc->dts){ //FIXME > vs >=
 926             if(stream->buffer_index < pkt_desc->size ||
 927                stream->predecode_packet == stream->premux_packet){
 928                 av_log(ctx, AV_LOG_ERROR,
 929                        "buffer underflow st=%d bufi=%d size=%d\n",
 930                        i, stream->buffer_index, pkt_desc->size);
 931                 break;
 932             }
 933             stream->buffer_index -= pkt_desc->size;
 934
 935             stream->predecode_packet= pkt_desc->next;
 936             av_freep(&pkt_desc);
 937         }
 938     }
 939
 940     return 0;
 941 }
 942
 943 static int output_packet(AVFormatContext *ctx, int flush){
 944     MpegMuxContext *s = ctx->priv_data;
 945     AVStream *st;
 946     StreamInfo *stream;
 947     int i, avail_space=0, es_size, trailer_size;
 948     int best_i= -1;
 949     int best_score= INT_MIN;
 950     int ignore_constraints=0;
 951     int64_t scr= s->last_scr;
 952     PacketDesc *timestamp_packet;
 953     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
 954
 955 retry:
 956     for(i=0; i<ctx->nb_streams; i++){
 957         AVStream *st = ctx->streams[i];
 958         StreamInfo *stream = st->priv_data;
 959         const int avail_data=  av_fifo_size(stream->fifo);
 960         const int space= stream->max_buffer_size - stream->buffer_index;
 961         int rel_space= 1024LL*space / stream->max_buffer_size;
 962         PacketDesc *next_pkt= stream->premux_packet;
 963
 964         /* for subtitle, a single PES packet must be generated,
 965            so we flush after every single subtitle packet */
 966         if(s->packet_size > avail_data && !flush
 967            && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
 968             return 0;
 969         if(avail_data==0)
 970             continue;
 971         av_assert0(avail_data>0);
 972
 973         if(space < s->packet_size && !ignore_constraints)
 974             continue;
 975
 976         if(next_pkt && next_pkt->dts - scr > max_delay)
 977             continue;
 978         if (   stream->predecode_packet
 979             && stream->predecode_packet->size > stream->buffer_index)
 980             rel_space += 1<<28;
 981         if(rel_space > best_score){
 982             best_score= rel_space;
 983             best_i = i;
 984             avail_space= space;
 985         }
 986     }
 987
 988     if(best_i < 0){
 989         int64_t best_dts= INT64_MAX;
 990
 991         for(i=0; i<ctx->nb_streams; i++){
 992             AVStream *st = ctx->streams[i];
 993             StreamInfo *stream = st->priv_data;
 994             PacketDesc *pkt_desc= stream->predecode_packet;
 995             if(pkt_desc && pkt_desc->dts < best_dts)
 996                 best_dts= pkt_desc->dts;
 997         }
 998
 999         av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1000                 scr / 90000.0, best_dts / 90000.0);
1001         if(best_dts == INT64_MAX)
1002             return 0;
1003
1004         if(scr >= best_dts+1 && !ignore_constraints){
1005             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1006             ignore_constraints= 1;
1007         }
1008         scr= FFMAX(best_dts+1, scr);
1009         if(remove_decoded_packets(ctx, scr) < 0)
1010             return -1;
1011         goto retry;
1012     }
1013
1014     assert(best_i >= 0);
1015
1016     st = ctx->streams[best_i];
1017     stream = st->priv_data;
1018
1019     assert(av_fifo_size(stream->fifo) > 0);
1020
1021     assert(avail_space >= s->packet_size || ignore_constraints);
1022
1023     timestamp_packet= stream->premux_packet;
1024     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1025         trailer_size= 0;
1026     }else{
1027         trailer_size= timestamp_packet->unwritten_size;
1028         timestamp_packet= timestamp_packet->next;
1029     }
1030
1031     if(timestamp_packet){
1032         av_dlog(ctx, "dts:%f pts:%f scr:%f stream:%d\n",
1033                 timestamp_packet->dts / 90000.0,
1034                 timestamp_packet->pts / 90000.0,
1035                 scr / 90000.0, best_i);
1036         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1037     }else{
1038         assert(av_fifo_size(stream->fifo) == trailer_size);
1039         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1040     }
1041
1042     if (s->is_vcd) {
1043         /* Write one or more padding sectors, if necessary, to reach
1044            the constant overall bitrate.*/
1045         int vcd_pad_bytes;
1046
1047         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1048             put_vcd_padding_sector(ctx);
1049             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1050         }
1051     }
1052
1053     stream->buffer_index += es_size;
1054     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1055
1056     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1057         es_size -= stream->premux_packet->unwritten_size;
1058         stream->premux_packet= stream->premux_packet->next;
1059     }
1060     if(es_size)
1061         stream->premux_packet->unwritten_size -= es_size;
1062
1063     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1064         return -1;
1065
1066     return 1;
1067 }
1068
1069 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1070 {
1071     MpegMuxContext *s = ctx->priv_data;
1072     int stream_index= pkt->stream_index;
1073     int size= pkt->size;
1074     uint8_t *buf= pkt->data;
1075     AVStream *st = ctx->streams[stream_index];
1076     StreamInfo *stream = st->priv_data;
1077     int64_t pts, dts;
1078     PacketDesc *pkt_desc;
1079     int preload;
1080     const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1081
1082     preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1083
1084     pts= pkt->pts;
1085     dts= pkt->dts;
1086
1087     if (s->last_scr == AV_NOPTS_VALUE) {
1088         if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1089             if (dts != AV_NOPTS_VALUE)
1090                 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1091             s->last_scr = 0;
1092         } else {
1093             s->last_scr = dts - preload;
1094             s->preload = 0;
1095         }
1096         preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1097         av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1098     }
1099
1100     if (dts != AV_NOPTS_VALUE) dts += preload;
1101     if (pts != AV_NOPTS_VALUE) pts += preload;
1102
1103     av_dlog(ctx, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1104             dts / 90000.0, pts / 90000.0, pkt->flags,
1105             pkt->stream_index, pts != AV_NOPTS_VALUE);
1106     if (!stream->premux_packet)
1107         stream->next_packet = &stream->premux_packet;
1108     *stream->next_packet=
1109     pkt_desc= av_mallocz(sizeof(PacketDesc));
1110     pkt_desc->pts= pts;
1111     pkt_desc->dts= dts;
1112     pkt_desc->unwritten_size=
1113     pkt_desc->size= size;
1114     if(!stream->predecode_packet)
1115         stream->predecode_packet= pkt_desc;
1116     stream->next_packet= &pkt_desc->next;
1117
1118     if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1119         return -1;
1120
1121     if (s->is_dvd){
1122         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1123             stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1124             stream->align_iframe = 1;
1125             stream->vobu_start_pts = pts;
1126         }
1127     }
1128
1129     av_fifo_generic_write(stream->fifo, buf, size, NULL);
1130
1131     for(;;){
1132         int ret= output_packet(ctx, 0);
1133         if(ret<=0)
1134             return ret;
1135     }
1136 }
1137
1138 static int mpeg_mux_end(AVFormatContext *ctx)
1139 {
1140 //    MpegMuxContext *s = ctx->priv_data;
1141     StreamInfo *stream;
1142     int i;
1143
1144     for(;;){
1145         int ret= output_packet(ctx, 1);
1146         if(ret<0)
1147             return ret;
1148         else if(ret==0)
1149             break;
1150     }
1151
1152     /* End header according to MPEG1 systems standard. We do not write
1153        it as it is usually not needed by decoders and because it
1154        complicates MPEG stream concatenation. */
1155     //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1156     //avio_flush(ctx->pb);
1157
1158     for(i=0;i<ctx->nb_streams;i++) {
1159         stream = ctx->streams[i]->priv_data;
1160
1161         assert(av_fifo_size(stream->fifo) == 0);
1162         av_fifo_free(stream->fifo);
1163     }
1164     return 0;
1165 }
1166
1167 #define OFFSET(x) offsetof(MpegMuxContext, x)
1168 #define E AV_OPT_FLAG_ENCODING_PARAM
1169 static const AVOption options[] = {
1170     { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, ((1<<22) - 1) * (8 * 50), E },
1171     { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload),  AV_OPT_TYPE_INT, {.i64 = 500000}, 0, INT_MAX, E},
1172     { NULL },
1173 };
1174
1175 #define MPEGENC_CLASS(flavor)\
1176 static const AVClass flavor ## _class = {\
1177     .class_name = #flavor " muxer",\
1178     .item_name  = av_default_item_name,\
1179     .version    = LIBAVUTIL_VERSION_INT,\
1180     .option     = options,\
1181 };
1182
1183 #if CONFIG_MPEG1SYSTEM_MUXER
1184 MPEGENC_CLASS(mpeg)
1185 AVOutputFormat ff_mpeg1system_muxer = {
1186     .name              = "mpeg",
1187     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1188     .mime_type         = "video/mpeg",
1189     .extensions        = "mpg,mpeg",
1190     .priv_data_size    = sizeof(MpegMuxContext),
1191     .audio_codec       = AV_CODEC_ID_MP2,
1192     .video_codec       = AV_CODEC_ID_MPEG1VIDEO,
1193     .write_header      = mpeg_mux_init,
1194     .write_packet      = mpeg_mux_write_packet,
1195     .write_trailer     = mpeg_mux_end,
1196     .priv_class        = &mpeg_class,
1197 };
1198 #endif
1199 #if CONFIG_MPEG1VCD_MUXER
1200 MPEGENC_CLASS(vcd)
1201 AVOutputFormat ff_mpeg1vcd_muxer = {
1202     .name              = "vcd",
1203     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1204     .mime_type         = "video/mpeg",
1205     .priv_data_size    = sizeof(MpegMuxContext),
1206     .audio_codec       = AV_CODEC_ID_MP2,
1207     .video_codec       = AV_CODEC_ID_MPEG1VIDEO,
1208     .write_header      = mpeg_mux_init,
1209     .write_packet      = mpeg_mux_write_packet,
1210     .write_trailer     = mpeg_mux_end,
1211     .priv_class        = &vcd_class,
1212 };
1213 #endif
1214 #if CONFIG_MPEG2VOB_MUXER
1215 MPEGENC_CLASS(vob)
1216 AVOutputFormat ff_mpeg2vob_muxer = {
1217     .name              = "vob",
1218     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1219     .mime_type         = "video/mpeg",
1220     .extensions        = "vob",
1221     .priv_data_size    = sizeof(MpegMuxContext),
1222     .audio_codec       = AV_CODEC_ID_MP2,
1223     .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1224     .write_header      = mpeg_mux_init,
1225     .write_packet      = mpeg_mux_write_packet,
1226     .write_trailer     = mpeg_mux_end,
1227     .priv_class        = &vob_class,
1228 };
1229 #endif
1230
1231 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1232 #if CONFIG_MPEG2SVCD_MUXER
1233 MPEGENC_CLASS(svcd)
1234 AVOutputFormat ff_mpeg2svcd_muxer = {
1235     .name              = "svcd",
1236     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1237     .mime_type         = "video/mpeg",
1238     .extensions        = "vob",
1239     .priv_data_size    = sizeof(MpegMuxContext),
1240     .audio_codec       = AV_CODEC_ID_MP2,
1241     .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1242     .write_header      = mpeg_mux_init,
1243     .write_packet      = mpeg_mux_write_packet,
1244     .write_trailer     = mpeg_mux_end,
1245     .priv_class        = &svcd_class,
1246 };
1247 #endif
1248
1249 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1250 #if CONFIG_MPEG2DVD_MUXER
1251 MPEGENC_CLASS(dvd)
1252 AVOutputFormat ff_mpeg2dvd_muxer = {
1253     .name              = "dvd",
1254     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1255     .mime_type         = "video/mpeg",
1256     .extensions        = "dvd",
1257     .priv_data_size    = sizeof(MpegMuxContext),
1258     .audio_codec       = AV_CODEC_ID_MP2,
1259     .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1260     .write_header      = mpeg_mux_init,
1261     .write_packet      = mpeg_mux_write_packet,
1262     .write_trailer     = mpeg_mux_end,
1263     .priv_class        = &dvd_class,
1264 };
1265 #endif