Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 25f8db58

History | View | Annotate | Download (56.2 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
#include "bitstream.h"
21

    
22
#define MAX_PAYLOAD_SIZE 4096
23
//#define DEBUG_SEEK
24

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

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

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

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

    
69
    double vcd_padding_bitrate; //FIXME floats
70
    int64_t vcd_padding_bytes_written;
71

    
72
} MpegMuxContext;
73

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

    
87

    
88
#define AUDIO_ID 0xc0
89
#define VIDEO_ID 0xe0
90
#define AC3_ID   0x80
91
#define DTS_ID   0x8a
92
#define LPCM_ID  0xa0
93
#define SUB_ID   0x20
94

    
95
#define STREAM_TYPE_VIDEO_MPEG1     0x01
96
#define STREAM_TYPE_VIDEO_MPEG2     0x02
97
#define STREAM_TYPE_AUDIO_MPEG1     0x03
98
#define STREAM_TYPE_AUDIO_MPEG2     0x04
99
#define STREAM_TYPE_PRIVATE_SECTION 0x05
100
#define STREAM_TYPE_PRIVATE_DATA    0x06
101
#define STREAM_TYPE_AUDIO_AAC       0x0f
102
#define STREAM_TYPE_VIDEO_MPEG4     0x10
103
#define STREAM_TYPE_VIDEO_H264      0x1b
104

    
105
#define STREAM_TYPE_AUDIO_AC3       0x81
106
#define STREAM_TYPE_AUDIO_DTS       0x8a
107

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

    
110
#ifdef CONFIG_MUXERS
111
static AVOutputFormat mpeg1system_mux;
112
static AVOutputFormat mpeg1vcd_mux;
113
static AVOutputFormat mpeg2vob_mux;
114
static AVOutputFormat mpeg2svcd_mux;
115
static AVOutputFormat mpeg2dvd_mux;
116

    
117
static int put_pack_header(AVFormatContext *ctx, 
118
                           uint8_t *buf, int64_t timestamp)
119
{
120
    MpegMuxContext *s = ctx->priv_data;
121
    PutBitContext pb;
122
    
123
    init_put_bits(&pb, buf, 128);
124

    
125
    put_bits(&pb, 32, PACK_START_CODE);
126
    if (s->is_mpeg2) {
127
        put_bits(&pb, 2, 0x1);
128
    } else {
129
        put_bits(&pb, 4, 0x2);
130
    }
131
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
132
    put_bits(&pb, 1, 1);
133
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
134
    put_bits(&pb, 1, 1);
135
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
136
    put_bits(&pb, 1, 1);
137
    if (s->is_mpeg2) {
138
        /* clock extension */
139
        put_bits(&pb, 9, 0);
140
    }
141
    put_bits(&pb, 1, 1);
142
    put_bits(&pb, 22, s->mux_rate);
143
    put_bits(&pb, 1, 1);
144
    if (s->is_mpeg2) {
145
        put_bits(&pb, 1, 1);
146
        put_bits(&pb, 5, 0x1f); /* reserved */
147
        put_bits(&pb, 3, 0); /* stuffing length */
148
    }
149
    flush_put_bits(&pb);
150
    return pbBufPtr(&pb) - pb.buf;
151
}
152

    
153
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
154
{
155
    MpegMuxContext *s = ctx->priv_data;
156
    int size, i, private_stream_coded, id;
157
    PutBitContext pb;
158

    
159
    init_put_bits(&pb, buf, 128);
160

    
161
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
162
    put_bits(&pb, 16, 0);
163
    put_bits(&pb, 1, 1);
164
    
165
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
166
    put_bits(&pb, 1, 1); /* marker */
167
    if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
168
        /* This header applies only to the video stream (see VCD standard p. IV-7)*/
169
        put_bits(&pb, 6, 0);
170
    } else
171
        put_bits(&pb, 6, s->audio_bound);
172

    
173
    if (s->is_vcd) {
174
        /* see VCD standard, p. IV-7*/
175
        put_bits(&pb, 1, 0); 
176
        put_bits(&pb, 1, 1);
177
    } else {
178
        put_bits(&pb, 1, 0); /* variable bitrate*/
179
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
180
    }
181
    
182
    if (s->is_vcd || s->is_dvd) {
183
        /* see VCD standard p IV-7 */
184
        put_bits(&pb, 1, 1); /* audio locked */
185
        put_bits(&pb, 1, 1); /* video locked */
186
    } else {
187
        put_bits(&pb, 1, 0); /* audio locked */
188
        put_bits(&pb, 1, 0); /* video locked */
189
    }
190

    
191
    put_bits(&pb, 1, 1); /* marker */
192

    
193
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
194
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
195
        put_bits(&pb, 5, 0);
196
    } else
197
        put_bits(&pb, 5, s->video_bound);
198
    
199
    if (s->is_dvd) {
200
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
201
        put_bits(&pb, 7, 0x7f); /* reserved byte */
202
    } else
203
        put_bits(&pb, 8, 0xff); /* reserved byte */
204
    
205
    /* DVD-Video Stream_bound entries
206
    id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1) 
207
    id (0xB8) audio, maximum P-STD for any MPEG audio (0xC0 to 0xC7) streams. If there are none set to 4096 (32x128). (P-STD_buffer_bound_scale = 0) 
208
    id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1) 
209
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
210
    if (s->is_dvd) {
211
        
212
        int P_STD_max_video = 0;
213
        int P_STD_max_mpeg_audio = 0;
214
        int P_STD_max_mpeg_PS1 = 0;
215
        
216
        for(i=0;i<ctx->nb_streams;i++) {
217
            StreamInfo *stream = ctx->streams[i]->priv_data;
218

    
219
            id = stream->id;
220
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
221
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
222
            } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
223
                P_STD_max_mpeg_audio = stream->max_buffer_size;
224
            } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
225
                P_STD_max_video = stream->max_buffer_size;
226
            }
227
        }
228

    
229
        /* video */
230
        put_bits(&pb, 8, 0xb9); /* stream ID */
231
        put_bits(&pb, 2, 3);
232
        put_bits(&pb, 1, 1);
233
        put_bits(&pb, 13, P_STD_max_video / 1024);
234

    
235
        /* audio */
236
        if (P_STD_max_mpeg_audio == 0)
237
            P_STD_max_mpeg_audio = 4096;
238
        put_bits(&pb, 8, 0xb8); /* stream ID */
239
        put_bits(&pb, 2, 3);
240
        put_bits(&pb, 1, 0);
241
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
242

    
243
        /* private stream 1 */
244
        put_bits(&pb, 8, 0xbd); /* stream ID */
245
        put_bits(&pb, 2, 3);
246
        put_bits(&pb, 1, 0);
247
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
248

    
249
        /* private stream 2 */
250
        put_bits(&pb, 8, 0xbf); /* stream ID */
251
        put_bits(&pb, 2, 3);
252
        put_bits(&pb, 1, 1);
253
        put_bits(&pb, 13, 2);
254
    }
255
    else {
256
        /* audio stream info */
257
        private_stream_coded = 0;
258
        for(i=0;i<ctx->nb_streams;i++) {
259
            StreamInfo *stream = ctx->streams[i]->priv_data;
260
            
261

    
262
            /* For VCDs, only include the stream info for the stream
263
            that the pack which contains this system belongs to.
264
            (see VCD standard p. IV-7) */
265
            if ( !s->is_vcd || stream->id==only_for_stream_id
266
                || only_for_stream_id==0) {
267

    
268
                id = stream->id;
269
                if (id < 0xc0) {
270
                    /* special case for private streams (AC3 use that) */
271
                    if (private_stream_coded)
272
                        continue;
273
                    private_stream_coded = 1;
274
                    id = 0xbd;
275
                }
276
                put_bits(&pb, 8, id); /* stream ID */
277
                put_bits(&pb, 2, 3);
278
                if (id < 0xe0) {
279
                    /* audio */
280
                    put_bits(&pb, 1, 0);
281
                    put_bits(&pb, 13, stream->max_buffer_size / 128);
282
                } else {
283
                    /* video */
284
                    put_bits(&pb, 1, 1);
285
                    put_bits(&pb, 13, stream->max_buffer_size / 1024);
286
                }
287
            }
288
        }
289
    }
