Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 8509fc7b

History | View | Annotate | Download (57.6 KB)

1
/*
2
 * MPEG1/2 muxer and demuxer
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "bitstream.h"
23
#include "fifo.h"
24

    
25
#define MAX_PAYLOAD_SIZE 4096
26
//#define DEBUG_SEEK
27

    
28
#undef NDEBUG
29
#include <assert.h>
30

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

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

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

    
72
    double vcd_padding_bitrate; //FIXME floats
73
    int64_t vcd_padding_bytes_written;
74

    
75
} MpegMuxContext;
76

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

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

    
90

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

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

    
108
#define STREAM_TYPE_AUDIO_AC3       0x81
109
#define STREAM_TYPE_AUDIO_DTS       0x8a
110

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

    
113
#ifdef CONFIG_MUXERS
114
AVOutputFormat mpeg1system_muxer;
115
AVOutputFormat mpeg1vcd_muxer;
116
AVOutputFormat mpeg2vob_muxer;
117
AVOutputFormat mpeg2svcd_muxer;
118
AVOutputFormat mpeg2dvd_muxer;
119

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

    
126
    init_put_bits(&pb, buf, 128);
127

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

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

    
162
    init_put_bits(&pb, buf, 128);
163

    
164
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
165
    put_bits(&pb, 16, 0);
166
    put_bits(&pb, 1, 1);
167

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

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

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

    
194
    put_bits(&pb, 1, 1); /* marker */
195

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

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

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

    
215
        int P_STD_max_video = 0;
216
        int P_STD_max_mpeg_audio = 0;
217
        int P_STD_max_mpeg_PS1 = 0;
218

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

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

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

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

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

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

    
264

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

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

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

    
300
    return size;
301
}
302

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

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

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

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

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

    
341
    if(ctx->packet_size)
342
        s->packet_size = ctx->packet_size;
343
    else
344
        s->packet_size = 2048;
345

    
346
    s->vcd_padding_bytes_written = 0;
347
    s->vcd_padding_bitrate=0;
348

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

    
364
        av_set_pts_info(st, 64, 1, 90000);
365

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

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

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

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

    
436
        bitrate += codec_rate;
437

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

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

    
454
    if (s->is_vcd) {
455
        double overhead_rate;
456

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

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

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

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

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

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

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

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

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

    
529

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

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

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

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

    
550
    return pad_bytes;
551
}
552

    
553

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

565
    stream = ctx->streams[stream_index]->priv_data;
566

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

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

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

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

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

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

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

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

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

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

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

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

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

    
669
    return nb_frames;
670
}
671

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

    
688
    id = stream->id;
689

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

    
695
    buf_ptr = buffer;
696

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

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

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

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

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

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

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

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

    
764
    packet_size = s->packet_size - size;
765

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

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

    
784
    packet_size -= pad_packet_bytes + zero_trail_bytes;
785

    
786
    if (packet_size > 0) {
787

    
788
        /* packet header size */
789
        packet_size -= 6;
790

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

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

    
823
        stuffing_size = payload_size - av_fifo_size(&stream->fifo);
824

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

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

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

    
865
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
866

    
867
        put_be32(&ctx->pb, startcode);
868

    
869
        put_be16(&ctx->pb, packet_size);
870

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

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

    
878
            pes_flags=0;
879

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

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

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

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

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

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

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

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

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

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

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

    
958
    if (pad_packet_bytes > 0)
959
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
960

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

    
964
    put_flush_packet(&ctx->pb);
965

    
966
    s->packet_number++;
967

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

    
974
    return payload_size - stuffing_size;
975
}
976

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

    
985
    MpegMuxContext *s = ctx->priv_data;
986
    int i;
987

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

    
991
    s->vcd_padding_bytes_written += s->packet_size;
992

    
993
    put_flush_packet(&ctx->pb);
994

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

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

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

1020
    return scr;
1021
}
1022
#endif
1023

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

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

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

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

    
1046
    return 0;
1047
}
1048

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

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

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

    
1079
        if(space < s->packet_size && !ignore_constraints)
1080
            continue;
