Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ e19fbbec

History | View | Annotate | Download (57.6 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 8fa36ae0 François Revol
    return AVERROR(ENOMEM);
517 de6d9b64 Fabrice Bellard
}
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 aad512b4 Michael Niedermayer
    int pes_ext, ext2_len, id_ext, skip;
1449 e56cfad0 Michael Niedermayer
    int64_t pts, dts;
1450
    int64_t last_sync= url_ftell(&s->pb);
1451 de6d9b64 Fabrice Bellard
1452 e56cfad0 Michael Niedermayer
 error_redo:
1453
        url_fseek(&s->pb, last_sync, SEEK_SET);
1454 de6d9b64 Fabrice Bellard
 redo:
1455 27f388aa Fabrice Bellard
        /* next start code (should be immediately after) */
1456
        m->header_state = 0xff;
1457
        size = MAX_SYNC_SIZE;
1458
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1459 e56cfad0 Michael Niedermayer
        last_sync = url_ftell(&s->pb);
1460 949b1a13 Steve L'Homme
    //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(&s->pb));
1461 de6d9b64 Fabrice Bellard
    if (startcode < 0)
1462 0bd586c5 Mike Melanson
        return AVERROR_IO;
1463 de6d9b64 Fabrice Bellard
    if (startcode == PACK_START_CODE)
1464
        goto redo;
1465
    if (startcode == SYSTEM_HEADER_START_CODE)
1466
        goto redo;
1467
    if (startcode == PADDING_STREAM ||
1468
        startcode == PRIVATE_STREAM_2) {
1469
        /* skip them */
1470
        len = get_be16(&s->pb);
1471
        url_fskip(&s->pb, len);
1472
        goto redo;
1473
    }
1474 e3d1cd8e Måns Rullgård
    if (startcode == PROGRAM_STREAM_MAP) {
1475
        mpegps_psm_parse(m, &s->pb);
1476
        goto redo;
1477
    }
1478 115329f1 Diego Biurrun
1479 de6d9b64 Fabrice Bellard
    /* find matching stream */
1480
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1481
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1482 aad512b4 Michael Niedermayer
          (startcode == 0x1bd) || (startcode == 0x1fd)))
1483 de6d9b64 Fabrice Bellard
        goto redo;
1484 27f388aa Fabrice Bellard
    if (ppos) {
1485
        *ppos = url_ftell(&s->pb) - 4;
1486
    }
1487 de6d9b64 Fabrice Bellard
    len = get_be16(&s->pb);
1488 75a9fbb9 Michael Niedermayer
    pts =
1489 b2cac184 Fabrice Bellard
    dts = AV_NOPTS_VALUE;
1490 de6d9b64 Fabrice Bellard
    /* stuffing */
1491
    for(;;) {
1492 27f388aa Fabrice Bellard
        if (len < 1)
1493 e56cfad0 Michael Niedermayer
            goto error_redo;
1494 de6d9b64 Fabrice Bellard
        c = get_byte(&s->pb);
1495
        len--;
1496
        /* XXX: for mpeg1, should test only bit 7 */
1497 115329f1 Diego Biurrun
        if (c != 0xff)
1498 de6d9b64 Fabrice Bellard
            break;
1499
    }
1500
    if ((c & 0xc0) == 0x40) {
1501
        /* buffer scale & size */
1502
        get_byte(&s->pb);
1503
        c = get_byte(&s->pb);
1504
        len -= 2;
1505
    }
