Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ e3d1cd8e

History | View | Annotate | Download (55.5 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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

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

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

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

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

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

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

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

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

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

    
172
    if (s->is_vcd) {
173
        /* see VCD standard, p. IV-7*/
174
        put_bits(&pb, 1, 0); 
175
        put_bits(&pb, 1, 1);
176
    } else {
177
        put_bits(&pb, 1, 0); /* variable bitrate*/
178
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
179
    }
180
    
181
    if (s->is_vcd || s->is_dvd) {
182
        /* see VCD standard p IV-7 */
183
        put_bits(&pb, 1, 1); /* audio locked */
184
        put_bits(&pb, 1, 1); /* video locked */
185
    } else {
186
        put_bits(&pb, 1, 0); /* audio locked */
187
        put_bits(&pb, 1, 0); /* video locked */
188
    }
189

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

    
192
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
193
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
194
        put_bits(&pb, 5, 0);
195
    } else
196
        put_bits(&pb, 5, s->video_bound);
197
    
198
    if (s->is_dvd) {
199
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
200
        put_bits(&pb, 7, 0x7f); /* reserved byte */
201
    } else
202
        put_bits(&pb, 8, 0xff); /* reserved byte */
203
    
204
    /* DVD-Video Stream_bound entries
205
    id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1) 
206
    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) 
207
    id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1) 
208
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
209
    if (s->is_dvd) {
210
        
211
        int P_STD_max_video = 0;
212
        int P_STD_max_mpeg_audio = 0;
213
        int P_STD_max_mpeg_PS1 = 0;
214
        
215
        for(i=0;i<ctx->nb_streams;i++) {
216
            StreamInfo *stream = ctx->streams[i]->priv_data;
217

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

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

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

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

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

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

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

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

    
296
    return size;
297
}
298

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

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

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

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

    
331
    s->packet_number = 0;
332
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
333
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
334
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
335
    s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
336
    
337
    if(ctx->packet_size)
338
        s->packet_size = ctx->packet_size;
339
    else
340
        s->packet_size = 2048;
341
       
342
    s->vcd_padding_bytes_written = 0;
343
    s->vcd_padding_bitrate=0;
344
        
345
    s->audio_bound = 0;
346
    s->video_bound = 0;
347
    mpa_id = AUDIO_ID;
348
    ac3_id = AC3_ID;
349
    dts_id = DTS_ID;
350
    mpv_id = VIDEO_ID;
351
    lpcm_id = LPCM_ID;
352
    for(i=0;i<ctx->nb_streams;i++) {
353
        st = ctx->streams[i];
354
        stream = av_mallocz(sizeof(StreamInfo));
355
        if (!stream)
356
            goto fail;
357
        st->priv_data = stream;
358

    
359
        av_set_pts_info(st, 64, 1, 90000);
360

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

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

    
420
        if(st->codec.rc_max_rate || stream->id==VIDEO_ID)
421
            codec_rate= st->codec.rc_max_rate;
422
        else
423
            codec_rate= st->codec.bit_rate;
424
                
425
        if(!codec_rate)
426
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
427
            
428
        bitrate += codec_rate;
429

    
430
        if (stream->id==AUDIO_ID)
431
            audio_bitrate += codec_rate;
432
        else if (stream->id==VIDEO_ID)
433
            video_bitrate += codec_rate;
434
    }
435
    
436
    if(ctx->mux_rate){
437
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
438
    } else {
439
        /* we increase slightly the bitrate to take into account the
440
           headers. XXX: compute it exactly */
441
        bitrate += bitrate*5/100;
442
        bitrate += 10000;
443
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
444
    }
445

    
446
    if (s->is_vcd) {
447
        double overhead_rate;
448

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

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

    
465
        /* Add the header overhead to the data rate.
466
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
467
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
468
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
469
        overhead_rate *= 8;
470
        
471
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
472
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
473
    }
474
    
475
    if (s->is_vcd || s->is_mpeg2)
476
        /* every packet */
477
        s->pack_header_freq = 1;
478
    else
479
        /* every 2 seconds */
480
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
481

    
482
    /* the above seems to make pack_header_freq zero sometimes */
483
    if (s->pack_header_freq == 0)
484
       s->pack_header_freq = 1;
485
    
486
    if (s->is_mpeg2)
487
        /* every 200 packets. Need to look at the spec.  */
488
        s->system_header_freq = s->pack_header_freq * 40;
489
    else if (s->is_vcd)
490
        /* the standard mandates that there are only two system headers
491
           in the whole file: one in the first packet of each stream.
492
           (see standard p. IV-7 and IV-8) */
493
        s->system_header_freq = 0x7fffffff;
494
    else
495
        s->system_header_freq = s->pack_header_freq * 5;
496
    
497
    for(i=0;i<ctx->nb_streams;i++) {
498
        stream = ctx->streams[i]->priv_data;
499
        stream->packet_number = 0;
500
    }
501
    s->system_header_size = get_system_header_size(ctx);
502
    s->last_scr = 0;
503
    return 0;
504
 fail:
505
    for(i=0;i<ctx->nb_streams;i++) {
506
        av_free(ctx->streams[i]->priv_data);
507
    }
508
    return -ENOMEM;
509
}
510

    
511
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
512
{
513
    put_byte(pb, 
514
             (id << 4) | 
515
             (((timestamp >> 30) & 0x07) << 1) | 
516
             1);
517
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
518
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
519
}
520

    
521

    
522
/* return the number of padding bytes that should be inserted into
523
   the multiplexed stream.*/
