← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavformat/mpeg.c

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-02-25 15:47:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080225154712-qvr11ekcea4c9ry8
Tags: 1.1.6-0.1ubuntu1
https://launchpad.net/bugs/120003
* Merge from debian-multimedia (LP: #120003), Ubuntu Changes:
 - For ffmpeg-related build-deps, remove cvs from package names.
 - Standards-Version 3.7.3
 - Maintainer Spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavformat/mpeg.c
1
1
/*
2
 
 * MPEG1/2 mux/demux
 
2
 * MPEG1/2 muxer and demuxer
3
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4
4
 *
5
 
 * This library is free software; you can redistribute it and/or
 
5
 * This file is part of FFmpeg.
 
6
 *
 
7
 * FFmpeg is free software; you can redistribute it and/or
6
8
 * modify it under the terms of the GNU Lesser General Public
7
9
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
 
10
 * version 2.1 of the License, or (at your option) any later version.
9
11
 *
10
 
 * This library is distributed in the hope that it will be useful,
 
12
 * FFmpeg is distributed in the hope that it will be useful,
11
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
15
 * Lesser General Public License for more details.
14
16
 *
15
17
 * 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
 * License along with FFmpeg; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
20
 */
19
21
#include "avformat.h"
 
22
#include "bitstream.h"
 
23
#include "fifo.h"
20
24
 
21
25
#define MAX_PAYLOAD_SIZE 4096
22
 
#define NB_STREAMS 2
 
26
//#define DEBUG_SEEK
 
27
 
 
28
#undef NDEBUG
 
29
#include <assert.h>
 
30
 
 
31
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;
23
39
 
24
40
typedef struct {
25
 
    uint8_t buffer[MAX_PAYLOAD_SIZE];
26
 
    int buffer_ptr;
 
41
    AVFifoBuffer fifo;
27
42
    uint8_t id;
28
43
    int max_buffer_size; /* in bytes */
 
44
    int buffer_index;
 
45
    PacketDesc *predecode_packet;
 
46
    PacketDesc *premux_packet;
 
47
    PacketDesc **next_packet;
29
48
    int packet_number;
30
 
    int64_t start_pts;
 
49
    uint8_t lpcm_header[3];
 
50
    int lpcm_align;
 
51
    int bytes_to_iframe;
 
52
    int align_iframe;
 
53
    int64_t vobu_start_pts;
31
54
} StreamInfo;
32
55
 
33
56
typedef struct {
34
57
    int packet_size; /* required packet size */
35
 
    int packet_data_max_size; /* maximum data size inside a packet */
36
58
    int packet_number;
37
59
    int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
38
60
    int system_header_freq;
 
61
    int system_header_size;
39
62
    int mux_rate; /* bitrate in units of 50 bytes/s */
40
63
    /* stream info */
41
64
    int audio_bound;
42
65
    int video_bound;
43
66
    int is_mpeg2;
44
67
    int is_vcd;
 
68
    int is_svcd;
 
69
    int is_dvd;
 
70
    int64_t last_scr; /* current system clock */
 
71
 
 
72
    double vcd_padding_bitrate; //FIXME floats
 
73
    int64_t vcd_padding_bytes_written;
 
74
 
45
75
} MpegMuxContext;
46
76
 
47
77
#define PACK_START_CODE             ((unsigned int)0x000001ba)
50
80
#define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
51
81
#define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
52
82
#define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
53
 
  
 
83
 
54
84
/* mpeg2 */
55
85
#define PROGRAM_STREAM_MAP 0x1bc
56
86
#define PRIVATE_STREAM_1   0x1bd
60
90
 
61
91
#define AUDIO_ID 0xc0
62
92
#define VIDEO_ID 0xe0
63
 
 
64
 
extern AVOutputFormat mpeg1system_mux;
65
 
extern AVOutputFormat mpeg1vcd_mux;
66
 
extern AVOutputFormat mpeg2vob_mux;
67
 
 
68
 
static int put_pack_header(AVFormatContext *ctx, 
 
93
#define AC3_ID   0x80
 
94
#define DTS_ID   0x8a
 
95
#define LPCM_ID  0xa0
 
96
#define SUB_ID   0x20
 
97
 
 
98
#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
static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
 
112
 
 
113
#ifdef CONFIG_MUXERS
 
114
AVOutputFormat mpeg1system_muxer;
 
115
AVOutputFormat mpeg1vcd_muxer;
 
116
AVOutputFormat mpeg2vob_muxer;
 
117
AVOutputFormat mpeg2svcd_muxer;
 
118
AVOutputFormat mpeg2dvd_muxer;
 
119
 
 
120
static int put_pack_header(AVFormatContext *ctx,
69
121
                           uint8_t *buf, int64_t timestamp)
70
122
{
71
123
    MpegMuxContext *s = ctx->priv_data;
72
124
    PutBitContext pb;
73
 
    
74
 
    init_put_bits(&pb, buf, 128, NULL, NULL);
 
125
 
 
126
    init_put_bits(&pb, buf, 128);
75
127
 
76
128
    put_bits(&pb, 32, PACK_START_CODE);
77
129
    if (s->is_mpeg2) {
88
140
    if (s->is_mpeg2) {
89
141
        /* clock extension */
90
142
        put_bits(&pb, 9, 0);
91
 
        put_bits(&pb, 1, 1);
92
143
    }
93
144
    put_bits(&pb, 1, 1);
94
145
    put_bits(&pb, 22, s->mux_rate);
95
146
    put_bits(&pb, 1, 1);
96
147
    if (s->is_mpeg2) {
 
148
        put_bits(&pb, 1, 1);
97
149
        put_bits(&pb, 5, 0x1f); /* reserved */
98
150
        put_bits(&pb, 3, 0); /* stuffing length */
99
151
    }
101
153
    return pbBufPtr(&pb) - pb.buf;
102
154
}
103
155
 
104
 
static int put_system_header(AVFormatContext *ctx, uint8_t *buf)
 
156
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
105
157
{
106
158
    MpegMuxContext *s = ctx->priv_data;
107
 
    int size, rate_bound, i, private_stream_coded, id;
 
159
    int size, i, private_stream_coded, id;
108
160
    PutBitContext pb;
109
161
 
110
 
    init_put_bits(&pb, buf, 128, NULL, NULL);
 
162
    init_put_bits(&pb, buf, 128);
111
163
 
112
164
    put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
113
165
    put_bits(&pb, 16, 0);
114
166
    put_bits(&pb, 1, 1);
115
 
    
116
 
    rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
117
 
    put_bits(&pb, 22, rate_bound);
118
 
    put_bits(&pb, 1, 1); /* marker */
119
 
    put_bits(&pb, 6, s->audio_bound);
120
 
 
121
 
    put_bits(&pb, 1, 1); /* variable bitrate */
122
 
    put_bits(&pb, 1, 1); /* non constrainted bit stream */
123
 
    
124
 
    put_bits(&pb, 1, 0); /* audio locked */
125
 
    put_bits(&pb, 1, 0); /* video locked */
126
 
    put_bits(&pb, 1, 1); /* marker */
127
 
 
128
 
    put_bits(&pb, 5, s->video_bound);
129
 
    put_bits(&pb, 8, 0xff); /* reserved byte */
130
 
    
131
 
    /* audio stream info */
132
 
    private_stream_coded = 0;
133
 
    for(i=0;i<ctx->nb_streams;i++) {
134
 
        StreamInfo *stream = ctx->streams[i]->priv_data;
135
 
        id = stream->id;
136
 
        if (id < 0xc0) {
137
 
            /* special case for private streams (AC3 use that) */
138
 
            if (private_stream_coded)
139
 
                continue;
140
 
            private_stream_coded = 1;
141
 
            id = 0xbd;
142
 
        }
143
 
        put_bits(&pb, 8, id); /* stream ID */
144
 
        put_bits(&pb, 2, 3);
145
 
        if (id < 0xe0) {
146
 
            /* audio */
147
 
            put_bits(&pb, 1, 0);
148
 
            put_bits(&pb, 13, stream->max_buffer_size / 128);
149
 
        } else {
150
 
            /* video */
151
 
            put_bits(&pb, 1, 1);
152
 
            put_bits(&pb, 13, stream->max_buffer_size / 1024);
153
 
        }
154
 
    }
 
167
 
 
168
    put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
 
169
    put_bits(&pb, 1, 1); /* marker */
 
170
    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
 
 
176
    if (s->is_vcd) {
 
177
        /* see VCD standard, p. IV-7*/
 
178
        put_bits(&pb, 1, 0);
 
179
        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
 
 
185
    if (s->is_vcd || s->is_dvd) {
 
186
        /* 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
    put_bits(&pb, 1, 1); /* marker */
 
195
 
 
196
    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
 
 
202
    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
 
 
208
    /* DVD-Video Stream_bound entries
 
209
    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
    id (0xBF) private stream 2, NAV packs, set to 2x1024. */
 
213
    if (s->is_dvd) {
 
214
 
 
215
        int P_STD_max_video = 0;
 
216
        int P_STD_max_mpeg_audio = 0;
 
217
        int P_STD_max_mpeg_PS1 = 0;
 
218
 
 
219
        for(i=0;i<ctx->nb_streams;i++) {
 
220
            StreamInfo *stream = ctx->streams[i]->priv_data;
 
221
 
 
222
            id = stream->id;
 
223
            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
            }
 
230
        }
 
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
 
 
264
 
 
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
            }
 
291
        }
 
292
    }
 
293
 
155
294
    flush_put_bits(&pb);
156
295
    size = pbBufPtr(&pb) - pb.buf;
157
296
    /* patch packet size */
161
300
    return size;
162
301
}
163
302
 
 
303
static int get_system_header_size(AVFormatContext *ctx)
 
304
{
 
305
    int buf_index, i, private_stream_coded;
 
306
    StreamInfo *stream;
 
307
    MpegMuxContext *s = ctx->priv_data;
 
308
 
 
309
    if (s->is_dvd)
 
310
       return 18; // DVD-Video system headers are 18 bytes fixed length.
 
311
 
 
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
 
164
326
static int mpeg_mux_init(AVFormatContext *ctx)
165
327
{
166
328
    MpegMuxContext *s = ctx->priv_data;
167
 
    int bitrate, i, mpa_id, mpv_id, ac3_id;
 
329
    int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
168
330
    AVStream *st;
169
331
    StreamInfo *stream;
 
332
    int audio_bitrate;
 
333
    int video_bitrate;
170
334
 
171
335
    s->packet_number = 0;
172
 
    s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
173
 
    s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux);
174
 
    
175
 
    if (s->is_vcd)
176
 
        s->packet_size = 2324; /* VCD packet size */
 
336
    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
 
 
341
    if(ctx->packet_size)
 
342
        s->packet_size = ctx->packet_size;
177
343
    else
178
344
        s->packet_size = 2048;
179
 
        
180
 
    /* startcode(4) + length(2) + flags(1) */
181
 
    s->packet_data_max_size = s->packet_size - 7;
 
345
 
 
346
    s->vcd_padding_bytes_written = 0;
 
347
    s->vcd_padding_bitrate=0;
 
348
 
182
349
    s->audio_bound = 0;
183
350
    s->video_bound = 0;
184
351
    mpa_id = AUDIO_ID;
185
 
    ac3_id = 0x80;
 
352
    ac3_id = AC3_ID;
 
353
    dts_id = DTS_ID;
186
354
    mpv_id = VIDEO_ID;
 
355
    mps_id = SUB_ID;
 
356
    lpcm_id = LPCM_ID;
187
357
    for(i=0;i<ctx->nb_streams;i++) {
188
358
        st = ctx->streams[i];
189
359
        stream = av_mallocz(sizeof(StreamInfo));
191
361
            goto fail;
192
362
        st->priv_data = stream;
193
363
 
194
 
        switch(st->codec.codec_type) {
 
364
        av_set_pts_info(st, 64, 1, 90000);
 
365
 
 
366
        switch(st->codec->codec_type) {
195
367
        case CODEC_TYPE_AUDIO:
196
 
            if (st->codec.codec_id == CODEC_ID_AC3)
 
368
            if (st->codec->codec_id == CODEC_ID_AC3) {
197
369
                stream->id = ac3_id++;
198
 
            else
 
370
            } else if (st->codec->codec_id == CODEC_ID_DTS) {
 
371
                stream->id = dts_id++;
 
372
            } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
 
373
                stream->id = lpcm_id++;
 
374
                for(j = 0; j < 4; j++) {
 
375
                    if (lpcm_freq_tab[j] == st->codec->sample_rate)
 
376
                        break;
 
377
                }
 
378
                if (j == 4)
 
379
                    goto fail;
 
380
                if (st->codec->channels > 8)
 
381
                    return -1;
 
382
                stream->lpcm_header[0] = 0x0c;
 
383
                stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
 
384
                stream->lpcm_header[2] = 0x80;
 
385
                stream->lpcm_align = st->codec->channels * 2;
 
386
            } else {
199
387
                stream->id = mpa_id++;
200
 
            stream->max_buffer_size = 4 * 1024; 
 
388
            }
 
389
 
 
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
            stream->max_buffer_size = 4 * 1024;
201
393
            s->audio_bound++;
202
394
            break;
203
395
        case CODEC_TYPE_VIDEO:
204
396
            stream->id = mpv_id++;
205
 
            stream->max_buffer_size = 46 * 1024; 
 
397
            if (st->codec->rc_buffer_size)
 
398
                stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
 
399
            else
 
400
                stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
 
401
#if 0
 
402
                /* see VCD standard, p. IV-7*/
 
403
                stream->max_buffer_size = 46 * 1024;
 
404
            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
                stream->max_buffer_size = 230 * 1024;
 
408
#endif
206
409
            s->video_bound++;
207
410
            break;
 
411
        case CODEC_TYPE_SUBTITLE:
 
412
            stream->id = mps_id++;
 
413
            stream->max_buffer_size = 16 * 1024;
 
414
            break;
208
415
        default:
209
 
            av_abort();
 
416
            return -1;
210
417
        }
 
418
        av_fifo_init(&stream->fifo, 16);
211
419
    }
212
 
 
213
 
    /* we increase slightly the bitrate to take into account the
214
 
       headers. XXX: compute it exactly */
215
 
    bitrate = 2000;
 
420
    bitrate = 0;
 
421
    audio_bitrate = 0;
 
422
    video_bitrate = 0;
216
423
    for(i=0;i<ctx->nb_streams;i++) {
 
424
        int codec_rate;
217
425
        st = ctx->streams[i];
218
 
        bitrate += st->codec.bit_rate;
219
 
    }
220
 
    s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
221
 
    
 
426
        stream = (StreamInfo*) st->priv_data;
 
427
 
 
428
        if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
 
429
            codec_rate= st->codec->rc_max_rate;
 
430
        else
 
431
            codec_rate= st->codec->bit_rate;
 
432
 
 
433
        if(!codec_rate)
 
434
            codec_rate= (1<<21)*8*50/ctx->nb_streams;
 
435
 
 
436
        bitrate += codec_rate;
 
437
 
 
438
        if (stream->id==AUDIO_ID)
 
439
            audio_bitrate += codec_rate;
 
440
        else if (stream->id==VIDEO_ID)
 
441
            video_bitrate += codec_rate;
 
442
    }
 
443
 
 
444
    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
 
 
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
//        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
 
465
 
 
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
 
 
479
        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
 
480
        s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
 
481
    }
 
482
 
222
483
    if (s->is_vcd || s->is_mpeg2)
223
484
        /* every packet */
224
485
        s->pack_header_freq = 1;
225
486
    else
226
487
        /* every 2 seconds */
227
488
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
228
 
    
 
489
 
 
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
 
229
494
    if (s->is_mpeg2)
230
495
        /* every 200 packets. Need to look at the spec.  */
231
496
        s->system_header_freq = s->pack_header_freq * 40;
232
497
    else if (s->is_vcd)
233
 
        /* every 40 packets, this is my invention */
234
 
        s->system_header_freq = s->pack_header_freq * 40;
 
498
        /* 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;
235
502
    else
236
503
        s->system_header_freq = s->pack_header_freq * 5;
237
 
    
 
504
 
238
505
    for(i=0;i<ctx->nb_streams;i++) {
239
506
        stream = ctx->streams[i]->priv_data;
240
 
        stream->buffer_ptr = 0;
241
507
        stream->packet_number = 0;
242
 
        stream->start_pts = -1;
243
508
    }
 
509
    s->system_header_size = get_system_header_size(ctx);
 
510
    s->last_scr = 0;
244
511
    return 0;
245
512
 fail:
246
513
    for(i=0;i<ctx->nb_streams;i++) {
247
514
        av_free(ctx->streams[i]->priv_data);
248
515
    }
249
 
    return -ENOMEM;
 
516
    return AVERROR(ENOMEM);
 
517
}
 
518
 
 
519
static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
 
520
{
 
521
    put_byte(pb,
 
522
             (id << 4) |
 
523
             (((timestamp >> 30) & 0x07) << 1) |
 
524
             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
 
 
530
/* 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
 
 
541
        full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
 
542
        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
#if 0 /* unused, remove? */
 
555
/* 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
    stream = ctx->streams[stream_index]->priv_data;
 
566
 
 
567
    buf_index = 0;
 
568
    if (((s->packet_number % s->pack_header_freq) == 0)) {
 
569
        /* pack header size */
 
570
        if (s->is_mpeg2)
 
571
            buf_index += 14;
 
572
        else
 
573
            buf_index += 12;
 
574
 
 
575
        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
 
 
580
            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
        } else {
 
586
            if ((s->packet_number % s->system_header_freq) == 0)
 
587
                buf_index += s->system_header_size;
 
588
        }
 