1081

    
1082
        if(next_pkt && next_pkt->dts - scr > max_delay)
1083
            continue;
1084

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

    
1092
    if(best_i < 0){
1093
        int64_t best_dts= INT64_MAX;
1094

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

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

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

    
1120
    assert(best_i >= 0);
1121

    
1122
    st = ctx->streams[best_i];
1123
    stream = st->priv_data;
1124

    
1125
    assert(av_fifo_size(&stream->fifo) > 0);
1126

    
1127
    assert(avail_space >= s->packet_size || ignore_constraints);
1128

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

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

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

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

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

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

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

    
1169
    return 1;
1170
}
1171

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

    
1185
    pts= pkt->pts;
1186
    dts= pkt->dts;
1187

    
1188
    if(pts != AV_NOPTS_VALUE) pts += preload;
1189
    if(dts != AV_NOPTS_VALUE) dts += preload;
1190

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

    
1204
    av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1205

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

    
1216
    av_fifo_write(&stream->fifo, buf, size);
1217

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

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

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

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

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

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

    
1255
/*********************************************/
1256
/* demux code */
1257

    
1258
#define MAX_SYNC_SIZE 100000
1259

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

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

    
1281
    score = cdxa_probe(p);
1282
    if (score > 0) return score;
1283

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

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

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

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

    
1311

    
1312
typedef struct MpegDemuxContext {
1313
    int32_t header_state;
1314
    unsigned char psm_es_type[256];
1315
} MpegDemuxContext;
1316

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

    
1324
    /* no need to do more */
1325
    return 0;
1326
}
1327

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

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

    
1343
static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1344
                                int32_t *header_state)
1345
{
1346
    unsigned int state, v;
1347
    int val, n;
1348

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

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

1377
    max_size = *size_ptr;
1378
    pos_start = url_ftell(pb);
1379

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

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

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

    
1415
    psm_length = get_be16(pb);
1416
    get_byte(pb);
1417
    get_byte(pb);
1418
    ps_info_length = get_be16(pb);
1419

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

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

    
1439
/* read the next PES header. Return its position in ppos
1440
   (if not NULL), and its start code, pts and dts.
1441
 */
1442
static int mpegps_read_pes_header(AVFormatContext *s,
1443
                                  int64_t *ppos, int *pstart_code,
1444
                                  int64_t *ppts, int64_t *pdts)
1445
{
1446
    MpegDemuxContext *m = s->priv_data;
1447
    int len, size, startcode, c, flags, header_len;
1448
    int pes_ext, ext2_len, id_ext, skip;
1449
    int64_t pts, dts;
1450
    int64_t last_sync= url_ftell(&s->pb);
1451

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

    
1479
    /* find matching stream */
1480
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1481
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1482
          (startcode == 0x1bd) || (startcode == 0x1fd)))
1483
        goto redo;
1484
    if (ppos) {
1485
        *ppos = url_ftell(&s->pb) - 4;
1486
    }
1487
    len = get_be16(&s->pb);
1488
    pts =
1489
    dts = AV_NOPTS_VALUE;
1490
    /* stuffing */
1491
    for(;;) {
1492
        if (len < 1)
1493
            goto error_redo;
1494
        c = get_byte(&s->pb);
1495
        len--;
1496
        /* XXX: for mpeg1, should test only bit 7 */
1497
        if (c != 0xff)
1498
            break;
1499
    }
1500
    if ((c & 0xc0) == 0x40) {
1501
        /* buffer scale & size */
1502
        get_byte(&s->pb);
1503
        c = get_byte(&s->pb);
1504
        len -= 2;
1505
    }