524
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
525
{
526
    MpegMuxContext *s = ctx->priv_data;
527
    int pad_bytes = 0;
528

    
529
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
530
    {
531
        int64_t full_pad_bytes;
532
        
533
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
534
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
535

    
536
        if (pad_bytes<0)
537
            /* might happen if we have already padded to a later timestamp. This
538
               can occur if another stream has already advanced further.*/
539
            pad_bytes=0;
540
    }
541

    
542
    return pad_bytes;
543
}
544

    
545

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

557
    stream = ctx->streams[stream_index]->priv_data;
558

559
    buf_index = 0;
560
    if (((s->packet_number % s->pack_header_freq) == 0)) {
561
        /* pack header size */
562
        if (s->is_mpeg2) 
563
            buf_index += 14;
564
        else
565
            buf_index += 12;
566
        
567
        if (s->is_vcd) {
568
            /* there is exactly one system header for each stream in a VCD MPEG,
569
               One in the very first video packet and one in the very first
570
               audio packet (see VCD standard p. IV-7 and IV-8).*/
571
            
572
            if (stream->packet_number==0)
573
                /* The system headers refer only to the stream they occur in,
574
                   so they have a constant size.*/
575
                buf_index += 15;
576

577
        } else {            
578
            if ((s->packet_number % s->system_header_freq) == 0)
579
                buf_index += s->system_header_size;
580
        }
581
    }
582

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

604
        } else {
605
            if (!s->is_mpeg2)
606
                buf_index++;
607
        }
608
    
609
        if (stream->id < 0xc0) {
610
            /* AC3/LPCM private data header */
611
            buf_index += 4;
612
            if (stream->id >= 0xa0) {
613
                int n;
614
                buf_index += 3;
615
                /* NOTE: we round the payload size to an integer number of
616
                   LPCM samples */
617
                n = (s->packet_size - buf_index) % stream->lpcm_align;
618
                if (n)
619
                    buf_index += (stream->lpcm_align - n);
620
            }
621
        }
622

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

    
632
/* Write an MPEG padding packet header. */
633
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
634
{
635
    MpegMuxContext *s = ctx->priv_data;
636
    int i;
637
    
638
    put_be32(pb, PADDING_STREAM);
639
    put_be16(pb, packet_bytes - 6);
640
    if (!s->is_mpeg2) {
641
        put_byte(pb, 0x0f);
642
        packet_bytes -= 7;
643
    } else
644
        packet_bytes -= 6;
645

    
646
    for(i=0;i<packet_bytes;i++)
647
        put_byte(pb, 0xff);
648
}
649

    
650
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
651
    int nb_frames=0;
652
    PacketDesc *pkt_desc= stream->premux_packet;
653

    
654
    while(len>0){ 
655
        if(pkt_desc->size == pkt_desc->unwritten_size)
656
            nb_frames++;
657
        len -= pkt_desc->unwritten_size;
658
        pkt_desc= pkt_desc->next;
659
    }
660

    
661
    return nb_frames;
