libavformat/mpegenc.c

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