Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 30a43f2d

History | View | Annotate | Download (55.6 KB)

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

    
22
#define MAX_PAYLOAD_SIZE 4096
23
//#define DEBUG_SEEK
24

    
25
#undef NDEBUG
26
#include <assert.h>
27

    
28
typedef struct PacketDesc {
29
    int64_t pts;
30
    int64_t dts;
31
    int size;
32
    int unwritten_size;
33
    int flags;
34
    struct PacketDesc *next;
35
} PacketDesc;
36

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

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

    
69
    double vcd_padding_bitrate; //FIXME floats
70
    int64_t vcd_padding_bytes_written;
71

    
72
} MpegMuxContext;
73

    
74
#define PACK_START_CODE             ((unsigned int)0x000001ba)
75
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
76
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
77
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
78
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
79
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
80

    
81
/* mpeg2 */
82
#define PROGRAM_STREAM_MAP 0x1bc
83
#define PRIVATE_STREAM_1   0x1bd
84
#define PADDING_STREAM     0x1be
85
#define PRIVATE_STREAM_2   0x1bf
86

    
87

    
88
#define AUDIO_ID 0xc0
89
#define VIDEO_ID 0xe0
90
#define AC3_ID   0x80
91
#define DTS_ID   0x8a
92
#define LPCM_ID  0xa0
93
#define SUB_ID   0x20
94

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

    
105
#define STREAM_TYPE_AUDIO_AC3       0x81
106
#define STREAM_TYPE_AUDIO_DTS       0x8a
107

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

    
110
#ifdef CONFIG_MUXERS
111
static AVOutputFormat mpeg1system_mux;
112
static AVOutputFormat mpeg1vcd_mux;
113
static AVOutputFormat mpeg2vob_mux;
114
static AVOutputFormat mpeg2svcd_mux;
115
static AVOutputFormat mpeg2dvd_mux;
116

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

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

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

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

    
159
    init_put_bits(&pb, buf, 128);
160

    
161
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
162
    put_bits(&pb, 16, 0);
163
    put_bits(&pb, 1, 1);
164

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

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

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

    
191
    put_bits(&pb, 1, 1); /* marker */
192

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

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

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

    
212
        int P_STD_max_video = 0;
213
        int P_STD_max_mpeg_audio = 0;
214
        int P_STD_max_mpeg_PS1 = 0;
215

    
216
        for(i=0;i<ctx->nb_streams;i++) {
217
            StreamInfo *stream = ctx->streams[i]->priv_data;
218

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

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

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

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

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

    
261

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

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

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

    
297
    return size;
298
}
299

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

    
306
    if (s->is_dvd)
307
       return 18; // DVD-Video system headers are 18 bytes fixed length.
308

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

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

    
332
    s->packet_number = 0;
333
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
334
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
335
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
336
    s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
337

    
338
    if(ctx->packet_size)
339
        s->packet_size = ctx->packet_size;
340
    else
341
        s->packet_size = 2048;
342

    
343
    s->vcd_padding_bytes_written = 0;
344
    s->vcd_padding_bitrate=0;
345

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

    
361
        av_set_pts_info(st, 64, 1, 90000);
362

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

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

    
425
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
426
            codec_rate= st->codec->rc_max_rate;
427
        else
428
            codec_rate= st->codec->bit_rate;
429

    
430
        if(!codec_rate)
431
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
432

    
433
        bitrate += codec_rate;
434

    
435
        if (stream->id==AUDIO_ID)
436
            audio_bitrate += codec_rate;
437
        else if (stream->id==VIDEO_ID)
438
            video_bitrate += codec_rate;
439
    }
440

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

    
451
    if (s->is_vcd) {
452
        double overhead_rate;
453

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

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

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

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

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

    
487
    /* the above seems to make pack_header_freq zero sometimes */
488
    if (s->pack_header_freq == 0)
489
       s->pack_header_freq = 1;
490

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

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

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

    
526

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

    
534
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
535
    {
536
        int64_t full_pad_bytes;
537

    
538
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
539
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
540

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

    
547
    return pad_bytes;
548
}
549

    
550

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

562
    stream = ctx->streams[stream_index]->priv_data;
563

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

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

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

582
        } else {
583
            if ((s->packet_number % s->system_header_freq) == 0)
584
                buf_index += s->system_header_size;
585
        }