662
}
663

    
664
/* flush the packet on stream stream_index */
665
static int flush_packet(AVFormatContext *ctx, int stream_index, 
666
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
667
{
668
    MpegMuxContext *s = ctx->priv_data;
669
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
670
    uint8_t *buf_ptr;
671
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
672
    int packet_size;
673
    uint8_t buffer[128];
674
    int zero_trail_bytes = 0;
675
    int pad_packet_bytes = 0;
676
    int pes_flags;
677
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
678
    int nb_frames;
679
    
680
    id = stream->id;
681
    
682
#if 0
683
    printf("packet ID=%2x PTS=%0.3f\n", 
684
           id, pts / 90000.0);
685
#endif
686

    
687
    buf_ptr = buffer;
688

    
689
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
690
        /* output pack and systems header if needed */
691
        size = put_pack_header(ctx, buf_ptr, scr);
692
        buf_ptr += size;
693
        s->last_scr= scr;
694

    
695
        if (s->is_vcd) {
696
            /* there is exactly one system header for each stream in a VCD MPEG,
697
               One in the very first video packet and one in the very first
698
               audio packet (see VCD standard p. IV-7 and IV-8).*/
699
            
700
            if (stream->packet_number==0) {
701
                size = put_system_header(ctx, buf_ptr, id);
702
                buf_ptr += size;
703
            }
704
        } else if (s->is_dvd) {
705
            if (stream->align_iframe || s->packet_number == 0){
706
                int bytes_to_iframe;
707
                int PES_bytes_to_fill;
708
                if (stream->fifo_iframe_ptr >= stream->fifo.rptr) {
709
                    bytes_to_iframe = stream->fifo_iframe_ptr - stream->fifo.rptr;
710
                } else {
711
                    bytes_to_iframe = (stream->fifo.end - stream->fifo.rptr) + (stream->fifo_iframe_ptr - stream->fifo.buffer);
712
                }
713
                PES_bytes_to_fill = s->packet_size - size - 10;
714

    
715
                if (pts != AV_NOPTS_VALUE) {
716
                    if (dts != pts)
717
                        PES_bytes_to_fill -= 5 + 5;
718
                    else
719
                        PES_bytes_to_fill -= 5;
720
                }
721

    
722
                if (bytes_to_iframe == 0 || s->packet_number == 0) {
723
                    size = put_system_header(ctx, buf_ptr, 0);
724
                    buf_ptr += size;
725
                    size = buf_ptr - buffer;
726
                    put_buffer(&ctx->pb, buffer, size);
727

    
728
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
729
                    put_be16(&ctx->pb, 0x03d4);         // length
730
                    put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
731
                    for (i = 0; i < 979; i++)
732
                        put_byte(&ctx->pb, 0x00);
733

    
734
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
735
                    put_be16(&ctx->pb, 0x03fa);         // length
736
                    put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
737
                    for (i = 0; i < 1017; i++)
738
                        put_byte(&ctx->pb, 0x00);
739

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

    
763
    packet_size = s->packet_size - size;
764

    
765
    if (s->is_vcd && id == AUDIO_ID)
766
        /* The VCD standard demands that 20 zero bytes follow
767
           each audio pack (see standard p. IV-8).*/
768
        zero_trail_bytes += 20;
769
            
770
    if ((s->is_vcd && stream->packet_number==0)
771
        || (s->is_svcd && s->packet_number==0)) {
772
        /* for VCD the first pack of each stream contains only the pack header,
773
           the system header and lots of padding (see VCD standard p. IV-6).
774
           In the case of an audio pack, 20 zero bytes are also added at
775
           the end.*/
776
        /* For SVCD we fill the very first pack to increase compatibility with
777
           some DVD players. Not mandated by the standard.*/
778
        if (s->is_svcd)
779
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
780
        pad_packet_bytes = packet_size - zero_trail_bytes;
781
    }
782

    
783
    packet_size -= pad_packet_bytes + zero_trail_bytes;
784

    
785
    if (packet_size > 0) {
786

    
787
        /* packet header size */
788
        packet_size -= 6;
789
        
790
        /* packet header */
791
        if (s->is_mpeg2) {
792
            header_len = 3;
793
            if (stream->packet_number==0)
794
                header_len += 3; /* PES extension */
795
            header_len += 1; /* obligatory stuffing byte */
796
        } else {
797
            header_len = 0;
798
        }
799
        if (pts != AV_NOPTS_VALUE) {
800
            if (dts != pts)
801
                header_len += 5 + 5;
802
            else
803
                header_len += 5;
804
        } else {
805
            if (!s->is_mpeg2)
806
                header_len++;
807
        }
808

    
809
        payload_size = packet_size - header_len;
810
        if (id < 0xc0) {
811
            startcode = PRIVATE_STREAM_1;
812
            payload_size -= 4;
813
            if (id >= 0xa0)
814
                payload_size -= 3;
815
        } else {
816
            startcode = 0x100 + id;
817
        }
818

    
819
        stuffing_size = payload_size - fifo_size(&stream->fifo, stream->fifo.rptr);
820

    
821
        // first byte doesnt fit -> reset pts/dts + stuffing
822
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
823
            int timestamp_len=0;
824
            if(dts != pts) 
825
                timestamp_len += 5;
826
            if(pts != AV_NOPTS_VALUE)
827
                timestamp_len += s->is_mpeg2 ? 5 : 4;
828
            pts=dts= AV_NOPTS_VALUE;
829
            header_len -= timestamp_len;
830
            if (s->is_dvd && stream->align_iframe) {
831
                pad_packet_bytes += timestamp_len;
832
                packet_size -= timestamp_len;
833
            } else {
834
                payload_size += timestamp_len;
835
            }
836
            stuffing_size += timestamp_len;
837
            if(payload_size > trailer_size)
838
                stuffing_size += payload_size - trailer_size;
839
        }
840

    
841
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
842
            packet_size += pad_packet_bytes;
843
            payload_size += pad_packet_bytes; // undo the previous adjustment
844
            if (stuffing_size < 0) {
845
                stuffing_size = pad_packet_bytes;
846
            } else {
847
                stuffing_size += pad_packet_bytes;
848
            }
849
            pad_packet_bytes = 0;
850
        }
851

    
852
        if (stuffing_size < 0)
853
            stuffing_size = 0;
854
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
855
            pad_packet_bytes += stuffing_size;
856
            packet_size -= stuffing_size;
857
            payload_size -= stuffing_size;
858
            stuffing_size = 0;
859
        }
860
        
861
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
862

    
863
        put_be32(&ctx->pb, startcode);
864

    
865
        put_be16(&ctx->pb, packet_size);
866
        
867
        if (!s->is_mpeg2)
868
            for(i=0;i<stuffing_size;i++)
869
                put_byte(&ctx->pb, 0xff);
870

    
871
        if (s->is_mpeg2) {
872
            put_byte(&ctx->pb, 0x80); /* mpeg2 id */
873

    
874
            pes_flags=0;
875

    
876
            if (pts != AV_NOPTS_VALUE) {
877
                pes_flags |= 0x80;
878
                if (dts != pts)
879
                    pes_flags |= 0x40;
880
            }
881

    
882
            /* Both the MPEG-2 and the SVCD standards demand that the
883
               P-STD_buffer_size field be included in the first packet of
884
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
885
               and MPEG-2 standard 2.7.7) */
886
            if (stream->packet_number == 0)
887
                pes_flags |= 0x01;
888

    
889
            put_byte(&ctx->pb, pes_flags); /* flags */
890
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
891

    
892
            if (pes_flags & 0x80)  /*write pts*/
893
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
894
            if (pes_flags & 0x40)  /*write dts*/
895
                put_timestamp(&ctx->pb, 0x01, dts);
896
            
897
            if (pes_flags & 0x01) {  /*write pes extension*/
898
                put_byte(&ctx->pb, 0x10); /* flags */
899

    
900
                /* P-STD buffer info */                
901
                if (id == AUDIO_ID)
902
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
903
                else
904
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
905
            }
906

    
907
        } else {
908
            if (pts != AV_NOPTS_VALUE) {
909
                if (dts != pts) {
910
                    put_timestamp(&ctx->pb, 0x03, pts);
911
                    put_timestamp(&ctx->pb, 0x01, dts);
912
                } else {
913
                    put_timestamp(&ctx->pb, 0x02, pts);
914
                }
915
            } else {
916
                put_byte(&ctx->pb, 0x0f);
917
            }
918
        }
919

    
920
        if (s->is_mpeg2) {
921
            /* special stuffing byte that is always written
922
               to prevent accidental generation of start codes. */
923
            put_byte(&ctx->pb, 0xff);
924

    
925
            for(i=0;i<stuffing_size;i++)
926
                put_byte(&ctx->pb, 0xff);
927
        }
928

    
929
        if (startcode == PRIVATE_STREAM_1) {
930
            put_byte(&ctx->pb, id);
931
            if (id >= 0xa0) {
932
                /* LPCM (XXX: check nb_frames) */
933
                put_byte(&ctx->pb, 7);
934
                put_be16(&ctx->pb, 4); /* skip 3 header bytes */
935
                put_byte(&ctx->pb, stream->lpcm_header[0]);
936
                put_byte(&ctx->pb, stream->lpcm_header[1]);
937
                put_byte(&ctx->pb, stream->lpcm_header[2]);
938
            } else {
939
                /* AC3 */
940
                put_byte(&ctx->pb, nb_frames);
941
                put_be16(&ctx->pb, trailer_size+1);
942
            }
943
        }
944

    
945
        /* output data */
946
        if(put_fifo(&ctx->pb, &stream->fifo, payload_size - stuffing_size, &stream->fifo.rptr) < 0)
947
            return -1;
948
    }else{
949
        payload_size=
950
        stuffing_size= 0;
951
    }
952

    
953
    if (pad_packet_bytes > 0)
954
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);    
955

    
956
    for(i=0;i<zero_trail_bytes;i++)
957
        put_byte(&ctx->pb, 0x00);
958
        
959
    put_flush_packet(&ctx->pb);
960
    
961
    s->packet_number++;
962

    
963
    /* only increase the stream packet number if this pack actually contains
964
       something that is specific to this stream! I.e. a dedicated header
965
       or some data.*/
966
    if (!general_pack)
967
        stream->packet_number++;
968
    
969
    return payload_size - stuffing_size;
970
}
971

    
972
static void put_vcd_padding_sector(AVFormatContext *ctx)
973
{
974
    /* There are two ways to do this padding: writing a sector/pack
975
       of 0 values, or writing an MPEG padding pack. Both seem to
976
       work with most decoders, BUT the VCD standard only allows a 0-sector
977
       (see standard p. IV-4, IV-5).
978
       So a 0-sector it is...*/
979

    
980
    MpegMuxContext *s = ctx->priv_data;
981
    int i;
982

    
983
    for(i=0;i<s->packet_size;i++)
984
        put_byte(&ctx->pb, 0);
985

    
986
    s->vcd_padding_bytes_written += s->packet_size;
987
        
988
    put_flush_packet(&ctx->pb);
989
    
990
    /* increasing the packet number is correct. The SCR of the following packs
991
       is calculated from the packet_number and it has to include the padding
992
       sector (it represents the sector index, not the MPEG pack index)
993
       (see VCD standard p. IV-6)*/
994
    s->packet_number++;
995
}
996

    
997
#if 0 /* unused, remove? */
998
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
999
{
1000
    MpegMuxContext *s = ctx->priv_data;
1001
    int64_t scr;
1002

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

1015
    return scr;
1016
}    
1017
#endif
1018

    
1019
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1020
//    MpegMuxContext *s = ctx->priv_data;
1021
    int i;
