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