589
    }
 
590
 
 
591
    if ((s->is_vcd && stream->packet_number==0)
 
592
        || (s->is_svcd && s->packet_number==0))
 
593
        /* the first pack of each stream contains only the pack header,
 
594
           the system header and some padding (see VCD standard p. IV-6)
 
595
           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
        if (s->is_mpeg2) {
 
601
            buf_index += 3;
 
602
            if (stream->packet_number==0)
 
603
                buf_index += 3; /* PES extension */
 
604
            buf_index += 1;    /* obligatory stuffing byte */
 
605
        }
 
606
        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
 
 
617
        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
        }
 
630
 
 
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
    }
 
636
    return s->packet_size - buf_index;
 
637
}
 
638
#endif
 
639
 
 
640
/* Write an MPEG padding packet header. */
 
641
static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
 
642
{
 
643
    MpegMuxContext *s = ctx->priv_data;
 
644
    int i;
 
645
 
 
646
    put_be32(pb, PADDING_STREAM);
 
647
    put_be16(pb, packet_bytes - 6);
 
648
    if (!s->is_mpeg2) {
 
649
        put_byte(pb, 0x0f);
 
650
        packet_bytes -= 7;
 
651
    } else
 
652
        packet_bytes -= 6;
 
653
 
 
654
    for(i=0;i<packet_bytes;i++)
 
655
        put_byte(pb, 0xff);
 
656
}
 
