Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpeg.c @ 27d5f18f

History | View | Annotate | Download (47 KB)

1 de6d9b64 Fabrice Bellard
/*
2 fb7566d0 Fabrice Bellard
 * MPEG1/2 mux/demux
3 19720f15 Fabrice Bellard
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4 de6d9b64 Fabrice Bellard
 *
5 19720f15 Fabrice Bellard
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9 de6d9b64 Fabrice Bellard
 *
10 19720f15 Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 de6d9b64 Fabrice Bellard
 */
19
#include "avformat.h"
20
21
#define MAX_PAYLOAD_SIZE 4096
22 27f388aa Fabrice Bellard
//#define DEBUG_SEEK
23 de6d9b64 Fabrice Bellard
24 b754978a Michael Niedermayer
#undef NDEBUG
25
#include <assert.h>
26
27 7000a175 Michael Niedermayer
typedef struct PacketDesc {
28
    int64_t pts;
29
    int64_t dts;
30
    int size;
31
    int unwritten_size;
32
    int flags;
33
    struct PacketDesc *next;
34
} PacketDesc;
35
36 de6d9b64 Fabrice Bellard
typedef struct {
37 7000a175 Michael Niedermayer
    FifoBuffer fifo;
38 0c1a9eda Zdenek Kabelac
    uint8_t id;
39 de6d9b64 Fabrice Bellard
    int max_buffer_size; /* in bytes */
40 7000a175 Michael Niedermayer
    int buffer_index;
41
    PacketDesc *predecode_packet;
42
    PacketDesc *premux_packet;
43
    PacketDesc **next_packet;
44 de6d9b64 Fabrice Bellard
    int packet_number;
45 044007c2 Fabrice Bellard
    uint8_t lpcm_header[3];
46
    int lpcm_align;
47 de6d9b64 Fabrice Bellard
} StreamInfo;
48
49
typedef struct {
50
    int packet_size; /* required packet size */
51
    int packet_number;
52
    int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
53
    int system_header_freq;
54 0dbb48d9 Fabrice Bellard
    int system_header_size;
55 de6d9b64 Fabrice Bellard
    int mux_rate; /* bitrate in units of 50 bytes/s */
56
    /* stream info */
57
    int audio_bound;
58
    int video_bound;
59 fb7566d0 Fabrice Bellard
    int is_mpeg2;
60
    int is_vcd;
61 24515926 Hauke Duden
    int is_svcd;
62 78a0efb4 Paul Curtis
    int is_dvd;
63 27a206e0 Michel Bardiaux
    int64_t last_scr; /* current system clock */
64 24515926 Hauke Duden
65 d8b5abfa Michael Niedermayer
    double vcd_padding_bitrate; //FIXME floats
66 24515926 Hauke Duden
    int64_t vcd_padding_bytes_written;
67
68 de6d9b64 Fabrice Bellard
} MpegMuxContext;
69
70
#define PACK_START_CODE             ((unsigned int)0x000001ba)
71
#define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
72 92b3e125 Juanjo
#define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
73 de6d9b64 Fabrice Bellard
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
74
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
75
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
76
  
77
/* mpeg2 */
78
#define PROGRAM_STREAM_MAP 0x1bc
79
#define PRIVATE_STREAM_1   0x1bd
80
#define PADDING_STREAM     0x1be
81
#define PRIVATE_STREAM_2   0x1bf
82
83
84
#define AUDIO_ID 0xc0
85
#define VIDEO_ID 0xe0
86 044007c2 Fabrice Bellard
#define AC3_ID   0x80
87 23c99253 Michael Niedermayer
#define DTS_ID   0x8a
88 044007c2 Fabrice Bellard
#define LPCM_ID  0xa0
89 de6d9b64 Fabrice Bellard
90 8a05bca4 Michael Niedermayer
static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
91
92 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
93 7906085f Falk Hüffner
static AVOutputFormat mpeg1system_mux;
94
static AVOutputFormat mpeg1vcd_mux;
95
static AVOutputFormat mpeg2vob_mux;
96
static AVOutputFormat mpeg2svcd_mux;
97 78a0efb4 Paul Curtis
static AVOutputFormat mpeg2dvd_mux;
98 fb7566d0 Fabrice Bellard
99 de6d9b64 Fabrice Bellard
static int put_pack_header(AVFormatContext *ctx, 
100 0c1a9eda Zdenek Kabelac
                           uint8_t *buf, int64_t timestamp)
101 de6d9b64 Fabrice Bellard
{
102
    MpegMuxContext *s = ctx->priv_data;
103
    PutBitContext pb;
104
    
105 117a5490 Alex Beregszaszi
    init_put_bits(&pb, buf, 128);
106 de6d9b64 Fabrice Bellard
107
    put_bits(&pb, 32, PACK_START_CODE);
108 b2cac184 Fabrice Bellard
    if (s->is_mpeg2) {
109 8683e4a0 Måns Rullgård
        put_bits(&pb, 2, 0x1);
110 b2cac184 Fabrice Bellard
    } else {
111
        put_bits(&pb, 4, 0x2);
112
    }
113 0c1a9eda Zdenek Kabelac
    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
114 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
115 0c1a9eda Zdenek Kabelac
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
116 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
117 0c1a9eda Zdenek Kabelac
    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
118 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
119 b2cac184 Fabrice Bellard
    if (s->is_mpeg2) {
120
        /* clock extension */
121
        put_bits(&pb, 9, 0);
122
    }
123 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1);
124
    put_bits(&pb, 22, s->mux_rate);
125
    put_bits(&pb, 1, 1);
126 b2cac184 Fabrice Bellard
    if (s->is_mpeg2) {
127 4aa533be Michael Niedermayer
        put_bits(&pb, 1, 1);
128 b2cac184 Fabrice Bellard
        put_bits(&pb, 5, 0x1f); /* reserved */
129
        put_bits(&pb, 3, 0); /* stuffing length */
130
    }
131 de6d9b64 Fabrice Bellard
    flush_put_bits(&pb);
132 17592475 Michael Niedermayer
    return pbBufPtr(&pb) - pb.buf;
133 de6d9b64 Fabrice Bellard
}
134
135 24515926 Hauke Duden
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
136 de6d9b64 Fabrice Bellard
{
137
    MpegMuxContext *s = ctx->priv_data;
138 7000a175 Michael Niedermayer
    int size, i, private_stream_coded, id;
139 de6d9b64 Fabrice Bellard
    PutBitContext pb;
140
141 117a5490 Alex Beregszaszi
    init_put_bits(&pb, buf, 128);
142 de6d9b64 Fabrice Bellard
143
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
144
    put_bits(&pb, 16, 0);
145
    put_bits(&pb, 1, 1);
146
    
147 7000a175 Michael Niedermayer
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
148 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1); /* marker */
149 24515926 Hauke Duden
    if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
150
        /* This header applies only to the video stream (see VCD standard p. IV-7)*/
151
        put_bits(&pb, 6, 0);
152
    } else
153
        put_bits(&pb, 6, s->audio_bound);
154 de6d9b64 Fabrice Bellard
155 22494489 Hauke Duden
    if (s->is_vcd) {
156
        /* see VCD standard, p. IV-7*/
157
        put_bits(&pb, 1, 0); 
158
        put_bits(&pb, 1, 1);
159
    } else {
160
        put_bits(&pb, 1, 0); /* variable bitrate*/
161
        put_bits(&pb, 1, 0); /* non constrainted bit stream */
162
    }
163 de6d9b64 Fabrice Bellard
    
164 24515926 Hauke Duden
    if (s->is_vcd) {
165
        /* see VCD standard p IV-7 */
166
        put_bits(&pb, 1, 1); /* audio locked */
167
        put_bits(&pb, 1, 1); /* video locked */
168
    } else {
169
        put_bits(&pb, 1, 0); /* audio locked */
170
        put_bits(&pb, 1, 0); /* video locked */
171
    }
172
173 de6d9b64 Fabrice Bellard
    put_bits(&pb, 1, 1); /* marker */
174
175 24515926 Hauke Duden
    if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
176
        /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
177
        put_bits(&pb, 5, 0);
178
    } else
179
        put_bits(&pb, 5, s->video_bound);
180
181 de6d9b64 Fabrice Bellard
    put_bits(&pb, 8, 0xff); /* reserved byte */
182
    
183
    /* audio stream info */
184
    private_stream_coded = 0;
