Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 25f8db58

History | View | Annotate | Download (56.2 KB)

1 de6d9b64 Fabrice Bellard
/*
2 fb7566d0 Fabrice Bellard
 * MPEG1/2 mux/demux
3 19720f15 Fabrice Bellard
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4 de6d9b64 Fabrice Bellard
 *
5 19720f15 Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 *
10 19720f15 Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 19720f15 Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 */
19
#include "avformat.h"
20 2de7795a Michael Niedermayer
#include "bitstream.h"
21 de6d9b64 Fabrice Bellard
22
#define MAX_PAYLOAD_SIZE 4096
23 27f388aa Fabrice Bellard
//#define DEBUG_SEEK
24 de6d9b64 Fabrice Bellard
25 b754978a Michael Niedermayer
#undef NDEBUG
26
#include <assert.h>
27
28 7000a175 Michael Niedermayer
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 de6d9b64 Fabrice Bellard
typedef struct {
38 7000a175 Michael Niedermayer
    FifoBuffer fifo;
39 0c1a9eda Zdenek Kabelac
    uint8_t id;
40 de6d9b64 Fabrice Bellard
    int max_buffer_size; /* in bytes */
41 7000a175 Michael Niedermayer
    int buffer_index;
42
    PacketDesc *predecode_packet;
43
    PacketDesc *premux_packet;
44
    PacketDesc **next_packet;
45 de6d9b64 Fabrice Bellard
    int packet_number;
46 044007c2 Fabrice Bellard
    uint8_t lpcm_header[3];
47
    int lpcm_align;
48 cbb6e405 Michael Niedermayer
    uint8_t *fifo_iframe_ptr;
49
    int align_iframe;
50 7be806f3 Chriss
    int64_t vobu_start_pts;
51 de6d9b64 Fabrice Bellard
} 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 0dbb48d9 Fabrice Bellard
    int system_header_size;
59 de6d9b64 Fabrice Bellard
    int mux_rate; /* bitrate in units of 50 bytes/s */
60
    /* stream info */
61
    int audio_bound;
62
    int video_bound;
63 fb7566d0 Fabrice Bellard
    int is_mpeg2;
64
    int is_vcd;
65 24515926 Hauke Duden
    int is_svcd;
66 78a0efb4 Paul Curtis
    int is_dvd;
67 27a206e0 Michel Bardiaux
    int64_t last_scr; /* current system clock */
68 24515926 Hauke Duden
69 d8b5abfa Michael Niedermayer
    double vcd_padding_bitrate; //FIXME floats
70 24515926 Hauke Duden
    int64_t vcd_padding_bytes_written;
71
72 de6d9b64 Fabrice Bellard
} MpegMuxContext;
73
74
#define PACK_START_CODE             ((unsigned int)0x000001ba)
75
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
76 92b3e125 Juanjo
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
77 de6d9b64 Fabrice Bellard
#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 044007c2 Fabrice Bellard
#define AC3_ID   0x80
91 23c99253 Michael Niedermayer
#define DTS_ID   0x8a
92 044007c2 Fabrice Bellard
#define LPCM_ID  0xa0
93 9ba73f1f Aurelien Jacobs
#define SUB_ID   0x20
94 de6d9b64 Fabrice Bellard
95 e3d1cd8e Måns Rullgård
#define STREAM_TYPE_VIDEO_MPEG1     0x01
96
#define STREAM_TYPE_VIDEO_MPEG2     0x02
97
#define STREAM_TYPE_AUDIO_MPEG1     0x03
98
#define STREAM_TYPE_AUDIO_MPEG2     0x04
99
#define STREAM_TYPE_PRIVATE_SECTION 0x05
100
#define STREAM_TYPE_PRIVATE_DATA    0x06
101
#define STREAM_TYPE_AUDIO_AAC       0x0f
102
#define STREAM_TYPE_VIDEO_MPEG4     0x10
103
#define STREAM_TYPE_VIDEO_H264      0x1b
104
105
#define STREAM_TYPE_AUDIO_AC3       0x81
106
#define STREAM_TYPE_AUDIO_DTS       0x8a
107
108 8a05bca4 Michael Niedermayer
static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
109
110 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
111 7906085f Falk Hüffner
static AVOutputFormat mpeg1system_mux;
112
static AVOutputFormat mpeg1vcd_mux;
113
static AVOutputFormat mpeg2vob_mux;
114
static AVOutputFormat mpeg2svcd_mux;
115 78a0efb4 Paul Curtis
static AVOutputFormat mpeg2dvd_mux;
116 fb7566d0 Fabrice Bellard
117 de6d9b64 Fabrice Bellard
static int put_pack_header(AVFormatContext *ctx, 
118 0c1a9eda Zdenek Kabelac
                           uint8_t *buf, int64_t timestamp)
119 de6d9b64 Fabrice Bellard
{
120
    MpegMuxContext *s = ctx->priv_data;
121
    PutBitContext pb;
122
    
123 117a5490 Alex Beregszaszi
    init_put_bits(&pb, buf, 128);
124 de6d9b64 Fabrice Bellard
125
    put_bits(&pb, 32, PACK_START_CODE);
126 b2cac184 Fabrice Bellard
    if (s->is_mpeg2) {
127 8683e4a0 Måns Rullgård
        put_bits(&pb, 2, 0x1);
128 b2cac184 Fabrice Bellard
    } else {
129
        put_bits(&pb, 4, 0x2);
130
    }
131 0c1a9eda Zdenek Kabelac
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
132 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
133 0c1a9eda Zdenek Kabelac
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
134 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
135 0c1a9eda Zdenek Kabelac
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
136 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
137 b2cac184 Fabrice Bellard
    if (s->is_mpeg2) {
138
        /* clock extension */
139
        put_bits(&pb, 9, 0);
140
    }
141 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
142
    put_bits(&pb, 22, s->mux_rate);
143
    put_bits(&pb, 1, 1);
144 b2cac184 Fabrice Bellard
    if (s->is_mpeg2) {
145 4aa533be Michael Niedermayer
        put_bits(&pb, 1, 1);
146 b2cac184 Fabrice Bellard
        put_bits(&pb, 5, 0x1f); /* reserved */
147
        put_bits(&pb, 3, 0); /* stuffing length */
148
    }
149 de6d9b64 Fabrice Bellard
    flush_put_bits(&pb);
150 17592475 Michael Niedermayer
    return pbBufPtr(&pb) - pb.buf;
151 de6d9b64 Fabrice Bellard
}
152
153 24515926 Hauke Duden
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
154 de6d9b64 Fabrice Bellard
{
155
    MpegMuxContext *s = ctx->priv_data;
156 7000a175 Michael Niedermayer
    int size, i, private_stream_coded, id;
157 de6d9b64 Fabrice Bellard
    PutBitContext pb;
158
159 117a5490 Alex Beregszaszi
    init_put_bits(&pb, buf, 128);
160 de6d9b64 Fabrice Bellard
161
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
162
    put_bits(&pb, 16, 0);
163
    put_bits(&pb, 1, 1);
164
    
165 7000a175 Michael Niedermayer
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
166 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1); /* marker */
167 24515926 Hauke Duden
    if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
168
        /* This header applies only to the video stream (see VCD standard p. IV-7)*/
169
        put_bits(&pb, 6, 0);
170
    } else
171
        put_bits(&pb, 6, s->audio_bound);
172 de6d9b64 Fabrice Bellard
173 22494489 Hauke Duden
    if (s->is_vcd) {
174
        /* see VCD standard, p. IV-7*/
175
        put_bits(&pb, 1, 0); 
176
        put_bits(&pb, 1, 1);
177
    } else {
178
        put_bits(&pb, 1, 0); /* variable bitrate*/
179
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
180
    }
