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