Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpegenc.c @ 5d385746

History | View | Annotate | Download (41.2 KB)

1
/*
2
 * MPEG1/2 muxer
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

    
22
#include "avformat.h"
23
#include "allformats.h"
24
#include "bitstream.h"
25
#include "fifo.h"
26
#include "mpeg.h"
27

    
28
#define MAX_PAYLOAD_SIZE 4096
29
//#define DEBUG_SEEK
30

    
31
#undef NDEBUG
32
#include <assert.h>
33

    
34
typedef struct PacketDesc {
35
    int64_t pts;
36
    int64_t dts;
37
    int size;
38
    int unwritten_size;
39
    int flags;
40
    struct PacketDesc *next;
41
} PacketDesc;
42

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

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

    
75
    double vcd_padding_bitrate; //FIXME floats
76
    int64_t vcd_padding_bytes_written;
77

    
78
} MpegMuxContext;
79

    
80
static int put_pack_header(AVFormatContext *ctx,
81
                           uint8_t *buf, int64_t timestamp)
82
{
83
    MpegMuxContext *s = ctx->priv_data;
84
    PutBitContext pb;
85

    
86
    init_put_bits(&pb, buf, 128);
87

    
88
    put_bits(&pb, 32, PACK_START_CODE);
89
    if (s->is_mpeg2) {
90
        put_bits(&pb, 2, 0x1);
91
    } else {
92
        put_bits(&pb, 4, 0x2);
93
    }
94
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
95
    put_bits(&pb, 1, 1);
96
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
97
    put_bits(&pb, 1, 1);
98
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
99
    put_bits(&pb, 1, 1);
100
    if (s->is_mpeg2) {
101
        /* clock extension */
102
        put_bits(&pb, 9, 0);
103
    }
104
    put_bits(&pb, 1, 1);
105
    put_bits(&pb, 22, s->mux_rate);
106
    put_bits(&pb, 1, 1);
107
    if (s->is_mpeg2) {
108
        put_bits(&pb, 1, 1);
109
        put_bits(&pb, 5, 0x1f); /* reserved */
110
        put_bits(&pb, 3, 0); /* stuffing length */
111
    }
112
    flush_put_bits(&pb);
113
    return pbBufPtr(&pb) - pb.buf;
114
}
115

    
116
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
117
{
118
    MpegMuxContext *s = ctx->priv_data;
119
    int size, i, private_stream_coded, id;
120
    PutBitContext pb;
121

    
122
    init_put_bits(&pb, buf, 128);
123

    
124
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
125
    put_bits(&pb, 16, 0);
126
    put_bits(&pb, 1, 1);
127

    
128
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
129
    put_bits(&pb, 1, 1); /* marker */
130
    if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
131
        /* This header applies only to the video stream (see VCD standard p. IV-7)*/
132
        put_bits(&pb, 6, 0);
133
    } else
134
        put_bits(&pb, 6, s->audio_bound);
135

    
136
    if (s->is_vcd) {
137
        /* see VCD standard, p. IV-7*/
138
        put_bits(&pb, 1, 0);
139
        put_bits(&pb, 1, 1);
140
    } else {
141
        put_bits(&pb, 1, 0); /* variable bitrate*/
142
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
143
    }
144

    
145
    if (s->is_vcd || s->is_dvd) {
146
        /* see VCD standard p IV-7 */
147
        put_bits(&pb, 1, 1); /* audio locked */
148
        put_bits(&pb, 1, 1); /* video locked */
149
    } else {
150
        put_bits(&pb, 1, 0); /* audio locked */
151
        put_bits(&pb, 1, 0); /* video locked */
152
    }
153

    
154
    put_bits(&pb, 1, 1); /* marker */
155

    
156
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
157
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
158
        put_bits(&pb, 5, 0);
159
    } else
160
        put_bits(&pb, 5, s->video_bound);
161

    
162
    if (s->is_dvd) {
163
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
164
        put_bits(&pb, 7, 0x7f); /* reserved byte */
165
    } else
166
        put_bits(&pb, 8, 0xff); /* reserved byte */
167

    
168
    /* DVD-Video Stream_bound entries
169
    id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
170
    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)
171
    id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
172
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
173
    if (s->is_dvd) {
174

    
175
        int P_STD_max_video = 0;
176
        int P_STD_max_mpeg_audio = 0;
177
        int P_STD_max_mpeg_PS1 = 0;
178

    
179
        for(i=0;i<ctx->nb_streams;i++) {
180
            StreamInfo *stream = ctx->streams[i]->priv_data;
181

    
182
            id = stream->id;
183
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
184
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
185
            } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
186
                P_STD_max_mpeg_audio = stream->max_buffer_size;
187
            } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
188
                P_STD_max_video = stream->max_buffer_size;
189
            }
190
        }
191

    
192
        /* video */
193
        put_bits(&pb, 8, 0xb9); /* stream ID */
194
        put_bits(&pb, 2, 3);
195
        put_bits(&pb, 1, 1);
196
        put_bits(&pb, 13, P_STD_max_video / 1024);
197

    
198
        /* audio */
199
        if (P_STD_max_mpeg_audio == 0)
200
            P_STD_max_mpeg_audio = 4096;
201
        put_bits(&pb, 8, 0xb8); /* stream ID */
202
        put_bits(&pb, 2, 3);
203
        put_bits(&pb, 1, 0);
