Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpegenc.c @ 72415b2a

History | View | Annotate | Download (42 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 "libavutil/fifo.h"
23
#include "libavcodec/put_bits.h"
24
#include "avformat.h"
25
#include "mpeg.h"
26

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

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

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

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

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

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

    
77
} MpegMuxContext;
78

    
79
extern AVOutputFormat mpeg1vcd_muxer;
80
extern AVOutputFormat mpeg2dvd_muxer;
81
extern AVOutputFormat mpeg2svcd_muxer;
82
extern AVOutputFormat mpeg2vob_muxer;
83

    
84
static int put_pack_header(AVFormatContext *ctx,
85
                           uint8_t *buf, int64_t timestamp)
86
{
87
    MpegMuxContext *s = ctx->priv_data;
88
    PutBitContext pb;
89

    
90
    init_put_bits(&pb, buf, 128);
91

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

    
120
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
121
{
122
    MpegMuxContext *s = ctx->priv_data;
123
    int size, i, private_stream_coded, id;
124
    PutBitContext pb;
125

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

    
128
    put_bits32(&pb, SYSTEM_HEADER_START_CODE);
129
    put_bits(&pb, 16, 0);
130
    put_bits(&pb, 1, 1);
131

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

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

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

    
158
    put_bits(&pb, 1, 1); /* marker */
159

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

    
166
    if (s->is_dvd) {
167
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
168
        put_bits(&pb, 7, 0x7f); /* reserved byte */
169
    } else
170
        put_bits(&pb, 8, 0xff); /* reserved byte */
171

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

    
179
        int P_STD_max_video = 0;
180
        int P_STD_max_mpeg_audio = 0;
181
        int P_STD_max_mpeg_PS1 = 0;
182

    
183
        for(i=0;i<ctx->nb_streams;i++) {
184
            StreamInfo *stream = ctx->streams[i]->priv_data;
185

    
186
            id = stream->id;
187
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
188
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
189
            } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
190
                P_STD_max_mpeg_audio = stream->max_buffer_size;
191
            } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
192
                P_STD_max_video = stream->max_buffer_size;
193
            }
194
        }
195

    
196
        /* video */
197
        put_bits(&pb, 8, 0xb9); /* stream ID */
198
        put_bits(&pb, 2, 3);
199
        put_bits(&pb, 1, 1);
200
        put_bits(&pb, 13, P_STD_max_video / 1024);
201

    
202
        /* audio */
203
        if (P_STD_max_mpeg_audio == 0)
204
            P_STD_max_mpeg_audio = 4096;
205
        put_bits(&pb, 8, 0xb8); /* stream ID */
206
        put_bits(&pb, 2, 3);
207
        put_bits(&pb, 1, 0);
208
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
209

    
210
        /* private stream 1 */
211
        put_bits(&pb, 8, 0xbd); /* stream ID */
212
        put_bits(&pb, 2, 3);
213
        put_bits(&pb, 1, 0);
214
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
215

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

    
228

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

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

    
258
    flush_put_bits(&pb);
259
    size = put_bits_ptr(&pb) - pb.buf;
260
    /* patch packet size */
261
    buf[4] = (size - 6) >> 8;
262
    buf[5] = (size - 6) & 0xff;
263

    
264
    return size;
265
}
266

    
267
static int get_system_header_size(AVFormatContext *ctx)
268
{
269
    int buf_index, i, private_stream_coded;
270
    StreamInfo *stream;
271
    MpegMuxContext *s = ctx->priv_data;
272

    
273
    if (s->is_dvd)
274
       return 18; // DVD-Video system headers are 18 bytes fixed length.
275

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

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

    
299
    s->packet_number = 0;
300
    s->is_vcd =    (CONFIG_MPEG1VCD_MUXER  && ctx->oformat == &mpeg1vcd_muxer);
301
    s->is_svcd =   (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer);
302
    s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER  && ctx->oformat == &mpeg2vob_muxer) ||
303
                   (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &mpeg2dvd_muxer) ||
304
                   (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer));
305
    s->is_dvd =    (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &mpeg2dvd_muxer);
306

    
307
    if(ctx->packet_size) {
308
        if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
309
            av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
310
                   ctx->packet_size);
311
            goto fail;
312
        }
313
        s->packet_size = ctx->packet_size;
314
    } else
315
        s->packet_size = 2048;
316

    
317
    s->vcd_padding_bytes_written = 0;
318
    s->vcd_padding_bitrate=0;
319

    
320
    s->audio_bound = 0;
321
    s->video_bound = 0;
322
    mpa_id = AUDIO_ID;
323
    ac3_id = AC3_ID;
324
    dts_id = DTS_ID;
325
    mpv_id = VIDEO_ID;
326
    mps_id = SUB_ID;
327
    lpcm_id = LPCM_ID;
