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

   1 /*
   2  * MPEG1/2 muxer and demuxer
   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 #include "avformat.h"
  22 #include "bitstream.h"
  23 #include "fifo.h"
  24
  25 #define MAX_PAYLOAD_SIZE 4096
  26 //#define DEBUG_SEEK
  27
  28 #undef NDEBUG
  29 #include <assert.h>
  30
  31 typedef struct PacketDesc {
  32     int64_t pts;
  33     int64_t dts;
  34     int size;
  35     int unwritten_size;
  36     int flags;
  37     struct PacketDesc *next;
  38 } PacketDesc;
  39
  40 typedef struct {
  41     AVFifoBuffer fifo;
  42     uint8_t id;
  43     int max_buffer_size; /* in bytes */
  44     int buffer_index;
  45     PacketDesc *predecode_packet;
  46     PacketDesc *premux_packet;
  47     PacketDesc **next_packet;
  48     int packet_number;
  49     uint8_t lpcm_header[3];
  50     int lpcm_align;
  51     int bytes_to_iframe;
  52     int align_iframe;
  53     int64_t vobu_start_pts;
  54 } StreamInfo;
  55
  56 typedef struct {
  57     int packet_size; /* required packet size */
  58     int packet_number;
  59     int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
  60     int system_header_freq;
  61     int system_header_size;
  62     int mux_rate; /* bitrate in units of 50 bytes/s */
  63     /* stream info */
  64     int audio_bound;
  65     int video_bound;
  66     int is_mpeg2;
  67     int is_vcd;
  68     int is_svcd;
  69     int is_dvd;
  70     int64_t last_scr; /* current system clock */
  71
  72     double vcd_padding_bitrate; //FIXME floats
  73     int64_t vcd_padding_bytes_written;
  74
  75 } MpegMuxContext;
  76
  77 #define PACK_START_CODE             ((unsigned int)0x000001ba)
  78 #define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
  79 #define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
  80 #define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
  81 #define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
  82 #define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
  83
  84 /* mpeg2 */
  85 #define PROGRAM_STREAM_MAP 0x1bc
  86 #define PRIVATE_STREAM_1   0x1bd
  87 #define PADDING_STREAM     0x1be
  88 #define PRIVATE_STREAM_2   0x1bf
  89
  90
  91 #define AUDIO_ID 0xc0
  92 #define VIDEO_ID 0xe0
  93 #define AC3_ID   0x80
  94 #define DTS_ID   0x8a
  95 #define LPCM_ID  0xa0
  96 #define SUB_ID   0x20
  97
  98 #define STREAM_TYPE_VIDEO_MPEG1     0x01
  99 #define STREAM_TYPE_VIDEO_MPEG2     0x02
 100 #define STREAM_TYPE_AUDIO_MPEG1     0x03
 101 #define STREAM_TYPE_AUDIO_MPEG2     0x04
 102 #define STREAM_TYPE_PRIVATE_SECTION 0x05
 103 #define STREAM_TYPE_PRIVATE_DATA    0x06
 104 #define STREAM_TYPE_AUDIO_AAC       0x0f
 105 #define STREAM_TYPE_VIDEO_MPEG4     0x10
 106 #define STREAM_TYPE_VIDEO_H264      0x1b
 107
 108 #define STREAM_TYPE_AUDIO_AC3       0x81
 109 #define STREAM_TYPE_AUDIO_DTS       0x8a
 110
 111 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
 112
 113 #ifdef CONFIG_MUXERS
 114 AVOutputFormat mpeg1system_muxer;
 115 AVOutputFormat mpeg1vcd_muxer;
 116 AVOutputFormat mpeg2vob_muxer;
 117 AVOutputFormat mpeg2svcd_muxer;
 118 AVOutputFormat mpeg2dvd_muxer;
 119
 120 static int put_pack_header(AVFormatContext *ctx,
 121                            uint8_t *buf, int64_t timestamp)
 122 {
 123     MpegMuxContext *s = ctx->priv_data;
 124     PutBitContext pb;
 125
 126     init_put_bits(&pb, buf, 128);
 127
 128     put_bits(&pb, 32, PACK_START_CODE);
 129     if (s->is_mpeg2) {
 130         put_bits(&pb, 2, 0x1);
 131     } else {
 132         put_bits(&pb, 4, 0x2);
 133     }
 134     put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
 135     put_bits(&pb, 1, 1);
 136     put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
 137     put_bits(&pb, 1, 1);
 138     put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
 139     put_bits(&pb, 1, 1);
 140     if (s->is_mpeg2) {
 141         /* clock extension */
 142         put_bits(&pb, 9, 0);
 143     }
 144     put_bits(&pb, 1, 1);
 145     put_bits(&pb, 22, s->mux_rate);
 146     put_bits(&pb, 1, 1);
 147     if (s->is_mpeg2) {
 148         put_bits(&pb, 1, 1);
 149         put_bits(&pb, 5, 0x1f); /* reserved */
 150         put_bits(&pb, 3, 0); /* stuffing length */
 151     }
 152     flush_put_bits(&pb);
 153     return pbBufPtr(&pb) - pb.buf;
 154 }
 155
 156 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
 157 {
 158     MpegMuxContext *s = ctx->priv_data;
 159     int size, i, private_stream_coded, id;
 160     PutBitContext pb;
 161
 162     init_put_bits(&pb, buf, 128);
 163
 164     put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
 165     put_bits(&pb, 16, 0);
 166     put_bits(&pb, 1, 1);
 167
 168     put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
 169     put_bits(&pb, 1, 1); /* marker */
 170     if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
 171         /* This header applies only to the video stream (see VCD standard p. IV-7)*/
 172         put_bits(&pb, 6, 0);
 173     } else
 174         put_bits(&pb, 6, s->audio_bound);
 175
 176     if (s->is_vcd) {
 177         /* see VCD standard, p. IV-7*/
 178         put_bits(&pb, 1, 0);
 179         put_bits(&pb, 1, 1);
 180     } else {
 181         put_bits(&pb, 1, 0); /* variable bitrate*/
 182         put_bits(&pb, 1, 0); /* non constrainted bit stream */
 183     }
 184
 185     if (s->is_vcd || s->is_dvd) {
 186         /* see VCD standard p IV-7 */
 187         put_bits(&pb, 1, 1); /* audio locked */
 188         put_bits(&pb, 1, 1); /* video locked */
 189     } else {
 190         put_bits(&pb, 1, 0); /* audio locked */
 191         put_bits(&pb, 1, 0); /* video locked */
 192     }
 193
 194     put_bits(&pb, 1, 1); /* marker */
 195
 196     if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
 197         /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
 198         put_bits(&pb, 5, 0);
 199     } else
 200         put_bits(&pb, 5, s->video_bound);
 201
 202     if (s->is_dvd) {
 203         put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
 204         put_bits(&pb, 7, 0x7f); /* reserved byte */
 205     } else
 206         put_bits(&pb, 8, 0xff); /* reserved byte */
 207
 208     /* DVD-Video Stream_bound entries
 209     id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
 210     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)
 211     id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
 212     id (0xBF) private stream 2, NAV packs, set to 2x1024. */
 213     if (s->is_dvd) {
 214
 215         int P_STD_max_video = 0;
 216         int P_STD_max_mpeg_audio = 0;
 217         int P_STD_max_mpeg_PS1 = 0;
 218
 219         for(i=0;i<ctx->nb_streams;i++) {
 220             StreamInfo *stream = ctx->streams[i]->priv_data;
 221
 222             id = stream->id;
 223             if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
 224                 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
 225             } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
 226                 P_STD_max_mpeg_audio = stream->max_buffer_size;
 227             } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
 228                 P_STD_max_video = stream->max_buffer_size;
 229             }
 230         }
 231
 232         /* video */
 233         put_bits(&pb, 8, 0xb9); /* stream ID */
 234         put_bits(&pb, 2, 3);
 235         put_bits(&pb, 1, 1);
 236         put_bits(&pb, 13, P_STD_max_video / 1024);
 237
 238         /* audio */
 239         if (P_STD_max_mpeg_audio == 0)
 240             P_STD_max_mpeg_audio = 4096;
 241         put_bits(&pb, 8, 0xb8); /* stream ID */
 242         put_bits(&pb, 2, 3);
 243         put_bits(&pb, 1, 0);
 244         put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
 245
 246         /* private stream 1 */
 247         put_bits(&pb, 8, 0xbd); /* stream ID */
 248         put_bits(&pb, 2, 3);
 249         put_bits(&pb, 1, 0);
 250         put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
 251
 252         /* private stream 2 */
 253         put_bits(&pb, 8, 0xbf); /* stream ID */
 254         put_bits(&pb, 2, 3);
 255         put_bits(&pb, 1, 1);
 256         put_bits(&pb, 13, 2);
 257     }
 258     else {
 259         /* audio stream info */
 260         private_stream_coded = 0;
 261         for(i=0;i<ctx->nb_streams;i++) {
 262             StreamInfo *stream = ctx->streams[i]->priv_data;
 263
 264
 265             /* For VCDs, only include the stream info for the stream
 266             that the pack which contains this system belongs to.
 267             (see VCD standard p. IV-7) */
 268             if ( !s->is_vcd || stream->id==only_for_stream_id
 269                 || only_for_stream_id==0) {
 270
 271                 id = stream->id;
 272                 if (id < 0xc0) {
 273                     /* special case for private streams (AC3 use that) */
 274                     if (private_stream_coded)
 275                         continue;
 276                     private_stream_coded = 1;
 277                     id = 0xbd;
 278                 }
 279                 put_bits(&pb, 8, id); /* stream ID */
 280                 put_bits(&pb, 2, 3);
 281                 if (id < 0xe0) {
 282                     /* audio */
 283                     put_bits(&pb, 1, 0);
 284                     put_bits(&pb, 13, stream->max_buffer_size / 128);
 285                 } else {
 286                     /* video */
 287                     put_bits(&pb, 1, 1);
 288                     put_bits(&pb, 13, stream->max_buffer_size / 1024);
 289                 }
 290             }
 291         }
 292     }
 293
 294     flush_put_bits(&pb);
 295     size = pbBufPtr(&pb) - pb.buf;
 296     /* patch packet size */
 297     buf[4] = (size - 6) >> 8;
 298     buf[5] = (size - 6) & 0xff;
 299
 300     return size;
 301 }
 302
 303 static int get_system_header_size(AVFormatContext *ctx)
 304 {
 305     int buf_index, i, private_stream_coded;
 306     StreamInfo *stream;
 307     MpegMuxContext *s = ctx->priv_data;
 308
 309     if (s->is_dvd)
 310        return 18; // DVD-Video system headers are 18 bytes fixed length.
 311
 312     buf_index = 12;
 313     private_stream_coded = 0;
 314     for(i=0;i<ctx->nb_streams;i++) {
 315         stream = ctx->streams[i]->priv_data;
 316         if (stream->id < 0xc0) {
 317             if (private_stream_coded)
 318                 continue;
 319             private_stream_coded = 1;
 320         }
 321         buf_index += 3;
 322     }
 323     return buf_index;
 324 }
 325
 326 static int mpeg_mux_init(AVFormatContext *ctx)
 327 {
 328     MpegMuxContext *s = ctx->priv_data;
 329     int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
 330     AVStream *st;
 331     StreamInfo *stream;
 332     int audio_bitrate;
 333     int video_bitrate;
 334
 335     s->packet_number = 0;
 336     s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
 337     s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
 338     s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
 339     s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
 340
 341     if(ctx->packet_size)
 342         s->packet_size = ctx->packet_size;
 343     else
 344         s->packet_size = 2048;
 345
 346     s->vcd_padding_bytes_written = 0;
 347     s->vcd_padding_bitrate=0;
 348
 349     s->audio_bound = 0;
 350     s->video_bound = 0;
 351     mpa_id = AUDIO_ID;
 352     ac3_id = AC3_ID;
 353     dts_id = DTS_ID;
 354     mpv_id = VIDEO_ID;
 355     mps_id = SUB_ID;
 356     lpcm_id = LPCM_ID;
 357     for(i=0;i<ctx->nb_streams;i++) {
 358         st = ctx->streams[i];
 359         stream = av_mallocz(sizeof(StreamInfo));
 360         if (!stream)
 361             goto fail;
 362         st->priv_data = stream;
 363
 364         av_set_pts_info(st, 64, 1, 90000);
 365
 366         switch(st->codec->codec_type) {
 367         case CODEC_TYPE_AUDIO:
 368             if (st->codec->codec_id == CODEC_ID_AC3) {
 369                 stream->id = ac3_id++;
 370             } else if (st->codec->codec_id == CODEC_ID_DTS) {
 371                 stream->id = dts_id++;
 372             } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
 373                 stream->id = lpcm_id++;
 374                 for(j = 0; j < 4; j++) {
 375                     if (lpcm_freq_tab[j] == st->codec->sample_rate)
 376                         break;
 377                 }
 378                 if (j == 4)
 379                     goto fail;
 380                 if (st->codec->channels > 8)
 381                     return -1;
 382                 stream->lpcm_header[0] = 0x0c;
 383                 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
 384                 stream->lpcm_header[2] = 0x80;
 385                 stream->lpcm_align = st->codec->channels * 2;
 386             } else {
 387                 stream->id = mpa_id++;
 388             }
 389
 390             /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
 391                Right now it is also used for everything else.*/
 392             stream->max_buffer_size = 4 * 1024;
 393             s->audio_bound++;
 394             break;
 395         case CODEC_TYPE_VIDEO:
 396             stream->id = mpv_id++;
 397             if (st->codec->rc_buffer_size)
 398                 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
 399             else
 400                 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
 401 #if 0
 402                 /* see VCD standard, p. IV-7*/
 403                 stream->max_buffer_size = 46 * 1024;
 404             else
 405                 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
 406                    Right now it is also used for everything else.*/
 407                 stream->max_buffer_size = 230 * 1024;
 408 #endif
 409             s->video_bound++;
 410             break;
 411         case CODEC_TYPE_SUBTITLE:
 412             stream->id = mps_id++;
 413             stream->max_buffer_size = 16 * 1024;
 414             break;
 415         default:
 416             return -1;
 417         }
 418         av_fifo_init(&stream->fifo, 16);
 419     }
 420     bitrate = 0;
 421     audio_bitrate = 0;
 422     video_bitrate = 0;
 423     for(i=0;i<ctx->nb_streams;i++) {
 424         int codec_rate;
 425         st = ctx->streams[i];
 426         stream = (StreamInfo*) st->priv_data;
 427
 428         if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
 429             codec_rate= st->codec->rc_max_rate;
 430         else
 431             codec_rate= st->codec->bit_rate;
 432
 433         if(!codec_rate)
 434             codec_rate= (1<<21)*8*50/ctx->nb_streams;
 435
 436         bitrate += codec_rate;
 437
 438         if (stream->id==AUDIO_ID)
 439             audio_bitrate += codec_rate;
 440         else if (stream->id==VIDEO_ID)
 441             video_bitrate += codec_rate;
 442     }
 443
 444     if(ctx->mux_rate){
 445         s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
 446     } else {
 447         /* we increase slightly the bitrate to take into account the
 448            headers. XXX: compute it exactly */
 449         bitrate += bitrate*5/100;
 450         bitrate += 10000;
 451         s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
 452     }
 453
 454     if (s->is_vcd) {
 455         double overhead_rate;
 456
 457         /* The VCD standard mandates that the mux_rate field is 3528
 458            (see standard p. IV-6).
 459            The value is actually "wrong", i.e. if you calculate
 460            it using the normal formula and the 75 sectors per second transfer
 461            rate you get a different value because the real pack size is 2324,
 462            not 2352. But the standard explicitly specifies that the mux_rate
 463            field in the header must have this value.*/
 464 //        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
 465
 466         /* The VCD standard states that the muxed stream must be
 467            exactly 75 packs / second (the data rate of a single speed cdrom).
 468            Since the video bitrate (probably 1150000 bits/sec) will be below
 469            the theoretical maximum we have to add some padding packets
 470            to make up for the lower data rate.
 471            (cf. VCD standard p. IV-6 )*/
 472
 473         /* Add the header overhead to the data rate.
 474            2279 data bytes per audio pack, 2294 data bytes per video pack*/
 475         overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
 476         overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
 477         overhead_rate *= 8;
 478
 479         /* Add padding so that the full bitrate is 2324*75 bytes/sec */
 480         s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
 481     }
 482
 483     if (s->is_vcd || s->is_mpeg2)
 484         /* every packet */
 485         s->pack_header_freq = 1;
 486     else
 487         /* every 2 seconds */
 488         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
 489
 490     /* the above seems to make pack_header_freq zero sometimes */
 491     if (s->pack_header_freq == 0)
 492        s->pack_header_freq = 1;
 493
 494     if (s->is_mpeg2)
 495         /* every 200 packets. Need to look at the spec.  */
 496         s->system_header_freq = s->pack_header_freq * 40;
 497     else if (s->is_vcd)
 498         /* the standard mandates that there are only two system headers
 499            in the whole file: one in the first packet of each stream.
 500            (see standard p. IV-7 and IV-8) */
 501         s->system_header_freq = 0x7fffffff;
 502     else
 503         s->system_header_freq = s->pack_header_freq * 5;
 504
 505     for(i=0;i<ctx->nb_streams;i++) {
 506         stream = ctx->streams[i]->priv_data;
 507         stream->packet_number = 0;
 508     }
 509     s->system_header_size = get_system_header_size(ctx);
 510     s->last_scr = 0;
 511     return 0;
 512  fail:
 513     for(i=0;i<ctx->nb_streams;i++) {
 514         av_free(ctx->streams[i]->priv_data);
 515     }
 516     return AVERROR(ENOMEM);
 517 }
 518
 519 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
 520 {
 521     put_byte(pb,
 522              (id << 4) |
 523              (((timestamp >> 30) & 0x07) << 1) |
 524              1);
 525     put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
 526     put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
 527 }
 528
 529
 530 /* return the number of padding bytes that should be inserted into
 531    the multiplexed stream.*/
 532 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
 533 {
 534     MpegMuxContext *s = ctx->priv_data;
 535     int pad_bytes = 0;
 536
 537     if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
 538     {
 539         int64_t full_pad_bytes;
 540
 541         full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
 542         pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
 543
 544         if (pad_bytes<0)
 545             /* might happen if we have already padded to a later timestamp. This
 546                can occur if another stream has already advanced further.*/
 547             pad_bytes=0;
 548     }
 549
 550     return pad_bytes;
 551 }
 552
 553
 554 #if 0 /* unused, remove? */
 555 /* return the exact available payload size for the next packet for
 556    stream 'stream_index'. 'pts' and 'dts' are only used to know if
 557    timestamps are needed in the packet header. */
 558 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
 559                                    int64_t pts, int64_t dts)
 560 {
 561     MpegMuxContext *s = ctx->priv_data;
 562     int buf_index;
 563     StreamInfo *stream;
 564
 565     stream = ctx->streams[stream_index]->priv_data;
 566
 567     buf_index = 0;
 568     if (((s->packet_number % s->pack_header_freq) == 0)) {
 569         /* pack header size */
 570         if (s->is_mpeg2)
 571             buf_index += 14;
 572         else
 573             buf_index += 12;
 574
 575         if (s->is_vcd) {
 576             /* there is exactly one system header for each stream in a VCD MPEG,
 577                One in the very first video packet and one in the very first
 578                audio packet (see VCD standard p. IV-7 and IV-8).*/
 579
 580             if (stream->packet_number==0)
 581                 /* The system headers refer only to the stream they occur in,
 582                    so they have a constant size.*/
 583                 buf_index += 15;
 584
 585         } else {
 586             if ((s->packet_number % s->system_header_freq) == 0)
 587                 buf_index += s->system_header_size;
 588         }
 589     }
 590
 591     if ((s->is_vcd && stream->packet_number==0)
 592         || (s->is_svcd && s->packet_number==0))
 593         /* the first pack of each stream contains only the pack header,
 594            the system header and some padding (see VCD standard p. IV-6)
 595            Add the padding size, so that the actual payload becomes 0.*/
 596         buf_index += s->packet_size - buf_index;
 597     else {
 598         /* packet header size */
 599         buf_index += 6;
 600         if (s->is_mpeg2) {
 601             buf_index += 3;
 602             if (stream->packet_number==0)
 603                 buf_index += 3; /* PES extension */
 604             buf_index += 1;    /* obligatory stuffing byte */
 605         }
 606         if (pts != AV_NOPTS_VALUE) {
 607             if (dts != pts)
 608                 buf_index += 5 + 5;
 609             else
 610                 buf_index += 5;
 611
 612         } else {
 613             if (!s->is_mpeg2)
 614                 buf_index++;
 615         }
 616
 617         if (stream->id < 0xc0) {
 618             /* AC3/LPCM private data header */
 619             buf_index += 4;
 620             if (stream->id >= 0xa0) {
 621                 int n;
 622                 buf_index += 3;
 623                 /* NOTE: we round the payload size to an integer number of
 624                    LPCM samples */
 625                 n = (s->packet_size - buf_index) % stream->lpcm_align;
 626                 if (n)
 627                     buf_index += (stream->lpcm_align - n);
 628             }
 629         }
 630
 631         if (s->is_vcd && stream->id == AUDIO_ID)
 632             /* The VCD standard demands that 20 zero bytes follow
 633                each audio packet (see standard p. IV-8).*/
 634             buf_index+=20;
 635     }
 636     return s->packet_size - buf_index;
 637 }
 638 #endif
 639
 640 /* Write an MPEG padding packet header. */
 641 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
 642 {
 643     MpegMuxContext *s = ctx->priv_data;
 644     int i;
 645
 646     put_be32(pb, PADDING_STREAM);
 647     put_be16(pb, packet_bytes - 6);
 648     if (!s->is_mpeg2) {
 649         put_byte(pb, 0x0f);
 650         packet_bytes -= 7;
 651     } else
 652         packet_bytes -= 6;
 653
 654     for(i=0;i<packet_bytes;i++)
 655         put_byte(pb, 0xff);
 656 }
 657
 658 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
 659     int nb_frames=0;
 660     PacketDesc *pkt_desc= stream->premux_packet;
 661
 662     while(len>0){
 663         if(pkt_desc->size == pkt_desc->unwritten_size)
 664             nb_frames++;
 665         len -= pkt_desc->unwritten_size;
 666         pkt_desc= pkt_desc->next;
 667     }
 668
 669     return nb_frames;
 670 }
 671
 672 /* flush the packet on stream stream_index */
 673 static int flush_packet(AVFormatContext *ctx, int stream_index,
 674                          int64_t pts, int64_t dts, int64_t scr, int trailer_size)
 675 {
 676     MpegMuxContext *s = ctx->priv_data;
 677     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
 678     uint8_t *buf_ptr;
 679     int size, payload_size, startcode, id, stuffing_size, i, header_len;
 680     int packet_size;
 681     uint8_t buffer[128];
 682     int zero_trail_bytes = 0;
 683     int pad_packet_bytes = 0;
 684     int pes_flags;
 685     int general_pack = 0;  /*"general" pack without data specific to one stream?*/
 686     int nb_frames;
 687
 688     id = stream->id;
 689
 690 #if 0
 691     printf("packet ID=%2x PTS=%0.3f\n",
 692            id, pts / 90000.0);
 693 #endif
 694
 695     buf_ptr = buffer;
 696
 697     if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
 698         /* output pack and systems header if needed */
 699         size = put_pack_header(ctx, buf_ptr, scr);
 700         buf_ptr += size;
 701         s->last_scr= scr;
 702
 703         if (s->is_vcd) {
 704             /* there is exactly one system header for each stream in a VCD MPEG,
 705                One in the very first video packet and one in the very first
 706                audio packet (see VCD standard p. IV-7 and IV-8).*/
 707
 708             if (stream->packet_number==0) {
 709                 size = put_system_header(ctx, buf_ptr, id);
 710                 buf_ptr += size;
 711             }
 712         } else if (s->is_dvd) {
 713             if (stream->align_iframe || s->packet_number == 0){
 714                 int PES_bytes_to_fill = s->packet_size - size - 10;
 715
 716                 if (pts != AV_NOPTS_VALUE) {
 717                     if (dts != pts)
 718                         PES_bytes_to_fill -= 5 + 5;
 719                     else
 720                         PES_bytes_to_fill -= 5;
 721                 }
 722
 723                 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
 724                     size = put_system_header(ctx, buf_ptr, 0);
 725                     buf_ptr += size;
 726                     size = buf_ptr - buffer;
 727                     put_buffer(&ctx->pb, buffer, size);
 728
 729                     put_be32(&ctx->pb, PRIVATE_STREAM_2);
 730                     put_be16(&ctx->pb, 0x03d4);         // length
 731                     put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
 732                     for (i = 0; i < 979; i++)
 733                         put_byte(&ctx->pb, 0x00);
 734
 735                     put_be32(&ctx->pb, PRIVATE_STREAM_2);
 736                     put_be16(&ctx->pb, 0x03fa);         // length
 737                     put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
 738                     for (i = 0; i < 1017; i++)
 739                         put_byte(&ctx->pb, 0x00);
 740
 741                     memset(buffer, 0, 128);
 742                     buf_ptr = buffer;
 743                     s->packet_number++;
 744                     stream->align_iframe = 0;
 745                     scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
 746                     size = put_pack_header(ctx, buf_ptr, scr);
 747                     s->last_scr= scr;
 748                     buf_ptr += size;
 749                     /* GOP Start */
 750                 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
 751                     pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
 752                 }
 753             }
 754         } else {
 755             if ((s->packet_number % s->system_header_freq) == 0) {
 756                 size = put_system_header(ctx, buf_ptr, 0);
 757                 buf_ptr += size;
 758             }
 759         }
 760     }
 761     size = buf_ptr - buffer;
 762     put_buffer(&ctx->pb, buffer, size);
 763
 764     packet_size = s->packet_size - size;
 765
 766     if (s->is_vcd && id == AUDIO_ID)
 767         /* The VCD standard demands that 20 zero bytes follow
 768            each audio pack (see standard p. IV-8).*/
 769         zero_trail_bytes += 20;
 770
 771     if ((s->is_vcd && stream->packet_number==0)
 772         || (s->is_svcd && s->packet_number==0)) {
 773         /* for VCD the first pack of each stream contains only the pack header,
 774            the system header and lots of padding (see VCD standard p. IV-6).
 775            In the case of an audio pack, 20 zero bytes are also added at
 776            the end.*/
 777         /* For SVCD we fill the very first pack to increase compatibility with
 778            some DVD players. Not mandated by the standard.*/
 779         if (s->is_svcd)
 780             general_pack = 1;    /* the system header refers to both streams and no stream data*/
 781         pad_packet_bytes = packet_size - zero_trail_bytes;
 782     }
 783
 784     packet_size -= pad_packet_bytes + zero_trail_bytes;
 785
 786     if (packet_size > 0) {
 787
 788         /* packet header size */
 789         packet_size -= 6;
 790
 791         /* packet header */
 792         if (s->is_mpeg2) {
 793             header_len = 3;
 794             if (stream->packet_number==0)
 795                 header_len += 3; /* PES extension */
 796             header_len += 1; /* obligatory stuffing byte */
 797         } else {
 798             header_len = 0;
 799         }
 800         if (pts != AV_NOPTS_VALUE) {
 801             if (dts != pts)
 802                 header_len += 5 + 5;
 803             else
 804                 header_len += 5;
 805         } else {
 806             if (!s->is_mpeg2)
 807                 header_len++;
 808         }
 809
 810         payload_size = packet_size - header_len;
 811         if (id < 0xc0) {
 812             startcode = PRIVATE_STREAM_1;
 813             payload_size -= 1;
 814             if (id >= 0x40) {
 815                 payload_size -= 3;
 816                 if (id >= 0xa0)
 817                     payload_size -= 3;
 818             }
 819         } else {
 820             startcode = 0x100 + id;
 821         }
 822
 823         stuffing_size = payload_size - av_fifo_size(&stream->fifo);
 824
 825         // first byte doesnt fit -> reset pts/dts + stuffing
 826         if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
 827             int timestamp_len=0;
 828             if(dts != pts)
 829                 timestamp_len += 5;
 830             if(pts != AV_NOPTS_VALUE)
 831                 timestamp_len += s->is_mpeg2 ? 5 : 4;
 832             pts=dts= AV_NOPTS_VALUE;
 833             header_len -= timestamp_len;
 834             if (s->is_dvd && stream->align_iframe) {
 835                 pad_packet_bytes += timestamp_len;
 836                 packet_size -= timestamp_len;
 837             } else {
 838                 payload_size += timestamp_len;
 839             }
 840             stuffing_size += timestamp_len;
 841             if(payload_size > trailer_size)
 842                 stuffing_size += payload_size - trailer_size;
 843         }
 844
 845         if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
 846             packet_size += pad_packet_bytes;
 847             payload_size += pad_packet_bytes; // undo the previous adjustment
 848             if (stuffing_size < 0) {
 849                 stuffing_size = pad_packet_bytes;
 850             } else {
 851                 stuffing_size += pad_packet_bytes;
 852             }
 853             pad_packet_bytes = 0;
 854         }
 855
 856         if (stuffing_size < 0)
 857             stuffing_size = 0;
 858         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
 859             pad_packet_bytes += stuffing_size;
 860             packet_size -= stuffing_size;
 861             payload_size -= stuffing_size;
 862             stuffing_size = 0;
 863         }
 864
 865         nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
 866
 867         put_be32(&ctx->pb, startcode);
 868
 869         put_be16(&ctx->pb, packet_size);
 870
 871         if (!s->is_mpeg2)
 872             for(i=0;i<stuffing_size;i++)
 873                 put_byte(&ctx->pb, 0xff);
 874
 875         if (s->is_mpeg2) {
 876             put_byte(&ctx->pb, 0x80); /* mpeg2 id */
 877
 878             pes_flags=0;
 879
 880             if (pts != AV_NOPTS_VALUE) {
 881                 pes_flags |= 0x80;
 882                 if (dts != pts)
 883                     pes_flags |= 0x40;
 884             }
 885
 886             /* Both the MPEG-2 and the SVCD standards demand that the
 887                P-STD_buffer_size field be included in the first packet of
 888                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
 889                and MPEG-2 standard 2.7.7) */
 890             if (stream->packet_number == 0)
 891                 pes_flags |= 0x01;
 892
 893             put_byte(&ctx->pb, pes_flags); /* flags */
 894             put_byte(&ctx->pb, header_len - 3 + stuffing_size);
 895
 896             if (pes_flags & 0x80)  /*write pts*/
 897                 put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
 898             if (pes_flags & 0x40)  /*write dts*/
 899                 put_timestamp(&ctx->pb, 0x01, dts);
 900
 901             if (pes_flags & 0x01) {  /*write pes extension*/
 902                 put_byte(&ctx->pb, 0x10); /* flags */
 903
 904                 /* P-STD buffer info */
 905                 if (id == AUDIO_ID)
 906                     put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
 907                 else
 908                     put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
 909             }
 910
 911         } else {
 912             if (pts != AV_NOPTS_VALUE) {
 913                 if (dts != pts) {
 914                     put_timestamp(&ctx->pb, 0x03, pts);
 915                     put_timestamp(&ctx->pb, 0x01, dts);
 916                 } else {
 917                     put_timestamp(&ctx->pb, 0x02, pts);
 918                 }
 919             } else {
 920                 put_byte(&ctx->pb, 0x0f);
 921             }
 922         }
 923
 924         if (s->is_mpeg2) {
 925             /* special stuffing byte that is always written
 926                to prevent accidental generation of start codes. */
 927             put_byte(&ctx->pb, 0xff);
 928
 929             for(i=0;i<stuffing_size;i++)
 930                 put_byte(&ctx->pb, 0xff);
 931         }
 932
 933         if (startcode == PRIVATE_STREAM_1) {
 934             put_byte(&ctx->pb, id);
 935             if (id >= 0xa0) {
 936                 /* LPCM (XXX: check nb_frames) */
 937                 put_byte(&ctx->pb, 7);
 938                 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
 939                 put_byte(&ctx->pb, stream->lpcm_header[0]);
 940                 put_byte(&ctx->pb, stream->lpcm_header[1]);
 941                 put_byte(&ctx->pb, stream->lpcm_header[2]);
 942             } else if (id >= 0x40) {
 943                 /* AC3 */
 944                 put_byte(&ctx->pb, nb_frames);
 945                 put_be16(&ctx->pb, trailer_size+1);
 946             }
 947         }
 948
 949         /* output data */
 950         if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
 951             return -1;
 952         stream->bytes_to_iframe -= payload_size - stuffing_size;
 953     }else{
 954         payload_size=
 955         stuffing_size= 0;
 956     }
 957
 958     if (pad_packet_bytes > 0)
 959         put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
 960
 961     for(i=0;i<zero_trail_bytes;i++)
 962         put_byte(&ctx->pb, 0x00);
 963
 964     put_flush_packet(&ctx->pb);
 965
 966     s->packet_number++;
 967
 968     /* only increase the stream packet number if this pack actually contains
 969        something that is specific to this stream! I.e. a dedicated header
 970        or some data.*/
 971     if (!general_pack)
 972         stream->packet_number++;
 973
 974     return payload_size - stuffing_size;
 975 }
 976
 977 static void put_vcd_padding_sector(AVFormatContext *ctx)
 978 {
 979     /* There are two ways to do this padding: writing a sector/pack
 980        of 0 values, or writing an MPEG padding pack. Both seem to
 981        work with most decoders, BUT the VCD standard only allows a 0-sector
 982        (see standard p. IV-4, IV-5).
 983        So a 0-sector it is...*/
 984
 985     MpegMuxContext *s = ctx->priv_data;
 986     int i;
 987
 988     for(i=0;i<s->packet_size;i++)
 989         put_byte(&ctx->pb, 0);
 990
 991     s->vcd_padding_bytes_written += s->packet_size;
 992
 993     put_flush_packet(&ctx->pb);
 994
 995     /* increasing the packet number is correct. The SCR of the following packs
 996        is calculated from the packet_number and it has to include the padding
 997        sector (it represents the sector index, not the MPEG pack index)
 998        (see VCD standard p. IV-6)*/
 999     s->packet_number++;
1000 }
1001
1002 #if 0 /* unused, remove? */
1003 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
1004 {
1005     MpegMuxContext *s = ctx->priv_data;
1006     int64_t scr;
1007
1008         /* Since the data delivery rate is constant, SCR is computed
1009            using the formula C + i * 1200 where C is the start constant
1010            and i is the pack index.
1011            It is recommended that SCR 0 is at the beginning of the VCD front
1012            margin (a sequence of empty Form 2 sectors on the CD).
1013            It is recommended that the front margin is 30 sectors long, so
1014            we use C = 30*1200 = 36000
1015            (Note that even if the front margin is not 30 sectors the file
1016            will still be correct according to the standard. It just won't have
1017            the "recommended" value).*/
1018         scr = 36000 + s->packet_number * 1200;
1019
1020     return scr;
1021 }
1022 #endif
1023
1024 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1025 //    MpegMuxContext *s = ctx->priv_data;
1026     int i;
1027
1028     for(i=0; i<ctx->nb_streams; i++){
1029         AVStream *st = ctx->streams[i];
1030         StreamInfo *stream = st->priv_data;
1031         PacketDesc *pkt_desc;
1032
1033         while((pkt_desc= stream->predecode_packet)
1034               && scr > pkt_desc->dts){ //FIXME > vs >=
1035             if(stream->buffer_index < pkt_desc->size ||
1036                stream->predecode_packet == stream->premux_packet){
1037                 av_log(ctx, AV_LOG_ERROR,
1038                        "buffer underflow i=%d bufi=%d size=%d\n",
1039                        i, stream->buffer_index, pkt_desc->size);
1040                 break;
1041             }
1042             stream->buffer_index -= pkt_desc->size;
1043
1044             stream->predecode_packet= pkt_desc->next;
1045             av_freep(&pkt_desc);
1046         }
1047     }
1048
1049     return 0;
1050 }
1051
1052 static int output_packet(AVFormatContext *ctx, int flush){
1053     MpegMuxContext *s = ctx->priv_data;
1054     AVStream *st;
1055     StreamInfo *stream;
1056     int i, avail_space, es_size, trailer_size;
1057     int best_i= -1;
1058     int best_score= INT_MIN;
1059     int ignore_constraints=0;
1060     int64_t scr= s->last_scr;
1061     PacketDesc *timestamp_packet;
1062     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1063
1064 retry:
1065     for(i=0; i<ctx->nb_streams; i++){
1066         AVStream *st = ctx->streams[i];
1067         StreamInfo *stream = st->priv_data;
1068         const int avail_data=  av_fifo_size(&stream->fifo);
1069         const int space= stream->max_buffer_size - stream->buffer_index;
1070         int rel_space= 1024*space / stream->max_buffer_size;
1071         PacketDesc *next_pkt= stream->premux_packet;
1072
1073         /* for subtitle, a single PES packet must be generated,
1074            so we flush after every single subtitle packet */
1075         if(s->packet_size > avail_data && !flush
1076            && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1077             return 0;
1078         if(avail_data==0)
1079             continue;
1080         assert(avail_data>0);
1081
1082         if(space < s->packet_size && !ignore_constraints)
1083             continue;
1084
1085         if(next_pkt && next_pkt->dts - scr > max_delay)
1086             continue;
1087
1088         if(rel_space > best_score){
1089             best_score= rel_space;
1090             best_i = i;
1091             avail_space= space;
1092         }
1093     }
1094
1095     if(best_i < 0){
1096         int64_t best_dts= INT64_MAX;
1097
1098         for(i=0; i<ctx->nb_streams; i++){
1099             AVStream *st = ctx->streams[i];
1100             StreamInfo *stream = st->priv_data;
1101             PacketDesc *pkt_desc= stream->predecode_packet;
1102             if(pkt_desc && pkt_desc->dts < best_dts)
1103                 best_dts= pkt_desc->dts;
1104         }
1105
1106 #if 0
1107         av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1108                scr/90000.0, best_dts/90000.0);
1109 #endif
1110         if(best_dts == INT64_MAX)
1111             return 0;
1112
1113         if(scr >= best_dts+1 && !ignore_constraints){
1114             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1115             ignore_constraints= 1;
1116         }
1117         scr= FFMAX(best_dts+1, scr);
1118         if(remove_decoded_packets(ctx, scr) < 0)
1119             return -1;
1120         goto retry;
1121     }
1122
1123     assert(best_i >= 0);
1124
1125     st = ctx->streams[best_i];
1126     stream = st->priv_data;
1127
1128     assert(av_fifo_size(&stream->fifo) > 0);
1129
1130     assert(avail_space >= s->packet_size || ignore_constraints);
1131
1132     timestamp_packet= stream->premux_packet;
1133     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1134         trailer_size= 0;
1135     }else{
1136         trailer_size= timestamp_packet->unwritten_size;
1137         timestamp_packet= timestamp_packet->next;
1138     }
1139
1140     if(timestamp_packet){
1141 //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);
1142         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1143     }else{
1144         assert(av_fifo_size(&stream->fifo) == trailer_size);
1145         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1146     }
1147
1148     if (s->is_vcd) {
1149         /* Write one or more padding sectors, if necessary, to reach
1150            the constant overall bitrate.*/
1151         int vcd_pad_bytes;
1152
1153         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1154             put_vcd_padding_sector(ctx);
1155             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1156         }
1157     }
1158
1159     stream->buffer_index += es_size;
1160     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1161
1162     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1163         es_size -= stream->premux_packet->unwritten_size;
1164         stream->premux_packet= stream->premux_packet->next;
1165     }
1166     if(es_size)
1167         stream->premux_packet->unwritten_size -= es_size;
1168
1169     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1170         return -1;
1171
1172     return 1;
1173 }
1174
1175 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1176 {
1177     MpegMuxContext *s = ctx->priv_data;
1178     int stream_index= pkt->stream_index;
1179     int size= pkt->size;
1180     uint8_t *buf= pkt->data;
1181     AVStream *st = ctx->streams[stream_index];
1182     StreamInfo *stream = st->priv_data;
1183     int64_t pts, dts;
1184     PacketDesc *pkt_desc;
1185     const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1186     const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1187
1188     pts= pkt->pts;
1189     dts= pkt->dts;
1190
1191     if(pts != AV_NOPTS_VALUE) pts += preload;
1192     if(dts != AV_NOPTS_VALUE) dts += preload;
1193
1194 //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);
1195     if (!stream->premux_packet)
1196         stream->next_packet = &stream->premux_packet;
1197     *stream->next_packet=
1198     pkt_desc= av_mallocz(sizeof(PacketDesc));
1199     pkt_desc->pts= pts;
1200     pkt_desc->dts= dts;
1201     pkt_desc->unwritten_size=
1202     pkt_desc->size= size;
1203     if(!stream->predecode_packet)
1204         stream->predecode_packet= pkt_desc;
1205     stream->next_packet= &pkt_desc->next;
1206
1207     av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1208
1209     if (s->is_dvd){
1210         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1211             stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1212             stream->align_iframe = 1;
1213             stream->vobu_start_pts = pts;
1214         } else {
1215             stream->align_iframe = 0;
1216         }
1217     }
1218
1219     av_fifo_write(&stream->fifo, buf, size);
1220
1221     for(;;){
1222         int ret= output_packet(ctx, 0);
1223         if(ret<=0)
1224             return ret;
1225     }
1226 }
1227
1228 static int mpeg_mux_end(AVFormatContext *ctx)
1229 {
1230 //    MpegMuxContext *s = ctx->priv_data;
1231     StreamInfo *stream;
1232     int i;
1233
1234     for(;;){
1235         int ret= output_packet(ctx, 1);
1236         if(ret<0)
1237             return ret;
1238         else if(ret==0)
1239             break;
1240     }
1241
1242     /* End header according to MPEG1 systems standard. We do not write
1243        it as it is usually not needed by decoders and because it
1244        complicates MPEG stream concatenation. */
1245     //put_be32(&ctx->pb, ISO_11172_END_CODE);
1246     //put_flush_packet(&ctx->pb);
1247
1248     for(i=0;i<ctx->nb_streams;i++) {
1249         stream = ctx->streams[i]->priv_data;
1250
1251         assert(av_fifo_size(&stream->fifo) == 0);
1252         av_fifo_free(&stream->fifo);
1253     }
1254     return 0;
1255 }
1256 #endif //CONFIG_MUXERS
1257
1258 /*********************************************/
1259 /* demux code */
1260
1261 #define MAX_SYNC_SIZE 100000
1262
1263 static int cdxa_probe(AVProbeData *p)
1264 {
1265     /* check file header */
1266     if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1267         p->buf[2] == 'F' && p->buf[3] == 'F' &&
1268         p->buf[8] == 'C' && p->buf[9] == 'D' &&
1269         p->buf[10] == 'X' && p->buf[11] == 'A')
1270         return AVPROBE_SCORE_MAX;
1271     else
1272         return 0;
1273 }
1274
1275 static int mpegps_probe(AVProbeData *p)
1276 {
1277     uint32_t code= -1;
1278     int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1279     int i;
1280     int score=0;
1281
1282     score = cdxa_probe(p);
1283     if (score > 0) return score;
1284
1285     /* Search for MPEG stream */
1286     for(i=0; i<p->buf_size; i++){
1287         code = (code<<8) + p->buf[i];
1288         if ((code & 0xffffff00) == 0x100) {
1289             if(code == SYSTEM_HEADER_START_CODE) sys++;
1290             else if(code == PRIVATE_STREAM_1)    priv1++;
1291             else if(code == PACK_START_CODE)     pspack++;
1292             else if((code & 0xf0) == VIDEO_ID)   vid++;
1293             else if((code & 0xe0) == AUDIO_ID)   audio++;
1294         }
1295     }
1296
1297     if(vid || audio)            /* invalid VDR files nd short PES streams */
1298         score= AVPROBE_SCORE_MAX/4;
1299
1300 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1301     if(sys && sys*9 <= pspack*10)
1302         return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1303     if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1304         return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1305     if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1306         return AVPROBE_SCORE_MAX/2+2;
1307
1308     //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1309     return score;
1310 }
1311
1312
1313 typedef struct MpegDemuxContext {
1314     int32_t header_state;
1315     unsigned char psm_es_type[256];
1316 } MpegDemuxContext;
1317
1318 static int mpegps_read_header(AVFormatContext *s,
1319                               AVFormatParameters *ap)
1320 {
1321     MpegDemuxContext *m = s->priv_data;
1322     m->header_state = 0xff;
1323     s->ctx_flags |= AVFMTCTX_NOHEADER;
1324
1325     /* no need to do more */
1326     return 0;
1327 }
1328
1329 static int64_t get_pts(ByteIOContext *pb, int c)
1330 {
1331     int64_t pts;
1332     int val;
1333
1334     if (c < 0)
1335         c = get_byte(pb);
1336     pts = (int64_t)((c >> 1) & 0x07) << 30;
1337     val = get_be16(pb);
1338     pts |= (int64_t)(val >> 1) << 15;
1339     val = get_be16(pb);
1340     pts |= (int64_t)(val >> 1);
1341     return pts;
1342 }
1343
1344 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1345                                 int32_t *header_state)
1346 {
1347     unsigned int state, v;
1348     int val, n;
1349
1350     state = *header_state;
1351     n = *size_ptr;
1352     while (n > 0) {
1353         if (url_feof(pb))
1354             break;
1355         v = get_byte(pb);
1356         n--;
1357         if (state == 0x000001) {
1358             state = ((state << 8) | v) & 0xffffff;
1359             val = state;
1360             goto found;
1361         }
1362         state = ((state << 8) | v) & 0xffffff;
1363     }
1364     val = -1;
1365  found:
1366     *header_state = state;
1367     *size_ptr = n;
1368     return val;
1369 }
1370
1371 #if 0 /* unused, remove? */
1372 /* XXX: optimize */
1373 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1374 {
1375     int64_t pos, pos_start;
1376     int max_size, start_code;
1377
1378     max_size = *size_ptr;
1379     pos_start = url_ftell(pb);
1380
1381     /* in order to go faster, we fill the buffer */
1382     pos = pos_start - 16386;
1383     if (pos < 0)
1384         pos = 0;
1385     url_fseek(pb, pos, SEEK_SET);
1386     get_byte(pb);
1387
1388     pos = pos_start;
1389     for(;;) {
1390         pos--;
1391         if (pos < 0 || (pos_start - pos) >= max_size) {
1392             start_code = -1;
1393             goto the_end;
1394         }
1395         url_fseek(pb, pos, SEEK_SET);
1396         start_code = get_be32(pb);
1397         if ((start_code & 0xffffff00) == 0x100)
1398             break;
1399     }
1400  the_end:
1401     *size_ptr = pos_start - pos;
1402     return start_code;
1403 }
1404 #endif
1405
1406 /**
1407  * Extracts stream types from a program stream map
1408  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1409  *
1410  * @return number of bytes occupied by PSM in the bitstream
1411  */
1412 static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1413 {
1414     int psm_length, ps_info_length, es_map_length;
1415
1416     psm_length = get_be16(pb);
1417     get_byte(pb);
1418     get_byte(pb);
1419     ps_info_length = get_be16(pb);
1420
1421     /* skip program_stream_info */
1422     url_fskip(pb, ps_info_length);
1423     es_map_length = get_be16(pb);
1424
1425     /* at least one es available? */
1426     while (es_map_length >= 4){
1427         unsigned char type = get_byte(pb);
1428         unsigned char es_id = get_byte(pb);
1429         uint16_t es_info_length = get_be16(pb);
1430         /* remember mapping from stream id to stream type */
1431         m->psm_es_type[es_id] = type;
1432         /* skip program_stream_info */
1433         url_fskip(pb, es_info_length);
1434         es_map_length -= 4 + es_info_length;
1435     }
1436     get_be32(pb); /* crc32 */
1437     return 2 + psm_length;
1438 }
1439
1440 /* read the next PES header. Return its position in ppos
1441    (if not NULL), and its start code, pts and dts.
1442  */
1443 static int mpegps_read_pes_header(AVFormatContext *s,
1444                                   int64_t *ppos, int *pstart_code,
1445                                   int64_t *ppts, int64_t *pdts)
1446 {
1447     MpegDemuxContext *m = s->priv_data;
1448     int len, size, startcode, c, flags, header_len;
1449     int pes_ext, ext2_len, id_ext, skip;
1450     int64_t pts, dts;
1451     int64_t last_sync= url_ftell(&s->pb);
1452
1453  error_redo:
1454         url_fseek(&s->pb, last_sync, SEEK_SET);
1455  redo:
1456         /* next start code (should be immediately after) */
1457         m->header_state = 0xff;
1458         size = MAX_SYNC_SIZE;
1459         startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1460         last_sync = url_ftell(&s->pb);
1461     //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(&s->pb));
1462     if (startcode < 0)
1463         return AVERROR_IO;
1464     if (startcode == PACK_START_CODE)
1465         goto redo;
1466     if (startcode == SYSTEM_HEADER_START_CODE)
1467         goto redo;
1468     if (startcode == PADDING_STREAM ||
1469         startcode == PRIVATE_STREAM_2) {
1470         /* skip them */
1471         len = get_be16(&s->pb);
1472         url_fskip(&s->pb, len);
1473         goto redo;
1474     }
1475     if (startcode == PROGRAM_STREAM_MAP) {
1476         mpegps_psm_parse(m, &s->pb);
1477         goto redo;
1478     }
1479
1480     /* find matching stream */
1481     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1482           (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1483           (startcode == 0x1bd) || (startcode == 0x1fd)))
1484         goto redo;
1485     if (ppos) {
1486         *ppos = url_ftell(&s->pb) - 4;
1487     }
1488     len = get_be16(&s->pb);
1489     pts =
1490     dts = AV_NOPTS_VALUE;
1491     /* stuffing */
1492     for(;;) {
1493         if (len < 1)
1494             goto error_redo;
1495         c = get_byte(&s->pb);
1496         len--;
1497         /* XXX: for mpeg1, should test only bit 7 */
1498         if (c != 0xff)
1499             break;
1500     }
1501     if ((c & 0xc0) == 0x40) {
1502         /* buffer scale & size */
1503         get_byte(&s->pb);
1504         c = get_byte(&s->pb);
1505         len -= 2;
1506     }
1507     if ((c & 0xe0) == 0x20) {
1508         dts = pts = get_pts(&s->pb, c);
1509         len -= 4;
1510         if (c & 0x10){
1511             dts = get_pts(&s->pb, -1);
1512             len -= 5;
1513         }
1514     } else if ((c & 0xc0) == 0x80) {
1515         /* mpeg 2 PES */
1516 #if 0 /* some streams have this field set for no apparent reason */
1517         if ((c & 0x30) != 0) {
1518             /* Encrypted multiplex not handled */
1519             goto redo;
1520         }
1521 #endif
1522         flags = get_byte(&s->pb);
1523         header_len = get_byte(&s->pb);
1524         len -= 2;
1525         if (header_len > len)
1526             goto error_redo;
1527         len -= header_len;
1528         if (flags & 0x80) {
1529             dts = pts = get_pts(&s->pb, -1);
1530             header_len -= 5;
1531             if (flags & 0x40) {
1532                 dts = get_pts(&s->pb, -1);
1533                 header_len -= 5;
1534             }
1535         }
1536         if (flags & 0x01) { /* PES extension */
1537             pes_ext = get_byte(&s->pb);
1538             header_len--;
1539             if (pes_ext & 0x40) { /* pack header - should be zero in PS */
1540                 goto error_redo;
1541             }
1542             /* Skip PES private data, program packet sequence counter and P-STD buffer */
1543             skip = (pes_ext >> 4) & 0xb;
1544             skip += skip & 0x9;
1545             url_fskip(&s->pb, skip);
1546             header_len -= skip;
1547
1548             if (pes_ext & 0x01) { /* PES extension 2 */
1549                 ext2_len = get_byte(&s->pb);
1550                 header_len--;
1551                 if ((ext2_len & 0x7f) > 0) {
1552                     id_ext = get_byte(&s->pb);
1553                     if ((id_ext & 0x80) == 0)
1554                         startcode = ((startcode & 0xff) << 8) | id_ext;
1555                     header_len--;
1556                 }
1557             }
1558         }
1559         if(header_len < 0)
1560             goto error_redo;
1561         url_fskip(&s->pb, header_len);
1562     }
1563     else if( c!= 0xf )
1564         goto redo;
1565
1566     if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1567         startcode = get_byte(&s->pb);
1568         len--;
1569         if (startcode >= 0x80 && startcode <= 0xcf) {
1570             /* audio: skip header */
1571             get_byte(&s->pb);
1572             get_byte(&s->pb);
1573             get_byte(&s->pb);
1574             len -= 3;
1575             if (startcode >= 0xb0 && startcode <= 0xbf) {
1576                 /* MLP/TrueHD audio has a 4-byte header */
1577                 get_byte(&s->pb);
1578                 len--;
1579             }
1580         }
1581     }
1582     if(len<0)
1583         goto error_redo;
1584     if(dts != AV_NOPTS_VALUE && ppos){
1585         int i;
1586         for(i=0; i<s->nb_streams; i++){
1587             if(startcode == s->streams[i]->id) {
1588                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1589             }
1590         }
1591     }
1592
1593     *pstart_code = startcode;
1594     *ppts = pts;
1595     *pdts = dts;
1596     return len;
1597 }
1598
1599 static int mpegps_read_packet(AVFormatContext *s,
1600                               AVPacket *pkt)
1601 {
1602     MpegDemuxContext *m = s->priv_data;
1603     AVStream *st;
1604     int len, startcode, i, type, codec_id = 0, es_type;
1605     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1606
1607  redo:
1608     len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1609     if (len < 0)
1610         return len;
1611
1612     /* now find stream */
1613     for(i=0;i<s->nb_streams;i++) {
1614         st = s->streams[i];
1615         if (st->id == startcode)
1616             goto found;
1617     }
1618
1619     es_type = m->psm_es_type[startcode & 0xff];
1620     if(es_type > 0){
1621         if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1622             codec_id = CODEC_ID_MPEG2VIDEO;
1623             type = CODEC_TYPE_VIDEO;
1624         } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1625             codec_id = CODEC_ID_MPEG2VIDEO;
1626             type = CODEC_TYPE_VIDEO;
1627         } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1628                   es_type == STREAM_TYPE_AUDIO_MPEG2){
1629             codec_id = CODEC_ID_MP3;
1630             type = CODEC_TYPE_AUDIO;
1631         } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1632             codec_id = CODEC_ID_AAC;
1633             type = CODEC_TYPE_AUDIO;
1634         } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1635             codec_id = CODEC_ID_MPEG4;
1636             type = CODEC_TYPE_VIDEO;
1637         } else if(es_type == STREAM_TYPE_VIDEO_H264){
1638             codec_id = CODEC_ID_H264;
1639             type = CODEC_TYPE_VIDEO;
1640         } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1641             codec_id = CODEC_ID_AC3;
1642             type = CODEC_TYPE_AUDIO;
1643         } else {
1644             goto skip;
1645         }
1646     } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1647         static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1648         unsigned char buf[8];
1649         get_buffer(&s->pb, buf, 8);
1650         url_fseek(&s->pb, -8, SEEK_CUR);
1651         if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1652             codec_id = CODEC_ID_CAVS;
1653         else
1654             codec_id = CODEC_ID_MPEG2VIDEO;
1655         type = CODEC_TYPE_VIDEO;
1656     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1657         type = CODEC_TYPE_AUDIO;
1658         codec_id = CODEC_ID_MP2;
1659     } else if (startcode >= 0x80 && startcode <= 0x87) {
1660         type = CODEC_TYPE_AUDIO;
1661         codec_id = CODEC_ID_AC3;
1662     } else if ((startcode >= 0x88 && startcode <= 0x8f)
1663                ||( startcode >= 0x98 && startcode <= 0x9f)) {
1664         /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
1665         type = CODEC_TYPE_AUDIO;
1666         codec_id = CODEC_ID_DTS;
1667     } else if (startcode >= 0xa0 && startcode <= 0xaf) {
1668         type = CODEC_TYPE_AUDIO;
1669         codec_id = CODEC_ID_PCM_S16BE;
1670     } else if (startcode >= 0xb0 && startcode <= 0xbf) {
1671         type = CODEC_TYPE_AUDIO;
1672         codec_id = CODEC_ID_MLP;
1673     } else if (startcode >= 0xc0 && startcode <= 0xcf) {
1674         /* Used for both AC-3 and E-AC-3 in EVOB files */
1675         type = CODEC_TYPE_AUDIO;
1676         codec_id = CODEC_ID_AC3;
1677     } else if (startcode >= 0x20 && startcode <= 0x3f) {
1678         type = CODEC_TYPE_SUBTITLE;
1679         codec_id = CODEC_ID_DVD_SUBTITLE;
1680     } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
1681         type = CODEC_TYPE_VIDEO;
1682         codec_id = CODEC_ID_VC1;
1683     } else {
1684     skip:
1685         /* skip packet */
1686         url_fskip(&s->pb, len);
1687         goto redo;
1688     }
1689     /* no stream found: add a new stream */
1690     st = av_new_stream(s, startcode);
1691     if (!st)
1692         goto skip;
1693     st->codec->codec_type = type;
1694     st->codec->codec_id = codec_id;
1695     if (codec_id != CODEC_ID_PCM_S16BE)
1696         st->need_parsing = AVSTREAM_PARSE_FULL;
1697  found:
1698     if(st->discard >= AVDISCARD_ALL)
1699         goto skip;
1700     if (startcode >= 0xa0 && startcode <= 0xaf) {
1701         int b1, freq;
1702
1703         /* for LPCM, we just skip the header and consider it is raw
1704            audio data */
1705         if (len <= 3)
1706             goto skip;
1707         get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1708         b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1709         get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1710         len -= 3;
1711         freq = (b1 >> 4) & 3;
1712         st->codec->sample_rate = lpcm_freq_tab[freq];
1713         st->codec->channels = 1 + (b1 & 7);
1714         st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1715     }
1716     av_new_packet(pkt, len);
1717     get_buffer(&s->pb, pkt->data, pkt->size);
1718     pkt->pts = pts;
1719     pkt->dts = dts;
1720     pkt->stream_index = st->index;
1721 #if 0
1722     av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1723            pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1724 #endif
1725
1726     return 0;
1727 }
1728
1729 static int mpegps_read_close(AVFormatContext *s)
1730 {
1731     return 0;
1732 }
1733
1734 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1735                                int64_t *ppos, int64_t pos_limit)
1736 {
1737     int len, startcode;
1738     int64_t pos, pts, dts;
1739
1740     pos = *ppos;
1741 #ifdef DEBUG_SEEK
1742     printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
1743 #endif
1744     url_fseek(&s->pb, pos, SEEK_SET);
1745     for(;;) {
1746         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1747         if (len < 0) {
1748 #ifdef DEBUG_SEEK
1749             printf("none (ret=%d)\n", len);
1750 #endif
1751             return AV_NOPTS_VALUE;
1752         }
1753         if (startcode == s->streams[stream_index]->id &&
1754             dts != AV_NOPTS_VALUE) {
1755             break;
1756         }
1757         url_fskip(&s->pb, len);
1758     }
1759 #ifdef DEBUG_SEEK
1760     printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
1761 #endif
1762     *ppos = pos;
1763     return dts;
1764 }
1765
1766 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1767 AVOutputFormat mpeg1system_muxer = {
1768     "mpeg",
1769     "MPEG1 System format",
1770     "video/mpeg",
1771     "mpg,mpeg",
1772     sizeof(MpegMuxContext),
1773     CODEC_ID_MP2,
1774     CODEC_ID_MPEG1VIDEO,
1775     mpeg_mux_init,
1776     mpeg_mux_write_packet,
1777     mpeg_mux_end,
1778 };
1779 #endif
1780 #ifdef CONFIG_MPEG1VCD_MUXER
1781 AVOutputFormat mpeg1vcd_muxer = {
1782     "vcd",
1783     "MPEG1 System format (VCD)",
1784     "video/mpeg",
1785     NULL,
1786     sizeof(MpegMuxContext),
1787     CODEC_ID_MP2,
1788     CODEC_ID_MPEG1VIDEO,
1789     mpeg_mux_init,
1790     mpeg_mux_write_packet,
1791     mpeg_mux_end,
1792 };
1793 #endif
1794 #ifdef CONFIG_MPEG2VOB_MUXER
1795 AVOutputFormat mpeg2vob_muxer = {
1796     "vob",
1797     "MPEG2 PS format (VOB)",
1798     "video/mpeg",
1799     "vob",
1800     sizeof(MpegMuxContext),
1801     CODEC_ID_MP2,
1802     CODEC_ID_MPEG2VIDEO,
1803     mpeg_mux_init,
1804     mpeg_mux_write_packet,
1805     mpeg_mux_end,
1806 };
1807 #endif
1808
1809 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1810 #ifdef CONFIG_MPEG2SVCD_MUXER
1811 AVOutputFormat mpeg2svcd_muxer = {
1812     "svcd",
1813     "MPEG2 PS format (VOB)",
1814     "video/mpeg",
1815     "vob",
1816     sizeof(MpegMuxContext),
1817     CODEC_ID_MP2,
1818     CODEC_ID_MPEG2VIDEO,
1819     mpeg_mux_init,
1820     mpeg_mux_write_packet,
1821     mpeg_mux_end,
1822 };
1823 #endif
1824
1825 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1826 #ifdef CONFIG_MPEG2DVD_MUXER
1827 AVOutputFormat mpeg2dvd_muxer = {
1828     "dvd",
1829     "MPEG2 PS format (DVD VOB)",
1830     "video/mpeg",
1831     "dvd",
1832     sizeof(MpegMuxContext),
1833     CODEC_ID_MP2,
1834     CODEC_ID_MPEG2VIDEO,
1835     mpeg_mux_init,
1836     mpeg_mux_write_packet,
1837     mpeg_mux_end,
1838 };
1839 #endif
1840
1841 #ifdef CONFIG_MPEGPS_DEMUXER
1842 AVInputFormat mpegps_demuxer = {
1843     "mpeg",
1844     "MPEG PS format",
1845     sizeof(MpegDemuxContext),
1846     mpegps_probe,
1847     mpegps_read_header,
1848     mpegps_read_packet,
1849     mpegps_read_close,
1850     NULL, //mpegps_read_seek,
1851     mpegps_read_dts,
1852     .flags = AVFMT_SHOW_IDS,
1853 };
1854 #endif