Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ f5a478f6

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
 */
19
#include "avformat.h"
20
#include "bitstream.h"
21
#include "fifo.h"
22

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

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

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

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

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

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

    
73
} MpegMuxContext;
74

    
75
#define PACK_START_CODE             ((unsigned int)0x000001ba)
76
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
77
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
78
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
79
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
80
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
81

    
82
/* mpeg2 */
83
#define PROGRAM_STREAM_MAP 0x1bc
84
#define PRIVATE_STREAM_1   0x1bd
85
#define PADDING_STREAM     0x1be
86
#define PRIVATE_STREAM_2   0x1bf
87

    
88

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

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

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

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

    
111
#ifdef CONFIG_MUXERS
112
AVOutputFormat mpeg1system_muxer;
113
AVOutputFormat mpeg1vcd_muxer;
114
AVOutputFormat mpeg2vob_muxer;
115
AVOutputFormat mpeg2svcd_muxer;
116
AVOutputFormat mpeg2dvd_muxer;
117

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

    
124
    init_put_bits(&pb, buf, 128);
125

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

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

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

    
162
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
163
    put_bits(&pb, 16, 0);
164
    put_bits(&pb, 1, 1);
165

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

    
174
    if (s->is_vcd) {
175
        /* see VCD standard, p. IV-7*/
176
        put_bits(&pb, 1, 0);
177
        put_bits(&pb, 1, 1);
178
    } else {
179
        put_bits(&pb, 1, 0); /* variable bitrate*/
180
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
181
    }
182

    
183
    if (s->is_vcd || s->is_dvd) {
184
        /* see VCD standard p IV-7 */
185
        put_bits(&pb, 1, 1); /* audio locked */
186
        put_bits(&pb, 1, 1); /* video locked */
187
    } else {
188
        put_bits(&pb, 1, 0); /* audio locked */
189
        put_bits(&pb, 1, 0); /* video locked */
190
    }
191

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

    
194
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
195
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
196
        put_bits(&pb, 5, 0);
197
    } else
198
        put_bits(&pb, 5, s->video_bound);
199

    
200
    if (s->is_dvd) {
201
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
202
        put_bits(&pb, 7, 0x7f); /* reserved byte */
203
    } else
204
        put_bits(&pb, 8, 0xff); /* reserved byte */
205

    
206
    /* DVD-Video Stream_bound entries
207
    id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
208
    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)
209
    id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
210
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
211
    if (s->is_dvd) {
212

    
213
        int P_STD_max_video = 0;
214
        int P_STD_max_mpeg_audio = 0;
215
        int P_STD_max_mpeg_PS1 = 0;
216

    
217
        for(i=0;i<ctx->nb_streams;i++) {
218
            StreamInfo *stream = ctx->streams[i]->priv_data;
219

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

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

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

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

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

    
262

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

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

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

    
298
    return size;
299
}
300

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

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

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

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

    
333
    s->packet_number = 0;
334
    s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
335
    s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
336
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
337
    s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
338

    
339
    if(ctx->packet_size)
340
        s->packet_size = ctx->packet_size;
341
    else
342
        s->packet_size = 2048;
343

    
344
    s->vcd_padding_bytes_written = 0;
345
    s->vcd_padding_bitrate=0;
346

    
347
    s->audio_bound = 0;
348
    s->video_bound = 0;
349
    mpa_id = AUDIO_ID;
350
    ac3_id = AC3_ID;
351
    dts_id = DTS_ID;
352
    mpv_id = VIDEO_ID;
353
    mps_id = SUB_ID;
354
    lpcm_id = LPCM_ID;
355
    for(i=0;i<ctx->nb_streams;i++) {
356
        st = ctx->streams[i];
357
        stream = av_mallocz(sizeof(StreamInfo));
358
        if (!stream)
359
            goto fail;
360
        st->priv_data = stream;
361

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

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

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

    
426
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
427
            codec_rate= st->codec->rc_max_rate;
428
        else
429
            codec_rate= st->codec->bit_rate;
430

    
431
        if(!codec_rate)
432
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
433

    
434
        bitrate += codec_rate;
435

    
436
        if (stream->id==AUDIO_ID)
437
            audio_bitrate += codec_rate;
438
        else if (stream->id==VIDEO_ID)
439
            video_bitrate += codec_rate;
440
    }
441

    
442
    if(ctx->mux_rate){
443
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
444
    } else {
445
        /* we increase slightly the bitrate to take into account the
446
           headers. XXX: compute it exactly */
447
        bitrate += bitrate*5/100;
448
        bitrate += 10000;
449
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
450
    }
451

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

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

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

    
471
        /* Add the header overhead to the data rate.
472
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
473
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
474
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
475
        overhead_rate *= 8;
476

    
477
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
478
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
479
    }
480

    
481
    if (s->is_vcd || s->is_mpeg2)
482
        /* every packet */
483
        s->pack_header_freq = 1;
484
    else
485
        /* every 2 seconds */
486
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
487

    
488
    /* the above seems to make pack_header_freq zero sometimes */
489
    if (s->pack_header_freq == 0)
490
       s->pack_header_freq = 1;
491

    
492
    if (s->is_mpeg2)