185
    for(i=0;i<ctx->nb_streams;i++) {
186
        StreamInfo *stream = ctx->streams[i]->priv_data;
187 24515926 Hauke Duden
        
188
        /* For VCDs, only include the stream info for the stream
189
           that the pack which contains this system belongs to.
190
           (see VCD standard p. IV-7) */
191
        if ( !s->is_vcd || stream->id==only_for_stream_id
192
            || only_for_stream_id==0) {
193
194
            id = stream->id;
195
            if (id < 0xc0) {
196
                /* special case for private streams (AC3 use that) */
197
                if (private_stream_coded)
198
                    continue;
199
                private_stream_coded = 1;
200
                id = 0xbd;
201
            }
202
            put_bits(&pb, 8, id); /* stream ID */
203
            put_bits(&pb, 2, 3);
204
            if (id < 0xe0) {
205
                /* audio */
206
                put_bits(&pb, 1, 0);
207
                put_bits(&pb, 13, stream->max_buffer_size / 128);
208
            } else {
209
                /* video */
210
                put_bits(&pb, 1, 1);
211
                put_bits(&pb, 13, stream->max_buffer_size / 1024);
212
            }
213 de6d9b64 Fabrice Bellard
        }
214
    }
215
    flush_put_bits(&pb);
216 17592475 Michael Niedermayer
    size = pbBufPtr(&pb) - pb.buf;
217 de6d9b64 Fabrice Bellard
    /* patch packet size */
218
    buf[4] = (size - 6) >> 8;
219
    buf[5] = (size - 6) & 0xff;
220
221
    return size;
222
}
223
224 0dbb48d9 Fabrice Bellard
static int get_system_header_size(AVFormatContext *ctx)
225
{
226
    int buf_index, i, private_stream_coded;
227
    StreamInfo *stream;
228
229
    buf_index = 12;
230
    private_stream_coded = 0;
231
    for(i=0;i<ctx->nb_streams;i++) {
232
        stream = ctx->streams[i]->priv_data;
233
        if (stream->id < 0xc0) {
234
            if (private_stream_coded)
235
                continue;
236
            private_stream_coded = 1;
237
        }
238
        buf_index += 3;
239
    }
240
    return buf_index;
241
}
242
243 de6d9b64 Fabrice Bellard
static int mpeg_mux_init(AVFormatContext *ctx)
244
{
245 db7f1f95 Fabrice Bellard
    MpegMuxContext *s = ctx->priv_data;
246 23c99253 Michael Niedermayer
    int bitrate, i, mpa_id, mpv_id, ac3_id, dts_id, lpcm_id, j;
247 de6d9b64 Fabrice Bellard
    AVStream *st;
248
    StreamInfo *stream;
249 24515926 Hauke Duden
    int audio_bitrate;
250
    int video_bitrate;
251 de6d9b64 Fabrice Bellard
252
    s->packet_number = 0;
253 fb7566d0 Fabrice Bellard
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
254 24515926 Hauke Duden
    s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
255 78a0efb4 Paul Curtis
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
256
    s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
257 fb7566d0 Fabrice Bellard
    
258 2db3c638 Michael Niedermayer
    if(ctx->packet_size)
259
        s->packet_size = ctx->packet_size;
260 92b3e125 Juanjo
    else
261
        s->packet_size = 2048;
262 2db3c638 Michael Niedermayer
       
263 24515926 Hauke Duden
    s->vcd_padding_bytes_written = 0;
264
    s->vcd_padding_bitrate=0;
265 92b3e125 Juanjo
        
266 de6d9b64 Fabrice Bellard
    s->audio_bound = 0;
267
    s->video_bound = 0;
268
    mpa_id = AUDIO_ID;
269 044007c2 Fabrice Bellard
    ac3_id = AC3_ID;
270 23c99253 Michael Niedermayer
    dts_id = DTS_ID;
271 de6d9b64 Fabrice Bellard
    mpv_id = VIDEO_ID;
272 044007c2 Fabrice Bellard
    lpcm_id = LPCM_ID;
273 de6d9b64 Fabrice Bellard
    for(i=0;i<ctx->nb_streams;i++) {
274
        st = ctx->streams[i];
275
        stream = av_mallocz(sizeof(StreamInfo));
276
        if (!stream)
277
            goto fail;
278
        st->priv_data = stream;
279
280 2031ba1b Michael Niedermayer
        av_set_pts_info(st, 64, 1, 90000);
281
282 de6d9b64 Fabrice Bellard
        switch(st->codec.codec_type) {
283
        case CODEC_TYPE_AUDIO:
284 044007c2 Fabrice Bellard
            if (st->codec.codec_id == CODEC_ID_AC3) {
285 de6d9b64 Fabrice Bellard
                stream->id = ac3_id++;
286 23c99253 Michael Niedermayer
            } else if (st->codec.codec_id == CODEC_ID_DTS) {
287
                stream->id = dts_id++;
288 044007c2 Fabrice Bellard
            } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
289
                stream->id = lpcm_id++;
290
                for(j = 0; j < 4; j++) {
291
                    if (lpcm_freq_tab[j] == st->codec.sample_rate)
292
                        break;
293
                }
294
                if (j == 4)
295
                    goto fail;
296
                if (st->codec.channels > 8)
297
                    return -1;
298
                stream->lpcm_header[0] = 0x0c;
299
                stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
300
                stream->lpcm_header[2] = 0x80;
301
                stream->lpcm_align = st->codec.channels * 2;
302
            } else {
303 de6d9b64 Fabrice Bellard
                stream->id = mpa_id++;
304 044007c2 Fabrice Bellard
            }
305 22494489 Hauke Duden
306
            /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
307
               Right now it is also used for everything else.*/
308 de6d9b64 Fabrice Bellard
            stream->max_buffer_size = 4 * 1024; 
309
            s->audio_bound++;
310
            break;
311
        case CODEC_TYPE_VIDEO:
312
            stream->id = mpv_id++;
313 7e051558 Michael Niedermayer
            if (st->codec.rc_buffer_size)
314
                stream->max_buffer_size = 6*1024 + st->codec.rc_buffer_size/8;
315
            else
316
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
317
#if 0
318 22494489 Hauke Duden
                /* see VCD standard, p. IV-7*/
319
                stream->max_buffer_size = 46 * 1024; 
320
            else
321
                /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
322
                   Right now it is also used for everything else.*/
323
                stream->max_buffer_size = 230 * 1024; 
324 7e051558 Michael Niedermayer
#endif
325 de6d9b64 Fabrice Bellard
            s->video_bound++;
326
            break;
327 ac5e6a5b Philip Gladstone
        default:
328 71c32f19 Michael Niedermayer
            return -1;
329 de6d9b64 Fabrice Bellard
        }
330 7000a175 Michael Niedermayer
        fifo_init(&stream->fifo, 2*stream->max_buffer_size + 100*MAX_PAYLOAD_SIZE); //FIXME think about the size maybe dynamically realloc
331
        stream->next_packet= &stream->premux_packet;
332 de6d9b64 Fabrice Bellard
    }
333 24515926 Hauke Duden
    bitrate = 0;
334
    audio_bitrate = 0;
335
    video_bitrate = 0;
336 de6d9b64 Fabrice Bellard
    for(i=0;i<ctx->nb_streams;i++) {
337 7000a175 Michael Niedermayer
        int codec_rate;
338 de6d9b64 Fabrice Bellard
        st = ctx->streams[i];
339 24515926 Hauke Duden
        stream = (StreamInfo*) st->priv_data;
340 7000a175 Michael Niedermayer
341
        if(st->codec.rc_max_rate || stream->id==VIDEO_ID)
342
            codec_rate= st->codec.rc_max_rate;
343
        else
344
            codec_rate= st->codec.bit_rate;
345
                
346
        if(!codec_rate)
347
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
348
            
349
        bitrate += codec_rate;
350 24515926 Hauke Duden
351
        if (stream->id==AUDIO_ID)
352 7000a175 Michael Niedermayer
            audio_bitrate += codec_rate;
353 24515926 Hauke Duden
        else if (stream->id==VIDEO_ID)
354 7000a175 Michael Niedermayer
            video_bitrate += codec_rate;
355 24515926 Hauke Duden
    }
356 2db3c638 Michael Niedermayer
    
357
    if(ctx->mux_rate){
358
        s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
359
    } else {
360
        /* we increase slightly the bitrate to take into account the
361
           headers. XXX: compute it exactly */
362
        bitrate += bitrate*5/100;
363
        bitrate += 10000;
364
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
365
    }