328
    for(i=0;i<ctx->nb_streams;i++) {
329
        st = ctx->streams[i];
330
        stream = av_mallocz(sizeof(StreamInfo));
331
        if (!stream)
332
            goto fail;
333
        st->priv_data = stream;
334

    
335
        av_set_pts_info(st, 64, 1, 90000);
336

    
337
        switch(st->codec->codec_type) {
338
        case AVMEDIA_TYPE_AUDIO:
339
            if        (st->codec->codec_id == CODEC_ID_AC3) {
340
                stream->id = ac3_id++;
341
            } else if (st->codec->codec_id == CODEC_ID_DTS) {
342
                stream->id = dts_id++;
343
            } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
344
                stream->id = lpcm_id++;
345
                for(j = 0; j < 4; j++) {
346
                    if (lpcm_freq_tab[j] == st->codec->sample_rate)
347
                        break;
348
                }
349
                if (j == 4)
350
                    goto fail;
351
                if (st->codec->channels > 8)
352
                    return -1;
353
                stream->lpcm_header[0] = 0x0c;
354
                stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
355
                stream->lpcm_header[2] = 0x80;
356
                stream->lpcm_align = st->codec->channels * 2;
357
            } else {
358
                stream->id = mpa_id++;
359
            }
360

    
361
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
362
               Right now it is also used for everything else.*/
363
            stream->max_buffer_size = 4 * 1024;
364
            s->audio_bound++;
365
            break;
366
        case AVMEDIA_TYPE_VIDEO:
367
            stream->id = mpv_id++;
368
            if (st->codec->rc_buffer_size)
369
                stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
370
            else
371
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
372
#if 0
373
                /* see VCD standard, p. IV-7*/
374
                stream->max_buffer_size = 46 * 1024;
375
            else
376
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
377
                   Right now it is also used for everything else.*/
378
                stream->max_buffer_size = 230 * 1024;
379
#endif
380
            s->video_bound++;
381
            break;
382
        case AVMEDIA_TYPE_SUBTITLE:
383
            stream->id = mps_id++;
384
            stream->max_buffer_size = 16 * 1024;
385
            break;
386
        default:
387
            return -1;
388
        }
389
        stream->fifo= av_fifo_alloc(16);
390
        if (!stream->fifo)
391
            goto fail;
392
    }
393
    bitrate = 0;
394
    audio_bitrate = 0;
395
    video_bitrate = 0;
396
    for(i=0;i<ctx->nb_streams;i++) {
397
        int codec_rate;
398
        st = ctx->streams[i];
399
        stream = (StreamInfo*) st->priv_data;
400

    
401
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
402
            codec_rate= st->codec->rc_max_rate;
403
        else
404
            codec_rate= st->codec->bit_rate;
405

    
406
        if(!codec_rate)
407
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
408

    
409
        bitrate += codec_rate;
410

    
411
        if ((stream->id & 0xe0) == AUDIO_ID)
412
            audio_bitrate += codec_rate;
413
        else if (stream->id==VIDEO_ID)
414
            video_bitrate += codec_rate;
415
    }
416

    
417
    if(ctx->mux_rate){
418
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
419
    } else {
420
        /* we increase slightly the bitrate to take into account the
421
           headers. XXX: compute it exactly */
422
        bitrate += bitrate*5/100;
423
        bitrate += 10000;
424
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
425
    }
426

    
427
    if (s->is_vcd) {
428
        double overhead_rate;
429

    
430
        /* The VCD standard mandates that the mux_rate field is 3528
431
           (see standard p. IV-6).
432
           The value is actually "wrong", i.e. if you calculate
433
           it using the normal formula and the 75 sectors per second transfer
434
           rate you get a different value because the real pack size is 2324,
435
           not 2352. But the standard explicitly specifies that the mux_rate
436
           field in the header must have this value.*/
437
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
438

    
439
        /* The VCD standard states that the muxed stream must be
440
           exactly 75 packs / second (the data rate of a single speed cdrom).
441
           Since the video bitrate (probably 1150000 bits/sec) will be below
442
           the theoretical maximum we have to add some padding packets
443
           to make up for the lower data rate.
444
           (cf. VCD standard p. IV-6 )*/
445

    
446
        /* Add the header overhead to the data rate.
447
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
448
        overhead_rate  = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
449
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
450
        overhead_rate *= 8;
451

    
452
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
453
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
454
    }
455

    
456
    if (s->is_vcd || s->is_mpeg2)
457
        /* every packet */
458
        s->pack_header_freq = 1;
459
    else
460
        /* every 2 seconds */
461
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
462

    
463
    /* the above seems to make pack_header_freq zero sometimes */
464
    if (s->pack_header_freq == 0)
465
       s->pack_header_freq = 1;
466

    
467
    if (s->is_mpeg2)
468
        /* every 200 packets. Need to look at the spec.  */
469
        s->system_header_freq = s->pack_header_freq * 40;
470
    else if (s->is_vcd)
471
        /* the standard mandates that there are only two system headers
472
           in the whole file: one in the first packet of each stream.
473
           (see standard p. IV-7 and IV-8) */
474
        s->system_header_freq = 0x7fffffff;
475
    else
476
        s->system_header_freq = s->pack_header_freq * 5;
477

    
478
    for(i=0;i<ctx->nb_streams;i++) {
479
        stream = ctx->streams[i]->priv_data;
480
        stream->packet_number = 0;
481
    }
482
    s->system_header_size = get_system_header_size(ctx);
483
    s->last_scr = 0;
484
    return 0;
485
 fail:
486
    for(i=0;i<ctx->nb_streams;i++) {
487
        av_free(ctx->streams[i]->priv_data);
488
    }
489
    return AVERROR(ENOMEM);
490
}
491

    
492
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
493
{
494
    put_byte(pb,
495
             (id << 4) |
496
             (((timestamp >> 30) & 0x07) << 1) |
497
             1);
498
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
499
    put_be16(pb, (uint16_t)((((timestamp      ) & 0x7fff) << 1) | 1));
500
}
501

    
502

    
503
/* return the number of padding bytes that should be inserted into
504
   the multiplexed stream.*/