1022

    
1023
    for(i=0; i<ctx->nb_streams; i++){
1024
        AVStream *st = ctx->streams[i];
1025
        StreamInfo *stream = st->priv_data;
1026
        PacketDesc *pkt_desc= stream->predecode_packet;
1027
        
1028
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1029
            if(stream->buffer_index < pkt_desc->size || 
1030
               stream->predecode_packet == stream->premux_packet){
1031
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1032
                break;
1033
            }
1034
            stream->buffer_index -= pkt_desc->size;
1035

    
1036
            stream->predecode_packet= pkt_desc->next;
1037
            av_freep(&pkt_desc);
1038
        }
1039
    }
1040
    
1041
    return 0;
1042
}
1043

    
1044
static int output_packet(AVFormatContext *ctx, int flush){
1045
    MpegMuxContext *s = ctx->priv_data;
1046
    AVStream *st;
1047
    StreamInfo *stream;
1048
    int i, avail_space, es_size, trailer_size;
1049
    int best_i= -1;
1050
    int best_score= INT_MIN;
1051
    int ignore_constraints=0;
1052
    int64_t scr= s->last_scr;
1053
    PacketDesc *timestamp_packet;
1054
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1055

    
1056
retry:
1057
    for(i=0; i<ctx->nb_streams; i++){
1058
        AVStream *st = ctx->streams[i];
1059
        StreamInfo *stream = st->priv_data;
1060
        const int avail_data=  fifo_size(&stream->fifo, stream->fifo.rptr);
1061
        const int space= stream->max_buffer_size - stream->buffer_index;
1062
        int rel_space= 1024*space / stream->max_buffer_size;
1063
        PacketDesc *next_pkt= stream->premux_packet;
1064

    
1065
        if(s->packet_size > avail_data && !flush)
1066
            return 0;
1067
        if(avail_data==0)
1068
            continue;
1069
        assert(avail_data>0);
1070

    
1071
        if(space < s->packet_size && !ignore_constraints)
1072
            continue;
1073
            
1074
        if(next_pkt && next_pkt->dts - scr > max_delay)
1075
            continue;
1076
            
1077
        if(rel_space > best_score){
1078
            best_score= rel_space;
1079
            best_i = i;
1080
            avail_space= space;
1081
        }
1082
    }
1083
    
1084
    if(best_i < 0){
1085
        int64_t best_dts= INT64_MAX;
1086

    
1087
        for(i=0; i<ctx->nb_streams; i++){
1088
            AVStream *st = ctx->streams[i];
1089
            StreamInfo *stream = st->priv_data;
1090
            PacketDesc *pkt_desc= stream->predecode_packet;
1091
            if(pkt_desc && pkt_desc->dts < best_dts)
1092
                best_dts= pkt_desc->dts;
1093
        }
1094

    
1095
#if 0
1096
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n", 
1097
               scr/90000.0, best_dts/90000.0);
1098
#endif
1099
        if(best_dts == INT64_MAX)
1100
            return 0;
1101

    
1102
        if(scr >= best_dts+1 && !ignore_constraints){
1103
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1104
            ignore_constraints= 1;
1105
        }
1106
        scr= FFMAX(best_dts+1, scr);
1107
        if(remove_decoded_packets(ctx, scr) < 0)
1108
            return -1;
1109
        goto retry;
1110
    }