366 24515926 Hauke Duden
367
    if (s->is_vcd) {
368
        double overhead_rate;
369
370
        /* The VCD standard mandates that the mux_rate field is 3528
371
           (see standard p. IV-6).
372
           The value is actually "wrong", i.e. if you calculate
373
           it using the normal formula and the 75 sectors per second transfer
374
           rate you get a different value because the real pack size is 2324,
375
           not 2352. But the standard explicitly specifies that the mux_rate
376
           field in the header must have this value.*/
377 2db3c638 Michael Niedermayer
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
378 24515926 Hauke Duden
379
        /* The VCD standard states that the muxed stream must be
380
           exactly 75 packs / second (the data rate of a single speed cdrom).
381
           Since the video bitrate (probably 1150000 bits/sec) will be below
382
           the theoretical maximum we have to add some padding packets
383
           to make up for the lower data rate.
384
           (cf. VCD standard p. IV-6 )*/
385
386
        /* Add the header overhead to the data rate.
387
           2279 data bytes per audio pack, 2294 data bytes per video pack*/
388
        overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
389
        overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
390
        overhead_rate *= 8;
391
        
392
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
393
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
394 de6d9b64 Fabrice Bellard
    }
395 92b3e125 Juanjo
    
396 fb7566d0 Fabrice Bellard
    if (s->is_vcd || s->is_mpeg2)
397 92b3e125 Juanjo
        /* every packet */
398
        s->pack_header_freq = 1;
399
    else
400
        /* every 2 seconds */
401
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
402 b623bbcb Michael Niedermayer
403
    /* the above seems to make pack_header_freq zero sometimes */
404
    if (s->pack_header_freq == 0)
405
       s->pack_header_freq = 1;
406 92b3e125 Juanjo
    
407 b2cac184 Fabrice Bellard
    if (s->is_mpeg2)
408
        /* every 200 packets. Need to look at the spec.  */
409
        s->system_header_freq = s->pack_header_freq * 40;
410
    else if (s->is_vcd)
411 24515926 Hauke Duden
        /* the standard mandates that there are only two system headers
412
           in the whole file: one in the first packet of each stream.
413
           (see standard p. IV-7 and IV-8) */
414
        s->system_header_freq = 0x7fffffff;
415 92b3e125 Juanjo
    else
416
        s->system_header_freq = s->pack_header_freq * 5;
417
    
418 de6d9b64 Fabrice Bellard
    for(i=0;i<ctx->nb_streams;i++) {
419
        stream = ctx->streams[i]->priv_data;
420
        stream->packet_number = 0;
421
    }
422 0dbb48d9 Fabrice Bellard
    s->system_header_size = get_system_header_size(ctx);
423 27a206e0 Michel Bardiaux
    s->last_scr = 0;
424 de6d9b64 Fabrice Bellard
    return 0;
425
 fail:
426
    for(i=0;i<ctx->nb_streams;i++) {
427 1ea4f593 Fabrice Bellard
        av_free(ctx->streams[i]->priv_data);
428 de6d9b64 Fabrice Bellard
    }
429
    return -ENOMEM;
430
}
431
432 27a206e0 Michel Bardiaux
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
433
{
434
    put_byte(pb, 
435
             (id << 4) | 
436
             (((timestamp >> 30) & 0x07) << 1) | 
437
             1);
438
    put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
439
    put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
440
}
441
442 0dbb48d9 Fabrice Bellard
443 24515926 Hauke Duden
/* return the number of padding bytes that should be inserted into
444
   the multiplexed stream.*/
445
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
446
{
447
    MpegMuxContext *s = ctx->priv_data;
448
    int pad_bytes = 0;
449
450
    if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
451
    {
452
        int64_t full_pad_bytes;
453
        
454 7000a175 Michael Niedermayer
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
455 24515926 Hauke Duden
        pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
456
457
        if (pad_bytes<0)
458
            /* might happen if we have already padded to a later timestamp. This
459
               can occur if another stream has already advanced further.*/
460
            pad_bytes=0;
461
    }
462
463
    return pad_bytes;
464
}
465
466
467 0dbb48d9 Fabrice Bellard
/* return the exact available payload size for the next packet for
468
   stream 'stream_index'. 'pts' and 'dts' are only used to know if
469
   timestamps are needed in the packet header. */
470
static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
471
                                   int64_t pts, int64_t dts)
472
{
473
    MpegMuxContext *s = ctx->priv_data;
474
    int buf_index;
475
    StreamInfo *stream;
476
477 24515926 Hauke Duden
    stream = ctx->streams[stream_index]->priv_data;
478
479 0dbb48d9 Fabrice Bellard
    buf_index = 0;
480
    if (((s->packet_number % s->pack_header_freq) == 0)) {
481
        /* pack header size */
482
        if (s->is_mpeg2) 
483
            buf_index += 14;
484
        else
485
            buf_index += 12;
486 24515926 Hauke Duden
        
487
        if (s->is_vcd) {
488
            /* there is exactly one system header for each stream in a VCD MPEG,
489
               One in the very first video packet and one in the very first
490
               audio packet (see VCD standard p. IV-7 and IV-8).*/
491
            
492
            if (stream->packet_number==0)
493
                /* The system headers refer only to the stream they occur in,
494
                   so they have a constant size.*/
495
                buf_index += 15;
496
497
        } else {            
498
            if ((s->packet_number % s->system_header_freq) == 0)
499
                buf_index += s->system_header_size;
500
        }
501 0dbb48d9 Fabrice Bellard
    }
502
503 22494489 Hauke Duden
    if ((s->is_vcd && stream->packet_number==0)
504
        || (s->is_svcd && s->packet_number==0))
505 24515926 Hauke Duden
        /* the first pack of each stream contains only the pack header,
506
           the system header and some padding (see VCD standard p. IV-6) 
507
           Add the padding size, so that the actual payload becomes 0.*/
508
        buf_index += s->packet_size - buf_index;
509
    else {
510
        /* packet header size */
511
        buf_index += 6;
512 22494489 Hauke Duden
        if (s->is_mpeg2) {
513 044007c2 Fabrice Bellard
            buf_index += 3;
514 22494489 Hauke Duden
            if (stream->packet_number==0)
515
                buf_index += 3; /* PES extension */
516
            buf_index += 1;    /* obligatory stuffing byte */
517
        }
518 24515926 Hauke Duden
        if (pts != AV_NOPTS_VALUE) {
519
            if (dts != pts)
520
                buf_index += 5 + 5;
521
            else
522
                buf_index += 5;
523
524
        } else {
525
            if (!s->is_mpeg2)
526
                buf_index++;
527
        }
528
    
529
        if (stream->id < 0xc0) {
530
            /* AC3/LPCM private data header */
531
            buf_index += 4;
532
            if (stream->id >= 0xa0) {
533
                int n;
534
                buf_index += 3;
535
                /* NOTE: we round the payload size to an integer number of
536
                   LPCM samples */
537
                n = (s->packet_size - buf_index) % stream->lpcm_align;
538
                if (n)
539
                    buf_index += (stream->lpcm_align - n);
540
            }
541 044007c2 Fabrice Bellard
        }
542 24515926 Hauke Duden
543
        if (s->is_vcd && stream->id == AUDIO_ID)
544
            /* The VCD standard demands that 20 zero bytes follow
545
               each audio packet (see standard p. IV-8).*/
546
            buf_index+=20;
547 0dbb48d9 Fabrice Bellard
    }
548
    return s->packet_size - buf_index; 
549
}
550
551 24515926 Hauke Duden
/* Write an MPEG padding packet header. */
552 d8b5abfa Michael Niedermayer
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
553 24515926 Hauke Duden
{
554
    MpegMuxContext *s = ctx->priv_data;
555 d8b5abfa Michael Niedermayer
    int i;
556
    
557
    put_be32(pb, PADDING_STREAM);
558
    put_be16(pb, packet_bytes - 6);
559 24515926 Hauke Duden
    if (!s->is_mpeg2) {
560 d8b5abfa Michael Niedermayer
        put_byte(pb, 0x0f);
561
        packet_bytes -= 7;
562 24515926 Hauke Duden
    } else
563 d8b5abfa Michael Niedermayer
        packet_bytes -= 6;
564 24515926 Hauke Duden
565
    for(i=0;i<packet_bytes;i++)
566
        put_byte(pb, 0xff);
567
}
568
569 7000a175 Michael Niedermayer
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
570
    int nb_frames=0;
571
    PacketDesc *pkt_desc= stream->premux_packet;
572
573
    while(len>0){ 
574
        if(pkt_desc->size == pkt_desc->unwritten_size)
575
            nb_frames++;
576
        len -= pkt_desc->unwritten_size;
577
        pkt_desc= pkt_desc->next;
578
    }
579
580
    return nb_frames;