290

    
291
    flush_put_bits(&pb);
292
    size = pbBufPtr(&pb) - pb.buf;
293
    /* patch packet size */
294
    buf[4] = (size - 6) >> 8;
295
    buf[5] = (size - 6) & 0xff;
296

    
297
    return size;
298
}
299

    
300
static int get_system_header_size(AVFormatContext *ctx)
301
{
302
    int buf_index, i, private_stream_coded;
303
    StreamInfo *stream;
304
    MpegMuxContext *s = ctx->priv_data;
305

    
306
    if (s->is_dvd)
307
       return 18; // DVD-Video system headers are 18 bytes fixed length.
308

    
309
    buf_index = 12;
310
    private_stream_coded = 0;
311
    for(i=0;i<ctx->nb_streams;i++) {
312
        stream = ctx->streams[i]->priv_data;
313
        if (stream->id < 0xc0) {
314
            if (private_stream_coded)
315
                continue;
316
            private_stream_coded = 1;
317
        }
318
        buf_index += 3;
319
    }
320
    return buf_index;
321
}
322

    
323
static int mpeg_mux_init(AVFormatContext *ctx)
324
{
325
    MpegMuxContext *s = ctx->priv_data;
326
    int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
327
    AVStream *st;
328
    StreamInfo *stream;
329
    int audio_bitrate;
330
    int video_bitrate;
331

    
332
    s->packet_number = 0;
333
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
334
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
335
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
336
    s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
337
    
338
    if(ctx->packet_size)
339
        s->packet_size = ctx->packet_size;
340
    else
341
        s->packet_size = 2048;
342
       
343
    s->vcd_padding_bytes_written = 0;
344
    s->vcd_padding_bitrate=0;
345
        
346
    s->audio_bound = 0;
347
    s->video_bound = 0;
348
    mpa_id = AUDIO_ID;
349
    ac3_id = AC3_ID;
350
    dts_id = DTS_ID;
351
    mpv_id = VIDEO_ID;
352
    mps_id = SUB_ID;
353
    lpcm_id = LPCM_ID;
354
    for(i=0;i<ctx->nb_streams;i++) {
355
        st = ctx->streams[i];
356
        stream = av_mallocz(sizeof(StreamInfo));
357
        if (!stream)
358
            goto fail;
359
        st->priv_data = stream;
360

    
361
        av_set_pts_info(st, 64, 1, 90000);
362

    
363
        switch(st->codec->codec_type) {
364
        case CODEC_TYPE_AUDIO:
365
            if (st->codec->codec_id == CODEC_ID_AC3) {
366
                stream->id = ac3_id++;
367
            } else if (st->codec->codec_id == CODEC_ID_DTS) {
368
                stream->id = dts_id++;
369
            } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
370
                stream->id = lpcm_id++;
371
                for(j = 0; j < 4; j++) {
372
                    if (lpcm_freq_tab[j] == st->codec->sample_rate)
373
                        break;
374
                }
375
                if (j == 4)
376
                    goto fail;
377
                if (st->codec->channels > 8)
378
                    return -1;
379
                stream->lpcm_header[0] = 0x0c;
380
                stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
381
                stream->lpcm_header[2] = 0x80;
382
                stream->lpcm_align = st->codec->channels * 2;
383
            } else {
384
                stream->id = mpa_id++;
385
            }
386

    
387
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
388
               Right now it is also used for everything else.*/
389
            stream->max_buffer_size = 4 * 1024; 
390
            s->audio_bound++;
391
            break;
392
        case CODEC_TYPE_VIDEO:
393
            stream->id = mpv_id++;
394
            if (st->codec->rc_buffer_size)
395
                stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
396
            else
397
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
398
#if 0
399
                /* see VCD standard, p. IV-7*/
400
                stream->max_buffer_size = 46 * 1024; 
401
            else
402
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
403
                   Right now it is also used for everything else.*/
404
                stream->max_buffer_size = 230 * 1024; 
405
#endif
406
            s->video_bound++;
407
            break;
408
        case CODEC_TYPE_SUBTITLE:
409
            stream->id = mps_id++;
410
            stream->max_buffer_size = 16 * 1024;
411
            break;
412
        default:
413
            return -1;
414
        }
415
        fifo_init(&stream->fifo, 16);
416
    }
417
    bitrate = 0;
418
    audio_bitrate = 0;
419
    video_bitrate = 0;
420
    for(i=0;i<ctx->nb_streams;i++) {
421
        int codec_rate;
422
        st = ctx->streams[i];
423
        stream = (StreamInfo*) st->priv_data;
424

    
425
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
426
            codec_rate= st->codec->rc_max_rate;
427
        else
428
            codec_rate= st->codec->bit_rate;
429
                
430
        if(!codec_rate)
431
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
432
            
433
        bitrate += codec_rate;
434

    
435
        if (stream->id==AUDIO_ID)
436
            audio_bitrate += codec_rate;
437
        else if (stream->id==VIDEO_ID)
438
            video_bitrate += codec_rate;
439
    }
440
    
441
    if(ctx->mux_rate){
442
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
443
    } else {
444
        /* we increase slightly the bitrate to take into account the
445
           headers. XXX: compute it exactly */
446
        bitrate += bitrate*5/100;
447
        bitrate += 10000;
448
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
449
    }
450

    
451
    if (s->is_vcd) {
452
        double overhead_rate;
453

    
454
        /* The VCD standard mandates that the mux_rate field is 3528
455
           (see standard p. IV-6).
456
           The value is actually "wrong", i.e. if you calculate
457
           it using the normal formula and the 75 sectors per second transfer
458
           rate you get a different value because the real pack size is 2324,
459
           not 2352. But the standard explicitly specifies that the mux_rate
460
           field in the header must have this value.*/
461
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
462

    
463
        /* The VCD standard states that the muxed stream must be
464
           exactly 75 packs / second (the data rate of a single speed cdrom).
465
           Since the video bitrate (probably 1150000 bits/sec) will be below
466
           the theoretical maximum we have to add some padding packets
467
           to make up for the lower data rate.
468
           (cf. VCD standard p. IV-6 )*/
469

    
470
        /* Add the header overhead to the data rate.
471
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
472
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
473
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
474
        overhead_rate *= 8;
475
        
476
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
477
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
478
    }
479
    
480
    if (s->is_vcd || s->is_mpeg2)
481
        /* every packet */
482
        s->pack_header_freq = 1;
483
    else
484
        /* every 2 seconds */
485
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
486

    
487
    /* the above seems to make pack_header_freq zero sometimes */
488
    if (s->pack_header_freq == 0)
489
       s->pack_header_freq = 1;
490
    
491
    if (s->is_mpeg2)
492
        /* every 200 packets. Need to look at the spec.  */
493
        s->system_header_freq = s->pack_header_freq * 40;
494
    else if (s->is_vcd)
495
        /* the standard mandates that there are only two system headers
496
           in the whole file: one in the first packet of each stream.
497
           (see standard p. IV-7 and IV-8) */
498
        s->system_header_freq = 0x7fffffff;
499
    else
500
        s->system_header_freq = s->pack_header_freq * 5;
501
    
502
    for(i=0;i<ctx->nb_streams;i++) {
503
        stream = ctx->streams[i]->priv_data;
504
        stream->packet_number = 0;
505
    }
506
    s->system_header_size = get_system_header_size(ctx);
507
    s->last_scr = 0;
508
    return 0;
509
 fail:
510
    for(i=0;i<ctx->nb_streams;i++) {
511
        av_free(ctx->streams[i]->priv_data);
512
    }
513
    return -ENOMEM;
514
}
515

    
516
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
517
{
518
    put_byte(pb, 
519
             (id << 4) | 
520
             (((timestamp >> 30) & 0x07) << 1) | 
521
             1);
522
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
523
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
524
}
525

    
526

    
527
/* return the number of padding bytes that should be inserted into
528
   the multiplexed stream.*/
