Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 755bfeab

History | View | Annotate | Download (57.7 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 does not 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;
1032

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

    
1044
            stream->predecode_packet= pkt_desc->next;
1045
            av_freep(&pkt_desc);
1046
        }
1047
    }
1048

    
1049
    return 0;
1050
}
1051

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

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

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

    
1082
        if(space < s->packet_size && !ignore_constraints)
1083
            continue;
1084

    
1085
        if(next_pkt && next_pkt->dts - scr > max_delay)
1086
            continue;
1087

    
1088
        if(rel_space > best_score){
1089
            best_score= rel_space;
1090
            best_i = i;
1091
            avail_space= space;
1092
        }
1093
    }
1094

    
1095
    if(best_i < 0){
1096
        int64_t best_dts= INT64_MAX;
1097

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

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

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

    
1123
    assert(best_i >= 0);
1124

    
1125
    st = ctx->streams[best_i];
1126
    stream = st->priv_data;
1127

    
1128
    assert(av_fifo_size(&stream->fifo) > 0);
1129

    
1130
    assert(avail_space >= s->packet_size || ignore_constraints);
1131

    
1132
    timestamp_packet= stream->premux_packet;
1133
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1134
        trailer_size= 0;
1135
    }else{
1136
        trailer_size= timestamp_packet->unwritten_size;
1137
        timestamp_packet= timestamp_packet->next;
1138
    }
1139

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

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

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

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

    
1162
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1163
        es_size -= stream->premux_packet->unwritten_size;
1164
        stream->premux_packet= stream->premux_packet->next;
1165
    }
1166
    if(es_size)
1167
        stream->premux_packet->unwritten_size -= es_size;
1168

    
1169
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1170
        return -1;
1171

    
1172
    return 1;
1173
}
1174

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

    
1188
    pts= pkt->pts;
1189
    dts= pkt->dts;
1190

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

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

    
1207
    av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1208

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

    
1219
    av_fifo_write(&stream->fifo, buf, size);
1220

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

    
1228
static int mpeg_mux_end(AVFormatContext *ctx)
1229
{
1230
//    MpegMuxContext *s = ctx->priv_data;
1231
    StreamInfo *stream;
1232
    int i;
1233

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

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

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

    
1251
        assert(av_fifo_size(&stream->fifo) == 0);
1252
        av_fifo_free(&stream->fifo);
1253
    }
1254
    return 0;
1255
}
1256
#endif //CONFIG_MUXERS
1257

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

    
1261
#define MAX_SYNC_SIZE 100000
1262

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

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

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

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

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

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

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

    
1312

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1726
    return 0;
1727
}
1728

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

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

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

    
1766
#ifdef CONFIG_MPEG1SYSTEM_MUXER
1767
AVOutputFormat mpeg1system_muxer = {
1768
    "mpeg",
1769
    "MPEG1 System format",
1770
    "video/mpeg",
1771
    "mpg,mpeg",
1772
    sizeof(MpegMuxContext),
1773
    CODEC_ID_MP2,
1774
    CODEC_ID_MPEG1VIDEO,
1775
    mpeg_mux_init,
1776
    mpeg_mux_write_packet,
1777
    mpeg_mux_end,
1778
};
1779
#endif
1780
#ifdef CONFIG_MPEG1VCD_MUXER
1781
AVOutputFormat mpeg1vcd_muxer = {
1782
    "vcd",
1783
    "MPEG1 System format (VCD)",
1784
    "video/mpeg",
1785
    NULL,
1786
    sizeof(MpegMuxContext),
1787
    CODEC_ID_MP2,
1788
    CODEC_ID_MPEG1VIDEO,
1789
    mpeg_mux_init,
1790
    mpeg_mux_write_packet,
1791
    mpeg_mux_end,
1792
};
1793
#endif
1794
#ifdef CONFIG_MPEG2VOB_MUXER
1795
AVOutputFormat mpeg2vob_muxer = {
1796
    "vob",
1797
    "MPEG2 PS format (VOB)",
1798
    "video/mpeg",
1799
    "vob",
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
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1810
#ifdef CONFIG_MPEG2SVCD_MUXER
1811
AVOutputFormat mpeg2svcd_muxer = {
1812
    "svcd",
1813
    "MPEG2 PS format (VOB)",
1814
    "video/mpeg",
1815
    "vob",
1816
    sizeof(MpegMuxContext),
1817
    CODEC_ID_MP2,
1818
    CODEC_ID_MPEG2VIDEO,
1819
    mpeg_mux_init,
1820
    mpeg_mux_write_packet,
1821
    mpeg_mux_end,
1822
};
1823
#endif
1824

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

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