657
 
 
658
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
    while(len>0){
 
663
        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;
250
670
}
251
671
 
252
672
/* flush the packet on stream stream_index */
253
 
static void flush_packet(AVFormatContext *ctx, int stream_index)
 
673
static int flush_packet(AVFormatContext *ctx, int stream_index,
 
674
                         int64_t pts, int64_t dts, int64_t scr, int trailer_size)
254
675
{
255
676
    MpegMuxContext *s = ctx->priv_data;
256
677
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
257
678
    uint8_t *buf_ptr;
258
 
    int size, payload_size, startcode, id, len, stuffing_size, i, header_len;
259
 
    int64_t timestamp;
 
679
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
 
680
    int packet_size;
260
681
    uint8_t buffer[128];
261
 
    
 
682
    int zero_trail_bytes = 0;
 
683
    int pad_packet_bytes = 0;
 
684
    int pes_flags;
 
685
    int general_pack = 0;  /*"general" pack without data specific to one stream?*/
 
686
    int nb_frames;
 
687
 
262
688
    id = stream->id;
263
 
    timestamp = stream->start_pts;
264
689
 
265
690
#if 0
266
 
    printf("packet ID=%2x PTS=%0.3f\n", 
267
 
           id, timestamp / 90000.0);
 
691
    printf("packet ID=%2x PTS=%0.3f\n",
 
692
           id, pts / 90000.0);
268
693
#endif
269
694
 
270
695
    buf_ptr = buffer;
271
 
    if (((s->packet_number % s->pack_header_freq) == 0)) {
 
696
 
 
697
    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
272
698
        /* output pack and systems header if needed */
273
 
        size = put_pack_header(ctx, buf_ptr, timestamp);
 
699
        size = put_pack_header(ctx, buf_ptr, scr);
274
700
        buf_ptr += size;
275
 
        if ((s->packet_number % s->system_header_freq) == 0) {
276
 
            size = put_system_header(ctx, buf_ptr);
277
 
            buf_ptr += size;
 
701
        s->last_scr= scr;
 
702
 
 
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
 
 
708
            if (stream->packet_number==0) {
 
709
                size = put_system_header(ctx, buf_ptr, id);
 
710
                buf_ptr += size;
 
711
            }
 
712
        } else if (s->is_dvd) {
 
713
            if (stream->align_iframe || s->packet_number == 0){
 
714
                int PES_bytes_to_fill = s->packet_size - size - 10;
 
715
 
 
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
                if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
 
724
                    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
                } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
 
751
                    pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
 
752
                }
 
753
            }
 
754
        } 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
            }