586
    }
587

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

609
        } else {
610
            if (!s->is_mpeg2)
611
                buf_index++;
612
        }
613

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

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

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

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

    
651
    for(i=0;i<packet_bytes;i++)
652
        put_byte(pb, 0xff);
653
}
654

    
655
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
656
    int nb_frames=0;
657
    PacketDesc *pkt_desc= stream->premux_packet;
658

    
659
    while(len>0){
660
        if(pkt_desc->size == pkt_desc->unwritten_size)
661
            nb_frames++;
662
        len -= pkt_desc->unwritten_size;
663
        pkt_desc= pkt_desc->next;
664
    }
665

    
666
    return nb_frames;
667
}
668

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

    
685
    id = stream->id;
686

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

    
692
    buf_ptr = buffer;
693

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

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

    
705
            if (stream->packet_number==0) {
706
                size = put_system_header(ctx, buf_ptr, id);
707
                buf_ptr += size;
708
            }
709
        } else if (s->is_dvd) {
710
            if (stream->align_iframe || s->packet_number == 0){
711
                int bytes_to_iframe;
712
                int PES_bytes_to_fill;
713
                if (stream->fifo_iframe_ptr >= stream->fifo.rptr) {
714
                    bytes_to_iframe = stream->fifo_iframe_ptr - stream->fifo.rptr;
715
                } else {
716
                    bytes_to_iframe = (stream->fifo.end - stream->fifo.rptr) + (stream->fifo_iframe_ptr - stream->fifo.buffer);
717
                }
718
                PES_bytes_to_fill = s->packet_size - size - 10;
719

    
720
                if (pts != AV_NOPTS_VALUE) {
721
                    if (dts != pts)
722
                        PES_bytes_to_fill -= 5 + 5;
723
                    else
724
                        PES_bytes_to_fill -= 5;
725
                }
726

    
727
                if (bytes_to_iframe == 0 || s->packet_number == 0) {
728
                    size = put_system_header(ctx, buf_ptr, 0);
729
                    buf_ptr += size;
730
                    size = buf_ptr - buffer;
731
                    put_buffer(&ctx->pb, buffer, size);
732

    
733
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
734
                    put_be16(&ctx->pb, 0x03d4);         // length
735
                    put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
736
                    for (i = 0; i < 979; i++)
737
                        put_byte(&ctx->pb, 0x00);
738

    
739
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
740
                    put_be16(&ctx->pb, 0x03fa);         // length
741
                    put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
742
                    for (i = 0; i < 1017; i++)
743
                        put_byte(&ctx->pb, 0x00);
744

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

    
768
    packet_size = s->packet_size - size;
769

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

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

    
788
    packet_size -= pad_packet_bytes + zero_trail_bytes;
789

    
790
    if (packet_size > 0) {
791

    
792
        /* packet header size */
793
        packet_size -= 6;
794

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

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

    
827
        stuffing_size = payload_size - fifo_size(&stream->fifo, stream->fifo.rptr);
828

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

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

    
860
        if (stuffing_size < 0)
861
            stuffing_size = 0;
862
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
863
            pad_packet_bytes += stuffing_size;
864
            packet_size -= stuffing_size;
865
            payload_size -= stuffing_size;
866
            stuffing_size = 0;
867
        }
868

    
869
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
870

    
871
        put_be32(&ctx->pb, startcode);
872

    
873
        put_be16(&ctx->pb, packet_size);
874

    
875
        if (!s->is_mpeg2)
876
            for(i=0;i<stuffing_size;i++)
877
                put_byte(&ctx->pb, 0xff);
878

    
879
        if (s->is_mpeg2) {
880
            put_byte(&ctx->pb, 0x80); /* mpeg2 id */
881

    
882
            pes_flags=0;
883

    
884
            if (pts != AV_NOPTS_VALUE) {
885
                pes_flags |= 0x80;
886
                if (dts != pts)
887
                    pes_flags |= 0x40;
888
            }
889

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

    
897
            put_byte(&ctx->pb, pes_flags); /* flags */
898
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
899

    
900
            if (pes_flags & 0x80)  /*write pts*/
901
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
902
            if (pes_flags & 0x40)  /*write dts*/
903
                put_timestamp(&ctx->pb, 0x01, dts);
904

    
905
            if (pes_flags & 0x01) {  /*write pes extension*/
906
                put_byte(&ctx->pb, 0x10); /* flags */
907

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

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

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

    
933
            for(i=0;i<stuffing_size;i++)
934
                put_byte(&ctx->pb, 0xff);
935
        }
936

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

    
953
        /* output data */
954
        if(put_fifo(&ctx->pb, &stream->fifo, payload_size - stuffing_size, &stream->fifo.rptr) < 0)
955
            return -1;
956
    }else{
957
        payload_size=
958
        stuffing_size= 0;
959
    }
960

    
961
    if (pad_packet_bytes > 0)
962
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
963

    
964
    for(i=0;i<zero_trail_bytes;i++)
965
        put_byte(&ctx->pb, 0x00);
966

    
967
    put_flush_packet(&ctx->pb);
968

    
969
    s->packet_number++;
970

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

    
977
    return payload_size - stuffing_size;
978
}
979

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

    
988
    MpegMuxContext *s = ctx->priv_data;
989
    int i;
990

    
991
    for(i=0;i<s->packet_size;i++)
992
        put_byte(&ctx->pb, 0);
993

    
994
    s->vcd_padding_bytes_written += s->packet_size;
995

    
996
    put_flush_packet(&ctx->pb);
997

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

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

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

1023
    return scr;
1024
}
1025
#endif
1026

    
1027
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1028
//    MpegMuxContext *s = ctx->priv_data;
1029
    int i;
1030

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

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

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

    
1049
    return 0;
1050
}
1051

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

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

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

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

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

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

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

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

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

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

    
1123
    assert(best_i >= 0);