1506 b90ba24b Michael Niedermayer
    if ((c & 0xe0) == 0x20) {
1507 27f388aa Fabrice Bellard
        dts = pts = get_pts(&s->pb, c);
1508 de6d9b64 Fabrice Bellard
        len -= 4;
1509 b90ba24b Michael Niedermayer
        if (c & 0x10){
1510
            dts = get_pts(&s->pb, -1);
1511
            len -= 5;
1512
        }
1513 de6d9b64 Fabrice Bellard
    } else if ((c & 0xc0) == 0x80) {
1514
        /* mpeg 2 PES */
1515 d8bee8dd Måns Rullgård
#if 0 /* some streams have this field set for no apparent reason */
1516 de6d9b64 Fabrice Bellard
        if ((c & 0x30) != 0) {
1517 27f388aa Fabrice Bellard
            /* Encrypted multiplex not handled */
1518
            goto redo;
1519 de6d9b64 Fabrice Bellard
        }
1520 d8bee8dd Måns Rullgård
#endif
1521 de6d9b64 Fabrice Bellard
        flags = get_byte(&s->pb);
1522
        header_len = get_byte(&s->pb);
1523
        len -= 2;
1524
        if (header_len > len)
1525 e56cfad0 Michael Niedermayer
            goto error_redo;
1526 80036204 Michael Niedermayer
        len -= header_len;
1527 b90ba24b Michael Niedermayer
        if (flags & 0x80) {
1528 27f388aa Fabrice Bellard
            dts = pts = get_pts(&s->pb, -1);
1529 de6d9b64 Fabrice Bellard
            header_len -= 5;
1530 b90ba24b Michael Niedermayer
            if (flags & 0x40) {
1531
                dts = get_pts(&s->pb, -1);
1532
                header_len -= 5;
1533
            }
1534 de6d9b64 Fabrice Bellard
        }
1535 aad512b4 Michael Niedermayer
        if (flags & 0x01) { /* PES extension */
1536
            pes_ext = get_byte(&s->pb);
1537
            header_len--;
1538
            if (pes_ext & 0x40) { /* pack header - should be zero in PS */
1539
                goto error_redo;
1540
            }
1541
            /* Skip PES private data, program packet sequence counter and P-STD buffer */
1542
            skip = (pes_ext >> 4) & 0xb;
1543
            skip += skip & 0x9;
1544
            url_fskip(&s->pb, skip);
1545
            header_len -= skip;
1546
1547
            if (pes_ext & 0x01) { /* PES extension 2 */
1548
                ext2_len = get_byte(&s->pb);
1549
                header_len--;
1550
                if ((ext2_len & 0x7f) > 0) {
1551
                    id_ext = get_byte(&s->pb);
1552
                    if ((id_ext & 0x80) == 0)
1553
                        startcode = ((startcode & 0xff) << 8) | id_ext;
1554
                    header_len--;
1555
                }
1556
            }
1557
        }
1558 80036204 Michael Niedermayer
        if(header_len < 0)
1559
            goto error_redo;
1560
        url_fskip(&s->pb, header_len);
1561 de6d9b64 Fabrice Bellard
    }
1562 df70de1f Dmitry Borisov
    else if( c!= 0xf )
1563
        goto redo;
1564
1565 e3d1cd8e Måns Rullgård
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1566 de6d9b64 Fabrice Bellard
        startcode = get_byte(&s->pb);
1567
        len--;
1568 aad512b4 Michael Niedermayer
        if (startcode >= 0x80 && startcode <= 0xcf) {
1569 de6d9b64 Fabrice Bellard
            /* audio: skip header */
1570
            get_byte(&s->pb);
1571
            get_byte(&s->pb);
1572
            get_byte(&s->pb);
1573
            len -= 3;
1574 aad512b4 Michael Niedermayer
            if (startcode >= 0xb0 && startcode <= 0xbf) {
1575
                /* MLP/TrueHD audio has a 4-byte header */
1576
                get_byte(&s->pb);
1577
                len--;
1578
            }
1579 de6d9b64 Fabrice Bellard
        }
1580
    }
1581 7e4709b1 Michael Niedermayer
    if(len<0)
1582
        goto error_redo;
1583 b754978a Michael Niedermayer
    if(dts != AV_NOPTS_VALUE && ppos){
1584
        int i;
1585
        for(i=0; i<s->nb_streams; i++){
1586
            if(startcode == s->streams[i]->id) {
1587 30a43f2d Michael Niedermayer
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1588 b754978a Michael Niedermayer
            }
1589
        }
1590
    }
1591 115329f1 Diego Biurrun
1592 27f388aa Fabrice Bellard
    *pstart_code = startcode;
1593
    *ppts = pts;
1594
    *pdts = dts;
1595
    return len;
1596
}
1597
1598
static int mpegps_read_packet(AVFormatContext *s,
1599
                              AVPacket *pkt)