278
759
        }
279
760
    }
280
761
    size = buf_ptr - buffer;
281
762
    put_buffer(&ctx->pb, buffer, size);
282
763
 
283
 
    /* packet header */
284
 
    if (s->is_mpeg2) {
285
 
        header_len = 8;
286
 
    } else {
287
 
        header_len = 5;
288
 
    }
289
 
    payload_size = s->packet_size - (size + 6 + header_len);
290
 
    if (id < 0xc0) {
291
 
        startcode = PRIVATE_STREAM_1;
292
 
        payload_size -= 4;
293
 
    } else {
294
 
        startcode = 0x100 + id;
295
 
    }
296
 
    stuffing_size = payload_size - stream->buffer_ptr;
297
 
    if (stuffing_size < 0)
298
 
        stuffing_size = 0;
299
 
 
300
 
    put_be32(&ctx->pb, startcode);
301
 
 
302
 
    put_be16(&ctx->pb, payload_size + header_len);
303
 
    /* stuffing */
304
 
    for(i=0;i<stuffing_size;i++)
305
 
        put_byte(&ctx->pb, 0xff);
306
 
 
307
 
    if (s->is_mpeg2) {
308
 
        put_byte(&ctx->pb, 0x80); /* mpeg2 id */
309
 
        put_byte(&ctx->pb, 0x80); /* flags */
310
 
        put_byte(&ctx->pb, 0x05); /* header len (only pts is included) */
311
 
    }
312
 
    put_byte(&ctx->pb, 
313
 
             (0x02 << 4) | 
314
 
             (((timestamp >> 30) & 0x07) << 1) | 
315
 
             1);
316
 
    put_be16(&ctx->pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
317
 
    put_be16(&ctx->pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
318
 
 
319
 
    if (startcode == PRIVATE_STREAM_1) {
320
 
        put_byte(&ctx->pb, id);
321
 
        if (id >= 0x80 && id <= 0xbf) {
322
 
            /* XXX: need to check AC3 spec */
323
 
            put_byte(&ctx->pb, 1);
324
 
            put_byte(&ctx->pb, 0);
325
 
            put_byte(&ctx->pb, 2);
326
 
        }
327
 
    }
328
 
 
329
 
    /* output data */
330
 
    put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
331
 
    put_flush_packet(&ctx->pb);
332
 
    
333
 
    /* preserve remaining data */
334
 
    len = stream->buffer_ptr - payload_size;
335
 
    if (len < 0) 
336
 
        len = 0;
337
 
    memmove(stream->buffer, stream->buffer + stream->buffer_ptr - len, len);
338
 
    stream->buffer_ptr = len;
339
 
 
340
 
    s->packet_number++;
341
 
    stream->packet_number++;
342
 
    stream->start_pts = -1;
343
 
}
344
 
 
345
 
static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
346
 
                                 const uint8_t *buf, int size, int64_t pts)
347
 
{
348
 
    MpegMuxContext *s = ctx->priv_data;
 
764
    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
 
 
771
    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
           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
        /* 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
        pad_packet_bytes = packet_size - zero_trail_bytes;
 
782
    }
 
783
 
 
784
    packet_size -= pad_packet_bytes + zero_trail_bytes;
 
785
 
 
786
    if (packet_size > 0) {
 
787
 
 
788
        /* packet header size */
 
789
        packet_size -= 6;
 
790
 
 
791
        /* packet header */
 
792
        if (s->is_mpeg2) {
 
793
            header_len = 3;
 
794
            if (stream->packet_number==0)
 
795
                header_len += 3; /* PES extension */
 
796
            header_len += 1; /* obligatory stuffing byte */
 
797
        } 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
 
 
810
        payload_size = packet_size - header_len;
 
811
        if (id < 0xc0) {
 
812
            startcode = PRIVATE_STREAM_1;
 
813
            payload_size -= 1;
 
814
            if (id >= 0x40) {
 
815
                payload_size -= 3;
 
816
                if (id >= 0xa0)
 
817
                    payload_size -= 3;
 
818
            }
 
819
        } else {
 
820
            startcode = 0x100 + id;
 
821
        }
 
822
 
 
823
        stuffing_size = payload_size - av_fifo_size(&stream->fifo);
 
824
 
 
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
            if(dts != pts)
 
829
                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
            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
            stuffing_size += timestamp_len;
 
841
            if(payload_size > trailer_size)
 
842
                stuffing_size += payload_size - trailer_size;
 
843
        }
 
844
 
 
845
        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
        if (stuffing_size < 0)
 
857
            stuffing_size = 0;
 
858
        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
 
 
865
        nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
 
866
 
 
867
        put_be32(&ctx->pb, startcode);
 
868
 
 
869
        put_be16(&ctx->pb, packet_size);
 
870
 
 
871
        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
            pes_flags=0;
 
879
 
 
880
            if (pts != AV_NOPTS_VALUE) {
 
881
                pes_flags |= 0x80;
 
882
                if (dts != pts)
 
883
                    pes_flags |= 0x40;
 
884
            }
 
885
 
 
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
 
 
901
            if (pes_flags & 0x01) {  /*write pes extension*/
 
902
                put_byte(&ctx->pb, 0x10); /* flags */
 
903
 
 
904
                /* P-STD buffer info */
 
905
                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
        } else {
 
912
            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
            } else {
 
920
                put_byte(&ctx->pb, 0x0f);
 
921
            }
 
922
        }
 
923
 
 
924
        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
        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
            } else if (id >= 0x40) {
 
943
                /* AC3 */
 
944
                put_byte(&ctx->pb, nb_frames);
 
945
                put_be16(&ctx->pb, trailer_size+1);
 
946
            }
 
947
        }
 
948
 
 
949
        /* output data */
 
950
        if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
 
951
            return -1;
 
