Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 2031ba1b

History | View | Annotate | Download (47 KB)

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 PRELOAD 45000 //0.5sec
23
//#define DEBUG_SEEK
24

    
25
#undef NDEBUG
26
#include <assert.h>
27

    
28
typedef struct PacketDesc {
29
    int64_t pts;
30
    int64_t dts;
31
    int size;
32
    int unwritten_size;
33
    int flags;
34
    struct PacketDesc *next;
35
} PacketDesc;
36

    
37
typedef struct {
38
    FifoBuffer fifo;
39
    uint8_t id;
40
    int max_buffer_size; /* in bytes */
41
    int buffer_index;
42
    PacketDesc *predecode_packet;
43
    PacketDesc *premux_packet;
44
    PacketDesc **next_packet;
45
    int packet_number;
46
    uint8_t lpcm_header[3];
47
    int lpcm_align;
48
} StreamInfo;
49

    
50
typedef struct {
51
    int packet_size; /* required packet size */
52
    int packet_number;
53
    int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
54
    int system_header_freq;
55
    int system_header_size;
56
    int mux_rate; /* bitrate in units of 50 bytes/s */
57
    /* stream info */
58
    int audio_bound;
59
    int video_bound;
60
    int is_mpeg2;
61
    int is_vcd;
62
    int is_svcd;
63
    int64_t last_scr; /* current system clock */
64

    
65
    double vcd_padding_bitrate; //FIXME floats
66
    int64_t vcd_padding_bytes_written;
67

    
68
} MpegMuxContext;
69

    
70
#define PACK_START_CODE             ((unsigned int)0x000001ba)
71
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
72
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
73
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
74
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
75
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
76
  
77
/* mpeg2 */
78
#define PROGRAM_STREAM_MAP 0x1bc
79
#define PRIVATE_STREAM_1   0x1bd
80
#define PADDING_STREAM     0x1be
81
#define PRIVATE_STREAM_2   0x1bf
82

    
83

    
84
#define AUDIO_ID 0xc0
85
#define VIDEO_ID 0xe0
86
#define AC3_ID   0x80
87
#define DTS_ID   0x8a
88
#define LPCM_ID  0xa0
89

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

    
92
#ifdef CONFIG_ENCODERS
93
static AVOutputFormat mpeg1system_mux;
94
static AVOutputFormat mpeg1vcd_mux;
95
static AVOutputFormat mpeg2vob_mux;
96
static AVOutputFormat mpeg2svcd_mux;
97

    
98
static int put_pack_header(AVFormatContext *ctx, 
99
                           uint8_t *buf, int64_t timestamp)
100
{
101
    MpegMuxContext *s = ctx->priv_data;
102
    PutBitContext pb;
103
    
104
    init_put_bits(&pb, buf, 128);
105

    
106
    put_bits(&pb, 32, PACK_START_CODE);
107
    if (s->is_mpeg2) {
108
        put_bits(&pb, 2, 0x1);
109
    } else {
110
        put_bits(&pb, 4, 0x2);
111
    }
112
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
113
    put_bits(&pb, 1, 1);
114
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
115
    put_bits(&pb, 1, 1);
116
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
117
    put_bits(&pb, 1, 1);
118
    if (s->is_mpeg2) {
119
        /* clock extension */
120
        put_bits(&pb, 9, 0);
121
    }
122
    put_bits(&pb, 1, 1);
123
    put_bits(&pb, 22, s->mux_rate);
124
    put_bits(&pb, 1, 1);
125
    if (s->is_mpeg2) {
126
        put_bits(&pb, 1, 1);
127
        put_bits(&pb, 5, 0x1f); /* reserved */
128
        put_bits(&pb, 3, 0); /* stuffing length */
129
    }
130
    flush_put_bits(&pb);
131
    return pbBufPtr(&pb) - pb.buf;
132
}
133

    
134
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
135
{
136
    MpegMuxContext *s = ctx->priv_data;
137
    int size, i, private_stream_coded, id;
138
    PutBitContext pb;
139

    
140
    init_put_bits(&pb, buf, 128);
141

    
142
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
143
    put_bits(&pb, 16, 0);
144
    put_bits(&pb, 1, 1);
145
    
146
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
147
    put_bits(&pb, 1, 1); /* marker */
148
    if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
149
        /* This header applies only to the video stream (see VCD standard p. IV-7)*/
150
        put_bits(&pb, 6, 0);
151
    } else
152
        put_bits(&pb, 6, s->audio_bound);
153

    
154
    if (s->is_vcd) {
155
        /* see VCD standard, p. IV-7*/
156
        put_bits(&pb, 1, 0); 
157
        put_bits(&pb, 1, 1);
158
    } else {
159
        put_bits(&pb, 1, 0); /* variable bitrate*/
160
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
161
    }
162
    
163
    if (s->is_vcd) {
164
        /* see VCD standard p IV-7 */
165
        put_bits(&pb, 1, 1); /* audio locked */
166
        put_bits(&pb, 1, 1); /* video locked */
167
    } else {
168
        put_bits(&pb, 1, 0); /* audio locked */
169
        put_bits(&pb, 1, 0); /* video locked */
170
    }
171

    
172
    put_bits(&pb, 1, 1); /* marker */
173

    
174
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
175
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
176
        put_bits(&pb, 5, 0);
177
    } else
178
        put_bits(&pb, 5, s->video_bound);
179

    
180
    put_bits(&pb, 8, 0xff); /* reserved byte */
181
    
182
    /* audio stream info */
183
    private_stream_coded = 0;
184
    for(i=0;i<ctx->nb_streams;i++) {
185
        StreamInfo *stream = ctx->streams[i]->priv_data;
186
        
187
        /* For VCDs, only include the stream info for the stream
188
           that the pack which contains this system belongs to.
189
           (see VCD standard p. IV-7) */
190
        if ( !s->is_vcd || stream->id==only_for_stream_id
191
            || only_for_stream_id==0) {
192

    
193
            id = stream->id;
194
            if (id < 0xc0) {
195
                /* special case for private streams (AC3 use that) */
196
                if (private_stream_coded)
197
                    continue;
198
                private_stream_coded = 1;
199
                id = 0xbd;
200
            }
201
            put_bits(&pb, 8, id); /* stream ID */
202
            put_bits(&pb, 2, 3);
203
            if (id < 0xe0) {
204
                /* audio */
205
                put_bits(&pb, 1, 0);
206
                put_bits(&pb, 13, stream->max_buffer_size / 128);
207
            } else {
208
                /* video */
209
                put_bits(&pb, 1, 1);
210
                put_bits(&pb, 13, stream->max_buffer_size / 1024);
211
            }
212
        }
213
    }