505
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
506
{
507
    MpegMuxContext *s = ctx->priv_data;
508
    int pad_bytes = 0;
509

    
510
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
511
    {
512
        int64_t full_pad_bytes;
513

    
514
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
515
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
516

    
517
        if (pad_bytes<0)
518
            /* might happen if we have already padded to a later timestamp. This
519
               can occur if another stream has already advanced further.*/
520
            pad_bytes=0;
521
    }
522

    
523
    return pad_bytes;
524
}
525

    
526

    
527
#if 0 /* unused, remove? */
528
/* return the exact available payload size for the next packet for
529
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
530
   timestamps are needed in the packet header. */
531
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
532
                                   int64_t pts, int64_t dts)
533
{
534
    MpegMuxContext *s = ctx->priv_data;
535
    int buf_index;
536
    StreamInfo *stream;
537

538
    stream = ctx->streams[stream_index]->priv_data;
539

540
    buf_index = 0;
541
    if (((s->packet_number % s->pack_header_freq) == 0)) {
542
        /* pack header size */
543
        if (s->is_mpeg2)
544
            buf_index += 14;
545
        else
546
            buf_index += 12;
547

548
        if (s->is_vcd) {
549
            /* there is exactly one system header for each stream in a VCD MPEG,
550
               One in the very first video packet and one in the very first
551
               audio packet (see VCD standard p. IV-7 and IV-8).*/
552

553
            if (stream->packet_number==0)
554
                /* The system headers refer only to the stream they occur in,
555
                   so they have a constant size.*/
556
                buf_index += 15;
557

558
        } else {
559
            if ((s->packet_number % s->system_header_freq) == 0)
560
                buf_index += s->system_header_size;
561
        }
562
    }
563

564
    if ((s->is_vcd && stream->packet_number==0)
565
        || (s->is_svcd && s->packet_number==0))
566
        /* the first pack of each stream contains only the pack header,
567
           the system header and some padding (see VCD standard p. IV-6)
568
           Add the padding size, so that the actual payload becomes 0.*/
569
        buf_index += s->packet_size - buf_index;
570
    else {
571
        /* packet header size */
572
        buf_index += 6;
573
        if (s->is_mpeg2) {
574
            buf_index += 3;
575
            if (stream->packet_number==0)
576
                buf_index += 3; /* PES extension */
577
            buf_index += 1;    /* obligatory stuffing byte */
578
        }
579
        if (pts != AV_NOPTS_VALUE) {
580
            if (dts != pts)
581
                buf_index += 5 + 5;
582
            else
583
                buf_index += 5;
584

585
        } else {
586
            if (!s->is_mpeg2)
587
                buf_index++;
588
        }
589

590
        if (stream->id < 0xc0) {
591
            /* AC-3/LPCM private data header */
592
            buf_index += 4;
593
            if (stream->id >= 0xa0) {
594
                int n;
595
                buf_index += 3;
596
                /* NOTE: we round the payload size to an integer number of
597
                   LPCM samples */
598
                n = (s->packet_size - buf_index) % stream->lpcm_align;
599
                if (n)
600
                    buf_index += (stream->lpcm_align - n);
601
            }
602
        }
603

604
        if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID)
605
            /* The VCD standard demands that 20 zero bytes follow
606
               each audio packet (see standard p. IV-8).*/
607
            buf_index+=20;
608
    }
609
    return s->packet_size - buf_index;
