Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpegenc.c @ 61dbf4e5

History | View | Annotate | Download (41.4 KB)

1 2abe5a01 Baptiste Coudurier
/*
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 "bitstream.h"
24
#include "fifo.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 6369638b Aurelien Jacobs
extern AVOutputFormat mpeg1vcd_muxer;
80
extern AVOutputFormat mpeg2dvd_muxer;
81
extern AVOutputFormat mpeg2svcd_muxer;
82
extern AVOutputFormat mpeg2vob_muxer;
83
84 2abe5a01 Baptiste Coudurier
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_bits(&pb, 32, 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 pbBufPtr(&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_bits(&pb, 32, 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==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 (AC3 use 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 = pbBufPtr(&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 372a80d1 Aurelien Jacobs
    s->is_vcd =   (ENABLE_MPEG1VCD_MUXER  && ctx->oformat == &mpeg1vcd_muxer);
301
    s->is_svcd =  (ENABLE_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer);
302
    s->is_mpeg2 = (ENABLE_MPEG2VOB_MUXER  && ctx->oformat == &mpeg2vob_muxer ||
303
                   ENABLE_MPEG2DVD_MUXER  && ctx->oformat == &mpeg2dvd_muxer ||
304
                   ENABLE_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer);
305
    s->is_dvd =   (ENABLE_MPEG2DVD_MUXER  && ctx->oformat == &mpeg2dvd_muxer);
306 2abe5a01 Baptiste Coudurier
307
    if(ctx->packet_size)
308
        s->packet_size = ctx->packet_size;
309
    else
310
        s->packet_size = 2048;
311
312
    s->vcd_padding_bytes_written = 0;
313
    s->vcd_padding_bitrate=0;
314
315
    s->audio_bound = 0;
316
    s->video_bound = 0;
317
    mpa_id = AUDIO_ID;
318
    ac3_id = AC3_ID;
319
    dts_id = DTS_ID;
320
    mpv_id = VIDEO_ID;
321
    mps_id = SUB_ID;
322
    lpcm_id = LPCM_ID;
323
    for(i=0;i<ctx->nb_streams;i++) {
324
        st = ctx->streams[i];
325
        stream = av_mallocz(sizeof(StreamInfo));
326
        if (!stream)
327
            goto fail;
328
        st->priv_data = stream;
329
330
        av_set_pts_info(st, 64, 1, 90000);
331
332
        switch(st->codec->codec_type) {
333
        case CODEC_TYPE_AUDIO:
334
            if (st->codec->codec_id == CODEC_ID_AC3) {
335
                stream->id = ac3_id++;
336
            } else if (st->codec->codec_id == CODEC_ID_DTS) {
337
                stream->id = dts_id++;
338
            } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
339
                stream->id = lpcm_id++;
340
                for(j = 0; j < 4; j++) {
341
                    if (lpcm_freq_tab[j] == st->codec->sample_rate)
342
                        break;
343
                }
344
                if (j == 4)
345
                    goto fail;
346
                if (st->codec->channels > 8)
347
                    return -1;
348
                stream->lpcm_header[0] = 0x0c;
349
                stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
350
                stream->lpcm_header[2] = 0x80;
351
                stream->lpcm_align = st->codec->channels * 2;
352
            } else {
353
                stream->id = mpa_id++;
354
            }
355
356
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
357
               Right now it is also used for everything else.*/
358
            stream->max_buffer_size = 4 * 1024;
359
            s->audio_bound++;
360
            break;
361
        case CODEC_TYPE_VIDEO:
362
            stream->id = mpv_id++;
363
            if (st->codec->rc_buffer_size)
364
                stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
365
            else
366
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
367
#if 0
368
                /* see VCD standard, p. IV-7*/
369
                stream->max_buffer_size = 46 * 1024;
370
            else
371
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
372
                   Right now it is also used for everything else.*/
373
                stream->max_buffer_size = 230 * 1024;
374
#endif
375
            s->video_bound++;
376
            break;
377
        case CODEC_TYPE_SUBTITLE:
378
            stream->id = mps_id++;
379
            stream->max_buffer_size = 16 * 1024;
380
            break;
381
        default:
382
            return -1;
383
        }
384
        av_fifo_init(&stream->fifo, 16);
385
    }
386
    bitrate = 0;
387
    audio_bitrate = 0;
388
    video_bitrate = 0;