493
        /* every 200 packets. Need to look at the spec.  */
494
        s->system_header_freq = s->pack_header_freq * 40;
495
    else if (s->is_vcd)
496
        /* the standard mandates that there are only two system headers
497
           in the whole file: one in the first packet of each stream.
498
           (see standard p. IV-7 and IV-8) */
499
        s->system_header_freq = 0x7fffffff;
500
    else
501
        s->system_header_freq = s->pack_header_freq * 5;
502

    
503
    for(i=0;i<ctx->nb_streams;i++) {
504
        stream = ctx->streams[i]->priv_data;
505
        stream->packet_number = 0;
506
    }
507
    s->system_header_size = get_system_header_size(ctx);
508
    s->last_scr = 0;
509
    return 0;
510
 fail:
511
    for(i=0;i<ctx->nb_streams;i++) {
512
        av_free(ctx->streams[i]->priv_data);
513
    }
514
    return -ENOMEM;
515
}
516

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

    
527

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

    
535
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
536
    {
537
        int64_t full_pad_bytes;
538

    
539
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
540
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
541

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

    
548
    return pad_bytes;
549
}
550

    
551

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

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

565
    buf_index = 0;
566
    if (((s->packet_number % s->pack_header_freq) == 0)) {
567
        /* pack header size */
568
        if (s->is_mpeg2)
569
            buf_index += 14;
570
        else
571
            buf_index += 12;
572

573
        if (s->is_vcd) {
574
            /* there is exactly one system header for each stream in a VCD MPEG,
575
               One in the very first video packet and one in the very first
576
               audio packet (see VCD standard p. IV-7 and IV-8).*/
577

578
            if (stream->packet_number==0)
579
                /* The system headers refer only to the stream they occur in,
580
                   so they have a constant size.*/
581
                buf_index += 15;
582

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

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

610
        } else {
611
            if (!s->is_mpeg2)
612
                buf_index++;
613
        }
614

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

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

    
638
/* Write an MPEG padding packet header. */
639
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
640
{
641
    MpegMuxContext *s = ctx->priv_data;
642
    int i;
643

    
644
    put_be32(pb, PADDING_STREAM);
645
    put_be16(pb, packet_bytes - 6);
646
    if (!s->is_mpeg2) {
647
        put_byte(pb, 0x0f);
648
        packet_bytes -= 7;
649
    } else
650
        packet_bytes -= 6;
651

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

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

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

    
667
    return nb_frames;
668
}
669

    
670
/* flush the packet on stream stream_index */
671
static int flush_packet(AVFormatContext *ctx, int stream_index,
672
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
673
{
674
    MpegMuxContext *s = ctx->priv_data;
675
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
676
    uint8_t *buf_ptr;
677
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
678
    int packet_size;
679
    uint8_t buffer[128];
680
    int zero_trail_bytes = 0;
681
    int pad_packet_bytes = 0;
682
    int pes_flags;
683
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
684
    int nb_frames;
685

    
686
    id = stream->id;
687

    
688
#if 0
689
    printf("packet ID=%2x PTS=%0.3f\n",
690
           id, pts / 90000.0);
691
#endif
692

    
693
    buf_ptr = buffer;
694

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

    
701
        if (s->is_vcd) {
702
            /* there is exactly one system header for each stream in a VCD MPEG,
703
               One in the very first video packet and one in the very first
704
               audio packet (see VCD standard p. IV-7 and IV-8).*/
705

    
706
            if (stream->packet_number==0) {
707
                size = put_system_header(ctx, buf_ptr, id);
708
                buf_ptr += size;
709
            }
710
        } else if (s->is_dvd) {
711
            if (stream->align_iframe || s->packet_number == 0){
712
                int PES_bytes_to_fill = s->packet_size - size - 10;
713

    
714
                if (pts != AV_NOPTS_VALUE) {
715
                    if (dts != pts)
716
                        PES_bytes_to_fill -= 5 + 5;
717
                    else
718
                        PES_bytes_to_fill -= 5;
719
                }
720

    
721
                if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
722
                    size = put_system_header(ctx, buf_ptr, 0);
723
                    buf_ptr += size;
724
                    size = buf_ptr - buffer;
725
                    put_buffer(&ctx->pb, buffer, size);
726

    
727
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
728
                    put_be16(&ctx->pb, 0x03d4);         // length
729
                    put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
730
                    for (i = 0; i < 979; i++)
731
                        put_byte(&ctx->pb, 0x00);
732

    
733
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
734
                    put_be16(&ctx->pb, 0x03fa);         // length
735
                    put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
736
                    for (i = 0; i < 1017; i++)
737
                        put_byte(&ctx->pb, 0x00);
738

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

    
762
    packet_size = s->packet_size - size;
763

    
764
    if (s->is_vcd && id == AUDIO_ID)
765
        /* The VCD standard demands that 20 zero bytes follow
766
           each audio pack (see standard p. IV-8).*/
767
        zero_trail_bytes += 20;
768

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

    
782
    packet_size -= pad_packet_bytes + zero_trail_bytes;
783

    
784
    if (packet_size > 0) {
785

    
786
        /* packet header size */
787
        packet_size -= 6;
788

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

    
808
        payload_size = packet_size - header_len;
809
        if (id < 0xc0) {
810
            startcode = PRIVATE_STREAM_1;
811
            payload_size -= 1;
812
            if (id >= 0x40) {
813
                payload_size -= 3;
814
                if (id >= 0xa0)
815
                    payload_size -= 3;
816
            }
817
        } else {
818
            startcode = 0x100 + id;
819
        }
820

    
821
        stuffing_size = payload_size - av_fifo_size(&stream->fifo);
822

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

    
843
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
844
            packet_size += pad_packet_bytes;
845
            payload_size += pad_packet_bytes; // undo the previous adjustment
846
            if (stuffing_size < 0) {
847
                stuffing_size = pad_packet_bytes;
848
            } else {
849
                stuffing_size += pad_packet_bytes;
850
            }
851
            pad_packet_bytes = 0;
852
        }
853

    
854
        if (stuffing_size < 0)
855
            stuffing_size = 0;
856
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
857
            pad_packet_bytes += stuffing_size;
858
            packet_size -= stuffing_size;
859
            payload_size -= stuffing_size;
860
            stuffing_size = 0;
861
        }
862

    
863
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
864

    
865
        put_be32(&ctx->pb, startcode);
866

    
867
        put_be16(&ctx->pb, packet_size);
868

    
869
        if (!s->is_mpeg2)
870
            for(i=0;i<stuffing_size;i++)
871
                put_byte(&ctx->pb, 0xff);
872

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

    
876
            pes_flags=0;
877

    
878
            if (pts != AV_NOPTS_VALUE) {
879
                pes_flags |= 0x80;
880
                if (dts != pts)
881
                    pes_flags |= 0x40;
882
            }
883

    
884
            /* Both the MPEG-2 and the SVCD standards demand that the
885
               P-STD_buffer_size field be included in the first packet of
886
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
887
               and MPEG-2 standard 2.7.7) */
888
            if (stream->packet_number == 0)
889
                pes_flags |= 0x01;
890

    
891
            put_byte(&ctx->pb, pes_flags); /* flags */
892
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
893

    
894
            if (pes_flags & 0x80)  /*write pts*/
895
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
896
            if (pes_flags & 0x40)  /*write dts*/
897
                put_timestamp(&ctx->pb, 0x01, dts);
898

    
899
            if (pes_flags & 0x01) {  /*write pes extension*/
900
                put_byte(&ctx->pb, 0x10); /* flags */
901

    
902
                /* P-STD buffer info */
903
                if (id == AUDIO_ID)
904
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
905
                else
906
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
907
            }
908

    
909
        } else {
910
            if (pts != AV_NOPTS_VALUE) {
911
                if (dts != pts) {
912
                    put_timestamp(&ctx->pb, 0x03, pts);
913
                    put_timestamp(&ctx->pb, 0x01, dts);
914
                } else {
915
                    put_timestamp(&ctx->pb, 0x02, pts);
916
                }
917
            } else {
918
                put_byte(&ctx->pb, 0x0f);
919
            }
920
        }
921

    
922
        if (s->is_mpeg2) {
923
            /* special stuffing byte that is always written
924
               to prevent accidental generation of start codes. */
925
            put_byte(&ctx->pb, 0xff);
926

    
927
            for(i=0;i<stuffing_size;i++)
928
                put_byte(&ctx->pb, 0xff);
929
        }
930

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

    
947
        /* output data */
948
        if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
949
            return -1;
950
        stream->bytes_to_iframe -= payload_size - stuffing_size;
951
    }else{
952
        payload_size=
953
        stuffing_size= 0;
954
    }
955

    
956
    if (pad_packet_bytes > 0)
957
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
958

    
959
    for(i=0;i<zero_trail_bytes;i++)
960
        put_byte(&ctx->pb, 0x00);
961

    
962
    put_flush_packet(&ctx->pb);
963

    
964
    s->packet_number++;
965

    
966
    /* only increase the stream packet number if this pack actually contains
967
       something that is specific to this stream! I.e. a dedicated header
968
       or some data.*/
969
    if (!general_pack)
970
        stream->packet_number++;
971

    
972
    return payload_size - stuffing_size;
973
}
974

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

    
983
    MpegMuxContext *s = ctx->priv_data;
984
    int i;
985

    
986
    for(i=0;i<s->packet_size;i++)
987
        put_byte(&ctx->pb, 0);
988

    
989
    s->vcd_padding_bytes_written += s->packet_size;
990

    
991
    put_flush_packet(&ctx->pb);
992

    
993
    /* increasing the packet number is correct. The SCR of the following packs
994
       is calculated from the packet_number and it has to include the padding
995
       sector (it represents the sector index, not the MPEG pack index)
996
       (see VCD standard p. IV-6)*/
997
    s->packet_number++;
998
}
999

    
1000
#if 0 /* unused, remove? */
1001
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
1002
{
1003
    MpegMuxContext *s = ctx->priv_data;
1004
    int64_t scr;
1005

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

1018
    return scr;
1019
}
1020
#endif
1021

    
1022
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1023
//    MpegMuxContext *s = ctx->priv_data;
1024
    int i;
