Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 20b02bc6

History | View | Annotate | Download (52.4 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

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

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

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

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

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

    
67
    double vcd_padding_bitrate; //FIXME floats
68
    int64_t vcd_padding_bytes_written;
69

    
70
} MpegMuxContext;
71

    
72
#define PACK_START_CODE             ((unsigned int)0x000001ba)
73
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
74
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
75
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
76
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
77
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
78
  
79
/* mpeg2 */
80
#define PROGRAM_STREAM_MAP 0x1bc
81
#define PRIVATE_STREAM_1   0x1bd
82
#define PADDING_STREAM     0x1be
83
#define PRIVATE_STREAM_2   0x1bf
84

    
85

    
86
#define AUDIO_ID 0xc0
87
#define VIDEO_ID 0xe0
88
#define AC3_ID   0x80
89
#define DTS_ID   0x8a
90
#define LPCM_ID  0xa0
91

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

    
94
#ifdef CONFIG_ENCODERS
95
static AVOutputFormat mpeg1system_mux;
96
static AVOutputFormat mpeg1vcd_mux;
97
static AVOutputFormat mpeg2vob_mux;
98
static AVOutputFormat mpeg2svcd_mux;
99
static AVOutputFormat mpeg2dvd_mux;
100

    
101
static int put_pack_header(AVFormatContext *ctx, 
102
                           uint8_t *buf, int64_t timestamp)
103
{
104
    MpegMuxContext *s = ctx->priv_data;
105
    PutBitContext pb;
106
    
107
    init_put_bits(&pb, buf, 128);
108

    
109
    put_bits(&pb, 32, PACK_START_CODE);
110
    if (s->is_mpeg2) {
111
        put_bits(&pb, 2, 0x1);
112
    } else {
113
        put_bits(&pb, 4, 0x2);
114
    }
115
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
116
    put_bits(&pb, 1, 1);
117
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
118
    put_bits(&pb, 1, 1);
119
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
120
    put_bits(&pb, 1, 1);
121
    if (s->is_mpeg2) {
122
        /* clock extension */
123
        put_bits(&pb, 9, 0);
124
    }
125
    put_bits(&pb, 1, 1);
126
    put_bits(&pb, 22, s->mux_rate);
127
    put_bits(&pb, 1, 1);
128
    if (s->is_mpeg2) {
129
        put_bits(&pb, 1, 1);
130
        put_bits(&pb, 5, 0x1f); /* reserved */
131
        put_bits(&pb, 3, 0); /* stuffing length */
132
    }
133
    flush_put_bits(&pb);
134
    return pbBufPtr(&pb) - pb.buf;
135
}
136

    
137
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
138
{
139
    MpegMuxContext *s = ctx->priv_data;
140
    int size, i, private_stream_coded, id;
141
    PutBitContext pb;
142

    
143
    init_put_bits(&pb, buf, 128);
144

    
145
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
146
    put_bits(&pb, 16, 0);
147
    put_bits(&pb, 1, 1);
148
    
149
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
150
    put_bits(&pb, 1, 1); /* marker */
151
    if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
152
        /* This header applies only to the video stream (see VCD standard p. IV-7)*/
153
        put_bits(&pb, 6, 0);
154
    } else
155
        put_bits(&pb, 6, s->audio_bound);
156

    
157
    if (s->is_vcd) {
158
        /* see VCD standard, p. IV-7*/
159
        put_bits(&pb, 1, 0); 
160
        put_bits(&pb, 1, 1);
161
    } else {
162
        put_bits(&pb, 1, 0); /* variable bitrate*/
163
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
164
    }
165
    
166
    if (s->is_vcd || s->is_dvd) {
167
        /* see VCD standard p IV-7 */
168
        put_bits(&pb, 1, 1); /* audio locked */
169
        put_bits(&pb, 1, 1); /* video locked */
170
    } else {
171
        put_bits(&pb, 1, 0); /* audio locked */
172
        put_bits(&pb, 1, 0); /* video locked */
173
    }
174

    
175
    put_bits(&pb, 1, 1); /* marker */
176

    
177
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
178
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
179
        put_bits(&pb, 5, 0);
180
    } else
181
        put_bits(&pb, 5, s->video_bound);
182
    
183
    if (s->is_dvd) {
184
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
185
        put_bits(&pb, 7, 0x7f); /* reserved byte */
186
    } else
187
        put_bits(&pb, 8, 0xff); /* reserved byte */
188
    
189
    /* DVD-Video Stream_bound entries
190
    id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1) 
191
    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) 
192
    id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1) 
193
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
194
    if (s->is_dvd) {
195
        
196
        int P_STD_max_video = 0;
197
        int P_STD_max_mpeg_audio = 0;
198
        int P_STD_max_mpeg_PS1 = 0;
199
        
200
        for(i=0;i<ctx->nb_streams;i++) {
201
            StreamInfo *stream = ctx->streams[i]->priv_data;
202

    
203
            id = stream->id;
204
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
205
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
206
            } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
207
                P_STD_max_mpeg_audio = stream->max_buffer_size;
208
            } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
209
                P_STD_max_video = stream->max_buffer_size;
210
            }
211
        }
212

    
213
        /* video */
214
        put_bits(&pb, 8, 0xb9); /* stream ID */
215
        put_bits(&pb, 2, 3);
216
        put_bits(&pb, 1, 1);
217
        put_bits(&pb, 13, P_STD_max_video / 1024);
218

    
219
        /* audio */
220
        if (P_STD_max_mpeg_audio == 0)
221
            P_STD_max_mpeg_audio = 4096;
222
        put_bits(&pb, 8, 0xb8); /* stream ID */
223
        put_bits(&pb, 2, 3);
224
        put_bits(&pb, 1, 0);
225
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
226

    
227
        /* private stream 1 */
228
        put_bits(&pb, 8, 0xbd); /* stream ID */