204
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
205

    
206
        /* private stream 1 */
207
        put_bits(&pb, 8, 0xbd); /* stream ID */
208
        put_bits(&pb, 2, 3);
209
        put_bits(&pb, 1, 0);
210
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
211

    
212
        /* private stream 2 */
213
        put_bits(&pb, 8, 0xbf); /* stream ID */
214
        put_bits(&pb, 2, 3);
215
        put_bits(&pb, 1, 1);
216
        put_bits(&pb, 13, 2);
217
    }
218
    else {
219
        /* audio stream info */
220
        private_stream_coded = 0;
221
        for(i=0;i<ctx->nb_streams;i++) {
222
            StreamInfo *stream = ctx->streams[i]->priv_data;
223

    
224

    
225
            /* For VCDs, only include the stream info for the stream
226
            that the pack which contains this system belongs to.
227
            (see VCD standard p. IV-7) */
228
            if ( !s->is_vcd || stream->id==only_for_stream_id
229
                || only_for_stream_id==0) {
230

    
231
                id = stream->id;
232
                if (id < 0xc0) {
233
                    /* special case for private streams (AC3 use that) */
234
                    if (private_stream_coded)
235
                        continue;
236
                    private_stream_coded = 1;
237
                    id = 0xbd;
238
                }
239
                put_bits(&pb, 8, id); /* stream ID */
240
                put_bits(&pb, 2, 3);
241
                if (id < 0xe0) {
242
                    /* audio */
243
                    put_bits(&pb, 1, 0);
244
                    put_bits(&pb, 13, stream->max_buffer_size / 128);
245
                } else {
246
                    /* video */
247
                    put_bits(&pb, 1, 1);
248
                    put_bits(&pb, 13, stream->max_buffer_size / 1024);
249
                }
250
            }
251
        }
252
    }
253

    
254
    flush_put_bits(&pb);
255
    size = pbBufPtr(&pb) - pb.buf;
256
    /* patch packet size */
257
    buf[4] = (size - 6) >> 8;
258
    buf[5] = (size - 6) & 0xff;
259

    
260
    return size;
261
}
262

    
263
static int get_system_header_size(AVFormatContext *ctx)
264
{
265
    int buf_index, i, private_stream_coded;
266
    StreamInfo *stream;
267
    MpegMuxContext *s = ctx->priv_data;
268

    
269
    if (s->is_dvd)
270
       return 18; // DVD-Video system headers are 18 bytes fixed length.
271

    
272
    buf_index = 12;
273
    private_stream_coded = 0;
274
    for(i=0;i<ctx->nb_streams;i++) {
275
        stream = ctx->streams[i]->priv_data;
276
        if (stream->id < 0xc0) {
277
            if (private_stream_coded)
278
                continue;
279
            private_stream_coded = 1;
280
        }
281
        buf_index += 3;
282
    }
283
    return buf_index;
284
}
285

    
286
static int mpeg_mux_init(AVFormatContext *ctx)
287
{
288
    MpegMuxContext *s = ctx->priv_data;
289
    int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
290
    AVStream *st;
291
    StreamInfo *stream;
292
    int audio_bitrate;
293
    int video_bitrate;
294

    
295
    s->packet_number = 0;
296
    s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
297
    s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
298
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
299
    s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
300

    
301
    if(ctx->packet_size)
302
        s->packet_size = ctx->packet_size;
303
    else
304
        s->packet_size = 2048;
305

    
306
    s->vcd_padding_bytes_written = 0;
307
    s->vcd_padding_bitrate=0;
308

    
309
    s->audio_bound = 0;
310
    s->video_bound = 0;
311
    mpa_id = AUDIO_ID;
312
    ac3_id = AC3_ID;
313
    dts_id = DTS_ID;
314
    mpv_id = VIDEO_ID;
315
    mps_id = SUB_ID;
316
    lpcm_id = LPCM_ID;
317
    for(i=0;i<ctx->nb_streams;i++) {
318
        st = ctx->streams[i];
319
        stream = av_mallocz(sizeof(StreamInfo));
320
        if (!stream)
321
            goto fail;
322
        st->priv_data = stream;
323

    
324
        av_set_pts_info(st, 64, 1, 90000);
325

    
326
        switch(st->codec->codec_type) {
327
        case CODEC_TYPE_AUDIO:
328
            if (st->codec->codec_id == CODEC_ID_AC3) {
329
                stream->id = ac3_id++;
330
            } else if (st->codec->codec_id == CODEC_ID_DTS) {
331
                stream->id = dts_id++;
332
            } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
333
                stream->id = lpcm_id++;
334
                for(j = 0; j < 4; j++) {
335
                    if (lpcm_freq_tab[j] == st->codec->sample_rate)
336
                        break;
337
                }
338
                if (j == 4)
339
                    goto fail;
340
                if (st->codec->channels > 8)
341
                    return -1;
342
                stream->lpcm_header[0] = 0x0c;
343
                stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
344
                stream->lpcm_header[2] = 0x80;
345
                stream->lpcm_align = st->codec->channels * 2;
346
            } else {
347
                stream->id = mpa_id++;
348
            }
349

    
350
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
351
               Right now it is also used for everything else.*/
352
            stream->max_buffer_size = 4 * 1024;
353
            s->audio_bound++;
354
            break;
355
        case CODEC_TYPE_VIDEO:
356
            stream->id = mpv_id++;
357
            if (st->codec->rc_buffer_size)
358
                stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
359
            else
360
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
361
#if 0
362
                /* see VCD standard, p. IV-7*/
363
                stream->max_buffer_size = 46 * 1024;
364
            else
365
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
366
                   Right now it is also used for everything else.*/
367
                stream->max_buffer_size = 230 * 1024;
368
#endif
369
            s->video_bound++;
370
            break;
371
        case CODEC_TYPE_SUBTITLE:
372
            stream->id = mps_id++;
373
            stream->max_buffer_size = 16 * 1024;
374
            break;
375
        default:
376
            return -1;
377
        }
378
        av_fifo_init(&stream->fifo, 16);
379
    }