1025

    
1026
    for(i=0; i<ctx->nb_streams; i++){
1027
        AVStream *st = ctx->streams[i];
1028
        StreamInfo *stream = st->priv_data;
1029
        PacketDesc *pkt_desc= stream->predecode_packet;
1030

    
1031
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1032
            if(stream->buffer_index < pkt_desc->size ||
1033
               stream->predecode_packet == stream->premux_packet){
1034
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1035
                break;
1036
            }
1037
            stream->buffer_index -= pkt_desc->size;
1038

    
1039
            stream->predecode_packet= pkt_desc->next;
1040
            av_freep(&pkt_desc);
1041
        }
1042
    }
1043

    
1044
    return 0;
1045
}
1046

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

    
1059
retry:
1060
    for(i=0; i<ctx->nb_streams; i++){
1061
        AVStream *st = ctx->streams[i];
1062
        StreamInfo *stream = st->priv_data;
1063
        const int avail_data=  av_fifo_size(&stream->fifo);
1064
        const int space= stream->max_buffer_size - stream->buffer_index;
1065
        int rel_space= 1024*space / stream->max_buffer_size;
1066
        PacketDesc *next_pkt= stream->premux_packet;
1067

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

    
1077
        if(space < s->packet_size && !ignore_constraints)
1078
            continue;
1079

    
1080
        if(next_pkt && next_pkt->dts - scr > max_delay)
1081
            continue;
1082

    
1083
        if(rel_space > best_score){
1084
            best_score= rel_space;
1085
            best_i = i;
1086
            avail_space= space;
1087
        }
1088
    }