214
    flush_put_bits(&pb);
215
    size = pbBufPtr(&pb) - pb.buf;
216
    /* patch packet size */
217
    buf[4] = (size - 6) >> 8;
218
    buf[5] = (size - 6) & 0xff;
219

    
220
    return size;
221
}
222

    
223
static int get_system_header_size(AVFormatContext *ctx)
224
{
225
    int buf_index, i, private_stream_coded;
226
    StreamInfo *stream;
227

    
228
    buf_index = 12;
229
    private_stream_coded = 0;
230
    for(i=0;i<ctx->nb_streams;i++) {
231
        stream = ctx->streams[i]->priv_data;
232
        if (stream->id < 0xc0) {
233
            if (private_stream_coded)
234
                continue;
235
            private_stream_coded = 1;
236
        }
237
        buf_index += 3;
238
    }
239
    return buf_index;
240
}
241

    
242
static int mpeg_mux_init(AVFormatContext *ctx)
243
{
244
    MpegMuxContext *s = ctx->priv_data;
245
    int bitrate, i, mpa_id, mpv_id, ac3_id, dts_id, lpcm_id, j;
246
    AVStream *st;
247
    StreamInfo *stream;
248
    int audio_bitrate;
249
    int video_bitrate;
250

    
251
    s->packet_number = 0;
252
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
253
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
254
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux);
255
    
256
    if (s->is_vcd || s->is_svcd)
257
        s->packet_size = 2324; /* VCD/SVCD packet size */
258
    else
259
        s->packet_size = 2048;
260

    
261
    s->vcd_padding_bytes_written = 0;
262
    s->vcd_padding_bitrate=0;
263
        
264
    s->audio_bound = 0;
265
    s->video_bound = 0;
266
    mpa_id = AUDIO_ID;
267
    ac3_id = AC3_ID;
268
    dts_id = DTS_ID;
269
    mpv_id = VIDEO_ID;
270
    lpcm_id = LPCM_ID;
271
    for(i=0;i<ctx->nb_streams;i++) {
272
        st = ctx->streams[i];
273
        stream = av_mallocz(sizeof(StreamInfo));
274
        if (!stream)
275
            goto fail;
276
        st->priv_data = stream;
277

    
278
        av_set_pts_info(st, 64, 1, 90000);
279

    
280
        switch(st->codec.codec_type) {
281
        case CODEC_TYPE_AUDIO:
282
            if (st->codec.codec_id == CODEC_ID_AC3) {
283
                stream->id = ac3_id++;
284
            } else if (st->codec.codec_id == CODEC_ID_DTS) {
285
                stream->id = dts_id++;
286
            } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
287
                stream->id = lpcm_id++;
288
                for(j = 0; j < 4; j++) {
289
                    if (lpcm_freq_tab[j] == st->codec.sample_rate)
290
                        break;
291
                }
292
                if (j == 4)
293
                    goto fail;
294
                if (st->codec.channels > 8)
295
                    return -1;
296
                stream->lpcm_header[0] = 0x0c;
297
                stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
298
                stream->lpcm_header[2] = 0x80;
299
                stream->lpcm_align = st->codec.channels * 2;
300
            } else {
301
                stream->id = mpa_id++;
302
            }
303

    
304
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
305
               Right now it is also used for everything else.*/
306
            stream->max_buffer_size = 4 * 1024; 
307
            s->audio_bound++;
308
            break;
309
        case CODEC_TYPE_VIDEO:
310
            stream->id = mpv_id++;
311
            if (st->codec.rc_buffer_size)
312
                stream->max_buffer_size = 6*1024 + st->codec.rc_buffer_size/8;
313
            else
314
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
315
#if 0
316
                /* see VCD standard, p. IV-7*/
317
                stream->max_buffer_size = 46 * 1024; 
318
            else
319
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
320
                   Right now it is also used for everything else.*/
321
                stream->max_buffer_size = 230 * 1024; 
322
#endif
323
            s->video_bound++;
324
            break;
325
        default:
326
            return -1;
327
        }
328
        fifo_init(&stream->fifo, 2*stream->max_buffer_size + 100*MAX_PAYLOAD_SIZE); //FIXME think about the size maybe dynamically realloc
329
        stream->next_packet= &stream->premux_packet;
330
    }
331
    bitrate = 0;
332
    audio_bitrate = 0;
333
    video_bitrate = 0;
334
    for(i=0;i<ctx->nb_streams;i++) {
335
        int codec_rate;
336
        st = ctx->streams[i];
337
        stream = (StreamInfo*) st->priv_data;
338

    
339
        if(st->codec.rc_max_rate || stream->id==VIDEO_ID)
340
            codec_rate= st->codec.rc_max_rate;
341
        else
342
            codec_rate= st->codec.bit_rate;
343
                
344
        if(!codec_rate)
345
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
346
            
347
        bitrate += codec_rate;
348

    
349
        if (stream->id==AUDIO_ID)
350
            audio_bitrate += codec_rate;
351
        else if (stream->id==VIDEO_ID)
352
            video_bitrate += codec_rate;
353
    }
354

    
355
    if (s->is_vcd) {
356
        double overhead_rate;
357

    
358
        /* The VCD standard mandates that the mux_rate field is 3528
359
           (see standard p. IV-6).
360
           The value is actually "wrong", i.e. if you calculate
361
           it using the normal formula and the 75 sectors per second transfer
362
           rate you get a different value because the real pack size is 2324,
363
           not 2352. But the standard explicitly specifies that the mux_rate
364
           field in the header must have this value.*/
365
        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
366

    
367
        /* The VCD standard states that the muxed stream must be
368
           exactly 75 packs / second (the data rate of a single speed cdrom).
369
           Since the video bitrate (probably 1150000 bits/sec) will be below
370
           the theoretical maximum we have to add some padding packets
371
           to make up for the lower data rate.
372
           (cf. VCD standard p. IV-6 )*/
373

    
374
        /* Add the header overhead to the data rate.
375
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
376
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
377
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
378
        overhead_rate *= 8;
379
        
380
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
381
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
382

    
383
    } else {
384
        /* we increase slightly the bitrate to take into account the
385
           headers. XXX: compute it exactly */
386
        bitrate += bitrate*5/100;
387
        bitrate += 10000;
388
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
389
    }
390
    
391
    if (s->is_vcd || s->is_mpeg2)
392
        /* every packet */
393
        s->pack_header_freq = 1;
394
    else
395
        /* every 2 seconds */