529
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
530
{
531
    MpegMuxContext *s = ctx->priv_data;
532
    int pad_bytes = 0;
533

    
534
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
535
    {
536
        int64_t full_pad_bytes;
537
        
538
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
539
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
540

    
541
        if (pad_bytes<0)
542
            /* might happen if we have already padded to a later timestamp. This
543
               can occur if another stream has already advanced further.*/
544
            pad_bytes=0;
545
    }
546

    
547
    return pad_bytes;
548
}
549

    
550

    
551
#if 0 /* unused, remove? */
552
/* return the exact available payload size for the next packet for
553
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
554
   timestamps are needed in the packet header. */
555
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
556
                                   int64_t pts, int64_t dts)
557
{
558
    MpegMuxContext *s = ctx->priv_data;
559
    int buf_index;
560
    StreamInfo *stream;
561

562
    stream = ctx->streams[stream_index]->priv_data;
563

564
    buf_index = 0;
565
    if (((s->packet_number % s->pack_header_freq) == 0)) {
566
        /* pack header size */
567
        if (s->is_mpeg2) 
568
            buf_index += 14;
569
        else
570
            buf_index += 12;
571
        
572
        if (s->is_vcd) {
573
            /* there is exactly one system header for each stream in a VCD MPEG,
574
               One in the very first video packet and one in the very first
575
               audio packet (see VCD standard p. IV-7 and IV-8).*/
576
            
577
            if (stream->packet_number==0)
578
                /* The system headers refer only to the stream they occur in,
579
                   so they have a constant size.*/
580
                buf_index += 15;
581

582
        } else {            
583
            if ((s->packet_number % s->system_header_freq) == 0)
584
                buf_index += s->system_header_size;
585
        }
586
    }
587

588
    if ((s->is_vcd && stream->packet_number==0)
589
        || (s->is_svcd && s->packet_number==0))
590
        /* the first pack of each stream contains only the pack header,
591
           the system header and some padding (see VCD standard p. IV-6) 
592
           Add the padding size, so that the actual payload becomes 0.*/
593
        buf_index += s->packet_size - buf_index;
594
    else {
595
        /* packet header size */
596
        buf_index += 6;
597
        if (s->is_mpeg2) {
598
            buf_index += 3;
599
            if (stream->packet_number==0)
600
                buf_index += 3; /* PES extension */
601
            buf_index += 1;    /* obligatory stuffing byte */
602
        }
603
        if (pts != AV_NOPTS_VALUE) {
604
            if (dts != pts)
605
                buf_index += 5 + 5;
606
            else
607
                buf_index += 5;
608

609
        } else {
610
            if (!s->is_mpeg2)
611
                buf_index++;
612
        }
613
    
614
        if (stream->id < 0xc0) {
615
            /* AC3/LPCM private data header */
616
            buf_index += 4;
617
            if (stream->id >= 0xa0) {
618
                int n;
619
                buf_index += 3;
620
                /* NOTE: we round the payload size to an integer number of
621
                   LPCM samples */
622
                n = (s->packet_size - buf_index) % stream->lpcm_align;
623
                if (n)
624
                    buf_index += (stream->lpcm_align - n);
625
            }
626
        }
627

628
        if (s->is_vcd && stream->id == AUDIO_ID)
629
            /* The VCD standard demands that 20 zero bytes follow
630
               each audio packet (see standard p. IV-8).*/
631
            buf_index+=20;
632
    }
633
    return s->packet_size - buf_index; 
634
}
635
#endif
636

    
637
/* Write an MPEG padding packet header. */
638
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
639
{
640
    MpegMuxContext *s = ctx->priv_data;
641
    int i;
642
    
643
    put_be32(pb, PADDING_STREAM);
644
    put_be16(pb, packet_bytes - 6);
645
    if (!s->is_mpeg2) {
646
        put_byte(pb, 0x0f);
647
        packet_bytes -= 7;
648
    } else
649
        packet_bytes -= 6;
650

    
651
    for(i=0;i<packet_bytes;i++)
652
        put_byte(pb, 0xff);
653
}
654

    
655
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
656
    int nb_frames=0;
657
    PacketDesc *pkt_desc= stream->premux_packet;
658

    
659
    while(len>0){ 
660
        if(pkt_desc->size == pkt_desc->unwritten_size)
661
            nb_frames++;
662
        len -= pkt_desc->unwritten_size;
663
        pkt_desc= pkt_desc->next;
664
    }
665

    
666
    return nb_frames;