1600
{
1601 e3d1cd8e Måns Rullgård
    MpegDemuxContext *m = s->priv_data;
1602 27f388aa Fabrice Bellard
    AVStream *st;
1603 e3d1cd8e Måns Rullgård
    int len, startcode, i, type, codec_id = 0, es_type;
1604 b754978a Michael Niedermayer
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1605 27f388aa Fabrice Bellard
1606
 redo:
1607 8d14a25c Michael Niedermayer
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1608 27f388aa Fabrice Bellard
    if (len < 0)
1609
        return len;
1610 115329f1 Diego Biurrun
1611 de6d9b64 Fabrice Bellard
    /* now find stream */
1612
    for(i=0;i<s->nb_streams;i++) {
1613
        st = s->streams[i];
1614
        if (st->id == startcode)
1615
            goto found;
1616
    }
1617 e3d1cd8e Måns Rullgård
1618
    es_type = m->psm_es_type[startcode & 0xff];
1619
    if(es_type > 0){
1620
        if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1621
            codec_id = CODEC_ID_MPEG2VIDEO;
1622
            type = CODEC_TYPE_VIDEO;
1623
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1624
            codec_id = CODEC_ID_MPEG2VIDEO;
1625
            type = CODEC_TYPE_VIDEO;
1626
        } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1627
                  es_type == STREAM_TYPE_AUDIO_MPEG2){
1628
            codec_id = CODEC_ID_MP3;
1629
            type = CODEC_TYPE_AUDIO;
1630
        } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1631
            codec_id = CODEC_ID_AAC;
1632
            type = CODEC_TYPE_AUDIO;
1633
        } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1634
            codec_id = CODEC_ID_MPEG4;
1635
            type = CODEC_TYPE_VIDEO;
1636
        } else if(es_type == STREAM_TYPE_VIDEO_H264){
1637
            codec_id = CODEC_ID_H264;
1638
            type = CODEC_TYPE_VIDEO;
1639
        } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1640
            codec_id = CODEC_ID_AC3;
1641
            type = CODEC_TYPE_AUDIO;
1642
        } else {
1643
            goto skip;
1644
        }
1645
    } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1646 83d07313 Måns Rullgård
        static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1647
        unsigned char buf[8];
1648
        get_buffer(&s->pb, buf, 8);
1649
        url_fseek(&s->pb, -8, SEEK_CUR);
1650
        if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1651
            codec_id = CODEC_ID_CAVS;
1652
        else
1653
            codec_id = CODEC_ID_MPEG2VIDEO;
1654 db7f1f95 Fabrice Bellard
        type = CODEC_TYPE_VIDEO;
1655
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1656
        type = CODEC_TYPE_AUDIO;
1657
        codec_id = CODEC_ID_MP2;
1658 3f2bf07b Joakim Plate
    } else if (startcode >= 0x80 && startcode <= 0x87) {
1659 db7f1f95 Fabrice Bellard
        type = CODEC_TYPE_AUDIO;
1660
        codec_id = CODEC_ID_AC3;
1661 aad512b4 Michael Niedermayer
    } else if ((startcode >= 0x88 && startcode <= 0x8f)
1662
               ||( startcode >= 0x98 && startcode <= 0x9f)) {
1663
        /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
1664 23c99253 Michael Niedermayer
        type = CODEC_TYPE_AUDIO;
1665
        codec_id = CODEC_ID_DTS;
1666 aad512b4 Michael Niedermayer
    } else if (startcode >= 0xa0 && startcode <= 0xaf) {
1667 9ec05e36 Fabrice Bellard
        type = CODEC_TYPE_AUDIO;
1668
        codec_id = CODEC_ID_PCM_S16BE;
1669 aad512b4 Michael Niedermayer
    } else if (startcode >= 0xb0 && startcode <= 0xbf) {
1670
        type = CODEC_TYPE_AUDIO;
1671
        codec_id = CODEC_ID_MLP;
1672
    } else if (startcode >= 0xc0 && startcode <= 0xcf) {
1673
        /* Used for both AC-3 and E-AC-3 in EVOB files */
1674
        type = CODEC_TYPE_AUDIO;
1675
        codec_id = CODEC_ID_AC3;
1676 a9c3213f Fabrice Bellard
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
1677
        type = CODEC_TYPE_SUBTITLE;
1678
        codec_id = CODEC_ID_DVD_SUBTITLE;
1679 aad512b4 Michael Niedermayer
    } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
1680
        type = CODEC_TYPE_VIDEO;
1681
        codec_id = CODEC_ID_VC1;
1682 db7f1f95 Fabrice Bellard
    } else {
1683
    skip:
1684
        /* skip packet */
1685
        url_fskip(&s->pb, len);
1686
        goto redo;
1687
    }