1111

    
1112
    assert(best_i >= 0);
1113
    
1114
    st = ctx->streams[best_i];
1115
    stream = st->priv_data;
1116
    
1117
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
1118

    
1119
    assert(avail_space >= s->packet_size || ignore_constraints);
1120
    
1121
    timestamp_packet= stream->premux_packet;
1122
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1123
        trailer_size= 0;
1124
    }else{
1125
        trailer_size= timestamp_packet->unwritten_size;
1126
        timestamp_packet= timestamp_packet->next;
1127
    }
1128

    
1129
    if(timestamp_packet){
1130
//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);
1131
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1132
    }else{
1133
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == trailer_size);
1134
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1135
    }
1136

    
1137
    if (s->is_vcd) {
1138
        /* Write one or more padding sectors, if necessary, to reach
1139
           the constant overall bitrate.*/
1140
        int vcd_pad_bytes;
1141

    
1142
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1143
            put_vcd_padding_sector(ctx);
1144
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1145
        }
1146
    }
1147
    
1148
    stream->buffer_index += es_size;
1149
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1150
    
1151
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1152
        es_size -= stream->premux_packet->unwritten_size;
1153
        stream->premux_packet= stream->premux_packet->next;
1154
    }
1155
    if(es_size)
1156
        stream->premux_packet->unwritten_size -= es_size;
1157
    
