mpeg.c 34.5 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * MPEG1/2 mux/demux
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5 6 7 8
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
9
 *
10
 * This library is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 *
15 16 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Fabrice Bellard's avatar
Fabrice Bellard committed
18 19 20 21
 */
#include "avformat.h"

#define MAX_PAYLOAD_SIZE 4096
Fabrice Bellard's avatar
Fabrice Bellard committed
22
//#define DEBUG_SEEK
Fabrice Bellard's avatar
Fabrice Bellard committed
23 24

typedef struct {
25
    uint8_t buffer[MAX_PAYLOAD_SIZE];
Fabrice Bellard's avatar
Fabrice Bellard committed
26
    int buffer_ptr;
27 28
    int nb_frames;    /* number of starting frame encountered (AC3) */
    int frame_start_offset; /* starting offset of the frame + 1 (0 if none) */
29
    uint8_t id;
Fabrice Bellard's avatar
Fabrice Bellard committed
30 31
    int max_buffer_size; /* in bytes */
    int packet_number;
32
    int64_t start_pts;
33
    int64_t start_dts;
34 35
    uint8_t lpcm_header[3];
    int lpcm_align;
Fabrice Bellard's avatar
Fabrice Bellard committed
36 37 38 39 40 41 42
} StreamInfo;

typedef struct {
    int packet_size; /* required packet size */
    int packet_number;
    int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
    int system_header_freq;
43
    int system_header_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
44 45 46 47
    int mux_rate; /* bitrate in units of 50 bytes/s */
    /* stream info */
    int audio_bound;
    int video_bound;
48 49
    int is_mpeg2;
    int is_vcd;
50 51 52
    int scr_stream_index; /* stream from which the system clock is
                             computed (VBR case) */
    int64_t last_scr; /* current system clock */
Fabrice Bellard's avatar
Fabrice Bellard committed
53 54 55 56
} MpegMuxContext;

#define PACK_START_CODE             ((unsigned int)0x000001ba)
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
57
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
Fabrice Bellard's avatar
Fabrice Bellard committed
58 59 60 61 62 63 64 65 66 67 68 69 70
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
  
/* mpeg2 */
#define PROGRAM_STREAM_MAP 0x1bc
#define PRIVATE_STREAM_1   0x1bd
#define PADDING_STREAM     0x1be
#define PRIVATE_STREAM_2   0x1bf


#define AUDIO_ID 0xc0
#define VIDEO_ID 0xe0
71 72
#define AC3_ID   0x80
#define LPCM_ID  0xa0
Fabrice Bellard's avatar
Fabrice Bellard committed
73

74
#ifdef CONFIG_ENCODERS
75 76 77 78
extern AVOutputFormat mpeg1system_mux;
extern AVOutputFormat mpeg1vcd_mux;
extern AVOutputFormat mpeg2vob_mux;

79 80
static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };

Fabrice Bellard's avatar
Fabrice Bellard committed
81
static int put_pack_header(AVFormatContext *ctx, 
82
                           uint8_t *buf, int64_t timestamp)