667
}
668

    
669
/* flush the packet on stream stream_index */
670
static int flush_packet(AVFormatContext *ctx, int stream_index, 
671
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
672
{
673
    MpegMuxContext *s = ctx->priv_data;
674
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
675
    uint8_t *buf_ptr;
676
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
677
    int packet_size;
678
    uint8_t buffer[128];
679
    int zero_trail_bytes = 0;
680
    int pad_packet_bytes = 0;
681
    int pes_flags;
682
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
683
    int nb_frames;
684
    
685
    id = stream->id;
686
    
687
#if 0
688
    printf("packet ID=%2x PTS=%0.3f\n", 
689
           id, pts / 90000.0);
690
#endif
691

    
692
    buf_ptr = buffer;
693

    
694
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
695
        /* output pack and systems header if needed */
696
        size = put_pack_header(ctx, buf_ptr, scr);
697
        buf_ptr += size;
698
        s->last_scr= scr;
699

    
700
        if (s->is_vcd) {
701
            /* there is exactly one system header for each stream in a VCD MPEG,
702
               One in the very first video packet and one in the very first
703
               audio packet (see VCD standard p. IV-7 and IV-8).*/
704
            
705
            if (stream->packet_number==0) {
706
                size = put_system_header(ctx, buf_ptr, id);
707
                buf_ptr += size;
708
            }
709
        } else if (s->is_dvd) {
710
            if (stream->align_iframe || s->packet_number == 0){
711
                int bytes_to_iframe;
712
                int PES_bytes_to_fill;
713
                if (stream->fifo_iframe_ptr >= stream->fifo.rptr) {
714
                    bytes_to_iframe = stream->fifo_iframe_ptr - stream->fifo.rptr;
715
                } else {
716
                    bytes_to_iframe = (stream->fifo.end - stream->fifo.rptr) + (stream->fifo_iframe_ptr - stream->fifo.buffer);
717
                }
718
                PES_bytes_to_fill = s->packet_size - size - 10;
719

    
720
                if (pts != AV_NOPTS_VALUE) {
721
                    if (dts != pts)
722
                        PES_bytes_to_fill -= 5 + 5;
723
                    else
724
                        PES_bytes_to_fill -= 5;
725
                }
726

    
727
                if (bytes_to_iframe == 0 || s->packet_number == 0) {
728
                    size = put_system_header(ctx, buf_ptr, 0);
729
                    buf_ptr += size;
730
                    size = buf_ptr - buffer;
731
                    put_buffer(&ctx->pb, buffer, size);
732

    
733
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
734
                    put_be16(&ctx->pb, 0x03d4);         // length
735
                    put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
736
                    for (i = 0; i < 979; i++)
737
                        put_byte(&ctx->pb, 0x00);
738

    
739
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
740
                    put_be16(&ctx->pb, 0x03fa);         // length
741
                    put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
742
                    for (i = 0; i < 1017; i++)
743
                        put_byte(&ctx->pb, 0x00);
744

    
745
                    memset(buffer, 0, 128);
746
                    buf_ptr = buffer;
747
                    s->packet_number++;
748
                    stream->align_iframe = 0;
749
                    scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
750
                    size = put_pack_header(ctx, buf_ptr, scr);
751
                    s->last_scr= scr;
752
                    buf_ptr += size;
753
                    /* GOP Start */
754
                } else if (bytes_to_iframe < PES_bytes_to_fill) {
755
                    pad_packet_bytes = PES_bytes_to_fill - bytes_to_iframe;
756
                }
757
            }
758
        } else {
759
            if ((s->packet_number % s->system_header_freq) == 0) {
760
                size = put_system_header(ctx, buf_ptr, 0);
761
                buf_ptr += size;
762
            }
763
        }
764
    }
765
    size = buf_ptr - buffer;
766
    put_buffer(&ctx->pb, buffer, size);
767

    
768
    packet_size = s->packet_size - size;
769

    
770
    if (s->is_vcd && id == AUDIO_ID)
771
        /* The VCD standard demands that 20 zero bytes follow
772
           each audio pack (see standard p. IV-8).*/
773
        zero_trail_bytes += 20;
774
            
775
    if ((s->is_vcd && stream->packet_number==0)
776
        || (s->is_svcd && s->packet_number==0)) {
777
        /* for VCD the first pack of each stream contains only the pack header,
778
           the system header and lots of padding (see VCD standard p. IV-6).
779
           In the case of an audio pack, 20 zero bytes are also added at
780
           the end.*/
781
        /* For SVCD we fill the very first pack to increase compatibility with
782
           some DVD players. Not mandated by the standard.*/
783
        if (s->is_svcd)
784
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
785
        pad_packet_bytes = packet_size - zero_trail_bytes;
786
    }
787

    
788
    packet_size -= pad_packet_bytes + zero_trail_bytes;
789

    
790
    if (packet_size > 0) {
791

    
792
        /* packet header size */
793
        packet_size -= 6;
794
        
795
        /* packet header */
796
        if (s->is_mpeg2) {
797
            header_len = 3;
798
            if (stream->packet_number==0)
799
                header_len += 3; /* PES extension */
800
            header_len += 1; /* obligatory stuffing byte */
801
        } else {
802
            header_len = 0;
803
        }
804
        if (pts != AV_NOPTS_VALUE) {
805
            if (dts != pts)
806
                header_len += 5 + 5;
807
            else
808
                header_len += 5;
809
        } else {
810
            if (!s->is_mpeg2)
811
                header_len++;
812
        }
813

    
814
        payload_size = packet_size - header_len;
815
        if (id < 0xc0) {
816
            startcode = PRIVATE_STREAM_1;
817
            payload_size -= 1;
818
            if (id >= 0x40) {
819
                payload_size -= 3;
820
                if (id >= 0xa0)
821
                    payload_size -= 3;
822
            }
823
        } else {
824
            startcode = 0x100 + id;
825
        }
826

    
827
        stuffing_size = payload_size - fifo_size(&stream->fifo, stream->fifo.rptr);
828

    
829
        // first byte doesnt fit -> reset pts/dts + stuffing
830
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
831
            int timestamp_len=0;
832
            if(dts != pts) 
833
                timestamp_len += 5;
834
            if(pts != AV_NOPTS_VALUE)
835
                timestamp_len += s->is_mpeg2 ? 5 : 4;
836
            pts=dts= AV_NOPTS_VALUE;
837
            header_len -= timestamp_len;
838
            if (s->is_dvd && stream->align_iframe) {
839
                pad_packet_bytes += timestamp_len;
840
                packet_size -= timestamp_len;
841
            } else {
842
                payload_size += timestamp_len;
843
            }
844
            stuffing_size += timestamp_len;
845
            if(payload_size > trailer_size)
846
                stuffing_size += payload_size - trailer_size;
847
        }
848

    
849
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
850
            packet_size += pad_packet_bytes;
851
            payload_size += pad_packet_bytes; // undo the previous adjustment
852
            if (stuffing_size < 0) {
853
                stuffing_size = pad_packet_bytes;
854
            } else {
855
                stuffing_size += pad_packet_bytes;
856
            }
857
            pad_packet_bytes = 0;
858
        }
859

    
860
        if (stuffing_size < 0)
861
            stuffing_size = 0;
862
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
863
            pad_packet_bytes += stuffing_size;
864
            packet_size -= stuffing_size;
865
            payload_size -= stuffing_size;
866
            stuffing_size = 0;
867
        }
868
        
869
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
870

    
871
        put_be32(&ctx->pb, startcode);
872

    
873
        put_be16(&ctx->pb, packet_size);
874
        
875
        if (!s->is_mpeg2)
876
            for(i=0;i<stuffing_size;i++)
877
                put_byte(&ctx->pb, 0xff);
878

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

    
882
            pes_flags=0;
883

    
884
            if (pts != AV_NOPTS_VALUE) {
885
                pes_flags |= 0x80;
886
                if (dts != pts)
887
                    pes_flags |= 0x40;
888
            }
889

    
890
            /* Both the MPEG-2 and the SVCD standards demand that the
891
               P-STD_buffer_size field be included in the first packet of
892
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
893
               and MPEG-2 standard 2.7.7) */
894
            if (stream->packet_number == 0)
895
                pes_flags |= 0x01;
896

    
897
            put_byte(&ctx->pb, pes_flags); /* flags */
898
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
899

    
900
            if (pes_flags & 0x80)  /*write pts*/
901
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
902
            if (pes_flags & 0x40)  /*write dts*/
903
                put_timestamp(&ctx->pb, 0x01, dts);
904
            
905
            if (pes_flags & 0x01) {  /*write pes extension*/
906
                put_byte(&ctx->pb, 0x10); /* flags */
907

    
908
                /* P-STD buffer info */                
909
                if (id == AUDIO_ID)
910
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
911
                else
912
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
913
            }
914

    
915
        } else {
916
            if (pts != AV_NOPTS_VALUE) {
917
                if (dts != pts) {
918
                    put_timestamp(&ctx->pb, 0x03, pts);
919
                    put_timestamp(&ctx->pb, 0x01, dts);
920
                } else {
921
                    put_timestamp(&ctx->pb, 0x02, pts);
922
                }
923
            } else {
924
                put_byte(&ctx->pb, 0x0f);
925
            }
926
        }
927

    
928
        if (s->is_mpeg2) {
929
            /* special stuffing byte that is always written
930
               to prevent accidental generation of start codes. */
931
            put_byte(&ctx->pb, 0xff);
932

    
933
            for(i=0;i<stuffing_size;i++)
934
                put_byte(&ctx->pb, 0xff);
935
        }