1506
    if ((c & 0xe0) == 0x20) {
1507
        dts = pts = get_pts(&s->pb, c);
1508
        len -= 4;
1509
        if (c & 0x10){
1510
            dts = get_pts(&s->pb, -1);
1511
            len -= 5;
1512
        }
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 error_redo;
1526
        len -= header_len;
1527
        if (flags & 0x80) {
1528
            dts = pts = get_pts(&s->pb, -1);
1529
            header_len -= 5;
1530
            if (flags & 0x40) {
1531
                dts = get_pts(&s->pb, -1);
1532
                header_len -= 5;
1533
            }
1534
        }
1535
        if (flags & 0x01) { /* PES extension */
1536
            pes_ext = get_byte(&s->pb);
1537
            header_len--;
1538
            if (pes_ext & 0x40) { /* pack header - should be zero in PS */
1539
                goto error_redo;
1540
            }
1541
            /* Skip PES private data, program packet sequence counter and P-STD buffer */
1542
            skip = (pes_ext >> 4) & 0xb;
1543
            skip += skip & 0x9;
1544
            url_fskip(&s->pb, skip);
1545
            header_len -= skip;
1546

    
1547
            if (pes_ext & 0x01) { /* PES extension 2 */
1548
                ext2_len = get_byte(&s->pb);
1549
                header_len--;
1550
                if ((ext2_len & 0x7f) > 0) {
1551
                    id_ext = get_byte(&s->pb);
1552
                    if ((id_ext & 0x80) == 0)
1553
                        startcode = ((startcode & 0xff) << 8) | id_ext;
1554
                    header_len--;
1555
                }
1556
            }
1557
        }
1558
        if(header_len < 0)
1559
            goto error_redo;
1560
        url_fskip(&s->pb, header_len);
1561
    }
1562
    else if( c!= 0xf )
1563
        goto redo;
1564

    
1565
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1566
        startcode = get_byte(&s->pb);
1567
        len--;
1568
        if (startcode >= 0x80 && startcode <= 0xcf) {
1569
            /* audio: skip header */
1570
            get_byte(&s->pb);
1571
            get_byte(&s->pb);
1572
            get_byte(&s->pb);
1573
            len -= 3;
1574
            if (startcode >= 0xb0 && startcode <= 0xbf) {
1575
                /* MLP/TrueHD audio has a 4-byte header */
1576
                get_byte(&s->pb);
1577
                len--;
1578
            }
1579
        }
1580
    }
1581
    if(len<0)
1582
        goto error_redo;
1583
    if(dts != AV_NOPTS_VALUE && ppos){
1584
        int i;
1585
        for(i=0; i<s->nb_streams; i++){
1586
            if(startcode == s->streams[i]->id) {
1587
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1588
            }
1589
        }
1590
    }
1591

    
1592
    *pstart_code = startcode;
1593
    *ppts = pts;
1594
    *pdts = dts;
1595
    return len;
1596
}
1597

    
1598
static int mpegps_read_packet(AVFormatContext *s,
1599
                              AVPacket *pkt)
1600
{
1601
    MpegDemuxContext *m = s->priv_data;
1602
    AVStream *st;
1603
    int len, startcode, i, type, codec_id = 0, es_type;
1604
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1605

    
1606
 redo:
1607
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1608
    if (len < 0)
1609
        return len;
1610

    
1611
    /* now find stream */
1612
    for(i=0;i<s->nb_streams;i++) {
1613
        st = s->streams[i];
1614
        if (st->id == startcode)
1615
            goto found;
1616
    }
1617

    
1618
    es_type = m->psm_es_type[startcode & 0xff];
1619
    if(es_type > 0){
1620
        if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1621
            codec_id = CODEC_ID_MPEG2VIDEO;
1622
            type = CODEC_TYPE_VIDEO;
1623
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1624
            codec_id = CODEC_ID_MPEG2VIDEO;
1625
            type = CODEC_TYPE_VIDEO;
1626
        } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1627
                  es_type == STREAM_TYPE_AUDIO_MPEG2){
1628
            codec_id = CODEC_ID_MP3;
1629
            type = CODEC_TYPE_AUDIO;
1630
        } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1631
            codec_id = CODEC_ID_AAC;
1632
            type = CODEC_TYPE_AUDIO;
1633
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1634
            codec_id = CODEC_ID_MPEG4;
1635
            type = CODEC_TYPE_VIDEO;
1636
        } else if(es_type == STREAM_TYPE_VIDEO_H264){
1637
            codec_id = CODEC_ID_H264;
1638
            type = CODEC_TYPE_VIDEO;
1639
        } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1640
            codec_id = CODEC_ID_AC3;