229
        put_bits(&pb, 2, 3);
230
        put_bits(&pb, 1, 0);
231
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
232

    
233
        /* private stream 2 */
234
        put_bits(&pb, 8, 0xbf); /* stream ID */
235
        put_bits(&pb, 2, 3);
236
        put_bits(&pb, 1, 1);
237
        put_bits(&pb, 13, 2);
238
    }
239
    else {
240
        /* audio stream info */
241
        private_stream_coded = 0;
242
        for(i=0;i<ctx->nb_streams;i++) {
243
            StreamInfo *stream = ctx->streams[i]->priv_data;
244
            
245

    
246
            /* For VCDs, only include the stream info for the stream
247
            that the pack which contains this system belongs to.
248
            (see VCD standard p. IV-7) */
249
            if ( !s->is_vcd || stream->id==only_for_stream_id
250
                || only_for_stream_id==0) {
251

    
252
                id = stream->id;
253
                if (id < 0xc0) {
254
                    /* special case for private streams (AC3 use that) */
255
                    if (private_stream_coded)
256
                        continue;
257
                    private_stream_coded = 1;
258
                    id = 0xbd;
259
                }
260
                put_bits(&pb, 8, id); /* stream ID */
261
                put_bits(&pb, 2, 3);
262
                if (id < 0xe0) {
263
                    /* audio */
264
                    put_bits(&pb, 1, 0);
265
                    put_bits(&pb, 13, stream->max_buffer_size / 128);
266
                } else {
267
                    /* video */
268
                    put_bits(&pb, 1, 1);
269
                    put_bits(&pb, 13, stream->max_buffer_size / 1024);
270
                }
271
            }
272
        }
273
    }
274

    
275
    flush_put_bits(&pb);
276
    size = pbBufPtr(&pb) - pb.buf;
277
    /* patch packet size */
278
    buf[4] = (size - 6) >> 8;
279
    buf[5] = (size - 6) & 0xff;
280

    
281
    return size;