380
    bitrate = 0;
381
    audio_bitrate = 0;
382
    video_bitrate = 0;
383
    for(i=0;i<ctx->nb_streams;i++) {
384
        int codec_rate;
385
        st = ctx->streams[i];
386
        stream = (StreamInfo*) st->priv_data;
387

    
388
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
389
            codec_rate= st->codec->rc_max_rate;
390
        else
391
            codec_rate= st->codec->bit_rate;
392

    
393
        if(!codec_rate)
394
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
395

    
396
        bitrate += codec_rate;
397

    
398
        if (stream->id==AUDIO_ID)
399
            audio_bitrate += codec_rate;
400
        else if (stream->id==VIDEO_ID)
401
            video_bitrate += codec_rate;
402
    }
403

    
404
    if(ctx->mux_rate){
405
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
406
    } else {
407
        /* we increase slightly the bitrate to take into account the
408
           headers. XXX: compute it exactly */
409
        bitrate += bitrate*5/100;
410
        bitrate += 10000;
411
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
412
    }
413

    
414
    if (s->is_vcd) {
415
        double overhead_rate;
416

    
417
        /* The VCD standard mandates that the mux_rate field is 3528
418
           (see standard p. IV-6).
419
           The value is actually "wrong", i.e. if you calculate
420
           it using the normal formula and the 75 sectors per second transfer
421
           rate you get a different value because the real pack size is 2324,
422
           not 2352. But the standard explicitly specifies that the mux_rate
423
           field in the header must have this value.*/
424
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
425

    
426
        /* The VCD standard states that the muxed stream must be
427
           exactly 75 packs / second (the data rate of a single speed cdrom).
428
           Since the video bitrate (probably 1150000 bits/sec) will be below
429
           the theoretical maximum we have to add some padding packets
430
           to make up for the lower data rate.
431
           (cf. VCD standard p. IV-6 )*/
432

    
433
        /* Add the header overhead to the data rate.
434
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
435
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
436
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
437
        overhead_rate *= 8;
438

    
439
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
440
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
441
    }
442

    
443
    if (s->is_vcd || s->is_mpeg2)
444
        /* every packet */
445
        s->pack_header_freq = 1;
446
    else
447
        /* every 2 seconds */
448
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
449

    
450
    /* the above seems to make pack_header_freq zero sometimes */
451
    if (s->pack_header_freq == 0)
452
       s->pack_header_freq = 1;
453

    
454
    if (s->is_mpeg2)
455
        /* every 200 packets. Need to look at the spec.  */
456
        s->system_header_freq = s->pack_header_freq * 40;
457
    else if (s->is_vcd)
458
        /* the standard mandates that there are only two system headers
459
           in the whole file: one in the first packet of each stream.
460
           (see standard p. IV-7 and IV-8) */
461
        s->system_header_freq = 0x7fffffff;
462
    else
463
        s->system_header_freq = s->pack_header_freq * 5;
464

    
465
    for(i=0;i<ctx->nb_streams;i++) {
466
        stream = ctx->streams[i]->priv_data;
467
        stream->packet_number = 0;
468
    }
469
    s->system_header_size = get_system_header_size(ctx);
470
    s->last_scr = 0;
471
    return 0;
472
 fail:
473
    for(i=0;i<ctx->nb_streams;i++) {
474
        av_free(ctx->streams[i]->priv_data);
475
    }
476
    return AVERROR(ENOMEM);
477
}
478

    
479
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
480
{
481
    put_byte(pb,
482
             (id << 4) |
483
             (((timestamp >> 30) & 0x07) << 1) |
484
             1);
485
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
486
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
487
}
488

    
489

    
490
/* return the number of padding bytes that should be inserted into
491
   the multiplexed stream.*/
492
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
493
{
494
    MpegMuxContext *s = ctx->priv_data;
495
    int pad_bytes = 0;
496

    
497
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
498
    {
499
        int64_t full_pad_bytes;
500

    
501
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
502
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
503

    
504
        if (pad_bytes<0)
505
            /* might happen if we have already padded to a later timestamp. This
506
               can occur if another stream has already advanced further.*/
507
            pad_bytes=0;
508
    }
509

    
510
    return pad_bytes;
511
}
512

    
513

    
514
#if 0 /* unused, remove? */
515
/* return the exact available payload size for the next packet for
516
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
517
   timestamps are needed in the packet header. */
518
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
519
                                   int64_t pts, int64_t dts)