952
        stream->bytes_to_iframe -= payload_size - stuffing_size;
 
953
    }else{
 
954
        payload_size=
 
955
        stuffing_size= 0;
 
956
    }
 
957
 
 
958
    if (pad_packet_bytes > 0)
 
959
        put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
 
960
 
 
961
    for(i=0;i<zero_trail_bytes;i++)
 
962
        put_byte(&ctx->pb, 0x00);
 
963
 
 
964
    put_flush_packet(&ctx->pb);
 
965
 
 
966
    s->packet_number++;
 
967
 
 
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
 
 
974
    return payload_size - stuffing_size;
 
975
}
 
976
 
 
977
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
 
 
993
    put_flush_packet(&ctx->pb);
 
994
 
 
995
    /* 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
#if 0 /* unused, remove? */
 
1003
static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
 
1004
{
 
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
 
 
1020
    return scr;
 
1021
}
 
1022
#endif
 
1023
 
 
1024
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
 
 
1033
        while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
 
1034
            if(stream->buffer_index < pkt_desc->size ||
 
1035
               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
 
 
1046
    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
    PacketDesc *timestamp_packet;
 
1059
    const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
 
1060
 
 
1061
retry:
 
1062
    for(i=0; i<ctx->nb_streams; i++){
 
1063
        AVStream *st = ctx->streams[i];
 
1064
        StreamInfo *stream = st->priv_data;
 
1065
        const int avail_data=  av_fifo_size(&stream->fifo);
 
1066
        const int space= stream->max_buffer_size - stream->buffer_index;
 
1067
        int rel_space= 1024*space / stream->max_buffer_size;
 
1068
        PacketDesc *next_pkt= stream->premux_packet;
 
1069
 
 
1070
        /* 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
           && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
 
1074
            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
 
 
1082
        if(next_pkt && next_pkt->dts - scr > max_delay)
 
1083
            continue;
 
1084
 
 
1085
        if(rel_space > best_score){
 
1086
            best_score= rel_space;
 
1087
            best_i = i;
 
1088
            avail_space= space;
 
1089
        }
 
1090
    }
 
1091
 
 
1092
    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
        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
 
1105
               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
 
 
1122
    st = ctx->streams[best_i];
 
1123
    stream = st->priv_data;
 
1124
 
 
1125
    assert(av_fifo_size(&stream->fifo) > 0);
 
1126
 
 
1127
    assert(avail_space >= s->packet_size || ignore_constraints);
 
1128
 
 
1129
    timestamp_packet= stream->premux_packet;
 
1130
    if(timestamp_packet->unwritten_size == timestamp_packet->size){
 
1131
        trailer_size= 0;
 
1132
    }else{
 
1133
        trailer_size= timestamp_packet->unwritten_size;
 
1134
        timestamp_packet= timestamp_packet->next;
 
1135
    }
 
1136
 
 
1137
    if(timestamp_packet){
 
1138
//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
        es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
 
1140
    }else{
 
1141
        assert(av_fifo_size(&stream->fifo) == trailer_size);
 
1142
        es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
 
1143
    }
 
1144
 
 
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
        while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
 
1151
            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
 
 
1156
    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
 
 
1159
    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
 
 
1166
    if(remove_decoded_packets(ctx, s->last_scr) < 0)
 
1167
        return -1;
 
1168
 
 
1169
    return 1;
 
1170
}
 
1171
 
 
1172
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
 
1173
{
 
1174
    MpegMuxContext *s = ctx->priv_data;
 
1175
    int stream_index= pkt->stream_index;
 
1176
    int size= pkt->size;
 
1177
    uint8_t *buf= pkt->data;
349
1178
    AVStream *st = ctx->streams[stream_index];
350
1179
    StreamInfo *stream = st->priv_data;
351
 
    int len;
352
 
    
353
 
    while (size > 0) {
354
 
        /* set pts */
355
 
        if (stream->start_pts == -1) {
356
 
            stream->start_pts = pts;
357
 
        }
358
 
        len = s->packet_data_max_size - stream->buffer_ptr;
359
 
        if (len > size)
360
 
            len = size;
361
 
        memcpy(stream->buffer + stream->buffer_ptr, buf, len);
362
 
        stream->buffer_ptr += len;
363
 
        buf += len;
364
 
        size -= len;
365
 
        while (stream->buffer_ptr >= s->packet_data_max_size) {
366
 
            /* output the packet */
367
 
            if (stream->start_pts == -1)
368
 
                stream->start_pts = pts;
369
 
            flush_packet(ctx, stream_index);
370
 
        }
371
 
    }
372
 
    return 0;
 
1180
    int64_t pts, dts;
 
1181
    PacketDesc *pkt_desc;
 
1182
    const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
 
1183
    const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
 
1184
 
 
1185
    pts= pkt->pts;
 
1186
    dts= pkt->dts;
 
1187
 
 
1188
    if(pts != AV_NOPTS_VALUE) pts += preload;
 
1189
    if(dts != AV_NOPTS_VALUE) dts += preload;
 
1190
 
 
1191
//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
    if (!stream->premux_packet)
 
1193
        stream->next_packet = &stream->premux_packet;
 
1194
    *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
    av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
 
1205
 
 
1206
    if (s->is_dvd){
 
1207
        if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
 
1208
            stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
 
1209
            stream->align_iframe = 1;
 
1210
            stream->vobu_start_pts = pts;
 
1211
        } else {
 
1212
            stream->align_iframe = 0;
 
1213
        }
 
1214
    }
 
1215
 
 
1216
    av_fifo_write(&stream->fifo, buf, size);
 
1217
 
 
1218
    for(;;){
 
1219
        int ret= output_packet(ctx, 0);
 
1220
        if(ret<=0)
 
1221
            return ret;
 
1222
    }
373
1223
}
374
1224
 
