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