520
{
521
    MpegMuxContext *s = ctx->priv_data;
522
    int buf_index;
523
    StreamInfo *stream;
524

525
    stream = ctx->streams[stream_index]->priv_data;
526

527
    buf_index = 0;
528
    if (((s->packet_number % s->pack_header_freq) == 0)) {
529
        /* pack header size */
530
        if (s->is_mpeg2)
531
            buf_index += 14;
532
        else
533
            buf_index += 12;
534

535
        if (s->is_vcd) {
536
            /* there is exactly one system header for each stream in a VCD MPEG,
537
               One in the very first video packet and one in the very first
538
               audio packet (see VCD standard p. IV-7 and IV-8).*/
539

540
            if (stream->packet_number==0)
541
                /* The system headers refer only to the stream they occur in,
542
                   so they have a constant size.*/
543
                buf_index += 15;
544

545
        } else {
546
            if ((s->packet_number % s->system_header_freq) == 0)
547
                buf_index += s->system_header_size;
548
        }
549
    }
550

551
    if ((s->is_vcd && stream->packet_number==0)
552
        || (s->is_svcd && s->packet_number==0))
553
        /* the first pack of each stream contains only the pack header,
554
           the system header and some padding (see VCD standard p. IV-6)
555
           Add the padding size, so that the actual payload becomes 0.*/
556
        buf_index += s->packet_size - buf_index;
557
    else {
558
        /* packet header size */
559
        buf_index += 6;
560
        if (s->is_mpeg2) {
561
            buf_index += 3;
562
            if (stream->packet_number==0)
563
                buf_index += 3; /* PES extension */
564
            buf_index += 1;    /* obligatory stuffing byte */
565
        }
566
        if (pts != AV_NOPTS_VALUE) {
567
            if (dts != pts)
568
                buf_index += 5 + 5;
569
            else
570
                buf_index += 5;
571

572
        } else {
573
            if (!s->is_mpeg2)
574
                buf_index++;
575
        }
576

577
        if (stream->id < 0xc0) {
578
            /* AC3/LPCM private data header */
579
            buf_index += 4;
580
            if (stream->id >= 0xa0) {
581
                int n;
582
                buf_index += 3;
583
                /* NOTE: we round the payload size to an integer number of
584
                   LPCM samples */
585
                n = (s->packet_size - buf_index) % stream->lpcm_align;
586
                if (n)
587
                    buf_index += (stream->lpcm_align - n);
588
            }
589
        }
590

591
        if (s->is_vcd && stream->id == AUDIO_ID)
592
            /* The VCD standard demands that 20 zero bytes follow
593
               each audio packet (see standard p. IV-8).*/
594
            buf_index+=20;
595
    }
596
    return s->packet_size - buf_index;
597
}
598
#endif
599

    
600
/* Write an MPEG padding packet header. */
601
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
602
{
603
    MpegMuxContext *s = ctx->priv_data;
604
    int i;
605

    
606
    put_be32(pb, PADDING_STREAM);
607
    put_be16(pb, packet_bytes - 6);
608
    if (!s->is_mpeg2) {
609
        put_byte(pb, 0x0f);
610
        packet_bytes -= 7;
611
    } else
612
        packet_bytes -= 6;
613

    
614
    for(i=0;i<packet_bytes;i++)
615
        put_byte(pb, 0xff);
616
}
617

    
618
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
619
    int nb_frames=0;
620
    PacketDesc *pkt_desc= stream->premux_packet;
621

    
622
    while(len>0){
623
        if(pkt_desc->size == pkt_desc->unwritten_size)
624
            nb_frames++;
625
        len -= pkt_desc->unwritten_size;
626
        pkt_desc= pkt_desc->next;
627
    }
628

    
629
    return nb_frames;
630
}
631

    
632
/* flush the packet on stream stream_index */
633
static int flush_packet(AVFormatContext *ctx, int stream_index,
634
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
635
{
636
    MpegMuxContext *s = ctx->priv_data;
637
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
638
    uint8_t *buf_ptr;
639
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
640
    int packet_size;
641
    uint8_t buffer[128];
642
    int zero_trail_bytes = 0;
643
    int pad_packet_bytes = 0;
644
    int pes_flags;
645
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
646
    int nb_frames;
647

    
648
    id = stream->id;
649

    
650
#if 0
651
    printf("packet ID=%2x PTS=%0.3f\n",
652
           id, pts / 90000.0);
653
#endif
654

    
655
    buf_ptr = buffer;
656

    
657
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
658
        /* output pack and systems header if needed */
659
        size = put_pack_header(ctx, buf_ptr, scr);
660
        buf_ptr += size;
661
        s->last_scr= scr;
662

    
663
        if (s->is_vcd) {
664
            /* there is exactly one system header for each stream in a VCD MPEG,
665
               One in the very first video packet and one in the very first
666
               audio packet (see VCD standard p. IV-7 and IV-8).*/
667

    
668
            if (stream->packet_number==0) {
669
                size = put_system_header(ctx, buf_ptr, id);
670
                buf_ptr += size;
671
            }
672
        } else if (s->is_dvd) {
673
            if (stream->align_iframe || s->packet_number == 0){
674
                int PES_bytes_to_fill = s->packet_size - size - 10;
675

    
676
                if (pts != AV_NOPTS_VALUE) {
677
                    if (dts != pts)
678
                        PES_bytes_to_fill -= 5 + 5;
679
                    else
680
                        PES_bytes_to_fill -= 5;
681
                }
682

    
683
                if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
684
                    size = put_system_header(ctx, buf_ptr, 0);
685
                    buf_ptr += size;
686
                    size = buf_ptr - buffer;
687
                    put_buffer(&ctx->pb, buffer, size);
688

    
689
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
690
                    put_be16(&ctx->pb, 0x03d4);         // length
691
                    put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
692
                    for (i = 0; i < 979; i++)
693
                        put_byte(&ctx->pb, 0x00);
694

    
695
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
696
                    put_be16(&ctx->pb, 0x03fa);         // length
697
                    put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
698
                    for (i = 0; i < 1017; i++)
699
                        put_byte(&ctx->pb, 0x00);
700

    
701
                    memset(buffer, 0, 128);
702
                    buf_ptr = buffer;
703
                    s->packet_number++;
704
                    stream->align_iframe = 0;
705
                    scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
706
                    size = put_pack_header(ctx, buf_ptr, scr);
707
                    s->last_scr= scr;
708
                    buf_ptr += size;
709
                    /* GOP Start */
710
                } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
711
                    pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
712
                }
713
            }
714
        } else {
715
            if ((s->packet_number % s->system_header_freq) == 0) {
716
                size = put_system_header(ctx, buf_ptr, 0);
717
                buf_ptr += size;
718
            }
719
        }
