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