1158
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1159
        return -1;
1160

    
1161
    return 1;
1162
}
1163

    
1164
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1165
{
1166
    MpegMuxContext *s = ctx->priv_data;
1167
    int stream_index= pkt->stream_index;
1168
    int size= pkt->size;
1169
    uint8_t *buf= pkt->data;
1170
    AVStream *st = ctx->streams[stream_index];
1171
    StreamInfo *stream = st->priv_data;
1172
    int64_t pts, dts;
1173
    PacketDesc *pkt_desc;
1174
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1175
    const int is_iframe = st->codec.codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1176
    
1177
    pts= pkt->pts;
1178
    dts= pkt->dts;
1179

    
1180
    if(pts != AV_NOPTS_VALUE) pts += preload;
1181
    if(dts != AV_NOPTS_VALUE) dts += preload;
1182

    
1183
//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);
1184
    *stream->next_packet=
1185
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1186
    pkt_desc->pts= pts;
1187
    pkt_desc->dts= dts;
1188
    pkt_desc->unwritten_size=
1189
    pkt_desc->size= size;
1190
    if(!stream->predecode_packet)
1191
        stream->predecode_packet= pkt_desc;
1192
    stream->next_packet= &pkt_desc->next;
1193

    
1194
    fifo_realloc(&stream->fifo, fifo_size(&stream->fifo, NULL) + size + 1);
1195

    
1196
    if (s->is_dvd){
1197
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1198
            stream->fifo_iframe_ptr = stream->fifo.wptr;
1199
            stream->align_iframe = 1;
1200
            stream->vobu_start_pts = pts;
1201
        } else {
1202
            stream->align_iframe = 0;
1203
        }
1204
    }
1205

    
1206
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1207

    
1208
    for(;;){
1209
        int ret= output_packet(ctx, 0);
1210
        if(ret<=0) 
1211
            return ret;
1212
    }
1213
}
1214

    
1215
static int mpeg_mux_end(AVFormatContext *ctx)
1216
{
1217
//    MpegMuxContext *s = ctx->priv_data;
1218
    StreamInfo *stream;
1219
    int i;
1220
    
1221
    for(;;){
1222
        int ret= output_packet(ctx, 1);
1223
        if(ret<0) 
1224
            return ret;
1225
        else if(ret==0)
1226
            break;
1227
    }
1228

    
1229
    /* End header according to MPEG1 systems standard. We do not write
1230
       it as it is usually not needed by decoders and because it
1231
       complicates MPEG stream concatenation. */
1232
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1233
    //put_flush_packet(&ctx->pb);
1234

    
1235
    for(i=0;i<ctx->nb_streams;i++) {
1236
        stream = ctx->streams[i]->priv_data;
1237

    
1238
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1239
        fifo_free(&stream->fifo);
1240
    }
1241
    return 0;
1242
}
1243
#endif //CONFIG_ENCODERS
1244

    
1245
/*********************************************/
1246
/* demux code */
1247

    
1248
#define MAX_SYNC_SIZE 100000
1249

    
1250
static int mpegps_probe(AVProbeData *p)
1251
{
1252
    int i;
1253
    int size= FFMIN(20, p->buf_size);
1254
    uint32_t code=0xFF;
1255

    
1256
    /* we search the first start code. If it is a packet start code,
1257
       then we decide it is mpeg ps. We do not send highest value to
1258
       give a chance to mpegts */
1259
    /* NOTE: the search range was restricted to avoid too many false
1260
       detections */
1261

    
1262
    for (i = 0; i < size; i++) {
1263
        code = (code << 8) | p->buf[i];
1264
        if ((code & 0xffffff00) == 0x100) {
1265
            if (code == PACK_START_CODE ||
1266
                code == SYSTEM_HEADER_START_CODE ||
1267
                (code >= 0x1e0 && code <= 0x1ef) ||
1268
                (code >= 0x1c0 && code <= 0x1df) ||
1269
                code == PRIVATE_STREAM_2 ||
1270
                code == PROGRAM_STREAM_MAP ||
1271
                code == PRIVATE_STREAM_1 ||
1272
                code == PADDING_STREAM)
1273
                return AVPROBE_SCORE_MAX - 2;
1274
            else
1275
                return 0;
1276
        }
1277
    }
1278
    return 0;
1279
}
1280

    
1281

    
1282
typedef struct MpegDemuxContext {
1283
    int header_state;
1284
    unsigned char psm_es_type[256];
1285
} MpegDemuxContext;
1286

    
1287
static int mpegps_read_header(AVFormatContext *s,
1288
                              AVFormatParameters *ap)
1289
{
1290
    MpegDemuxContext *m = s->priv_data;
1291
    m->header_state = 0xff;
1292
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1293

    
1294
    /* no need to do more */
1295
    return 0;
1296
}
1297

    
1298
static int64_t get_pts(ByteIOContext *pb, int c)
1299
{
1300
    int64_t pts;
1301
    int val;
1302

    
1303
    if (c < 0)
1304
        c = get_byte(pb);
1305
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1306
    val = get_be16(pb);
1307
    pts |= (int64_t)(val >> 1) << 15;
1308
    val = get_be16(pb);
1309
    pts |= (int64_t)(val >> 1);
1310
    return pts;
1311
}
1312

    
1313
static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1314
                                uint32_t *header_state)