282
}
283

    
284
static int get_system_header_size(AVFormatContext *ctx)
285
{
286
    int buf_index, i, private_stream_coded;
287
    StreamInfo *stream;
288
    MpegMuxContext *s = ctx->priv_data;
289

    
290
    if (s->is_dvd)
291
       return 18; // DVD-Video system headers are 18 bytes fixed length.
292

    
293
    buf_index = 12;
294
    private_stream_coded = 0;
295
    for(i=0;i<ctx->nb_streams;i++) {
296
        stream = ctx->streams[i]->priv_data;
297
        if (stream->id < 0xc0) {
298
            if (private_stream_coded)
299
                continue;
300
            private_stream_coded = 1;
301
        }
302
        buf_index += 3;
303
    }
304
    return buf_index;
305
}
306

    
307
static int mpeg_mux_init(AVFormatContext *ctx)
308
{
309
    MpegMuxContext *s = ctx->priv_data;
310
    int bitrate, i, mpa_id, mpv_id, ac3_id, dts_id, lpcm_id, j;
311
    AVStream *st;
312
    StreamInfo *stream;
313
    int audio_bitrate;
314
    int video_bitrate;
315

    
316
    s->packet_number = 0;
317
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
318
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
319
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
320
    s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
321
    
322
    if(ctx->packet_size)
323
        s->packet_size = ctx->packet_size;
324
    else
325
        s->packet_size = 2048;
326
       
327
    s->vcd_padding_bytes_written = 0;
328
    s->vcd_padding_bitrate=0;
329
        
330
    s->audio_bound = 0;
331
    s->video_bound = 0;
332
    mpa_id = AUDIO_ID;
333
    ac3_id = AC3_ID;
334
    dts_id = DTS_ID;
335
    mpv_id = VIDEO_ID;
336
    lpcm_id = LPCM_ID;
337
    for(i=0;i<ctx->nb_streams;i++) {
338
        st = ctx->streams[i];
339
        stream = av_mallocz(sizeof(StreamInfo));
340
        if (!stream)
341
            goto fail;
342
        st->priv_data = stream;
343

    
344
        av_set_pts_info(st, 64, 1, 90000);
345

    
346
        switch(st->codec.codec_type) {
347
        case CODEC_TYPE_AUDIO:
348
            if (st->codec.codec_id == CODEC_ID_AC3) {
349
                stream->id = ac3_id++;
350
            } else if (st->codec.codec_id == CODEC_ID_DTS) {
351
                stream->id = dts_id++;
352
            } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
353
                stream->id = lpcm_id++;
354
                for(j = 0; j < 4; j++) {
355
                    if (lpcm_freq_tab[j] == st->codec.sample_rate)
356
                        break;
357
                }
358
                if (j == 4)
359
                    goto fail;
360
                if (st->codec.channels > 8)
361
                    return -1;
362
                stream->lpcm_header[0] = 0x0c;
363
                stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
364
                stream->lpcm_header[2] = 0x80;
365
                stream->lpcm_align = st->codec.channels * 2;
366
            } else {
367
                stream->id = mpa_id++;
368
            }
369

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

    
405
        if(st->codec.rc_max_rate || stream->id==VIDEO_ID)
406
            codec_rate= st->codec.rc_max_rate;
407
        else
408
            codec_rate= st->codec.bit_rate;
409
                
410
        if(!codec_rate)
411
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
412
            
413
        bitrate += codec_rate;
414

    
415
        if (stream->id==AUDIO_ID)
416
            audio_bitrate += codec_rate;
417
        else if (stream->id==VIDEO_ID)
418
            video_bitrate += codec_rate;
419
    }
420
    
421
    if(ctx->mux_rate){
422
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
423
    } else {
424
        /* we increase slightly the bitrate to take into account the
425
           headers. XXX: compute it exactly */
426
        bitrate += bitrate*5/100;
427
        bitrate += 10000;
428
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
429
    }
430

    
431
    if (s->is_vcd) {
432
        double overhead_rate;
433

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

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

    
450
        /* Add the header overhead to the data rate.
451
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
452
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
453
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
454
        overhead_rate *= 8;
455
        
456
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
457
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
458
    }
459
    
460
    if (s->is_vcd || s->is_mpeg2)
461
        /* every packet */
462
        s->pack_header_freq = 1;
463
    else
464
        /* every 2 seconds */
465
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
466

    
467
    /* the above seems to make pack_header_freq zero sometimes */
468
    if (s->pack_header_freq == 0)
469
       s->pack_header_freq = 1;
470
    
471
    if (s->is_mpeg2)
472
        /* every 200 packets. Need to look at the spec.  */
473
        s->system_header_freq = s->pack_header_freq * 40;
474
    else if (s->is_vcd)
475
        /* the standard mandates that there are only two system headers
476
           in the whole file: one in the first packet of each stream.
477
           (see standard p. IV-7 and IV-8) */
478
        s->system_header_freq = 0x7fffffff;
479
    else
480
        s->system_header_freq = s->pack_header_freq * 5;
481
    
482
    for(i=0;i<ctx->nb_streams;i++) {
483
        stream = ctx->streams[i]->priv_data;
484
        stream->packet_number = 0;
485
    }
486
    s->system_header_size = get_system_header_size(ctx);
487
    s->last_scr = 0;
488
    return 0;
489
 fail:
490
    for(i=0;i<ctx->nb_streams;i++) {
491
        av_free(ctx->streams[i]->priv_data);
492
    }
493
    return -ENOMEM;
494
}
495

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

    
506

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

    
514
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
515
    {
516
        int64_t full_pad_bytes;
517
        
518
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
519
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
520

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

    
527
    return pad_bytes;
528
}
529

    
530

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

    
541
    stream = ctx->streams[stream_index]->priv_data;
542

    
543
    buf_index = 0;
544
    if (((s->packet_number % s->pack_header_freq) == 0)) {
545
        /* pack header size */
546
        if (s->is_mpeg2) 
547
            buf_index += 14;
548
        else
549
            buf_index += 12;
550
        
551
        if (s->is_vcd) {
552
            /* there is exactly one system header for each stream in a VCD MPEG,
553
               One in the very first video packet and one in the very first
554
               audio packet (see VCD standard p. IV-7 and IV-8).*/
555
            
556
            if (stream->packet_number==0)
557
                /* The system headers refer only to the stream they occur in,
558
                   so they have a constant size.*/
559
                buf_index += 15;
560

    
561
        } else {            
562
            if ((s->packet_number % s->system_header_freq) == 0)
563
                buf_index += s->system_header_size;
564
        }
565
    }
566

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

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

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

    
615
/* Write an MPEG padding packet header. */
616
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
617
{
618
    MpegMuxContext *s = ctx->priv_data;
619
    int i;
620
    
621
    put_be32(pb, PADDING_STREAM);
622
    put_be16(pb, packet_bytes - 6);
623
    if (!s->is_mpeg2) {
624
        put_byte(pb, 0x0f);
625
        packet_bytes -= 7;
626
    } else
627
        packet_bytes -= 6;
628

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

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

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

    
644
    return nb_frames;
645
}
646

    
647
/* flush the packet on stream stream_index */
648
static int flush_packet(AVFormatContext *ctx, int stream_index, 
649
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
650
{
651
    MpegMuxContext *s = ctx->priv_data;
652
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
653
    uint8_t *buf_ptr;
654
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
655
    int packet_size;
656
    uint8_t buffer[128];
657
    int zero_trail_bytes = 0;
658
    int pad_packet_bytes = 0;
659
    int pes_flags;
660
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
661
    int nb_frames;
662
    
663
    id = stream->id;
664
    
665
#if 0
666
    printf("packet ID=%2x PTS=%0.3f\n", 
667
           id, pts / 90000.0);
668
#endif
669

    
670
    buf_ptr = buffer;
671

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

    
678
        if (s->is_vcd) {
679
            /* there is exactly one system header for each stream in a VCD MPEG,
680
               One in the very first video packet and one in the very first
681
               audio packet (see VCD standard p. IV-7 and IV-8).*/
682
            
683
            if (stream->packet_number==0) {
684
                size = put_system_header(ctx, buf_ptr, id);
685
                buf_ptr += size;
686
            }
687
        } else if (s->is_dvd) {
688
            if (stream->align_iframe || s->packet_number == 0){
689
                int bytes_to_iframe;
690
                int PES_bytes_to_fill;
691
                if (stream->fifo_iframe_ptr >= stream->fifo.rptr) {
692
                    bytes_to_iframe = stream->fifo_iframe_ptr - stream->fifo.rptr;
693
                } else {
694
                    bytes_to_iframe = (stream->fifo.end - stream->fifo.rptr) + (stream->fifo_iframe_ptr - stream->fifo.buffer);
695
                }
696
                PES_bytes_to_fill = s->packet_size - size - 10;
697

    
698
                if (pts != AV_NOPTS_VALUE) {
699
                    if (dts != pts)
700
                        PES_bytes_to_fill -= 5 + 5;
701
                    else
702
                        PES_bytes_to_fill -= 5;
703
                }
704

    
705
                if (bytes_to_iframe == 0 || s->packet_number == 0) {
706
                    size = put_system_header(ctx, buf_ptr, 0);
707
                    buf_ptr += size;
708
                    size = buf_ptr - buffer;
709
                    put_buffer(&ctx->pb, buffer, size);
710

    
711
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
712
                    put_be16(&ctx->pb, 0x03d4);         // length
713
                    put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
714
                    for (i = 0; i < 979; i++)
715
                        put_byte(&ctx->pb, 0x00);
716

    
717
                    put_be32(&ctx->pb, PRIVATE_STREAM_2);
718
                    put_be16(&ctx->pb, 0x03fa);         // length
719
                    put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
720
                    for (i = 0; i < 1017; i++)
721
                        put_byte(&ctx->pb, 0x00);
722

    
723
                    memset(buffer, 0, 128);
724
                    buf_ptr = buffer;
725
                    s->packet_number++;
726
                    stream->align_iframe = 0;
727
                    scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
728
                    size = put_pack_header(ctx, buf_ptr, scr);
729
                    s->last_scr= scr;
730
                    buf_ptr += size;
731
                    /* GOP Start */
732
                } else if (bytes_to_iframe < PES_bytes_to_fill) {
733
                    pad_packet_bytes = PES_bytes_to_fill - bytes_to_iframe;
734
                }
735
            }
736
        } else {
737
            if ((s->packet_number % s->system_header_freq) == 0) {
738
                size = put_system_header(ctx, buf_ptr, 0);
739
                buf_ptr += size;
740
            }
741
        }
742
    }
743
    size = buf_ptr - buffer;
744
    put_buffer(&ctx->pb, buffer, size);
745

    
746
    packet_size = s->packet_size - size;
747

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

    
766
    packet_size -= pad_packet_bytes + zero_trail_bytes;
767

    
768
    if (packet_size > 0) {
769

    
770
        /* packet header size */
771
        packet_size -= 6;
772
        
773
        /* packet header */
774
        if (s->is_mpeg2) {
775
            header_len = 3;
776
            if (stream->packet_number==0)
777
                header_len += 3; /* PES extension */
778
            header_len += 1; /* obligatory stuffing byte */
779
        } else {
780
            header_len = 0;
781
        }
782
        if (pts != AV_NOPTS_VALUE) {
783
            if (dts != pts)
784
                header_len += 5 + 5;
785
            else
786
                header_len += 5;
787
        } else {
788
            if (!s->is_mpeg2)
789
                header_len++;
790
        }
791

    
792
        payload_size = packet_size - header_len;
793
        if (id < 0xc0) {
794
            startcode = PRIVATE_STREAM_1;
795
            payload_size -= 4;
796
            if (id >= 0xa0)
797
                payload_size -= 3;
798
        } else {
799
            startcode = 0x100 + id;
800
        }
801

    
802
        stuffing_size = payload_size - fifo_size(&stream->fifo, stream->fifo.rptr);
803

    
804
        // first byte doesnt fit -> reset pts/dts + stuffing
805
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
806
            int timestamp_len=0;
807
            if(dts != pts) 
808
                timestamp_len += 5;
809
            if(pts != AV_NOPTS_VALUE)
810
                timestamp_len += s->is_mpeg2 ? 5 : 4;
811
            pts=dts= AV_NOPTS_VALUE;
812
            header_len -= timestamp_len;
813
            if (s->is_dvd && stream->align_iframe) {
814
                pad_packet_bytes += timestamp_len;
815
                packet_size -= timestamp_len;
816
            } else {
817
                payload_size += timestamp_len;
818
            }
819
            stuffing_size += timestamp_len;
820
            if(payload_size > trailer_size)
821
                stuffing_size += payload_size - trailer_size;
822
        }
823

    
824
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
825
            packet_size += pad_packet_bytes;
826
            payload_size += pad_packet_bytes; // undo the previous adjustment
827
            if (stuffing_size < 0) {
828
                stuffing_size = pad_packet_bytes;
829
            } else {
830
                stuffing_size += pad_packet_bytes;
831
            }
832
            pad_packet_bytes = 0;
833
        }
834

    
835
        if (stuffing_size < 0)
836
            stuffing_size = 0;
837
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
838
            pad_packet_bytes += stuffing_size;
839
            packet_size -= stuffing_size;
840
            payload_size -= stuffing_size;
841
            stuffing_size = 0;
842
        }