610
}
611
#endif
612

    
613
/* Write an MPEG padding packet header. */
614
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
615
{
616
    MpegMuxContext *s = ctx->priv_data;
617
    int i;
618

    
619
    put_be32(pb, PADDING_STREAM);
620
    put_be16(pb, packet_bytes - 6);
621
    if (!s->is_mpeg2) {
622
        put_byte(pb, 0x0f);
623
        packet_bytes -= 7;
624
    } else
625
        packet_bytes -= 6;
626

    
627
    for(i=0;i<packet_bytes;i++)
628
        put_byte(pb, 0xff);
629
}
630

    
631
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
632
    int nb_frames=0;
633
    PacketDesc *pkt_desc= stream->premux_packet;
634

    
635
    while(len>0){
636
        if(pkt_desc->size == pkt_desc->unwritten_size)
637
            nb_frames++;
638
        len -= pkt_desc->unwritten_size;
639
        pkt_desc= pkt_desc->next;
640
    }
641

    
642
    return nb_frames;
643
}
644

    
645
/* flush the packet on stream stream_index */
646
static int flush_packet(AVFormatContext *ctx, int stream_index,
647
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
648
{
649
    MpegMuxContext *s = ctx->priv_data;
650
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
651
    uint8_t *buf_ptr;
652
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
653
    int packet_size;
654
    uint8_t buffer[128];
655
    int zero_trail_bytes = 0;
656
    int pad_packet_bytes = 0;
657
    int pes_flags;
658
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
659
    int nb_frames;
660

    
661
    id = stream->id;
662

    
663
#if 0
664
    printf("packet ID=%2x PTS=%0.3f\n",
665
           id, pts / 90000.0);
666
#endif
667

    
668
    buf_ptr = buffer;
669

    
670
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
671
        /* output pack and systems header if needed */
672
        size = put_pack_header(ctx, buf_ptr, scr);
673
        buf_ptr += size;
674
        s->last_scr= scr;
675

    
676
        if (s->is_vcd) {
677
            /* there is exactly one system header for each stream in a VCD MPEG,
678
               One in the very first video packet and one in the very first
679
               audio packet (see VCD standard p. IV-7 and IV-8).*/
680

    
681
            if (stream->packet_number==0) {
682
                size = put_system_header(ctx, buf_ptr, id);
683
                buf_ptr += size;
684
            }
685
        } else if (s->is_dvd) {
686
            if (stream->align_iframe || s->packet_number == 0){
687
                int PES_bytes_to_fill = s->packet_size - size - 10;
688

    
689
                if (pts != AV_NOPTS_VALUE) {
690
                    if (dts != pts)
691
                        PES_bytes_to_fill -= 5 + 5;
692
                    else
693
                        PES_bytes_to_fill -= 5;
694
                }
695

    
696
                if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
697
                    size = put_system_header(ctx, buf_ptr, 0);
698
                    buf_ptr += size;
699
                    size = buf_ptr - buffer;
700
                    put_buffer(ctx->pb, buffer, size);
701

    
702
                    put_be32(ctx->pb, PRIVATE_STREAM_2);
703
                    put_be16(ctx->pb, 0x03d4);         // length
704
                    put_byte(ctx->pb, 0x00);           // substream ID, 00=PCI
705
                    for (i = 0; i < 979; i++)
706
                        put_byte(ctx->pb, 0x00);
707

    
708
                    put_be32(ctx->pb, PRIVATE_STREAM_2);
709
                    put_be16(ctx->pb, 0x03fa);         // length
710
                    put_byte(ctx->pb, 0x01);           // substream ID, 01=DSI
711
                    for (i = 0; i < 1017; i++)
712
                        put_byte(ctx->pb, 0x00);
713

    
714
                    memset(buffer, 0, 128);
715
                    buf_ptr = buffer;
716
                    s->packet_number++;
717
                    stream->align_iframe = 0;
718
                    scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
719
                    size = put_pack_header(ctx, buf_ptr, scr);
720
                    s->last_scr= scr;
721
                    buf_ptr += size;
722
                    /* GOP Start */
723
                } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
724
                    pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
725
                }
726
            }
727
        } else {
728
            if ((s->packet_number % s->system_header_freq) == 0) {
729
                size = put_system_header(ctx, buf_ptr, 0);
730
                buf_ptr += size;
731
            }
732
        }
733
    }
734
    size = buf_ptr - buffer;
735
    put_buffer(ctx->pb, buffer, size);
736

    
737
    packet_size = s->packet_size - size;
738

    
739
    if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
740
        /* The VCD standard demands that 20 zero bytes follow
741
           each audio pack (see standard p. IV-8).*/
742
        zero_trail_bytes += 20;
743

    
744
    if ((s->is_vcd && stream->packet_number==0)
745
        || (s->is_svcd && s->packet_number==0)) {
746
        /* for VCD the first pack of each stream contains only the pack header,
747
           the system header and lots of padding (see VCD standard p. IV-6).
748
           In the case of an audio pack, 20 zero bytes are also added at
749
           the end.*/
750
        /* For SVCD we fill the very first pack to increase compatibility with
751
           some DVD players. Not mandated by the standard.*/
752
        if (s->is_svcd)
753
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
754
        pad_packet_bytes = packet_size - zero_trail_bytes;
755
    }