1688 1e5c667c Fabrice Bellard
    /* no stream found: add a new stream */
1689
    st = av_new_stream(s, startcode);
1690 115329f1 Diego Biurrun
    if (!st)
1691 1e5c667c Fabrice Bellard
        goto skip;
1692 01f4895c Michael Niedermayer
    st->codec->codec_type = type;
1693
    st->codec->codec_id = codec_id;
1694 27f388aa Fabrice Bellard
    if (codec_id != CODEC_ID_PCM_S16BE)
1695
        st->need_parsing = 1;
1696 de6d9b64 Fabrice Bellard
 found:
1697 f3356e9c Michael Niedermayer
    if(st->discard >= AVDISCARD_ALL)
1698 b9866ebc Michael Niedermayer
        goto skip;
1699 aad512b4 Michael Niedermayer
    if (startcode >= 0xa0 && startcode <= 0xaf) {
1700 9ec05e36 Fabrice Bellard
        int b1, freq;
1701
1702
        /* for LPCM, we just skip the header and consider it is raw
1703
           audio data */
1704
        if (len <= 3)
1705
            goto skip;
1706
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1707
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1708
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1709
        len -= 3;
1710
        freq = (b1 >> 4) & 3;
1711 01f4895c Michael Niedermayer
        st->codec->sample_rate = lpcm_freq_tab[freq];
1712
        st->codec->channels = 1 + (b1 & 7);
1713
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1714 9ec05e36 Fabrice Bellard
    }
1715 de6d9b64 Fabrice Bellard
    av_new_packet(pkt, len);
1716
    get_buffer(&s->pb, pkt->data, pkt->size);
1717
    pkt->pts = pts;
1718 27f388aa Fabrice Bellard
    pkt->dts = dts;
1719 db7f1f95 Fabrice Bellard
    pkt->stream_index = st->index;
1720 27a206e0 Michel Bardiaux
#if 0
1721 b9866ebc Michael Niedermayer
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1722
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1723 27a206e0 Michel Bardiaux
#endif
1724 0bd586c5 Mike Melanson
1725 de6d9b64 Fabrice Bellard
    return 0;
1726
}
1727
1728 db7f1f95 Fabrice Bellard
static int mpegps_read_close(AVFormatContext *s)
1729 de6d9b64 Fabrice Bellard
{
1730
    return 0;
1731
}
1732
1733 115329f1 Diego Biurrun
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1734 8d14a25c Michael Niedermayer
                               int64_t *ppos, int64_t pos_limit)