843
        
844
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
845

    
846
        put_be32(&ctx->pb, startcode);
847

    
848
        put_be16(&ctx->pb, packet_size);
849
        
850
        if (!s->is_mpeg2)
851
            for(i=0;i<stuffing_size;i++)
852
                put_byte(&ctx->pb, 0xff);
853

    
854
        if (s->is_mpeg2) {
855
            put_byte(&ctx->pb, 0x80); /* mpeg2 id */
856

    
857
            pes_flags=0;
858

    
859
            if (pts != AV_NOPTS_VALUE) {
860
                pes_flags |= 0x80;
861
                if (dts != pts)
862
                    pes_flags |= 0x40;
863
            }
864

    
865
            /* Both the MPEG-2 and the SVCD standards demand that the
866
               P-STD_buffer_size field be included in the first packet of
867
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
868
               and MPEG-2 standard 2.7.7) */
869
            if (stream->packet_number == 0)
870
                pes_flags |= 0x01;
871

    
872
            put_byte(&ctx->pb, pes_flags); /* flags */
873
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
874

    
875
            if (pes_flags & 0x80)  /*write pts*/
876
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
877
            if (pes_flags & 0x40)  /*write dts*/
878
                put_timestamp(&ctx->pb, 0x01, dts);
879
            
880
            if (pes_flags & 0x01) {  /*write pes extension*/
881
                put_byte(&ctx->pb, 0x10); /* flags */
882

    
883
                /* P-STD buffer info */                
884
                if (id == AUDIO_ID)
885
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
886
                else
887
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
888
            }
889

    
890
        } else {
891
            if (pts != AV_NOPTS_VALUE) {
892
                if (dts != pts) {
893
                    put_timestamp(&ctx->pb, 0x03, pts);
894
                    put_timestamp(&ctx->pb, 0x01, dts);
895
                } else {
896
                    put_timestamp(&ctx->pb, 0x02, pts);
897
                }
898
            } else {
899
                put_byte(&ctx->pb, 0x0f);
900
            }
901
        }