1089

    
1090
    if(best_i < 0){
1091
        int64_t best_dts= INT64_MAX;
1092

    
1093
        for(i=0; i<ctx->nb_streams; i++){
1094
            AVStream *st = ctx->streams[i];
1095
            StreamInfo *stream = st->priv_data;
1096
            PacketDesc *pkt_desc= stream->predecode_packet;
1097
            if(pkt_desc && pkt_desc->dts < best_dts)
1098
                best_dts= pkt_desc->dts;
1099
        }
1100

    
1101
#if 0
1102
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1103
               scr/90000.0, best_dts/90000.0);
1104
#endif
1105
        if(best_dts == INT64_MAX)
1106
            return 0;
1107

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

    
1118
    assert(best_i >= 0);
1119

    
1120
    st = ctx->streams[best_i];
1121
    stream = st->priv_data;
1122

    
1123
    assert(av_fifo_size(&stream->fifo) > 0);
1124

    
1125
    assert(avail_space >= s->packet_size || ignore_constraints);
1126

    
1127
    timestamp_packet= stream->premux_packet;
1128
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1129
        trailer_size= 0;
1130
    }else{
1131
        trailer_size= timestamp_packet->unwritten_size;
1132
        timestamp_packet= timestamp_packet->next;
1133
    }
1134

    
1135
    if(timestamp_packet){
1136
//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);
1137
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1138
    }else{
1139
        assert(av_fifo_size(&stream->fifo) == trailer_size);
1140
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1141
    }
1142

    
1143
    if (s->is_vcd) {
1144
        /* Write one or more padding sectors, if necessary, to reach
1145
           the constant overall bitrate.*/
1146
        int vcd_pad_bytes;
1147

    
1148
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1149
            put_vcd_padding_sector(ctx);
1150
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1151
        }
1152
    }
1153

    
1154
    stream->buffer_index += es_size;
1155
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1156

    
1157
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1158
        es_size -= stream->premux_packet->unwritten_size;
1159
        stream->premux_packet= stream->premux_packet->next;
1160
    }
1161
    if(es_size)
1162
        stream->premux_packet->unwritten_size -= es_size;
1163

    
1164
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1165
        return -1;
1166

    
1167
    return 1;
1168
}
1169

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

    
1183
    pts= pkt->pts;
1184
    dts= pkt->dts;
1185

    
1186
    if(pts != AV_NOPTS_VALUE) pts += preload;
1187
    if(dts != AV_NOPTS_VALUE) dts += preload;
1188

    
1189
//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);
1190
    if (!stream->premux_packet)
1191
        stream->next_packet = &stream->premux_packet;
1192
    *stream->next_packet=
1193
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1194
    pkt_desc->pts= pts;
1195
    pkt_desc->dts= dts;
1196
    pkt_desc->unwritten_size=
1197
    pkt_desc->size= size;
1198
    if(!stream->predecode_packet)
1199
        stream->predecode_packet= pkt_desc;
1200
    stream->next_packet= &pkt_desc->next;
1201

    
1202
    av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1203

    
1204
    if (s->is_dvd){
1205
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1206
            stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1207
            stream->align_iframe = 1;
1208
            stream->vobu_start_pts = pts;
1209
        } else {
1210
            stream->align_iframe = 0;
1211
        }
1212
    }
1213

    
1214
    av_fifo_write(&stream->fifo, buf, size);
1215

    
1216
    for(;;){
1217
        int ret= output_packet(ctx, 0);
1218
        if(ret<=0)
1219
            return ret;
1220
    }