1124

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

    
1128
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
1129

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

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

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

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

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

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

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

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

    
1172
    return 1;
1173
}
1174

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

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

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

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

    
1207
    fifo_realloc(&stream->fifo, fifo_size(&stream->fifo, NULL) + size + 1);
1208

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

    
1219
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1220

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

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

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

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

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

    
1251
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1252
        fifo_free(&stream->fifo);
1253
    }
1254
    return 0;
1255
}
1256
#endif //CONFIG_MUXERS
1257

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

    
1261
#define MAX_SYNC_SIZE 100000
1262

    
1263
static int mpegps_probe(AVProbeData *p)
1264
{
1265
    uint32_t code= -1;
1266
    int sys=0, pspack=0, priv1=0, vid=0;
1267
    int i;
1268

    
1269
    for(i=0; i<p->buf_size; i++){
1270
        code = (code<<8) + p->buf[i];
1271
        if ((code & 0xffffff00) == 0x100) {
1272
            switch(code){
1273
            case SYSTEM_HEADER_START_CODE:    sys++; break;
1274
            case         PRIVATE_STREAM_1:  priv1++; break;
1275
            case          PACK_START_CODE: pspack++; break;
1276
            case       (VIDEO_ID + 0x100):    vid++; break;
1277
            }
1278
        }
1279
    }
1280
    if(sys && sys*9 <= pspack*10)
1281
        return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1282
    if((priv1 || vid) && (priv1+vid)*9 <= pspack*10)
1283
        return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1284
    return 0;
1285
}
1286

    
1287

    
1288
typedef struct MpegDemuxContext {
1289
    int header_state;
1290
    unsigned char psm_es_type[256];
1291
} MpegDemuxContext;
1292

    
1293
static int mpegps_read_header(AVFormatContext *s,
1294
                              AVFormatParameters *ap)
1295
{
1296
    MpegDemuxContext *m = s->priv_data;
1297
    m->header_state = 0xff;
1298
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1299

    
1300
    /* no need to do more */
1301
    return 0;
1302
}
1303

    
1304
static int64_t get_pts(ByteIOContext *pb, int c)
1305
{
1306
    int64_t pts;
1307
    int val;
1308

    
1309
    if (c < 0)
1310
        c = get_byte(pb);
1311
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1312
    val = get_be16(pb);
1313
    pts |= (int64_t)(val >> 1) << 15;
1314
    val = get_be16(pb);
1315
    pts |= (int64_t)(val >> 1);
1316
    return pts;
1317
}
1318

    
1319
static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1320
                                uint32_t *header_state)