756

    
757
    packet_size -= pad_packet_bytes + zero_trail_bytes;
758

    
759
    if (packet_size > 0) {
760

    
761
        /* packet header size */
762
        packet_size -= 6;
763

    
764
        /* packet header */
765
        if (s->is_mpeg2) {
766
            header_len = 3;
767
            if (stream->packet_number==0)
768
                header_len += 3; /* PES extension */
769
            header_len += 1; /* obligatory stuffing byte */
770
        } else {
771
            header_len = 0;
772
        }
773
        if (pts != AV_NOPTS_VALUE) {
774
            if (dts != pts)
775
                header_len += 5 + 5;
776
            else
777
                header_len += 5;
778
        } else {
779
            if (!s->is_mpeg2)
780
                header_len++;
781
        }
782

    
783
        payload_size = packet_size - header_len;
784
        if (id < 0xc0) {
785
            startcode = PRIVATE_STREAM_1;
786
            payload_size -= 1;
787
            if (id >= 0x40) {
788
                payload_size -= 3;
789
                if (id >= 0xa0)
790
                    payload_size -= 3;
791
            }
792
        } else {
793
            startcode = 0x100 + id;
794
        }
795

    
796
        stuffing_size = payload_size - av_fifo_size(stream->fifo);
797

    
798
        // first byte does not fit -> reset pts/dts + stuffing
799
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
800
            int timestamp_len=0;
801
            if(dts != pts)
802
                timestamp_len += 5;
803
            if(pts != AV_NOPTS_VALUE)
804
                timestamp_len += s->is_mpeg2 ? 5 : 4;
805
            pts=dts= AV_NOPTS_VALUE;
806
            header_len -= timestamp_len;
807
            if (s->is_dvd && stream->align_iframe) {
808
                pad_packet_bytes += timestamp_len;
809
                packet_size  -= timestamp_len;
810
            } else {
811
                payload_size += timestamp_len;
812
            }
813
            stuffing_size += timestamp_len;
814
            if(payload_size > trailer_size)
815
                stuffing_size += payload_size - trailer_size;
816
        }
817

    
818
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
819
            packet_size += pad_packet_bytes;
820
            payload_size += pad_packet_bytes; // undo the previous adjustment
821
            if (stuffing_size < 0) {
822
                stuffing_size  = pad_packet_bytes;
823
            } else {
824
                stuffing_size += pad_packet_bytes;
825
            }
826
            pad_packet_bytes = 0;
827
        }
828

    
829
        if (stuffing_size < 0)
830
            stuffing_size = 0;
831
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
832
            pad_packet_bytes += stuffing_size;
833
            packet_size      -= stuffing_size;
834
            payload_size     -= stuffing_size;
835
            stuffing_size = 0;
836
        }
837

    
838
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
839

    
840
        put_be32(ctx->pb, startcode);
841

    
842
        put_be16(ctx->pb, packet_size);
843

    
844
        if (!s->is_mpeg2)
845
            for(i=0;i<stuffing_size;i++)
846
                put_byte(ctx->pb, 0xff);
847

    
848
        if (s->is_mpeg2) {
849
            put_byte(ctx->pb, 0x80); /* mpeg2 id */
850

    
851
            pes_flags=0;
852

    
853
            if (pts != AV_NOPTS_VALUE) {
854
                pes_flags |= 0x80;
855
                if (dts != pts)
856
                    pes_flags |= 0x40;
857
            }
858

    
859
            /* Both the MPEG-2 and the SVCD standards demand that the
860
               P-STD_buffer_size field be included in the first packet of
861
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
862
               and MPEG-2 standard 2.7.7) */
863
            if (stream->packet_number == 0)
864
                pes_flags |= 0x01;
865

    
866
            put_byte(ctx->pb, pes_flags); /* flags */
867
            put_byte(ctx->pb, header_len - 3 + stuffing_size);
868

    
869
            if (pes_flags & 0x80)  /*write pts*/
870
                put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
871
            if (pes_flags & 0x40)  /*write dts*/
872
                put_timestamp(ctx->pb, 0x01, dts);
873

    
874
            if (pes_flags & 0x01) {  /*write pes extension*/
875
                put_byte(ctx->pb, 0x10); /* flags */
876

    
877
                /* P-STD buffer info */
878
                if ((id & 0xe0) == AUDIO_ID)
879
                    put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
880
                else
881
                    put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
882
            }
883

    
884
        } else {
885
            if (pts != AV_NOPTS_VALUE) {
886
                if (dts != pts) {
887
                    put_timestamp(ctx->pb, 0x03, pts);
888
                    put_timestamp(ctx->pb, 0x01, dts);
889
                } else {
890
                    put_timestamp(ctx->pb, 0x02, pts);
891
                }
892
            } else {
893
                put_byte(ctx->pb, 0x0f);
894
            }
895
        }