389
    for(i=0;i<ctx->nb_streams;i++) {
390
        int codec_rate;
391
        st = ctx->streams[i];
392
        stream = (StreamInfo*) st->priv_data;
393
394
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
395
            codec_rate= st->codec->rc_max_rate;
396
        else
397
            codec_rate= st->codec->bit_rate;
398
399
        if(!codec_rate)
400
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
401
402
        bitrate += codec_rate;
403
404
        if (stream->id==AUDIO_ID)
405
            audio_bitrate += codec_rate;
406
        else if (stream->id==VIDEO_ID)
407
            video_bitrate += codec_rate;
408
    }
409
410
    if(ctx->mux_rate){
411
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
412
    } else {
413
        /* we increase slightly the bitrate to take into account the
414
           headers. XXX: compute it exactly */
415
        bitrate += bitrate*5/100;
416
        bitrate += 10000;
417
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
418
    }
419
420
    if (s->is_vcd) {
421
        double overhead_rate;
422
423
        /* The VCD standard mandates that the mux_rate field is 3528
424
           (see standard p. IV-6).
425
           The value is actually "wrong", i.e. if you calculate
426
           it using the normal formula and the 75 sectors per second transfer
427
           rate you get a different value because the real pack size is 2324,
428
           not 2352. But the standard explicitly specifies that the mux_rate
429
           field in the header must have this value.*/
430
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
431
432
        /* The VCD standard states that the muxed stream must be
433
           exactly 75 packs / second (the data rate of a single speed cdrom).
434
           Since the video bitrate (probably 1150000 bits/sec) will be below
435
           the theoretical maximum we have to add some padding packets
436
           to make up for the lower data rate.
437
           (cf. VCD standard p. IV-6 )*/
438
439
        /* Add the header overhead to the data rate.
440
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
441
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
442
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
443
        overhead_rate *= 8;
444
445
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
446
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
447
    }
448
449
    if (s->is_vcd || s->is_mpeg2)
450
        /* every packet */
451
        s->pack_header_freq = 1;
452
    else
453
        /* every 2 seconds */
454
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
455
456
    /* the above seems to make pack_header_freq zero sometimes */
457
    if (s->pack_header_freq == 0)
458
       s->pack_header_freq = 1;
459
460
    if (s->is_mpeg2)
461
        /* every 200 packets. Need to look at the spec.  */
462
        s->system_header_freq = s->pack_header_freq * 40;
463
    else if (s->is_vcd)
464
        /* the standard mandates that there are only two system headers
465
           in the whole file: one in the first packet of each stream.
466
           (see standard p. IV-7 and IV-8) */
467
        s->system_header_freq = 0x7fffffff;
468
    else
469
        s->system_header_freq = s->pack_header_freq * 5;
470
471
    for(i=0;i<ctx->nb_streams;i++) {
472
        stream = ctx->streams[i]->priv_data;
473
        stream->packet_number = 0;
474
    }
475
    s->system_header_size = get_system_header_size(ctx);
476
    s->last_scr = 0;
477
    return 0;
478
 fail:
479
    for(i=0;i<ctx->nb_streams;i++) {
480
        av_free(ctx->streams[i]->priv_data);
481
    }
482
    return AVERROR(ENOMEM);
483
}
484
485 6a058d90 Michael Niedermayer
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
486 2abe5a01 Baptiste Coudurier
{
487
    put_byte(pb,
488
             (id << 4) |
489
             (((timestamp >> 30) & 0x07) << 1) |
490
             1);
491
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
492
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
493
}
494
495
496
/* return the number of padding bytes that should be inserted into
497
   the multiplexed stream.*/
498
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
499
{
500
    MpegMuxContext *s = ctx->priv_data;
501
    int pad_bytes = 0;
502
503
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
504
    {
505
        int64_t full_pad_bytes;
506
507
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
508
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
509
510
        if (pad_bytes<0)
511
            /* might happen if we have already padded to a later timestamp. This
512
               can occur if another stream has already advanced further.*/
513
            pad_bytes=0;
514
    }
515
516
    return pad_bytes;
517
}
518
519
520
#if 0 /* unused, remove? */
521
/* return the exact available payload size for the next packet for
522
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
523
   timestamps are needed in the packet header. */
524
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
525
                                   int64_t pts, int64_t dts)