1221
}
1222

    
1223
static int mpeg_mux_end(AVFormatContext *ctx)
1224
{
1225
//    MpegMuxContext *s = ctx->priv_data;
1226
    StreamInfo *stream;
1227
    int i;
1228

    
1229
    for(;;){
1230
        int ret= output_packet(ctx, 1);
1231
        if(ret<0)
1232
            return ret;
1233
        else if(ret==0)
1234
            break;
1235
    }
1236

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

    
1243
    for(i=0;i<ctx->nb_streams;i++) {
1244
        stream = ctx->streams[i]->priv_data;
1245

    
1246
        assert(av_fifo_size(&stream->fifo) == 0);
1247
        av_fifo_free(&stream->fifo);
1248
    }
1249
    return 0;
1250
}
1251
#endif //CONFIG_MUXERS
1252

    
1253
/*********************************************/
1254
/* demux code */
1255

    
1256
#define MAX_SYNC_SIZE 100000
1257

    
1258
static int cdxa_probe(AVProbeData *p)
1259
{
1260
    /* check file header */
1261
    if (p->buf_size <= 32)
1262
        return 0;
1263
    if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1264
        p->buf[2] == 'F' && p->buf[3] == 'F' &&
1265
        p->buf[8] == 'C' && p->buf[9] == 'D' &&
1266
        p->buf[10] == 'X' && p->buf[11] == 'A')
1267
        return AVPROBE_SCORE_MAX;
1268
    else
1269
        return 0;
1270
}
1271

    
1272
static int mpegps_probe(AVProbeData *p)
1273
{
1274
    uint32_t code= -1;
1275
    int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1276
    int i;
1277
    int score=0;
1278

    
1279
    score = cdxa_probe(p);
1280
    if (score > 0) return score;
1281

    
1282
    /* Search for MPEG stream */
1283
    for(i=0; i<p->buf_size; i++){
1284
        code = (code<<8) + p->buf[i];
1285
        if ((code & 0xffffff00) == 0x100) {
1286
            if(code == SYSTEM_HEADER_START_CODE) sys++;
1287
            else if(code == PRIVATE_STREAM_1)    priv1++;
1288
            else if(code == PACK_START_CODE)     pspack++;
1289
            else if((code & 0xf0) == VIDEO_ID)   vid++;
1290
            else if((code & 0xe0) == AUDIO_ID)   audio++;
1291
        }
1292
    }
1293

    
1294
    if(vid || audio)            /* invalid VDR files nd short PES streams */
1295
        score= AVPROBE_SCORE_MAX/4;
1296

    
1297
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1298
    if(sys && sys*9 <= pspack*10)
1299
        return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1300
    if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1301
        return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1302
    if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1303
        return AVPROBE_SCORE_MAX/2+2;
1304

    
1305
    //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1306
    return score;
1307
}
1308

    
1309

    
1310
typedef struct MpegDemuxContext {
1311
    int header_state;
1312
    unsigned char psm_es_type[256];
1313
} MpegDemuxContext;
1314

    
1315
static int mpegps_read_header(AVFormatContext *s,
1316
                              AVFormatParameters *ap)
1317
{
1318
    MpegDemuxContext *m = s->priv_data;
1319
    m->header_state = 0xff;
1320
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1321

    
1322
    /* no need to do more */
1323
    return 0;
1324
}
1325

    
1326
static int64_t get_pts(ByteIOContext *pb, int c)
1327
{
1328
    int64_t pts;
1329
    int val;
1330

    
1331
    if (c < 0)
1332
        c = get_byte(pb);
1333
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1334
    val = get_be16(pb);
1335
    pts |= (int64_t)(val >> 1) << 15;
1336
    val = get_be16(pb);
1337
    pts |= (int64_t)(val >> 1);
1338
    return pts;
1339
}
1340

    
1341
static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1342
                                uint32_t *header_state)
1343
{
1344
    unsigned int state, v;
1345
    int val, n;
1346

    
1347
    state = *header_state;
1348
    n = *size_ptr;
1349
    while (n > 0) {
1350
        if (url_feof(pb))
1351
            break;
1352
        v = get_byte(pb);
1353
        n--;
1354
        if (state == 0x000001) {
1355
            state = ((state << 8) | v) & 0xffffff;
1356
            val = state;
1357
            goto found;
1358
        }
1359
        state = ((state << 8) | v) & 0xffffff;
1360
    }
1361
    val = -1;
1362
 found:
1363
    *header_state = state;
1364
    *size_ptr = n;
1365
    return val;
1366
}
1367

    
1368
#if 0 /* unused, remove? */
1369
/* XXX: optimize */
1370
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1371
{
1372
    int64_t pos, pos_start;
1373
    int max_size, start_code;
1374

1375
    max_size = *size_ptr;
1376
    pos_start = url_ftell(pb);
1377

1378
    /* in order to go faster, we fill the buffer */
1379
    pos = pos_start - 16386;
1380
    if (pos < 0)
1381
        pos = 0;
1382
    url_fseek(pb, pos, SEEK_SET);
1383
    get_byte(pb);
1384

1385
    pos = pos_start;
1386
    for(;;) {
1387
        pos--;
1388
        if (pos < 0 || (pos_start - pos) >= max_size) {
1389
            start_code = -1;
1390
            goto the_end;
1391
        }
1392
        url_fseek(pb, pos, SEEK_SET);
1393
        start_code = get_be32(pb);
1394
        if ((start_code & 0xffffff00) == 0x100)
1395
            break;
1396
    }
1397
 the_end:
1398
    *size_ptr = pos_start - pos;
1399
    return start_code;
1400
}
1401
#endif
1402

    
1403
/**
1404
 * Extracts stream types from a program stream map
1405
 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1406
 *
1407
 * @return number of bytes occupied by PSM in the bitstream
1408
 */