936

    
937
        if (startcode == PRIVATE_STREAM_1) {
938
            put_byte(&ctx->pb, id);
939
            if (id >= 0xa0) {
940
                /* LPCM (XXX: check nb_frames) */
941
                put_byte(&ctx->pb, 7);
942
                put_be16(&ctx->pb, 4); /* skip 3 header bytes */
943
                put_byte(&ctx->pb, stream->lpcm_header[0]);
944
                put_byte(&ctx->pb, stream->lpcm_header[1]);
945
                put_byte(&ctx->pb, stream->lpcm_header[2]);
946
            } else if (id >= 0x40) {
947
                /* AC3 */
948
                put_byte(&ctx->pb, nb_frames);
949
                put_be16(&ctx->pb, trailer_size+1);
950
            }
951
        }
952

    
953
        /* output data */
954
        if(put_fifo(&ctx->pb, &stream->fifo, payload_size - stuffing_size, &stream->fifo.rptr) < 0)
955
            return -1;
956
    }else{
957
        payload_size=
958
        stuffing_size= 0;
959
    }
960

    
961
    if (pad_packet_bytes > 0)
962
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);    
963

    
964
    for(i=0;i<zero_trail_bytes;i++)
965
        put_byte(&ctx->pb, 0x00);
966
        
967
    put_flush_packet(&ctx->pb);
968
    
969
    s->packet_number++;
970

    
971
    /* only increase the stream packet number if this pack actually contains
972
       something that is specific to this stream! I.e. a dedicated header
973
       or some data.*/
974
    if (!general_pack)
975
        stream->packet_number++;
976
    
977
    return payload_size - stuffing_size;
978
}
979

    
980
static void put_vcd_padding_sector(AVFormatContext *ctx)
981
{
982
    /* There are two ways to do this padding: writing a sector/pack
983
       of 0 values, or writing an MPEG padding pack. Both seem to
984
       work with most decoders, BUT the VCD standard only allows a 0-sector
985
       (see standard p. IV-4, IV-5).
986
       So a 0-sector it is...*/
987

    
988
    MpegMuxContext *s = ctx->priv_data;
989
    int i;
990

    
991
    for(i=0;i<s->packet_size;i++)
992
        put_byte(&ctx->pb, 0);
993

    
994
    s->vcd_padding_bytes_written += s->packet_size;
995
        
996
    put_flush_packet(&ctx->pb);
997
    
998
    /* increasing the packet number is correct. The SCR of the following packs
999
       is calculated from the packet_number and it has to include the padding
1000
       sector (it represents the sector index, not the MPEG pack index)
1001
       (see VCD standard p. IV-6)*/
1002
    s->packet_number++;
1003
}
1004

    
1005
#if 0 /* unused, remove? */
1006
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
1007
{
1008
    MpegMuxContext *s = ctx->priv_data;
1009
    int64_t scr;
1010

1011
        /* Since the data delivery rate is constant, SCR is computed
1012
           using the formula C + i * 1200 where C is the start constant
1013
           and i is the pack index.
1014
           It is recommended that SCR 0 is at the beginning of the VCD front
1015
           margin (a sequence of empty Form 2 sectors on the CD).
1016
           It is recommended that the front margin is 30 sectors long, so
1017
           we use C = 30*1200 = 36000
1018
           (Note that even if the front margin is not 30 sectors the file
1019
           will still be correct according to the standard. It just won't have
1020
           the "recommended" value).*/
1021
        scr = 36000 + s->packet_number * 1200;
1022

1023
    return scr;
1024
}    
1025
#endif
1026

    
1027
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1028
//    MpegMuxContext *s = ctx->priv_data;
1029
    int i;
1030

    
1031
    for(i=0; i<ctx->nb_streams; i++){
1032
        AVStream *st = ctx->streams[i];
1033
        StreamInfo *stream = st->priv_data;
1034
        PacketDesc *pkt_desc= stream->predecode_packet;
1035
        
1036
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1037
            if(stream->buffer_index < pkt_desc->size || 
1038
               stream->predecode_packet == stream->premux_packet){
1039
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1040
                break;
1041
            }
1042
            stream->buffer_index -= pkt_desc->size;
1043

    
1044
            stream->predecode_packet= pkt_desc->next;
1045
            av_freep(&pkt_desc);
1046
        }
1047
    }
1048
    
1049
    return 0;
1050
}
1051

    
1052
static int output_packet(AVFormatContext *ctx, int flush){
1053
    MpegMuxContext *s = ctx->priv_data;
1054
    AVStream *st;
1055
    StreamInfo *stream;
1056
    int i, avail_space, es_size, trailer_size;
1057
    int best_i= -1;
1058
    int best_score= INT_MIN;
1059
    int ignore_constraints=0;
1060
    int64_t scr= s->last_scr;
1061
    PacketDesc *timestamp_packet;
1062
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1063

    
1064
retry:
1065
    for(i=0; i<ctx->nb_streams; i++){
1066
        AVStream *st = ctx->streams[i];
1067
        StreamInfo *stream = st->priv_data;
1068
        const int avail_data=  fifo_size(&stream->fifo, stream->fifo.rptr);
1069
        const int space= stream->max_buffer_size - stream->buffer_index;
1070
        int rel_space= 1024*space / stream->max_buffer_size;
1071
        PacketDesc *next_pkt= stream->premux_packet;
1072

    
1073
        /* for subtitle, a single PES packet must be generated,
1074
           so we flush after every single subtitle packet */
1075
        if(s->packet_size > avail_data && !flush
1076
           && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1077
            return 0;
1078
        if(avail_data==0)
1079
            continue;
1080
        assert(avail_data>0);
1081

    
1082
        if(space < s->packet_size && !ignore_constraints)
1083
            continue;
1084
            
1085
        if(next_pkt && next_pkt->dts - scr > max_delay)
1086
            continue;
1087
            
1088
        if(rel_space > best_score){
1089
            best_score= rel_space;
1090
            best_i = i;
1091
            avail_space= space;
1092
        }
1093
    }
1094
    
1095
    if(best_i < 0){
1096
        int64_t best_dts= INT64_MAX;
1097

    
1098
        for(i=0; i<ctx->nb_streams; i++){
1099
            AVStream *st = ctx->streams[i];
1100
            StreamInfo *stream = st->priv_data;
1101
            PacketDesc *pkt_desc= stream->predecode_packet;
1102
            if(pkt_desc && pkt_desc->dts < best_dts)
1103
                best_dts= pkt_desc->dts;
1104
        }
1105

    
1106
#if 0
1107
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n", 
1108
               scr/90000.0, best_dts/90000.0);
1109
#endif
1110
        if(best_dts == INT64_MAX)
1111
            return 0;
1112

    
1113
        if(scr >= best_dts+1 && !ignore_constraints){
1114
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1115
            ignore_constraints= 1;
1116
        }
1117
        scr= FFMAX(best_dts+1, scr);
1118
        if(remove_decoded_packets(ctx, scr) < 0)
1119
            return -1;
1120
        goto retry;
1121
    }
1122

    
1123
    assert(best_i >= 0);
1124
    
1125
    st = ctx->streams[best_i];
1126
    stream = st->priv_data;
1127
    
1128
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
1129

    
1130
    assert(avail_space >= s->packet_size || ignore_constraints);
1131
    
1132
    timestamp_packet= stream->premux_packet;
1133
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1134
        trailer_size= 0;
1135
    }else{
1136
        trailer_size= timestamp_packet->unwritten_size;
1137
        timestamp_packet= timestamp_packet->next;
1138
    }
1139

    
1140
    if(timestamp_packet){
1141
//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f scr:%f stream:%d\n", timestamp_packet->dts/90000.0, timestamp_packet->pts/90000.0, scr/90000.0, best_i);
1142
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1143
    }else{
1144
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == trailer_size);
1145
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1146
    }