526
{
527
    MpegMuxContext *s = ctx->priv_data;
528
    int buf_index;
529
    StreamInfo *stream;
530

531
    stream = ctx->streams[stream_index]->priv_data;
532

533
    buf_index = 0;
534
    if (((s->packet_number % s->pack_header_freq) == 0)) {
535
        /* pack header size */
536
        if (s->is_mpeg2)
537
            buf_index += 14;
538
        else
539
            buf_index += 12;
540

541
        if (s->is_vcd) {
542
            /* there is exactly one system header for each stream in a VCD MPEG,
543
               One in the very first video packet and one in the very first
544
               audio packet (see VCD standard p. IV-7 and IV-8).*/
545

546
            if (stream->packet_number==0)
547
                /* The system headers refer only to the stream they occur in,
548
                   so they have a constant size.*/
549
                buf_index += 15;
550

551
        } else {
552
            if ((s->packet_number % s->system_header_freq) == 0)
553
                buf_index += s->system_header_size;
554
        }
555
    }
556

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

578
        } else {
579
            if (!s->is_mpeg2)
580
                buf_index++;
581
        }
582

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

597
        if (s->is_vcd && stream->id == AUDIO_ID)
598
            /* The VCD standard demands that 20 zero bytes follow
599
               each audio packet (see standard p. IV-8).*/
600
            buf_index+=20;
601
    }
602
    return s->packet_size - buf_index;
603
}
604
#endif
605
606
/* Write an MPEG padding packet header. */
607
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
608
{
609
    MpegMuxContext *s = ctx->priv_data;
610
    int i;
611
612
    put_be32(pb, PADDING_STREAM);
613
    put_be16(pb, packet_bytes - 6);
614
    if (!s->is_mpeg2) {
615
        put_byte(pb, 0x0f);
616
        packet_bytes -= 7;
617
    } else
618
        packet_bytes -= 6;
619
620
    for(i=0;i<packet_bytes;i++)
621
        put_byte(pb, 0xff);
622
}
623
624
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
625
    int nb_frames=0;
626
    PacketDesc *pkt_desc= stream->premux_packet;
627
628
    while(len>0){
629
        if(pkt_desc->size == pkt_desc->unwritten_size)
630
            nb_frames++;
631
        len -= pkt_desc->unwritten_size;
632
        pkt_desc= pkt_desc->next;
633
    }
634
635
    return nb_frames;
636
}
637
638
/* flush the packet on stream stream_index */
639
static int flush_packet(AVFormatContext *ctx, int stream_index,
640
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
641
{
642
    MpegMuxContext *s = ctx->priv_data;
643
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
644
    uint8_t *buf_ptr;
645
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
646
    int packet_size;
647
    uint8_t buffer[128];
648
    int zero_trail_bytes = 0;
649
    int pad_packet_bytes = 0;
650
    int pes_flags;
651
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
652
    int nb_frames;
653
654
    id = stream->id;
655
656
#if 0
657
    printf("packet ID=%2x PTS=%0.3f\n",
658
           id, pts / 90000.0);
659
#endif
660
661
    buf_ptr = buffer;
662
663
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
664
        /* output pack and systems header if needed */
665
        size = put_pack_header(ctx, buf_ptr, scr);
666
        buf_ptr += size;
667
        s->last_scr= scr;
668
669
        if (s->is_vcd) {
670
            /* there is exactly one system header for each stream in a VCD MPEG,
671
               One in the very first video packet and one in the very first
672
               audio packet (see VCD standard p. IV-7 and IV-8).*/
673
674
            if (stream->packet_number==0) {
675
                size = put_system_header(ctx, buf_ptr, id);
676
                buf_ptr += size;
677
            }
678
        } else if (s->is_dvd) {
679
            if (stream->align_iframe || s->packet_number == 0){
680
                int PES_bytes_to_fill = s->packet_size - size - 10;
681
682
                if (pts != AV_NOPTS_VALUE) {
683
                    if (dts != pts)
684
                        PES_bytes_to_fill -= 5 + 5;
685
                    else
686
                        PES_bytes_to_fill -= 5;
687
                }
688
689
                if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
690
                    size = put_system_header(ctx, buf_ptr, 0);
691
                    buf_ptr += size;
692
                    size = buf_ptr - buffer;
693 899681cd Björn Axelsson
                    put_buffer(ctx->pb, buffer, size);
694 2abe5a01 Baptiste Coudurier
695 899681cd Björn Axelsson
                    put_be32(ctx->pb, PRIVATE_STREAM_2);
696
                    put_be16(ctx->pb, 0x03d4);         // length
697
                    put_byte(ctx->pb, 0x00);           // substream ID, 00=PCI
698 2abe5a01 Baptiste Coudurier
                    for (i = 0; i < 979; i++)
699 899681cd Björn Axelsson
                        put_byte(ctx->pb, 0x00);
700 2abe5a01 Baptiste Coudurier
701 899681cd Björn Axelsson
                    put_be32(ctx->pb, PRIVATE_STREAM_2);
702
                    put_be16(ctx->pb, 0x03fa);         // length
703
                    put_byte(ctx->pb, 0x01);           // substream ID, 01=DSI
704 2abe5a01 Baptiste Coudurier
                    for (i = 0; i < 1017; i++)
705 899681cd Björn Axelsson
                        put_byte(ctx->pb, 0x00);
706 2abe5a01 Baptiste Coudurier
707
                    memset(buffer, 0, 128);
708
                    buf_ptr = buffer;
709
                    s->packet_number++;
710
                    stream->align_iframe = 0;
711
                    scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
712
                    size = put_pack_header(ctx, buf_ptr, scr);
713
                    s->last_scr= scr;
714
                    buf_ptr += size;
715
                    /* GOP Start */
716
                } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
717
                    pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
718
                }
719
            }
720
        } else {
721
            if ((s->packet_number % s->system_header_freq) == 0) {
722
                size = put_system_header(ctx, buf_ptr, 0);
723
                buf_ptr += size;
724
            }
725
        }