396
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
397

    
398
    /* the above seems to make pack_header_freq zero sometimes */
399
    if (s->pack_header_freq == 0)
400
       s->pack_header_freq = 1;
401
    
402
    if (s->is_mpeg2)
403
        /* every 200 packets. Need to look at the spec.  */
404
        s->system_header_freq = s->pack_header_freq * 40;
405
    else if (s->is_vcd)
406
        /* the standard mandates that there are only two system headers
407
           in the whole file: one in the first packet of each stream.
408
           (see standard p. IV-7 and IV-8) */
409
        s->system_header_freq = 0x7fffffff;
410
    else
411
        s->system_header_freq = s->pack_header_freq * 5;
412
    
413
    for(i=0;i<ctx->nb_streams;i++) {
414
        stream = ctx->streams[i]->priv_data;
415
        stream->packet_number = 0;
416
    }
417
    s->system_header_size = get_system_header_size(ctx);
418
    s->last_scr = 0;
419
    return 0;
420
 fail:
421
    for(i=0;i<ctx->nb_streams;i++) {
422
        av_free(ctx->streams[i]->priv_data);
423
    }
424
    return -ENOMEM;
425
}
426

    
427
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
428
{
429
    put_byte(pb, 
430
             (id << 4) | 
431
             (((timestamp >> 30) & 0x07) << 1) | 
432
             1);
433
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
434
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
435
}
436

    
437

    
438
/* return the number of padding bytes that should be inserted into
439
   the multiplexed stream.*/
440
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
441
{
442
    MpegMuxContext *s = ctx->priv_data;
443
    int pad_bytes = 0;
444

    
445
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
446
    {
447
        int64_t full_pad_bytes;
448
        
449
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
450
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
451

    
452
        if (pad_bytes<0)
453
            /* might happen if we have already padded to a later timestamp. This
454
               can occur if another stream has already advanced further.*/
455
            pad_bytes=0;
456
    }
457

    
458
    return pad_bytes;
459
}
460

    
461

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

    
472
    stream = ctx->streams[stream_index]->priv_data;
473

    
474
    buf_index = 0;
475
    if (((s->packet_number % s->pack_header_freq) == 0)) {
476
        /* pack header size */
477
        if (s->is_mpeg2) 
478
            buf_index += 14;
479
        else
480
            buf_index += 12;
481
        
482
        if (s->is_vcd) {
483
            /* there is exactly one system header for each stream in a VCD MPEG,
484
               One in the very first video packet and one in the very first
485
               audio packet (see VCD standard p. IV-7 and IV-8).*/
486
            
487
            if (stream->packet_number==0)
488
                /* The system headers refer only to the stream they occur in,
489
                   so they have a constant size.*/
490
                buf_index += 15;
491

    
492
        } else {            
493
            if ((s->packet_number % s->system_header_freq) == 0)
494
                buf_index += s->system_header_size;
495
        }
496
    }
497

    
498
    if ((s->is_vcd && stream->packet_number==0)
499
        || (s->is_svcd && s->packet_number==0))
500
        /* the first pack of each stream contains only the pack header,
501
           the system header and some padding (see VCD standard p. IV-6) 
502
           Add the padding size, so that the actual payload becomes 0.*/
503
        buf_index += s->packet_size - buf_index;
504
    else {
505
        /* packet header size */
506
        buf_index += 6;
507
        if (s->is_mpeg2) {
508
            buf_index += 3;
509
            if (stream->packet_number==0)
510
                buf_index += 3; /* PES extension */
511
            buf_index += 1;    /* obligatory stuffing byte */
512
        }
513
        if (pts != AV_NOPTS_VALUE) {
514
            if (dts != pts)
515
                buf_index += 5 + 5;
516
            else
517
                buf_index += 5;
518

    
519
        } else {
520
            if (!s->is_mpeg2)
521
                buf_index++;
522
        }
523
    
524
        if (stream->id < 0xc0) {
525
            /* AC3/LPCM private data header */
526
            buf_index += 4;
527
            if (stream->id >= 0xa0) {
528
                int n;
529
                buf_index += 3;
530
                /* NOTE: we round the payload size to an integer number of
531
                   LPCM samples */
532
                n = (s->packet_size - buf_index) % stream->lpcm_align;
533
                if (n)
534
                    buf_index += (stream->lpcm_align - n);
535
            }
536
        }
537

    
538
        if (s->is_vcd && stream->id == AUDIO_ID)
539
            /* The VCD standard demands that 20 zero bytes follow
540
               each audio packet (see standard p. IV-8).*/
541
            buf_index+=20;
542
    }
543
    return s->packet_size - buf_index; 
544
}
545

    
546
/* Write an MPEG padding packet header. */
547
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
548
{
549
    MpegMuxContext *s = ctx->priv_data;
550
    int i;
551
    
552
    put_be32(pb, PADDING_STREAM);
553
    put_be16(pb, packet_bytes - 6);
554
    if (!s->is_mpeg2) {
555
        put_byte(pb, 0x0f);
556
        packet_bytes -= 7;
557
    } else
558
        packet_bytes -= 6;
559

    
560
    for(i=0;i<packet_bytes;i++)
561
        put_byte(pb, 0xff);
562
}
563

    
564
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
565
    int nb_frames=0;
566
    PacketDesc *pkt_desc= stream->premux_packet;
567

    
568
    while(len>0){ 
569
        if(pkt_desc->size == pkt_desc->unwritten_size)
570
            nb_frames++;
571
        len -= pkt_desc->unwritten_size;
572
        pkt_desc= pkt_desc->next;
573
    }
574

    
575
    return nb_frames;