1321
{
1322
    unsigned int state, v;
1323
    int val, n;
1324

    
1325
    state = *header_state;
1326
    n = *size_ptr;
1327
    while (n > 0) {
1328
        if (url_feof(pb))
1329
            break;
1330
        v = get_byte(pb);
1331
        n--;
1332
        if (state == 0x000001) {
1333
            state = ((state << 8) | v) & 0xffffff;
1334
            val = state;
1335
            goto found;
1336
        }
1337
        state = ((state << 8) | v) & 0xffffff;
1338
    }
1339
    val = -1;
1340
 found:
1341
    *header_state = state;
1342
    *size_ptr = n;
1343
    return val;
1344
}
1345

    
1346
#if 0 /* unused, remove? */
1347
/* XXX: optimize */
1348
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1349
{
1350
    int64_t pos, pos_start;
1351
    int max_size, start_code;
1352

1353
    max_size = *size_ptr;
1354
    pos_start = url_ftell(pb);
1355

1356
    /* in order to go faster, we fill the buffer */
1357
    pos = pos_start - 16386;
1358
    if (pos < 0)
1359
        pos = 0;
1360
    url_fseek(pb, pos, SEEK_SET);
1361
    get_byte(pb);
1362

1363
    pos = pos_start;
1364
    for(;;) {
1365
        pos--;
1366
        if (pos < 0 || (pos_start - pos) >= max_size) {
1367
            start_code = -1;
1368
            goto the_end;
1369
        }
1370
        url_fseek(pb, pos, SEEK_SET);
1371
        start_code = get_be32(pb);
1372
        if ((start_code & 0xffffff00) == 0x100)
1373
            break;
1374
    }
1375
 the_end:
1376
    *size_ptr = pos_start - pos;
1377
    return start_code;
1378
}
1379
#endif
1380

    
1381
/**
1382
 * Extracts stream types from a program stream map
1383
 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1384
 *
1385
 * @return number of bytes occupied by PSM in the bitstream
1386
 */
1387
static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1388
{
1389
    int psm_length, ps_info_length, es_map_length;
1390

    
1391
    psm_length = get_be16(pb);
1392
    get_byte(pb);
1393
    get_byte(pb);
1394
    ps_info_length = get_be16(pb);
1395

    
1396
    /* skip program_stream_info */
1397
    url_fskip(pb, ps_info_length);
1398
    es_map_length = get_be16(pb);
1399

    
1400
    /* at least one es available? */
1401
    while (es_map_length >= 4){
1402
        unsigned char type = get_byte(pb);
1403
        unsigned char es_id = get_byte(pb);
1404
        uint16_t es_info_length = get_be16(pb);
1405
        /* remember mapping from stream id to stream type */
1406
        m->psm_es_type[es_id] = type;
1407
        /* skip program_stream_info */
1408
        url_fskip(pb, es_info_length);
1409
        es_map_length -= 4 + es_info_length;
1410
    }
1411
    get_be32(pb); /* crc32 */
1412
    return 2 + psm_length;
1413
}
1414

    
1415
/* read the next PES header. Return its position in ppos
1416
   (if not NULL), and its start code, pts and dts.
1417
 */
1418
static int mpegps_read_pes_header(AVFormatContext *s,
1419
                                  int64_t *ppos, int *pstart_code,
1420
                                  int64_t *ppts, int64_t *pdts)
1421
{
1422
    MpegDemuxContext *m = s->priv_data;
1423
    int len, size, startcode, c, flags, header_len;
1424
    int64_t pts, dts, last_pos;
1425

    
1426
    last_pos = -1;
1427
 redo:
1428
        /* next start code (should be immediately after) */
1429
        m->header_state = 0xff;
1430
        size = MAX_SYNC_SIZE;
1431
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1432
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1433
    if (startcode < 0)
1434
        return AVERROR_IO;
1435
    if (startcode == PACK_START_CODE)
1436
        goto redo;
1437
    if (startcode == SYSTEM_HEADER_START_CODE)
1438
        goto redo;
1439
    if (startcode == PADDING_STREAM ||
1440
        startcode == PRIVATE_STREAM_2) {
1441
        /* skip them */
1442
        len = get_be16(&s->pb);
1443
        url_fskip(&s->pb, len);
1444
        goto redo;
1445
    }
1446
    if (startcode == PROGRAM_STREAM_MAP) {
1447
        mpegps_psm_parse(m, &s->pb);
1448
        goto redo;
1449
    }
1450

    
1451
    /* find matching stream */
1452
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1453
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1454
          (startcode == 0x1bd)))