726
    }
727
    size = buf_ptr - buffer;
728 899681cd Björn Axelsson
    put_buffer(ctx->pb, buffer, size);
729 2abe5a01 Baptiste Coudurier
730
    packet_size = s->packet_size - size;
731
732
    if (s->is_vcd && id == AUDIO_ID)
733
        /* The VCD standard demands that 20 zero bytes follow
734
           each audio pack (see standard p. IV-8).*/
735
        zero_trail_bytes += 20;
736
737
    if ((s->is_vcd && stream->packet_number==0)
738
        || (s->is_svcd && s->packet_number==0)) {
739
        /* for VCD the first pack of each stream contains only the pack header,
740
           the system header and lots of padding (see VCD standard p. IV-6).
741
           In the case of an audio pack, 20 zero bytes are also added at
742
           the end.*/
743
        /* For SVCD we fill the very first pack to increase compatibility with
744
           some DVD players. Not mandated by the standard.*/
745
        if (s->is_svcd)
746
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
747
        pad_packet_bytes = packet_size - zero_trail_bytes;
748
    }
749
750
    packet_size -= pad_packet_bytes + zero_trail_bytes;
751
752
    if (packet_size > 0) {
753
754
        /* packet header size */
755
        packet_size -= 6;
756
757
        /* packet header */
758
        if (s->is_mpeg2) {
759
            header_len = 3;
760
            if (stream->packet_number==0)
761
                header_len += 3; /* PES extension */
762
            header_len += 1; /* obligatory stuffing byte */
763
        } else {
764
            header_len = 0;
765
        }
766
        if (pts != AV_NOPTS_VALUE) {
767
            if (dts != pts)
768
                header_len += 5 + 5;
769
            else
770
                header_len += 5;
771
        } else {
772
            if (!s->is_mpeg2)
773
                header_len++;
774
        }
775
776
        payload_size = packet_size - header_len;
777
        if (id < 0xc0) {
778
            startcode = PRIVATE_STREAM_1;
779
            payload_size -= 1;
780
            if (id >= 0x40) {
781
                payload_size -= 3;
782
                if (id >= 0xa0)
783
                    payload_size -= 3;
784
            }
785
        } else {
786
            startcode = 0x100 + id;
787
        }
788
789
        stuffing_size = payload_size - av_fifo_size(&stream->fifo);
790
791
        // first byte does not fit -> reset pts/dts + stuffing
792
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
793
            int timestamp_len=0;
794
            if(dts != pts)
795
                timestamp_len += 5;
796
            if(pts != AV_NOPTS_VALUE)
797
                timestamp_len += s->is_mpeg2 ? 5 : 4;
798
            pts=dts= AV_NOPTS_VALUE;
799
            header_len -= timestamp_len;
800
            if (s->is_dvd && stream->align_iframe) {
801
                pad_packet_bytes += timestamp_len;
802
                packet_size -= timestamp_len;
803
            } else {
804
                payload_size += timestamp_len;
805
            }
806
            stuffing_size += timestamp_len;
807
            if(payload_size > trailer_size)
808
                stuffing_size += payload_size - trailer_size;
809
        }
810
811
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
812
            packet_size += pad_packet_bytes;
813
            payload_size += pad_packet_bytes; // undo the previous adjustment
814
            if (stuffing_size < 0) {
815
                stuffing_size = pad_packet_bytes;
816
            } else {
817
                stuffing_size += pad_packet_bytes;
818
            }
819
            pad_packet_bytes = 0;