Fabrice Bellard's avatar
Fabrice Bellard committed
83 84 85 86
{
    MpegMuxContext *s = ctx->priv_data;
    PutBitContext pb;
    
Alex Beregszaszi's avatar
Alex Beregszaszi committed
87
    init_put_bits(&pb, buf, 128);
Fabrice Bellard's avatar
Fabrice Bellard committed
88 89

    put_bits(&pb, 32, PACK_START_CODE);
90
    if (s->is_mpeg2) {
91
        put_bits(&pb, 2, 0x1);
92 93 94
    } else {
        put_bits(&pb, 4, 0x2);
    }
95
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
Fabrice Bellard's avatar
Fabrice Bellard committed
96
    put_bits(&pb, 1, 1);
97
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
Fabrice Bellard's avatar
Fabrice Bellard committed
98
    put_bits(&pb, 1, 1);
99
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
Fabrice Bellard's avatar
Fabrice Bellard committed
100
    put_bits(&pb, 1, 1);
101 102 103 104 105
    if (s->is_mpeg2) {
        /* clock extension */
        put_bits(&pb, 9, 0);
        put_bits(&pb, 1, 1);
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
106 107 108
    put_bits(&pb, 1, 1);
    put_bits(&pb, 22, s->mux_rate);
    put_bits(&pb, 1, 1);
109 110 111 112
    if (s->is_mpeg2) {
        put_bits(&pb, 5, 0x1f); /* reserved */
        put_bits(&pb, 3, 0); /* stuffing length */
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
113
    flush_put_bits(&pb);
114
    return pbBufPtr(&pb) - pb.buf;
Fabrice Bellard's avatar
Fabrice Bellard committed
115 116
}

117
static int put_system_header(AVFormatContext *ctx, uint8_t *buf)
Fabrice Bellard's avatar
Fabrice Bellard committed
118 119 120 121 122
{
    MpegMuxContext *s = ctx->priv_data;
    int size, rate_bound, i, private_stream_coded, id;
    PutBitContext pb;

Alex Beregszaszi's avatar
Alex Beregszaszi committed
123
    init_put_bits(&pb, buf, 128);
Fabrice Bellard's avatar
Fabrice Bellard committed
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
    put_bits(&pb, 16, 0);
    put_bits(&pb, 1, 1);
    
    rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
    put_bits(&pb, 22, rate_bound);
    put_bits(&pb, 1, 1); /* marker */
    put_bits(&pb, 6, s->audio_bound);

    put_bits(&pb, 1, 1); /* variable bitrate */
    put_bits(&pb, 1, 1); /* non constrainted bit stream */
    
    put_bits(&pb, 1, 0); /* audio locked */
    put_bits(&pb, 1, 0); /* video locked */
    put_bits(&pb, 1, 1); /* marker */

    put_bits(&pb, 5, s->video_bound);
    put_bits(&pb, 8, 0xff); /* reserved byte */
    
    /* audio stream info */
    private_stream_coded = 0;
    for(i=0;i<ctx->nb_streams;i++) {
        StreamInfo *stream = ctx->streams[i]->priv_data;
        id = stream->id;
        if (id < 0xc0) {
            /* special case for private streams (AC3 use that) */
            if (private_stream_coded)
                continue;
            private_stream_coded = 1;
            id = 0xbd;
        }
        put_bits(&pb, 8, id); /* stream ID */
        put_bits(&pb, 2, 3);
        if (id < 0xe0) {
            /* audio */
            put_bits(&pb, 1, 0);
            put_bits(&pb, 13, stream->max_buffer_size / 128);
        } else {
            /* video */
            put_bits(&pb, 1, 1);
            put_bits(&pb, 13, stream->max_buffer_size / 1024);
        }
    }
    flush_put_bits(&pb);
169
    size = pbBufPtr(&pb) - pb.buf;
Fabrice Bellard's avatar
Fabrice Bellard committed
170 171 172 173 174 175 176
    /* patch packet size */
    buf[4] = (size - 6) >> 8;
    buf[5] = (size - 6) & 0xff;

    return size;
}

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
static int get_system_header_size(AVFormatContext *ctx)
{
    int buf_index, i, private_stream_coded;
    StreamInfo *stream;

    buf_index = 12;
    private_stream_coded = 0;
    for(i=0;i<ctx->nb_streams;i++) {
        stream = ctx->streams[i]->priv_data;
        if (stream->id < 0xc0) {
            if (private_stream_coded)
                continue;
            private_stream_coded = 1;
        }
        buf_index += 3;
    }
    return buf_index;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
196 197
static int mpeg_mux_init(AVFormatContext *ctx)
{
198
    MpegMuxContext *s = ctx->priv_data;
199
    int bitrate, i, mpa_id, mpv_id, ac3_id, lpcm_id, j;
Fabrice Bellard's avatar
Fabrice Bellard committed
200 201 202 203
    AVStream *st;
    StreamInfo *stream;

    s->packet_number = 0;
204 205 206 207
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux);
    
    if (s->is_vcd)
208 209 210 211
        s->packet_size = 2324; /* VCD packet size */
    else
        s->packet_size = 2048;
        
Fabrice Bellard's avatar
Fabrice Bellard committed
212 213 214
    s->audio_bound = 0;
    s->video_bound = 0;
    mpa_id = AUDIO_ID;
215
    ac3_id = AC3_ID;
Fabrice Bellard's avatar
Fabrice Bellard committed
216
    mpv_id = VIDEO_ID;
217
    lpcm_id = LPCM_ID;
218
    s->scr_stream_index = -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
219 220 221 222 223 224 225 226 227
    for(i=0;i<ctx->nb_streams;i++) {
        st = ctx->streams[i];
        stream = av_mallocz(sizeof(StreamInfo));
        if (!stream)
            goto fail;
        st->priv_data = stream;

        switch(st->codec.codec_type) {
        case CODEC_TYPE_AUDIO:
228
            if (st->codec.codec_id == CODEC_ID_AC3) {
Fabrice Bellard's avatar
Fabrice Bellard committed
229
                stream->id = ac3_id++;
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
            } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
                stream->id = lpcm_id++;
                for(j = 0; j < 4; j++) {
                    if (lpcm_freq_tab[j] == st->codec.sample_rate)
                        break;
                }
                if (j == 4)
                    goto fail;
                if (st->codec.channels > 8)
                    return -1;
                stream->lpcm_header[0] = 0x0c;
                stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
                stream->lpcm_header[2] = 0x80;
                stream->lpcm_align = st->codec.channels * 2;
            } else {
Fabrice Bellard's avatar
Fabrice Bellard committed
245
                stream->id = mpa_id++;
246
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
247 248 249 250
            stream->max_buffer_size = 4 * 1024; 
            s->audio_bound++;
            break;
        case CODEC_TYPE_VIDEO:
251 252 253
            /* by default, video is used for the SCR computation */
            if (s->scr_stream_index == -1)
                s->scr_stream_index = i;
Fabrice Bellard's avatar
Fabrice Bellard committed
254 255 256 257
            stream->id = mpv_id++;
            stream->max_buffer_size = 46 * 1024; 
            s->video_bound++;
            break;
258
        default:
259
            av_abort();
Fabrice Bellard's avatar
Fabrice Bellard committed
260 261
        }
    }
262 263 264
    /* if no SCR, use first stream (audio) */
    if (s->scr_stream_index == -1)
        s->scr_stream_index = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
265 266 267 268 269 270 271 272 273

    /* we increase slightly the bitrate to take into account the
       headers. XXX: compute it exactly */
    bitrate = 2000;
    for(i=0;i<ctx->nb_streams;i++) {
        st = ctx->streams[i];
        bitrate += st->codec.bit_rate;
    }
    s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
274
    
275
    if (s->is_vcd || s->is_mpeg2)
276 277 278 279 280
        /* every packet */
        s->pack_header_freq = 1;
    else
        /* every 2 seconds */
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
281 282 283 284

    /* the above seems to make pack_header_freq zero sometimes */
    if (s->pack_header_freq == 0)
       s->pack_header_freq = 1;
285
    
286 287 288 289
    if (s->is_mpeg2)
        /* every 200 packets. Need to look at the spec.  */
        s->system_header_freq = s->pack_header_freq * 40;
    else if (s->is_vcd)
290 291 292 293 294
        /* every 40 packets, this is my invention */
        s->system_header_freq = s->pack_header_freq * 40;
    else
        s->system_header_freq = s->pack_header_freq * 5;
    
Fabrice Bellard's avatar
Fabrice Bellard committed
295 296 297 298
    for(i=0;i<ctx->nb_streams;i++) {
        stream = ctx->streams[i]->priv_data;
        stream->buffer_ptr = 0;
        stream->packet_number = 0;
299 300
        stream->start_pts = AV_NOPTS_VALUE;
        stream->start_dts = AV_NOPTS_VALUE;
Fabrice Bellard's avatar
Fabrice Bellard committed
301
    }
302
    s->system_header_size = get_system_header_size(ctx);
303
    s->last_scr = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
304 305 306
    return 0;
 fail:
    for(i=0;i<ctx->nb_streams;i++) {
307
        av_free(ctx->streams[i]->priv_data);
Fabrice Bellard's avatar
Fabrice Bellard committed
308 309 310 311
    }
    return -ENOMEM;
}

312 313 314 315 316 317 318 319 320 321
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
{
    put_byte(pb, 
             (id << 4) | 
             (((timestamp >> 30) & 0x07) << 1) | 
             1);
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
}

322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348

/* return the exact available payload size for the next packet for
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
   timestamps are needed in the packet header. */
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
                                   int64_t pts, int64_t dts)
{
    MpegMuxContext *s = ctx->priv_data;
    int buf_index;
    StreamInfo *stream;

    buf_index = 0;
    if (((s->packet_number % s->pack_header_freq) == 0)) {
        /* pack header size */
        if (s->is_mpeg2) 
            buf_index += 14;
        else
            buf_index += 12;
        if ((s->packet_number % s->system_header_freq) == 0)
            buf_index += s->system_header_size;
    }

    /* packet header size */
    buf_index += 6;
    if (s->is_mpeg2)
        buf_index += 3;
    if (pts != AV_NOPTS_VALUE) {
349
        if (dts != pts)
350 351 352 353 354 355 356 357 358 359
            buf_index += 5 + 5;
        else
            buf_index += 5;
    } else {
        if (!s->is_mpeg2)
            buf_index++;
    }
    
    stream = ctx->streams[stream_index]->priv_data;
    if (stream->id < 0xc0) {
360
        /* AC3/LPCM private data header */
361
        buf_index += 4;
362 363 364 365 366 367 368 369 370
        if (stream->id >= 0xa0) {
            int n;
            buf_index += 3;
            /* NOTE: we round the payload size to an integer number of
               LPCM samples */
            n = (s->packet_size - buf_index) % stream->lpcm_align;
            if (n)
                buf_index += (stream->lpcm_align - n);
        }
371 372 373 374
    }
    return s->packet_size - buf_index; 
}

Fabrice Bellard's avatar
Fabrice Bellard committed
375
/* flush the packet on stream stream_index */
376 377
static void flush_packet(AVFormatContext *ctx, int stream_index, 
                         int64_t pts, int64_t dts, int64_t scr)
Fabrice Bellard's avatar
Fabrice Bellard committed
378 379 380
{
    MpegMuxContext *s = ctx->priv_data;
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
381
    uint8_t *buf_ptr;
382 383
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
    int packet_size;
384
    uint8_t buffer[128];
385
    
Fabrice Bellard's avatar
Fabrice Bellard committed
386
    id = stream->id;
387
    
Fabrice Bellard's avatar
Fabrice Bellard committed
388 389
#if 0
    printf("packet ID=%2x PTS=%0.3f\n", 
390
           id, pts / 90000.0);
Fabrice Bellard's avatar
Fabrice Bellard committed
391 392 393
#endif

    buf_ptr = buffer;
394
    if (((s->packet_number % s->pack_header_freq) == 0)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
395
        /* output pack and systems header if needed */
396
        size = put_pack_header(ctx, buf_ptr, scr);
Fabrice Bellard's avatar
Fabrice Bellard committed
397 398 399 400 401 402 403 404 405 406
        buf_ptr += size;
        if ((s->packet_number % s->system_header_freq) == 0) {
            size = put_system_header(ctx, buf_ptr);
            buf_ptr += size;
        }
    }
    size = buf_ptr - buffer;
    put_buffer(&ctx->pb, buffer, size);

    /* packet header */
407
    if (s->is_mpeg2) {
408
        header_len = 3;
409
    } else {
410
        header_len = 0;
411
    }
412
    if (pts != AV_NOPTS_VALUE) {
413
        if (dts != pts)
414 415 416 417 418 419 420 421
            header_len += 5 + 5;
        else
            header_len += 5;
    } else {
        if (!s->is_mpeg2)
            header_len++;
    }

422 423
    packet_size = s->packet_size - (size + 6);
    payload_size = packet_size - header_len;
Fabrice Bellard's avatar
Fabrice Bellard committed
424 425 426
    if (id < 0xc0) {
        startcode = PRIVATE_STREAM_1;
        payload_size -= 4;
427 428
        if (id >= 0xa0)
            payload_size -= 3;
Fabrice Bellard's avatar
Fabrice Bellard committed
429 430 431
    } else {
        startcode = 0x100 + id;
    }
432

Fabrice Bellard's avatar
Fabrice Bellard committed
433 434 435 436 437
    stuffing_size = payload_size - stream->buffer_ptr;
    if (stuffing_size < 0)
        stuffing_size = 0;
    put_be32(&ctx->pb, startcode);

438
    put_be16(&ctx->pb, packet_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
439 440 441
    /* stuffing */
    for(i=0;i<stuffing_size;i++)
        put_byte(&ctx->pb, 0xff);
442 443 444

    if (s->is_mpeg2) {
        put_byte(&ctx->pb, 0x80); /* mpeg2 id */
445 446

        if (pts != AV_NOPTS_VALUE) {
447
            if (dts != pts) {
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
                put_byte(&ctx->pb, 0xc0); /* flags */
                put_byte(&ctx->pb, header_len - 3);
                put_timestamp(&ctx->pb, 0x03, pts);
                put_timestamp(&ctx->pb, 0x01, dts);
            } else {
                put_byte(&ctx->pb, 0x80); /* flags */
                put_byte(&ctx->pb, header_len - 3);
                put_timestamp(&ctx->pb, 0x02, pts);
            }
        } else {
            put_byte(&ctx->pb, 0x00); /* flags */
            put_byte(&ctx->pb, header_len - 3);
        }
    } else {
        if (pts != AV_NOPTS_VALUE) {
463
            if (dts != pts) {
464 465 466 467 468 469 470 471
                put_timestamp(&ctx->pb, 0x03, pts);
                put_timestamp(&ctx->pb, 0x01, dts);
            } else {
                put_timestamp(&ctx->pb, 0x02, pts);
            }
        } else {
            put_byte(&ctx->pb, 0x0f);
        }
472
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
473 474 475

    if (startcode == PRIVATE_STREAM_1) {
        put_byte(&ctx->pb, id);
476 477 478 479 480 481 482 483 484
        if (id >= 0xa0) {
            /* LPCM (XXX: check nb_frames) */
            put_byte(&ctx->pb, 7);
            put_be16(&ctx->pb, 4); /* skip 3 header bytes */
            put_byte(&ctx->pb, stream->lpcm_header[0]);
            put_byte(&ctx->pb, stream->lpcm_header[1]);
            put_byte(&ctx->pb, stream->lpcm_header[2]);
        } else {
            /* AC3 */
485 486
            put_byte(&ctx->pb, stream->nb_frames);
            put_be16(&ctx->pb, stream->frame_start_offset);
Fabrice Bellard's avatar
Fabrice Bellard committed
487 488 489 490 491 492 493 494 495
        }
    }

    /* output data */
    put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
    put_flush_packet(&ctx->pb);
    
    s->packet_number++;
    stream->packet_number++;
496 497
    stream->nb_frames = 0;
    stream->frame_start_offset = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
498 499
}

500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
/* XXX: move that to upper layer */
/* XXX: we assume that there are always 'max_b_frames' between
   reference frames. A better solution would be to use the AVFrame pts
   field */
static void compute_pts_dts(AVStream *st, int64_t *ppts, int64_t *pdts, 
                            int64_t timestamp)
{
    int frame_delay;
    int64_t pts, dts;

    if (st->codec.codec_type == CODEC_TYPE_VIDEO && 
        st->codec.max_b_frames != 0) {
        frame_delay = (st->codec.frame_rate_base * 90000LL) / 
            st->codec.frame_rate;
        if (timestamp == 0) {
            /* specific case for first frame : DTS just before */
            pts = timestamp;
            dts = timestamp - frame_delay;
        } else {
            timestamp -= frame_delay;
            if (st->codec.coded_frame->pict_type == FF_B_TYPE) {
                /* B frames has identical pts/dts */
                pts = timestamp;
                dts = timestamp;
            } else {
                /* a reference frame has a pts equal to the dts of the
                   _next_ one */
                dts = timestamp;
                pts = timestamp + (st->codec.max_b_frames + 1) * frame_delay;
            }
        }
#if 1
        printf("pts=%0.3f dts=%0.3f pict_type=%c\n", 
               pts / 90000.0, dts / 90000.0, 
               av_get_pict_type_char(st->codec.coded_frame->pict_type));
#endif
    } else {
        pts = timestamp;
        dts = timestamp;
    }
    *ppts = pts & ((1LL << 33) - 1);
    *pdts = dts & ((1LL << 33) - 1);
}

544
static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
545 546
                                 const uint8_t *buf, int size, 
                                 int64_t timestamp)
Fabrice Bellard's avatar
Fabrice Bellard committed
547 548 549 550
{
    MpegMuxContext *s = ctx->priv_data;
    AVStream *st = ctx->streams[stream_index];
    StreamInfo *stream = st->priv_data;
551
    int64_t pts, dts, new_start_pts, new_start_dts;
552
    int len, avail_size;
553

554 555
    compute_pts_dts(st, &pts, &dts, timestamp);

556 557 558 559
    /* XXX: system clock should be computed precisely, especially for
       CBR case. The current mode gives at least something coherent */
    if (stream_index == s->scr_stream_index)
        s->last_scr = pts;
560
    
561
#if 0
562 563 564 565 566
    printf("%d: pts=%0.3f dts=%0.3f scr=%0.3f\n", 
           stream_index, 
           pts / 90000.0, 
           dts / 90000.0, 
           s->last_scr / 90000.0);
567 568 569
#endif
    
    /* we assume here that pts != AV_NOPTS_VALUE */
570 571 572
    new_start_pts = stream->start_pts;
    new_start_dts = stream->start_dts;
    
573
    if (stream->start_pts == AV_NOPTS_VALUE) {
574 575 576 577 578 579 580 581 582 583 584 585 586 587
        new_start_pts = pts;
        new_start_dts = dts;
    }
    avail_size = get_packet_payload_size(ctx, stream_index,
                                         new_start_pts, 
                                         new_start_dts);
    if (stream->buffer_ptr >= avail_size) {
        /* unlikely case: outputing the pts or dts increase the packet
           size so that we cannot write the start of the next
           packet. In this case, we must flush the current packet with
           padding */
        flush_packet(ctx, stream_index,
                     stream->start_pts, stream->start_dts, s->last_scr);
        stream->buffer_ptr = 0;
588
    }
589 590 591 592 593
    stream->start_pts = new_start_pts;
    stream->start_dts = new_start_dts;
    stream->nb_frames++;
    if (stream->frame_start_offset == 0)
        stream->frame_start_offset = stream->buffer_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
594
    while (size > 0) {
595 596 597 598
        avail_size = get_packet_payload_size(ctx, stream_index,
                                             stream->start_pts, 
                                             stream->start_dts);
        len = avail_size - stream->buffer_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
599 600 601 602 603 604
        if (len > size)
            len = size;
        memcpy(stream->buffer + stream->buffer_ptr, buf, len);
        stream->buffer_ptr += len;
        buf += len;
        size -= len;
605 606
        if (stream->buffer_ptr >= avail_size) {
            /* if packet full, we send it now */
607 608
            flush_packet(ctx, stream_index,
                         stream->start_pts, stream->start_dts, s->last_scr);
609
            stream->buffer_ptr = 0;
610 611 612 613
            /* Make sure only the FIRST pes packet for this frame has
               a timestamp */
            stream->start_pts = AV_NOPTS_VALUE;
            stream->start_dts = AV_NOPTS_VALUE;
Fabrice Bellard's avatar
Fabrice Bellard committed
614 615
        }
    }
616

Fabrice Bellard's avatar
Fabrice Bellard committed
617 618 619 620 621
    return 0;
}

static int mpeg_mux_end(AVFormatContext *ctx)
{
622
    MpegMuxContext *s = ctx->priv_data;
Fabrice Bellard's avatar
Fabrice Bellard committed
623 624 625 626 627 628
    StreamInfo *stream;
    int i;

    /* flush each packet */
    for(i=0;i<ctx->nb_streams;i++) {
        stream = ctx->streams[i]->priv_data;
629 630 631 632 633
        if (stream->buffer_ptr > 0) {
            /* NOTE: we can always write the remaining data as it was
               tested before in mpeg_mux_write_packet() */
            flush_packet(ctx, i, stream->start_pts, stream->start_dts, 
                         s->last_scr);
634
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
635 636
    }

637 638 639
    /* End header according to MPEG1 systems standard. We do not write
       it as it is usually not needed by decoders and because it
       complicates MPEG stream concatenation. */
640 641
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
    //put_flush_packet(&ctx->pb);
642 643 644 645

    for(i=0;i<ctx->nb_streams;i++)
        av_freep(&ctx->streams[i]->priv_data);

Fabrice Bellard's avatar
Fabrice Bellard committed
646 647
    return 0;
}
648
#endif //CONFIG_ENCODERS
Fabrice Bellard's avatar
Fabrice Bellard committed
649 650 651 652 653 654

/*********************************************/
/* demux code */

#define MAX_SYNC_SIZE 100000

655 656
static int mpegps_probe(AVProbeData *p)
{
657
    int code, c, i;
658

659
    code = 0xff;
660 661 662
    /* we search the first start code. If it is a packet start code,
       then we decide it is mpeg ps. We do not send highest value to
       give a chance to mpegts */
663 664 665 666 667
    /* NOTE: the search range was restricted to avoid too many false
       detections */

    if (p->buf_size < 6)
        return 0;
668 669 670 671 672 673 674 675 676 677 678 679 680

    for (i = 0; i < 20; i++) {
        c = p->buf[i];
        code = (code << 8) | c;
        if ((code & 0xffffff00) == 0x100) {
            if (code == PACK_START_CODE ||
                code == SYSTEM_HEADER_START_CODE ||
                (code >= 0x1e0 && code <= 0x1ef) ||
                (code >= 0x1c0 && code <= 0x1df) ||
                code == PRIVATE_STREAM_2 ||
                code == PROGRAM_STREAM_MAP ||
                code == PRIVATE_STREAM_1 ||
                code == PADDING_STREAM)
681
                return AVPROBE_SCORE_MAX - 2;
682 683 684
            else
                return 0;
        }
685 686 687 688 689
    }
    return 0;
}


Fabrice Bellard's avatar
Fabrice Bellard committed
690 691 692 693
typedef struct MpegDemuxContext {
    int header_state;
} MpegDemuxContext;

Fabrice Bellard's avatar
Fabrice Bellard committed
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
static int mpegps_read_header(AVFormatContext *s,
                              AVFormatParameters *ap)
{
    MpegDemuxContext *m = s->priv_data;
    m->header_state = 0xff;
    s->ctx_flags |= AVFMTCTX_NOHEADER;

    /* no need to do more */
    return 0;
}

static int64_t get_pts(ByteIOContext *pb, int c)
{
    int64_t pts;
    int val;

    if (c < 0)
        c = get_byte(pb);
    pts = (int64_t)((c >> 1) & 0x07) << 30;
    val = get_be16(pb);
    pts |= (int64_t)(val >> 1) << 15;
    val = get_be16(pb);
    pts |= (int64_t)(val >> 1);
    return pts;
}

static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
                                uint32_t *header_state)
Fabrice Bellard's avatar
Fabrice Bellard committed
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
{
    unsigned int state, v;
    int val, n;

    state = *header_state;
    n = *size_ptr;
    while (n > 0) {
        if (url_feof(pb))
            break;
        v = get_byte(pb);
        n--;
        if (state == 0x000001) {
            state = ((state << 8) | v) & 0xffffff;
            val = state;
            goto found;
        }
        state = ((state << 8) | v) & 0xffffff;
    }
    val = -1;
 found:
    *header_state = state;
    *size_ptr = n;
    return val;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
747 748
/* XXX: optimize */
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
Fabrice Bellard's avatar
Fabrice Bellard committed
749
{
Fabrice Bellard's avatar
Fabrice Bellard committed
750 751
    int64_t pos, pos_start;
    int max_size, start_code;
752

Fabrice Bellard's avatar
Fabrice Bellard committed
753 754
    max_size = *size_ptr;
    pos_start = url_ftell(pb);
Fabrice Bellard's avatar
Fabrice Bellard committed
755

Fabrice Bellard's avatar
Fabrice Bellard committed
756 757 758 759 760 761
    /* in order to go faster, we fill the buffer */
    pos = pos_start - 16386;
    if (pos < 0)
        pos = 0;
    url_fseek(pb, pos, SEEK_SET);
    get_byte(pb);
Fabrice Bellard's avatar
Fabrice Bellard committed
762

Fabrice Bellard's avatar
Fabrice Bellard committed
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
    pos = pos_start;
    for(;;) {
        pos--;
        if (pos < 0 || (pos_start - pos) >= max_size) {
            start_code = -1;
            goto the_end;
        }
        url_fseek(pb, pos, SEEK_SET);
        start_code = get_be32(pb);
        if ((start_code & 0xffffff00) == 0x100)
            break;
    }
 the_end:
    *size_ptr = pos_start - pos;
    return start_code;
Fabrice Bellard's avatar
Fabrice Bellard committed
778 779
}

Fabrice Bellard's avatar
Fabrice Bellard committed
780 781 782 783 784 785
/* read the next (or previous) PES header. Return its position in ppos 
   (if not NULL), and its start code, pts and dts.
 */
static int mpegps_read_pes_header(AVFormatContext *s,
                                  int64_t *ppos, int *pstart_code, 
                                  int64_t *ppts, int64_t *pdts, int find_next)
Fabrice Bellard's avatar
Fabrice Bellard committed
786 787
{
    MpegDemuxContext *m = s->priv_data;
Fabrice Bellard's avatar
Fabrice Bellard committed
788 789
    int len, size, startcode, c, flags, header_len;
    int64_t pts, dts, last_pos;
Fabrice Bellard's avatar
Fabrice Bellard committed
790

Fabrice Bellard's avatar
Fabrice Bellard committed
791
    last_pos = -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
792
 redo:
Fabrice Bellard's avatar
Fabrice Bellard committed
793 794 795 796 797 798 799 800 801 802 803 804
    if (find_next) {
        /* next start code (should be immediately after) */
        m->header_state = 0xff;
        size = MAX_SYNC_SIZE;
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
    } else {
        if (last_pos >= 0)
            url_fseek(&s->pb, last_pos, SEEK_SET);
        size = MAX_SYNC_SIZE;
        startcode = find_prev_start_code(&s->pb, &size);
        last_pos = url_ftell(&s->pb) - 4;
    }
805
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
Fabrice Bellard's avatar
Fabrice Bellard committed
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
    if (startcode < 0)
        return -EIO;
    if (startcode == PACK_START_CODE)
        goto redo;
    if (startcode == SYSTEM_HEADER_START_CODE)
        goto redo;
    if (startcode == PADDING_STREAM ||
        startcode == PRIVATE_STREAM_2) {
        /* skip them */
        len = get_be16(&s->pb);
        url_fskip(&s->pb, len);
        goto redo;
    }
    /* find matching stream */
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
          (startcode == 0x1bd)))
        goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
824 825 826
    if (ppos) {
        *ppos = url_ftell(&s->pb) - 4;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
827
    len = get_be16(&s->pb);
828 829
    pts = AV_NOPTS_VALUE;
    dts = AV_NOPTS_VALUE;
Fabrice Bellard's avatar
Fabrice Bellard committed
830 831
    /* stuffing */
    for(;;) {
Fabrice Bellard's avatar
Fabrice Bellard committed
832 833
        if (len < 1)
            goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
834 835 836 837 838 839 840 841
        c = get_byte(&s->pb);
        len--;
        /* XXX: for mpeg1, should test only bit 7 */
        if (c != 0xff) 
            break;
    }
    if ((c & 0xc0) == 0x40) {
        /* buffer scale & size */
Fabrice Bellard's avatar
Fabrice Bellard committed
842 843
        if (len < 2)
            goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
844 845 846 847 848
        get_byte(&s->pb);
        c = get_byte(&s->pb);
        len -= 2;
    }
    if ((c & 0xf0) == 0x20) {
Fabrice Bellard's avatar
Fabrice Bellard committed
849 850 851
        if (len < 4)
            goto redo;
        dts = pts = get_pts(&s->pb, c);
Fabrice Bellard's avatar
Fabrice Bellard committed
852 853
        len -= 4;
    } else if ((c & 0xf0) == 0x30) {
Fabrice Bellard's avatar
Fabrice Bellard committed
854 855
        if (len < 9)
            goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
856 857 858 859 860 861
        pts = get_pts(&s->pb, c);
        dts = get_pts(&s->pb, -1);
        len -= 9;
    } else if ((c & 0xc0) == 0x80) {
        /* mpeg 2 PES */
        if ((c & 0x30) != 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
862 863
            /* Encrypted multiplex not handled */
            goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
864 865 866 867 868 869
        }
        flags = get_byte(&s->pb);
        header_len = get_byte(&s->pb);
        len -= 2;
        if (header_len > len)
            goto redo;
870
        if ((flags & 0xc0) == 0x80) {
Fabrice Bellard's avatar
Fabrice Bellard committed
871 872 873
            dts = pts = get_pts(&s->pb, -1);
            if (header_len < 5)
                goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
874 875 876 877 878
            header_len -= 5;
            len -= 5;
        } if ((flags & 0xc0) == 0xc0) {
            pts = get_pts(&s->pb, -1);
            dts = get_pts(&s->pb, -1);
Fabrice Bellard's avatar
Fabrice Bellard committed
879 880
            if (header_len < 10)
                goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
881 882 883 884 885 886 887 888 889 890
            header_len -= 10;
            len -= 10;
        }
        len -= header_len;
        while (header_len > 0) {
            get_byte(&s->pb);
            header_len--;
        }
    }
    if (startcode == 0x1bd) {
Fabrice Bellard's avatar
Fabrice Bellard committed
891 892
        if (len < 1)
            goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
893 894 895 896
        startcode = get_byte(&s->pb);
        len--;
        if (startcode >= 0x80 && startcode <= 0xbf) {
            /* audio: skip header */
Fabrice Bellard's avatar
Fabrice Bellard committed
897 898
            if (len < 3)
                goto redo;
Fabrice Bellard's avatar
Fabrice Bellard committed
899 900 901 902 903 904
            get_byte(&s->pb);
            get_byte(&s->pb);
            get_byte(&s->pb);
            len -= 3;
        }
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
    *pstart_code = startcode;
    *ppts = pts;
    *pdts = dts;
    return len;
}

static int mpegps_read_packet(AVFormatContext *s,
                              AVPacket *pkt)
{
    AVStream *st;
    int len, startcode, i, type, codec_id;
    int64_t pts, dts;

 redo:
    len = mpegps_read_pes_header(s, NULL, &startcode, &pts, &dts, 1);
    if (len < 0)
        return len;
922
    
Fabrice Bellard's avatar
Fabrice Bellard committed
923 924 925 926 927 928
    /* now find stream */
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
        if (st->id == startcode)
            goto found;
    }
929 930
    if (startcode >= 0x1e0 && startcode <= 0x1ef) {
        type = CODEC_TYPE_VIDEO;
931
        codec_id = CODEC_ID_MPEG2VIDEO;
932 933 934 935 936 937
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
        type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_MP2;
    } else if (startcode >= 0x80 && startcode <= 0x9f) {
        type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_AC3;
938 939 940
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
        type = CODEC_TYPE_AUDIO;
        codec_id = CODEC_ID_PCM_S16BE;
941 942 943 944 945 946
    } else {
    skip:
        /* skip packet */
        url_fskip(&s->pb, len);
        goto redo;
    }
947 948 949 950
    /* no stream found: add a new stream */
    st = av_new_stream(s, startcode);
    if (!st) 
        goto skip;
951 952
    st->codec.codec_type = type;
    st->codec.codec_id = codec_id;
Fabrice Bellard's avatar
Fabrice Bellard committed
953 954
    if (codec_id != CODEC_ID_PCM_S16BE)
        st->need_parsing = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
955
 found:
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
    if (startcode >= 0xa0 && startcode <= 0xbf) {
        int b1, freq;

        /* for LPCM, we just skip the header and consider it is raw
           audio data */
        if (len <= 3)
            goto skip;
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
        len -= 3;
        freq = (b1 >> 4) & 3;
        st->codec.sample_rate = lpcm_freq_tab[freq];
        st->codec.channels = 1 + (b1 & 7);
        st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
972 973 974
    av_new_packet(pkt, len);
    get_buffer(&s->pb, pkt->data, pkt->size);
    pkt->pts = pts;
Fabrice Bellard's avatar
Fabrice Bellard committed
975
    pkt->dts = dts;
976
    pkt->stream_index = st->index;
977 978 979 980
#if 0
    printf("%d: pts=%0.3f dts=%0.3f\n",
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
981 982 983
    return 0;
}

984
static int mpegps_read_close(AVFormatContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
985 986 987 988
{
    return 0;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
                               int64_t *ppos, int find_next)
{
    int len, startcode;
    int64_t pos, pts, dts;

    pos = *ppos;
#ifdef DEBUG_SEEK
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
#endif
    url_fseek(&s->pb, pos, SEEK_SET);
    for(;;) {
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts, find_next);
        if (len < 0) {
#ifdef DEBUG_SEEK
            printf("none (ret=%d)\n", len);
#endif
            return AV_NOPTS_VALUE;
        }
        if (startcode == s->streams[stream_index]->id && 
            dts != AV_NOPTS_VALUE) {
            break;
        }
        if (find_next) {
            url_fskip(&s->pb, len);
        } else {
            url_fseek(&s->pb, pos, SEEK_SET);
        }
    }
#ifdef DEBUG_SEEK
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
#endif
    *ppos = pos;
    return dts;
}

static int find_stream_index(AVFormatContext *s)
{
    int i;
    AVStream *st;

    if (s->nb_streams <= 0)
        return -1;
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
            return i;
        }
    }
    return 0;
}

static int mpegps_read_seek(AVFormatContext *s, 
                            int stream_index, int64_t timestamp)
{
    int64_t pos_min, pos_max, pos;
    int64_t dts_min, dts_max, dts;

    timestamp = (timestamp * 90000) / AV_TIME_BASE;

#ifdef DEBUG_SEEK
    printf("read_seek: %d %0.3f\n", stream_index, timestamp / 90000.0);
#endif

    /* XXX: find stream_index by looking at the first PES packet found */
    if (stream_index < 0) {
        stream_index = find_stream_index(s);
        if (stream_index < 0)
            return -1;
    }
    pos_min = 0;
    dts_min = mpegps_read_dts(s, stream_index, &pos_min, 1);
    if (dts_min == AV_NOPTS_VALUE) {
        /* we can reach this case only if no PTS are present in
           the whole stream */
        return -1;
    }
    pos_max = url_filesize(url_fileno(&s->pb)) - 1;
    dts_max = mpegps_read_dts(s, stream_index, &pos_max, 0);
    
    while (pos_min <= pos_max) {
#ifdef DEBUG_SEEK
        printf("pos_min=0x%llx pos_max=0x%llx dts_min=%0.3f dts_max=%0.3f\n", 
               pos_min, pos_max,
               dts_min / 90000.0, dts_max / 90000.0);
#endif
        if (timestamp <= dts_min) {
            pos = pos_min;
            goto found;
        } else if (timestamp >= dts_max) {
            pos = pos_max;
            goto found;
        } else {
            /* interpolate position (better than dichotomy) */
            pos = (int64_t)((double)(pos_max - pos_min) * 
                            (double)(timestamp - dts_min) /
                            (double)(dts_max - dts_min)) + pos_min;
        }
#ifdef DEBUG_SEEK
        printf("pos=0x%llx\n", pos);
#endif
        /* read the next timestamp */
        dts = mpegps_read_dts(s, stream_index, &pos, 1);
        /* check if we are lucky */
        if (dts == AV_NOPTS_VALUE) {
            /* should never happen */
            pos = pos_min;
            goto found;
        } else if (timestamp == dts) {
            goto found;
        } else if (timestamp < dts) {
            pos_max = pos;
            dts_max = mpegps_read_dts(s, stream_index, &pos_max, 0);
            if (dts_max == AV_NOPTS_VALUE) {
                /* should never happen */
                break;
            } else if (timestamp >= dts_max) {
                pos = pos_max;
                goto found;
            }
        } else {
            pos_min = pos + 1;
            dts_min = mpegps_read_dts(s, stream_index, &pos_min, 1);
            if (dts_min == AV_NOPTS_VALUE) {
                /* should never happen */
                goto found;
            } else if (timestamp <= dts_min) {
                goto found;
            }
        }
    }
    pos = pos_min;
 found:
#ifdef DEBUG_SEEK
    pos_min = pos;
    dts_min = mpegps_read_dts(s, stream_index, &pos_min, 1);
    pos_min++;
    dts_max = mpegps_read_dts(s, stream_index, &pos_min, 1);
    printf("pos=0x%llx %0.3f<=%0.3f<=%0.3f\n", 
           pos, dts_min / 90000.0, timestamp / 90000.0, dts_max / 90000.0);
#endif
    /* do the seek */
    url_fseek(&s->pb, pos, SEEK_SET);
    return 0;
}

1135
#ifdef CONFIG_ENCODERS
1136
static AVOutputFormat mpeg1system_mux = {
Fabrice Bellard's avatar
Fabrice Bellard committed
1137
    "mpeg",
1138
    "MPEG1 System format",
1139
    "video/mpeg",
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
    "mpg,mpeg",
    sizeof(MpegMuxContext),
    CODEC_ID_MP2,
    CODEC_ID_MPEG1VIDEO,
    mpeg_mux_init,
    mpeg_mux_write_packet,
    mpeg_mux_end,
};

static AVOutputFormat mpeg1vcd_mux = {
    "vcd",
    "MPEG1 System format (VCD)",
1152
    "video/mpeg",
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
    NULL,
    sizeof(MpegMuxContext),
    CODEC_ID_MP2,
    CODEC_ID_MPEG1VIDEO,
    mpeg_mux_init,
    mpeg_mux_write_packet,
    mpeg_mux_end,
};

static AVOutputFormat mpeg2vob_mux = {
    "vob",
    "MPEG2 PS format (VOB)",
1165
    "video/mpeg",
1166
    "vob",
1167
    sizeof(MpegMuxContext),
Fabrice Bellard's avatar
Fabrice Bellard committed
1168
    CODEC_ID_MP2,
1169
    CODEC_ID_MPEG2VIDEO,
Fabrice Bellard's avatar
Fabrice Bellard committed
1170 1171 1172
    mpeg_mux_init,
    mpeg_mux_write_packet,
    mpeg_mux_end,
1173
};
1174
#endif //CONFIG_ENCODERS
Fabrice Bellard's avatar
Fabrice Bellard committed
1175

Fabrice Bellard's avatar
Fabrice Bellard committed
1176
AVInputFormat mpegps_demux = {
1177 1178 1179 1180 1181 1182 1183
    "mpeg",
    "MPEG PS format",
    sizeof(MpegDemuxContext),
    mpegps_probe,
    mpegps_read_header,
    mpegps_read_packet,
    mpegps_read_close,
Fabrice Bellard's avatar
Fabrice Bellard committed
1184
    mpegps_read_seek,
Fabrice Bellard's avatar
Fabrice Bellard committed
1185
};
1186 1187 1188

int mpegps_init(void)
{
1189
#ifdef CONFIG_ENCODERS
1190 1191 1192
    av_register_output_format(&mpeg1system_mux);
    av_register_output_format(&mpeg1vcd_mux);
    av_register_output_format(&mpeg2vob_mux);
1193
#endif //CONFIG_ENCODERS
1194 1195 1196
    av_register_input_format(&mpegps_demux);
    return 0;
}