181 de6d9b64 Fabrice Bellard
    
182 cbb6e405 Michael Niedermayer
    if (s->is_vcd || s->is_dvd) {
183 24515926 Hauke Duden
        /* see VCD standard p IV-7 */
184
        put_bits(&pb, 1, 1); /* audio locked */
185
        put_bits(&pb, 1, 1); /* video locked */
186
    } else {
187
        put_bits(&pb, 1, 0); /* audio locked */
188
        put_bits(&pb, 1, 0); /* video locked */
189
    }
190
191 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1); /* marker */
192
193 24515926 Hauke Duden
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
194
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
195
        put_bits(&pb, 5, 0);
196
    } else
197
        put_bits(&pb, 5, s->video_bound);
198 de6d9b64 Fabrice Bellard
    
199 cbb6e405 Michael Niedermayer
    if (s->is_dvd) {
200
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
201
        put_bits(&pb, 7, 0x7f); /* reserved byte */
202
    } else
203
        put_bits(&pb, 8, 0xff); /* reserved byte */
204
    
205
    /* DVD-Video Stream_bound entries
206
    id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1) 
207
    id (0xB8) audio, maximum P-STD for any MPEG audio (0xC0 to 0xC7) streams. If there are none set to 4096 (32x128). (P-STD_buffer_bound_scale = 0) 
208
    id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1) 
209
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
210
    if (s->is_dvd) {
211
        
212
        int P_STD_max_video = 0;
213
        int P_STD_max_mpeg_audio = 0;
214
        int P_STD_max_mpeg_PS1 = 0;
215 24515926 Hauke Duden
        
216 cbb6e405 Michael Niedermayer
        for(i=0;i<ctx->nb_streams;i++) {
217
            StreamInfo *stream = ctx->streams[i]->priv_data;
218 24515926 Hauke Duden
219
            id = stream->id;
220 cbb6e405 Michael Niedermayer
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
221
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
222
            } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
223
                P_STD_max_mpeg_audio = stream->max_buffer_size;
224
            } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
225
                P_STD_max_video = stream->max_buffer_size;
226 24515926 Hauke Duden
            }
227 cbb6e405 Michael Niedermayer
        }
228
229
        /* video */
230
        put_bits(&pb, 8, 0xb9); /* stream ID */
231
        put_bits(&pb, 2, 3);
232
        put_bits(&pb, 1, 1);
233
        put_bits(&pb, 13, P_STD_max_video / 1024);
234
235
        /* audio */
236
        if (P_STD_max_mpeg_audio == 0)
237
            P_STD_max_mpeg_audio = 4096;
238
        put_bits(&pb, 8, 0xb8); /* stream ID */
239
        put_bits(&pb, 2, 3);
240
        put_bits(&pb, 1, 0);
241
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
242
243
        /* private stream 1 */
244
        put_bits(&pb, 8, 0xbd); /* stream ID */
245
        put_bits(&pb, 2, 3);
246
        put_bits(&pb, 1, 0);
247
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
248
249
        /* private stream 2 */
250
        put_bits(&pb, 8, 0xbf); /* stream ID */
251
        put_bits(&pb, 2, 3);
252
        put_bits(&pb, 1, 1);
253
        put_bits(&pb, 13, 2);
254
    }
255
    else {
256
        /* audio stream info */
257
        private_stream_coded = 0;
258
        for(i=0;i<ctx->nb_streams;i++) {
259
            StreamInfo *stream = ctx->streams[i]->priv_data;
260
            
261
262
            /* For VCDs, only include the stream info for the stream
263
            that the pack which contains this system belongs to.
264
            (see VCD standard p. IV-7) */
265
            if ( !s->is_vcd || stream->id==only_for_stream_id
266
                || only_for_stream_id==0) {
267
268
                id = stream->id;
269
                if (id < 0xc0) {
270
                    /* special case for private streams (AC3 use that) */
271
                    if (private_stream_coded)
272
                        continue;
273
                    private_stream_coded = 1;
274
                    id = 0xbd;
275
                }
276
                put_bits(&pb, 8, id); /* stream ID */
277
                put_bits(&pb, 2, 3);
278
                if (id < 0xe0) {
279
                    /* audio */
280
                    put_bits(&pb, 1, 0);
281
                    put_bits(&pb, 13, stream->max_buffer_size / 128);
282
                } else {
283
                    /* video */
284
                    put_bits(&pb, 1, 1);
285
                    put_bits(&pb, 13, stream->max_buffer_size / 1024);
286
                }
287 24515926 Hauke Duden
            }
288 de6d9b64 Fabrice Bellard
        }
289
    }
290 cbb6e405 Michael Niedermayer
291 de6d9b64 Fabrice Bellard
    flush_put_bits(&pb);
292 17592475 Michael Niedermayer
    size = pbBufPtr(&pb) - pb.buf;
293 de6d9b64 Fabrice Bellard
    /* patch packet size */
294
    buf[4] = (size - 6) >> 8;
295
    buf[5] = (size - 6) & 0xff;
296
297
    return size;