820
        }
821
822
        if (stuffing_size < 0)
823
            stuffing_size = 0;
824
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
825
            pad_packet_bytes += stuffing_size;
826
            packet_size -= stuffing_size;
827
            payload_size -= stuffing_size;
828
            stuffing_size = 0;
829
        }
830
831
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
832
833 899681cd Björn Axelsson
        put_be32(ctx->pb, startcode);
834 2abe5a01 Baptiste Coudurier
835 899681cd Björn Axelsson
        put_be16(ctx->pb, packet_size);
836 2abe5a01 Baptiste Coudurier
837
        if (!s->is_mpeg2)
838
            for(i=0;i<stuffing_size;i++)
839 899681cd Björn Axelsson
                put_byte(ctx->pb, 0xff);
840 2abe5a01 Baptiste Coudurier
841
        if (s->is_mpeg2) {
842 899681cd Björn Axelsson
            put_byte(ctx->pb, 0x80); /* mpeg2 id */
843 2abe5a01 Baptiste Coudurier
844
            pes_flags=0;
845
846
            if (pts != AV_NOPTS_VALUE) {
847
                pes_flags |= 0x80;
848
                if (dts != pts)
849
                    pes_flags |= 0x40;
850
            }
851
852
            /* Both the MPEG-2 and the SVCD standards demand that the
853
               P-STD_buffer_size field be included in the first packet of
854
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
855
               and MPEG-2 standard 2.7.7) */
856
            if (stream->packet_number == 0)
857
                pes_flags |= 0x01;
858
859 899681cd Björn Axelsson
            put_byte(ctx->pb, pes_flags); /* flags */
860
            put_byte(ctx->pb, header_len - 3 + stuffing_size);
861 2abe5a01 Baptiste Coudurier
862
            if (pes_flags & 0x80)  /*write pts*/
863 899681cd Björn Axelsson
                put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
864 2abe5a01 Baptiste Coudurier
            if (pes_flags & 0x40)  /*write dts*/
865 899681cd Björn Axelsson
                put_timestamp(ctx->pb, 0x01, dts);
866 2abe5a01 Baptiste Coudurier
867
            if (pes_flags & 0x01) {  /*write pes extension*/
868 899681cd Björn Axelsson
                put_byte(ctx->pb, 0x10); /* flags */
869 2abe5a01 Baptiste Coudurier
870
                /* P-STD buffer info */
871
                if (id == AUDIO_ID)
872 899681cd Björn Axelsson
                    put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/128);
873 2abe5a01 Baptiste Coudurier
                else
874 899681cd Björn Axelsson
                    put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
875 2abe5a01 Baptiste Coudurier
            }
876
877
        } else {
878
            if (pts != AV_NOPTS_VALUE) {
879
                if (dts != pts) {
880 899681cd Björn Axelsson
                    put_timestamp(ctx->pb, 0x03, pts);
881
                    put_timestamp(ctx->pb, 0x01, dts);
882 2abe5a01 Baptiste Coudurier
                } else {
883 899681cd Björn Axelsson
                    put_timestamp(ctx->pb, 0x02, pts);
884 2abe5a01 Baptiste Coudurier
                }
885
            } else {
886 899681cd Björn Axelsson
                put_byte(ctx->pb, 0x0f);
887 2abe5a01 Baptiste Coudurier
            }
888
        }
889
890
        if (s->is_mpeg2) {
891
            /* special stuffing byte that is always written
892
               to prevent accidental generation of start codes. */
893 899681cd Björn Axelsson
            put_byte(ctx->pb, 0xff);
894 2abe5a01 Baptiste Coudurier
895
            for(i=0;i<stuffing_size;i++)
896 899681cd Björn Axelsson
                put_byte(ctx->pb, 0xff);
897 2abe5a01 Baptiste Coudurier
        }
898
899
        if (startcode == PRIVATE_STREAM_1) {
900 899681cd Björn Axelsson
            put_byte(ctx->pb, id);
901 2abe5a01 Baptiste Coudurier
            if (id >= 0xa0) {
902
                /* LPCM (XXX: check nb_frames) */
903 899681cd Björn Axelsson
                put_byte(ctx->pb, 7);
904
                put_be16(ctx->pb, 4); /* skip 3 header bytes */
905
                put_byte(ctx->pb, stream->lpcm_header[0]);
906
                put_byte(ctx->pb, stream->lpcm_header[1]);
907
                put_byte(ctx->pb, stream->lpcm_header[2]);
908 2abe5a01 Baptiste Coudurier
            } else if (id >= 0x40) {
909
                /* AC3 */
910 899681cd Björn Axelsson
                put_byte(ctx->pb, nb_frames);
911
                put_be16(ctx->pb, trailer_size+1);
912 2abe5a01 Baptiste Coudurier
            }
913
        }