576
}
577

    
578
/* flush the packet on stream stream_index */
579
static int flush_packet(AVFormatContext *ctx, int stream_index, 
580
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
581
{
582
    MpegMuxContext *s = ctx->priv_data;
583
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
584
    uint8_t *buf_ptr;
585
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
586
    int packet_size;
587
    uint8_t buffer[128];
588
    int zero_trail_bytes = 0;
589
    int pad_packet_bytes = 0;
590
    int pes_flags;
591
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
592
    int nb_frames;
593
    
594
    id = stream->id;
595
    
596
#if 0
597
    printf("packet ID=%2x PTS=%0.3f\n", 
598
           id, pts / 90000.0);
599
#endif
600

    
601
    buf_ptr = buffer;
602

    
603
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
604
        /* output pack and systems header if needed */
605
        size = put_pack_header(ctx, buf_ptr, scr);
606
        buf_ptr += size;
607
        s->last_scr= scr;
608

    
609
        if (s->is_vcd) {
610
            /* there is exactly one system header for each stream in a VCD MPEG,
611
               One in the very first video packet and one in the very first
612
               audio packet (see VCD standard p. IV-7 and IV-8).*/
613
            
614
            if (stream->packet_number==0) {
615
                size = put_system_header(ctx, buf_ptr, id);
616
                buf_ptr += size;
617
            }
618
        } else {
619
            if ((s->packet_number % s->system_header_freq) == 0) {
620
                size = put_system_header(ctx, buf_ptr, 0);
621
                buf_ptr += size;
622
            }
623
        }
624
    }
625
    size = buf_ptr - buffer;
626
    put_buffer(&ctx->pb, buffer, size);
627

    
628
    packet_size = s->packet_size - size;
629

    
630
    if (s->is_vcd && id == AUDIO_ID)
631
        /* The VCD standard demands that 20 zero bytes follow
632
           each audio pack (see standard p. IV-8).*/
633
        zero_trail_bytes += 20;
634
            
635
    if ((s->is_vcd && stream->packet_number==0)
636
        || (s->is_svcd && s->packet_number==0)) {
637
        /* for VCD the first pack of each stream contains only the pack header,
638
           the system header and lots of padding (see VCD standard p. IV-6).
639
           In the case of an audio pack, 20 zero bytes are also added at
640
           the end.*/
641
        /* For SVCD we fill the very first pack to increase compatibility with
642
           some DVD players. Not mandated by the standard.*/
643
        if (s->is_svcd)
644
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
645
        pad_packet_bytes = packet_size - zero_trail_bytes;
646
    }
647

    
648
    packet_size -= pad_packet_bytes + zero_trail_bytes;
649

    
650
    if (packet_size > 0) {
651

    
652
        /* packet header size */
653
        packet_size -= 6;
654
        
655
        /* packet header */
656
        if (s->is_mpeg2) {
657
            header_len = 3;
658
            if (stream->packet_number==0)
659
                header_len += 3; /* PES extension */
660
            header_len += 1; /* obligatory stuffing byte */
661
        } else {
662
            header_len = 0;
663
        }
664
        if (pts != AV_NOPTS_VALUE) {
665
            if (dts != pts)
666
                header_len += 5 + 5;
667
            else
668
                header_len += 5;
669
        } else {
670
            if (!s->is_mpeg2)
671
                header_len++;
672
        }
673

    
674
        payload_size = packet_size - header_len;
675
        if (id < 0xc0) {
676
            startcode = PRIVATE_STREAM_1;
677
            payload_size -= 4;
678
            if (id >= 0xa0)
679
                payload_size -= 3;
680
        } else {
681
            startcode = 0x100 + id;
682
        }
683

    
684
        stuffing_size = payload_size - fifo_size(&stream->fifo, stream->fifo.rptr);
685

    
686
        // first byte doesnt fit -> reset pts/dts + stuffing
687
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
688
            int timestamp_len=0;
689
            if(dts != pts) 
690
                timestamp_len += 5;
691
            if(pts != AV_NOPTS_VALUE)
692
                timestamp_len += s->is_mpeg2 ? 5 : 4;
693
            pts=dts= AV_NOPTS_VALUE;
694
            header_len -= timestamp_len;
695
            payload_size += timestamp_len;
696
            stuffing_size += timestamp_len;
697
            if(payload_size > trailer_size)
698
                stuffing_size += payload_size - trailer_size;
699
        }
700

    
701
        if (stuffing_size < 0)
702
            stuffing_size = 0;
703
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
704
            pad_packet_bytes += stuffing_size;
705
            packet_size -= stuffing_size;
706
            payload_size -= stuffing_size;
707
            stuffing_size = 0;
708
        }
709
        
710
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
711

    
712
        put_be32(&ctx->pb, startcode);
713

    
714
        put_be16(&ctx->pb, packet_size);
715
        
716
        if (!s->is_mpeg2)
717
            for(i=0;i<stuffing_size;i++)
718
                put_byte(&ctx->pb, 0xff);
719

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

    
723
            pes_flags=0;
724

    
725
            if (pts != AV_NOPTS_VALUE) {
726
                pes_flags |= 0x80;
727
                if (dts != pts)
728
                    pes_flags |= 0x40;
729
            }
730

    
731
            /* Both the MPEG-2 and the SVCD standards demand that the
732
               P-STD_buffer_size field be included in the first packet of
733
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
734
               and MPEG-2 standard 2.7.7) */
735
            if (stream->packet_number == 0)
736
                pes_flags |= 0x01;
737

    
738
            put_byte(&ctx->pb, pes_flags); /* flags */
739
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
740

    
741
            if (pes_flags & 0x80)  /*write pts*/
742
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
743
            if (pes_flags & 0x40)  /*write dts*/
744
                put_timestamp(&ctx->pb, 0x01, dts);
745
            
746
            if (pes_flags & 0x01) {  /*write pes extension*/
747
                put_byte(&ctx->pb, 0x10); /* flags */
748

    
749
                /* P-STD buffer info */                
750
                if (id == AUDIO_ID)
751
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
752
                else
753
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
754
            }
755

    
756
        } else {
757
            if (pts != AV_NOPTS_VALUE) {
758
                if (dts != pts) {
759
                    put_timestamp(&ctx->pb, 0x03, pts);
760
                    put_timestamp(&ctx->pb, 0x01, dts);
761
                } else {
762
                    put_timestamp(&ctx->pb, 0x02, pts);
763
                }
764
            } else {
765
                put_byte(&ctx->pb, 0x0f);
766
            }
767
        }
768

    
769
        if (s->is_mpeg2) {
770
            /* special stuffing byte that is always written
771
               to prevent accidental generation of start codes. */
772
            put_byte(&ctx->pb, 0xff);
773

    
774
            for(i=0;i<stuffing_size;i++)
775
                put_byte(&ctx->pb, 0xff);
776
        }
777

    
778
        if (startcode == PRIVATE_STREAM_1) {
779
            put_byte(&ctx->pb, id);
780
            if (id >= 0xa0) {
781
                /* LPCM (XXX: check nb_frames) */
782
                put_byte(&ctx->pb, 7);
783
                put_be16(&ctx->pb, 4); /* skip 3 header bytes */
784
                put_byte(&ctx->pb, stream->lpcm_header[0]);
785
                put_byte(&ctx->pb, stream->lpcm_header[1]);
786
                put_byte(&ctx->pb, stream->lpcm_header[2]);
787
            } else {
788
                /* AC3 */
789
                put_byte(&ctx->pb, nb_frames);
790
                put_be16(&ctx->pb, trailer_size+1);
791
            }
792
        }