298
}
299
300 0dbb48d9 Fabrice Bellard
static int get_system_header_size(AVFormatContext *ctx)
301
{
302
    int buf_index, i, private_stream_coded;
303
    StreamInfo *stream;
304 cbb6e405 Michael Niedermayer
    MpegMuxContext *s = ctx->priv_data;
305
306
    if (s->is_dvd)
307
       return 18; // DVD-Video system headers are 18 bytes fixed length.
308 0dbb48d9 Fabrice Bellard
309
    buf_index = 12;
310
    private_stream_coded = 0;
311
    for(i=0;i<ctx->nb_streams;i++) {
312
        stream = ctx->streams[i]->priv_data;
313
        if (stream->id < 0xc0) {
314
            if (private_stream_coded)
315
                continue;
316
            private_stream_coded = 1;
317
        }
318
        buf_index += 3;
319
    }
320
    return buf_index;
321
}
322
323 de6d9b64 Fabrice Bellard
static int mpeg_mux_init(AVFormatContext *ctx)
324
{
325 db7f1f95 Fabrice Bellard
    MpegMuxContext *s = ctx->priv_data;
326 9ba73f1f Aurelien Jacobs
    int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
327 de6d9b64 Fabrice Bellard
    AVStream *st;
328
    StreamInfo *stream;
329 24515926 Hauke Duden
    int audio_bitrate;
330
    int video_bitrate;
331 de6d9b64 Fabrice Bellard
332
    s->packet_number = 0;
333 fb7566d0 Fabrice Bellard
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
334 24515926 Hauke Duden
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
335 78a0efb4 Paul Curtis
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
336
    s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
337 fb7566d0 Fabrice Bellard
    
338 2db3c638 Michael Niedermayer
    if(ctx->packet_size)
339
        s->packet_size = ctx->packet_size;
340 92b3e125 Juanjo
    else
341
        s->packet_size = 2048;
342 2db3c638 Michael Niedermayer
       
343 24515926 Hauke Duden
    s->vcd_padding_bytes_written = 0;
344
    s->vcd_padding_bitrate=0;
345 92b3e125 Juanjo
        
346 de6d9b64 Fabrice Bellard
    s->audio_bound = 0;
347
    s->video_bound = 0;
348
    mpa_id = AUDIO_ID;
349 044007c2 Fabrice Bellard
    ac3_id = AC3_ID;
350 23c99253 Michael Niedermayer
    dts_id = DTS_ID;
351 de6d9b64 Fabrice Bellard
    mpv_id = VIDEO_ID;
352 9ba73f1f Aurelien Jacobs
    mps_id = SUB_ID;
353 044007c2 Fabrice Bellard
    lpcm_id = LPCM_ID;
354 de6d9b64 Fabrice Bellard
    for(i=0;i<ctx->nb_streams;i++) {
355
        st = ctx->streams[i];
356
        stream = av_mallocz(sizeof(StreamInfo));
357
        if (!stream)
358
            goto fail;
359
        st->priv_data = stream;
360
361 2031ba1b Michael Niedermayer
        av_set_pts_info(st, 64, 1, 90000);
362
363 01f4895c Michael Niedermayer
        switch(st->codec->codec_type) {
364 de6d9b64 Fabrice Bellard
        case CODEC_TYPE_AUDIO:
365 01f4895c Michael Niedermayer
            if (st->codec->codec_id == CODEC_ID_AC3) {
366 de6d9b64 Fabrice Bellard
                stream->id = ac3_id++;
367 01f4895c Michael Niedermayer
            } else if (st->codec->codec_id == CODEC_ID_DTS) {
368 23c99253 Michael Niedermayer
                stream->id = dts_id++;
369 01f4895c Michael Niedermayer
            } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
370 044007c2 Fabrice Bellard
                stream->id = lpcm_id++;
371
                for(j = 0; j < 4; j++) {
372 01f4895c Michael Niedermayer
                    if (lpcm_freq_tab[j] == st->codec->sample_rate)
373 044007c2 Fabrice Bellard
                        break;
374
                }
375
                if (j == 4)
376
                    goto fail;
377 01f4895c Michael Niedermayer
                if (st->codec->channels > 8)
378 044007c2 Fabrice Bellard
                    return -1;
379
                stream->lpcm_header[0] = 0x0c;
380 01f4895c Michael Niedermayer
                stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
381 044007c2 Fabrice Bellard
                stream->lpcm_header[2] = 0x80;
382 01f4895c Michael Niedermayer
                stream->lpcm_align = st->codec->channels * 2;
383 044007c2 Fabrice Bellard
            } else {
384 de6d9b64 Fabrice Bellard
                stream->id = mpa_id++;
385 044007c2 Fabrice Bellard
            }
386 22494489 Hauke Duden
387
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
388
               Right now it is also used for everything else.*/
389 de6d9b64 Fabrice Bellard
            stream->max_buffer_size = 4 * 1024; 
390
            s->audio_bound++;
391
            break;
392
        case CODEC_TYPE_VIDEO:
393
            stream->id = mpv_id++;
394 01f4895c Michael Niedermayer
            if (st->codec->rc_buffer_size)
395
                stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
396 7e051558 Michael Niedermayer
            else
397
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
398
#if 0
399 22494489 Hauke Duden
                /* see VCD standard, p. IV-7*/
400
                stream->max_buffer_size = 46 * 1024; 
401
            else
402
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
403
                   Right now it is also used for everything else.*/
404
                stream->max_buffer_size = 230 * 1024; 
405 7e051558 Michael Niedermayer
#endif
406 de6d9b64 Fabrice Bellard
            s->video_bound++;
407
            break;
408 9ba73f1f Aurelien Jacobs
        case CODEC_TYPE_SUBTITLE:
409
            stream->id = mps_id++;
410
            stream->max_buffer_size = 16 * 1024;
411
            break;
412 ac5e6a5b Philip Gladstone
        default:
413 71c32f19 Michael Niedermayer
            return -1;
414 de6d9b64 Fabrice Bellard
        }
415 0d712409 Michael Niedermayer
        fifo_init(&stream->fifo, 16);
416 de6d9b64 Fabrice Bellard
    }
417 24515926 Hauke Duden
    bitrate = 0;
418
    audio_bitrate = 0;
419
    video_bitrate = 0;
420 de6d9b64 Fabrice Bellard
    for(i=0;i<ctx->nb_streams;i++) {
421 7000a175 Michael Niedermayer
        int codec_rate;
422 de6d9b64 Fabrice Bellard
        st = ctx->streams[i];
423 24515926 Hauke Duden
        stream = (StreamInfo*) st->priv_data;
424 7000a175 Michael Niedermayer
425 01f4895c Michael Niedermayer
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
426
            codec_rate= st->codec->rc_max_rate;
427 7000a175 Michael Niedermayer
        else
428 01f4895c Michael Niedermayer
            codec_rate= st->codec->bit_rate;
429 7000a175 Michael Niedermayer
                
430
        if(!codec_rate)
431
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
432
            
433
        bitrate += codec_rate;
434 24515926 Hauke Duden
435
        if (stream->id==AUDIO_ID)
436 7000a175 Michael Niedermayer
            audio_bitrate += codec_rate;
437 24515926 Hauke Duden
        else if (stream->id==VIDEO_ID)
438 7000a175 Michael Niedermayer
            video_bitrate += codec_rate;
439 24515926 Hauke Duden
    }
440 2db3c638 Michael Niedermayer
    
441
    if(ctx->mux_rate){
442
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
443
    } else {
444
        /* we increase slightly the bitrate to take into account the
445
           headers. XXX: compute it exactly */
446
        bitrate += bitrate*5/100;
447
        bitrate += 10000;
448
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
449
    }
450 24515926 Hauke Duden
451
    if (s->is_vcd) {
452
        double overhead_rate;
453
454
        /* The VCD standard mandates that the mux_rate field is 3528
455
           (see standard p. IV-6).
456
           The value is actually "wrong", i.e. if you calculate
457
           it using the normal formula and the 75 sectors per second transfer
458
           rate you get a different value because the real pack size is 2324,
459
           not 2352. But the standard explicitly specifies that the mux_rate
460
           field in the header must have this value.*/
461 2db3c638 Michael Niedermayer
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
462 24515926 Hauke Duden
463
        /* The VCD standard states that the muxed stream must be
464
           exactly 75 packs / second (the data rate of a single speed cdrom).
465
           Since the video bitrate (probably 1150000 bits/sec) will be below
466
           the theoretical maximum we have to add some padding packets
467
           to make up for the lower data rate.
468
           (cf. VCD standard p. IV-6 )*/
469
470
        /* Add the header overhead to the data rate.
471
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
472
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
473
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
474
        overhead_rate *= 8;
475
        
476
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
477
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
478 de6d9b64 Fabrice Bellard
    }
479 92b3e125 Juanjo
    
480 fb7566d0 Fabrice Bellard
    if (s->is_vcd || s->is_mpeg2)
481 92b3e125 Juanjo
        /* every packet */
482
        s->pack_header_freq = 1;
483
    else
484
        /* every 2 seconds */
485
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
486 b623bbcb Michael Niedermayer
487
    /* the above seems to make pack_header_freq zero sometimes */
488
    if (s->pack_header_freq == 0)
489
       s->pack_header_freq = 1;
490 92b3e125 Juanjo
    
491 b2cac184 Fabrice Bellard
    if (s->is_mpeg2)
492
        /* every 200 packets. Need to look at the spec.  */
493
        s->system_header_freq = s->pack_header_freq * 40;
494
    else if (s->is_vcd)
495 24515926 Hauke Duden
        /* the standard mandates that there are only two system headers
496
           in the whole file: one in the first packet of each stream.
497
           (see standard p. IV-7 and IV-8) */
498
        s->system_header_freq = 0x7fffffff;
499 92b3e125 Juanjo
    else
500
        s->system_header_freq = s->pack_header_freq * 5;
501
    
502 de6d9b64 Fabrice Bellard
    for(i=0;i<ctx->nb_streams;i++) {
503
        stream = ctx->streams[i]->priv_data;
504
        stream->packet_number = 0;
505
    }
506 0dbb48d9 Fabrice Bellard
    s->system_header_size = get_system_header_size(ctx);
507 27a206e0 Michel Bardiaux
    s->last_scr = 0;
508 de6d9b64 Fabrice Bellard
    return 0;
509
 fail:
510
    for(i=0;i<ctx->nb_streams;i++) {
511 1ea4f593 Fabrice Bellard
        av_free(ctx->streams[i]->priv_data);
512 de6d9b64 Fabrice Bellard
    }
513
    return -ENOMEM;
514
}
515
516 27a206e0 Michel Bardiaux
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
517
{
518
    put_byte(pb, 
519
             (id << 4) | 
520
             (((timestamp >> 30) & 0x07) << 1) | 
521
             1);
522
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
523
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
524
}
525
526 0dbb48d9 Fabrice Bellard
527 24515926 Hauke Duden
/* return the number of padding bytes that should be inserted into
528
   the multiplexed stream.*/