896

    
897
        if (s->is_mpeg2) {
898
            /* special stuffing byte that is always written
899
               to prevent accidental generation of start codes. */
900
            put_byte(ctx->pb, 0xff);
901

    
902
            for(i=0;i<stuffing_size;i++)
903
                put_byte(ctx->pb, 0xff);
904
        }
905

    
906
        if (startcode == PRIVATE_STREAM_1) {
907
            put_byte(ctx->pb, id);
908
            if (id >= 0xa0) {
909
                /* LPCM (XXX: check nb_frames) */
910
                put_byte(ctx->pb, 7);
911
                put_be16(ctx->pb, 4); /* skip 3 header bytes */
912
                put_byte(ctx->pb, stream->lpcm_header[0]);
913
                put_byte(ctx->pb, stream->lpcm_header[1]);
914
                put_byte(ctx->pb, stream->lpcm_header[2]);
915
            } else if (id >= 0x40) {
916
                /* AC-3 */
917
                put_byte(ctx->pb, nb_frames);
918
                put_be16(ctx->pb, trailer_size+1);
919
            }
920
        }
921

    
922
        /* output data */
923
        assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
924
        av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &put_buffer);
925
        stream->bytes_to_iframe -= payload_size - stuffing_size;
926
    }else{
927
        payload_size=
928
        stuffing_size= 0;
929
    }
930

    
931
    if (pad_packet_bytes > 0)
932
        put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
933

    
934
    for(i=0;i<zero_trail_bytes;i++)
935
        put_byte(ctx->pb, 0x00);
936

    
937
    put_flush_packet(ctx->pb);
938

    
939
    s->packet_number++;
940

    
941
    /* only increase the stream packet number if this pack actually contains
942
       something that is specific to this stream! I.e. a dedicated header
943
       or some data.*/
944
    if (!general_pack)
945
        stream->packet_number++;
946

    
947
    return payload_size - stuffing_size;
948
}
949

    
950
static void put_vcd_padding_sector(AVFormatContext *ctx)
951
{
952
    /* There are two ways to do this padding: writing a sector/pack
953
       of 0 values, or writing an MPEG padding pack. Both seem to
954
       work with most decoders, BUT the VCD standard only allows a 0-sector
955
       (see standard p. IV-4, IV-5).
956
       So a 0-sector it is...*/
957

    
958
    MpegMuxContext *s = ctx->priv_data;
959
    int i;
960

    
961
    for(i=0;i<s->packet_size;i++)
962
        put_byte(ctx->pb, 0);
963

    
964
    s->vcd_padding_bytes_written += s->packet_size;
965

    
966
    put_flush_packet(ctx->pb);
967

    
968
    /* increasing the packet number is correct. The SCR of the following packs
969
       is calculated from the packet_number and it has to include the padding
970
       sector (it represents the sector index, not the MPEG pack index)
971
       (see VCD standard p. IV-6)*/
972
    s->packet_number++;
973
}
974

    
975
#if 0 /* unused, remove? */
976
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
977
{
978
    MpegMuxContext *s = ctx->priv_data;
979
    int64_t scr;
980

981
        /* Since the data delivery rate is constant, SCR is computed
982
           using the formula C + i * 1200 where C is the start constant
983
           and i is the pack index.
984
           It is recommended that SCR 0 is at the beginning of the VCD front
985
           margin (a sequence of empty Form 2 sectors on the CD).
986
           It is recommended that the front margin is 30 sectors long, so
987
           we use C = 30*1200 = 36000
988
           (Note that even if the front margin is not 30 sectors the file
989
           will still be correct according to the standard. It just won't have
990
           the "recommended" value).*/
991
        scr = 36000 + s->packet_number * 1200;
992

993
    return scr;
994
}
995
#endif
996

    
997
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
998
//    MpegMuxContext *s = ctx->priv_data;
999
    int i;
1000

    
1001
    for(i=0; i<ctx->nb_streams; i++){
1002
        AVStream *st = ctx->streams[i];
1003
        StreamInfo *stream = st->priv_data;
1004
        PacketDesc *pkt_desc;
1005

    
1006
        while((pkt_desc= stream->predecode_packet)
1007
              && scr > pkt_desc->dts){ //FIXME > vs >=
1008
            if(stream->buffer_index < pkt_desc->size ||
1009
               stream->predecode_packet == stream->premux_packet){
1010
                av_log(ctx, AV_LOG_ERROR,
1011
                       "buffer underflow i=%d bufi=%d size=%d\n",
1012
                       i, stream->buffer_index, pkt_desc->size);
1013
                break;
1014
            }
1015
            stream->buffer_index -= pkt_desc->size;
1016

    
1017
            stream->predecode_packet= pkt_desc->next;
1018
            av_freep(&pkt_desc);
1019
        }
1020
    }