914
915
        /* output data */
916 899681cd Björn Axelsson
        if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, ctx->pb) < 0)
917 2abe5a01 Baptiste Coudurier
            return -1;
918
        stream->bytes_to_iframe -= payload_size - stuffing_size;
919
    }else{
920
        payload_size=
921
        stuffing_size= 0;
922
    }
923
924
    if (pad_packet_bytes > 0)
925 899681cd Björn Axelsson
        put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
926 2abe5a01 Baptiste Coudurier
927
    for(i=0;i<zero_trail_bytes;i++)
928 899681cd Björn Axelsson
        put_byte(ctx->pb, 0x00);
929 2abe5a01 Baptiste Coudurier
930 899681cd Björn Axelsson
    put_flush_packet(ctx->pb);
931 2abe5a01 Baptiste Coudurier
932
    s->packet_number++;
933
934
    /* only increase the stream packet number if this pack actually contains
935
       something that is specific to this stream! I.e. a dedicated header
936
       or some data.*/
937
    if (!general_pack)
938
        stream->packet_number++;
939
940
    return payload_size - stuffing_size;
941
}
942
943
static void put_vcd_padding_sector(AVFormatContext *ctx)
944
{
945
    /* There are two ways to do this padding: writing a sector/pack
946
       of 0 values, or writing an MPEG padding pack. Both seem to
947
       work with most decoders, BUT the VCD standard only allows a 0-sector
948
       (see standard p. IV-4, IV-5).
949
       So a 0-sector it is...*/
950
951
    MpegMuxContext *s = ctx->priv_data;
952
    int i;
953
954
    for(i=0;i<s->packet_size;i++)
955 899681cd Björn Axelsson
        put_byte(ctx->pb, 0);
956 2abe5a01 Baptiste Coudurier
957
    s->vcd_padding_bytes_written += s->packet_size;
958
959 899681cd Björn Axelsson
    put_flush_packet(ctx->pb);
960 2abe5a01 Baptiste Coudurier
961
    /* increasing the packet number is correct. The SCR of the following packs
962
       is calculated from the packet_number and it has to include the padding
963
       sector (it represents the sector index, not the MPEG pack index)
964
       (see VCD standard p. IV-6)*/
965
    s->packet_number++;
966
}
967
968
#if 0 /* unused, remove? */
969
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
970
{
971
    MpegMuxContext *s = ctx->priv_data;
972
    int64_t scr;
973

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

986
    return scr;
987
}
988
#endif
989
990
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
991
//    MpegMuxContext *s = ctx->priv_data;
992
    int i;
993
994
    for(i=0; i<ctx->nb_streams; i++){
995
        AVStream *st = ctx->streams[i];
996
        StreamInfo *stream = st->priv_data;
997
        PacketDesc *pkt_desc;
998
999
        while((pkt_desc= stream->predecode_packet)
1000
              && scr > pkt_desc->dts){ //FIXME > vs >=
1001
            if(stream->buffer_index < pkt_desc->size ||
1002
               stream->predecode_packet == stream->premux_packet){
1003
                av_log(ctx, AV_LOG_ERROR,
1004
                       "buffer underflow i=%d bufi=%d size=%d\n",
1005
                       i, stream->buffer_index, pkt_desc->size);
1006
                break;
1007
            }
1008
            stream->buffer_index -= pkt_desc->size;
1009
1010
            stream->predecode_packet= pkt_desc->next;
1011
            av_freep(&pkt_desc);
1012
        }
1013
    }
1014
1015
    return 0;