720
    }
721
    size = buf_ptr - buffer;
722
    put_buffer(&ctx->pb, buffer, size);
723

    
724
    packet_size = s->packet_size - size;
725

    
726
    if (s->is_vcd && id == AUDIO_ID)
727
        /* The VCD standard demands that 20 zero bytes follow
728
           each audio pack (see standard p. IV-8).*/
729
        zero_trail_bytes += 20;
730

    
731
    if ((s->is_vcd && stream->packet_number==0)
732
        || (s->is_svcd && s->packet_number==0)) {
733
        /* for VCD the first pack of each stream contains only the pack header,
734
           the system header and lots of padding (see VCD standard p. IV-6).
735
           In the case of an audio pack, 20 zero bytes are also added at
736
           the end.*/
737
        /* For SVCD we fill the very first pack to increase compatibility with
738
           some DVD players. Not mandated by the standard.*/
739
        if (s->is_svcd)
740
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
741
        pad_packet_bytes = packet_size - zero_trail_bytes;
742
    }
743

    
744
    packet_size -= pad_packet_bytes + zero_trail_bytes;
745

    
746
    if (packet_size > 0) {
747

    
748
        /* packet header size */
749
        packet_size -= 6;
750

    
751
        /* packet header */
752
        if (s->is_mpeg2) {
753
            header_len = 3;
754
            if (stream->packet_number==0)
755
                header_len += 3; /* PES extension */
756
            header_len += 1; /* obligatory stuffing byte */
757
        } else {
758
            header_len = 0;
759
        }
760
        if (pts != AV_NOPTS_VALUE) {
761
            if (dts != pts)
762
                header_len += 5 + 5;
763
            else
764
                header_len += 5;
765
        } else {
766
            if (!s->is_mpeg2)
767
                header_len++;
768
        }
769

    
770
        payload_size = packet_size - header_len;
771
        if (id < 0xc0) {
772
            startcode = PRIVATE_STREAM_1;
773
            payload_size -= 1;
774
            if (id >= 0x40) {
775
                payload_size -= 3;
776
                if (id >= 0xa0)
777
                    payload_size -= 3;
778
            }
779
        } else {
780
            startcode = 0x100 + id;
781
        }
782

    
783
        stuffing_size = payload_size - av_fifo_size(&stream->fifo);
784

    
785
        // first byte does not fit -> reset pts/dts + stuffing
786
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
787
            int timestamp_len=0;
788
            if(dts != pts)
789
                timestamp_len += 5;
790
            if(pts != AV_NOPTS_VALUE)
791
                timestamp_len += s->is_mpeg2 ? 5 : 4;
792
            pts=dts= AV_NOPTS_VALUE;
793
            header_len -= timestamp_len;
794
            if (s->is_dvd && stream->align_iframe) {
795
                pad_packet_bytes += timestamp_len;
796
                packet_size -= timestamp_len;
797
            } else {
798
                payload_size += timestamp_len;
799
            }
800
            stuffing_size += timestamp_len;
801
            if(payload_size > trailer_size)
802
                stuffing_size += payload_size - trailer_size;
803
        }
804

    
805
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
806
            packet_size += pad_packet_bytes;
807
            payload_size += pad_packet_bytes; // undo the previous adjustment
808
            if (stuffing_size < 0) {
809
                stuffing_size = pad_packet_bytes;
810
            } else {
811
                stuffing_size += pad_packet_bytes;
812
            }
813
            pad_packet_bytes = 0;
814
        }
815

    
816
        if (stuffing_size < 0)
817
            stuffing_size = 0;
818
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
819
            pad_packet_bytes += stuffing_size;
820
            packet_size -= stuffing_size;
821
            payload_size -= stuffing_size;
822
            stuffing_size = 0;
823
        }
824

    
825
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
826

    
827
        put_be32(&ctx->pb, startcode);
828

    
829
        put_be16(&ctx->pb, packet_size);
830

    
831
        if (!s->is_mpeg2)
832
            for(i=0;i<stuffing_size;i++)
833
                put_byte(&ctx->pb, 0xff);