793

    
794
        /* output data */
795
        if(put_fifo(&ctx->pb, &stream->fifo, payload_size - stuffing_size, &stream->fifo.rptr) < 0)
796
            return -1;
797
    }else{
798
        payload_size=
799
        stuffing_size= 0;
800
    }
801

    
802
    if (pad_packet_bytes > 0)
803
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);    
804

    
805
    for(i=0;i<zero_trail_bytes;i++)
806
        put_byte(&ctx->pb, 0x00);
807
        
808
    put_flush_packet(&ctx->pb);
809
    
810
    s->packet_number++;
811

    
812
    /* only increase the stream packet number if this pack actually contains
813
       something that is specific to this stream! I.e. a dedicated header
814
       or some data.*/
815
    if (!general_pack)
816
        stream->packet_number++;
817
    
818
    return payload_size - stuffing_size;
819
}
820

    
821
static void put_vcd_padding_sector(AVFormatContext *ctx)
822
{
823
    /* There are two ways to do this padding: writing a sector/pack
824
       of 0 values, or writing an MPEG padding pack. Both seem to
825
       work with most decoders, BUT the VCD standard only allows a 0-sector
826
       (see standard p. IV-4, IV-5).
827
       So a 0-sector it is...*/
828

    
829
    MpegMuxContext *s = ctx->priv_data;
830
    int i;
831

    
832
    for(i=0;i<s->packet_size;i++)
833
        put_byte(&ctx->pb, 0);
834

    
835
    s->vcd_padding_bytes_written += s->packet_size;
836
        
837
    put_flush_packet(&ctx->pb);
838
    
839
    /* increasing the packet number is correct. The SCR of the following packs
840
       is calculated from the packet_number and it has to include the padding
841
       sector (it represents the sector index, not the MPEG pack index)
842
       (see VCD standard p. IV-6)*/
843
    s->packet_number++;
844
}
845

    
846
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
847
{
848
    MpegMuxContext *s = ctx->priv_data;
849
    int64_t scr;
850

    
851
        /* Since the data delivery rate is constant, SCR is computed
852
           using the formula C + i * 1200 where C is the start constant
853
           and i is the pack index.
854
           It is recommended that SCR 0 is at the beginning of the VCD front
855
           margin (a sequence of empty Form 2 sectors on the CD).
856
           It is recommended that the front margin is 30 sectors long, so
857
           we use C = 30*1200 = 36000
858
           (Note that even if the front margin is not 30 sectors the file
859
           will still be correct according to the standard. It just won't have
860
           the "recommended" value).*/
861
        scr = 36000 + s->packet_number * 1200;
862

    
863
    return scr;
864
}    
865

    
866
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
867
//    MpegMuxContext *s = ctx->priv_data;
868
    int i;
869

    
870
    for(i=0; i<ctx->nb_streams; i++){
871
        AVStream *st = ctx->streams[i];
872
        StreamInfo *stream = st->priv_data;
873
        PacketDesc *pkt_desc= stream->predecode_packet;
874
        
875
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
876
            if(stream->buffer_index < pkt_desc->size || 
877
               stream->predecode_packet == stream->premux_packet){
878
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
879
                break;
880
            }
881
            stream->buffer_index -= pkt_desc->size;
882

    
883
            stream->predecode_packet= pkt_desc->next;
884
            av_freep(&pkt_desc);
885
        }
886
    }
887
    
888
    return 0;
889
}
890

    
891
static int output_packet(AVFormatContext *ctx, int flush){
892
    MpegMuxContext *s = ctx->priv_data;
893
    AVStream *st;
894
    StreamInfo *stream;
895
    int i, avail_space, es_size, trailer_size;
896
    int best_i= -1;
897
    int best_score= INT_MIN;
898
    int ignore_constraints=0;
899
    int64_t scr= s->last_scr;
900
    PacketDesc *timestamp_packet;
901

    
902
retry:
903
    for(i=0; i<ctx->nb_streams; i++){
904
        AVStream *st = ctx->streams[i];
905
        StreamInfo *stream = st->priv_data;
906
        const int avail_data=  fifo_size(&stream->fifo, stream->fifo.rptr);
907
        const int space= stream->max_buffer_size - stream->buffer_index;
908
        int rel_space= 1024*space / stream->max_buffer_size;
909

    
910
        if(s->packet_size > avail_data && !flush)
911
            return 0;
912
        if(avail_data==0)
913
            continue;
914
        assert(avail_data>0);
915

    
916
        if(space < s->packet_size && !ignore_constraints)
917
            continue;
918
            
919
        if(rel_space > best_score){
920
            best_score= rel_space;
921
            best_i = i;
922
            avail_space= space;
923
        }
924
    }
925
    
926
    if(best_i < 0){
927
        int64_t best_dts= INT64_MAX;
928

    
929
        for(i=0; i<ctx->nb_streams; i++){
930
            AVStream *st = ctx->streams[i];
931
            StreamInfo *stream = st->priv_data;
932
            PacketDesc *pkt_desc= stream->predecode_packet;
933
            if(pkt_desc && pkt_desc->dts < best_dts)
934
                best_dts= pkt_desc->dts;
935
        }
936

    
937
#if 0
938
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n", 
939
               scr/90000.0, best_dts/90000.0);
940
#endif
941
        if(best_dts == INT64_MAX)
942
            return 0;
943

    
944
        if(scr >= best_dts+1 && !ignore_constraints){
945
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
946
            ignore_constraints= 1;
947
        }
948
        scr= FFMAX(best_dts+1, scr);
949
        if(remove_decoded_packets(ctx, scr) < 0)
950
            return -1;
951
        goto retry;
952
    }
953

    
954
    assert(best_i >= 0);
955
    
956
    st = ctx->streams[best_i];
957
    stream = st->priv_data;
958
    
959
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
960

    
961
    assert(avail_space >= s->packet_size || ignore_constraints);
962
    
963
    timestamp_packet= stream->premux_packet;
964
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
965
        trailer_size= 0;
966
    }else{
967
        trailer_size= timestamp_packet->unwritten_size;
968
        timestamp_packet= timestamp_packet->next;
969
    }
970

    
971
    if(timestamp_packet){
972
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
973
    }else{
974
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == trailer_size);
975
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
976
    }
977

    
978
    if (s->is_vcd) {
979
        /* Write one or more padding sectors, if necessary, to reach
980
           the constant overall bitrate.*/
981
        int vcd_pad_bytes;
982

    
983
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
984
            put_vcd_padding_sector(ctx);
985
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
986
        }