375
1225
static int mpeg_mux_end(AVFormatContext *ctx)
376
1226
{
 
1227
//    MpegMuxContext *s = ctx->priv_data;
377
1228
    StreamInfo *stream;
378
1229
    int i;
379
1230
 
380
 
    /* flush each packet */
381
 
    for(i=0;i<ctx->nb_streams;i++) {
382
 
        stream = ctx->streams[i]->priv_data;
383
 
        if (stream->buffer_ptr > 0) {
384
 
            flush_packet(ctx, i);
385
 
        }
 
1231
    for(;;){
 
1232
        int ret= output_packet(ctx, 1);
 
1233
        if(ret<0)
 
1234
            return ret;
 
1235
        else if(ret==0)
 
1236
            break;
386
1237
    }
387
1238
 
388
1239
    /* End header according to MPEG1 systems standard. We do not write
391
1242
    //put_be32(&ctx->pb, ISO_11172_END_CODE);
392
1243
    //put_flush_packet(&ctx->pb);
393
1244
 
394
 
    for(i=0;i<ctx->nb_streams;i++)
395
 
        av_freep(&ctx->streams[i]->priv_data);
 
1245
    for(i=0;i<ctx->nb_streams;i++) {
 
1246
        stream = ctx->streams[i]->priv_data;
396
1247
 
 
1248
        assert(av_fifo_size(&stream->fifo) == 0);
 
1249
        av_fifo_free(&stream->fifo);
 
1250
    }
397
1251
    return 0;
398
1252
}
 
1253
#endif //CONFIG_MUXERS
399
1254
 
400
1255
/*********************************************/
401
1256
/* demux code */
402
1257
 
403
1258
#define MAX_SYNC_SIZE 100000
404
1259
 
 
1260
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
 
405
1274
static int mpegps_probe(AVProbeData *p)
406
1275
{
407
 
    int code, c, i;
408
 
 
409
 
    code = 0xff;
410
 
    /* we search the first start code. If it is a packet start code,
411
 
       then we decide it is mpeg ps. We do not send highest value to
412
 
       give a chance to mpegts */
413
 
    /* NOTE: the search range was restricted to avoid too many false
414
 
       detections */
415
 
 
416
 
    if (p->buf_size < 6)
417
 
        return 0;
418
 
 
419
 
    for (i = 0; i < 20; i++) {
420
 
        c = p->buf[i];
421
 
        code = (code << 8) | c;
 
1276
    uint32_t code= -1;
 
1277
    int sys=0, pspack=0, priv1=0, vid=0, audio=0;
 
1278
    int i;
 
1279
    int score=0;
 
1280
 
 
1281
    score = cdxa_probe(p);
 
1282
    if (score > 0) return score;
 
1283
 
 
1284
    /* Search for MPEG stream */
 
1285
    for(i=0; i<p->buf_size; i++){
 
1286
        code = (code<<8) + p->buf[i];
422
1287
        if ((code & 0xffffff00) == 0x100) {
423
 
            if (code == PACK_START_CODE ||
424
 
                code == SYSTEM_HEADER_START_CODE ||
425
 
                (code >= 0x1e0 && code <= 0x1ef) ||
426
 
                (code >= 0x1c0 && code <= 0x1df) ||
427
 
                code == PRIVATE_STREAM_2 ||
428
 
                code == PROGRAM_STREAM_MAP ||
429
 
                code == PRIVATE_STREAM_1 ||
430
 
                code == PADDING_STREAM)
431
 
                return AVPROBE_SCORE_MAX - 2;
432
 
            else
433
 
                return 0;
 
1288
            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++;
434
1293
        }
435
1294
    }
436
 
    return 0;
 
1295
 
 
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
    if(sys && sys*9 <= pspack*10)
 
1301
        return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
 
1302
    if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
 
1303
        return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
 
1304
    if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
 
1305
        return AVPROBE_SCORE_MAX/2+2;
 
1306
 
 
1307
    //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
 
1308
    return score;
437
1309
}
438
1310
 
439
1311
 
440
1312
typedef struct MpegDemuxContext {
441
 
    int header_state;
 
1313
    int32_t header_state;
 
1314
    unsigned char psm_es_type[256];
442
1315
} MpegDemuxContext;
443
1316
 
444
 
static int find_start_code(ByteIOContext *pb, int *size_ptr, 
445
 
                           uint32_t *header_state)
 
1317
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
static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
 
1344
                                int32_t *header_state)
446
1345
{
447
1346
    unsigned int state, v;
448
1347
    int val, n;
468
1367
    return val;
469
1368
}
470
1369
 
471
 
static int mpegps_read_header(AVFormatContext *s,
472
 
                                  AVFormatParameters *ap)
473
 
{
474
 
    MpegDemuxContext *m = s->priv_data;
475
 
    m->header_state = 0xff;
476
 
    /* no need to do more */
477
 
    return 0;
478
 
}
479
 
 
480
 
static int64_t get_pts(ByteIOContext *pb, int c)
481
 
{
482
 
    int64_t pts;
483
 
    int val;
484
 
 
485
 
    if (c < 0)
486
 
        c = get_byte(pb);
487
 
    pts = (int64_t)((c >> 1) & 0x07) << 30;
488
 
    val = get_be16(pb);
489
 
    pts |= (int64_t)(val >> 1) << 15;
490
 
    val = get_be16(pb);
491
 
    pts |= (int64_t)(val >> 1);
492
 
    return pts;
493
 
}
494
 
 
495
 
static int mpegps_read_packet(AVFormatContext *s,
496
 
                                  AVPacket *pkt)
497
 
{
498
 
    MpegDemuxContext *m = s->priv_data;
499
 
    AVStream *st;
500
 
    int len, size, startcode, i, c, flags, header_len, type, codec_id;
 
1370
#if 0 /* unused, remove? */
 
1371
/* XXX: optimize */
 
1372
static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
 
1373
{
 
1374
    int64_t pos, pos_start;
 
1375
    int max_size, start_code;
 
1376
 
 
1377
    max_size = *size_ptr;
 
1378
    pos_start = url_ftell(pb);
 
1379
 
 
1380
    /* 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
 
 
1387
    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
}
 
1403
#endif
 
1404
 
 
1405
/**
 
1406
 * Extracts stream types from a program stream map
 
1407
 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
 
1408
 *
 
1409
 * @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
/* read the next PES header. Return its position in ppos
 
1440
   (if not NULL), and its start code, pts and dts.
 
1441
 */
 
1442
static int mpegps_read_pes_header(AVFormatContext *s,
 
1443
                                  int64_t *ppos, int *pstart_code,
 
1444
                                  int64_t *ppts, int64_t *pdts)
 
1445
{
 
1446
    MpegDemuxContext *m = s->priv_data;
 
1447
    int len, size, startcode, c, flags, header_len;
 
1448
    int pes_ext, ext2_len, id_ext, skip;
501
1449
    int64_t pts, dts;
 
1450
    int64_t last_sync= url_ftell(&s->pb);
502
1451
 
503
 
    /* next start code (should be immediately after) */
 
1452
 error_redo:
 
1453
        url_fseek(&s->pb, last_sync, SEEK_SET);
504
1454
 redo:
505
 
    m->header_state = 0xff;
506
 
    size = MAX_SYNC_SIZE;
507
 
    startcode = find_start_code(&s->pb, &size, &m->header_state);
508
 
    //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
 
1455
        /* 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
        last_sync = url_ftell(&s->pb);
 
1460
    //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(&s->pb));
509
1461
    if (startcode < 0)
510
 
        return -EIO;
 
1462
        return AVERROR_IO;
511
1463
    if (startcode == PACK_START_CODE)
512
1464
        goto redo;
513
1465
    if (startcode == SYSTEM_HEADER_START_CODE)
519
1471
        url_fskip(&s->pb, len);
520
1472
        goto redo;
521
1473
    }
 
1474
    if (startcode == PROGRAM_STREAM_MAP) {
 
1475
        mpegps_psm_parse(m, &s->pb);
 
1476
        goto redo;
 
1477
    }
 
1478
 
522
1479
    /* find matching stream */
523
1480
    if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
524
1481
          (startcode >= 0x1e0 && startcode <= 0x1ef) ||
525
 
          (startcode == 0x1bd)))
 
1482
          (startcode == 0x1bd) || (startcode == 0x1fd)))
526
1483
        goto redo;
527
 
 
 
1484
    if (ppos) {
 
1485
        *ppos = url_ftell(&s->pb) - 4;
 
1486
    }
528
1487
    len = get_be16(&s->pb);
529
 
    pts = AV_NOPTS_VALUE;
 
1488
    pts =
530
1489
    dts = AV_NOPTS_VALUE;
531
1490
    /* stuffing */
532
1491
    for(;;) {
 
1492
        if (len < 1)
 
1493
            goto error_redo;
533
1494
        c = get_byte(&s->pb);
534
1495
        len--;
535
1496
        /* XXX: for mpeg1, should test only bit 7 */
536
 
        if (c != 0xff) 
 
1497
        if (c != 0xff)
537
1498
            break;
538
1499
    }
539
1500
    if ((c & 0xc0) == 0x40) {
542
1503
        c = get_byte(&s->pb);
543
1504
        len -= 2;
544
1505
    }
545
 
    if ((c & 0xf0) == 0x20) {
546
 
        pts = get_pts(&s->pb, c);
 
1506
    if ((c & 0xe0) == 0x20) {
 
1507
        dts = pts = get_pts(&s->pb, c);
547
1508
        len -= 4;
548
 
    } else if ((c & 0xf0) == 0x30) {
549
 
        pts = get_pts(&s->pb, c);
550
 
        dts = get_pts(&s->pb, -1);
551
 
        len -= 9;
 
1509
        if (c & 0x10){
 
1510
            dts = get_pts(&s->pb, -1);
 
1511
            len -= 5;
 
1512
        }
552
1513
    } else if ((c & 0xc0) == 0x80) {
553
1514
        /* mpeg 2 PES */
 
1515
#if 0 /* some streams have this field set for no apparent reason */
554
1516
        if ((c & 0x30) != 0) {
555
 
            fprintf(stderr, "Encrypted multiplex not handled\n");
556
 
            return -EIO;
 
1517
            /* Encrypted multiplex not handled */
 
1518
            goto redo;
557
1519
        }
 
1520
#endif
558
1521
        flags = get_byte(&s->pb);
559
1522
        header_len = get_byte(&s->pb);
560
1523
        len -= 2;
561
1524
        if (header_len > len)
562
 
            goto redo;
563
 
        if ((flags & 0xc0) == 0x80) {
564
 
            pts = get_pts(&s->pb, -1);
 
1525
            goto error_redo;
 
1526
        len -= header_len;
 
1527
        if (flags & 0x80) {
 
1528
            dts = pts = get_pts(&s->pb, -1);
565
1529
            header_len -= 5;
566
 
            len -= 5;
567
 
        } if ((flags & 0xc0) == 0xc0) {
568
 
            pts = get_pts(&s->pb, -1);
569
 
            dts = get_pts(&s->pb, -1);
570
 
            header_len -= 10;
571
 
            len -= 10;
 
1530
            if (flags & 0x40) {
 
1531
                dts = get_pts(&s->pb, -1);
 
1532
                header_len -= 5;
 
1533
            }
572
1534
        }
573
 
        len -= header_len;
574
 
        while (header_len > 0) {
575
 
            get_byte(&s->pb);
 
1535
        if (flags & 0x01) { /* PES extension */
 
1536
            pes_ext = get_byte(&s->pb);
576
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
            }
577
1557
        }
 
1558
        if(header_len < 0)
 
1559
            goto error_redo;
 
1560
        url_fskip(&s->pb, header_len);
578
1561
    }
579
 
    if (startcode == 0x1bd) {
 
1562
    else if( c!= 0xf )
 
1563
        goto redo;
 
1564
 
 
1565
    if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
580
1566
        startcode = get_byte(&s->pb);
581
1567
        len--;
582
 
        if (startcode >= 0x80 && startcode <= 0xbf) {
 
1568
        if (startcode >= 0x80 && startcode <= 0xcf) {
583
1569
            /* audio: skip header */
584
1570
            get_byte(&s->pb);
585
1571
            get_byte(&s->pb);
586
1572
            get_byte(&s->pb);
587
1573
            len -= 3;
588
 
        }
589
 
    }
 
1574
            if (startcode >= 0xb0 && startcode <= 0xbf) {
 
1575
                /* MLP/TrueHD audio has a 4-byte header */
 
1576
                get_byte(&s->pb);
 
1577
                len--;
 
1578
            }
 
1579
        }
 
1580
    }
 
1581
    if(len<0)
 
1582
        goto error_redo;
 
1583
    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
                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
 
1588
            }
 
1589
        }
 