834

    
835
        if (s->is_mpeg2) {
836
            put_byte(&ctx->pb, 0x80); /* mpeg2 id */
837

    
838
            pes_flags=0;
839

    
840
            if (pts != AV_NOPTS_VALUE) {
841
                pes_flags |= 0x80;
842
                if (dts != pts)
843
                    pes_flags |= 0x40;
844
            }
845

    
846
            /* Both the MPEG-2 and the SVCD standards demand that the
847
               P-STD_buffer_size field be included in the first packet of
848
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
849
               and MPEG-2 standard 2.7.7) */
850
            if (stream->packet_number == 0)
851
                pes_flags |= 0x01;
852

    
853
            put_byte(&ctx->pb, pes_flags); /* flags */
854
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
855

    
856
            if (pes_flags & 0x80)  /*write pts*/
857
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
858
            if (pes_flags & 0x40)  /*write dts*/
859
                put_timestamp(&ctx->pb, 0x01, dts);
860

    
861
            if (pes_flags & 0x01) {  /*write pes extension*/
862
                put_byte(&ctx->pb, 0x10); /* flags */
863

    
864
                /* P-STD buffer info */
865
                if (id == AUDIO_ID)
866
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
867
                else
868
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
869
            }
870

    
871
        } else {
872
            if (pts != AV_NOPTS_VALUE) {
873
                if (dts != pts) {
874
                    put_timestamp(&ctx->pb, 0x03, pts);
875
                    put_timestamp(&ctx->pb, 0x01, dts);
876
                } else {
877
                    put_timestamp(&ctx->pb, 0x02, pts);
878
                }
879
            } else {
880
                put_byte(&ctx->pb, 0x0f);
881
            }
882
        }
883

    
884
        if (s->is_mpeg2) {
885
            /* special stuffing byte that is always written
886
               to prevent accidental generation of start codes. */
887
            put_byte(&ctx->pb, 0xff);
888

    
889
            for(i=0;i<stuffing_size;i++)
890
                put_byte(&ctx->pb, 0xff);
891
        }
892

    
893
        if (startcode == PRIVATE_STREAM_1) {
894
            put_byte(&ctx->pb, id);
895
            if (id >= 0xa0) {
896
                /* LPCM (XXX: check nb_frames) */
897
                put_byte(&ctx->pb, 7);
898
                put_be16(&ctx->pb, 4); /* skip 3 header bytes */
899
                put_byte(&ctx->pb, stream->lpcm_header[0]);
900
                put_byte(&ctx->pb, stream->lpcm_header[1]);
901
                put_byte(&ctx->pb, stream->lpcm_header[2]);
902
            } else if (id >= 0x40) {
903
                /* AC3 */
904
                put_byte(&ctx->pb, nb_frames);
905
                put_be16(&ctx->pb, trailer_size+1);
906
            }
907
        }
908

    
909
        /* output data */
910
        if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
911
            return -1;
912
        stream->bytes_to_iframe -= payload_size - stuffing_size;
913
    }else{
914
        payload_size=
915
        stuffing_size= 0;
916
    }
917

    
918
    if (pad_packet_bytes > 0)
919
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
920

    
921
    for(i=0;i<zero_trail_bytes;i++)
922
        put_byte(&ctx->pb, 0x00);
923

    
924
    put_flush_packet(&ctx->pb);
925

    
926
    s->packet_number++;
927

    
928
    /* only increase the stream packet number if this pack actually contains
929
       something that is specific to this stream! I.e. a dedicated header
930
       or some data.*/
931
    if (!general_pack)
932
        stream->packet_number++;
933

    
934
    return payload_size - stuffing_size;
935
}
936

    
937
static void put_vcd_padding_sector(AVFormatContext *ctx)
938
{
939
    /* There are two ways to do this padding: writing a sector/pack
940
       of 0 values, or writing an MPEG padding pack. Both seem to
941
       work with most decoders, BUT the VCD standard only allows a 0-sector
942
       (see standard p. IV-4, IV-5).
943
       So a 0-sector it is...*/
944

    
945
    MpegMuxContext *s = ctx->priv_data;
946
    int i;
947

    
948
    for(i=0;i<s->packet_size;i++)
949
        put_byte(&ctx->pb, 0);
950

    
951
    s->vcd_padding_bytes_written += s->packet_size;
952

    
953
    put_flush_packet(&ctx->pb);
954

    
955
    /* increasing the packet number is correct. The SCR of the following packs
956
       is calculated from the packet_number and it has to include the padding
957
       sector (it represents the sector index, not the MPEG pack index)
958
       (see VCD standard p. IV-6)*/
959
    s->packet_number++;
960
}
961

    
962
#if 0 /* unused, remove? */
963
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
964
{
965
    MpegMuxContext *s = ctx->priv_data;
966
    int64_t scr;
967

968
        /* Since the data delivery rate is constant, SCR is computed
969
           using the formula C + i * 1200 where C is the start constant
970
           and i is the pack index.
971
           It is recommended that SCR 0 is at the beginning of the VCD front
972
           margin (a sequence of empty Form 2 sectors on the CD).
973
           It is recommended that the front margin is 30 sectors long, so
974
           we use C = 30*1200 = 36000
975
           (Note that even if the front margin is not 30 sectors the file
976
           will still be correct according to the standard. It just won't have
977
           the "recommended" value).*/
978
        scr = 36000 + s->packet_number * 1200;
979

980
    return scr;
981
}
982
#endif
983

    
984
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
985
//    MpegMuxContext *s = ctx->priv_data;
986
    int i;