1409
static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1410
{
1411
    int psm_length, ps_info_length, es_map_length;
1412

    
1413
    psm_length = get_be16(pb);
1414
    get_byte(pb);
1415
    get_byte(pb);
1416
    ps_info_length = get_be16(pb);
1417

    
1418
    /* skip program_stream_info */
1419
    url_fskip(pb, ps_info_length);
1420
    es_map_length = get_be16(pb);
1421

    
1422
    /* at least one es available? */
1423
    while (es_map_length >= 4){
1424
        unsigned char type = get_byte(pb);
1425
        unsigned char es_id = get_byte(pb);
1426
        uint16_t es_info_length = get_be16(pb);
1427
        /* remember mapping from stream id to stream type */
1428
        m->psm_es_type[es_id] = type;
1429
        /* skip program_stream_info */
1430
        url_fskip(pb, es_info_length);
1431
        es_map_length -= 4 + es_info_length;
1432
    }
1433
    get_be32(pb); /* crc32 */
1434
    return 2 + psm_length;
1435
}
1436

    
1437
/* read the next PES header. Return its position in ppos
1438
   (if not NULL), and its start code, pts and dts.
1439
 */
1440
static int mpegps_read_pes_header(AVFormatContext *s,
1441
                                  int64_t *ppos, int *pstart_code,
1442
                                  int64_t *ppts, int64_t *pdts)
1443
{
1444
    MpegDemuxContext *m = s->priv_data;
1445
    int len, size, startcode, c, flags, header_len;
1446
    int64_t pts, dts, last_pos;
1447

    
1448
    last_pos = -1;
1449
 redo:
1450
        /* next start code (should be immediately after) */
1451
        m->header_state = 0xff;
1452
        size = MAX_SYNC_SIZE;
1453
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1454
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1455
    if (startcode < 0)
1456
        return AVERROR_IO;
1457
    if (startcode == PACK_START_CODE)
1458
        goto redo;
1459
    if (startcode == SYSTEM_HEADER_START_CODE)
1460
        goto redo;
1461
    if (startcode == PADDING_STREAM ||
1462
        startcode == PRIVATE_STREAM_2) {
1463
        /* skip them */
1464
        len = get_be16(&s->pb);
1465
        url_fskip(&s->pb, len);
1466
        goto redo;
1467
    }
1468
    if (startcode == PROGRAM_STREAM_MAP) {
1469
        mpegps_psm_parse(m, &s->pb);
1470
        goto redo;
1471
    }
1472

    
1473
    /* find matching stream */
1474
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1475
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1476
          (startcode == 0x1bd)))
1477
        goto redo;
1478
    if (ppos) {
1479
        *ppos = url_ftell(&s->pb) - 4;
1480
    }
1481
    len = get_be16(&s->pb);
1482
    pts = AV_NOPTS_VALUE;
1483
    dts = AV_NOPTS_VALUE;
1484
    /* stuffing */
1485
    for(;;) {
1486
        if (len < 1)
1487
            goto redo;
1488
        c = get_byte(&s->pb);
1489
        len--;
1490
        /* XXX: for mpeg1, should test only bit 7 */
1491
        if (c != 0xff)
1492
            break;
1493
    }
1494
    if ((c & 0xc0) == 0x40) {
1495
        /* buffer scale & size */
1496
        if (len < 2)
1497
            goto redo;
1498
        get_byte(&s->pb);
1499
        c = get_byte(&s->pb);
1500
        len -= 2;
1501
    }
1502
    if ((c & 0xf0) == 0x20) {
1503
        if (len < 4)
1504
            goto redo;
1505
        dts = pts = get_pts(&s->pb, c);
1506
        len -= 4;
1507
    } else if ((c & 0xf0) == 0x30) {
1508
        if (len < 9)
1509
            goto redo;
1510
        pts = get_pts(&s->pb, c);
1511
        dts = get_pts(&s->pb, -1);
1512
        len -= 9;
1513
    } else if ((c & 0xc0) == 0x80) {
1514
        /* mpeg 2 PES */
1515
#if 0 /* some streams have this field set for no apparent reason */
1516
        if ((c & 0x30) != 0) {
1517
            /* Encrypted multiplex not handled */
1518
            goto redo;
1519
        }
1520
#endif
1521
        flags = get_byte(&s->pb);
1522
        header_len = get_byte(&s->pb);
1523
        len -= 2;
1524
        if (header_len > len)
1525
            goto redo;
1526
        if ((flags & 0xc0) == 0x80) {
1527
            dts = pts = get_pts(&s->pb, -1);
1528
            if (header_len < 5)
1529
                goto redo;
1530
            header_len -= 5;
1531
            len -= 5;
1532
        } if ((flags & 0xc0) == 0xc0) {
1533
            pts = get_pts(&s->pb, -1);
1534
            dts = get_pts(&s->pb, -1);
1535
            if (header_len < 10)
1536
                goto redo;
1537
            header_len -= 10;
1538
            len -= 10;
1539
        }
1540
        len -= header_len;
1541
        while (header_len > 0) {
1542
            get_byte(&s->pb);
1543
            header_len--;
1544
        }
1545
    }