902

    
903
        if (s->is_mpeg2) {
904
            /* special stuffing byte that is always written
905
               to prevent accidental generation of start codes. */
906
            put_byte(&ctx->pb, 0xff);
907

    
908
            for(i=0;i<stuffing_size;i++)
909
                put_byte(&ctx->pb, 0xff);
910
        }
911

    
912
        if (startcode == PRIVATE_STREAM_1) {
913
            put_byte(&ctx->pb, id);
914
            if (id >= 0xa0) {
915
                /* LPCM (XXX: check nb_frames) */
916
                put_byte(&ctx->pb, 7);
917
                put_be16(&ctx->pb, 4); /* skip 3 header bytes */
918
                put_byte(&ctx->pb, stream->lpcm_header[0]);
919
                put_byte(&ctx->pb, stream->lpcm_header[1]);
920
                put_byte(&ctx->pb, stream->lpcm_header[2]);
921
            } else {
922
                /* AC3 */
923
                put_byte(&ctx->pb, nb_frames);
924
                put_be16(&ctx->pb, trailer_size+1);
925
            }
926
        }
927

    
928
        /* output data */
929
        if(put_fifo(&ctx->pb, &stream->fifo, payload_size - stuffing_size, &stream->fifo.rptr) < 0)
930
            return -1;
931
    }else{
932
        payload_size=
933
        stuffing_size= 0;
934
    }
935

    
936
    if (pad_packet_bytes > 0)
937
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);    
938

    
939
    for(i=0;i<zero_trail_bytes;i++)
940
        put_byte(&ctx->pb, 0x00);
941
        
942
    put_flush_packet(&ctx->pb);
943
    
944
    s->packet_number++;
945

    
946
    /* only increase the stream packet number if this pack actually contains
947
       something that is specific to this stream! I.e. a dedicated header
948
       or some data.*/
949
    if (!general_pack)
950
        stream->packet_number++;
951
    
952
    return payload_size - stuffing_size;
953
}
954

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

    
963
    MpegMuxContext *s = ctx->priv_data;
964
    int i;
965

    
966
    for(i=0;i<s->packet_size;i++)
967
        put_byte(&ctx->pb, 0);
968

    
969
    s->vcd_padding_bytes_written += s->packet_size;
970
        
971
    put_flush_packet(&ctx->pb);
972
    
973
    /* increasing the packet number is correct. The SCR of the following packs
974
       is calculated from the packet_number and it has to include the padding
975
       sector (it represents the sector index, not the MPEG pack index)
976
       (see VCD standard p. IV-6)*/
977
    s->packet_number++;
978
}
979

    
980
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
981
{
982
    MpegMuxContext *s = ctx->priv_data;
983
    int64_t scr;
984

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

    
997
    return scr;
998
}    
999

    
1000
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1001
//    MpegMuxContext *s = ctx->priv_data;
1002
    int i;
1003

    
1004
    for(i=0; i<ctx->nb_streams; i++){
1005
        AVStream *st = ctx->streams[i];
1006
        StreamInfo *stream = st->priv_data;
1007
        PacketDesc *pkt_desc= stream->predecode_packet;
1008
        
1009
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1010
            if(stream->buffer_index < pkt_desc->size || 
1011
               stream->predecode_packet == stream->premux_packet){
1012
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1013
                break;
1014
            }
1015
            stream->buffer_index -= pkt_desc->size;
1016

    
1017
            stream->predecode_packet= pkt_desc->next;
1018
            av_freep(&pkt_desc);
1019
        }
1020
    }
1021
    
1022
    return 0;
1023
}
1024

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

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

    
1046
        if(s->packet_size > avail_data && !flush)
1047
            return 0;
1048
        if(avail_data==0)
1049
            continue;
1050
        assert(avail_data>0);
1051

    
1052
        if(space < s->packet_size && !ignore_constraints)
1053
            continue;
1054
            
1055
        if(next_pkt && next_pkt->dts - scr > max_delay)
1056
            continue;
1057
            
1058
        if(rel_space > best_score){
1059
            best_score= rel_space;
1060
            best_i = i;
1061
            avail_space= space;
1062
        }
1063
    }
1064
    
1065
    if(best_i < 0){
1066
        int64_t best_dts= INT64_MAX;
1067

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

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

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

    
1093
    assert(best_i >= 0);
1094
    
1095
    st = ctx->streams[best_i];
1096
    stream = st->priv_data;
1097
    
1098
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
1099

    
1100
    assert(avail_space >= s->packet_size || ignore_constraints);
1101
    
1102
    timestamp_packet= stream->premux_packet;
1103
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1104
        trailer_size= 0;
1105
    }else{
1106
        trailer_size= timestamp_packet->unwritten_size;
1107
        timestamp_packet= timestamp_packet->next;
1108
    }
1109

    
1110
    if(timestamp_packet){
1111
//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);
1112
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1113
    }else{
1114
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == trailer_size);
1115
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1116
    }
1117

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

    
1123
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1124
            put_vcd_padding_sector(ctx);
1125
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1126
        }
1127
    }
1128
    
1129
    stream->buffer_index += es_size;
1130
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1131
    
1132
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1133
        es_size -= stream->premux_packet->unwritten_size;
1134
        stream->premux_packet= stream->premux_packet->next;
1135
    }
1136
    if(es_size)
1137
        stream->premux_packet->unwritten_size -= es_size;
1138
    
1139
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1140
        return -1;
1141

    
1142
    return 1;
1143
}
1144

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

    
1161
    if(pts != AV_NOPTS_VALUE) pts += preload;
1162
    if(dts != AV_NOPTS_VALUE) dts += preload;
1163

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

    
1175
    fifo_realloc(&stream->fifo, fifo_size(&stream->fifo, NULL) + size + 1);
1176

    
1177
    if (s->is_dvd){
1178
        if (is_iframe) {
1179
            stream->fifo_iframe_ptr = stream->fifo.wptr;
1180
            stream->align_iframe = 1;
1181
        } else {
1182
            stream->align_iframe = 0;
1183
        }
1184
    }
