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

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