529
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
530
{
531
    MpegMuxContext *s = ctx->priv_data;
532
    int pad_bytes = 0;
533
534
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
535
    {
536
        int64_t full_pad_bytes;
537
        
538 7000a175 Michael Niedermayer
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
539 24515926 Hauke Duden
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
540
541
        if (pad_bytes<0)
542
            /* might happen if we have already padded to a later timestamp. This
543
               can occur if another stream has already advanced further.*/
544
            pad_bytes=0;
545
    }
546
547
    return pad_bytes;
548
}
549
550
551 88730be6 Måns Rullgård
#if 0 /* unused, remove? */
552 0dbb48d9 Fabrice Bellard
/* return the exact available payload size for the next packet for
553
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
554
   timestamps are needed in the packet header. */
555
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
556
                                   int64_t pts, int64_t dts)
557
{
558
    MpegMuxContext *s = ctx->priv_data;
559
    int buf_index;
560
    StreamInfo *stream;
561

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

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

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

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

609
        } else {
610
            if (!s->is_mpeg2)
611
                buf_index++;
612
        }
613
    
614
        if (stream->id < 0xc0) {
615
            /* AC3/LPCM private data header */
616
            buf_index += 4;
617
            if (stream->id >= 0xa0) {
618
                int n;
619
                buf_index += 3;
620
                /* NOTE: we round the payload size to an integer number of
621
                   LPCM samples */
622
                n = (s->packet_size - buf_index) % stream->lpcm_align;
623
                if (n)
624
                    buf_index += (stream->lpcm_align - n);
625
            }
626 044007c2 Fabrice Bellard
        }
627 24515926 Hauke Duden

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

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

1023 24515926 Hauke Duden
    return scr;
1024
}    
1025 88730be6 Måns Rullgård
#endif
1026 24515926 Hauke Duden
1027 7000a175 Michael Niedermayer
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1028
//    MpegMuxContext *s = ctx->priv_data;
1029
    int i;
1030
1031
    for(i=0; i<ctx->nb_streams; i++){
1032
        AVStream *st = ctx->streams[i];
1033
        StreamInfo *stream = st->priv_data;
1034
        PacketDesc *pkt_desc= stream->predecode_packet;
1035
        
1036
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1037
            if(stream->buffer_index < pkt_desc->size || 
1038
               stream->predecode_packet == stream->premux_packet){
1039
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1040
                break;
1041
            }
1042
            stream->buffer_index -= pkt_desc->size;
1043
1044
            stream->predecode_packet= pkt_desc->next;
1045
            av_freep(&pkt_desc);
1046
        }
1047
    }
1048
    
1049
    return 0;
1050
}
1051
1052
static int output_packet(AVFormatContext *ctx, int flush){
1053
    MpegMuxContext *s = ctx->priv_data;
1054
    AVStream *st;
1055
    StreamInfo *stream;
1056
    int i, avail_space, es_size, trailer_size;
1057
    int best_i= -1;
1058
    int best_score= INT_MIN;
1059
    int ignore_constraints=0;
1060
    int64_t scr= s->last_scr;
1061 bc3429e3 Michael Niedermayer
    PacketDesc *timestamp_packet;
1062 17c88cb0 Michael Niedermayer
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1063 7000a175 Michael Niedermayer
1064
retry:
1065
    for(i=0; i<ctx->nb_streams; i++){
1066
        AVStream *st = ctx->streams[i];
1067
        StreamInfo *stream = st->priv_data;
1068
        const int avail_data=  fifo_size(&stream->fifo, stream->fifo.rptr);
1069
        const int space= stream->max_buffer_size - stream->buffer_index;
1070
        int rel_space= 1024*space / stream->max_buffer_size;
1071 17c88cb0 Michael Niedermayer
        PacketDesc *next_pkt= stream->premux_packet;
1072 7000a175 Michael Niedermayer
1073 9ba73f1f Aurelien Jacobs
        /* for subtitle, a single PES packet must be generated,
1074
           so we flush after every single subtitle packet */
1075
        if(s->packet_size > avail_data && !flush
1076 01f4895c Michael Niedermayer
           && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1077 7000a175 Michael Niedermayer
            return 0;
1078
        if(avail_data==0)
1079
            continue;
1080
        assert(avail_data>0);
1081
1082
        if(space < s->packet_size && !ignore_constraints)
1083
            continue;
1084
            
1085 17c88cb0 Michael Niedermayer
        if(next_pkt && next_pkt->dts - scr > max_delay)
1086
            continue;
1087
            
1088 7000a175 Michael Niedermayer
        if(rel_space > best_score){
1089
            best_score= rel_space;
1090
            best_i = i;
1091
            avail_space= space;
1092
        }
1093
    }
1094
    
1095
    if(best_i < 0){
1096
        int64_t best_dts= INT64_MAX;
1097
1098
        for(i=0; i<ctx->nb_streams; i++){
1099
            AVStream *st = ctx->streams[i];
1100
            StreamInfo *stream = st->priv_data;
1101
            PacketDesc *pkt_desc= stream->predecode_packet;
1102
            if(pkt_desc && pkt_desc->dts < best_dts)
1103
                best_dts= pkt_desc->dts;
1104
        }
1105
1106
#if 0
1107
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n", 
1108
               scr/90000.0, best_dts/90000.0);
1109
#endif
1110
        if(best_dts == INT64_MAX)
1111
            return 0;
1112
1113
        if(scr >= best_dts+1 && !ignore_constraints){
1114
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1115
            ignore_constraints= 1;
1116
        }
1117
        scr= FFMAX(best_dts+1, scr);
1118
        if(remove_decoded_packets(ctx, scr) < 0)
1119
            return -1;
1120
        goto retry;
1121
    }
1122
1123
    assert(best_i >= 0);
1124
    
1125
    st = ctx->streams[best_i];
1126
    stream = st->priv_data;
1127
    
1128
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
1129
1130
    assert(avail_space >= s->packet_size || ignore_constraints);
1131
    
1132 bc3429e3 Michael Niedermayer
    timestamp_packet= stream->premux_packet;
1133
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
1134 7000a175 Michael Niedermayer
        trailer_size= 0;
1135 bc3429e3 Michael Niedermayer
    }else{
1136
        trailer_size= timestamp_packet->unwritten_size;
1137
        timestamp_packet= timestamp_packet->next;
1138
    }