1185

    
1186
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1187

    
1188
    for(;;){
1189
        int ret= output_packet(ctx, 0);
1190
        if(ret<=0) 
1191
            return ret;
1192
    }
1193
}
1194

    
1195
static int mpeg_mux_end(AVFormatContext *ctx)
1196
{
1197
//    MpegMuxContext *s = ctx->priv_data;
1198
    StreamInfo *stream;
1199
    int i;
1200
    
1201
    for(;;){
1202
        int ret= output_packet(ctx, 1);
1203
        if(ret<0) 
1204
            return ret;
1205
        else if(ret==0)
1206
            break;
1207
    }
1208

    
1209
    /* End header according to MPEG1 systems standard. We do not write
1210
       it as it is usually not needed by decoders and because it
1211
       complicates MPEG stream concatenation. */
1212
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1213
    //put_flush_packet(&ctx->pb);
1214

    
1215
    for(i=0;i<ctx->nb_streams;i++) {
1216
        stream = ctx->streams[i]->priv_data;
1217

    
1218
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1219
        fifo_free(&stream->fifo);
1220
    }
1221
    return 0;
1222
}
1223
#endif //CONFIG_ENCODERS
1224

    
1225
/*********************************************/
1226
/* demux code */
1227

    
1228
#define MAX_SYNC_SIZE 100000
1229

    
1230
static int mpegps_probe(AVProbeData *p)
1231
{
1232
    int i;
1233
    int size= FFMIN(20, p->buf_size);
1234
    uint32_t code=0xFF;
1235

    
1236
    /* we search the first start code. If it is a packet start code,
1237
       then we decide it is mpeg ps. We do not send highest value to
1238
       give a chance to mpegts */
1239
    /* NOTE: the search range was restricted to avoid too many false
1240
       detections */
1241

    
1242
    for (i = 0; i < size; i++) {
1243
        code = (code << 8) | p->buf[i];
1244
        if ((code & 0xffffff00) == 0x100) {
1245
            if (code == PACK_START_CODE ||
1246
                code == SYSTEM_HEADER_START_CODE ||
1247
                (code >= 0x1e0 && code <= 0x1ef) ||
1248
                (code >= 0x1c0 && code <= 0x1df) ||
1249
                code == PRIVATE_STREAM_2 ||
1250
                code == PROGRAM_STREAM_MAP ||
1251
                code == PRIVATE_STREAM_1 ||
1252
                code == PADDING_STREAM)
1253
                return AVPROBE_SCORE_MAX - 2;
1254
            else
1255
                return 0;
1256
        }
1257
    }
1258
    return 0;
1259
}
1260

    
1261

    
1262
typedef struct MpegDemuxContext {
1263
    int header_state;
1264
} MpegDemuxContext;
1265

    
1266
static int mpegps_read_header(AVFormatContext *s,
1267
                              AVFormatParameters *ap)
1268
{
1269
    MpegDemuxContext *m = s->priv_data;
1270
    m->header_state = 0xff;
1271
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1272

    
1273
    /* no need to do more */
1274
    return 0;
1275
}
1276

    
1277
static int64_t get_pts(ByteIOContext *pb, int c)
1278
{
1279
    int64_t pts;
1280
    int val;
1281

    
1282
    if (c < 0)
1283
        c = get_byte(pb);
1284
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1285
    val = get_be16(pb);
1286
    pts |= (int64_t)(val >> 1) << 15;
1287
    val = get_be16(pb);
1288
    pts |= (int64_t)(val >> 1);
1289
    return pts;
1290
}
1291

    
1292
static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1293
                                uint32_t *header_state)
1294
{
1295
    unsigned int state, v;
1296
    int val, n;
1297

    
1298
    state = *header_state;
1299
    n = *size_ptr;
1300
    while (n > 0) {
1301
        if (url_feof(pb))
1302
            break;
1303
        v = get_byte(pb);
1304
        n--;
1305
        if (state == 0x000001) {
1306
            state = ((state << 8) | v) & 0xffffff;
1307
            val = state;
1308
            goto found;
1309
        }
1310
        state = ((state << 8) | v) & 0xffffff;
1311
    }
1312
    val = -1;
1313
 found:
1314
    *header_state = state;
1315
    *size_ptr = n;
1316
    return val;
1317
}
1318

    
1319
/* XXX: optimize */
1320
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1321
{
1322
    int64_t pos, pos_start;
1323
    int max_size, start_code;
1324

    
1325
    max_size = *size_ptr;
1326
    pos_start = url_ftell(pb);
1327

    
1328
    /* in order to go faster, we fill the buffer */
1329
    pos = pos_start - 16386;
1330
    if (pos < 0)
1331
        pos = 0;
1332
    url_fseek(pb, pos, SEEK_SET);
1333
    get_byte(pb);
1334

    
1335
    pos = pos_start;
1336
    for(;;) {
1337
        pos--;
1338
        if (pos < 0 || (pos_start - pos) >= max_size) {
1339
            start_code = -1;
1340
            goto the_end;
1341
        }
1342
        url_fseek(pb, pos, SEEK_SET);
1343
        start_code = get_be32(pb);
1344
        if ((start_code & 0xffffff00) == 0x100)
1345
            break;
1346
    }
1347
 the_end:
1348
    *size_ptr = pos_start - pos;
1349
    return start_code;
1350
}
1351

    
1352
/* read the next PES header. Return its position in ppos 
1353
   (if not NULL), and its start code, pts and dts.
1354
 */
1355
static int mpegps_read_pes_header(AVFormatContext *s,
1356
                                  int64_t *ppos, int *pstart_code, 
1357
                                  int64_t *ppts, int64_t *pdts)
