Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 20cd83e2

History | View | Annotate | Download (56.3 KB)

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

565 24515926 Hauke Duden
    stream = ctx->streams[stream_index]->priv_data;
566

567 0dbb48d9 Fabrice Bellard
    buf_index = 0;
568
    if (((s->packet_number % s->pack_header_freq) == 0)) {
569
        /* pack header size */
570 115329f1 Diego Biurrun
        if (s->is_mpeg2)
571 0dbb48d9 Fabrice Bellard
            buf_index += 14;
572
        else
573
            buf_index += 12;
574 115329f1 Diego Biurrun

575 24515926 Hauke Duden
        if (s->is_vcd) {
576
            /* there is exactly one system header for each stream in a VCD MPEG,
577
               One in the very first video packet and one in the very first
578
               audio packet (see VCD standard p. IV-7 and IV-8).*/
579 115329f1 Diego Biurrun

580 24515926 Hauke Duden
            if (stream->packet_number==0)
581
                /* The system headers refer only to the stream they occur in,
582
                   so they have a constant size.*/
583
                buf_index += 15;
584

585 115329f1 Diego Biurrun
        } else {
586 24515926 Hauke Duden
            if ((s->packet_number % s->system_header_freq) == 0)
587
                buf_index += s->system_header_size;
588
        }
589 0dbb48d9 Fabrice Bellard
    }
590

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

612
        } else {
613
            if (!s->is_mpeg2)
614
                buf_index++;
615
        }
616 115329f1 Diego Biurrun

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

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

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

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

1377 27f388aa Fabrice Bellard
    max_size = *size_ptr;
1378
    pos_start = url_ftell(pb);
1379 de6d9b64 Fabrice Bellard

1380 27f388aa Fabrice Bellard
    /* in order to go faster, we fill the buffer */
1381
    pos = pos_start - 16386;
1382
    if (pos < 0)
1383
        pos = 0;
1384
    url_fseek(pb, pos, SEEK_SET);
1385
    get_byte(pb);
1386 de6d9b64 Fabrice Bellard

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