1139 7000a175 Michael Niedermayer
1140 bc3429e3 Michael Niedermayer
    if(timestamp_packet){
1141 2db3c638 Michael Niedermayer
//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f scr:%f stream:%d\n", timestamp_packet->dts/90000.0, timestamp_packet->pts/90000.0, scr/90000.0, best_i);
1142 bc3429e3 Michael Niedermayer
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1143
    }else{
1144
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == trailer_size);
1145
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1146
    }
1147 7000a175 Michael Niedermayer
1148
    if (s->is_vcd) {
1149
        /* Write one or more padding sectors, if necessary, to reach
1150
           the constant overall bitrate.*/
1151
        int vcd_pad_bytes;
1152
1153 92050933 Michael Niedermayer
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1154 7000a175 Michael Niedermayer
            put_vcd_padding_sector(ctx);
1155
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1156
        }
1157
    }
1158
    
1159
    stream->buffer_index += es_size;
1160
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1161
    
1162
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1163
        es_size -= stream->premux_packet->unwritten_size;
1164
        stream->premux_packet= stream->premux_packet->next;
1165
    }
1166
    if(es_size)
1167
        stream->premux_packet->unwritten_size -= es_size;
1168
    
1169
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1170
        return -1;
1171
1172
    return 1;
1173
}
1174 24515926 Hauke Duden
1175 e928649b Michael Niedermayer
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1176 de6d9b64 Fabrice Bellard
{
1177
    MpegMuxContext *s = ctx->priv_data;
1178 e928649b Michael Niedermayer
    int stream_index= pkt->stream_index;
1179
    int size= pkt->size;
1180
    uint8_t *buf= pkt->data;
1181 de6d9b64 Fabrice Bellard
    AVStream *st = ctx->streams[stream_index];
1182
    StreamInfo *stream = st->priv_data;
1183 92050933 Michael Niedermayer
    int64_t pts, dts;
1184 7000a175 Michael Niedermayer
    PacketDesc *pkt_desc;
1185 17c88cb0 Michael Niedermayer
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1186 01f4895c Michael Niedermayer
    const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1187 24515926 Hauke Duden
    
1188 e928649b Michael Niedermayer
    pts= pkt->pts;
1189
    dts= pkt->dts;
1190 e45f1943 Fabrice Bellard
1191 17c88cb0 Michael Niedermayer
    if(pts != AV_NOPTS_VALUE) pts += preload;
1192
    if(dts != AV_NOPTS_VALUE) dts += preload;
1193
1194 6c55b27f Michael Niedermayer
//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index, pts != AV_NOPTS_VALUE);
1195 9ba73f1f Aurelien Jacobs
    if (!stream->premux_packet)
1196
        stream->next_packet = &stream->premux_packet;
1197 7000a175 Michael Niedermayer
    *stream->next_packet=
1198
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1199
    pkt_desc->pts= pts;
1200
    pkt_desc->dts= dts;
1201
    pkt_desc->unwritten_size=
1202
    pkt_desc->size= size;
1203
    if(!stream->predecode_packet)
1204
        stream->predecode_packet= pkt_desc;
1205
    stream->next_packet= &pkt_desc->next;
1206
1207 20b02bc6 Chriss
    fifo_realloc(&stream->fifo, fifo_size(&stream->fifo, NULL) + size + 1);
1208
1209 cbb6e405 Michael Niedermayer
    if (s->is_dvd){
1210 7be806f3 Chriss
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1211 cbb6e405 Michael Niedermayer
            stream->fifo_iframe_ptr = stream->fifo.wptr;
1212
            stream->align_iframe = 1;
1213 7be806f3 Chriss
            stream->vobu_start_pts = pts;
1214 cbb6e405 Michael Niedermayer
        } else {
1215
            stream->align_iframe = 0;
1216
        }
1217
    }
1218
1219 7000a175 Michael Niedermayer
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1220 24515926 Hauke Duden
1221 7000a175 Michael Niedermayer
    for(;;){
1222
        int ret= output_packet(ctx, 0);
1223 92050933 Michael Niedermayer
        if(ret<=0) 
1224 7000a175 Michael Niedermayer
            return ret;
1225 0dbb48d9 Fabrice Bellard
    }
1226 de6d9b64 Fabrice Bellard
}
1227
1228
static int mpeg_mux_end(AVFormatContext *ctx)
1229
{
1230 7000a175 Michael Niedermayer
//    MpegMuxContext *s = ctx->priv_data;
1231 de6d9b64 Fabrice Bellard
    StreamInfo *stream;
1232
    int i;
1233 7000a175 Michael Niedermayer
    
1234
    for(;;){
1235
        int ret= output_packet(ctx, 1);
1236
        if(ret<0) 
1237
            return ret;
1238
        else if(ret==0)
1239
            break;
1240 de6d9b64 Fabrice Bellard
    }
1241
1242 fa0f62c3 Fabrice Bellard
    /* End header according to MPEG1 systems standard. We do not write
1243
       it as it is usually not needed by decoders and because it
1244
       complicates MPEG stream concatenation. */
1245 92b3e125 Juanjo
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1246
    //put_flush_packet(&ctx->pb);
1247 9d90c37f Michael Niedermayer
1248 7000a175 Michael Niedermayer
    for(i=0;i<ctx->nb_streams;i++) {
1249
        stream = ctx->streams[i]->priv_data;
1250
1251
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1252
        fifo_free(&stream->fifo);
1253
    }
1254 de6d9b64 Fabrice Bellard
    return 0;
1255
}
1256 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
1257 de6d9b64 Fabrice Bellard
1258
/*********************************************/
1259
/* demux code */
1260
1261
#define MAX_SYNC_SIZE 100000
1262
1263 db7f1f95 Fabrice Bellard
static int mpegps_probe(AVProbeData *p)
1264
{
1265 95f97de1 Michael Niedermayer
    int i;
1266
    int size= FFMIN(20, p->buf_size);
1267
    uint32_t code=0xFF;
1268 db7f1f95 Fabrice Bellard
1269
    /* we search the first start code. If it is a packet start code,
1270
       then we decide it is mpeg ps. We do not send highest value to
1271
       give a chance to mpegts */
1272 fa777321 Fabrice Bellard
    /* NOTE: the search range was restricted to avoid too many false
1273
       detections */
1274
1275 95f97de1 Michael Niedermayer
    for (i = 0; i < size; i++) {
1276
        code = (code << 8) | p->buf[i];
1277 ec23a472 Isaac Richards
        if ((code & 0xffffff00) == 0x100) {
1278
            if (code == PACK_START_CODE ||
1279
                code == SYSTEM_HEADER_START_CODE ||
1280
                (code >= 0x1e0 && code <= 0x1ef) ||
1281
                (code >= 0x1c0 && code <= 0x1df) ||
1282
                code == PRIVATE_STREAM_2 ||
1283
                code == PROGRAM_STREAM_MAP ||
1284
                code == PRIVATE_STREAM_1 ||
1285
                code == PADDING_STREAM)
1286 149f7c02 Michael Niedermayer
                return AVPROBE_SCORE_MAX - 2;
1287 ec23a472 Isaac Richards
            else
1288
                return 0;
1289
        }
1290 db7f1f95 Fabrice Bellard
    }
1291
    return 0;
1292
}
1293
1294
1295 de6d9b64 Fabrice Bellard
typedef struct MpegDemuxContext {
1296
    int header_state;
1297 e3d1cd8e Måns Rullgård
    unsigned char psm_es_type[256];
1298 de6d9b64 Fabrice Bellard
} MpegDemuxContext;
1299
1300 27f388aa Fabrice Bellard
static int mpegps_read_header(AVFormatContext *s,
1301
                              AVFormatParameters *ap)