1315
{
1316
    unsigned int state, v;
1317
    int val, n;
1318

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

    
1340
#if 0 /* unused, remove? */
1341
/* XXX: optimize */
1342
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1343
{
1344
    int64_t pos, pos_start;
1345
    int max_size, start_code;
1346

1347
    max_size = *size_ptr;
1348
    pos_start = url_ftell(pb);
1349

1350
    /* in order to go faster, we fill the buffer */
1351
    pos = pos_start - 16386;
1352
    if (pos < 0)
1353
        pos = 0;
1354
    url_fseek(pb, pos, SEEK_SET);
1355
    get_byte(pb);
1356

1357
    pos = pos_start;
1358
    for(;;) {
1359
        pos--;
1360
        if (pos < 0 || (pos_start - pos) >= max_size) {
1361
            start_code = -1;
1362
            goto the_end;
1363
        }
1364
        url_fseek(pb, pos, SEEK_SET);
1365
        start_code = get_be32(pb);
1366
        if ((start_code & 0xffffff00) == 0x100)
1367
            break;
1368
    }
1369
 the_end:
1370
    *size_ptr = pos_start - pos;
1371
    return start_code;
1372
}
1373
#endif
1374

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

    
1385
    psm_length = get_be16(pb);
1386
    get_byte(pb);
1387
    get_byte(pb);
1388
    ps_info_length = get_be16(pb);
1389

    
1390
    /* skip program_stream_info */
1391
    url_fskip(pb, ps_info_length);
1392
    es_map_length = get_be16(pb);
1393

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

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

    
1420
    last_pos = -1;
1421
 redo:
1422
        /* next start code (should be immediately after) */
1423
        m->header_state = 0xff;
1424
        size = MAX_SYNC_SIZE;
1425
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1426
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1427
    if (startcode < 0)
1428
        return AVERROR_IO;
1429
    if (startcode == PACK_START_CODE)
1430
        goto redo;
1431
    if (startcode == SYSTEM_HEADER_START_CODE)
1432
        goto redo;
1433
    if (startcode == PADDING_STREAM ||
1434
        startcode == PRIVATE_STREAM_2) {
1435
        /* skip them */
1436
        len = get_be16(&s->pb);
1437
        url_fskip(&s->pb, len);
1438
        goto redo;
1439
    }
1440
    if (startcode == PROGRAM_STREAM_MAP) {
1441
        mpegps_psm_parse(m, &s->pb);
1442
        goto redo;
1443
    }
1444
    
1445
    /* find matching stream */
1446
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1447
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1448
          (startcode == 0x1bd)))
1449
        goto redo;
1450
    if (ppos) {
1451
        *ppos = url_ftell(&s->pb) - 4;
1452
    }
1453
    len = get_be16(&s->pb);
1454
    pts = AV_NOPTS_VALUE;
1455
    dts = AV_NOPTS_VALUE;
1456
    /* stuffing */
1457
    for(;;) {
1458
        if (len < 1)
1459
            goto redo;
1460
        c = get_byte(&s->pb);
1461
        len--;
1462
        /* XXX: for mpeg1, should test only bit 7 */
1463
        if (c != 0xff) 
1464
            break;
1465
    }
1466
    if ((c & 0xc0) == 0x40) {
1467
        /* buffer scale & size */
1468
        if (len < 2)
1469
            goto redo;
1470
        get_byte(&s->pb);
1471
        c = get_byte(&s->pb);
1472
        len -= 2;
1473
    }
1474
    if ((c & 0xf0) == 0x20) {
1475
        if (len < 4)
1476
            goto redo;
1477
        dts = pts = get_pts(&s->pb, c);
1478
        len -= 4;
1479
    } else if ((c & 0xf0) == 0x30) {
1480
        if (len < 9)
1481
            goto redo;
1482
        pts = get_pts(&s->pb, c);
1483
        dts = get_pts(&s->pb, -1);
1484
        len -= 9;
1485
    } else if ((c & 0xc0) == 0x80) {
1486
        /* mpeg 2 PES */
1487
        if ((c & 0x30) != 0) {
1488
            /* Encrypted multiplex not handled */
1489
            goto redo;
1490
        }
1491
        flags = get_byte(&s->pb);
1492
        header_len = get_byte(&s->pb);
1493
        len -= 2;
1494
        if (header_len > len)
1495
            goto redo;
1496
        if ((flags & 0xc0) == 0x80) {
1497
            dts = pts = get_pts(&s->pb, -1);
1498
            if (header_len < 5)
1499
                goto redo;
1500
            header_len -= 5;
1501
            len -= 5;
1502
        } if ((flags & 0xc0) == 0xc0) {
1503
            pts = get_pts(&s->pb, -1);
1504
            dts = get_pts(&s->pb, -1);
1505
            if (header_len < 10)
1506
                goto redo;
1507
            header_len -= 10;
1508
            len -= 10;
1509
        }
1510
        len -= header_len;
1511
        while (header_len > 0) {
1512
            get_byte(&s->pb);
1513
            header_len--;
1514
        }
1515
    }