1455
        goto redo;
1456
    if (ppos) {
1457
        *ppos = url_ftell(&s->pb) - 4;
1458
    }
1459
    len = get_be16(&s->pb);
1460
    pts = AV_NOPTS_VALUE;
1461
    dts = AV_NOPTS_VALUE;
1462
    /* stuffing */
1463
    for(;;) {
1464
        if (len < 1)
1465
            goto redo;
1466
        c = get_byte(&s->pb);
1467
        len--;
1468
        /* XXX: for mpeg1, should test only bit 7 */
1469
        if (c != 0xff)
1470
            break;
1471
    }
1472
    if ((c & 0xc0) == 0x40) {
1473
        /* buffer scale & size */
1474
        if (len < 2)
1475
            goto redo;
1476
        get_byte(&s->pb);
1477
        c = get_byte(&s->pb);
1478
        len -= 2;
1479
    }
1480
    if ((c & 0xf0) == 0x20) {
1481
        if (len < 4)
1482
            goto redo;
1483
        dts = pts = get_pts(&s->pb, c);
1484
        len -= 4;
1485
    } else if ((c & 0xf0) == 0x30) {
1486
        if (len < 9)
1487
            goto redo;
1488
        pts = get_pts(&s->pb, c);
1489
        dts = get_pts(&s->pb, -1);
1490
        len -= 9;
1491
    } else if ((c & 0xc0) == 0x80) {
1492
        /* mpeg 2 PES */
1493
        if ((c & 0x30) != 0) {
1494
            /* Encrypted multiplex not handled */
1495
            goto redo;
1496
        }
1497
        flags = get_byte(&s->pb);
1498
        header_len = get_byte(&s->pb);
1499
        len -= 2;
1500
        if (header_len > len)
1501
            goto redo;
1502
        if ((flags & 0xc0) == 0x80) {
1503
            dts = pts = get_pts(&s->pb, -1);
1504
            if (header_len < 5)
1505
                goto redo;
1506
            header_len -= 5;
1507
            len -= 5;
1508
        } if ((flags & 0xc0) == 0xc0) {
1509
            pts = get_pts(&s->pb, -1);
1510
            dts = get_pts(&s->pb, -1);
1511
            if (header_len < 10)
1512
                goto redo;
1513
            header_len -= 10;
1514
            len -= 10;
1515
        }
1516
        len -= header_len;
1517
        while (header_len > 0) {
1518
            get_byte(&s->pb);
1519
            header_len--;
1520
        }
1521
    }
1522
    else if( c!= 0xf )
1523
        goto redo;
1524

    
1525
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1526
        if (len < 1)
1527
            goto redo;
1528
        startcode = get_byte(&s->pb);
1529
        len--;
1530
        if (startcode >= 0x80 && startcode <= 0xbf) {
1531
            /* audio: skip header */
1532
            if (len < 3)
1533
                goto redo;
1534
            get_byte(&s->pb);
1535
            get_byte(&s->pb);
1536
            get_byte(&s->pb);
1537
            len -= 3;
1538
        }
1539
    }
1540
    if(dts != AV_NOPTS_VALUE && ppos){
1541
        int i;
1542
        for(i=0; i<s->nb_streams; i++){
1543
            if(startcode == s->streams[i]->id) {
1544
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1545
            }
1546
        }
1547
    }
1548

    
1549
    *pstart_code = startcode;
1550
    *ppts = pts;
1551
    *pdts = dts;
1552
    return len;
1553
}
1554

    
1555
static int mpegps_read_packet(AVFormatContext *s,
1556
                              AVPacket *pkt)