1302
{
1303
    MpegDemuxContext *m = s->priv_data;
1304
    m->header_state = 0xff;
1305
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1306
1307
    /* no need to do more */
1308
    return 0;
1309
}
1310
1311
static int64_t get_pts(ByteIOContext *pb, int c)
1312
{
1313
    int64_t pts;
1314
    int val;
1315
1316
    if (c < 0)
1317
        c = get_byte(pb);
1318
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1319
    val = get_be16(pb);
1320
    pts |= (int64_t)(val >> 1) << 15;
1321
    val = get_be16(pb);
1322
    pts |= (int64_t)(val >> 1);
1323
    return pts;
1324
}
1325
1326
static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1327
                                uint32_t *header_state)
1328 de6d9b64 Fabrice Bellard
{
1329
    unsigned int state, v;
1330
    int val, n;
1331
1332
    state = *header_state;
1333
    n = *size_ptr;
1334
    while (n > 0) {
1335
        if (url_feof(pb))
1336
            break;
1337
        v = get_byte(pb);
1338
        n--;
1339
        if (state == 0x000001) {
1340
            state = ((state << 8) | v) & 0xffffff;
1341
            val = state;
1342
            goto found;
1343
        }
1344
        state = ((state << 8) | v) & 0xffffff;
1345
    }
1346
    val = -1;
1347
 found:
1348
    *header_state = state;
1349
    *size_ptr = n;
1350
    return val;
1351
}
1352
1353 88730be6 Måns Rullgård
#if 0 /* unused, remove? */
1354 27f388aa Fabrice Bellard
/* XXX: optimize */
1355
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1356 de6d9b64 Fabrice Bellard
{
1357 27f388aa Fabrice Bellard
    int64_t pos, pos_start;
1358
    int max_size, start_code;
1359 da24c5e3 Fabrice Bellard

1360 27f388aa Fabrice Bellard
    max_size = *size_ptr;
1361
    pos_start = url_ftell(pb);
1362 de6d9b64 Fabrice Bellard

1363 27f388aa Fabrice Bellard
    /* in order to go faster, we fill the buffer */
1364
    pos = pos_start - 16386;
1365
    if (pos < 0)
1366
        pos = 0;
1367
    url_fseek(pb, pos, SEEK_SET);
1368
    get_byte(pb);
1369 de6d9b64 Fabrice Bellard

1370 27f388aa Fabrice Bellard
    pos = pos_start;
1371
    for(;;) {
1372
        pos--;
1373
        if (pos < 0 || (pos_start - pos) >= max_size) {
1374
            start_code = -1;
1375
            goto the_end;
1376
        }
1377
        url_fseek(pb, pos, SEEK_SET);
1378
        start_code = get_be32(pb);
1379
        if ((start_code & 0xffffff00) == 0x100)
1380
            break;
1381
    }
1382
 the_end:
1383
    *size_ptr = pos_start - pos;
1384
    return start_code;
1385 de6d9b64 Fabrice Bellard
}
1386 88730be6 Måns Rullgård
#endif
1387 de6d9b64 Fabrice Bellard
1388 e3d1cd8e Måns Rullgård
/**
1389
 * Extracts stream types from a program stream map
1390
 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1391
 * 
1392
 * @return number of bytes occupied by PSM in the bitstream
1393
 */
1394
static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1395
{
1396
    int psm_length, ps_info_length, es_map_length;
1397
1398
    psm_length = get_be16(pb);
1399
    get_byte(pb);
1400
    get_byte(pb);
1401
    ps_info_length = get_be16(pb);
1402
1403
    /* skip program_stream_info */
1404
    url_fskip(pb, ps_info_length);
1405
    es_map_length = get_be16(pb);
1406
1407
    /* at least one es available? */
1408
    while (es_map_length >= 4){
1409
        unsigned char type = get_byte(pb);
1410
        unsigned char es_id = get_byte(pb);
1411
        uint16_t es_info_length = get_be16(pb);
1412
        /* remember mapping from stream id to stream type */
1413
        m->psm_es_type[es_id] = type;
1414
        /* skip program_stream_info */
1415
        url_fskip(pb, es_info_length);
1416
        es_map_length -= 4 + es_info_length;
1417
    }
1418
    get_be32(pb); /* crc32 */
1419
    return 2 + psm_length;
1420
}
1421
1422 8d14a25c Michael Niedermayer
/* read the next PES header. Return its position in ppos 
1423 27f388aa Fabrice Bellard
   (if not NULL), and its start code, pts and dts.
1424
 */
1425
static int mpegps_read_pes_header(AVFormatContext *s,
1426
                                  int64_t *ppos, int *pstart_code, 
1427 8d14a25c Michael Niedermayer
                                  int64_t *ppts, int64_t *pdts)
1428 de6d9b64 Fabrice Bellard
{
1429
    MpegDemuxContext *m = s->priv_data;
1430 27f388aa Fabrice Bellard
    int len, size, startcode, c, flags, header_len;
1431
    int64_t pts, dts, last_pos;
1432 de6d9b64 Fabrice Bellard
1433 27f388aa Fabrice Bellard
    last_pos = -1;
1434 de6d9b64 Fabrice Bellard
 redo:
1435 27f388aa Fabrice Bellard
        /* next start code (should be immediately after) */
1436
        m->header_state = 0xff;
1437
        size = MAX_SYNC_SIZE;
1438
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1439 001e3f55 Juanjo
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1440 de6d9b64 Fabrice Bellard
    if (startcode < 0)
1441 0bd586c5 Mike Melanson
        return AVERROR_IO;
1442 de6d9b64 Fabrice Bellard
    if (startcode == PACK_START_CODE)
1443
        goto redo;
1444
    if (startcode == SYSTEM_HEADER_START_CODE)
1445
        goto redo;
1446
    if (startcode == PADDING_STREAM ||
1447
        startcode == PRIVATE_STREAM_2) {
1448
        /* skip them */
1449
        len = get_be16(&s->pb);
1450
        url_fskip(&s->pb, len);
1451
        goto redo;
1452
    }
1453 e3d1cd8e Måns Rullgård
    if (startcode == PROGRAM_STREAM_MAP) {
1454
        mpegps_psm_parse(m, &s->pb);
1455
        goto redo;
1456
    }
1457
    
1458 de6d9b64 Fabrice Bellard
    /* find matching stream */
1459
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1460
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1461
          (startcode == 0x1bd)))
1462
        goto redo;
1463 27f388aa Fabrice Bellard
    if (ppos) {
1464
        *ppos = url_ftell(&s->pb) - 4;
1465
    }
1466 de6d9b64 Fabrice Bellard
    len = get_be16(&s->pb);
1467 b2cac184 Fabrice Bellard
    pts = AV_NOPTS_VALUE;
1468
    dts = AV_NOPTS_VALUE;
1469 de6d9b64 Fabrice Bellard
    /* stuffing */
1470
    for(;;) {
1471 27f388aa Fabrice Bellard
        if (len < 1)
1472
            goto redo;
1473 de6d9b64 Fabrice Bellard
        c = get_byte(&s->pb);
1474
        len--;
1475
        /* XXX: for mpeg1, should test only bit 7 */
1476
        if (c != 0xff) 
1477
            break;
1478
    }
1479
    if ((c & 0xc0) == 0x40) {
1480
        /* buffer scale & size */
1481 27f388aa Fabrice Bellard
        if (len < 2)
1482
            goto redo;
1483 de6d9b64 Fabrice Bellard
        get_byte(&s->pb);
1484
        c = get_byte(&s->pb);
1485
        len -= 2;
1486
    }
