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

   1 /*
   2  * MPEG1/2 muxer
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "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 = (ctx->oformat == &mpeg1vcd_muxer);
 297     s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
 298     s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
 299     s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
 300
 301     if(ctx->packet_size)
 302         s->packet_size = ctx->packet_size;
 303     else
 304         s->packet_size = 2048;
 305
 306     s->vcd_padding_bytes_written = 0;
 307     s->vcd_padding_bitrate=0;
 308
 309     s->audio_bound = 0;
 310     s->video_bound = 0;
 311     mpa_id = AUDIO_ID;
 312     ac3_id = AC3_ID;
 313     dts_id = DTS_ID;
 314     mpv_id = VIDEO_ID;
 315     mps_id = SUB_ID;
 316     lpcm_id = LPCM_ID;
 317     for(i=0;i<ctx->nb_streams;i++) {
 318         st = ctx->streams[i];
 319         stream = av_mallocz(sizeof(StreamInfo));
 320         if (!stream)
 321             goto fail;
 322         st->priv_data = stream;
 323
 324         av_set_pts_info(st, 64, 1, 90000);
 325
 326         switch(st->codec->codec_type) {
 327         case CODEC_TYPE_AUDIO:
 328             if (st->codec->codec_id == CODEC_ID_AC3) {
 329                 stream->id = ac3_id++;
 330             } else if (st->codec->codec_id == CODEC_ID_DTS) {
 331                 stream->id = dts_id++;
 332             } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
 333                 stream->id = lpcm_id++;
 334                 for(j = 0; j < 4; j++) {
 335                     if (lpcm_freq_tab[j] == st->codec->sample_rate)
 336                         break;
 337                 }
 338                 if (j == 4)
 339                     goto fail;
 340                 if (st->codec->channels > 8)
 341                     return -1;
 342                 stream->lpcm_header[0] = 0x0c;
 343                 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
 344                 stream->lpcm_header[2] = 0x80;
 345                 stream->lpcm_align = st->codec->channels * 2;
 346             } else {
 347                 stream->id = mpa_id++;
 348             }
 349
 350             /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
 351                Right now it is also used for everything else.*/
 352             stream->max_buffer_size = 4 * 1024;
 353             s->audio_bound++;
 354             break;
 355         case CODEC_TYPE_VIDEO:
 356             stream->id = mpv_id++;
 357             if (st->codec->rc_buffer_size)
 358                 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
 359             else
 360                 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
 361 #if 0
 362                 /* see VCD standard, p. IV-7*/
 363                 stream->max_buffer_size = 46 * 1024;
 364             else
 365                 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
 366                    Right now it is also used for everything else.*/
 367                 stream->max_buffer_size = 230 * 1024;
 368 #endif
 369             s->video_bound++;
 370             break;
 371         case CODEC_TYPE_SUBTITLE:
 372             stream->id = mps_id++;
 373             stream->max_buffer_size = 16 * 1024;
 374             break;
 375         default:
 376             return -1;
 377         }
 378         av_fifo_init(&stream->fifo, 16);
 379     }
 380     bitrate = 0;
 381     audio_bitrate = 0;
 382     video_bitrate = 0;
 383     for(i=0;i<ctx->nb_streams;i++) {
 384         int codec_rate;
 385         st = ctx->streams[i];
 386         stream = (StreamInfo*) st->priv_data;
 387
 388         if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
 389             codec_rate= st->codec->rc_max_rate;
 390         else
 391             codec_rate= st->codec->bit_rate;
 392
 393         if(!codec_rate)
 394             codec_rate= (1<<21)*8*50/ctx->nb_streams;
 395
 396         bitrate += codec_rate;
 397
 398         if (stream->id==AUDIO_ID)
 399             audio_bitrate += codec_rate;
 400         else if (stream->id==VIDEO_ID)
 401             video_bitrate += codec_rate;
 402     }
 403
 404     if(ctx->mux_rate){
 405         s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
 406     } else {
 407         /* we increase slightly the bitrate to take into account the
 408            headers. XXX: compute it exactly */
 409         bitrate += bitrate*5/100;
 410         bitrate += 10000;
 411         s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
 412     }
 413
 414     if (s->is_vcd) {
 415         double overhead_rate;
 416
 417         /* The VCD standard mandates that the mux_rate field is 3528
 418            (see standard p. IV-6).
 419            The value is actually "wrong", i.e. if you calculate
 420            it using the normal formula and the 75 sectors per second transfer
 421            rate you get a different value because the real pack size is 2324,
 422            not 2352. But the standard explicitly specifies that the mux_rate
 423            field in the header must have this value.*/
 424 //        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
 425
 426         /* The VCD standard states that the muxed stream must be
 427            exactly 75 packs / second (the data rate of a single speed cdrom).
 428            Since the video bitrate (probably 1150000 bits/sec) will be below
 429            the theoretical maximum we have to add some padding packets
 430            to make up for the lower data rate.
 431            (cf. VCD standard p. IV-6 )*/
 432
 433         /* Add the header overhead to the data rate.
 434            2279 data bytes per audio pack, 2294 data bytes per video pack*/
 435         overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
 436         overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
 437         overhead_rate *= 8;
 438
 439         /* Add padding so that the full bitrate is 2324*75 bytes/sec */
 440         s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
 441     }
 442
 443     if (s->is_vcd || s->is_mpeg2)
 444         /* every packet */
 445         s->pack_header_freq = 1;
 446     else
 447         /* every 2 seconds */
 448         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
 449
 450     /* the above seems to make pack_header_freq zero sometimes */
 451     if (s->pack_header_freq == 0)
 452        s->pack_header_freq = 1;
 453
 454     if (s->is_mpeg2)
 455         /* every 200 packets. Need to look at the spec.  */
 456         s->system_header_freq = s->pack_header_freq * 40;
 457     else if (s->is_vcd)
 458         /* the standard mandates that there are only two system headers
 459            in the whole file: one in the first packet of each stream.
 460            (see standard p. IV-7 and IV-8) */
 461         s->system_header_freq = 0x7fffffff;
 462     else
 463         s->system_header_freq = s->pack_header_freq * 5;
 464
 465     for(i=0;i<ctx->nb_streams;i++) {
 466         stream = ctx->streams[i]->priv_data;
 467         stream->packet_number = 0;
 468     }
 469     s->system_header_size = get_system_header_size(ctx);
 470     s->last_scr = 0;
 471     return 0;
 472  fail:
 473     for(i=0;i<ctx->nb_streams;i++) {
 474         av_free(ctx->streams[i]->priv_data);
 475     }
 476     return AVERROR(ENOMEM);
 477 }
 478
 479 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
 480 {
 481     put_byte(pb,
 482              (id << 4) |
 483              (((timestamp >> 30) & 0x07) << 1) |
 484              1);
 485     put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
 486     put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
 487 }
 488
 489
 490 /* return the number of padding bytes that should be inserted into
 491    the multiplexed stream.*/
 492 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
 493 {
 494     MpegMuxContext *s = ctx->priv_data;
 495     int pad_bytes = 0;
 496
 497     if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
 498     {
 499         int64_t full_pad_bytes;
 500
 501         full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
 502         pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
 503
 504         if (pad_bytes<0)
 505             /* might happen if we have already padded to a later timestamp. This
 506                can occur if another stream has already advanced further.*/
 507             pad_bytes=0;
 508     }
 509
 510     return pad_bytes;
 511 }
 512
 513
 514 #if 0 /* unused, remove? */
 515 /* return the exact available payload size for the next packet for
 516    stream 'stream_index'. 'pts' and 'dts' are only used to know if
 517    timestamps are needed in the packet header. */
 518 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
 519                                    int64_t pts, int64_t dts)
 520 {
 521     MpegMuxContext *s = ctx->priv_data;
 522     int buf_index;
 523     StreamInfo *stream;
 524
 525     stream = ctx->streams[stream_index]->priv_data;
 526
 527     buf_index = 0;
 528     if (((s->packet_number % s->pack_header_freq) == 0)) {
 529         /* pack header size */
 530         if (s->is_mpeg2)
 531             buf_index += 14;
 532         else
 533             buf_index += 12;
 534
 535         if (s->is_vcd) {
 536             /* there is exactly one system header for each stream in a VCD MPEG,
 537                One in the very first video packet and one in the very first
 538                audio packet (see VCD standard p. IV-7 and IV-8).*/
 539
 540             if (stream->packet_number==0)
 541                 /* The system headers refer only to the stream they occur in,
 542                    so they have a constant size.*/
 543                 buf_index += 15;
 544
 545         } else {
 546             if ((s->packet_number % s->system_header_freq) == 0)
 547                 buf_index += s->system_header_size;
 548         }
 549     }
 550
 551     if ((s->is_vcd && stream->packet_number==0)
 552         || (s->is_svcd && s->packet_number==0))
 553         /* the first pack of each stream contains only the pack header,
 554            the system header and some padding (see VCD standard p. IV-6)
 555            Add the padding size, so that the actual payload becomes 0.*/
 556         buf_index += s->packet_size - buf_index;
 557     else {
 558         /* packet header size */
 559         buf_index += 6;
 560         if (s->is_mpeg2) {
 561             buf_index += 3;
 562             if (stream->packet_number==0)
 563                 buf_index += 3; /* PES extension */
 564             buf_index += 1;    /* obligatory stuffing byte */
 565         }
 566         if (pts != AV_NOPTS_VALUE) {
 567             if (dts != pts)
 568                 buf_index += 5 + 5;
 569             else
 570                 buf_index += 5;
 571
 572         } else {
 573             if (!s->is_mpeg2)
 574                 buf_index++;
 575         }
 576
 577         if (stream->id < 0xc0) {
 578             /* AC3/LPCM private data header */
 579             buf_index += 4;
 580             if (stream->id >= 0xa0) {
 581                 int n;
 582                 buf_index += 3;
 583                 /* NOTE: we round the payload size to an integer number of
 584                    LPCM samples */
 585                 n = (s->packet_size - buf_index) % stream->lpcm_align;
 586                 if (n)
 587                     buf_index += (stream->lpcm_align - n);
 588             }
 589         }
 590
 591         if (s->is_vcd && stream->id == AUDIO_ID)
 592             /* The VCD standard demands that 20 zero bytes follow
 593                each audio packet (see standard p. IV-8).*/
 594             buf_index+=20;
 595     }
 596     return s->packet_size - buf_index;
 597 }
 598 #endif
 599
 600 /* Write an MPEG padding packet header. */
 601 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
 602 {
 603     MpegMuxContext *s = ctx->priv_data;
 604     int i;
 605
 606     put_be32(pb, PADDING_STREAM);
 607     put_be16(pb, packet_bytes - 6);
 608     if (!s->is_mpeg2) {
 609         put_byte(pb, 0x0f);
 610         packet_bytes -= 7;
 611     } else
 612         packet_bytes -= 6;
 613
 614     for(i=0;i<packet_bytes;i++)
 615         put_byte(pb, 0xff);
 616 }
 617
 618 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
 619     int nb_frames=0;
 620     PacketDesc *pkt_desc= stream->premux_packet;
 621
 622     while(len>0){
 623         if(pkt_desc->size == pkt_desc->unwritten_size)
 624             nb_frames++;
 625         len -= pkt_desc->unwritten_size;
 626         pkt_desc= pkt_desc->next;
 627     }
 628
 629     return nb_frames;
 630 }
 631
 632 /* flush the packet on stream stream_index */
 633 static int flush_packet(AVFormatContext *ctx, int stream_index,
 634                          int64_t pts, int64_t dts, int64_t scr, int trailer_size)
 635 {
 636     MpegMuxContext *s = ctx->priv_data;
 637     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
 638     uint8_t *buf_ptr;
 639     int size, payload_size, startcode, id, stuffing_size, i, header_len;
 640     int packet_size;
 641     uint8_t buffer[128];
 642     int zero_trail_bytes = 0;
 643     int pad_packet_bytes = 0;
 644     int pes_flags;
 645     int general_pack = 0;  /*"general" pack without data specific to one stream?*/
 646     int nb_frames;
 647
 648     id = stream->id;
 649
 650 #if 0
 651     printf("packet ID=%2x PTS=%0.3f\n",
 652            id, pts / 90000.0);
 653 #endif
 654
 655     buf_ptr = buffer;
 656
 657     if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
 658         /* output pack and systems header if needed */
 659         size = put_pack_header(ctx, buf_ptr, scr);
 660         buf_ptr += size;
 661         s->last_scr= scr;
 662
 663         if (s->is_vcd) {
 664             /* there is exactly one system header for each stream in a VCD MPEG,
 665                One in the very first video packet and one in the very first
 666                audio packet (see VCD standard p. IV-7 and IV-8).*/
 667
 668             if (stream->packet_number==0) {
 669                 size = put_system_header(ctx, buf_ptr, id);
 670                 buf_ptr += size;
 671             }
 672         } else if (s->is_dvd) {
 673             if (stream->align_iframe || s->packet_number == 0){
 674                 int PES_bytes_to_fill = s->packet_size - size - 10;
 675
 676                 if (pts != AV_NOPTS_VALUE) {
 677                     if (dts != pts)
 678                         PES_bytes_to_fill -= 5 + 5;
 679                     else
 680                         PES_bytes_to_fill -= 5;
 681                 }
 682
 683                 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
 684                     size = put_system_header(ctx, buf_ptr, 0);
 685                     buf_ptr += size;
 686                     size = buf_ptr - buffer;
 687                     put_buffer(&ctx->pb, buffer, size);
 688
 689                     put_be32(&ctx->pb, PRIVATE_STREAM_2);
 690                     put_be16(&ctx->pb, 0x03d4);         // length
 691                     put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
 692                     for (i = 0; i < 979; i++)
 693                         put_byte(&ctx->pb, 0x00);
 694
 695                     put_be32(&ctx->pb, PRIVATE_STREAM_2);
 696                     put_be16(&ctx->pb, 0x03fa);         // length
 697                     put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
 698                     for (i = 0; i < 1017; i++)
 699                         put_byte(&ctx->pb, 0x00);
 700
 701                     memset(buffer, 0, 128);
 702                     buf_ptr = buffer;
 703                     s->packet_number++;
 704                     stream->align_iframe = 0;
 705                     scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
 706                     size = put_pack_header(ctx, buf_ptr, scr);
 707                     s->last_scr= scr;
 708                     buf_ptr += size;
 709                     /* GOP Start */
 710                 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
 711                     pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
 712                 }
 713             }
 714         } else {
 715             if ((s->packet_number % s->system_header_freq) == 0) {
 716                 size = put_system_header(ctx, buf_ptr, 0);
 717                 buf_ptr += size;
 718             }
 719         }
 720     }
 721     size = buf_ptr - buffer;
 722     put_buffer(&ctx->pb, buffer, size);
 723
 724     packet_size = s->packet_size - size;
 725
 726     if (s->is_vcd && id == AUDIO_ID)
 727         /* The VCD standard demands that 20 zero bytes follow
 728            each audio pack (see standard p. IV-8).*/
 729         zero_trail_bytes += 20;
 730
 731     if ((s->is_vcd && stream->packet_number==0)
 732         || (s->is_svcd && s->packet_number==0)) {
 733         /* for VCD the first pack of each stream contains only the pack header,
 734            the system header and lots of padding (see VCD standard p. IV-6).
 735            In the case of an audio pack, 20 zero bytes are also added at
 736            the end.*/
 737         /* For SVCD we fill the very first pack to increase compatibility with
 738            some DVD players. Not mandated by the standard.*/
 739         if (s->is_svcd)
 740             general_pack = 1;    /* the system header refers to both streams and no stream data*/
 741         pad_packet_bytes = packet_size - zero_trail_bytes;
 742     }
 743
 744     packet_size -= pad_packet_bytes + zero_trail_bytes;
 745
 746     if (packet_size > 0) {
 747
 748         /* packet header size */
 749         packet_size -= 6;
 750
 751         /* packet header */
 752         if (s->is_mpeg2) {
 753             header_len = 3;
 754             if (stream->packet_number==0)
 755                 header_len += 3; /* PES extension */
 756             header_len += 1; /* obligatory stuffing byte */
 757         } else {
 758             header_len = 0;
 759         }
 760         if (pts != AV_NOPTS_VALUE) {
 761             if (dts != pts)
 762                 header_len += 5 + 5;
 763             else
 764                 header_len += 5;
 765         } else {
 766             if (!s->is_mpeg2)
 767                 header_len++;
 768         }
 769
 770         payload_size = packet_size - header_len;
 771         if (id < 0xc0) {
 772             startcode = PRIVATE_STREAM_1;
 773             payload_size -= 1;
 774             if (id >= 0x40) {
 775                 payload_size -= 3;
 776                 if (id >= 0xa0)
 777                     payload_size -= 3;
 778             }
 779         } else {
 780             startcode = 0x100 + id;
 781         }
 782
 783         stuffing_size = payload_size - av_fifo_size(&stream->fifo);
 784
 785         // first byte does not fit -> reset pts/dts + stuffing
 786         if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
 787             int timestamp_len=0;
 788             if(dts != pts)
 789                 timestamp_len += 5;
 790             if(pts != AV_NOPTS_VALUE)
 791                 timestamp_len += s->is_mpeg2 ? 5 : 4;
 792             pts=dts= AV_NOPTS_VALUE;
 793             header_len -= timestamp_len;
 794             if (s->is_dvd && stream->align_iframe) {
 795                 pad_packet_bytes += timestamp_len;
 796                 packet_size -= timestamp_len;
 797             } else {
 798                 payload_size += timestamp_len;
 799             }
 800             stuffing_size += timestamp_len;
 801             if(payload_size > trailer_size)
 802                 stuffing_size += payload_size - trailer_size;
 803         }
 804
 805         if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
 806             packet_size += pad_packet_bytes;
 807             payload_size += pad_packet_bytes; // undo the previous adjustment
 808             if (stuffing_size < 0) {
 809                 stuffing_size = pad_packet_bytes;
 810             } else {
 811                 stuffing_size += pad_packet_bytes;
 812             }
 813             pad_packet_bytes = 0;
 814         }
 815
 816         if (stuffing_size < 0)
 817             stuffing_size = 0;
 818         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
 819             pad_packet_bytes += stuffing_size;
 820             packet_size -= stuffing_size;
 821             payload_size -= stuffing_size;
 822             stuffing_size = 0;
 823         }
 824
 825         nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
 826
 827         put_be32(&ctx->pb, startcode);
 828
 829         put_be16(&ctx->pb, packet_size);
 830
 831         if (!s->is_mpeg2)
 832             for(i=0;i<stuffing_size;i++)
 833                 put_byte(&ctx->pb, 0xff);
 834
 835         if (s->is_mpeg2) {
 836             put_byte(&ctx->pb, 0x80); /* mpeg2 id */
 837
 838             pes_flags=0;
 839
 840             if (pts != AV_NOPTS_VALUE) {
 841                 pes_flags |= 0x80;
 842                 if (dts != pts)
 843                     pes_flags |= 0x40;
 844             }
 845
 846             /* Both the MPEG-2 and the SVCD standards demand that the
 847                P-STD_buffer_size field be included in the first packet of
 848                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
 849                and MPEG-2 standard 2.7.7) */
 850             if (stream->packet_number == 0)
 851                 pes_flags |= 0x01;
 852
 853             put_byte(&ctx->pb, pes_flags); /* flags */
 854             put_byte(&ctx->pb, header_len - 3 + stuffing_size);
 855
 856             if (pes_flags & 0x80)  /*write pts*/
 857                 put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
 858             if (pes_flags & 0x40)  /*write dts*/
 859                 put_timestamp(&ctx->pb, 0x01, dts);
 860
 861             if (pes_flags & 0x01) {  /*write pes extension*/
 862                 put_byte(&ctx->pb, 0x10); /* flags */
 863
 864                 /* P-STD buffer info */
 865                 if (id == AUDIO_ID)
 866                     put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
 867                 else
 868                     put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
 869             }
 870
 871         } else {
 872             if (pts != AV_NOPTS_VALUE) {
 873                 if (dts != pts) {
 874                     put_timestamp(&ctx->pb, 0x03, pts);
 875                     put_timestamp(&ctx->pb, 0x01, dts);
 876                 } else {
 877                     put_timestamp(&ctx->pb, 0x02, pts);
 878                 }
 879             } else {
 880                 put_byte(&ctx->pb, 0x0f);
 881             }
 882         }
 883
 884         if (s->is_mpeg2) {
 885             /* special stuffing byte that is always written
 886                to prevent accidental generation of start codes. */
 887             put_byte(&ctx->pb, 0xff);
 888
 889             for(i=0;i<stuffing_size;i++)
 890                 put_byte(&ctx->pb, 0xff);
 891         }
 892
 893         if (startcode == PRIVATE_STREAM_1) {
 894             put_byte(&ctx->pb, id);
 895             if (id >= 0xa0) {
 896                 /* LPCM (XXX: check nb_frames) */
 897                 put_byte(&ctx->pb, 7);
 898                 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
 899                 put_byte(&ctx->pb, stream->lpcm_header[0]);
 900                 put_byte(&ctx->pb, stream->lpcm_header[1]);
 901                 put_byte(&ctx->pb, stream->lpcm_header[2]);
 902             } else if (id >= 0x40) {
 903                 /* AC3 */
 904                 put_byte(&ctx->pb, nb_frames);
 905                 put_be16(&ctx->pb, trailer_size+1);
 906             }
 907         }
 908
 909         /* output data */
 910         if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
 911             return -1;
 912         stream->bytes_to_iframe -= payload_size - stuffing_size;
 913     }else{
 914         payload_size=
 915         stuffing_size= 0;
 916     }
 917
 918     if (pad_packet_bytes > 0)
 919         put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
 920
 921     for(i=0;i<zero_trail_bytes;i++)
 922         put_byte(&ctx->pb, 0x00);
 923
 924     put_flush_packet(&ctx->pb);
 925
 926     s->packet_number++;
 927
 928     /* only increase the stream packet number if this pack actually contains
 929        something that is specific to this stream! I.e. a dedicated header
 930        or some data.*/
 931     if (!general_pack)
 932         stream->packet_number++;
 933
 934     return payload_size - stuffing_size;
 935 }
 936
 937 static void put_vcd_padding_sector(AVFormatContext *ctx)
 938 {
 939     /* There are two ways to do this padding: writing a sector/pack
 940        of 0 values, or writing an MPEG padding pack. Both seem to
 941        work with most decoders, BUT the VCD standard only allows a 0-sector
 942        (see standard p. IV-4, IV-5).
 943        So a 0-sector it is...*/
 944
 945     MpegMuxContext *s = ctx->priv_data;
 946     int i;
 947
 948     for(i=0;i<s->packet_size;i++)
 949         put_byte(&ctx->pb, 0);
 950
 951     s->vcd_padding_bytes_written += s->packet_size;
 952
 953     put_flush_packet(&ctx->pb);
 954
 955     /* increasing the packet number is correct. The SCR of the following packs
 956        is calculated from the packet_number and it has to include the padding
 957        sector (it represents the sector index, not the MPEG pack index)
 958        (see VCD standard p. IV-6)*/
 959     s->packet_number++;
 960 }
 961
 962 #if 0 /* unused, remove? */
 963 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
 964 {
 965     MpegMuxContext *s = ctx->priv_data;
 966     int64_t scr;
 967
 968         /* Since the data delivery rate is constant, SCR is computed
 969            using the formula C + i * 1200 where C is the start constant
 970            and i is the pack index.
 971            It is recommended that SCR 0 is at the beginning of the VCD front
 972            margin (a sequence of empty Form 2 sectors on the CD).
 973            It is recommended that the front margin is 30 sectors long, so
 974            we use C = 30*1200 = 36000
 975            (Note that even if the front margin is not 30 sectors the file
 976            will still be correct according to the standard. It just won't have
 977            the "recommended" value).*/
 978         scr = 36000 + s->packet_number * 1200;
 979
 980     return scr;
 981 }
 982 #endif
 983
 984 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
 985 //    MpegMuxContext *s = ctx->priv_data;
 986     int i;
 987
 988     for(i=0; i<ctx->nb_streams; i++){
 989         AVStream *st = ctx->streams[i];
 990         StreamInfo *stream = st->priv_data;
 991         PacketDesc *pkt_desc;
 992
 993         while((pkt_desc= stream->predecode_packet)
 994               && scr > pkt_desc->dts){ //FIXME > vs >=
 995             if(stream->buffer_index < pkt_desc->size ||
 996                stream->predecode_packet == stream->premux_packet){
 997                 av_log(ctx, AV_LOG_ERROR,
 998                        "buffer underflow i=%d bufi=%d size=%d\n",
 999                        i, stream->buffer_index, pkt_desc->size);
1000                 break;
1001             }
1002             stream->buffer_index -= pkt_desc->size;
1003
1004             stream->predecode_packet= pkt_desc->next;
1005             av_freep(&pkt_desc);
1006         }
1007     }
1008
1009     return 0;
1010 }
1011
1012 static int output_packet(AVFormatContext *ctx, int flush){
1013     MpegMuxContext *s = ctx->priv_data;
1014     AVStream *st;
1015     StreamInfo *stream;
1016     int i, avail_space, es_size, trailer_size;
1017     int best_i= -1;
1018     int best_score= INT_MIN;
1019     int ignore_constraints=0;
1020     int64_t scr= s->last_scr;
1021     PacketDesc *timestamp_packet;
1022     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1023
1024 retry:
1025     for(i=0; i<ctx->nb_streams; i++){
1026         AVStream *st = ctx->streams[i];
1027         StreamInfo *stream = st->priv_data;
1028         const int avail_data=  av_fifo_size(&stream->fifo);
1029         const int space= stream->max_buffer_size - stream->buffer_index;
1030         int rel_space= 1024*space / stream->max_buffer_size;
1031         PacketDesc *next_pkt= stream->premux_packet;
1032
1033         /* for subtitle, a single PES packet must be generated,
1034            so we flush after every single subtitle packet */
1035         if(s->packet_size > avail_data && !flush
1036            && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1037             return 0;
1038         if(avail_data==0)
1039             continue;
1040         assert(avail_data>0);
1041
1042         if(space < s->packet_size && !ignore_constraints)
1043             continue;
1044
1045         if(next_pkt && next_pkt->dts - scr > max_delay)
1046             continue;
1047
1048         if(rel_space > best_score){
1049             best_score= rel_space;
1050             best_i = i;
1051             avail_space= space;
1052         }
1053     }
1054
1055     if(best_i < 0){
1056         int64_t best_dts= INT64_MAX;
1057
1058         for(i=0; i<ctx->nb_streams; i++){
1059             AVStream *st = ctx->streams[i];
1060             StreamInfo *stream = st->priv_data;
1061             PacketDesc *pkt_desc= stream->predecode_packet;
1062             if(pkt_desc && pkt_desc->dts < best_dts)
1063                 best_dts= pkt_desc->dts;
1064         }
1065
1066 #if 0
1067         av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1068                scr/90000.0, best_dts/90000.0);
1069 #endif
1070         if(best_dts == INT64_MAX)
1071             return 0;
1072
1073         if(scr >= best_dts+1 && !ignore_constraints){
1074             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1075             ignore_constraints= 1;
1076         }
1077         scr= FFMAX(best_dts+1, scr);
1078         if(remove_decoded_packets(ctx, scr) < 0)
1079             return -1;
1080         goto retry;
1081     }
1082
1083     assert(best_i >= 0);
1084
1085     st = ctx->streams[best_i];
1086     stream = st->priv_data;
1087
1088     assert(av_fifo_size(&stream->fifo) > 0);
1089
1090     assert(avail_space >= s->packet_size || ignore_constraints);
1091
1092     timestamp_packet= stream->premux_packet;
1093     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1094         trailer_size= 0;
1095     }else{
1096         trailer_size= timestamp_packet->unwritten_size;
1097         timestamp_packet= timestamp_packet->next;
1098     }
1099
1100     if(timestamp_packet){
1101 //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);
1102         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1103     }else{
1104         assert(av_fifo_size(&stream->fifo) == trailer_size);
1105         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1106     }
1107
1108     if (s->is_vcd) {
1109         /* Write one or more padding sectors, if necessary, to reach
1110            the constant overall bitrate.*/
1111         int vcd_pad_bytes;
1112
1113         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1114             put_vcd_padding_sector(ctx);
1115             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1116         }
1117     }
1118
1119     stream->buffer_index += es_size;
1120     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1121
1122     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1123         es_size -= stream->premux_packet->unwritten_size;
1124         stream->premux_packet= stream->premux_packet->next;
1125     }
1126     if(es_size)
1127         stream->premux_packet->unwritten_size -= es_size;
1128
1129     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1130         return -1;
1131
1132     return 1;
1133 }
1134
1135 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1136 {
1137     MpegMuxContext *s = ctx->priv_data;
1138     int stream_index= pkt->stream_index;
1139     int size= pkt->size;
1140     uint8_t *buf= pkt->data;
1141     AVStream *st = ctx->streams[stream_index];
1142     StreamInfo *stream = st->priv_data;
1143     int64_t pts, dts;
1144     PacketDesc *pkt_desc;
1145     const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1146     const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1147
1148     pts= pkt->pts;
1149     dts= pkt->dts;
1150
1151     if(pts != AV_NOPTS_VALUE) pts += preload;
1152     if(dts != AV_NOPTS_VALUE) dts += preload;
1153
1154 //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);
1155     if (!stream->premux_packet)
1156         stream->next_packet = &stream->premux_packet;
1157     *stream->next_packet=
1158     pkt_desc= av_mallocz(sizeof(PacketDesc));
1159     pkt_desc->pts= pts;
1160     pkt_desc->dts= dts;
1161     pkt_desc->unwritten_size=
1162     pkt_desc->size= size;
1163     if(!stream->predecode_packet)
1164         stream->predecode_packet= pkt_desc;
1165     stream->next_packet= &pkt_desc->next;
1166
1167     av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1168
1169     if (s->is_dvd){
1170         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1171             stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1172             stream->align_iframe = 1;
1173             stream->vobu_start_pts = pts;
1174         } else {
1175             stream->align_iframe = 0;
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