1557
{
1558
    MpegDemuxContext *m = s->priv_data;
1559
    AVStream *st;
1560
    int len, startcode, i, type, codec_id = 0, es_type;
1561
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1562

    
1563
 redo:
1564
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1565
    if (len < 0)
1566
        return len;
1567

    
1568
    /* now find stream */
1569
    for(i=0;i<s->nb_streams;i++) {
1570
        st = s->streams[i];
1571
        if (st->id == startcode)
1572
            goto found;
1573
    }
1574

    
1575
    es_type = m->psm_es_type[startcode & 0xff];
1576
    if(es_type > 0){
1577
        if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1578
            codec_id = CODEC_ID_MPEG2VIDEO;
1579
            type = CODEC_TYPE_VIDEO;
1580
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1581
            codec_id = CODEC_ID_MPEG2VIDEO;
1582
            type = CODEC_TYPE_VIDEO;
1583
        } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1584
                  es_type == STREAM_TYPE_AUDIO_MPEG2){
1585
            codec_id = CODEC_ID_MP3;
1586
            type = CODEC_TYPE_AUDIO;
1587
        } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1588
            codec_id = CODEC_ID_AAC;
1589
            type = CODEC_TYPE_AUDIO;
1590
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1591
            codec_id = CODEC_ID_MPEG4;
1592
            type = CODEC_TYPE_VIDEO;
1593
        } else if(es_type == STREAM_TYPE_VIDEO_H264){
1594
            codec_id = CODEC_ID_H264;
1595
            type = CODEC_TYPE_VIDEO;
1596
        } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1597
            codec_id = CODEC_ID_AC3;
1598
            type = CODEC_TYPE_AUDIO;
1599
        } else {
1600
            goto skip;
1601
        }
1602
    } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1603
        type = CODEC_TYPE_VIDEO;
1604
        codec_id = CODEC_ID_MPEG2VIDEO;
1605
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1606
        type = CODEC_TYPE_AUDIO;
1607
        codec_id = CODEC_ID_MP2;
1608
    } else if (startcode >= 0x80 && startcode <= 0x87) {
1609
        type = CODEC_TYPE_AUDIO;
1610
        codec_id = CODEC_ID_AC3;
1611
    } else if (startcode >= 0x88 && startcode <= 0x9f) {
1612
        type = CODEC_TYPE_AUDIO;
1613
        codec_id = CODEC_ID_DTS;
1614
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1615
        type = CODEC_TYPE_AUDIO;
1616
        codec_id = CODEC_ID_PCM_S16BE;
1617
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
1618
        type = CODEC_TYPE_SUBTITLE;
1619
        codec_id = CODEC_ID_DVD_SUBTITLE;
1620
    } else {
1621
    skip:
1622
        /* skip packet */
1623
        url_fskip(&s->pb, len);
1624
        goto redo;
1625
    }
1626
    /* no stream found: add a new stream */
1627
    st = av_new_stream(s, startcode);
1628
    if (!st)
1629
        goto skip;
1630
    st->codec->codec_type = type;
1631
    st->codec->codec_id = codec_id;
1632
    if (codec_id != CODEC_ID_PCM_S16BE)
1633
        st->need_parsing = 1;
1634
 found:
1635
    if(st->discard >= AVDISCARD_ALL)
1636
        goto skip;
1637
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1638
        int b1, freq;
1639

    
1640
        /* for LPCM, we just skip the header and consider it is raw
1641
           audio data */
1642
        if (len <= 3)
1643
            goto skip;
1644
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1645
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1646
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1647
        len -= 3;
1648
        freq = (b1 >> 4) & 3;
1649
        st->codec->sample_rate = lpcm_freq_tab[freq];
1650
        st->codec->channels = 1 + (b1 & 7);
1651
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1652
    }
1653
    av_new_packet(pkt, len);
1654
    get_buffer(&s->pb, pkt->data, pkt->size);
1655
    pkt->pts = pts;
1656
    pkt->dts = dts;
1657
    pkt->stream_index = st->index;
1658
#if 0
1659
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1660
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1661
#endif
1662

    
1663
    return 0;
1664
}
1665

    
1666
static int mpegps_read_close(AVFormatContext *s)
1667
{
1668
    return 0;
1669
}
1670

    
1671
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1672
                               int64_t *ppos, int64_t pos_limit)
