libavformat/mpeg.c

   1 /*
   2  * MPEG1/2 mux/demux
   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 -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= stream->predecode_packet;
1032
1033         while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1034             if(stream->buffer_index < pkt_desc->size ||
1035                stream->predecode_packet == stream->premux_packet){
1036                 av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1037                 break;
1038             }
1039             stream->buffer_index -= pkt_desc->size;
1040
1041             stream->predecode_packet= pkt_desc->next;
1042             av_freep(&pkt_desc);
1043         }
1044     }
1045
1046     return 0;
1047 }
1048
1049 static int output_packet(AVFormatContext *ctx, int flush){
1050     MpegMuxContext *s = ctx->priv_data;
1051     AVStream *st;
1052     StreamInfo *stream;
1053     int i, avail_space, es_size, trailer_size;
1054     int best_i= -1;
1055     int best_score= INT_MIN;
1056     int ignore_constraints=0;
1057     int64_t scr= s->last_scr;
1058     PacketDesc *timestamp_packet;
1059     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1060
1061 retry:
1062     for(i=0; i<ctx->nb_streams; i++){
1063         AVStream *st = ctx->streams[i];
1064         StreamInfo *stream = st->priv_data;
1065         const int avail_data=  av_fifo_size(&stream->fifo);
1066         const int space= stream->max_buffer_size - stream->buffer_index;
1067         int rel_space= 1024*space / stream->max_buffer_size;
1068         PacketDesc *next_pkt= stream->premux_packet;
1069
1070         /* for subtitle, a single PES packet must be generated,
1071            so we flush after every single subtitle packet */
1072         if(s->packet_size > avail_data && !flush
1073            && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1074             return 0;
1075         if(avail_data==0)
1076             continue;
1077         assert(avail_data>0);
1078
1079         if(space < s->packet_size && !ignore_constraints)
1080             continue;
1081
1082         if(next_pkt && next_pkt->dts - scr > max_delay)
1083             continue;
1084
1085         if(rel_space > best_score){
1086             best_score= rel_space;
1087             best_i = i;
1088             avail_space= space;
1089         }
1090     }
1091
1092     if(best_i < 0){
1093         int64_t best_dts= INT64_MAX;
1094
1095         for(i=0; i<ctx->nb_streams; i++){
1096             AVStream *st = ctx->streams[i];
1097             StreamInfo *stream = st->priv_data;
1098             PacketDesc *pkt_desc= stream->predecode_packet;
1099             if(pkt_desc && pkt_desc->dts < best_dts)
1100                 best_dts= pkt_desc->dts;
1101         }
1102
1103 #if 0
1104         av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1105                scr/90000.0, best_dts/90000.0);
1106 #endif
1107         if(best_dts == INT64_MAX)
1108             return 0;
1109
1110         if(scr >= best_dts+1 && !ignore_constraints){
1111             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1112             ignore_constraints= 1;
1113         }
1114         scr= FFMAX(best_dts+1, scr);
1115         if(remove_decoded_packets(ctx, scr) < 0)
1116             return -1;
1117         goto retry;
1118     }
1119
1120     assert(best_i >= 0);
1121
1122     st = ctx->streams[best_i];
1123     stream = st->priv_data;
1124
1125     assert(av_fifo_size(&stream->fifo) > 0);
1126
1127     assert(avail_space >= s->packet_size || ignore_constraints);
1128
1129     timestamp_packet= stream->premux_packet;
1130     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1131         trailer_size= 0;
1132     }else{
1133         trailer_size= timestamp_packet->unwritten_size;
1134         timestamp_packet= timestamp_packet->next;
1135     }
1136
1137     if(timestamp_packet){
1138 //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);
1139         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1140     }else{
1141         assert(av_fifo_size(&stream->fifo) == trailer_size);
1142         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1143     }
1144
1145     if (s->is_vcd) {
1146         /* Write one or more padding sectors, if necessary, to reach
1147            the constant overall bitrate.*/
1148         int vcd_pad_bytes;
1149
1150         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1151             put_vcd_padding_sector(ctx);
1152             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1153         }
1154     }
1155
1156     stream->buffer_index += es_size;
1157     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1158
1159     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1160         es_size -= stream->premux_packet->unwritten_size;
1161         stream->premux_packet= stream->premux_packet->next;
1162     }
1163     if(es_size)
1164         stream->premux_packet->unwritten_size -= es_size;
1165
1166     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1167         return -1;
1168
1169     return 1;
1170 }
1171
1172 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1173 {
1174     MpegMuxContext *s = ctx->priv_data;
1175     int stream_index= pkt->stream_index;
1176     int size= pkt->size;
1177     uint8_t *buf= pkt->data;
1178     AVStream *st = ctx->streams[stream_index];
1179     StreamInfo *stream = st->priv_data;
1180     int64_t pts, dts;
1181     PacketDesc *pkt_desc;
1182     const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1183     const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1184
1185     pts= pkt->pts;
1186     dts= pkt->dts;
1187
1188     if(pts != AV_NOPTS_VALUE) pts += preload;
1189     if(dts != AV_NOPTS_VALUE) dts += preload;
1190
1191 //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);
1192     if (!stream->premux_packet)
1193         stream->next_packet = &stream->premux_packet;
1194     *stream->next_packet=
1195     pkt_desc= av_mallocz(sizeof(PacketDesc));
1196     pkt_desc->pts= pts;
1197     pkt_desc->dts= dts;
1198     pkt_desc->unwritten_size=
1199     pkt_desc->size= size;
1200     if(!stream->predecode_packet)
1201         stream->predecode_packet= pkt_desc;
1202     stream->next_packet= &pkt_desc->next;
1203
1204     av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1205
1206     if (s->is_dvd){
1207         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1208             stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1209             stream->align_iframe = 1;
1210             stream->vobu_start_pts = pts;
1211         } else {
1212             stream->align_iframe = 0;
1213         }
1214     }
1215
1216     av_fifo_write(&stream->fifo, buf, size);
1217
1218     for(;;){
1219         int ret= output_packet(ctx, 0);
1220         if(ret<=0)
1221             return ret;
1222     }
1223 }
1224
1225 static int mpeg_mux_end(AVFormatContext *ctx)
1226 {
1227 //    MpegMuxContext *s = ctx->priv_data;
1228     StreamInfo *stream;
1229     int i;
1230
1231     for(;;){
1232         int ret= output_packet(ctx, 1);
1233         if(ret<0)
1234             return ret;
1235         else if(ret==0)
1236             break;
1237     }
1238
1239     /* End header according to MPEG1 systems standard. We do not write
1240        it as it is usually not needed by decoders and because it
1241        complicates MPEG stream concatenation. */
1242     //put_be32(&ctx->pb, ISO_11172_END_CODE);
1243     //put_flush_packet(&ctx->pb);
1244
1245     for(i=0;i<ctx->nb_streams;i++) {
1246         stream = ctx->streams[i]->priv_data;
1247
1248         assert(av_fifo_size(&stream->fifo) == 0);
1249         av_fifo_free(&stream->fifo);
1250     }
1251     return 0;
1252 }
1253 #endif //CONFIG_MUXERS
1254
1255 /*********************************************/
1256 /* demux code */
1257
1258 #define MAX_SYNC_SIZE 100000
1259
1260 static int cdxa_probe(AVProbeData *p)
1261 {
1262     /* check file header */
1263     if (p->buf_size <= 32)
1264         return 0;
1265     if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1266         p->buf[2] == 'F' && p->buf[3] == 'F' &&
1267         p->buf[8] == 'C' && p->buf[9] == 'D' &&
1268         p->buf[10] == 'X' && p->buf[11] == 'A')
1269         return AVPROBE_SCORE_MAX;
1270     else
1271         return 0;
1272 }
1273
1274 static int mpegps_probe(AVProbeData *p)
1275 {
1276     uint32_t code= -1;
1277     int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1278     int i;
1279     int score=0;
1280
1281     score = cdxa_probe(p);
1282     if (score > 0) return score;
1283
1284     /* Search for MPEG stream */
1285     for(i=0; i<p->buf_size; i++){
1286         code = (code<<8) + p->buf[i];
1287         if ((code & 0xffffff00) == 0x100) {
1288             if(code == SYSTEM_HEADER_START_CODE) sys++;
1289             else if(code == PRIVATE_STREAM_1)    priv1++;
1290             else if(code == PACK_START_CODE)     pspack++;
1291             else if((code & 0xf0) == VIDEO_ID)   vid++;
1292             else if((code & 0xe0) == AUDIO_ID)   audio++;
1293         }
1294     }
1295
1296     if(vid || audio)            /* invalid VDR files nd short PES streams */
1297         score= AVPROBE_SCORE_MAX/4;
1298
1299 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1300     if(sys && sys*9 <= pspack*10)
1301         return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1302     if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1303         return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1304     if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1305         return AVPROBE_SCORE_MAX/2+2;
1306
1307     //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1308     return score;
1309 }
1310
1311
1312 typedef struct MpegDemuxContext {
1313     int32_t header_state;
1314     unsigned char psm_es_type[256];
1315 } MpegDemuxContext;
1316
1317 static int mpegps_read_header(AVFormatContext *s,
1318                               AVFormatParameters *ap)
1319 {
1320     MpegDemuxContext *m = s->priv_data;
1321     m->header_state = 0xff;
1322     s->ctx_flags |= AVFMTCTX_NOHEADER;
1323
1324     /* no need to do more */
1325     return 0;
1326 }
1327
1328 static int64_t get_pts(ByteIOContext *pb, int c)
1329 {
1330     int64_t pts;
1331     int val;
1332
1333     if (c < 0)
1334         c = get_byte(pb);
1335     pts = (int64_t)((c >> 1) & 0x07) << 30;
1336     val = get_be16(pb);
1337     pts |= (int64_t)(val >> 1) << 15;
1338     val = get_be16(pb);
1339     pts |= (int64_t)(val >> 1);
1340     return pts;
1341 }
1342
1343 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1344                                 int32_t *header_state)
1345 {
1346     unsigned int state, v;
1347     int val, n;
1348
1349     state = *header_state;
1350     n = *size_ptr;
1351     while (n > 0) {
1352         if (url_feof(pb))
1353             break;
1354         v = get_byte(pb);
1355         n--;
1356         if (state == 0x000001) {
1357             state = ((state << 8) | v) & 0xffffff;
1358             val = state;
1359             goto found;
1360         }
1361         state = ((state << 8) | v) & 0xffffff;
1362     }
1363     val = -1;
1364  found:
1365     *header_state = state;
1366     *size_ptr = n;
1367     return val;
1368 }
1369
1370 #if 0 /* unused, remove? */
1371 /* XXX: optimize */
1372 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1373 {
1374     int64_t pos, pos_start;
1375     int max_size, start_code;
1376
1377     max_size = *size_ptr;
1378     pos_start = url_ftell(pb);
1379
1380     /* in order to go faster, we fill the buffer */
1381     pos = pos_start - 16386;
1382     if (pos < 0)
1383         pos = 0;
1384     url_fseek(pb, pos, SEEK_SET);
1385     get_byte(pb);
1386
1387     pos = pos_start;
1388     for(;;) {
1389         pos--;
1390         if (pos < 0 || (pos_start - pos) >= max_size) {
1391             start_code = -1;
1392             goto the_end;
1393         }
1394         url_fseek(pb, pos, SEEK_SET);
1395         start_code = get_be32(pb);
1396         if ((start_code & 0xffffff00) == 0x100)
1397             break;
1398     }
1399  the_end:
1400     *size_ptr = pos_start - pos;
1401     return start_code;
1402 }
1403 #endif
1404
1405 /**
1406  * Extracts stream types from a program stream map
1407  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1408  *
1409  * @return number of bytes occupied by PSM in the bitstream
1410  */
1411 static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1412 {
1413     int psm_length, ps_info_length, es_map_length;
1414
1415     psm_length = get_be16(pb);
1416     get_byte(pb);
1417     get_byte(pb);
1418     ps_info_length = get_be16(pb);
1419
1420     /* skip program_stream_info */
1421     url_fskip(pb, ps_info_length);
1422     es_map_length = get_be16(pb);
1423
1424     /* at least one es available? */
1425     while (es_map_length >= 4){
1426         unsigned char type = get_byte(pb);
1427         unsigned char es_id = get_byte(pb);
1428         uint16_t es_info_length = get_be16(pb);
1429         /* remember mapping from stream id to stream type */
1430         m->psm_es_type[es_id] = type;
1431         /* skip program_stream_info */
1432         url_fskip(pb, es_info_length);
1433         es_map_length -= 4 + es_info_length;
1434     }
1435     get_be32(pb); /* crc32 */
1436     return 2 + psm_length;
1437 }
1438
1439 /* read the next PES header. Return its position in ppos
1440    (if not NULL), and its start code, pts and dts.
1441  */
1442 static int mpegps_read_pes_header(AVFormatContext *s,
1443                                   int64_t *ppos, int *pstart_code,
1444                                   int64_t *ppts, int64_t *pdts)
1445 {
1446     MpegDemuxContext *m = s->priv_data;
1447     int len, size, startcode, c, flags, header_len;
1448     int64_t pts, dts, last_pos;
1449
1450     last_pos = -1;
1451  redo:
1452         /* next start code (should be immediately after) */
1453         m->header_state = 0xff;
1454         size = MAX_SYNC_SIZE;
1455         startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1456     //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1457     if (startcode < 0)
1458         return AVERROR_IO;
1459     if (startcode == PACK_START_CODE)
1460         goto redo;
1461     if (startcode == SYSTEM_HEADER_START_CODE)
1462         goto redo;
1463     if (startcode == PADDING_STREAM ||
1464         startcode == PRIVATE_STREAM_2) {
1465         /* skip them */
1466         len = get_be16(&s->pb);
1467         url_fskip(&s->pb, len);
1468         goto redo;
1469     }
1470     if (startcode == PROGRAM_STREAM_MAP) {
1471         mpegps_psm_parse(m, &s->pb);
1472         goto redo;
1473     }
1474
1475     /* find matching stream */
1476     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1477           (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1478           (startcode == 0x1bd)))
1479         goto redo;
1480     if (ppos) {
1481         *ppos = url_ftell(&s->pb) - 4;
1482     }
1483     len = get_be16(&s->pb);
1484     pts = AV_NOPTS_VALUE;
1485     dts = AV_NOPTS_VALUE;
1486     /* stuffing */
1487     for(;;) {
1488         if (len < 1)
1489             goto redo;
1490         c = get_byte(&s->pb);
1491         len--;
1492         /* XXX: for mpeg1, should test only bit 7 */
1493         if (c != 0xff)
1494             break;
1495     }
1496     if ((c & 0xc0) == 0x40) {
1497         /* buffer scale & size */
1498         if (len < 2)
1499             goto redo;
1500         get_byte(&s->pb);
1501         c = get_byte(&s->pb);
1502         len -= 2;
1503     }
1504     if ((c & 0xf0) == 0x20) {
1505         if (len < 4)
1506             goto redo;
1507         dts = pts = get_pts(&s->pb, c);
1508         len -= 4;
1509     } else if ((c & 0xf0) == 0x30) {
1510         if (len < 9)
1511             goto redo;
1512         pts = get_pts(&s->pb, c);
1513         dts = get_pts(&s->pb, -1);
1514         len -= 9;
1515     } else if ((c & 0xc0) == 0x80) {
1516         /* mpeg 2 PES */
1517 #if 0 /* some streams have this field set for no apparent reason */
1518         if ((c & 0x30) != 0) {
1519             /* Encrypted multiplex not handled */
1520             goto redo;
1521         }
1522 #endif
1523         flags = get_byte(&s->pb);
1524         header_len = get_byte(&s->pb);
1525         len -= 2;
1526         if (header_len > len)
1527             goto redo;
1528         if ((flags & 0xc0) == 0x80) {
1529             dts = pts = get_pts(&s->pb, -1);
1530             if (header_len < 5)
1531                 goto redo;
1532             header_len -= 5;
1533             len -= 5;
1534         } if ((flags & 0xc0) == 0xc0) {
1535             pts = get_pts(&s->pb, -1);
1536             dts = get_pts(&s->pb, -1);
1537             if (header_len < 10)
1538                 goto redo;
1539             header_len -= 10;
1540             len -= 10;
1541         }
1542         len -= header_len;
1543         while (header_len > 0) {
1544             get_byte(&s->pb);
1545             header_len--;
1546         }
1547     }
1548     else if( c!= 0xf )
1549         goto redo;
1550
1551     if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1552         if (len < 1)
1553             goto redo;
1554         startcode = get_byte(&s->pb);
1555         len--;
1556         if (startcode >= 0x80 && startcode <= 0xbf) {
1557             /* audio: skip header */
1558             if (len < 3)
1559                 goto redo;
1560             get_byte(&s->pb);
1561             get_byte(&s->pb);
1562             get_byte(&s->pb);
1563             len -= 3;
1564         }
1565     }
1566     if(dts != AV_NOPTS_VALUE && ppos){
1567         int i;
1568         for(i=0; i<s->nb_streams; i++){
1569             if(startcode == s->streams[i]->id) {
1570                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1571             }
1572         }
1573     }
1574
1575     *pstart_code = startcode;
1576     *ppts = pts;
1577     *pdts = dts;
1578     return len;
1579 }
1580
1581 static int mpegps_read_packet(AVFormatContext *s,
1582                               AVPacket *pkt)
1583 {
1584     MpegDemuxContext *m = s->priv_data;
1585     AVStream *st;
1586     int len, startcode, i, type, codec_id = 0, es_type;
1587     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1588
1589  redo:
1590     len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1591     if (len < 0)
1592         return len;
1593
1594     /* now find stream */
1595     for(i=0;i<s->nb_streams;i++) {
1596         st = s->streams[i];
1597         if (st->id == startcode)
1598             goto found;
1599     }
1600
1601     es_type = m->psm_es_type[startcode & 0xff];
1602     if(es_type > 0){
1603         if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1604             codec_id = CODEC_ID_MPEG2VIDEO;
1605             type = CODEC_TYPE_VIDEO;
1606         } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1607             codec_id = CODEC_ID_MPEG2VIDEO;
1608             type = CODEC_TYPE_VIDEO;
1609         } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1610                   es_type == STREAM_TYPE_AUDIO_MPEG2){
1611             codec_id = CODEC_ID_MP3;
1612             type = CODEC_TYPE_AUDIO;
1613         } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1614             codec_id = CODEC_ID_AAC;
1615             type = CODEC_TYPE_AUDIO;
1616         } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1617             codec_id = CODEC_ID_MPEG4;
1618             type = CODEC_TYPE_VIDEO;
1619         } else if(es_type == STREAM_TYPE_VIDEO_H264){
1620             codec_id = CODEC_ID_H264;
1621             type = CODEC_TYPE_VIDEO;
1622         } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1623             codec_id = CODEC_ID_AC3;
1624             type = CODEC_TYPE_AUDIO;
1625         } else {
1626             goto skip;
1627         }
1628     } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1629         static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1630         unsigned char buf[8];
1631         get_buffer(&s->pb, buf, 8);
1632         url_fseek(&s->pb, -8, SEEK_CUR);
1633         if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1634             codec_id = CODEC_ID_CAVS;
1635         else
1636             codec_id = CODEC_ID_MPEG2VIDEO;
1637         type = CODEC_TYPE_VIDEO;
1638     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1639         type = CODEC_TYPE_AUDIO;
1640         codec_id = CODEC_ID_MP2;
1641     } else if (startcode >= 0x80 && startcode <= 0x87) {
1642         type = CODEC_TYPE_AUDIO;
1643         codec_id = CODEC_ID_AC3;
1644     } else if (startcode >= 0x88 && startcode <= 0x9f) {
1645         type = CODEC_TYPE_AUDIO;
1646         codec_id = CODEC_ID_DTS;
1647     } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1648         type = CODEC_TYPE_AUDIO;
1649         codec_id = CODEC_ID_PCM_S16BE;
1650     } else if (startcode >= 0x20 && startcode <= 0x3f) {
1651         type = CODEC_TYPE_SUBTITLE;
1652         codec_id = CODEC_ID_DVD_SUBTITLE;
1653     } else {
1654     skip:
1655         /* skip packet */
1656         url_fskip(&s->pb, len);
1657         goto redo;
1658     }
1659     /* no stream found: add a new stream */
1660     st = av_new_stream(s, startcode);
1661     if (!st)
1662         goto skip;
1663     st->codec->codec_type = type;
1664     st->codec->codec_id = codec_id;
1665     if (codec_id != CODEC_ID_PCM_S16BE)
1666         st->need_parsing = 1;
1667  found:
1668     if(st->discard >= AVDISCARD_ALL)
1669         goto skip;
1670     if (startcode >= 0xa0 && startcode <= 0xbf) {
1671         int b1, freq;
1672
1673         /* for LPCM, we just skip the header and consider it is raw
1674            audio data */
1675         if (len <= 3)
1676             goto skip;
1677         get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1678         b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1679         get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1680         len -= 3;
1681         freq = (b1 >> 4) & 3;
1682         st->codec->sample_rate = lpcm_freq_tab[freq];
1683         st->codec->channels = 1 + (b1 & 7);
1684         st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1685     }
1686     av_new_packet(pkt, len);
1687     get_buffer(&s->pb, pkt->data, pkt->size);
1688     pkt->pts = pts;
1689     pkt->dts = dts;
1690     pkt->stream_index = st->index;
1691 #if 0
1692     av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1693            pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1694 #endif
1695
1696     return 0;
1697 }
1698
1699 static int mpegps_read_close(AVFormatContext *s)
1700 {
1701     return 0;
1702 }
1703
1704 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1705                                int64_t *ppos, int64_t pos_limit)
1706 {
1707     int len, startcode;
1708     int64_t pos, pts, dts;
1709
1710     pos = *ppos;
1711 #ifdef DEBUG_SEEK
1712     printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1713 #endif
1714     url_fseek(&s->pb, pos, SEEK_SET);
1715     for(;;) {
1716         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1717         if (len < 0) {
1718 #ifdef DEBUG_SEEK
1719             printf("none (ret=%d)\n", len);
1720 #endif
1721             return AV_NOPTS_VALUE;
1722         }
1723         if (startcode == s->streams[stream_index]->id &&
1724             dts != AV_NOPTS_VALUE) {
1725             break;
1726         }
1727         url_fskip(&s->pb, len);
1728     }
1729 #ifdef DEBUG_SEEK
1730     printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1731 #endif
1732     *ppos = pos;
1733     return dts;
1734 }
1735
1736 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1737 AVOutputFormat mpeg1system_muxer = {
1738     "mpeg",
1739     "MPEG1 System format",
1740     "video/mpeg",
1741     "mpg,mpeg",
1742     sizeof(MpegMuxContext),
1743     CODEC_ID_MP2,
1744     CODEC_ID_MPEG1VIDEO,
1745     mpeg_mux_init,
1746     mpeg_mux_write_packet,
1747     mpeg_mux_end,
1748 };
1749 #endif
1750 #ifdef CONFIG_MPEG1VCD_MUXER
1751 AVOutputFormat mpeg1vcd_muxer = {
1752     "vcd",
1753     "MPEG1 System format (VCD)",
1754     "video/mpeg",
1755     NULL,
1756     sizeof(MpegMuxContext),
1757     CODEC_ID_MP2,
1758     CODEC_ID_MPEG1VIDEO,
1759     mpeg_mux_init,
1760     mpeg_mux_write_packet,
1761     mpeg_mux_end,
1762 };
1763 #endif
1764 #ifdef CONFIG_MPEG2VOB_MUXER
1765 AVOutputFormat mpeg2vob_muxer = {
1766     "vob",
1767     "MPEG2 PS format (VOB)",
1768     "video/mpeg",
1769     "vob",
1770     sizeof(MpegMuxContext),
1771     CODEC_ID_MP2,
1772     CODEC_ID_MPEG2VIDEO,
1773     mpeg_mux_init,
1774     mpeg_mux_write_packet,
1775     mpeg_mux_end,
1776 };
1777 #endif
1778
1779 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1780 #ifdef CONFIG_MPEG2SVCD_MUXER
1781 AVOutputFormat mpeg2svcd_muxer = {
1782     "svcd",
1783     "MPEG2 PS format (VOB)",
1784     "video/mpeg",
1785     "vob",
1786     sizeof(MpegMuxContext),
1787     CODEC_ID_MP2,
1788     CODEC_ID_MPEG2VIDEO,
1789     mpeg_mux_init,
1790     mpeg_mux_write_packet,
1791     mpeg_mux_end,
1792 };
1793 #endif
1794
1795 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1796 #ifdef CONFIG_MPEG2DVD_MUXER
1797 AVOutputFormat mpeg2dvd_muxer = {
1798     "dvd",
1799     "MPEG2 PS format (DVD VOB)",
1800     "video/mpeg",
1801     "dvd",
1802     sizeof(MpegMuxContext),
1803     CODEC_ID_MP2,
1804     CODEC_ID_MPEG2VIDEO,
1805     mpeg_mux_init,
1806     mpeg_mux_write_packet,
1807     mpeg_mux_end,
1808 };
1809 #endif
1810
1811 #ifdef CONFIG_MPEGPS_DEMUXER
1812 AVInputFormat mpegps_demuxer = {
1813     "mpeg",
1814     "MPEG PS format",
1815     sizeof(MpegDemuxContext),
1816     mpegps_probe,
1817     mpegps_read_header,
1818     mpegps_read_packet,
1819     mpegps_read_close,
1820     NULL, //mpegps_read_seek,
1821     mpegps_read_dts,
1822     .flags = AVFMT_SHOW_IDS,
1823 };
1824 #endif