1516
    else if( c!= 0xf )
1517
        goto redo;
1518

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

    
1549
static int mpegps_read_packet(AVFormatContext *s,
1550
                              AVPacket *pkt)
1551
{
1552
    MpegDemuxContext *m = s->priv_data;
1553
    AVStream *st;
1554
    int len, startcode, i, type, codec_id = 0, es_type;
1555
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1556

    
1557
 redo:
1558
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1559
    if (len < 0)
1560
        return len;
1561
    
1562
    /* now find stream */
1563
    for(i=0;i<s->nb_streams;i++) {
1564
        st = s->streams[i];
1565
        if (st->id == startcode)
1566
            goto found;
1567
    }
1568

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

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

    
1654
    return 0;
1655
}
1656

    
1657
static int mpegps_read_close(AVFormatContext *s)
1658
{
1659
    return 0;
1660
}
1661

    
1662
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1663
                               int64_t *ppos, int64_t pos_limit)
1664
{
1665
    int len, startcode;
1666
    int64_t pos, pts, dts;
1667

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

    
1694
#ifdef CONFIG_ENCODERS
1695
static AVOutputFormat mpeg1system_mux = {
1696
    "mpeg",
1697
    "MPEG1 System format",
1698
    "video/mpeg",
1699
    "mpg,mpeg",
1700
    sizeof(MpegMuxContext),
1701
    CODEC_ID_MP2,
1702
    CODEC_ID_MPEG1VIDEO,
1703
    mpeg_mux_init,
1704
    mpeg_mux_write_packet,
1705
    mpeg_mux_end,
1706
};
1707

    
1708
static AVOutputFormat mpeg1vcd_mux = {
1709
    "vcd",
1710
    "MPEG1 System format (VCD)",
1711
    "video/mpeg",
1712
    NULL,
1713
    sizeof(MpegMuxContext),
1714
    CODEC_ID_MP2,
1715
    CODEC_ID_MPEG1VIDEO,
1716
    mpeg_mux_init,
1717
    mpeg_mux_write_packet,
1718
    mpeg_mux_end,
1719
};
1720

    
1721
static AVOutputFormat mpeg2vob_mux = {
1722
    "vob",
1723
    "MPEG2 PS format (VOB)",
1724
    "video/mpeg",
1725
    "vob",
1726
    sizeof(MpegMuxContext),
1727
    CODEC_ID_MP2,
1728
    CODEC_ID_MPEG2VIDEO,
1729
    mpeg_mux_init,
1730
    mpeg_mux_write_packet,
1731
    mpeg_mux_end,
1732
};
1733

    
1734
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1735
static AVOutputFormat mpeg2svcd_mux = {
1736
    "svcd",
1737
    "MPEG2 PS format (VOB)",
1738
    "video/mpeg",
1739
    "vob",
1740
    sizeof(MpegMuxContext),
1741
    CODEC_ID_MP2,
1742
    CODEC_ID_MPEG2VIDEO,
1743
    mpeg_mux_init,
1744
    mpeg_mux_write_packet,
1745
    mpeg_mux_end,
1746
};
1747

    
1748
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1749
static AVOutputFormat mpeg2dvd_mux = {
1750
    "dvd",
1751
    "MPEG2 PS format (DVD VOB)",
1752
    "video/mpeg",
1753
    "dvd",
1754
    sizeof(MpegMuxContext),
1755
    CODEC_ID_MP2,
1756
    CODEC_ID_MPEG2VIDEO,
1757
    mpeg_mux_init,
1758
    mpeg_mux_write_packet,
1759
    mpeg_mux_end,
1760
};
1761

    
1762
#endif //CONFIG_ENCODERS
1763

    
1764
AVInputFormat mpegps_demux = {
1765
    "mpeg",
1766
    "MPEG PS format",
1767
    sizeof(MpegDemuxContext),
1768
    mpegps_probe,
1769
    mpegps_read_header,
1770
    mpegps_read_packet,
1771
    mpegps_read_close,
1772
    NULL, //mpegps_read_seek,
1773
    mpegps_read_dts,
1774
};
1775

    
1776
int mpegps_init(void)
1777
{
1778
#ifdef CONFIG_ENCODERS
1779
    av_register_output_format(&mpeg1system_mux);
1780
    av_register_output_format(&mpeg1vcd_mux);
1781
    av_register_output_format(&mpeg2vob_mux);
1782
    av_register_output_format(&mpeg2svcd_mux);
1783
    av_register_output_format(&mpeg2dvd_mux);
1784
#endif //CONFIG_ENCODERS
1785
    av_register_input_format(&mpegps_demux);
1786
    return 0;
1787
}