1735 27f388aa Fabrice Bellard
{
1736
    int len, startcode;
1737
    int64_t pos, pts, dts;
1738
1739
    pos = *ppos;
1740
#ifdef DEBUG_SEEK
1741 949b1a13 Steve L'Homme
    printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
1742 27f388aa Fabrice Bellard
#endif
1743
    url_fseek(&s->pb, pos, SEEK_SET);
1744
    for(;;) {
1745 8d14a25c Michael Niedermayer
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1746 27f388aa Fabrice Bellard
        if (len < 0) {
1747
#ifdef DEBUG_SEEK
1748
            printf("none (ret=%d)\n", len);
1749
#endif
1750
            return AV_NOPTS_VALUE;
1751
        }
1752 115329f1 Diego Biurrun
        if (startcode == s->streams[stream_index]->id &&
1753 27f388aa Fabrice Bellard
            dts != AV_NOPTS_VALUE) {
1754
            break;
1755
        }
1756 8d14a25c Michael Niedermayer
        url_fskip(&s->pb, len);
1757 27f388aa Fabrice Bellard
    }
1758
#ifdef DEBUG_SEEK
1759 949b1a13 Steve L'Homme
    printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
1760 27f388aa Fabrice Bellard
#endif
1761
    *ppos = pos;
1762 cdd5034f Michael Niedermayer
    return dts;
1763 27f388aa Fabrice Bellard
}
1764
1765 ff70e601 Måns Rullgård
#ifdef CONFIG_MPEG1SYSTEM_MUXER
1766
AVOutputFormat mpeg1system_muxer = {
1767 de6d9b64 Fabrice Bellard
    "mpeg",
1768 fb7566d0 Fabrice Bellard
    "MPEG1 System format",
1769 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1770 fb7566d0 Fabrice Bellard
    "mpg,mpeg",
1771
    sizeof(MpegMuxContext),
1772
    CODEC_ID_MP2,
1773
    CODEC_ID_MPEG1VIDEO,
1774
    mpeg_mux_init,
1775
    mpeg_mux_write_packet,
1776
    mpeg_mux_end,
1777
};
1778 ff70e601 Måns Rullgård
#endif
1779
#ifdef CONFIG_MPEG1VCD_MUXER
1780
AVOutputFormat mpeg1vcd_muxer = {
1781 fb7566d0 Fabrice Bellard
    "vcd",
1782
    "MPEG1 System format (VCD)",
1783 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1784 fb7566d0 Fabrice Bellard
    NULL,
1785
    sizeof(MpegMuxContext),
1786
    CODEC_ID_MP2,
1787
    CODEC_ID_MPEG1VIDEO,
1788
    mpeg_mux_init,
1789
    mpeg_mux_write_packet,
1790
    mpeg_mux_end,
1791
};
1792 ff70e601 Måns Rullgård
#endif
1793
#ifdef CONFIG_MPEG2VOB_MUXER
1794
AVOutputFormat mpeg2vob_muxer = {
1795 fb7566d0 Fabrice Bellard
    "vob",
1796
    "MPEG2 PS format (VOB)",
1797 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1798 fb7566d0 Fabrice Bellard
    "vob",
1799 db7f1f95 Fabrice Bellard
    sizeof(MpegMuxContext),
1800 de6d9b64 Fabrice Bellard
    CODEC_ID_MP2,
1801 0dbb48d9 Fabrice Bellard
    CODEC_ID_MPEG2VIDEO,
1802 de6d9b64 Fabrice Bellard
    mpeg_mux_init,
1803
    mpeg_mux_write_packet,
1804
    mpeg_mux_end,
1805 db7f1f95 Fabrice Bellard
};
1806 ff70e601 Måns Rullgård
#endif
1807 24515926 Hauke Duden
1808 ff70e601 Måns Rullgård
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1809
#ifdef CONFIG_MPEG2SVCD_MUXER
1810
AVOutputFormat mpeg2svcd_muxer = {
1811 24515926 Hauke Duden
    "svcd",
1812
    "MPEG2 PS format (VOB)",
1813
    "video/mpeg",
1814
    "vob",
1815
    sizeof(MpegMuxContext),
1816
    CODEC_ID_MP2,
1817
    CODEC_ID_MPEG2VIDEO,
1818
    mpeg_mux_init,
1819
    mpeg_mux_write_packet,
1820
    mpeg_mux_end,
1821
};
1822 ff70e601 Måns Rullgård
#endif
1823 24515926 Hauke Duden
1824 ff70e601 Måns Rullgård
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1825
#ifdef CONFIG_MPEG2DVD_MUXER
1826
AVOutputFormat mpeg2dvd_muxer = {
1827 78a0efb4 Paul Curtis
    "dvd",
1828
    "MPEG2 PS format (DVD VOB)",
1829
    "video/mpeg",
1830
    "dvd",
1831
    sizeof(MpegMuxContext),
1832
    CODEC_ID_MP2,
1833
    CODEC_ID_MPEG2VIDEO,
1834
    mpeg_mux_init,
1835
    mpeg_mux_write_packet,
1836
    mpeg_mux_end,
1837
};
1838 ff70e601 Måns Rullgård
#endif
1839 24515926 Hauke Duden
1840 ff70e601 Måns Rullgård
#ifdef CONFIG_MPEGPS_DEMUXER
1841 d2a067d1 Måns Rullgård
AVInputFormat mpegps_demuxer = {
1842 db7f1f95 Fabrice Bellard
    "mpeg",
1843
    "MPEG PS format",
1844
    sizeof(MpegDemuxContext),
1845
    mpegps_probe,
1846
    mpegps_read_header,
1847
    mpegps_read_packet,
1848
    mpegps_read_close,
1849 8d14a25c Michael Niedermayer
    NULL, //mpegps_read_seek,
1850
    mpegps_read_dts,
1851 a9c3213f Fabrice Bellard
    .flags = AVFMT_SHOW_IDS,
1852 de6d9b64 Fabrice Bellard
};
1853 ff70e601 Måns Rullgård
#endif