1021

    
1022
    return 0;
1023
}
1024

    
1025
static int output_packet(AVFormatContext *ctx, int flush){
1026
    MpegMuxContext *s = ctx->priv_data;
1027
    AVStream *st;
1028
    StreamInfo *stream;
1029
    int i, avail_space=0, es_size, trailer_size;
1030
    int best_i= -1;
1031
    int best_score= INT_MIN;
1032
    int ignore_constraints=0;
1033
    int64_t scr= s->last_scr;
1034
    PacketDesc *timestamp_packet;
1035
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1036

    
1037
retry:
1038
    for(i=0; i<ctx->nb_streams; i++){
1039
        AVStream *st = ctx->streams[i];
1040
        StreamInfo *stream = st->priv_data;
1041
        const int avail_data=  av_fifo_size(stream->fifo);
1042
        const int space= stream->max_buffer_size - stream->buffer_index;
1043
        int rel_space= 1024*space / stream->max_buffer_size;
1044
        PacketDesc *next_pkt= stream->premux_packet;
1045

    
1046
        /* for subtitle, a single PES packet must be generated,
1047
           so we flush after every single subtitle packet */
1048
        if(s->packet_size > avail_data && !flush
1049
           && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1050
            return 0;
1051
        if(avail_data==0)
1052
            continue;
1053
        assert(avail_data>0);
1054

    
1055
        if(space < s->packet_size && !ignore_constraints)
1056
            continue;
1057

    
1058
        if(next_pkt && next_pkt->dts - scr > max_delay)
1059
            continue;
1060

    
1061
        if(rel_space > best_score){
1062
            best_score= rel_space;
1063
            best_i = i;
1064
            avail_space= space;
1065
        }
1066
    }
1067

    
1068
    if(best_i < 0){
1069
        int64_t best_dts= INT64_MAX;
1070

    
1071
        for(i=0; i<ctx->nb_streams; i++){
1072
            AVStream *st = ctx->streams[i];
1073
            StreamInfo *stream = st->priv_data;
1074
            PacketDesc *pkt_desc= stream->predecode_packet;
1075
            if(pkt_desc && pkt_desc->dts < best_dts)
1076
                best_dts= pkt_desc->dts;
1077
        }
1078

    
1079
#if 0
1080
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1081
               scr/90000.0, best_dts/90000.0);
1082
#endif
1083
        if(best_dts == INT64_MAX)
1084
            return 0;
1085

    
1086
        if(scr >= best_dts+1 && !ignore_constraints){
1087
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1088
            ignore_constraints= 1;
1089
        }
1090
        scr= FFMAX(best_dts+1, scr);
1091
        if(remove_decoded_packets(ctx, scr) < 0)
1092
            return -1;
1093
        goto retry;
1094
    }
1095

    
1096
    assert(best_i >= 0);
1097

    
1098
    st = ctx->streams[best_i];
1099
    stream = st->priv_data;
1100

    
1101
    assert(av_fifo_size(stream->fifo) > 0);
1102

    
1103
    assert(avail_space >= s->packet_size || ignore_constraints);
1104

    
1105
    timestamp_packet= stream->premux_packet;
1106
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1107
        trailer_size= 0;
1108
    }else{
1109
        trailer_size= timestamp_packet->unwritten_size;
1110
        timestamp_packet= timestamp_packet->next;
1111
    }
1112

    
1113
    if(timestamp_packet){
1114
//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);
1115
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1116
    }else{
1117
        assert(av_fifo_size(stream->fifo) == trailer_size);
1118
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1119
    }
1120

    
1121
    if (s->is_vcd) {
1122
        /* Write one or more padding sectors, if necessary, to reach
1123
           the constant overall bitrate.*/
1124
        int vcd_pad_bytes;
1125

    
1126
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1127
            put_vcd_padding_sector(ctx);
1128
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1129
        }
1130
    }
1131

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

    
1135
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1136
        es_size -= stream->premux_packet->unwritten_size;
1137
        stream->premux_packet= stream->premux_packet->next;
1138
    }
1139
    if(es_size)
1140
        stream->premux_packet->unwritten_size -= es_size;
1141

    
1142
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1143
        return -1;
1144

    
1145
    return 1;