987
    }
988
    
989
    stream->buffer_index += es_size;
990
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
991
    
992
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
993
        es_size -= stream->premux_packet->unwritten_size;
994
        stream->premux_packet= stream->premux_packet->next;
995
    }
996
    if(es_size)
997
        stream->premux_packet->unwritten_size -= es_size;
998
    
999
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1000
        return -1;
1001

    
1002
    return 1;
1003
}
1004

    
1005
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1006
{
1007
    MpegMuxContext *s = ctx->priv_data;
1008
    int stream_index= pkt->stream_index;
1009
    int size= pkt->size;
1010
    uint8_t *buf= pkt->data;
1011
    AVStream *st = ctx->streams[stream_index];
1012
    StreamInfo *stream = st->priv_data;
1013
    int64_t pts, dts;
1014
    PacketDesc *pkt_desc;
1015
    
1016
    pts= pkt->pts;
1017
    dts= pkt->dts;
1018

    
1019
    if(s->is_svcd) {
1020
        /* offset pts and dts slightly into the future to be able
1021
           to do the compatibility fix below.*/
1022
        pts += 2;
1023
        dts += 2;
1024

    
1025
        if (stream->packet_number == 0 && dts == pts)
1026
            /* For the very first packet we want to force the DTS to be included.
1027
               This increases compatibility with lots of DVD players.
1028
               Since the MPEG-2 standard mandates that DTS is only written when
1029
               it is different from PTS we have to move it slightly into the past.*/
1030
            dts -= 2;
1031
    }
1032
    if(s->is_vcd) {
1033
        /* We have to offset the PTS, so that it is consistent with the SCR.
1034
           SCR starts at 36000, but the first two packs contain only padding
1035
           and the first pack from the other stream, respectively, may also have
1036
           been written before.
1037
           So the real data starts at SCR 36000+3*1200. */
1038
        pts += 36000 + 3600;
1039
        dts += 36000 + 3600;
1040
    }else{
1041
        pts += PRELOAD;
1042
        dts += PRELOAD;
1043
    }
1044
//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index);
1045
    *stream->next_packet=
1046
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1047
    pkt_desc->pts= pts;
1048
    pkt_desc->dts= dts;
1049
    pkt_desc->unwritten_size=
1050
    pkt_desc->size= size;
1051
    if(!stream->predecode_packet)
1052
        stream->predecode_packet= pkt_desc;
1053
    stream->next_packet= &pkt_desc->next;
1054

    
1055
    if(stream->fifo.end - stream->fifo.buffer - fifo_size(&stream->fifo, stream->fifo.rptr) < size){
1056
        av_log(ctx, AV_LOG_ERROR, "fifo overflow\n");
1057
        return -1;
1058
    }
1059
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1060

    
1061
    for(;;){
1062
        int ret= output_packet(ctx, 0);
1063
        if(ret<=0) 
1064
            return ret;
1065
    }
1066
}
1067

    
1068
static int mpeg_mux_end(AVFormatContext *ctx)
1069
{
1070
//    MpegMuxContext *s = ctx->priv_data;
1071
    StreamInfo *stream;
1072
    int i;
1073
    
1074
    for(;;){
1075
        int ret= output_packet(ctx, 1);
1076
        if(ret<0) 
1077
            return ret;
1078
        else if(ret==0)
1079
            break;
1080
    }
1081

    
1082
    /* End header according to MPEG1 systems standard. We do not write
1083
       it as it is usually not needed by decoders and because it
1084
       complicates MPEG stream concatenation. */
1085
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1086
    //put_flush_packet(&ctx->pb);
1087

    
1088
    for(i=0;i<ctx->nb_streams;i++) {
1089
        stream = ctx->streams[i]->priv_data;
1090

    
1091
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1092
        fifo_free(&stream->fifo);
1093
    }
1094
    return 0;
1095
}
1096
#endif //CONFIG_ENCODERS
1097

    
1098
/*********************************************/
1099
/* demux code */
1100

    
1101
#define MAX_SYNC_SIZE 100000
1102

    
1103
static int mpegps_probe(AVProbeData *p)
1104
{
1105
    int i;
1106
    int size= FFMIN(20, p->buf_size);
1107
    uint32_t code=0xFF;
1108

    
1109
    /* we search the first start code. If it is a packet start code,
1110
       then we decide it is mpeg ps. We do not send highest value to
1111
       give a chance to mpegts */
1112
    /* NOTE: the search range was restricted to avoid too many false
1113
       detections */
1114

    
1115
    for (i = 0; i < size; i++) {
1116
        code = (code << 8) | p->buf[i];
1117
        if ((code & 0xffffff00) == 0x100) {
1118
            if (code == PACK_START_CODE ||
1119
                code == SYSTEM_HEADER_START_CODE ||
1120
                (code >= 0x1e0 && code <= 0x1ef) ||
1121
                (code >= 0x1c0 && code <= 0x1df) ||
1122
                code == PRIVATE_STREAM_2 ||
1123
                code == PROGRAM_STREAM_MAP ||
1124
                code == PRIVATE_STREAM_1 ||
1125
                code == PADDING_STREAM)
1126
                return AVPROBE_SCORE_MAX - 2;
1127
            else
1128
                return 0;
1129
        }
1130
    }
1131
    return 0;
1132
}
1133

    
1134

    
1135
typedef struct MpegDemuxContext {
1136
    int header_state;
1137
} MpegDemuxContext;
1138

    
1139
static int mpegps_read_header(AVFormatContext *s,
1140
                              AVFormatParameters *ap)
1141
{
1142
    MpegDemuxContext *m = s->priv_data;
1143
    m->header_state = 0xff;
1144
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1145

    
1146
    /* no need to do more */
1147
    return 0;
1148
}
1149

    
1150
static int64_t get_pts(ByteIOContext *pb, int c)
1151
{
1152
    int64_t pts;
1153
    int val;
1154

    
1155
    if (c < 0)
1156
        c = get_byte(pb);
1157
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1158
    val = get_be16(pb);
1159
    pts |= (int64_t)(val >> 1) << 15;
1160
    val = get_be16(pb);
1161
    pts |= (int64_t)(val >> 1);
1162
    return pts;
1163
}
1164

    
1165
static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1166
                                uint32_t *header_state)