987

    
988
    for(i=0; i<ctx->nb_streams; i++){
989
        AVStream *st = ctx->streams[i];
990
        StreamInfo *stream = st->priv_data;
991
        PacketDesc *pkt_desc;
992

    
993
        while((pkt_desc= stream->predecode_packet)
994
              && scr > pkt_desc->dts){ //FIXME > vs >=
995
            if(stream->buffer_index < pkt_desc->size ||
996
               stream->predecode_packet == stream->premux_packet){
997
                av_log(ctx, AV_LOG_ERROR,
998
                       "buffer underflow i=%d bufi=%d size=%d\n",
999
                       i, stream->buffer_index, pkt_desc->size);
1000
                break;
1001
            }
1002
            stream->buffer_index -= pkt_desc->size;
1003

    
1004
            stream->predecode_packet= pkt_desc->next;
1005
            av_freep(&pkt_desc);
1006
        }
1007
    }
1008

    
1009
    return 0;
1010
}
1011

    
1012
static int output_packet(AVFormatContext *ctx, int flush){
1013
    MpegMuxContext *s = ctx->priv_data;
1014
    AVStream *st;
1015
    StreamInfo *stream;
1016
    int i, avail_space, es_size, trailer_size;
1017
    int best_i= -1;
1018
    int best_score= INT_MIN;
1019
    int ignore_constraints=0;
1020
    int64_t scr= s->last_scr;
1021
    PacketDesc *timestamp_packet;
1022
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1023

    
1024
retry:
1025
    for(i=0; i<ctx->nb_streams; i++){
1026
        AVStream *st = ctx->streams[i];
1027
        StreamInfo *stream = st->priv_data;
1028
        const int avail_data=  av_fifo_size(&stream->fifo);
1029
        const int space= stream->max_buffer_size - stream->buffer_index;
1030
        int rel_space= 1024*space / stream->max_buffer_size;
1031
        PacketDesc *next_pkt= stream->premux_packet;
1032

    
1033
        /* for subtitle, a single PES packet must be generated,
1034
           so we flush after every single subtitle packet */
1035
        if(s->packet_size > avail_data && !flush
1036
           && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1037
            return 0;
1038
        if(avail_data==0)
1039
            continue;
1040
        assert(avail_data>0);
1041

    
1042
        if(space < s->packet_size && !ignore_constraints)
1043
            continue;
1044

    
1045
        if(next_pkt && next_pkt->dts - scr > max_delay)
1046
            continue;
1047

    
1048
        if(rel_space > best_score){
1049
            best_score= rel_space;
1050
            best_i = i;
1051
            avail_space= space;
1052
        }
1053
    }
1054

    
1055
    if(best_i < 0){
1056
        int64_t best_dts= INT64_MAX;
1057

    
1058
        for(i=0; i<ctx->nb_streams; i++){
1059
            AVStream *st = ctx->streams[i];
1060
            StreamInfo *stream = st->priv_data;
1061
            PacketDesc *pkt_desc= stream->predecode_packet;
1062
            if(pkt_desc && pkt_desc->dts < best_dts)
1063
                best_dts= pkt_desc->dts;
1064
        }
1065

    
1066
#if 0
1067
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1068
               scr/90000.0, best_dts/90000.0);
1069
#endif
1070
        if(best_dts == INT64_MAX)
1071
            return 0;
1072

    
1073
        if(scr >= best_dts+1 && !ignore_constraints){
1074
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1075
            ignore_constraints= 1;
1076
        }
1077
        scr= FFMAX(best_dts+1, scr);
1078
        if(remove_decoded_packets(ctx, scr) < 0)
1079
            return -1;
1080
        goto retry;
1081
    }
1082

    
1083
    assert(best_i >= 0);
1084

    
1085
    st = ctx->streams[best_i];
1086
    stream = st->priv_data;
1087

    
1088
    assert(av_fifo_size(&stream->fifo) > 0);
1089

    
1090
    assert(avail_space >= s->packet_size || ignore_constraints);
1091

    
1092
    timestamp_packet= stream->premux_packet;
1093
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1094
        trailer_size= 0;
1095
    }else{
1096
        trailer_size= timestamp_packet->unwritten_size;
1097
        timestamp_packet= timestamp_packet->next;
1098
    }
1099

    
1100
    if(timestamp_packet){
1101
//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);
1102
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1103
    }else{
1104
        assert(av_fifo_size(&stream->fifo) == trailer_size);
1105
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1106
    }
1107

    
1108
    if (s->is_vcd) {
1109
        /* Write one or more padding sectors, if necessary, to reach
1110
           the constant overall bitrate.*/
1111
        int vcd_pad_bytes;
1112

    
1113
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1114
            put_vcd_padding_sector(ctx);
1115
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1116
        }
1117
    }
1118

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

    
1122
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1123
        es_size -= stream->premux_packet->unwritten_size;
1124
        stream->premux_packet= stream->premux_packet->next;
1125
    }
1126
    if(es_size)
1127
        stream->premux_packet->unwritten_size -= es_size;
1128

    
1129
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1130
        return -1;
1131

    
1132
    return 1;