1147

    
1148
    if (s->is_vcd) {
1149
        /* Write one or more padding sectors, if necessary, to reach
1150
           the constant overall bitrate.*/
1151
        int vcd_pad_bytes;
1152

    
1153
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1154
            put_vcd_padding_sector(ctx);
1155
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1156
        }
1157
    }
1158
    
1159
    stream->buffer_index += es_size;
1160
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1161
    
1162
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1163
        es_size -= stream->premux_packet->unwritten_size;
1164
        stream->premux_packet= stream->premux_packet->next;
1165
    }
1166
    if(es_size)
1167
        stream->premux_packet->unwritten_size -= es_size;
1168
    
1169
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1170
        return -1;
1171

    
1172
    return 1;
1173
}
1174

    
1175
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1176
{
1177
    MpegMuxContext *s = ctx->priv_data;
1178
    int stream_index= pkt->stream_index;
1179
    int size= pkt->size;
1180
    uint8_t *buf= pkt->data;
1181
    AVStream *st = ctx->streams[stream_index];
1182
    StreamInfo *stream = st->priv_data;
1183
    int64_t pts, dts;
1184
    PacketDesc *pkt_desc;
1185
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1186
    const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1187
    
1188
    pts= pkt->pts;
1189
    dts= pkt->dts;
1190

    
1191
    if(pts != AV_NOPTS_VALUE) pts += preload;
1192
    if(dts != AV_NOPTS_VALUE) dts += preload;
1193

    
1194
//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index, pts != AV_NOPTS_VALUE);
1195
    if (!stream->premux_packet)
1196
        stream->next_packet = &stream->premux_packet;
1197
    *stream->next_packet=
1198
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1199
    pkt_desc->pts= pts;
1200
    pkt_desc->dts= dts;
1201
    pkt_desc->unwritten_size=
1202
    pkt_desc->size= size;
1203
    if(!stream->predecode_packet)
1204
        stream->predecode_packet= pkt_desc;
1205
    stream->next_packet= &pkt_desc->next;
1206

    
1207
    fifo_realloc(&stream->fifo, fifo_size(&stream->fifo, NULL) + size + 1);
1208

    
1209
    if (s->is_dvd){
1210
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1211
            stream->fifo_iframe_ptr = stream->fifo.wptr;
1212
            stream->align_iframe = 1;
1213
            stream->vobu_start_pts = pts;
1214
        } else {
1215
            stream->align_iframe = 0;
1216
        }
1217
    }
1218

    
1219
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1220

    
1221
    for(;;){
1222
        int ret= output_packet(ctx, 0);
1223
        if(ret<=0) 
1224
            return ret;
1225
    }
1226
}
1227

    
1228
static int mpeg_mux_end(AVFormatContext *ctx)
1229
{
1230
//    MpegMuxContext *s = ctx->priv_data;
1231
    StreamInfo *stream;
1232
    int i;
1233
    
1234
    for(;;){
1235
        int ret= output_packet(ctx, 1);
1236
        if(ret<0) 
1237
            return ret;
1238
        else if(ret==0)
1239
            break;
1240
    }
1241

    
1242
    /* End header according to MPEG1 systems standard. We do not write
1243
       it as it is usually not needed by decoders and because it
1244
       complicates MPEG stream concatenation. */
1245
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1246
    //put_flush_packet(&ctx->pb);
1247

    
1248
    for(i=0;i<ctx->nb_streams;i++) {
1249
        stream = ctx->streams[i]->priv_data;
1250

    
1251
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1252
        fifo_free(&stream->fifo);
1253
    }
1254
    return 0;
1255
}
1256
#endif //CONFIG_MUXERS
1257

    
1258
/*********************************************/
1259
/* demux code */
1260

    
1261
#define MAX_SYNC_SIZE 100000
1262

    
1263
static int mpegps_probe(AVProbeData *p)
1264
{
1265
    int i;
1266
    int size= FFMIN(20, p->buf_size);
1267
    uint32_t code=0xFF;
1268

    
1269
    /* we search the first start code. If it is a packet start code,
1270
       then we decide it is mpeg ps. We do not send highest value to
1271
       give a chance to mpegts */
1272
    /* NOTE: the search range was restricted to avoid too many false
1273
       detections */
1274

    
1275
    for (i = 0; i < size; i++) {
1276
        code = (code << 8) | p->buf[i];
1277
        if ((code & 0xffffff00) == 0x100) {
1278
            if (code == PACK_START_CODE ||
1279
                code == SYSTEM_HEADER_START_CODE ||
1280
                (code >= 0x1e0 && code <= 0x1ef) ||
1281
                (code >= 0x1c0 && code <= 0x1df) ||
1282
                code == PRIVATE_STREAM_2 ||
1283
                code == PROGRAM_STREAM_MAP ||
1284
                code == PRIVATE_STREAM_1 ||
1285
                code == PADDING_STREAM)
1286
                return AVPROBE_SCORE_MAX - 2;
1287
            else
1288
                return 0;
1289
        }
1290
    }
1291
    return 0;
1292
}
1293

    
1294

    
1295
typedef struct MpegDemuxContext {
1296
    int header_state;
1297
    unsigned char psm_es_type[256];
1298
} MpegDemuxContext;
1299

    
1300
static int mpegps_read_header(AVFormatContext *s,
1301
                              AVFormatParameters *ap)
1302
{
1303
    MpegDemuxContext *m = s->priv_data;
1304
    m->header_state = 0xff;
1305
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1306

    
1307
    /* no need to do more */
1308
    return 0;
1309
}
1310

    
1311
static int64_t get_pts(ByteIOContext *pb, int c)
1312
{
1313
    int64_t pts;
1314
    int val;
1315

    
1316
    if (c < 0)
1317
        c = get_byte(pb);
1318
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1319
    val = get_be16(pb);
1320
    pts |= (int64_t)(val >> 1) << 15;
1321
    val = get_be16(pb);
1322
    pts |= (int64_t)(val >> 1);
1323
    return pts;
1324
}
1325

    
1326
static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1327
                                uint32_t *header_state)
1328
{
1329
    unsigned int state, v;
1330
    int val, n;
1331

    
1332
    state = *header_state;
1333
    n = *size_ptr;
1334
    while (n > 0) {
1335
        if (url_feof(pb))
1336
            break;
1337
        v = get_byte(pb);
1338
        n--;
1339
        if (state == 0x000001) {
1340
            state = ((state << 8) | v) & 0xffffff;
1341
            val = state;
1342
            goto found;
1343
        }
1344
        state = ((state << 8) | v) & 0xffffff;
1345
    }
1346
    val = -1;
1347
 found:
1348
    *header_state = state;
1349
    *size_ptr = n;
1350
    return val;
1351
}
1352

    
1353
#if 0 /* unused, remove? */
1354
/* XXX: optimize */
1355
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1356
{
1357
    int64_t pos, pos_start;
1358
    int max_size, start_code;
1359

1360
    max_size = *size_ptr;
1361
    pos_start = url_ftell(pb);
1362

1363
    /* in order to go faster, we fill the buffer */
1364
    pos = pos_start - 16386;
1365
    if (pos < 0)
1366
        pos = 0;
1367
    url_fseek(pb, pos, SEEK_SET);
1368
    get_byte(pb);
1369

1370
    pos = pos_start;
1371
    for(;;) {
1372
        pos--;
1373
        if (pos < 0 || (pos_start - pos) >= max_size) {
1374
            start_code = -1;
1375
            goto the_end;
1376
        }
1377
        url_fseek(pb, pos, SEEK_SET);
1378
        start_code = get_be32(pb);
1379
        if ((start_code & 0xffffff00) == 0x100)
1380
            break;
1381
    }
1382
 the_end:
1383
    *size_ptr = pos_start - pos;
1384
    return start_code;
1385
}
1386
#endif
1387

    
1388
/**
1389
 * Extracts stream types from a program stream map
1390
 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1391
 * 
1392
 * @return number of bytes occupied by PSM in the bitstream
1393
 */
