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