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