1546
    else if( c!= 0xf )
1547
        goto redo;
1548

    
1549
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1550
        if (len < 1)
1551
            goto redo;
1552
        startcode = get_byte(&s->pb);
1553
        len--;
1554
        if (startcode >= 0x80 && startcode <= 0xbf) {
1555
            /* audio: skip header */
1556
            if (len < 3)
1557
                goto redo;
1558
            get_byte(&s->pb);
1559
            get_byte(&s->pb);
1560
            get_byte(&s->pb);
1561
            len -= 3;
1562
        }
1563
    }
1564
    if(dts != AV_NOPTS_VALUE && ppos){
1565
        int i;
1566
        for(i=0; i<s->nb_streams; i++){
1567
            if(startcode == s->streams[i]->id) {
1568
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1569
            }
1570
        }
1571
    }
1572

    
1573
    *pstart_code = startcode;
1574
    *ppts = pts;
1575
    *pdts = dts;
1576
    return len;
1577
}
1578

    
1579
static int mpegps_read_packet(AVFormatContext *s,
1580
                              AVPacket *pkt)
1581
{
1582
    MpegDemuxContext *m = s->priv_data;
1583
    AVStream *st;
1584
    int len, startcode, i, type, codec_id = 0, es_type;
1585
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1586

    
1587
 redo:
1588
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1589
    if (len < 0)
1590
        return len;
1591

    
1592
    /* now find stream */
1593
    for(i=0;i<s->nb_streams;i++) {
1594
        st = s->streams[i];
1595
        if (st->id == startcode)
1596
            goto found;
1597
    }
1598

    
1599
    es_type = m->psm_es_type[startcode & 0xff];
1600
    if(es_type > 0){
1601
        if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1602
            codec_id = CODEC_ID_MPEG2VIDEO;
1603
            type = CODEC_TYPE_VIDEO;
1604
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1605
            codec_id = CODEC_ID_MPEG2VIDEO;
1606
            type = CODEC_TYPE_VIDEO;
1607
        } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1608
                  es_type == STREAM_TYPE_AUDIO_MPEG2){
1609
            codec_id = CODEC_ID_MP3;
1610
            type = CODEC_TYPE_AUDIO;
1611
        } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1612
            codec_id = CODEC_ID_AAC;
1613
            type = CODEC_TYPE_AUDIO;
1614
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1615
            codec_id = CODEC_ID_MPEG4;
1616
            type = CODEC_TYPE_VIDEO;
1617
        } else if(es_type == STREAM_TYPE_VIDEO_H264){
1618
            codec_id = CODEC_ID_H264;
1619
            type = CODEC_TYPE_VIDEO;
1620
        } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1621
            codec_id = CODEC_ID_AC3;
1622
            type = CODEC_TYPE_AUDIO;
1623
        } else {
1624
            goto skip;
1625
        }
1626
    } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1627
        static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1628
        unsigned char buf[8];
1629
        get_buffer(&s->pb, buf, 8);
1630
        url_fseek(&s->pb, -8, SEEK_CUR);
1631
        if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1632
            codec_id = CODEC_ID_CAVS;
1633
        else
1634
            codec_id = CODEC_ID_MPEG2VIDEO;
1635
        type = CODEC_TYPE_VIDEO;
1636
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1637
        type = CODEC_TYPE_AUDIO;
1638
        codec_id = CODEC_ID_MP2;
1639
    } else if (startcode >= 0x80 && startcode <= 0x87) {
1640
        type = CODEC_TYPE_AUDIO;
1641
        codec_id = CODEC_ID_AC3;
1642
    } else if (startcode >= 0x88 && startcode <= 0x9f) {
1643
        type = CODEC_TYPE_AUDIO;
1644
        codec_id = CODEC_ID_DTS;
1645
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1646
        type = CODEC_TYPE_AUDIO;
1647
        codec_id = CODEC_ID_PCM_S16BE;
1648
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
1649
        type = CODEC_TYPE_SUBTITLE;
1650
        codec_id = CODEC_ID_DVD_SUBTITLE;
1651
    } else {
1652
    skip:
1653
        /* skip packet */
1654
        url_fskip(&s->pb, len);
1655
        goto redo;
1656
    }
1657
    /* no stream found: add a new stream */
1658
    st = av_new_stream(s, startcode);
1659
    if (!st)
1660
        goto skip;
1661
    st->codec->codec_type = type;
1662
    st->codec->codec_id = codec_id;
1663
    if (codec_id != CODEC_ID_PCM_S16BE)
1664
        st->need_parsing = 1;
1665
 found:
1666
    if(st->discard >= AVDISCARD_ALL)
1667
        goto skip;
1668
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1669
        int b1, freq;
1670

    
1671
        /* for LPCM, we just skip the header and consider it is raw
1672
           audio data */
1673
        if (len <= 3)
1674
            goto skip;