1016
}
1017
1018
static int output_packet(AVFormatContext *ctx, int flush){
1019
    MpegMuxContext *s = ctx->priv_data;
1020
    AVStream *st;
1021
    StreamInfo *stream;
1022
    int i, avail_space, es_size, trailer_size;
1023
    int best_i= -1;
1024
    int best_score= INT_MIN;
1025
    int ignore_constraints=0;
1026
    int64_t scr= s->last_scr;
1027
    PacketDesc *timestamp_packet;
1028
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1029
1030
retry:
1031
    for(i=0; i<ctx->nb_streams; i++){
1032
        AVStream *st = ctx->streams[i];
1033
        StreamInfo *stream = st->priv_data;
1034
        const int avail_data=  av_fifo_size(&stream->fifo);
1035
        const int space= stream->max_buffer_size - stream->buffer_index;
1036
        int rel_space= 1024*space / stream->max_buffer_size;
1037
        PacketDesc *next_pkt= stream->premux_packet;
1038
1039
        /* for subtitle, a single PES packet must be generated,
1040
           so we flush after every single subtitle packet */
1041
        if(s->packet_size > avail_data && !flush
1042
           && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1043
            return 0;
1044
        if(avail_data==0)
1045
            continue;
1046
        assert(avail_data>0);
1047
1048
        if(space < s->packet_size && !ignore_constraints)
1049
            continue;
1050
1051
        if(next_pkt && next_pkt->dts - scr > max_delay)
1052
            continue;
1053
1054
        if(rel_space > best_score){
1055
            best_score= rel_space;
1056
            best_i = i;
1057
            avail_space= space;
1058
        }
1059
    }
1060
1061
    if(best_i < 0){
1062
        int64_t best_dts= INT64_MAX;
1063
1064
        for(i=0; i<ctx->nb_streams; i++){
1065
            AVStream *st = ctx->streams[i];
1066
            StreamInfo *stream = st->priv_data;
1067
            PacketDesc *pkt_desc= stream->predecode_packet;
1068
            if(pkt_desc && pkt_desc->dts < best_dts)
1069
                best_dts= pkt_desc->dts;
1070
        }
1071
1072
#if 0
1073
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1074
               scr/90000.0, best_dts/90000.0);
1075
#endif
1076
        if(best_dts == INT64_MAX)
1077
            return 0;
1078
1079
        if(scr >= best_dts+1 && !ignore_constraints){
1080
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1081
            ignore_constraints= 1;
1082
        }
1083
        scr= FFMAX(best_dts+1, scr);
1084
        if(remove_decoded_packets(ctx, scr) < 0)
1085
            return -1;
1086
        goto retry;
1087
    }
1088
1089
    assert(best_i >= 0);
1090
1091
    st = ctx->streams[best_i];
1092
    stream = st->priv_data;
1093
1094
    assert(av_fifo_size(&stream->fifo) > 0);
1095
1096
    assert(avail_space >= s->packet_size || ignore_constraints);
1097
1098
    timestamp_packet= stream->premux_packet;
1099
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1100
        trailer_size= 0;
1101
    }else{
1102
        trailer_size= timestamp_packet->unwritten_size;
1103
        timestamp_packet= timestamp_packet->next;
1104
    }
1105
1106
    if(timestamp_packet){
1107
//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);
1108
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1109
    }else{
1110
        assert(av_fifo_size(&stream->fifo) == trailer_size);
1111
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1112
    }
1113
1114
    if (s->is_vcd) {
1115
        /* Write one or more padding sectors, if necessary, to reach
1116
           the constant overall bitrate.*/
1117
        int vcd_pad_bytes;
1118
1119
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1120
            put_vcd_padding_sector(ctx);
1121
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1122
        }
1123
    }
1124
1125
    stream->buffer_index += es_size;
1126
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1127
1128
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1129
        es_size -= stream->premux_packet->unwritten_size;
1130
        stream->premux_packet= stream->premux_packet->next;
1131
    }
1132
    if(es_size)
1133
        stream->premux_packet->unwritten_size -= es_size;
1134
1135
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1136
        return -1;
1137
1138
    return 1;
1139
}
1140
1141
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1142
{
1143
    MpegMuxContext *s = ctx->priv_data;
1144
    int stream_index= pkt->stream_index;
1145
    int size= pkt->size;
1146
    uint8_t *buf= pkt->data;
1147
    AVStream *st = ctx->streams[stream_index];
1148
    StreamInfo *stream = st->priv_data;
1149
    int64_t pts, dts;
1150
    PacketDesc *pkt_desc;
1151
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1152
    const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1153
1154
    pts= pkt->pts;
1155
    dts= pkt->dts;
1156
1157
    if(pts != AV_NOPTS_VALUE) pts += preload;
1158
    if(dts != AV_NOPTS_VALUE) dts += preload;
1159
1160
//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);
1161
    if (!stream->premux_packet)
1162
        stream->next_packet = &stream->premux_packet;
1163
    *stream->next_packet=
1164
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1165
    pkt_desc->pts= pts;
1166
    pkt_desc->dts= dts;
1167
    pkt_desc->unwritten_size=
1168
    pkt_desc->size= size;
1169
    if(!stream->predecode_packet)
1170
        stream->predecode_packet= pkt_desc;
1171
    stream->next_packet= &pkt_desc->next;
1172
1173
    av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1174
1175
    if (s->is_dvd){
1176
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1177
            stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1178
            stream->align_iframe = 1;
1179
            stream->vobu_start_pts = pts;
1180
        }
1181
    }