1358
{
1359
    MpegDemuxContext *m = s->priv_data;
1360
    int len, size, startcode, c, flags, header_len;
1361
    int64_t pts, dts, last_pos;
1362

    
1363
    last_pos = -1;
1364
 redo:
1365
        /* next start code (should be immediately after) */
1366
        m->header_state = 0xff;
1367
        size = MAX_SYNC_SIZE;
1368
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1369
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1370
    if (startcode < 0)
1371
        return AVERROR_IO;
1372
    if (startcode == PACK_START_CODE)
1373
        goto redo;
1374
    if (startcode == SYSTEM_HEADER_START_CODE)
1375
        goto redo;
1376
    if (startcode == PADDING_STREAM ||
1377
        startcode == PRIVATE_STREAM_2) {
1378
        /* skip them */
1379
        len = get_be16(&s->pb);
1380
        url_fskip(&s->pb, len);
1381
        goto redo;
1382
    }
1383
    /* find matching stream */
1384
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1385
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1386
          (startcode == 0x1bd)))
1387
        goto redo;
1388
    if (ppos) {
1389
        *ppos = url_ftell(&s->pb) - 4;
1390
    }
1391
    len = get_be16(&s->pb);
1392
    pts = AV_NOPTS_VALUE;
1393
    dts = AV_NOPTS_VALUE;
1394
    /* stuffing */
1395
    for(;;) {
1396
        if (len < 1)
1397
            goto redo;
1398
        c = get_byte(&s->pb);
1399
        len--;
1400
        /* XXX: for mpeg1, should test only bit 7 */
1401
        if (c != 0xff) 
1402
            break;
1403
    }
1404
    if ((c & 0xc0) == 0x40) {
1405
        /* buffer scale & size */
1406
        if (len < 2)
1407
            goto redo;
1408
        get_byte(&s->pb);
1409
        c = get_byte(&s->pb);
1410
        len -= 2;
1411
    }
1412
    if ((c & 0xf0) == 0x20) {
1413
        if (len < 4)
1414
            goto redo;
1415
        dts = pts = get_pts(&s->pb, c);
1416
        len -= 4;
1417
    } else if ((c & 0xf0) == 0x30) {
1418
        if (len < 9)
1419
            goto redo;
1420
        pts = get_pts(&s->pb, c);
1421
        dts = get_pts(&s->pb, -1);
1422
        len -= 9;
1423
    } else if ((c & 0xc0) == 0x80) {
1424
        /* mpeg 2 PES */
1425
        if ((c & 0x30) != 0) {
1426
            /* Encrypted multiplex not handled */
1427
            goto redo;
1428
        }
1429
        flags = get_byte(&s->pb);
1430
        header_len = get_byte(&s->pb);
1431
        len -= 2;
1432
        if (header_len > len)
1433
            goto redo;
1434
        if ((flags & 0xc0) == 0x80) {
1435
            dts = pts = get_pts(&s->pb, -1);
1436
            if (header_len < 5)
1437
                goto redo;
1438
            header_len -= 5;
1439
            len -= 5;
1440
        } if ((flags & 0xc0) == 0xc0) {
1441
            pts = get_pts(&s->pb, -1);
1442
            dts = get_pts(&s->pb, -1);
1443
            if (header_len < 10)
1444
                goto redo;
1445
            header_len -= 10;
1446
            len -= 10;
1447
        }
1448
        len -= header_len;
1449
        while (header_len > 0) {
1450
            get_byte(&s->pb);
1451
            header_len--;
1452
        }
1453
    }
1454
    else if( c!= 0xf )
1455
        goto redo;
1456

    
1457
    if (startcode == 0x1bd) {
1458
        if (len < 1)
1459
            goto redo;
1460
        startcode = get_byte(&s->pb);
1461
        len--;
1462
        if (startcode >= 0x80 && startcode <= 0xbf) {
1463
            /* audio: skip header */
1464
            if (len < 3)
1465
                goto redo;
1466
            get_byte(&s->pb);
1467
            get_byte(&s->pb);
1468
            get_byte(&s->pb);
1469
            len -= 3;
1470
        }
1471
    }
1472
    if(dts != AV_NOPTS_VALUE && ppos){
1473
        int i;
1474
        for(i=0; i<s->nb_streams; i++){
1475
            if(startcode == s->streams[i]->id) {
1476
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0 /* FIXME keyframe? */);
1477
            }
1478
        }
1479
    }
1480
    
1481
    *pstart_code = startcode;
1482
    *ppts = pts;
1483
    *pdts = dts;
1484
    return len;
1485
}
1486

    
1487
static int mpegps_read_packet(AVFormatContext *s,
1488
                              AVPacket *pkt)
1489
{
1490
    AVStream *st;
1491
    int len, startcode, i, type, codec_id = 0;
1492
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1493

    
1494
 redo:
1495
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1496
    if (len < 0)
1497
        return len;
1498
    
1499
    /* now find stream */
1500
    for(i=0;i<s->nb_streams;i++) {
1501
        st = s->streams[i];
1502
        if (st->id == startcode)
1503
            goto found;
1504
    }
1505
    if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1506
        type = CODEC_TYPE_VIDEO;
1507
        codec_id = CODEC_ID_MPEG2VIDEO;
1508
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1509
        type = CODEC_TYPE_AUDIO;
1510
        codec_id = CODEC_ID_MP2;
1511
    } else if (startcode >= 0x80 && startcode <= 0x89) {
1512
        type = CODEC_TYPE_AUDIO;
1513
        codec_id = CODEC_ID_AC3;
1514
    } else if (startcode >= 0x8a && startcode <= 0x9f) {
1515
        type = CODEC_TYPE_AUDIO;
1516
        codec_id = CODEC_ID_DTS;
1517
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1518
        type = CODEC_TYPE_AUDIO;
1519
        codec_id = CODEC_ID_PCM_S16BE;
1520
    } else {
1521
    skip:
1522
        /* skip packet */
1523
        url_fskip(&s->pb, len);
1524
        goto redo;
1525
    }