1394
static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1395
{
1396
    int psm_length, ps_info_length, es_map_length;
1397

    
1398
    psm_length = get_be16(pb);
1399
    get_byte(pb);
1400
    get_byte(pb);
1401
    ps_info_length = get_be16(pb);
1402

    
1403
    /* skip program_stream_info */
1404
    url_fskip(pb, ps_info_length);
1405
    es_map_length = get_be16(pb);
1406

    
1407
    /* at least one es available? */
1408
    while (es_map_length >= 4){
1409
        unsigned char type = get_byte(pb);
1410
        unsigned char es_id = get_byte(pb);
1411
        uint16_t es_info_length = get_be16(pb);
1412
        /* remember mapping from stream id to stream type */
1413
        m->psm_es_type[es_id] = type;
1414
        /* skip program_stream_info */
1415
        url_fskip(pb, es_info_length);
1416
        es_map_length -= 4 + es_info_length;
1417
    }
1418
    get_be32(pb); /* crc32 */
1419
    return 2 + psm_length;
1420
}
1421

    
1422
/* read the next PES header. Return its position in ppos 
1423
   (if not NULL), and its start code, pts and dts.
1424
 */
1425
static int mpegps_read_pes_header(AVFormatContext *s,
1426
                                  int64_t *ppos, int *pstart_code, 
1427
                                  int64_t *ppts, int64_t *pdts)
1428
{
1429
    MpegDemuxContext *m = s->priv_data;
1430
    int len, size, startcode, c, flags, header_len;
1431
    int64_t pts, dts, last_pos;
1432

    
1433
    last_pos = -1;
1434
 redo:
1435
        /* next start code (should be immediately after) */
1436
        m->header_state = 0xff;
1437
        size = MAX_SYNC_SIZE;
1438
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1439
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1440
    if (startcode < 0)
1441
        return AVERROR_IO;
1442
    if (startcode == PACK_START_CODE)
1443
        goto redo;
1444
    if (startcode == SYSTEM_HEADER_START_CODE)
1445
        goto redo;
1446
    if (startcode == PADDING_STREAM ||
1447
        startcode == PRIVATE_STREAM_2) {
1448
        /* skip them */
1449
        len = get_be16(&s->pb);
1450
        url_fskip(&s->pb, len);
1451
        goto redo;
1452
    }
1453
    if (startcode == PROGRAM_STREAM_MAP) {
1454
        mpegps_psm_parse(m, &s->pb);
1455
        goto redo;
1456
    }
1457
    
1458
    /* find matching stream */
1459
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1460
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1461
          (startcode == 0x1bd)))
1462
        goto redo;
1463
    if (ppos) {
1464
        *ppos = url_ftell(&s->pb) - 4;
1465
    }
1466
    len = get_be16(&s->pb);
1467
    pts = AV_NOPTS_VALUE;
1468
    dts = AV_NOPTS_VALUE;
1469
    /* stuffing */
1470
    for(;;) {
1471
        if (len < 1)
1472
            goto redo;
1473
        c = get_byte(&s->pb);
1474
        len--;
1475
        /* XXX: for mpeg1, should test only bit 7 */
1476
        if (c != 0xff) 
1477
            break;
1478
    }
1479
    if ((c & 0xc0) == 0x40) {
1480
        /* buffer scale & size */
1481
        if (len < 2)
1482
            goto redo;
1483
        get_byte(&s->pb);
1484
        c = get_byte(&s->pb);
1485
        len -= 2;
1486
    }
1487
    if ((c & 0xf0) == 0x20) {
1488
        if (len < 4)
1489
            goto redo;
1490
        dts = pts = get_pts(&s->pb, c);
1491
        len -= 4;
1492
    } else if ((c & 0xf0) == 0x30) {
1493
        if (len < 9)
1494
            goto redo;
1495
        pts = get_pts(&s->pb, c);
1496
        dts = get_pts(&s->pb, -1);
1497
        len -= 9;
1498
    } else if ((c & 0xc0) == 0x80) {
1499
        /* mpeg 2 PES */
1500
        if ((c & 0x30) != 0) {
1501
            /* Encrypted multiplex not handled */
1502
            goto redo;
1503
        }
1504
        flags = get_byte(&s->pb);
1505
        header_len = get_byte(&s->pb);
1506
        len -= 2;
1507
        if (header_len > len)
1508
            goto redo;
1509
        if ((flags & 0xc0) == 0x80) {
1510
            dts = pts = get_pts(&s->pb, -1);
1511
            if (header_len < 5)
1512
                goto redo;
1513
            header_len -= 5;
1514
            len -= 5;
1515
        } if ((flags & 0xc0) == 0xc0) {
1516
            pts = get_pts(&s->pb, -1);
1517
            dts = get_pts(&s->pb, -1);
1518
            if (header_len < 10)
1519
                goto redo;
1520
            header_len -= 10;
1521
            len -= 10;
1522
        }
1523
        len -= header_len;
1524
        while (header_len > 0) {
1525
            get_byte(&s->pb);
1526
            header_len--;
1527
        }
1528
    }
1529
    else if( c!= 0xf )
1530
        goto redo;
1531

    
1532
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1533
        if (len < 1)
1534
            goto redo;
1535
        startcode = get_byte(&s->pb);
1536
        len--;
1537
        if (startcode >= 0x80 && startcode <= 0xbf) {
1538
            /* audio: skip header */
1539
            if (len < 3)
1540
                goto redo;
1541
            get_byte(&s->pb);
1542
            get_byte(&s->pb);
1543
            get_byte(&s->pb);
1544
            len -= 3;
1545
        }
1546
    }
1547
    if(dts != AV_NOPTS_VALUE && ppos){
1548
        int i;
1549
        for(i=0; i<s->nb_streams; i++){
1550
            if(startcode == s->streams[i]->id) {
1551
                av_add_index_entry(s->streams[i], *ppos, dts, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1552
            }
1553
        }
1554
    }
1555
    
1556
    *pstart_code = startcode;
1557
    *ppts = pts;
1558
    *pdts = dts;
1559
    return len;
1560
}
1561

    
1562
static int mpegps_read_packet(AVFormatContext *s,
1563
                              AVPacket *pkt)
1564
{
1565
    MpegDemuxContext *m = s->priv_data;
1566
    AVStream *st;
1567
    int len, startcode, i, type, codec_id = 0, es_type;
1568
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1569

    
1570
 redo:
1571
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1572
    if (len < 0)
1573
        return len;
1574
    
1575
    /* now find stream */
1576
    for(i=0;i<s->nb_streams;i++) {
1577
        st = s->streams[i];
1578
        if (st->id == startcode)
1579
            goto found;
1580
    }
1581

    
1582
    es_type = m->psm_es_type[startcode & 0xff];
1583
    if(es_type > 0){
1584
        if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1585
            codec_id = CODEC_ID_MPEG2VIDEO;
1586
            type = CODEC_TYPE_VIDEO;
1587
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1588
            codec_id = CODEC_ID_MPEG2VIDEO;
1589
            type = CODEC_TYPE_VIDEO;
1590
        } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1591
                  es_type == STREAM_TYPE_AUDIO_MPEG2){
1592
            codec_id = CODEC_ID_MP3;
1593
            type = CODEC_TYPE_AUDIO;
1594
        } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1595
            codec_id = CODEC_ID_AAC;