1641
            type = CODEC_TYPE_AUDIO;
1642
        } else {
1643
            goto skip;
1644
        }
1645
    } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1646
        static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1647
        unsigned char buf[8];
1648
        get_buffer(&s->pb, buf, 8);
1649
        url_fseek(&s->pb, -8, SEEK_CUR);
1650
        if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1651
            codec_id = CODEC_ID_CAVS;
1652
        else
1653
            codec_id = CODEC_ID_MPEG2VIDEO;
1654
        type = CODEC_TYPE_VIDEO;
1655
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1656
        type = CODEC_TYPE_AUDIO;
1657
        codec_id = CODEC_ID_MP2;
1658
    } else if (startcode >= 0x80 && startcode <= 0x87) {
1659
        type = CODEC_TYPE_AUDIO;
1660
        codec_id = CODEC_ID_AC3;
1661
    } else if ((startcode >= 0x88 && startcode <= 0x8f)
1662
               ||( startcode >= 0x98 && startcode <= 0x9f)) {
1663
        /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
1664
        type = CODEC_TYPE_AUDIO;
1665
        codec_id = CODEC_ID_DTS;
1666
    } else if (startcode >= 0xa0 && startcode <= 0xaf) {
1667
        type = CODEC_TYPE_AUDIO;
1668
        codec_id = CODEC_ID_PCM_S16BE;
1669
    } else if (startcode >= 0xb0 && startcode <= 0xbf) {
1670
        type = CODEC_TYPE_AUDIO;
1671
        codec_id = CODEC_ID_MLP;
1672
    } else if (startcode >= 0xc0 && startcode <= 0xcf) {
1673
        /* Used for both AC-3 and E-AC-3 in EVOB files */
1674
        type = CODEC_TYPE_AUDIO;
1675
        codec_id = CODEC_ID_AC3;
1676
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
1677
        type = CODEC_TYPE_SUBTITLE;
1678
        codec_id = CODEC_ID_DVD_SUBTITLE;
1679
    } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
1680
        type = CODEC_TYPE_VIDEO;
1681
        codec_id = CODEC_ID_VC1;
1682
    } else {
1683
    skip:
1684
        /* skip packet */
1685
        url_fskip(&s->pb, len);
1686
        goto redo;
1687
    }
1688
    /* no stream found: add a new stream */
1689
    st = av_new_stream(s, startcode);
1690
    if (!st)
1691
        goto skip;
1692
    st->codec->codec_type = type;
1693
    st->codec->codec_id = codec_id;
1694
    if (codec_id != CODEC_ID_PCM_S16BE)
1695
        st->need_parsing = 1;
1696
 found:
1697
    if(st->discard >= AVDISCARD_ALL)
1698
        goto skip;
1699
    if (startcode >= 0xa0 && startcode <= 0xaf) {
1700
        int b1, freq;
1701

    
1702
        /* for LPCM, we just skip the header and consider it is raw
1703
           audio data */
1704
        if (len <= 3)
1705
            goto skip;
1706
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1707
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1708
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1709
        len -= 3;
1710
        freq = (b1 >> 4) & 3;
1711
        st->codec->sample_rate = lpcm_freq_tab[freq];
1712
        st->codec->channels = 1 + (b1 & 7);
1713
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1714
    }
1715
    av_new_packet(pkt, len);
1716
    get_buffer(&s->pb, pkt->data, pkt->size);
1717
    pkt->pts = pts;
1718
    pkt->dts = dts;
1719
    pkt->stream_index = st->index;
1720
#if 0
1721
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1722
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1723
#endif
1724

    
1725
    return 0;
1726
}
1727

    
1728
static int mpegps_read_close(AVFormatContext *s)
1729
{
1730
    return 0;
1731
}
1732

    
1733
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1734
                               int64_t *ppos, int64_t pos_limit)