581
}
582 24515926 Hauke Duden
583 de6d9b64 Fabrice Bellard
/* flush the packet on stream stream_index */
584 7000a175 Michael Niedermayer
static int flush_packet(AVFormatContext *ctx, int stream_index, 
585
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
586 de6d9b64 Fabrice Bellard
{
587
    MpegMuxContext *s = ctx->priv_data;
588
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
589 0c1a9eda Zdenek Kabelac
    uint8_t *buf_ptr;
590 0dbb48d9 Fabrice Bellard
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
591
    int packet_size;
592 0c1a9eda Zdenek Kabelac
    uint8_t buffer[128];
593 24515926 Hauke Duden
    int zero_trail_bytes = 0;
594
    int pad_packet_bytes = 0;
595 22494489 Hauke Duden
    int pes_flags;
596
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
597 7000a175 Michael Niedermayer
    int nb_frames;
598 92b3e125 Juanjo
    
599 de6d9b64 Fabrice Bellard
    id = stream->id;
600 27a206e0 Michel Bardiaux
    
601 de6d9b64 Fabrice Bellard
#if 0
602
    printf("packet ID=%2x PTS=%0.3f\n", 
603 27a206e0 Michel Bardiaux
           id, pts / 90000.0);
604 de6d9b64 Fabrice Bellard
#endif
605
606
    buf_ptr = buffer;
607 24515926 Hauke Duden
608 7000a175 Michael Niedermayer
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
609 de6d9b64 Fabrice Bellard
        /* output pack and systems header if needed */
610 27a206e0 Michel Bardiaux
        size = put_pack_header(ctx, buf_ptr, scr);
611 de6d9b64 Fabrice Bellard
        buf_ptr += size;
612 7000a175 Michael Niedermayer
        s->last_scr= scr;
613 24515926 Hauke Duden
614
        if (s->is_vcd) {
615
            /* there is exactly one system header for each stream in a VCD MPEG,
616
               One in the very first video packet and one in the very first
617
               audio packet (see VCD standard p. IV-7 and IV-8).*/
618
            
619
            if (stream->packet_number==0) {
620
                size = put_system_header(ctx, buf_ptr, id);
621
                buf_ptr += size;
622
            }
623
        } else {
624
            if ((s->packet_number % s->system_header_freq) == 0) {
625
                size = put_system_header(ctx, buf_ptr, 0);
626
                buf_ptr += size;
627
            }
628 de6d9b64 Fabrice Bellard
        }
629
    }
630
    size = buf_ptr - buffer;
631
    put_buffer(&ctx->pb, buffer, size);
632
633 24515926 Hauke Duden
    packet_size = s->packet_size - size;
634
635
    if (s->is_vcd && id == AUDIO_ID)
636
        /* The VCD standard demands that 20 zero bytes follow
637
           each audio pack (see standard p. IV-8).*/
638
        zero_trail_bytes += 20;
639
            
640 22494489 Hauke Duden
    if ((s->is_vcd && stream->packet_number==0)
641
        || (s->is_svcd && s->packet_number==0)) {
642
        /* for VCD the first pack of each stream contains only the pack header,
643 24515926 Hauke Duden
           the system header and lots of padding (see VCD standard p. IV-6).
644
           In the case of an audio pack, 20 zero bytes are also added at
645
           the end.*/
646 22494489 Hauke Duden
        /* For SVCD we fill the very first pack to increase compatibility with
647
           some DVD players. Not mandated by the standard.*/
648
        if (s->is_svcd)
649
            general_pack = 1;    /* the system header refers to both streams and no stream data*/
650 24515926 Hauke Duden
        pad_packet_bytes = packet_size - zero_trail_bytes;
651 27a206e0 Michel Bardiaux
    }
652
653 24515926 Hauke Duden
    packet_size -= pad_packet_bytes + zero_trail_bytes;
654 0dbb48d9 Fabrice Bellard
655 24515926 Hauke Duden
    if (packet_size > 0) {
656 de6d9b64 Fabrice Bellard
657 24515926 Hauke Duden
        /* packet header size */
658
        packet_size -= 6;
659
        
660
        /* packet header */
661
        if (s->is_mpeg2) {
662
            header_len = 3;
663 22494489 Hauke Duden
            if (stream->packet_number==0)
664
                header_len += 3; /* PES extension */
665
            header_len += 1; /* obligatory stuffing byte */
666 24515926 Hauke Duden
        } else {
667
            header_len = 0;
668
        }
669
        if (pts != AV_NOPTS_VALUE) {
670
            if (dts != pts)
671
                header_len += 5 + 5;
672
            else
673
                header_len += 5;
674
        } else {
675
            if (!s->is_mpeg2)
676
                header_len++;
677
        }
678 4aa533be Michael Niedermayer
679 24515926 Hauke Duden
        payload_size = packet_size - header_len;
680
        if (id < 0xc0) {
681
            startcode = PRIVATE_STREAM_1;
682
            payload_size -= 4;
683
            if (id >= 0xa0)
684
                payload_size -= 3;
685
        } else {
686
            startcode = 0x100 + id;
687
        }
688 fb7566d0 Fabrice Bellard
689 7000a175 Michael Niedermayer
        stuffing_size = payload_size - fifo_size(&stream->fifo, stream->fifo.rptr);
690
691
        // first byte doesnt fit -> reset pts/dts + stuffing
692
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
693
            int timestamp_len=0;
694
            if(dts != pts) 
695
                timestamp_len += 5;
696
            if(pts != AV_NOPTS_VALUE)
697
                timestamp_len += s->is_mpeg2 ? 5 : 4;
698
            pts=dts= AV_NOPTS_VALUE;
699
            header_len -= timestamp_len;
700
            payload_size += timestamp_len;
701
            stuffing_size += timestamp_len;
702
            if(payload_size > trailer_size)
703
                stuffing_size += payload_size - trailer_size;
704
        }
705
706 24515926 Hauke Duden
        if (stuffing_size < 0)
707
            stuffing_size = 0;
708 22494489 Hauke Duden
        if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
709
            pad_packet_bytes += stuffing_size;
710
            packet_size -= stuffing_size;
711
            payload_size -= stuffing_size;
712
            stuffing_size = 0;
713
        }
714 7000a175 Michael Niedermayer
        
715
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
716 22494489 Hauke Duden
717 24515926 Hauke Duden
        put_be32(&ctx->pb, startcode);
718 27a206e0 Michel Bardiaux
719 24515926 Hauke Duden
        put_be16(&ctx->pb, packet_size);
720
        
721
        if (!s->is_mpeg2)
722
            for(i=0;i<stuffing_size;i++)
723
                put_byte(&ctx->pb, 0xff);
724
725
        if (s->is_mpeg2) {
726
            put_byte(&ctx->pb, 0x80); /* mpeg2 id */
727
728 22494489 Hauke Duden
            pes_flags=0;
729
730 24515926 Hauke Duden
            if (pts != AV_NOPTS_VALUE) {
731 22494489 Hauke Duden
                pes_flags |= 0x80;
732
                if (dts != pts)
733
                    pes_flags |= 0x40;
734 27a206e0 Michel Bardiaux
            }
735 22494489 Hauke Duden
736
            /* Both the MPEG-2 and the SVCD standards demand that the
737
               P-STD_buffer_size field be included in the first packet of
738
               every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
739
               and MPEG-2 standard 2.7.7) */
740
            if (stream->packet_number == 0)
741
                pes_flags |= 0x01;
742
743
            put_byte(&ctx->pb, pes_flags); /* flags */
744
            put_byte(&ctx->pb, header_len - 3 + stuffing_size);
745
746
            if (pes_flags & 0x80)  /*write pts*/
747
                put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
748
            if (pes_flags & 0x40)  /*write dts*/
749
                put_timestamp(&ctx->pb, 0x01, dts);
750
            
751
            if (pes_flags & 0x01) {  /*write pes extension*/
752
                put_byte(&ctx->pb, 0x10); /* flags */
753
754
                /* P-STD buffer info */                
755
                if (id == AUDIO_ID)
756
                    put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
757
                else
758
                    put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
759
            }
760
761 27a206e0 Michel Bardiaux
        } else {
762 24515926 Hauke Duden
            if (pts != AV_NOPTS_VALUE) {
763
                if (dts != pts) {
764
                    put_timestamp(&ctx->pb, 0x03, pts);
765
                    put_timestamp(&ctx->pb, 0x01, dts);
766
                } else {
767
                    put_timestamp(&ctx->pb, 0x02, pts);
768
                }
769 27a206e0 Michel Bardiaux
            } else {
770 24515926 Hauke Duden
                put_byte(&ctx->pb, 0x0f);
771 27a206e0 Michel Bardiaux
            }
772
        }