1487
    if ((c & 0xf0) == 0x20) {
1488 27f388aa Fabrice Bellard
        if (len < 4)
1489
            goto redo;
1490
        dts = pts = get_pts(&s->pb, c);
1491 de6d9b64 Fabrice Bellard
        len -= 4;
1492
    } else if ((c & 0xf0) == 0x30) {
1493 27f388aa Fabrice Bellard
        if (len < 9)
1494
            goto redo;
1495 de6d9b64 Fabrice Bellard
        pts = get_pts(&s->pb, c);
1496
        dts = get_pts(&s->pb, -1);
1497
        len -= 9;
1498
    } else if ((c & 0xc0) == 0x80) {
1499
        /* mpeg 2 PES */
1500
        if ((c & 0x30) != 0) {
1501 27f388aa Fabrice Bellard
            /* Encrypted multiplex not handled */
1502
            goto redo;
1503 de6d9b64 Fabrice Bellard
        }
1504
        flags = get_byte(&s->pb);
1505
        header_len = get_byte(&s->pb);
1506
        len -= 2;
1507
        if (header_len > len)
1508
            goto redo;
1509 1e5c667c Fabrice Bellard
        if ((flags & 0xc0) == 0x80) {
1510 27f388aa Fabrice Bellard
            dts = pts = get_pts(&s->pb, -1);
1511
            if (header_len < 5)
1512
                goto redo;
1513 de6d9b64 Fabrice Bellard
            header_len -= 5;
1514
            len -= 5;
1515
        } if ((flags & 0xc0) == 0xc0) {
1516
            pts = get_pts(&s->pb, -1);
1517
            dts = get_pts(&s->pb, -1);
1518 27f388aa Fabrice Bellard
            if (header_len < 10)
1519
                goto redo;
1520 de6d9b64 Fabrice Bellard
            header_len -= 10;
1521
            len -= 10;
1522
        }
1523
        len -= header_len;
1524
        while (header_len > 0) {
1525
            get_byte(&s->pb);
1526
            header_len--;
1527
        }
1528
    }
1529 df70de1f Dmitry Borisov
    else if( c!= 0xf )
1530
        goto redo;
1531
1532 e3d1cd8e Måns Rullgård
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1533 27f388aa Fabrice Bellard
        if (len < 1)
1534
            goto redo;
1535 de6d9b64 Fabrice Bellard
        startcode = get_byte(&s->pb);
1536
        len--;
1537
        if (startcode >= 0x80 && startcode <= 0xbf) {
1538
            /* audio: skip header */
1539 27f388aa Fabrice Bellard
            if (len < 3)
1540
                goto redo;
1541 de6d9b64 Fabrice Bellard
            get_byte(&s->pb);
1542
            get_byte(&s->pb);
1543
            get_byte(&s->pb);
1544
            len -= 3;
1545
        }
1546
    }
1547 b754978a Michael Niedermayer
    if(dts != AV_NOPTS_VALUE && ppos){
1548
        int i;
1549
        for(i=0; i<s->nb_streams; i++){
1550
            if(startcode == s->streams[i]->id) {
1551 27a5fe5f Michael Niedermayer
                av_add_index_entry(s->streams[i], *ppos, dts, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1552 b754978a Michael Niedermayer
            }
1553
        }
1554
    }
1555
    
1556 27f388aa Fabrice Bellard
    *pstart_code = startcode;
1557
    *ppts = pts;
1558
    *pdts = dts;
1559
    return len;
1560
}
1561
1562
static int mpegps_read_packet(AVFormatContext *s,
1563
                              AVPacket *pkt)
1564
{
1565 e3d1cd8e Måns Rullgård
    MpegDemuxContext *m = s->priv_data;
1566 27f388aa Fabrice Bellard
    AVStream *st;
1567 e3d1cd8e Måns Rullgård
    int len, startcode, i, type, codec_id = 0, es_type;
1568 b754978a Michael Niedermayer
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1569 27f388aa Fabrice Bellard
1570
 redo:
1571 8d14a25c Michael Niedermayer
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1572 27f388aa Fabrice Bellard
    if (len < 0)
1573
        return len;
1574 27a206e0 Michel Bardiaux
    
1575 de6d9b64 Fabrice Bellard
    /* now find stream */
1576
    for(i=0;i<s->nb_streams;i++) {
1577
        st = s->streams[i];
1578
        if (st->id == startcode)
1579
            goto found;
1580
    }
1581 e3d1cd8e Måns Rullgård
1582
    es_type = m->psm_es_type[startcode & 0xff];
1583
    if(es_type > 0){
1584
        if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1585
            codec_id = CODEC_ID_MPEG2VIDEO;
1586
            type = CODEC_TYPE_VIDEO;
1587
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1588
            codec_id = CODEC_ID_MPEG2VIDEO;
1589
            type = CODEC_TYPE_VIDEO;
1590
        } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1591
                  es_type == STREAM_TYPE_AUDIO_MPEG2){
1592
            codec_id = CODEC_ID_MP3;
1593
            type = CODEC_TYPE_AUDIO;
1594
        } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1595
            codec_id = CODEC_ID_AAC;
1596
            type = CODEC_TYPE_AUDIO;
1597
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1598
            codec_id = CODEC_ID_MPEG4;
1599
            type = CODEC_TYPE_VIDEO;
1600
        } else if(es_type == STREAM_TYPE_VIDEO_H264){
1601
            codec_id = CODEC_ID_H264;
1602
            type = CODEC_TYPE_VIDEO;
1603
        } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1604
            codec_id = CODEC_ID_AC3;
1605
            type = CODEC_TYPE_AUDIO;
1606
        } else {
1607
            goto skip;
1608
        }
1609
    } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1610 db7f1f95 Fabrice Bellard
        type = CODEC_TYPE_VIDEO;
1611 0dbb48d9 Fabrice Bellard
        codec_id = CODEC_ID_MPEG2VIDEO;
1612 db7f1f95 Fabrice Bellard
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1613
        type = CODEC_TYPE_AUDIO;
1614
        codec_id = CODEC_ID_MP2;
1615 3f2bf07b Joakim Plate
    } else if (startcode >= 0x80 && startcode <= 0x87) {
1616 db7f1f95 Fabrice Bellard
        type = CODEC_TYPE_AUDIO;
1617
        codec_id = CODEC_ID_AC3;
1618 3f2bf07b Joakim Plate
    } else if (startcode >= 0x88 && startcode <= 0x9f) {
1619 23c99253 Michael Niedermayer
        type = CODEC_TYPE_AUDIO;
1620
        codec_id = CODEC_ID_DTS;
1621 9ec05e36 Fabrice Bellard
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1622
        type = CODEC_TYPE_AUDIO;
1623
        codec_id = CODEC_ID_PCM_S16BE;
1624 a9c3213f Fabrice Bellard
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
1625
        type = CODEC_TYPE_SUBTITLE;
1626
        codec_id = CODEC_ID_DVD_SUBTITLE;
1627 db7f1f95 Fabrice Bellard
    } else {
1628
    skip:
1629
        /* skip packet */
1630
        url_fskip(&s->pb, len);
1631
        goto redo;
1632
    }
1633 1e5c667c Fabrice Bellard
    /* no stream found: add a new stream */
1634
    st = av_new_stream(s, startcode);
1635
    if (!st) 
1636
        goto skip;
1637 01f4895c Michael Niedermayer
    st->codec->codec_type = type;