1675
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1676
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1677
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1678
        len -= 3;
1679
        freq = (b1 >> 4) & 3;
1680
        st->codec->sample_rate = lpcm_freq_tab[freq];
1681
        st->codec->channels = 1 + (b1 & 7);
1682
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1683
    }
1684
    av_new_packet(pkt, len);
1685
    get_buffer(&s->pb, pkt->data, pkt->size);
1686
    pkt->pts = pts;
1687
    pkt->dts = dts;
1688
    pkt->stream_index = st->index;
1689
#if 0
1690
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1691
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1692
#endif
1693

    
1694
    return 0;
1695
}
1696

    
1697
static int mpegps_read_close(AVFormatContext *s)
1698
{
1699
    return 0;
1700
}
1701

    
1702
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1703
                               int64_t *ppos, int64_t pos_limit)
1704
{
1705
    int len, startcode;
1706
    int64_t pos, pts, dts;
1707

    
1708
    pos = *ppos;
1709
#ifdef DEBUG_SEEK
1710
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1711
#endif
1712
    url_fseek(&s->pb, pos, SEEK_SET);
1713
    for(;;) {
1714
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1715
        if (len < 0) {
1716
#ifdef DEBUG_SEEK
1717
            printf("none (ret=%d)\n", len);
1718
#endif
1719
            return AV_NOPTS_VALUE;
1720
        }
1721
        if (startcode == s->streams[stream_index]->id &&
1722
            dts != AV_NOPTS_VALUE) {
1723
            break;
1724
        }
1725
        url_fskip(&s->pb, len);
1726
    }
1727
#ifdef DEBUG_SEEK
1728
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1729
#endif
1730
    *ppos = pos;
1731
    return dts;
1732
}
1733

    
1734
#ifdef CONFIG_MPEG1SYSTEM_MUXER
1735
AVOutputFormat mpeg1system_muxer = {
1736
    "mpeg",
1737
    "MPEG1 System format",
1738
    "video/mpeg",
1739
    "mpg,mpeg",
1740
    sizeof(MpegMuxContext),
1741
    CODEC_ID_MP2,
1742
    CODEC_ID_MPEG1VIDEO,
1743
    mpeg_mux_init,
1744
    mpeg_mux_write_packet,
1745
    mpeg_mux_end,
1746
};
1747
#endif
1748
#ifdef CONFIG_MPEG1VCD_MUXER
1749
AVOutputFormat mpeg1vcd_muxer = {
1750
    "vcd",
1751
    "MPEG1 System format (VCD)",
1752
    "video/mpeg",
1753
    NULL,
1754
    sizeof(MpegMuxContext),
1755
    CODEC_ID_MP2,
1756
    CODEC_ID_MPEG1VIDEO,
1757
    mpeg_mux_init,
1758
    mpeg_mux_write_packet,
1759
    mpeg_mux_end,
1760
};
1761
#endif
1762
#ifdef CONFIG_MPEG2VOB_MUXER
1763
AVOutputFormat mpeg2vob_muxer = {
1764
    "vob",
1765
    "MPEG2 PS format (VOB)",
1766
    "video/mpeg",
1767
    "vob",
1768
    sizeof(MpegMuxContext),
1769
    CODEC_ID_MP2,
1770
    CODEC_ID_MPEG2VIDEO,
1771
    mpeg_mux_init,
1772
    mpeg_mux_write_packet,
1773
    mpeg_mux_end,
1774
};
1775
#endif
1776

    
1777
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1778
#ifdef CONFIG_MPEG2SVCD_MUXER
1779
AVOutputFormat mpeg2svcd_muxer = {
1780
    "svcd",
1781
    "MPEG2 PS format (VOB)",
1782
    "video/mpeg",
1783
    "vob",
1784
    sizeof(MpegMuxContext),
1785
    CODEC_ID_MP2,
1786
    CODEC_ID_MPEG2VIDEO,
1787
    mpeg_mux_init,
1788
    mpeg_mux_write_packet,
1789
    mpeg_mux_end,
1790
};
1791
#endif
1792

    
1793
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1794
#ifdef CONFIG_MPEG2DVD_MUXER
1795
AVOutputFormat mpeg2dvd_muxer = {
1796
    "dvd",
1797
    "MPEG2 PS format (DVD VOB)",
1798
    "video/mpeg",
1799
    "dvd",
1800
    sizeof(MpegMuxContext),
1801
    CODEC_ID_MP2,
1802
    CODEC_ID_MPEG2VIDEO,
1803
    mpeg_mux_init,
1804
    mpeg_mux_write_packet,
1805
    mpeg_mux_end,
1806
};
1807
#endif
1808

    
1809
#ifdef CONFIG_MPEGPS_DEMUXER
1810
AVInputFormat mpegps_demuxer = {
1811
    "mpeg",
1812
    "MPEG PS format",
1813
    sizeof(MpegDemuxContext),
1814
    mpegps_probe,
1815
    mpegps_read_header,
1816
    mpegps_read_packet,
1817
    mpegps_read_close,
1818
    NULL, //mpegps_read_seek,
1819
    mpegps_read_dts,
1820
    .flags = AVFMT_SHOW_IDS,
1821
};
1822
#endif