773 de6d9b64 Fabrice Bellard
774 9e9080b6 Sidik Isani
        if (s->is_mpeg2) {
775
            /* special stuffing byte that is always written
776
               to prevent accidental generation of start codes. */
777
            put_byte(&ctx->pb, 0xff);
778
779
            for(i=0;i<stuffing_size;i++)
780
                put_byte(&ctx->pb, 0xff);
781
        }
782
783 24515926 Hauke Duden
        if (startcode == PRIVATE_STREAM_1) {
784
            put_byte(&ctx->pb, id);
785
            if (id >= 0xa0) {
786
                /* LPCM (XXX: check nb_frames) */
787
                put_byte(&ctx->pb, 7);
788
                put_be16(&ctx->pb, 4); /* skip 3 header bytes */
789
                put_byte(&ctx->pb, stream->lpcm_header[0]);
790
                put_byte(&ctx->pb, stream->lpcm_header[1]);
791
                put_byte(&ctx->pb, stream->lpcm_header[2]);
792
            } else {
793
                /* AC3 */
794 7000a175 Michael Niedermayer
                put_byte(&ctx->pb, nb_frames);
795
                put_be16(&ctx->pb, trailer_size+1);
796 24515926 Hauke Duden
            }
797 de6d9b64 Fabrice Bellard
        }
798 24515926 Hauke Duden
799
        /* output data */
800 7000a175 Michael Niedermayer
        if(put_fifo(&ctx->pb, &stream->fifo, payload_size - stuffing_size, &stream->fifo.rptr) < 0)
801
            return -1;
802
    }else{
803
        payload_size=
804
        stuffing_size= 0;
805 de6d9b64 Fabrice Bellard
    }
806
807 24515926 Hauke Duden
    if (pad_packet_bytes > 0)
808
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);    
809 4aa533be Michael Niedermayer
810 24515926 Hauke Duden
    for(i=0;i<zero_trail_bytes;i++)
811
        put_byte(&ctx->pb, 0x00);
812
        
813 de6d9b64 Fabrice Bellard
    put_flush_packet(&ctx->pb);
814
    
815
    s->packet_number++;
816 22494489 Hauke Duden
817
    /* only increase the stream packet number if this pack actually contains
818
       something that is specific to this stream! I.e. a dedicated header
819
       or some data.*/
820
    if (!general_pack)
821
        stream->packet_number++;
822 7000a175 Michael Niedermayer
    
823
    return payload_size - stuffing_size;
824 de6d9b64 Fabrice Bellard
}
825
826 24515926 Hauke Duden
static void put_vcd_padding_sector(AVFormatContext *ctx)
827
{
828
    /* There are two ways to do this padding: writing a sector/pack
829
       of 0 values, or writing an MPEG padding pack. Both seem to
830
       work with most decoders, BUT the VCD standard only allows a 0-sector
831
       (see standard p. IV-4, IV-5).
832
       So a 0-sector it is...*/
833
834
    MpegMuxContext *s = ctx->priv_data;
835
    int i;
836
837
    for(i=0;i<s->packet_size;i++)
838
        put_byte(&ctx->pb, 0);
839
840
    s->vcd_padding_bytes_written += s->packet_size;
841
        
842
    put_flush_packet(&ctx->pb);
843
    
844
    /* increasing the packet number is correct. The SCR of the following packs
845
       is calculated from the packet_number and it has to include the padding
846
       sector (it represents the sector index, not the MPEG pack index)
847
       (see VCD standard p. IV-6)*/
848
    s->packet_number++;
849
}
850
851 92050933 Michael Niedermayer
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
852 24515926 Hauke Duden
{
853
    MpegMuxContext *s = ctx->priv_data;
854
    int64_t scr;
855
856
        /* Since the data delivery rate is constant, SCR is computed
857
           using the formula C + i * 1200 where C is the start constant
858
           and i is the pack index.
859
           It is recommended that SCR 0 is at the beginning of the VCD front
860
           margin (a sequence of empty Form 2 sectors on the CD).
861
           It is recommended that the front margin is 30 sectors long, so
862
           we use C = 30*1200 = 36000
863
           (Note that even if the front margin is not 30 sectors the file
864
           will still be correct according to the standard. It just won't have
865
           the "recommended" value).*/
866
        scr = 36000 + s->packet_number * 1200;
867 22494489 Hauke Duden
868 24515926 Hauke Duden
    return scr;
869
}    
870
871 7000a175 Michael Niedermayer
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
872
//    MpegMuxContext *s = ctx->priv_data;
873
    int i;
874
875
    for(i=0; i<ctx->nb_streams; i++){
876
        AVStream *st = ctx->streams[i];
877
        StreamInfo *stream = st->priv_data;
878
        PacketDesc *pkt_desc= stream->predecode_packet;
879
        
880
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
881
            if(stream->buffer_index < pkt_desc->size || 
882
               stream->predecode_packet == stream->premux_packet){
883
                av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
884
                break;
885
            }
886
            stream->buffer_index -= pkt_desc->size;
887
888
            stream->predecode_packet= pkt_desc->next;
889
            av_freep(&pkt_desc);
890
        }
891
    }
892
    
893
    return 0;
894
}
895
896
static int output_packet(AVFormatContext *ctx, int flush){
897
    MpegMuxContext *s = ctx->priv_data;
898
    AVStream *st;
899
    StreamInfo *stream;
900
    int i, avail_space, es_size, trailer_size;
901
    int best_i= -1;
902
    int best_score= INT_MIN;
903
    int ignore_constraints=0;
904
    int64_t scr= s->last_scr;
905 bc3429e3 Michael Niedermayer
    PacketDesc *timestamp_packet;
906 17c88cb0 Michael Niedermayer
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
907 7000a175 Michael Niedermayer
908
retry:
909
    for(i=0; i<ctx->nb_streams; i++){
910
        AVStream *st = ctx->streams[i];
911
        StreamInfo *stream = st->priv_data;
912
        const int avail_data=  fifo_size(&stream->fifo, stream->fifo.rptr);
913
        const int space= stream->max_buffer_size - stream->buffer_index;
914
        int rel_space= 1024*space / stream->max_buffer_size;
915 17c88cb0 Michael Niedermayer
        PacketDesc *next_pkt= stream->premux_packet;
916 7000a175 Michael Niedermayer
917
        if(s->packet_size > avail_data && !flush)
918
            return 0;
919
        if(avail_data==0)
920
            continue;
921
        assert(avail_data>0);
922
923
        if(space < s->packet_size && !ignore_constraints)
924
            continue;
925
            
926 17c88cb0 Michael Niedermayer
        if(next_pkt && next_pkt->dts - scr > max_delay)
927
            continue;
928
            
929 7000a175 Michael Niedermayer
        if(rel_space > best_score){
930
            best_score= rel_space;
931
            best_i = i;
932
            avail_space= space;
933
        }
934
    }
935
    
936
    if(best_i < 0){
937
        int64_t best_dts= INT64_MAX;
938
939
        for(i=0; i<ctx->nb_streams; i++){
940
            AVStream *st = ctx->streams[i];
941
            StreamInfo *stream = st->priv_data;
942
            PacketDesc *pkt_desc= stream->predecode_packet;
943
            if(pkt_desc && pkt_desc->dts < best_dts)
944
                best_dts= pkt_desc->dts;
945
        }
946
947
#if 0
948
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n", 
949
               scr/90000.0, best_dts/90000.0);
950
#endif
951
        if(best_dts == INT64_MAX)
952
            return 0;
953
954
        if(scr >= best_dts+1 && !ignore_constraints){
955
            av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
956
            ignore_constraints= 1;
957
        }
958
        scr= FFMAX(best_dts+1, scr);
959
        if(remove_decoded_packets(ctx, scr) < 0)
960
            return -1;
961
        goto retry;
962
    }
963
964
    assert(best_i >= 0);
965
    
966
    st = ctx->streams[best_i];
967
    stream = st->priv_data;
968
    
969
    assert(fifo_size(&stream->fifo, stream->fifo.rptr) > 0);
970
971
    assert(avail_space >= s->packet_size || ignore_constraints);
972
    
973 bc3429e3 Michael Niedermayer
    timestamp_packet= stream->premux_packet;
974
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
975 7000a175 Michael Niedermayer
        trailer_size= 0;
976 bc3429e3 Michael Niedermayer
    }else{
977
        trailer_size= timestamp_packet->unwritten_size;
978
        timestamp_packet= timestamp_packet->next;
979
    }
980 7000a175 Michael Niedermayer
981 bc3429e3 Michael Niedermayer
    if(timestamp_packet){
982 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);
983 bc3429e3 Michael Niedermayer
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
984
    }else{
985
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == trailer_size);
986
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
987
    }