1526
    /* no stream found: add a new stream */
1527
    st = av_new_stream(s, startcode);
1528
    if (!st) 
1529
        goto skip;
1530
    st->codec.codec_type = type;
1531
    st->codec.codec_id = codec_id;
1532
    if (codec_id != CODEC_ID_PCM_S16BE)
1533
        st->need_parsing = 1;
1534
 found:
1535
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1536
        int b1, freq;
1537

    
1538
        /* for LPCM, we just skip the header and consider it is raw
1539
           audio data */
1540
        if (len <= 3)
1541
            goto skip;
1542
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1543
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1544
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1545
        len -= 3;
1546
        freq = (b1 >> 4) & 3;
1547
        st->codec.sample_rate = lpcm_freq_tab[freq];
1548
        st->codec.channels = 1 + (b1 & 7);
1549
        st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
1550
    }
1551
    av_new_packet(pkt, len);
1552
    get_buffer(&s->pb, pkt->data, pkt->size);
1553
    pkt->pts = pts;
1554
    pkt->dts = dts;
1555
    pkt->stream_index = st->index;
1556
#if 0
1557
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f\n",
1558
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
1559
#endif
1560

    
1561
    return 0;
1562
}
1563

    
1564
static int mpegps_read_close(AVFormatContext *s)
1565
{
1566
    return 0;
1567
}
1568

    
1569
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1570
                               int64_t *ppos, int64_t pos_limit)
1571
{
1572
    int len, startcode;
1573
    int64_t pos, pts, dts;
1574

    
1575
    pos = *ppos;
1576
#ifdef DEBUG_SEEK
1577
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1578
#endif
1579
    url_fseek(&s->pb, pos, SEEK_SET);
1580
    for(;;) {
1581
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1582
        if (len < 0) {
1583
#ifdef DEBUG_SEEK
1584
            printf("none (ret=%d)\n", len);
1585
#endif
1586
            return AV_NOPTS_VALUE;
1587
        }
1588
        if (startcode == s->streams[stream_index]->id && 
1589
            dts != AV_NOPTS_VALUE) {
1590
            break;
1591
        }
1592
        url_fskip(&s->pb, len);
1593
    }
1594
#ifdef DEBUG_SEEK
1595
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1596
#endif
1597
    *ppos = pos;
1598
    return dts;
1599
}
1600

    
1601
#ifdef CONFIG_ENCODERS
1602
static AVOutputFormat mpeg1system_mux = {
1603
    "mpeg",
1604
    "MPEG1 System format",
1605
    "video/mpeg",
1606
    "mpg,mpeg",
1607
    sizeof(MpegMuxContext),
1608
    CODEC_ID_MP2,
1609
    CODEC_ID_MPEG1VIDEO,
1610
    mpeg_mux_init,
1611
    mpeg_mux_write_packet,
1612
    mpeg_mux_end,
1613
};
1614

    
1615
static AVOutputFormat mpeg1vcd_mux = {
1616
    "vcd",
1617
    "MPEG1 System format (VCD)",
1618
    "video/mpeg",
1619
    NULL,
1620
    sizeof(MpegMuxContext),
1621
    CODEC_ID_MP2,
1622
    CODEC_ID_MPEG1VIDEO,
1623
    mpeg_mux_init,
1624
    mpeg_mux_write_packet,
1625
    mpeg_mux_end,
1626
};
1627

    
1628
static AVOutputFormat mpeg2vob_mux = {
1629
    "vob",
1630
    "MPEG2 PS format (VOB)",
1631
    "video/mpeg",
1632
    "vob",
1633
    sizeof(MpegMuxContext),
1634
    CODEC_ID_MP2,
1635
    CODEC_ID_MPEG2VIDEO,
1636
    mpeg_mux_init,
1637
    mpeg_mux_write_packet,
1638
    mpeg_mux_end,
1639
};
1640

    
1641
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1642
static AVOutputFormat mpeg2svcd_mux = {
1643
    "svcd",
1644
    "MPEG2 PS format (VOB)",
1645
    "video/mpeg",
1646
    "vob",
1647
    sizeof(MpegMuxContext),
1648
    CODEC_ID_MP2,
1649
    CODEC_ID_MPEG2VIDEO,
1650
    mpeg_mux_init,
1651
    mpeg_mux_write_packet,
1652
    mpeg_mux_end,
1653
};
1654

    
1655
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1656
static AVOutputFormat mpeg2dvd_mux = {
1657
    "dvd",
1658
    "MPEG2 PS format (DVD VOB)",
1659
    "video/mpeg",
1660
    "dvd",
1661
    sizeof(MpegMuxContext),
1662
    CODEC_ID_MP2,
1663
    CODEC_ID_MPEG2VIDEO,
1664
    mpeg_mux_init,
1665
    mpeg_mux_write_packet,
1666
    mpeg_mux_end,
1667
};
1668

    
1669
#endif //CONFIG_ENCODERS
1670

    
1671
AVInputFormat mpegps_demux = {
1672
    "mpeg",
1673
    "MPEG PS format",
1674
    sizeof(MpegDemuxContext),
1675
    mpegps_probe,
1676
    mpegps_read_header,
1677
    mpegps_read_packet,
1678
    mpegps_read_close,
1679
    NULL, //mpegps_read_seek,
1680
    mpegps_read_dts,
1681
};
1682

    
1683
int mpegps_init(void)
1684
{
1685
#ifdef CONFIG_ENCODERS
1686
    av_register_output_format(&mpeg1system_mux);
1687
    av_register_output_format(&mpeg1vcd_mux);
1688
    av_register_output_format(&mpeg2vob_mux);
1689
    av_register_output_format(&mpeg2svcd_mux);
1690
    av_register_output_format(&mpeg2dvd_mux);
1691
#endif //CONFIG_ENCODERS
1692
    av_register_input_format(&mpegps_demux);
1693
    return 0;
1694
}