1167
{
1168
    unsigned int state, v;
1169
    int val, n;
1170

    
1171
    state = *header_state;
1172
    n = *size_ptr;
1173
    while (n > 0) {
1174
        if (url_feof(pb))
1175
            break;
1176
        v = get_byte(pb);
1177
        n--;
1178
        if (state == 0x000001) {
1179
            state = ((state << 8) | v) & 0xffffff;
1180
            val = state;
1181
            goto found;
1182
        }
1183
        state = ((state << 8) | v) & 0xffffff;
1184
    }
1185
    val = -1;
1186
 found:
1187
    *header_state = state;
1188
    *size_ptr = n;
1189
    return val;
1190
}
1191

    
1192
/* XXX: optimize */
1193
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1194
{
1195
    int64_t pos, pos_start;
1196
    int max_size, start_code;
1197

    
1198
    max_size = *size_ptr;
1199
    pos_start = url_ftell(pb);
1200

    
1201
    /* in order to go faster, we fill the buffer */
1202
    pos = pos_start - 16386;
1203
    if (pos < 0)
1204
        pos = 0;
1205
    url_fseek(pb, pos, SEEK_SET);
1206
    get_byte(pb);
1207

    
1208
    pos = pos_start;
1209
    for(;;) {
1210
        pos--;
1211
        if (pos < 0 || (pos_start - pos) >= max_size) {
1212
            start_code = -1;
1213
            goto the_end;
1214
        }
1215
        url_fseek(pb, pos, SEEK_SET);
1216
        start_code = get_be32(pb);
1217
        if ((start_code & 0xffffff00) == 0x100)
1218
            break;
1219
    }
1220
 the_end:
1221
    *size_ptr = pos_start - pos;
1222
    return start_code;
1223
}
1224

    
1225
/* read the next PES header. Return its position in ppos 
1226
   (if not NULL), and its start code, pts and dts.
1227
 */
1228
static int mpegps_read_pes_header(AVFormatContext *s,
1229
                                  int64_t *ppos, int *pstart_code, 
1230
                                  int64_t *ppts, int64_t *pdts)
1231
{
1232
    MpegDemuxContext *m = s->priv_data;
1233
    int len, size, startcode, c, flags, header_len;
1234
    int64_t pts, dts, last_pos;
1235

    
1236
    last_pos = -1;
1237
 redo:
1238
        /* next start code (should be immediately after) */
1239
        m->header_state = 0xff;
1240
        size = MAX_SYNC_SIZE;
1241
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1242
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1243
    if (startcode < 0)
1244
        return AVERROR_IO;
1245
    if (startcode == PACK_START_CODE)
1246
        goto redo;
1247
    if (startcode == SYSTEM_HEADER_START_CODE)
1248
        goto redo;
1249
    if (startcode == PADDING_STREAM ||
1250
        startcode == PRIVATE_STREAM_2) {
1251
        /* skip them */
1252
        len = get_be16(&s->pb);
1253
        url_fskip(&s->pb, len);
1254
        goto redo;
1255
    }
1256
    /* find matching stream */
1257
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1258
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1259
          (startcode == 0x1bd)))
1260
        goto redo;
1261
    if (ppos) {
1262
        *ppos = url_ftell(&s->pb) - 4;
1263
    }
1264
    len = get_be16(&s->pb);
1265
    pts = AV_NOPTS_VALUE;
1266
    dts = AV_NOPTS_VALUE;
1267
    /* stuffing */
1268
    for(;;) {
1269
        if (len < 1)
1270
            goto redo;
1271
        c = get_byte(&s->pb);
1272
        len--;
1273
        /* XXX: for mpeg1, should test only bit 7 */
1274
        if (c != 0xff) 
1275
            break;
1276
    }
1277
    if ((c & 0xc0) == 0x40) {
1278
        /* buffer scale & size */
1279
        if (len < 2)
1280
            goto redo;
1281
        get_byte(&s->pb);
1282
        c = get_byte(&s->pb);
1283
        len -= 2;
1284
    }
1285
    if ((c & 0xf0) == 0x20) {
1286
        if (len < 4)
1287
            goto redo;
1288
        dts = pts = get_pts(&s->pb, c);
1289
        len -= 4;
1290
    } else if ((c & 0xf0) == 0x30) {
1291
        if (len < 9)
1292
            goto redo;
1293
        pts = get_pts(&s->pb, c);
1294
        dts = get_pts(&s->pb, -1);
1295
        len -= 9;
1296
    } else if ((c & 0xc0) == 0x80) {
1297
        /* mpeg 2 PES */
1298
        if ((c & 0x30) != 0) {
1299
            /* Encrypted multiplex not handled */
1300
            goto redo;
1301
        }
1302
        flags = get_byte(&s->pb);
1303
        header_len = get_byte(&s->pb);
1304
        len -= 2;
1305
        if (header_len > len)
1306
            goto redo;
1307
        if ((flags & 0xc0) == 0x80) {
1308
            dts = pts = get_pts(&s->pb, -1);
1309
            if (header_len < 5)
1310
                goto redo;
1311
            header_len -= 5;
1312
            len -= 5;
1313
        } if ((flags & 0xc0) == 0xc0) {
1314
            pts = get_pts(&s->pb, -1);
1315
            dts = get_pts(&s->pb, -1);
1316
            if (header_len < 10)
1317
                goto redo;
1318
            header_len -= 10;
1319
            len -= 10;
1320
        }
1321
        len -= header_len;
1322
        while (header_len > 0) {
1323
            get_byte(&s->pb);
1324
            header_len--;
1325
        }
1326
    }
1327
    else if( c!= 0xf )
1328
        goto redo;
1329

    
1330
    if (startcode == 0x1bd) {
1331
        if (len < 1)
1332
            goto redo;
1333
        startcode = get_byte(&s->pb);
1334
        len--;
1335
        if (startcode >= 0x80 && startcode <= 0xbf) {
1336
            /* audio: skip header */
1337
            if (len < 3)
1338
                goto redo;
1339
            get_byte(&s->pb);
1340
            get_byte(&s->pb);
1341
            get_byte(&s->pb);
1342
            len -= 3;
1343
        }
1344
    }
1345
    if(dts != AV_NOPTS_VALUE && ppos){
1346
        int i;
1347
        for(i=0; i<s->nb_streams; i++){
1348
            if(startcode == s->streams[i]->id) {
1349
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0 /* FIXME keyframe? */);
1350
            }
1351
        }
1352
    }
1353
    
1354
    *pstart_code = startcode;
1355
    *ppts = pts;
1356
    *pdts = dts;
1357
    return len;
1358
}
1359

    
1360
static int mpegps_read_packet(AVFormatContext *s,
1361
                              AVPacket *pkt)