1133
}
1134

    
1135
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1136
{
1137
    MpegMuxContext *s = ctx->priv_data;
1138
    int stream_index= pkt->stream_index;
1139
    int size= pkt->size;
1140
    uint8_t *buf= pkt->data;
1141
    AVStream *st = ctx->streams[stream_index];
1142
    StreamInfo *stream = st->priv_data;
1143
    int64_t pts, dts;
1144
    PacketDesc *pkt_desc;
1145
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1146
    const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1147

    
1148
    pts= pkt->pts;
1149
    dts= pkt->dts;
1150

    
1151
    if(pts != AV_NOPTS_VALUE) pts += preload;
1152
    if(dts != AV_NOPTS_VALUE) dts += preload;
1153

    
1154
//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);
1155
    if (!stream->premux_packet)
1156
        stream->next_packet = &stream->premux_packet;
1157
    *stream->next_packet=
1158
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1159
    pkt_desc->pts= pts;
1160
    pkt_desc->dts= dts;
1161
    pkt_desc->unwritten_size=
1162
    pkt_desc->size= size;
1163
    if(!stream->predecode_packet)
1164
        stream->predecode_packet= pkt_desc;
1165
    stream->next_packet= &pkt_desc->next;
1166

    
1167
    av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1168

    
1169
    if (s->is_dvd){
1170
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1171
            stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1172
            stream->align_iframe = 1;
1173
            stream->vobu_start_pts = pts;
1174
        } else {
1175
            stream->align_iframe = 0;
1176
        }
1177
    }
1178

    
1179
    av_fifo_write(&stream->fifo, buf, size);
1180

    
1181
    for(;;){
1182
        int ret= output_packet(ctx, 0);
1183
        if(ret<=0)
1184
            return ret;
1185
    }
1186
}
1187

    
1188
static int mpeg_mux_end(AVFormatContext *ctx)
1189
{
1190
//    MpegMuxContext *s = ctx->priv_data;
1191
    StreamInfo *stream;
1192
    int i;
1193

    
1194
    for(;;){
1195
        int ret= output_packet(ctx, 1);
1196
        if(ret<0)
1197
            return ret;
1198
        else if(ret==0)
1199
            break;
1200
    }
1201

    
1202
    /* End header according to MPEG1 systems standard. We do not write
1203
       it as it is usually not needed by decoders and because it
1204
       complicates MPEG stream concatenation. */
1205
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1206
    //put_flush_packet(&ctx->pb);
1207

    
1208
    for(i=0;i<ctx->nb_streams;i++) {
1209
        stream = ctx->streams[i]->priv_data;
1210

    
1211
        assert(av_fifo_size(&stream->fifo) == 0);
1212
        av_fifo_free(&stream->fifo);
1213
    }
1214
    return 0;
1215
}
1216

    
1217
#ifdef CONFIG_MPEG1SYSTEM_MUXER
1218
AVOutputFormat mpeg1system_muxer = {
1219
    "mpeg",
1220
    "MPEG1 System format",
1221
    "video/mpeg",
1222
    "mpg,mpeg",
1223
    sizeof(MpegMuxContext),
1224
    CODEC_ID_MP2,
1225
    CODEC_ID_MPEG1VIDEO,
1226
    mpeg_mux_init,
1227
    mpeg_mux_write_packet,
1228
    mpeg_mux_end,
1229
};
1230
#endif
1231
#ifdef CONFIG_MPEG1VCD_MUXER
1232
AVOutputFormat mpeg1vcd_muxer = {
1233
    "vcd",
1234
    "MPEG1 System format (VCD)",
1235
    "video/mpeg",
1236
    NULL,
1237
    sizeof(MpegMuxContext),
1238
    CODEC_ID_MP2,
1239
    CODEC_ID_MPEG1VIDEO,
1240
    mpeg_mux_init,
1241
    mpeg_mux_write_packet,
1242
    mpeg_mux_end,
1243
};
1244
#endif
1245
#ifdef CONFIG_MPEG2VOB_MUXER
1246
AVOutputFormat mpeg2vob_muxer = {
1247
    "vob",
1248
    "MPEG2 PS format (VOB)",
1249
    "video/mpeg",
1250
    "vob",
1251
    sizeof(MpegMuxContext),
1252
    CODEC_ID_MP2,
1253
    CODEC_ID_MPEG2VIDEO,
1254
    mpeg_mux_init,
1255
    mpeg_mux_write_packet,
1256
    mpeg_mux_end,
1257
};
1258
#endif
1259

    
1260
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1261
#ifdef CONFIG_MPEG2SVCD_MUXER
1262
AVOutputFormat mpeg2svcd_muxer = {
1263
    "svcd",
1264
    "MPEG2 PS format (VOB)",
1265
    "video/mpeg",
1266
    "vob",
1267
    sizeof(MpegMuxContext),
1268
    CODEC_ID_MP2,
1269
    CODEC_ID_MPEG2VIDEO,
1270
    mpeg_mux_init,
1271
    mpeg_mux_write_packet,
1272
    mpeg_mux_end,
1273
};
1274
#endif
1275

    
1276
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1277
#ifdef CONFIG_MPEG2DVD_MUXER
1278
AVOutputFormat mpeg2dvd_muxer = {
1279
    "dvd",
1280
    "MPEG2 PS format (DVD VOB)",
1281
    "video/mpeg",
1282
    "dvd",
1283
    sizeof(MpegMuxContext),
1284
    CODEC_ID_MP2,
1285
    CODEC_ID_MPEG2VIDEO,
1286
    mpeg_mux_init,
1287
    mpeg_mux_write_packet,
1288
    mpeg_mux_end,
1289
};
1290
#endif