988 7000a175 Michael Niedermayer
989
    if (s->is_vcd) {
990
        /* Write one or more padding sectors, if necessary, to reach
991
           the constant overall bitrate.*/
992
        int vcd_pad_bytes;
993
994 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
995 7000a175 Michael Niedermayer
            put_vcd_padding_sector(ctx);
996
            s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
997
        }
998
    }
999
    
1000
    stream->buffer_index += es_size;
1001
    s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1002
    
1003
    while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1004
        es_size -= stream->premux_packet->unwritten_size;
1005
        stream->premux_packet= stream->premux_packet->next;
1006
    }
1007
    if(es_size)
1008
        stream->premux_packet->unwritten_size -= es_size;
1009
    
1010
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
1011
        return -1;
1012
1013
    return 1;
1014
}
1015 24515926 Hauke Duden
1016 e928649b Michael Niedermayer
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1017 de6d9b64 Fabrice Bellard
{
1018
    MpegMuxContext *s = ctx->priv_data;
1019 e928649b Michael Niedermayer
    int stream_index= pkt->stream_index;
1020
    int size= pkt->size;
1021
    uint8_t *buf= pkt->data;
1022 de6d9b64 Fabrice Bellard
    AVStream *st = ctx->streams[stream_index];
1023
    StreamInfo *stream = st->priv_data;
1024 92050933 Michael Niedermayer
    int64_t pts, dts;
1025 7000a175 Michael Niedermayer
    PacketDesc *pkt_desc;
1026 17c88cb0 Michael Niedermayer
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1027 24515926 Hauke Duden
    
1028 e928649b Michael Niedermayer
    pts= pkt->pts;
1029
    dts= pkt->dts;
1030 e45f1943 Fabrice Bellard
1031 17c88cb0 Michael Niedermayer
    if(pts != AV_NOPTS_VALUE) pts += preload;
1032
    if(dts != AV_NOPTS_VALUE) dts += preload;
1033
1034 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);
1035 7000a175 Michael Niedermayer
    *stream->next_packet=
1036
    pkt_desc= av_mallocz(sizeof(PacketDesc));
1037
    pkt_desc->pts= pts;
1038
    pkt_desc->dts= dts;
1039
    pkt_desc->unwritten_size=
1040
    pkt_desc->size= size;
1041
    if(!stream->predecode_packet)
1042
        stream->predecode_packet= pkt_desc;
1043
    stream->next_packet= &pkt_desc->next;
1044
1045
    if(stream->fifo.end - stream->fifo.buffer - fifo_size(&stream->fifo, stream->fifo.rptr) < size){
1046
        av_log(ctx, AV_LOG_ERROR, "fifo overflow\n");
1047
        return -1;
1048
    }
1049
    fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1050 24515926 Hauke Duden
1051 7000a175 Michael Niedermayer
    for(;;){
1052
        int ret= output_packet(ctx, 0);
1053 92050933 Michael Niedermayer
        if(ret<=0) 
1054 7000a175 Michael Niedermayer
            return ret;
1055 0dbb48d9 Fabrice Bellard
    }
1056 de6d9b64 Fabrice Bellard
}
1057
1058
static int mpeg_mux_end(AVFormatContext *ctx)
1059
{
1060 7000a175 Michael Niedermayer
//    MpegMuxContext *s = ctx->priv_data;
1061 de6d9b64 Fabrice Bellard
    StreamInfo *stream;
1062
    int i;
1063 7000a175 Michael Niedermayer
    
1064
    for(;;){
1065
        int ret= output_packet(ctx, 1);
1066
        if(ret<0) 
1067
            return ret;
1068
        else if(ret==0)
1069
            break;
1070 de6d9b64 Fabrice Bellard
    }
1071
1072 fa0f62c3 Fabrice Bellard
    /* End header according to MPEG1 systems standard. We do not write
1073
       it as it is usually not needed by decoders and because it
1074
       complicates MPEG stream concatenation. */
1075 92b3e125 Juanjo
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
1076
    //put_flush_packet(&ctx->pb);
1077 9d90c37f Michael Niedermayer
1078 7000a175 Michael Niedermayer
    for(i=0;i<ctx->nb_streams;i++) {
1079
        stream = ctx->streams[i]->priv_data;
1080
1081
        assert(fifo_size(&stream->fifo, stream->fifo.rptr) == 0);
1082
        fifo_free(&stream->fifo);
1083
    }
1084 de6d9b64 Fabrice Bellard
    return 0;
1085
}
1086 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
1087 de6d9b64 Fabrice Bellard
1088
/*********************************************/
1089
/* demux code */
1090
1091
#define MAX_SYNC_SIZE 100000
1092
1093 db7f1f95 Fabrice Bellard
static int mpegps_probe(AVProbeData *p)
1094
{
1095 95f97de1 Michael Niedermayer
    int i;
1096
    int size= FFMIN(20, p->buf_size);
1097
    uint32_t code=0xFF;
1098 db7f1f95 Fabrice Bellard
1099
    /* we search the first start code. If it is a packet start code,
1100
       then we decide it is mpeg ps. We do not send highest value to
1101
       give a chance to mpegts */
1102 fa777321 Fabrice Bellard
    /* NOTE: the search range was restricted to avoid too many false
1103
       detections */
1104
1105 95f97de1 Michael Niedermayer
    for (i = 0; i < size; i++) {
1106
        code = (code << 8) | p->buf[i];
1107 ec23a472 Isaac Richards
        if ((code & 0xffffff00) == 0x100) {
1108
            if (code == PACK_START_CODE ||
1109
                code == SYSTEM_HEADER_START_CODE ||
1110
                (code >= 0x1e0 && code <= 0x1ef) ||
1111
                (code >= 0x1c0 && code <= 0x1df) ||
1112
                code == PRIVATE_STREAM_2 ||
1113
                code == PROGRAM_STREAM_MAP ||
1114
                code == PRIVATE_STREAM_1 ||
1115
                code == PADDING_STREAM)
1116 149f7c02 Michael Niedermayer
                return AVPROBE_SCORE_MAX - 2;
1117 ec23a472 Isaac Richards
            else
1118
                return 0;
1119
        }
1120 db7f1f95 Fabrice Bellard
    }
1121
    return 0;
1122
}
1123
1124
1125 de6d9b64 Fabrice Bellard
typedef struct MpegDemuxContext {
1126
    int header_state;
1127
} MpegDemuxContext;
1128
1129 27f388aa Fabrice Bellard
static int mpegps_read_header(AVFormatContext *s,
1130
                              AVFormatParameters *ap)
1131
{
1132
    MpegDemuxContext *m = s->priv_data;
1133
    m->header_state = 0xff;
1134
    s->ctx_flags |= AVFMTCTX_NOHEADER;
1135
1136
    /* no need to do more */
1137
    return 0;
1138
}
1139
1140
static int64_t get_pts(ByteIOContext *pb, int c)
1141
{
1142
    int64_t pts;
1143
    int val;
1144
1145
    if (c < 0)
1146
        c = get_byte(pb);
1147
    pts = (int64_t)((c >> 1) & 0x07) << 30;
1148
    val = get_be16(pb);
1149
    pts |= (int64_t)(val >> 1) << 15;
1150
    val = get_be16(pb);
1151
    pts |= (int64_t)(val >> 1);
1152
    return pts;
1153
}
1154
1155
static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1156
                                uint32_t *header_state)
