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