1590
    }
 
1591
 
 
1592
    *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
    MpegDemuxContext *m = s->priv_data;
 
1602
    AVStream *st;
 
1603
    int len, startcode, i, type, codec_id = 0, es_type;
 
1604
    int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
 
1605
 
 
1606
 redo:
 
1607
    len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
 
1608
    if (len < 0)
 
1609
        return len;
590
1610
 
591
1611
    /* now find stream */
592
1612
    for(i=0;i<s->nb_streams;i++) {
594
1614
        if (st->id == startcode)
595
1615
            goto found;
596
1616
    }
597
 
    if (startcode >= 0x1e0 && startcode <= 0x1ef) {
 
1617
 
 
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
        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;
598
1654
        type = CODEC_TYPE_VIDEO;
599
 
        codec_id = CODEC_ID_MPEG1VIDEO;
600
1655
    } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
601
1656
        type = CODEC_TYPE_AUDIO;
602
1657
        codec_id = CODEC_ID_MP2;
603
 
    } else if (startcode >= 0x80 && startcode <= 0x9f) {
 
1658
    } else if (startcode >= 0x80 && startcode <= 0x87) {
604
1659
        type = CODEC_TYPE_AUDIO;
605
1660
        codec_id = CODEC_ID_AC3;
606
 
    } else if (startcode >= 0xa0 && startcode <= 0xbf) {
 
1661
    } else if ((startcode >= 0x88 && startcode <= 0x8f)
 
1662
               ||( startcode >= 0x98 && startcode <= 0x9f)) {
 
1663
        /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
 
1664
        type = CODEC_TYPE_AUDIO;
 
1665
        codec_id = CODEC_ID_DTS;
 
1666
    } else if (startcode >= 0xa0 && startcode <= 0xaf) {
607
1667
        type = CODEC_TYPE_AUDIO;
608
1668
        codec_id = CODEC_ID_PCM_S16BE;
 
1669
    } 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
    } else if (startcode >= 0x20 && startcode <= 0x3f) {
 
1677
        type = CODEC_TYPE_SUBTITLE;
 
1678
        codec_id = CODEC_ID_DVD_SUBTITLE;
 
1679
    } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
 