1157 de6d9b64 Fabrice Bellard
{
1158
    unsigned int state, v;
1159
    int val, n;
1160
1161
    state = *header_state;
1162
    n = *size_ptr;
1163
    while (n > 0) {
1164
        if (url_feof(pb))
1165
            break;
1166
        v = get_byte(pb);
1167
        n--;
1168
        if (state == 0x000001) {
1169
            state = ((state << 8) | v) & 0xffffff;
1170
            val = state;
1171
            goto found;
1172
        }
1173
        state = ((state << 8) | v) & 0xffffff;
1174
    }
1175
    val = -1;
1176
 found:
1177
    *header_state = state;
1178
    *size_ptr = n;
1179
    return val;
1180
}
1181
1182 27f388aa Fabrice Bellard
/* XXX: optimize */
1183
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1184 de6d9b64 Fabrice Bellard
{
1185 27f388aa Fabrice Bellard
    int64_t pos, pos_start;
1186
    int max_size, start_code;
1187 da24c5e3 Fabrice Bellard
1188 27f388aa Fabrice Bellard
    max_size = *size_ptr;
1189
    pos_start = url_ftell(pb);
1190 de6d9b64 Fabrice Bellard
1191 27f388aa Fabrice Bellard
    /* in order to go faster, we fill the buffer */
1192
    pos = pos_start - 16386;
1193
    if (pos < 0)
1194
        pos = 0;
1195
    url_fseek(pb, pos, SEEK_SET);
1196
    get_byte(pb);
1197 de6d9b64 Fabrice Bellard
1198 27f388aa Fabrice Bellard
    pos = pos_start;
1199
    for(;;) {
1200
        pos--;
1201
        if (pos < 0 || (pos_start - pos) >= max_size) {
1202
            start_code = -1;
1203
            goto the_end;
1204
        }
1205
        url_fseek(pb, pos, SEEK_SET);
1206
        start_code = get_be32(pb);
1207
        if ((start_code & 0xffffff00) == 0x100)
1208
            break;
1209
    }
1210
 the_end:
1211
    *size_ptr = pos_start - pos;
1212
    return start_code;
1213 de6d9b64 Fabrice Bellard
}
1214
1215 8d14a25c Michael Niedermayer
/* read the next PES header. Return its position in ppos 
1216 27f388aa Fabrice Bellard
   (if not NULL), and its start code, pts and dts.
1217
 */
1218
static int mpegps_read_pes_header(AVFormatContext *s,
1219
                                  int64_t *ppos, int *pstart_code, 
1220 8d14a25c Michael Niedermayer
                                  int64_t *ppts, int64_t *pdts)
1221 de6d9b64 Fabrice Bellard
{
1222
    MpegDemuxContext *m = s->priv_data;
1223 27f388aa Fabrice Bellard
    int len, size, startcode, c, flags, header_len;
1224
    int64_t pts, dts, last_pos;
1225 de6d9b64 Fabrice Bellard
1226 27f388aa Fabrice Bellard
    last_pos = -1;
1227 de6d9b64 Fabrice Bellard
 redo:
1228 27f388aa Fabrice Bellard
        /* next start code (should be immediately after) */
1229
        m->header_state = 0xff;
1230
        size = MAX_SYNC_SIZE;
1231
        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1232 001e3f55 Juanjo
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1233 de6d9b64 Fabrice Bellard
    if (startcode < 0)
1234 0bd586c5 Mike Melanson
        return AVERROR_IO;
1235 de6d9b64 Fabrice Bellard
    if (startcode == PACK_START_CODE)
1236
        goto redo;
1237
    if (startcode == SYSTEM_HEADER_START_CODE)
1238
        goto redo;
1239
    if (startcode == PADDING_STREAM ||
1240
        startcode == PRIVATE_STREAM_2) {
1241
        /* skip them */
1242
        len = get_be16(&s->pb);
1243
        url_fskip(&s->pb, len);
1244
        goto redo;
1245
    }
1246
    /* find matching stream */
1247
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1248
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1249
          (startcode == 0x1bd)))
1250
        goto redo;
1251 27f388aa Fabrice Bellard
    if (ppos) {
1252
        *ppos = url_ftell(&s->pb) - 4;
1253
    }
1254 de6d9b64 Fabrice Bellard
    len = get_be16(&s->pb);
1255 b2cac184 Fabrice Bellard
    pts = AV_NOPTS_VALUE;
1256
    dts = AV_NOPTS_VALUE;
1257 de6d9b64 Fabrice Bellard
    /* stuffing */
1258
    for(;;) {
1259 27f388aa Fabrice Bellard
        if (len < 1)
1260
            goto redo;
1261 de6d9b64 Fabrice Bellard
        c = get_byte(&s->pb);
1262
        len--;
1263
        /* XXX: for mpeg1, should test only bit 7 */
1264
        if (c != 0xff) 
1265
            break;
1266
    }
1267
    if ((c & 0xc0) == 0x40) {
1268
        /* buffer scale & size */
1269 27f388aa Fabrice Bellard
        if (len < 2)
1270
            goto redo;
1271 de6d9b64 Fabrice Bellard
        get_byte(&s->pb);
1272
        c = get_byte(&s->pb);
1273
        len -= 2;
1274
    }
1275
    if ((c & 0xf0) == 0x20) {
1276 27f388aa Fabrice Bellard
        if (len < 4)
1277
            goto redo;
1278
        dts = pts = get_pts(&s->pb, c);
1279 de6d9b64 Fabrice Bellard
        len -= 4;
1280
    } else if ((c & 0xf0) == 0x30) {
1281 27f388aa Fabrice Bellard
        if (len < 9)
1282
            goto redo;
1283 de6d9b64 Fabrice Bellard
        pts = get_pts(&s->pb, c);
1284
        dts = get_pts(&s->pb, -1);
1285
        len -= 9;
1286
    } else if ((c & 0xc0) == 0x80) {
1287
        /* mpeg 2 PES */
1288
        if ((c & 0x30) != 0) {
1289 27f388aa Fabrice Bellard
            /* Encrypted multiplex not handled */
1290
            goto redo;
1291 de6d9b64 Fabrice Bellard
        }
1292
        flags = get_byte(&s->pb);
1293
        header_len = get_byte(&s->pb);
1294
        len -= 2;
1295
        if (header_len > len)
1296
            goto redo;
1297 1e5c667c Fabrice Bellard
        if ((flags & 0xc0) == 0x80) {
1298 27f388aa Fabrice Bellard
            dts = pts = get_pts(&s->pb, -1);
1299
            if (header_len < 5)
1300
                goto redo;
1301 de6d9b64 Fabrice Bellard
            header_len -= 5;
1302
            len -= 5;
1303
        } if ((flags & 0xc0) == 0xc0) {
1304
            pts = get_pts(&s->pb, -1);
1305
            dts = get_pts(&s->pb, -1);
1306 27f388aa Fabrice Bellard
            if (header_len < 10)
1307
                goto redo;
1308 de6d9b64 Fabrice Bellard
            header_len -= 10;
1309
            len -= 10;
1310
        }
1311
        len -= header_len;
1312
        while (header_len > 0) {
1313
            get_byte(&s->pb);
1314
            header_len--;
1315
        }
1316
    }
1317 df70de1f Dmitry Borisov
    else if( c!= 0xf )
1318
        goto redo;
1319
1320 de6d9b64 Fabrice Bellard
    if (startcode == 0x1bd) {
1321 27f388aa Fabrice Bellard
        if (len < 1)
1322
            goto redo;
1323 de6d9b64 Fabrice Bellard
        startcode = get_byte(&s->pb);
1324
        len--;
1325
        if (startcode >= 0x80 && startcode <= 0xbf) {
1326
            /* audio: skip header */
1327 27f388aa Fabrice Bellard
            if (len < 3)
1328
                goto redo;
1329 de6d9b64 Fabrice Bellard
            get_byte(&s->pb);
1330
            get_byte(&s->pb);
1331
            get_byte(&s->pb);
1332
            len -= 3;
1333
        }
1334
    }
1335 b754978a Michael Niedermayer
    if(dts != AV_NOPTS_VALUE && ppos){
1336
        int i;
1337
        for(i=0; i<s->nb_streams; i++){
1338
            if(startcode == s->streams[i]->id) {
1339 cdd5034f Michael Niedermayer
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0 /* FIXME keyframe? */);
1340 b754978a Michael Niedermayer
            }
1341
        }
1342
    }
1343
    
1344 27f388aa Fabrice Bellard
    *pstart_code = startcode;
1345
    *ppts = pts;
1346
    *pdts = dts;
1347
    return len;
1348
}
1349
1350
static int mpegps_read_packet(AVFormatContext *s,
1351
                              AVPacket *pkt)
1352
{
1353
    AVStream *st;
1354 0bd586c5 Mike Melanson
    int len, startcode, i, type, codec_id = 0;
1355 b754978a Michael Niedermayer
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1356 27f388aa Fabrice Bellard
1357
 redo:
1358 8d14a25c Michael Niedermayer
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1359 27f388aa Fabrice Bellard
    if (len < 0)
1360
        return len;
1361 27a206e0 Michel Bardiaux
    
1362 de6d9b64 Fabrice Bellard
    /* now find stream */
1363
    for(i=0;i<s->nb_streams;i++) {
1364
        st = s->streams[i];
1365
        if (st->id == startcode)
1366
            goto found;
1367
    }
1368 db7f1f95 Fabrice Bellard
    if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1369
        type = CODEC_TYPE_VIDEO;
1370 0dbb48d9 Fabrice Bellard
        codec_id = CODEC_ID_MPEG2VIDEO;
1371 db7f1f95 Fabrice Bellard
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1372
        type = CODEC_TYPE_AUDIO;
1373
        codec_id = CODEC_ID_MP2;
1374 23c99253 Michael Niedermayer
    } else if (startcode >= 0x80 && startcode <= 0x89) {
1375 db7f1f95 Fabrice Bellard
        type = CODEC_TYPE_AUDIO;
1376
        codec_id = CODEC_ID_AC3;
1377 23c99253 Michael Niedermayer
    } else if (startcode >= 0x8a && startcode <= 0x9f) {
1378
        type = CODEC_TYPE_AUDIO;
1379
        codec_id = CODEC_ID_DTS;
1380 9ec05e36 Fabrice Bellard
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1381
        type = CODEC_TYPE_AUDIO;
1382
        codec_id = CODEC_ID_PCM_S16BE;
1383 db7f1f95 Fabrice Bellard
    } else {
1384
    skip:
1385
        /* skip packet */
1386
        url_fskip(&s->pb, len);
1387
        goto redo;
1388
    }