1673
{
1674
    int len, startcode;
1675
    int64_t pos, pts, dts;
1676

    
1677
    pos = *ppos;
1678
#ifdef DEBUG_SEEK
1679
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1680
#endif
1681
    url_fseek(&s->pb, pos, SEEK_SET);
1682
    for(;;) {
1683
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1684
        if (len < 0) {
1685
#ifdef DEBUG_SEEK
1686
            printf("none (ret=%d)\n", len);
1687
#endif
1688
            return AV_NOPTS_VALUE;
1689
        }
1690
        if (startcode == s->streams[stream_index]->id &&
1691
            dts != AV_NOPTS_VALUE) {
1692
            break;
1693
        }
1694
        url_fskip(&s->pb, len);
1695
    }
1696
#ifdef DEBUG_SEEK
1697
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1698
#endif
1699
    *ppos = pos;
1700
    return dts;
1701
}
1702

    
1703
#ifdef CONFIG_MUXERS
1704
static AVOutputFormat mpeg1system_mux = {
1705
    "mpeg",
1706
    "MPEG1 System format",
1707
    "video/mpeg",
1708
    "mpg,mpeg",
1709
    sizeof(MpegMuxContext),
1710
    CODEC_ID_MP2,
1711
    CODEC_ID_MPEG1VIDEO,
1712
    mpeg_mux_init,
1713
    mpeg_mux_write_packet,
1714
    mpeg_mux_end,
1715
};
1716

    
1717
static AVOutputFormat mpeg1vcd_mux = {
1718
    "vcd",
1719
    "MPEG1 System format (VCD)",
1720
    "video/mpeg",
1721
    NULL,
1722
    sizeof(MpegMuxContext),
1723
    CODEC_ID_MP2,
1724
    CODEC_ID_MPEG1VIDEO,
1725
    mpeg_mux_init,
1726
    mpeg_mux_write_packet,
1727
    mpeg_mux_end,
1728
};
1729

    
1730
static AVOutputFormat mpeg2vob_mux = {
1731
    "vob",
1732
    "MPEG2 PS format (VOB)",
1733
    "video/mpeg",
1734
    "vob",
1735
    sizeof(MpegMuxContext),
1736
    CODEC_ID_MP2,
1737
    CODEC_ID_MPEG2VIDEO,
1738
    mpeg_mux_init,
1739
    mpeg_mux_write_packet,
1740
    mpeg_mux_end,
1741
};
1742

    
1743
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1744
static AVOutputFormat mpeg2svcd_mux = {
1745
    "svcd",
1746
    "MPEG2 PS format (VOB)",
1747
    "video/mpeg",
1748
    "vob",
1749
    sizeof(MpegMuxContext),
1750
    CODEC_ID_MP2,
1751
    CODEC_ID_MPEG2VIDEO,
1752
    mpeg_mux_init,
1753
    mpeg_mux_write_packet,
1754
    mpeg_mux_end,
1755
};
1756

    
1757
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1758
static AVOutputFormat mpeg2dvd_mux = {
1759
    "dvd",
1760
    "MPEG2 PS format (DVD VOB)",
1761
    "video/mpeg",
1762
    "dvd",
1763
    sizeof(MpegMuxContext),
1764
    CODEC_ID_MP2,
1765
    CODEC_ID_MPEG2VIDEO,
1766
    mpeg_mux_init,
1767
    mpeg_mux_write_packet,
1768
    mpeg_mux_end,
1769
};
1770

    
1771
#endif //CONFIG_MUXERS
1772

    
1773
AVInputFormat mpegps_demux = {
1774
    "mpeg",
1775
    "MPEG PS format",
1776
    sizeof(MpegDemuxContext),
1777
    mpegps_probe,
1778
    mpegps_read_header,
1779
    mpegps_read_packet,
1780
    mpegps_read_close,
1781
    NULL, //mpegps_read_seek,
1782
    mpegps_read_dts,
1783
    .flags = AVFMT_SHOW_IDS,
1784
};
1785

    
1786
int mpegps_init(void)
1787
{
1788
#ifdef CONFIG_MUXERS
1789
    av_register_output_format(&mpeg1system_mux);
1790
    av_register_output_format(&mpeg1vcd_mux);
1791
    av_register_output_format(&mpeg2vob_mux);
1792
    av_register_output_format(&mpeg2svcd_mux);
1793
    av_register_output_format(&mpeg2dvd_mux);
1794
#endif //CONFIG_MUXERS
1795
    av_register_input_format(&mpegps_demux);
1796
    return 0;
1797
}