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