1596
            type = CODEC_TYPE_AUDIO;
1597
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1598
            codec_id = CODEC_ID_MPEG4;
1599
            type = CODEC_TYPE_VIDEO;
1600
        } else if(es_type == STREAM_TYPE_VIDEO_H264){
1601
            codec_id = CODEC_ID_H264;
1602
            type = CODEC_TYPE_VIDEO;
1603
        } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1604
            codec_id = CODEC_ID_AC3;
1605
            type = CODEC_TYPE_AUDIO;
1606
        } else {
1607
            goto skip;
1608
        }
1609
    } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1610
        type = CODEC_TYPE_VIDEO;
1611
        codec_id = CODEC_ID_MPEG2VIDEO;
1612
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1613
        type = CODEC_TYPE_AUDIO;
1614
        codec_id = CODEC_ID_MP2;
1615
    } else if (startcode >= 0x80 && startcode <= 0x87) {
1616
        type = CODEC_TYPE_AUDIO;
1617
        codec_id = CODEC_ID_AC3;
1618
    } else if (startcode >= 0x88 && startcode <= 0x9f) {
1619
        type = CODEC_TYPE_AUDIO;
1620
        codec_id = CODEC_ID_DTS;
1621
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1622
        type = CODEC_TYPE_AUDIO;
1623
        codec_id = CODEC_ID_PCM_S16BE;
1624
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
1625
        type = CODEC_TYPE_SUBTITLE;
1626
        codec_id = CODEC_ID_DVD_SUBTITLE;
1627
    } else {
1628
    skip:
1629
        /* skip packet */
1630
        url_fskip(&s->pb, len);
1631
        goto redo;
1632
    }
1633
    /* no stream found: add a new stream */
1634
    st = av_new_stream(s, startcode);
1635
    if (!st) 
1636
        goto skip;
1637
    st->codec->codec_type = type;
1638
    st->codec->codec_id = codec_id;
1639
    if (codec_id != CODEC_ID_PCM_S16BE)
1640
        st->need_parsing = 1;
1641
 found:
1642
    if(st->discard >= AVDISCARD_ALL)
1643
        goto skip;
1644
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1645
        int b1, freq;
1646

    
1647
        /* for LPCM, we just skip the header and consider it is raw
1648
           audio data */
1649
        if (len <= 3)
1650
            goto skip;
1651
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1652
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1653
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1654
        len -= 3;
1655
        freq = (b1 >> 4) & 3;
1656
        st->codec->sample_rate = lpcm_freq_tab[freq];
1657
        st->codec->channels = 1 + (b1 & 7);
1658
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1659
    }
1660
    av_new_packet(pkt, len);
1661
    get_buffer(&s->pb, pkt->data, pkt->size);
1662
    pkt->pts = pts;
1663
    pkt->dts = dts;
1664
    pkt->stream_index = st->index;
1665
#if 0
1666
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1667
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1668
#endif
1669

    
1670
    return 0;
1671
}
1672

    
1673
static int mpegps_read_close(AVFormatContext *s)
1674
{
1675
    return 0;
1676
}
1677

    
1678
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1679
                               int64_t *ppos, int64_t pos_limit)
1680
{
1681
    int len, startcode;
1682
    int64_t pos, pts, dts;
1683

    
1684
    pos = *ppos;
1685
#ifdef DEBUG_SEEK
1686
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1687
#endif
1688
    url_fseek(&s->pb, pos, SEEK_SET);
1689
    for(;;) {
1690
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1691
        if (len < 0) {
1692
#ifdef DEBUG_SEEK
1693
            printf("none (ret=%d)\n", len);
1694
#endif
1695
            return AV_NOPTS_VALUE;
1696
        }
1697
        if (startcode == s->streams[stream_index]->id && 
1698
            dts != AV_NOPTS_VALUE) {
1699
            break;
1700
        }
1701
        url_fskip(&s->pb, len);
1702
    }
1703
#ifdef DEBUG_SEEK
1704
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1705
#endif
1706
    *ppos = pos;
1707
    return dts;
1708
}
1709

    
1710
#ifdef CONFIG_MUXERS
1711
static AVOutputFormat mpeg1system_mux = {
1712
    "mpeg",
1713
    "MPEG1 System format",
1714
    "video/mpeg",
1715
    "mpg,mpeg",
1716
    sizeof(MpegMuxContext),
1717
    CODEC_ID_MP2,
1718
    CODEC_ID_MPEG1VIDEO,
1719
    mpeg_mux_init,
1720
    mpeg_mux_write_packet,
1721
    mpeg_mux_end,
1722
};
1723

    
1724
static AVOutputFormat mpeg1vcd_mux = {
1725
    "vcd",
1726
    "MPEG1 System format (VCD)",
1727
    "video/mpeg",
1728
    NULL,
1729
    sizeof(MpegMuxContext),
1730
    CODEC_ID_MP2,
1731
    CODEC_ID_MPEG1VIDEO,
1732
    mpeg_mux_init,
1733
    mpeg_mux_write_packet,
1734
    mpeg_mux_end,
1735
};
1736

    
1737
static AVOutputFormat mpeg2vob_mux = {
1738
    "vob",
1739
    "MPEG2 PS format (VOB)",
1740
    "video/mpeg",
1741
    "vob",
1742
    sizeof(MpegMuxContext),
1743
    CODEC_ID_MP2,
1744
    CODEC_ID_MPEG2VIDEO,
1745
    mpeg_mux_init,
1746
    mpeg_mux_write_packet,
1747
    mpeg_mux_end,
1748
};
1749

    
1750
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1751
static AVOutputFormat mpeg2svcd_mux = {
1752
    "svcd",
1753
    "MPEG2 PS format (VOB)",
1754
    "video/mpeg",
1755
    "vob",
1756
    sizeof(MpegMuxContext),
1757
    CODEC_ID_MP2,
1758
    CODEC_ID_MPEG2VIDEO,
1759
    mpeg_mux_init,
1760
    mpeg_mux_write_packet,
1761
    mpeg_mux_end,
1762
};
1763

    
1764
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1765
static AVOutputFormat mpeg2dvd_mux = {
1766
    "dvd",
1767
    "MPEG2 PS format (DVD VOB)",
1768
    "video/mpeg",
1769
    "dvd",
1770
    sizeof(MpegMuxContext),
1771
    CODEC_ID_MP2,
1772
    CODEC_ID_MPEG2VIDEO,
1773
    mpeg_mux_init,
1774
    mpeg_mux_write_packet,
1775
    mpeg_mux_end,
1776
};
1777

    
1778
#endif //CONFIG_MUXERS
1779

    
1780
AVInputFormat mpegps_demux = {
1781
    "mpeg",
1782
    "MPEG PS format",
1783
    sizeof(MpegDemuxContext),
1784
    mpegps_probe,
1785
    mpegps_read_header,
1786
    mpegps_read_packet,
1787
    mpegps_read_close,
1788
    NULL, //mpegps_read_seek,
1789
    mpegps_read_dts,
1790
    .flags = AVFMT_SHOW_IDS,
1791
};
1792

    
1793
int mpegps_init(void)
1794
{
1795
#ifdef CONFIG_MUXERS
1796
    av_register_output_format(&mpeg1system_mux);
1797
    av_register_output_format(&mpeg1vcd_mux);
1798
    av_register_output_format(&mpeg2vob_mux);
1799
    av_register_output_format(&mpeg2svcd_mux);
1800
    av_register_output_format(&mpeg2dvd_mux);
1801
#endif //CONFIG_MUXERS
1802
    av_register_input_format(&mpegps_demux);
1803
    return 0;
1804
}