1638
    st->codec->codec_id = codec_id;
1639 27f388aa Fabrice Bellard
    if (codec_id != CODEC_ID_PCM_S16BE)
1640
        st->need_parsing = 1;
1641 de6d9b64 Fabrice Bellard
 found:
1642 f3356e9c Michael Niedermayer
    if(st->discard >= AVDISCARD_ALL)
1643 b9866ebc Michael Niedermayer
        goto skip;
1644 9ec05e36 Fabrice Bellard
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1645
        int b1, freq;
1646
1647
        /* for LPCM, we just skip the header and consider it is raw
1648
           audio data */
1649
        if (len <= 3)
1650
            goto skip;
1651
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1652
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1653
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1654
        len -= 3;
1655
        freq = (b1 >> 4) & 3;
1656 01f4895c Michael Niedermayer
        st->codec->sample_rate = lpcm_freq_tab[freq];
1657
        st->codec->channels = 1 + (b1 & 7);
1658
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1659 9ec05e36 Fabrice Bellard
    }
1660 de6d9b64 Fabrice Bellard
    av_new_packet(pkt, len);
1661
    get_buffer(&s->pb, pkt->data, pkt->size);
1662
    pkt->pts = pts;
1663 27f388aa Fabrice Bellard
    pkt->dts = dts;
1664 db7f1f95 Fabrice Bellard
    pkt->stream_index = st->index;
1665 27a206e0 Michel Bardiaux
#if 0
1666 b9866ebc Michael Niedermayer
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1667
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1668 27a206e0 Michel Bardiaux
#endif
1669 0bd586c5 Mike Melanson
1670 de6d9b64 Fabrice Bellard
    return 0;
1671
}
1672
1673 db7f1f95 Fabrice Bellard
static int mpegps_read_close(AVFormatContext *s)
1674 de6d9b64 Fabrice Bellard
{
1675
    return 0;
1676
}
1677
1678 27f388aa Fabrice Bellard
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1679 8d14a25c Michael Niedermayer
                               int64_t *ppos, int64_t pos_limit)
1680 27f388aa Fabrice Bellard
{
1681
    int len, startcode;
1682
    int64_t pos, pts, dts;
1683
1684
    pos = *ppos;
1685
#ifdef DEBUG_SEEK
1686
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1687
#endif
1688
    url_fseek(&s->pb, pos, SEEK_SET);
1689
    for(;;) {
1690 8d14a25c Michael Niedermayer
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1691 27f388aa Fabrice Bellard
        if (len < 0) {
1692
#ifdef DEBUG_SEEK
1693
            printf("none (ret=%d)\n", len);
1694
#endif
1695
            return AV_NOPTS_VALUE;
1696
        }
1697
        if (startcode == s->streams[stream_index]->id && 
1698
            dts != AV_NOPTS_VALUE) {
1699
            break;
1700
        }
1701 8d14a25c Michael Niedermayer
        url_fskip(&s->pb, len);
1702 27f388aa Fabrice Bellard
    }
1703
#ifdef DEBUG_SEEK
1704
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1705
#endif
1706
    *ppos = pos;
1707 cdd5034f Michael Niedermayer
    return dts;
1708 27f388aa Fabrice Bellard
}
1709
1710 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
1711 fb7566d0 Fabrice Bellard
static AVOutputFormat mpeg1system_mux = {
1712 de6d9b64 Fabrice Bellard
    "mpeg",
1713 fb7566d0 Fabrice Bellard
    "MPEG1 System format",
1714 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1715 fb7566d0 Fabrice Bellard
    "mpg,mpeg",
1716
    sizeof(MpegMuxContext),
1717
    CODEC_ID_MP2,
1718
    CODEC_ID_MPEG1VIDEO,
1719
    mpeg_mux_init,
1720
    mpeg_mux_write_packet,
1721
    mpeg_mux_end,
1722
};
1723
1724
static AVOutputFormat mpeg1vcd_mux = {
1725
    "vcd",
1726
    "MPEG1 System format (VCD)",
1727 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1728 fb7566d0 Fabrice Bellard
    NULL,
1729
    sizeof(MpegMuxContext),
1730
    CODEC_ID_MP2,
1731
    CODEC_ID_MPEG1VIDEO,
1732
    mpeg_mux_init,
1733
    mpeg_mux_write_packet,
1734
    mpeg_mux_end,
1735
};
1736
1737
static AVOutputFormat mpeg2vob_mux = {
1738
    "vob",
1739
    "MPEG2 PS format (VOB)",
1740 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1741 fb7566d0 Fabrice Bellard
    "vob",
1742 db7f1f95 Fabrice Bellard
    sizeof(MpegMuxContext),
1743 de6d9b64 Fabrice Bellard
    CODEC_ID_MP2,
1744 0dbb48d9 Fabrice Bellard
    CODEC_ID_MPEG2VIDEO,
1745 de6d9b64 Fabrice Bellard
    mpeg_mux_init,
1746
    mpeg_mux_write_packet,
1747
    mpeg_mux_end,
1748 db7f1f95 Fabrice Bellard
};
1749 24515926 Hauke Duden
1750
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1751
static AVOutputFormat mpeg2svcd_mux = {
1752
    "svcd",
1753
    "MPEG2 PS format (VOB)",
1754
    "video/mpeg",
1755
    "vob",
1756
    sizeof(MpegMuxContext),
1757
    CODEC_ID_MP2,
1758
    CODEC_ID_MPEG2VIDEO,
1759
    mpeg_mux_init,
1760
    mpeg_mux_write_packet,
1761
    mpeg_mux_end,
1762
};
1763
1764 78a0efb4 Paul Curtis
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1765
static AVOutputFormat mpeg2dvd_mux = {
1766
    "dvd",
1767
    "MPEG2 PS format (DVD VOB)",
1768
    "video/mpeg",
1769
    "dvd",
1770
    sizeof(MpegMuxContext),
1771
    CODEC_ID_MP2,
1772
    CODEC_ID_MPEG2VIDEO,
1773
    mpeg_mux_init,
1774
    mpeg_mux_write_packet,
1775
    mpeg_mux_end,
1776
};
1777 24515926 Hauke Duden
1778 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
1779 de6d9b64 Fabrice Bellard
1780 32f38cb4 Fabrice Bellard
AVInputFormat mpegps_demux = {
1781 db7f1f95 Fabrice Bellard
    "mpeg",
1782
    "MPEG PS format",
1783
    sizeof(MpegDemuxContext),
1784
    mpegps_probe,
1785
    mpegps_read_header,
1786
    mpegps_read_packet,
1787
    mpegps_read_close,
1788 8d14a25c Michael Niedermayer
    NULL, //mpegps_read_seek,
1789
    mpegps_read_dts,
1790 a9c3213f Fabrice Bellard
    .flags = AVFMT_SHOW_IDS,
1791 de6d9b64 Fabrice Bellard
};
1792 db7f1f95 Fabrice Bellard
1793
int mpegps_init(void)
1794
{
1795 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
1796 fb7566d0 Fabrice Bellard
    av_register_output_format(&mpeg1system_mux);
1797
    av_register_output_format(&mpeg1vcd_mux);
1798
    av_register_output_format(&mpeg2vob_mux);
1799 24515926 Hauke Duden
    av_register_output_format(&mpeg2svcd_mux);
1800 78a0efb4 Paul Curtis
    av_register_output_format(&mpeg2dvd_mux);
1801 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
1802 db7f1f95 Fabrice Bellard
    av_register_input_format(&mpegps_demux);
1803
    return 0;
1804
}