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