1389 1e5c667c Fabrice Bellard
    /* no stream found: add a new stream */
1390
    st = av_new_stream(s, startcode);
1391
    if (!st) 
1392
        goto skip;
1393 db7f1f95 Fabrice Bellard
    st->codec.codec_type = type;
1394
    st->codec.codec_id = codec_id;
1395 27f388aa Fabrice Bellard
    if (codec_id != CODEC_ID_PCM_S16BE)
1396
        st->need_parsing = 1;
1397 de6d9b64 Fabrice Bellard
 found:
1398 9ec05e36 Fabrice Bellard
    if (startcode >= 0xa0 && startcode <= 0xbf) {
1399
        int b1, freq;
1400
1401
        /* for LPCM, we just skip the header and consider it is raw
1402
           audio data */
1403
        if (len <= 3)
1404
            goto skip;
1405
        get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1406
        b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1407
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1408
        len -= 3;
1409
        freq = (b1 >> 4) & 3;
1410
        st->codec.sample_rate = lpcm_freq_tab[freq];
1411
        st->codec.channels = 1 + (b1 & 7);
1412
        st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
1413
    }
1414 de6d9b64 Fabrice Bellard
    av_new_packet(pkt, len);
1415
    get_buffer(&s->pb, pkt->data, pkt->size);
1416
    pkt->pts = pts;
1417 27f388aa Fabrice Bellard
    pkt->dts = dts;
1418 db7f1f95 Fabrice Bellard
    pkt->stream_index = st->index;
1419 27a206e0 Michel Bardiaux
#if 0
1420 3c895fc0 Michael Niedermayer
    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f\n",
1421 27a206e0 Michel Bardiaux
           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
1422
#endif
1423 0bd586c5 Mike Melanson
1424 de6d9b64 Fabrice Bellard
    return 0;
1425
}
1426
1427 db7f1f95 Fabrice Bellard
static int mpegps_read_close(AVFormatContext *s)
1428 de6d9b64 Fabrice Bellard
{
1429
    return 0;
1430
}
1431
1432 27f388aa Fabrice Bellard
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1433 8d14a25c Michael Niedermayer
                               int64_t *ppos, int64_t pos_limit)
1434 27f388aa Fabrice Bellard
{
1435
    int len, startcode;
1436
    int64_t pos, pts, dts;
1437
1438
    pos = *ppos;
1439
#ifdef DEBUG_SEEK
1440
    printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1441
#endif
1442
    url_fseek(&s->pb, pos, SEEK_SET);
1443
    for(;;) {
1444 8d14a25c Michael Niedermayer
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1445 27f388aa Fabrice Bellard
        if (len < 0) {
1446
#ifdef DEBUG_SEEK
1447
            printf("none (ret=%d)\n", len);
1448
#endif
1449
            return AV_NOPTS_VALUE;
1450
        }
1451
        if (startcode == s->streams[stream_index]->id && 
1452
            dts != AV_NOPTS_VALUE) {
1453
            break;
1454
        }
1455 8d14a25c Michael Niedermayer
        url_fskip(&s->pb, len);
1456 27f388aa Fabrice Bellard
    }
1457
#ifdef DEBUG_SEEK
1458
    printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1459
#endif
1460
    *ppos = pos;
1461 cdd5034f Michael Niedermayer
    return dts;
1462 27f388aa Fabrice Bellard
}
1463
1464 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
1465 fb7566d0 Fabrice Bellard
static AVOutputFormat mpeg1system_mux = {
1466 de6d9b64 Fabrice Bellard
    "mpeg",
1467 fb7566d0 Fabrice Bellard
    "MPEG1 System format",
1468 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1469 fb7566d0 Fabrice Bellard
    "mpg,mpeg",
1470
    sizeof(MpegMuxContext),
1471
    CODEC_ID_MP2,
1472
    CODEC_ID_MPEG1VIDEO,
1473
    mpeg_mux_init,
1474
    mpeg_mux_write_packet,
1475
    mpeg_mux_end,
1476
};
1477
1478
static AVOutputFormat mpeg1vcd_mux = {
1479
    "vcd",
1480
    "MPEG1 System format (VCD)",
1481 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1482 fb7566d0 Fabrice Bellard
    NULL,
1483
    sizeof(MpegMuxContext),
1484
    CODEC_ID_MP2,
1485
    CODEC_ID_MPEG1VIDEO,
1486
    mpeg_mux_init,
1487
    mpeg_mux_write_packet,
1488
    mpeg_mux_end,
1489
};
1490
1491
static AVOutputFormat mpeg2vob_mux = {
1492
    "vob",
1493
    "MPEG2 PS format (VOB)",
1494 c6c11cb6 Ryutaroh Matsumoto
    "video/mpeg",
1495 fb7566d0 Fabrice Bellard
    "vob",
1496 db7f1f95 Fabrice Bellard
    sizeof(MpegMuxContext),
1497 de6d9b64 Fabrice Bellard
    CODEC_ID_MP2,
1498 0dbb48d9 Fabrice Bellard
    CODEC_ID_MPEG2VIDEO,
1499 de6d9b64 Fabrice Bellard
    mpeg_mux_init,
1500
    mpeg_mux_write_packet,
1501
    mpeg_mux_end,
1502 db7f1f95 Fabrice Bellard
};
1503 24515926 Hauke Duden
1504
/* Same as mpeg2vob_mux except that the pack size is 2324 */
1505
static AVOutputFormat mpeg2svcd_mux = {
1506
    "svcd",
1507
    "MPEG2 PS format (VOB)",
1508
    "video/mpeg",
1509
    "vob",
1510
    sizeof(MpegMuxContext),
1511
    CODEC_ID_MP2,
1512
    CODEC_ID_MPEG2VIDEO,
1513
    mpeg_mux_init,
1514
    mpeg_mux_write_packet,
1515
    mpeg_mux_end,
1516
};
1517
1518 78a0efb4 Paul Curtis
/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1519
static AVOutputFormat mpeg2dvd_mux = {
1520
    "dvd",
1521
    "MPEG2 PS format (DVD VOB)",
1522
    "video/mpeg",
1523
    "dvd",
1524
    sizeof(MpegMuxContext),
1525
    CODEC_ID_MP2,
1526
    CODEC_ID_MPEG2VIDEO,
1527
    mpeg_mux_init,
1528
    mpeg_mux_write_packet,
1529
    mpeg_mux_end,
1530
};
1531 24515926 Hauke Duden
1532 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
1533 de6d9b64 Fabrice Bellard
1534 32f38cb4 Fabrice Bellard
AVInputFormat mpegps_demux = {
1535 db7f1f95 Fabrice Bellard
    "mpeg",
1536
    "MPEG PS format",
1537
    sizeof(MpegDemuxContext),
1538
    mpegps_probe,
1539
    mpegps_read_header,
1540
    mpegps_read_packet,
1541
    mpegps_read_close,
1542 8d14a25c Michael Niedermayer
    NULL, //mpegps_read_seek,
1543
    mpegps_read_dts,
1544 de6d9b64 Fabrice Bellard
};
1545 db7f1f95 Fabrice Bellard
1546
int mpegps_init(void)
1547
{
1548 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
1549 fb7566d0 Fabrice Bellard
    av_register_output_format(&mpeg1system_mux);
1550
    av_register_output_format(&mpeg1vcd_mux);
1551
    av_register_output_format(&mpeg2vob_mux);
1552 24515926 Hauke Duden
    av_register_output_format(&mpeg2svcd_mux);
1553 78a0efb4 Paul Curtis
    av_register_output_format(&mpeg2dvd_mux);
1554 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
1555 db7f1f95 Fabrice Bellard
    av_register_input_format(&mpegps_demux);
1556
    return 0;
1557
}