1680
        type = CODEC_TYPE_VIDEO;
 
1681
        codec_id = CODEC_ID_VC1;
609
1682
    } else {
610
1683
    skip:
611
1684
        /* skip packet */
614
1687
    }
615
1688
    /* no stream found: add a new stream */
616
1689
    st = av_new_stream(s, startcode);
617
 
    if (!st) 
 
1690
    if (!st)
618
1691
        goto skip;
619
 
    st->codec.codec_type = type;
620
 
    st->codec.codec_id = codec_id;
 
1692
    st->codec->codec_type = type;
 
1693
    st->codec->codec_id = codec_id;
 
1694
    if (codec_id != CODEC_ID_PCM_S16BE)
 
1695
        st->need_parsing = 1;
621
1696
 found:
622
 
    if (startcode >= 0xa0 && startcode <= 0xbf) {
 
1697
    if(st->discard >= AVDISCARD_ALL)
 
1698
        goto skip;
 
1699
    if (startcode >= 0xa0 && startcode <= 0xaf) {
623
1700
        int b1, freq;
624
 
        static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
625
1701
 
626
1702
        /* for LPCM, we just skip the header and consider it is raw
627
1703
           audio data */
632
1708
        get_byte(&s->pb); /* dynamic range control (0x80 = off) */
633
1709
        len -= 3;
634
1710
        freq = (b1 >> 4) & 3;
635
 
        st->codec.sample_rate = lpcm_freq_tab[freq];
636
 
        st->codec.channels = 1 + (b1 & 7);
637
 
        st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
 
1711
        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;
638
1714
    }
639
1715
    av_new_packet(pkt, len);
640
 
    //printf("\nRead Packet ID: %x PTS: %f Size: %d", startcode,
641
 
    //       (float)pts/90000, len);
642
1716
    get_buffer(&s->pb, pkt->data, pkt->size);
643
1717
    pkt->pts = pts;
 
1718
    pkt->dts = dts;
644
1719
    pkt->stream_index = st->index;
 
1720
#if 0
 
1721
    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
#endif
 
1724
 
645
1725
    return 0;
646
1726
}
647
1727
 
650
1730
    return 0;
651
1731
}
652
1732
 
653
 
static AVOutputFormat mpeg1system_mux = {
 
1733
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
 
1734
                               int64_t *ppos, int64_t pos_limit)
 
1735
{
 
1736
    int len, startcode;
 
1737
    int64_t pos, pts, dts;
 
1738
 
 
1739
    pos = *ppos;
 
1740
#ifdef DEBUG_SEEK
 
1741
    printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
 
1742
#endif
 
1743
    url_fseek(&s->pb, pos, SEEK_SET);
 
1744
    for(;;) {
 
1745
        len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
 
1746
        if (len < 0) {
 
1747
#ifdef DEBUG_SEEK
 
1748
            printf("none (ret=%d)\n", len);
 
1749
#endif
 
1750
            return AV_NOPTS_VALUE;
 
1751
        }
 
1752
        if (startcode == s->streams[stream_index]->id &&
 
1753
            dts != AV_NOPTS_VALUE) {
 
1754
            break;
 
1755
        }
 
1756
        url_fskip(&s->pb, len);
 
1757
    }
 
1758
#ifdef DEBUG_SEEK
 
1759
    printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
 
1760
#endif
 
1761
    *ppos = pos;
 
1762
    return dts;
 
1763
}
 
1764
 
 
1765
#ifdef CONFIG_MPEG1SYSTEM_MUXER
 
1766
AVOutputFormat mpeg1system_muxer = {
654
1767
    "mpeg",
655
1768
    "MPEG1 System format",
656
1769
    "video/mpeg",
662
1775
    mpeg_mux_write_packet,
663
1776
    mpeg_mux_end,
664
1777
};
665
 
 
666
 
static AVOutputFormat mpeg1vcd_mux = {
 
1778
#endif
 
1779
#ifdef CONFIG_MPEG1VCD_MUXER
 
1780
AVOutputFormat mpeg1vcd_muxer = {
667
1781
    "vcd",
668
1782
    "MPEG1 System format (VCD)",
669
1783
    "video/mpeg",
675
1789
    mpeg_mux_write_packet,
676
1790
    mpeg_mux_end,
677
1791
};
678
 
 
679
 
static AVOutputFormat mpeg2vob_mux = {
680
 
    "vob",
681
 
    "MPEG2 PS format (VOB)",
682
 
    "video/mpeg",
683
 
    "vob",
684
 
    sizeof(MpegMuxContext),
685
 
    CODEC_ID_MP2,
686
 
    CODEC_ID_MPEG1VIDEO,
687
 
    mpeg_mux_init,
688
 
    mpeg_mux_write_packet,
689
 
    mpeg_mux_end,
690
 
};
691
 
 
692
 
AVInputFormat mpegps_demux = {
 
1792
#endif
 
1793
#ifdef CONFIG_MPEG2VOB_MUXER
 
1794
AVOutputFormat mpeg2vob_muxer = {
 
1795
    "vob",
 
1796
    "MPEG2 PS format (VOB)",
 
1797
    "video/mpeg",
 
1798
    "vob",
 
1799
    sizeof(MpegMuxContext),
 
1800
    CODEC_ID_MP2,
 
1801
    CODEC_ID_MPEG2VIDEO,
 
1802
    mpeg_mux_init,
 
1803
    mpeg_mux_write_packet,
 
1804
    mpeg_mux_end,
 
1805
};
 
1806
#endif
 
1807
 
 
1808
/* Same as mpeg2vob_mux except that the pack size is 2324 */
 
1809
#ifdef CONFIG_MPEG2SVCD_MUXER
 
1810
AVOutputFormat mpeg2svcd_muxer = {
 
1811
    "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
#endif
 
1823
 
 
1824
/*  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
    "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
#endif
 
1839
 
 
1840
#ifdef CONFIG_MPEGPS_DEMUXER
 
1841
AVInputFormat mpegps_demuxer = {
693
1842
    "mpeg",
694
1843
    "MPEG PS format",
695
1844
    sizeof(MpegDemuxContext),
697
1846
    mpegps_read_header,
698
1847
    mpegps_read_packet,
699
1848
    mpegps_read_close,
700
 
    .flags = AVFMT_NOHEADER,
 
1849
    NULL, //mpegps_read_seek,
 
1850
    mpegps_read_dts,
 
1851
    .flags = AVFMT_SHOW_IDS,
701
1852
};
702
 
 
703
 
int mpegps_init(void)
704
 
{
705
 
    av_register_output_format(&mpeg1system_mux);
706
 
    av_register_output_format(&mpeg1vcd_mux);
707
 
    av_register_output_format(&mpeg2vob_mux);
708
 
    av_register_input_format(&mpegps_demux);
709
 
    return 0;
710
 
}
 
1853
#endif