1146
}
1147

    
1148
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1149
{
1150
    MpegMuxContext *s = ctx->priv_data;
1151
    int stream_index= pkt->stream_index;
1152
    int size= pkt->size;
1153
    uint8_t *buf= pkt->data;
1154
    AVStream *st = ctx->streams[stream_index];
1155
    StreamInfo *stream = st->priv_data;
1156
    int64_t pts, dts;
1157
    PacketDesc *pkt_desc;
1158
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1159
    const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1160

    
1161
    pts= pkt->pts;
1162
    dts= pkt->dts;
1163

    
1164
    if(pts != AV_NOPTS_VALUE) pts += preload;
1165
    if(dts != AV_NOPTS_VALUE) dts += preload;
1166

    
1167
//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);
1168
    if (!stream->premux_packet)
1169
        stream->next_packet = &stream->premux_packet;
1170
    *stream->next_packet=
1171
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1172
    pkt_desc->pts= pts;
1173
    pkt_desc->dts= dts;
1174
    pkt_desc->unwritten_size=
1175
    pkt_desc->size= size;
1176
    if(!stream->predecode_packet)
1177
        stream->predecode_packet= pkt_desc;
1178
    stream->next_packet= &pkt_desc->next;
1179

    
1180
    if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1181
        return -1;
1182

    
1183
    if (s->is_dvd){
1184
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1185
            stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1186
            stream->align_iframe = 1;
1187
            stream->vobu_start_pts = pts;
1188
        }
1189
    }
1190

    
1191
    av_fifo_generic_write(stream->fifo, buf, size, NULL);
1192

    
1193
    for(;;){
1194
        int ret= output_packet(ctx, 0);
1195
        if(ret<=0)
1196
            return ret;
1197
    }
1198
}
1199

    
1200
static int mpeg_mux_end(AVFormatContext *ctx)
1201
{
1202
//    MpegMuxContext *s = ctx->priv_data;
1203
    StreamInfo *stream;
1204
    int i;
1205

    
1206
    for(;;){
1207
        int ret= output_packet(ctx, 1);
1208
        if(ret<0)
1209
            return ret;
1210
        else if(ret==0)
1211
            break;
1212
    }
1213

    
1214
    /* End header according to MPEG1 systems standard. We do not write
1215
       it as it is usually not needed by decoders and because it
1216
       complicates MPEG stream concatenation. */
1217
    //put_be32(ctx->pb, ISO_11172_END_CODE);
1218
    //put_flush_packet(ctx->pb);
1219

    
1220
    for(i=0;i<ctx->nb_streams;i++) {
1221
        stream = ctx->streams[i]->priv_data;
1222

    
1223
        assert(av_fifo_size(stream->fifo) == 0);
1224
        av_fifo_free(stream->fifo);
1225
    }
1226
    return 0;
1227
}
1228

    
1229
#if CONFIG_MPEG1SYSTEM_MUXER
1230
AVOutputFormat mpeg1system_muxer = {
1231
    "mpeg",
1232
    NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1233
    "video/mpeg",
1234
    "mpg,mpeg",
1235
    sizeof(MpegMuxContext),
1236
    CODEC_ID_MP2,
1237
    CODEC_ID_MPEG1VIDEO,
1238
    mpeg_mux_init,
1239
    mpeg_mux_write_packet,
1240
    mpeg_mux_end,
1241
};
1242
#endif
1243
#if CONFIG_MPEG1VCD_MUXER
1244
AVOutputFormat mpeg1vcd_muxer = {
1245
    "vcd",
1246
    NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1247
    "video/mpeg",
1248
    NULL,
1249
    sizeof(MpegMuxContext),
1250
    CODEC_ID_MP2,
1251
    CODEC_ID_MPEG1VIDEO,
1252
    mpeg_mux_init,
1253
    mpeg_mux_write_packet,
1254
    mpeg_mux_end,
1255
};
1256
#endif
1257
#if CONFIG_MPEG2VOB_MUXER
1258
AVOutputFormat mpeg2vob_muxer = {
1259
    "vob",
1260
    NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1261
    "video/mpeg",
1262
    "vob",
1263
    sizeof(MpegMuxContext),
1264
    CODEC_ID_MP2,
1265
    CODEC_ID_MPEG2VIDEO,
1266
    mpeg_mux_init,
1267
    mpeg_mux_write_packet,
1268
    mpeg_mux_end,
1269
};
1270
#endif
1271

    
1272
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1273
#if CONFIG_MPEG2SVCD_MUXER
1274
AVOutputFormat mpeg2svcd_muxer = {
1275
    "svcd",
1276
    NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1277
    "video/mpeg",
1278
    "vob",
1279
    sizeof(MpegMuxContext),
1280
    CODEC_ID_MP2,
1281
    CODEC_ID_MPEG2VIDEO,
1282
    mpeg_mux_init,
1283
    mpeg_mux_write_packet,
1284
    mpeg_mux_end,
1285
};
1286
#endif
1287

    
1288
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1289
#if CONFIG_MPEG2DVD_MUXER
1290
AVOutputFormat mpeg2dvd_muxer = {
1291
    "dvd",
1292
    NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1293
    "video/mpeg",
1294
    "dvd",
1295
    sizeof(MpegMuxContext),
1296
    CODEC_ID_MP2,
1297
    CODEC_ID_MPEG2VIDEO,
1298
    mpeg_mux_init,
1299
    mpeg_mux_write_packet,
1300
    mpeg_mux_end,
1301
};
1302
#endif