1735
{
1736
    int len, startcode;
1737
    int64_t pos, pts, dts;
1738

    
1739
    pos = *ppos;
1740
#ifdef DEBUG_SEEK
1741
    printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
1742
#endif
1743
    url_fseek(&s->pb, pos, SEEK_SET);
1744
    for(;;) {
1745
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1746
        if (len < 0) {
1747
#ifdef DEBUG_SEEK
1748
            printf("none (ret=%d)\n", len);
1749
#endif
1750
            return AV_NOPTS_VALUE;
1751
        }
1752
        if (startcode == s->streams[stream_index]->id &&
1753
            dts != AV_NOPTS_VALUE) {
1754
            break;
1755
        }
1756
        url_fskip(&s->pb, len);
1757
    }
1758
#ifdef DEBUG_SEEK
1759
    printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
1760
#endif
1761
    *ppos = pos;
1762
    return dts;
1763
}
1764

    
1765
#ifdef CONFIG_MPEG1SYSTEM_MUXER
1766
AVOutputFormat mpeg1system_muxer = {
1767
    "mpeg",
1768
    "MPEG1 System format",
1769
    "video/mpeg",
1770
    "mpg,mpeg",
1771
    sizeof(MpegMuxContext),
1772
    CODEC_ID_MP2,
1773
    CODEC_ID_MPEG1VIDEO,
1774
    mpeg_mux_init,
1775
    mpeg_mux_write_packet,
1776
    mpeg_mux_end,
1777
};
1778
#endif
1779
#ifdef CONFIG_MPEG1VCD_MUXER
1780
AVOutputFormat mpeg1vcd_muxer = {
1781
    "vcd",
1782
    "MPEG1 System format (VCD)",
1783
    "video/mpeg",
1784
    NULL,
1785
    sizeof(MpegMuxContext),
1786
    CODEC_ID_MP2,
1787
    CODEC_ID_MPEG1VIDEO,
1788
    mpeg_mux_init,
1789
    mpeg_mux_write_packet,
1790
    mpeg_mux_end,
1791
};
1792
#endif
1793
#ifdef CONFIG_MPEG2VOB_MUXER
1794
AVOutputFormat mpeg2vob_muxer = {
1795
    "vob",
1796
    "MPEG2 PS format (VOB)",
1797
    "video/mpeg",
1798
    "vob",
1799
    sizeof(MpegMuxContext),
1800
    CODEC_ID_MP2,
1801
    CODEC_ID_MPEG2VIDEO,
1802
    mpeg_mux_init,
1803
    mpeg_mux_write_packet,
1804
    mpeg_mux_end,
1805
};
1806
#endif
1807

    
1808
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1809
#ifdef CONFIG_MPEG2SVCD_MUXER
1810
AVOutputFormat mpeg2svcd_muxer = {
1811
    "svcd",
1812
    "MPEG2 PS format (VOB)",
1813
    "video/mpeg",
1814
    "vob",
1815
    sizeof(MpegMuxContext),
1816
    CODEC_ID_MP2,
1817
    CODEC_ID_MPEG2VIDEO,
1818
    mpeg_mux_init,
1819
    mpeg_mux_write_packet,
1820
    mpeg_mux_end,
1821
};
1822
#endif
1823

    
1824
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1825
#ifdef CONFIG_MPEG2DVD_MUXER
1826
AVOutputFormat mpeg2dvd_muxer = {
1827
    "dvd",
1828
    "MPEG2 PS format (DVD VOB)",
1829
    "video/mpeg",
1830
    "dvd",
1831
    sizeof(MpegMuxContext),
1832
    CODEC_ID_MP2,
1833
    CODEC_ID_MPEG2VIDEO,
1834
    mpeg_mux_init,
1835
    mpeg_mux_write_packet,
1836
    mpeg_mux_end,
1837
};
1838
#endif
1839

    
1840
#ifdef CONFIG_MPEGPS_DEMUXER
1841
AVInputFormat mpegps_demuxer = {
1842
    "mpeg",
1843
    "MPEG PS format",
1844
    sizeof(MpegDemuxContext),
1845
    mpegps_probe,
1846
    mpegps_read_header,
1847
    mpegps_read_packet,
1848
    mpegps_read_close,
1849
    NULL, //mpegps_read_seek,
1850
    mpegps_read_dts,
1851
    .flags = AVFMT_SHOW_IDS,
1852
};
1853
#endif