1182
1183
    av_fifo_write(&stream->fifo, buf, size);
1184
1185
    for(;;){
1186
        int ret= output_packet(ctx, 0);
1187
        if(ret<=0)
1188
            return ret;
1189
    }
1190
}
1191
1192
static int mpeg_mux_end(AVFormatContext *ctx)
1193
{
1194
//    MpegMuxContext *s = ctx->priv_data;
1195
    StreamInfo *stream;
1196
    int i;
1197
1198
    for(;;){
1199
        int ret= output_packet(ctx, 1);
1200
        if(ret<0)
1201
            return ret;
1202
        else if(ret==0)
1203
            break;
1204
    }
1205
1206
    /* End header according to MPEG1 systems standard. We do not write
1207
       it as it is usually not needed by decoders and because it
1208
       complicates MPEG stream concatenation. */
1209 899681cd Björn Axelsson
    //put_be32(ctx->pb, ISO_11172_END_CODE);
1210
    //put_flush_packet(ctx->pb);
1211 2abe5a01 Baptiste Coudurier
1212
    for(i=0;i<ctx->nb_streams;i++) {
1213
        stream = ctx->streams[i]->priv_data;
1214
1215
        assert(av_fifo_size(&stream->fifo) == 0);
1216
        av_fifo_free(&stream->fifo);
1217
    }
1218
    return 0;
1219
}
1220
1221
#ifdef CONFIG_MPEG1SYSTEM_MUXER
1222
AVOutputFormat mpeg1system_muxer = {
1223
    "mpeg",
1224
    "MPEG1 System format",
1225
    "video/mpeg",
1226
    "mpg,mpeg",
1227
    sizeof(MpegMuxContext),
1228
    CODEC_ID_MP2,
1229
    CODEC_ID_MPEG1VIDEO,
1230
    mpeg_mux_init,
1231
    mpeg_mux_write_packet,
1232
    mpeg_mux_end,
1233
};
1234
#endif
1235
#ifdef CONFIG_MPEG1VCD_MUXER
1236
AVOutputFormat mpeg1vcd_muxer = {
1237
    "vcd",
1238
    "MPEG1 System format (VCD)",
1239
    "video/mpeg",
1240
    NULL,
1241
    sizeof(MpegMuxContext),
1242
    CODEC_ID_MP2,
1243
    CODEC_ID_MPEG1VIDEO,
1244
    mpeg_mux_init,
1245
    mpeg_mux_write_packet,
1246
    mpeg_mux_end,
1247
};
1248
#endif
1249
#ifdef CONFIG_MPEG2VOB_MUXER
1250
AVOutputFormat mpeg2vob_muxer = {
1251
    "vob",
1252
    "MPEG2 PS format (VOB)",
1253
    "video/mpeg",
1254
    "vob",
1255
    sizeof(MpegMuxContext),
1256
    CODEC_ID_MP2,
1257
    CODEC_ID_MPEG2VIDEO,
1258
    mpeg_mux_init,
1259
    mpeg_mux_write_packet,
1260
    mpeg_mux_end,
1261
};
1262
#endif
1263
1264
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1265
#ifdef CONFIG_MPEG2SVCD_MUXER
1266
AVOutputFormat mpeg2svcd_muxer = {
1267
    "svcd",
1268
    "MPEG2 PS format (VOB)",
1269
    "video/mpeg",
1270
    "vob",
1271
    sizeof(MpegMuxContext),
1272
    CODEC_ID_MP2,
1273
    CODEC_ID_MPEG2VIDEO,
1274
    mpeg_mux_init,
1275
    mpeg_mux_write_packet,
1276
    mpeg_mux_end,
1277
};
1278
#endif
1279
1280
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1281
#ifdef CONFIG_MPEG2DVD_MUXER
1282
AVOutputFormat mpeg2dvd_muxer = {
1283
    "dvd",
1284
    "MPEG2 PS format (DVD VOB)",
1285
    "video/mpeg",
1286
    "dvd",
1287
    sizeof(MpegMuxContext),
1288
    CODEC_ID_MP2,
1289
    CODEC_ID_MPEG2VIDEO,
1290
    mpeg_mux_init,
1291
    mpeg_mux_write_packet,
1292
    mpeg_mux_end,
1293
};
1294
#endif