1362
{
1363
    AVStream *st;
1364
    int len, startcode, i, type, codec_id = 0;
1365
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1366

    
1367
 redo:
1368
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1369
    if (len < 0)
1370
        return len;
1371
    
1372
    /* now find stream */
1373
    for(i=0;i<s->nb_streams;i++) {
1374
        st = s->streams[i];
1375
        if (st->id == startcode)
1376
            goto found;
1377
    }
1378
    if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1379
        type = CODEC_TYPE_VIDEO;
1380
        codec_id = CODEC_ID_MPEG2VIDEO;
1381
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1382
        type = CODEC_TYPE_AUDIO;
1383
        codec_id = CODEC_ID_MP2;
1384
    } else if (startcode >= 0x80 && startcode <= 0x89) {
1385
        type = CODEC_TYPE_AUDIO;
1386
        codec_id = CODEC_ID_AC3;
1387
    } else if (startcode >= 0x8a && startcode <= 0x9f) {
1388
        type = CODEC_TYPE_AUDIO;
1389
        codec_id = CODEC_ID_DTS;
1390
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1391
        type = CODEC_TYPE_AUDIO;
1392
        codec_id = CODEC_ID_PCM_S16BE;
1393
    } else {
1394
    skip:
1395
        /* skip packet */
1396
        url_fskip(&s->pb, len);
1397
        goto redo;
1398
    }
1399
    /* no stream found: add a new stream */
1400
    st = av_new_stream(s, startcode);
1401
    if (!st) 
1402
        goto skip;
1403
    st->codec.codec_type = type;
1404
    st->codec.codec_id = codec_id;
1405
    if (codec_id != CODEC_ID_PCM_S16BE)
1406
        st->need_parsing = 1;
1407
 found:
1408
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1409
        int b1, freq;
1410

    
1411
        /* for LPCM, we just skip the header and consider it is raw
1412
           audio data */
1413
        if (len <= 3)
1414
            goto skip;
1415
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1416
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1417
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1418
        len -= 3;
1419
        freq = (b1 >> 4) & 3;
1420
        st->codec.sample_rate = lpcm_freq_tab[freq];
1421
        st->codec.channels = 1 + (b1 & 7);
1422
        st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
1423
    }
1424
    av_new_packet(pkt, len);
1425
    get_buffer(&s->pb, pkt->data, pkt->size);
1426
    pkt->pts = pts;
1427
    pkt->dts = dts;
1428
    pkt->stream_index = st->index;
1429
#if 0
1430
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f\n",
1431
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
1432
#endif
1433

    
1434
    return 0;
1435
}
1436

    
1437
static int mpegps_read_close(AVFormatContext *s)
1438
{
1439
    return 0;
1440
}
1441

    
1442
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1443
                               int64_t *ppos, int64_t pos_limit)
1444
{
1445
    int len, startcode;
1446
    int64_t pos, pts, dts;
1447

    
1448
    pos = *ppos;
1449
#ifdef DEBUG_SEEK
1450
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1451
#endif
1452
    url_fseek(&s->pb, pos, SEEK_SET);
1453
    for(;;) {
1454
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1455
        if (len < 0) {
1456
#ifdef DEBUG_SEEK
1457
            printf("none (ret=%d)\n", len);
1458
#endif
1459
            return AV_NOPTS_VALUE;
1460
        }
1461
        if (startcode == s->streams[stream_index]->id && 
1462
            dts != AV_NOPTS_VALUE) {
1463
            break;
1464
        }
1465
        url_fskip(&s->pb, len);
1466
    }
1467
#ifdef DEBUG_SEEK
1468
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1469
#endif
1470
    *ppos = pos;
1471
    return dts;
1472
}
1473

    
1474
#ifdef CONFIG_ENCODERS
1475
static AVOutputFormat mpeg1system_mux = {
1476
    "mpeg",
1477
    "MPEG1 System format",
1478
    "video/mpeg",
1479
    "mpg,mpeg",
1480
    sizeof(MpegMuxContext),
1481
    CODEC_ID_MP2,
1482
    CODEC_ID_MPEG1VIDEO,
1483
    mpeg_mux_init,
1484
    mpeg_mux_write_packet,
1485
    mpeg_mux_end,
1486
};
1487

    
1488
static AVOutputFormat mpeg1vcd_mux = {
1489
    "vcd",
1490
    "MPEG1 System format (VCD)",
1491
    "video/mpeg",
1492
    NULL,
1493
    sizeof(MpegMuxContext),
1494
    CODEC_ID_MP2,
1495
    CODEC_ID_MPEG1VIDEO,
1496
    mpeg_mux_init,
1497
    mpeg_mux_write_packet,
1498
    mpeg_mux_end,
1499
};
1500

    
1501
static AVOutputFormat mpeg2vob_mux = {
1502
    "vob",
1503
    "MPEG2 PS format (VOB)",
1504
    "video/mpeg",
1505
    "vob",
1506
    sizeof(MpegMuxContext),
1507
    CODEC_ID_MP2,
1508
    CODEC_ID_MPEG2VIDEO,
1509
    mpeg_mux_init,
1510
    mpeg_mux_write_packet,
1511
    mpeg_mux_end,
1512
};
1513

    
1514
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1515
static AVOutputFormat mpeg2svcd_mux = {
1516
    "svcd",
1517
    "MPEG2 PS format (VOB)",
1518
    "video/mpeg",
1519
    "vob",
1520
    sizeof(MpegMuxContext),
1521
    CODEC_ID_MP2,
1522
    CODEC_ID_MPEG2VIDEO,
1523
    mpeg_mux_init,
1524
    mpeg_mux_write_packet,
1525
    mpeg_mux_end,
1526
};
1527

    
1528

    
1529

    
1530
#endif //CONFIG_ENCODERS
1531

    
1532
AVInputFormat mpegps_demux = {
1533
    "mpeg",
1534
    "MPEG PS format",
1535
    sizeof(MpegDemuxContext),
1536
    mpegps_probe,
1537
    mpegps_read_header,
1538
    mpegps_read_packet,
1539
    mpegps_read_close,
1540
    NULL, //mpegps_read_seek,
1541
    mpegps_read_dts,
1542
};
1543

    
1544
int mpegps_init(void)
1545
{
1546
#ifdef CONFIG_ENCODERS
1547
    av_register_output_format(&mpeg1system_mux);
1548
    av_register_output_format(&mpeg1vcd_mux);
1549
    av_register_output_format(&mpeg2vob_mux);
1550
    av_register_output_format(&mpeg2svcd_mux);
1551
#endif //CONFIG_ENCODERS
1552
    av_register_input_format(&mpegps_demux);
1553
    return 0;
1554
}