add support for information in CDXA format
[libav.git] / libavformat / mpeg.c
1 /*
2 * MPEG1/2 mux/demux
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4 *
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.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19 #include "avformat.h"
20 #include "bitstream.h"
21
22 #define MAX_PAYLOAD_SIZE 4096
23 //#define DEBUG_SEEK
24
25 #undef NDEBUG
26 #include <assert.h>
27
28 typedef 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
37 typedef struct {
38 FifoBuffer fifo;
39 uint8_t id;
40 int max_buffer_size; /* in bytes */
41 int buffer_index;
42 PacketDesc *predecode_packet;
43 PacketDesc *premux_packet;
44 PacketDesc **next_packet;
45 int packet_number;
46 uint8_t lpcm_header[3];
47 int lpcm_align;
48 uint8_t *fifo_iframe_ptr;
49 int align_iframe;
50 int64_t vobu_start_pts;
51 } StreamInfo;
52
53 typedef struct {
54 int packet_size; /* required packet size */
55 int packet_number;
56 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
57 int system_header_freq;
58 int system_header_size;
59 int mux_rate; /* bitrate in units of 50 bytes/s */
60 /* stream info */
61 int audio_bound;
62 int video_bound;
63 int is_mpeg2;
64 int is_vcd;
65 int is_svcd;
66 int is_dvd;
67 int64_t last_scr; /* current system clock */
68
69 double vcd_padding_bitrate; //FIXME floats
70 int64_t vcd_padding_bytes_written;
71
72 } MpegMuxContext;
73
74 #define PACK_START_CODE ((unsigned int)0x000001ba)
75 #define SYSTEM_HEADER_START_CODE ((unsigned int)0x000001bb)
76 #define SEQUENCE_END_CODE ((unsigned int)0x000001b7)
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
90 #define AC3_ID 0x80
91 #define DTS_ID 0x8a
92 #define LPCM_ID 0xa0
93 #define SUB_ID 0x20
94
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
108 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
109
110 #ifdef CONFIG_MUXERS
111 AVOutputFormat mpeg1system_muxer;
112 AVOutputFormat mpeg1vcd_muxer;
113 AVOutputFormat mpeg2vob_muxer;
114 AVOutputFormat mpeg2svcd_muxer;
115 AVOutputFormat mpeg2dvd_muxer;
116
117 static int put_pack_header(AVFormatContext *ctx,
118 uint8_t *buf, int64_t timestamp)
119 {
120 MpegMuxContext *s = ctx->priv_data;
121 PutBitContext pb;
122
123 init_put_bits(&pb, buf, 128);
124
125 put_bits(&pb, 32, PACK_START_CODE);
126 if (s->is_mpeg2) {
127 put_bits(&pb, 2, 0x1);
128 } else {
129 put_bits(&pb, 4, 0x2);
130 }
131 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
132 put_bits(&pb, 1, 1);
133 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
134 put_bits(&pb, 1, 1);
135 put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
136 put_bits(&pb, 1, 1);
137 if (s->is_mpeg2) {
138 /* clock extension */
139 put_bits(&pb, 9, 0);
140 }
141 put_bits(&pb, 1, 1);
142 put_bits(&pb, 22, s->mux_rate);
143 put_bits(&pb, 1, 1);
144 if (s->is_mpeg2) {
145 put_bits(&pb, 1, 1);
146 put_bits(&pb, 5, 0x1f); /* reserved */
147 put_bits(&pb, 3, 0); /* stuffing length */
148 }
149 flush_put_bits(&pb);
150 return pbBufPtr(&pb) - pb.buf;
151 }
152
153 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
154 {
155 MpegMuxContext *s = ctx->priv_data;
156 int size, i, private_stream_coded, id;
157 PutBitContext pb;
158
159 init_put_bits(&pb, buf, 128);
160
161 put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
162 put_bits(&pb, 16, 0);
163 put_bits(&pb, 1, 1);
164
165 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
166 put_bits(&pb, 1, 1); /* marker */
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);
172
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 }
181
182 if (s->is_vcd || s->is_dvd) {
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
191 put_bits(&pb, 1, 1); /* marker */
192
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);
198
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;
215
216 for(i=0;i<ctx->nb_streams;i++) {
217 StreamInfo *stream = ctx->streams[i]->priv_data;
218
219 id = stream->id;
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;
226 }
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 }
287 }
288 }
289 }
290
291 flush_put_bits(&pb);
292 size = pbBufPtr(&pb) - pb.buf;
293 /* patch packet size */
294 buf[4] = (size - 6) >> 8;
295 buf[5] = (size - 6) & 0xff;
296
297 return size;
298 }
299
300 static int get_system_header_size(AVFormatContext *ctx)
301 {
302 int buf_index, i, private_stream_coded;
303 StreamInfo *stream;
304 MpegMuxContext *s = ctx->priv_data;
305
306 if (s->is_dvd)
307 return 18; // DVD-Video system headers are 18 bytes fixed length.
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
323 static int mpeg_mux_init(AVFormatContext *ctx)
324 {
325 MpegMuxContext *s = ctx->priv_data;
326 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
327 AVStream *st;
328 StreamInfo *stream;
329 int audio_bitrate;
330 int video_bitrate;
331
332 s->packet_number = 0;
333 s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
334 s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
335 s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
336 s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
337
338 if(ctx->packet_size)
339 s->packet_size = ctx->packet_size;
340 else
341 s->packet_size = 2048;
342
343 s->vcd_padding_bytes_written = 0;
344 s->vcd_padding_bitrate=0;
345
346 s->audio_bound = 0;
347 s->video_bound = 0;
348 mpa_id = AUDIO_ID;
349 ac3_id = AC3_ID;
350 dts_id = DTS_ID;
351 mpv_id = VIDEO_ID;
352 mps_id = SUB_ID;
353 lpcm_id = LPCM_ID;
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
361 av_set_pts_info(st, 64, 1, 90000);
362
363 switch(st->codec->codec_type) {
364 case CODEC_TYPE_AUDIO:
365 if (st->codec->codec_id == CODEC_ID_AC3) {
366 stream->id = ac3_id++;
367 } else if (st->codec->codec_id == CODEC_ID_DTS) {
368 stream->id = dts_id++;
369 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
370 stream->id = lpcm_id++;
371 for(j = 0; j < 4; j++) {
372 if (lpcm_freq_tab[j] == st->codec->sample_rate)
373 break;
374 }
375 if (j == 4)
376 goto fail;
377 if (st->codec->channels > 8)
378 return -1;
379 stream->lpcm_header[0] = 0x0c;
380 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
381 stream->lpcm_header[2] = 0x80;
382 stream->lpcm_align = st->codec->channels * 2;
383 } else {
384 stream->id = mpa_id++;
385 }
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.*/
389 stream->max_buffer_size = 4 * 1024;
390 s->audio_bound++;
391 break;
392 case CODEC_TYPE_VIDEO:
393 stream->id = mpv_id++;
394 if (st->codec->rc_buffer_size)
395 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
396 else
397 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
398 #if 0
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;
405 #endif
406 s->video_bound++;
407 break;
408 case CODEC_TYPE_SUBTITLE:
409 stream->id = mps_id++;
410 stream->max_buffer_size = 16 * 1024;
411 break;
412 default:
413 return -1;
414 }
415 fifo_init(&stream->fifo, 16);
416 }
417 bitrate = 0;
418 audio_bitrate = 0;
419 video_bitrate = 0;
420 for(i=0;i<ctx->nb_streams;i++) {
421 int codec_rate;
422 st = ctx->streams[i];
423 stream = (StreamInfo*) st->priv_data;
424
425 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
426 codec_rate= st->codec->rc_max_rate;
427 else
428 codec_rate= st->codec->bit_rate;
429
430 if(!codec_rate)
431 codec_rate= (1<<21)*8*50/ctx->nb_streams;
432
433 bitrate += codec_rate;
434
435 if (stream->id==AUDIO_ID)
436 audio_bitrate += codec_rate;
437 else if (stream->id==VIDEO_ID)
438 video_bitrate += codec_rate;
439 }
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 }
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.*/
461 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
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);
478 }
479
480 if (s->is_vcd || s->is_mpeg2)
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;
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;
490
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)
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;
499 else
500 s->system_header_freq = s->pack_header_freq * 5;
501
502 for(i=0;i<ctx->nb_streams;i++) {
503 stream = ctx->streams[i]->priv_data;
504 stream->packet_number = 0;
505 }
506 s->system_header_size = get_system_header_size(ctx);
507 s->last_scr = 0;
508 return 0;
509 fail:
510 for(i=0;i<ctx->nb_streams;i++) {
511 av_free(ctx->streams[i]->priv_data);
512 }
513 return -ENOMEM;
514 }
515
516 static 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
526
527 /* return the number of padding bytes that should be inserted into
528 the multiplexed stream.*/
529 static 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
538 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
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
551 #if 0 /* unused, remove? */
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. */
555 static 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
562 stream = ctx->streams[stream_index]->priv_data;
563
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;
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 }
586 }
587
588 if ((s->is_vcd && stream->packet_number==0)
589 || (s->is_svcd && s->packet_number==0))
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;
597 if (s->is_mpeg2) {
598 buf_index += 3;
599 if (stream->packet_number==0)
600 buf_index += 3; /* PES extension */
601 buf_index += 1; /* obligatory stuffing byte */
602 }
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 }
626 }
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;
632 }
633 return s->packet_size - buf_index;
634 }
635 #endif
636
637 /* Write an MPEG padding packet header. */
638 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
639 {
640 MpegMuxContext *s = ctx->priv_data;
641 int i;
642
643 put_be32(pb, PADDING_STREAM);
644 put_be16(pb, packet_bytes - 6);
645 if (!s->is_mpeg2) {
646 put_byte(pb, 0x0f);
647 packet_bytes -= 7;
648 } else
649 packet_bytes -= 6;
650
651 for(i=0;i<packet_bytes;i++)
652 put_byte(pb, 0xff);
653 }
654
655 static 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 }
668
669 /* flush the packet on stream stream_index */
670 static int flush_packet(AVFormatContext *ctx, int stream_index,
671 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
672 {
673 MpegMuxContext *s = ctx->priv_data;
674 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
675 uint8_t *buf_ptr;
676 int size, payload_size, startcode, id, stuffing_size, i, header_len;
677 int packet_size;
678 uint8_t buffer[128];
679 int zero_trail_bytes = 0;
680 int pad_packet_bytes = 0;
681 int pes_flags;
682 int general_pack = 0; /*"general" pack without data specific to one stream?*/
683 int nb_frames;
684
685 id = stream->id;
686
687 #if 0
688 printf("packet ID=%2x PTS=%0.3f\n",
689 id, pts / 90000.0);
690 #endif
691
692 buf_ptr = buffer;
693
694 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
695 /* output pack and systems header if needed */
696 size = put_pack_header(ctx, buf_ptr, scr);
697 buf_ptr += size;
698 s->last_scr= scr;
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 }
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 }
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 }
763 }
764 }
765 size = buf_ptr - buffer;
766 put_buffer(&ctx->pb, buffer, size);
767
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
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,
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.*/
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*/
785 pad_packet_bytes = packet_size - zero_trail_bytes;
786 }
787
788 packet_size -= pad_packet_bytes + zero_trail_bytes;
789
790 if (packet_size > 0) {
791
792 /* packet header size */
793 packet_size -= 6;
794
795 /* packet header */
796 if (s->is_mpeg2) {
797 header_len = 3;
798 if (stream->packet_number==0)
799 header_len += 3; /* PES extension */
800 header_len += 1; /* obligatory stuffing byte */
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 }
813
814 payload_size = packet_size - header_len;
815 if (id < 0xc0) {
816 startcode = PRIVATE_STREAM_1;
817 payload_size -= 1;
818 if (id >= 0x40) {
819 payload_size -= 3;
820 if (id >= 0xa0)
821 payload_size -= 3;
822 }
823 } else {
824 startcode = 0x100 + id;
825 }
826
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;
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 }
844 stuffing_size += timestamp_len;
845 if(payload_size > trailer_size)
846 stuffing_size += payload_size - trailer_size;
847 }
848
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
860 if (stuffing_size < 0)
861 stuffing_size = 0;
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 }
868
869 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
870
871 put_be32(&ctx->pb, startcode);
872
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
882 pes_flags=0;
883
884 if (pts != AV_NOPTS_VALUE) {
885 pes_flags |= 0x80;
886 if (dts != pts)
887 pes_flags |= 0x40;
888 }
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
915 } else {
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 }
923 } else {
924 put_byte(&ctx->pb, 0x0f);
925 }
926 }
927
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
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]);
946 } else if (id >= 0x40) {
947 /* AC3 */
948 put_byte(&ctx->pb, nb_frames);
949 put_be16(&ctx->pb, trailer_size+1);
950 }
951 }
952
953 /* output data */
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;
959 }
960
961 if (pad_packet_bytes > 0)
962 put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
963
964 for(i=0;i<zero_trail_bytes;i++)
965 put_byte(&ctx->pb, 0x00);
966
967 put_flush_packet(&ctx->pb);
968
969 s->packet_number++;
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++;
976
977 return payload_size - stuffing_size;
978 }
979
980 static 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
1005 #if 0 /* unused, remove? */
1006 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
1007 {
1008 MpegMuxContext *s = ctx->priv_data;
1009 int64_t scr;
1010
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;
1022
1023 return scr;
1024 }
1025 #endif
1026
1027 static 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
1052 static 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;
1061 PacketDesc *timestamp_packet;
1062 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1063
1064 retry:
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;
1071 PacketDesc *next_pkt= stream->premux_packet;
1072
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
1076 && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
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
1085 if(next_pkt && next_pkt->dts - scr > max_delay)
1086 continue;
1087
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
1132 timestamp_packet= stream->premux_packet;
1133 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1134 trailer_size= 0;
1135 }else{
1136 trailer_size= timestamp_packet->unwritten_size;
1137 timestamp_packet= timestamp_packet->next;
1138 }
1139
1140 if(timestamp_packet){
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);
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 }
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
1153 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
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 }
1174
1175 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1176 {
1177 MpegMuxContext *s = ctx->priv_data;
1178 int stream_index= pkt->stream_index;
1179 int size= pkt->size;
1180 uint8_t *buf= pkt->data;
1181 AVStream *st = ctx->streams[stream_index];
1182 StreamInfo *stream = st->priv_data;
1183 int64_t pts, dts;
1184 PacketDesc *pkt_desc;
1185 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1186 const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1187
1188 pts= pkt->pts;
1189 dts= pkt->dts;
1190
1191 if(pts != AV_NOPTS_VALUE) pts += preload;
1192 if(dts != AV_NOPTS_VALUE) dts += preload;
1193
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);
1195 if (!stream->premux_packet)
1196 stream->next_packet = &stream->premux_packet;
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
1207 fifo_realloc(&stream->fifo, fifo_size(&stream->fifo, NULL) + size + 1);
1208
1209 if (s->is_dvd){
1210 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1211 stream->fifo_iframe_ptr = stream->fifo.wptr;
1212 stream->align_iframe = 1;
1213 stream->vobu_start_pts = pts;
1214 } else {
1215 stream->align_iframe = 0;
1216 }
1217 }
1218
1219 fifo_write(&stream->fifo, buf, size, &stream->fifo.wptr);
1220
1221 for(;;){
1222 int ret= output_packet(ctx, 0);
1223 if(ret<=0)
1224 return ret;
1225 }
1226 }
1227
1228 static int mpeg_mux_end(AVFormatContext *ctx)
1229 {
1230 // MpegMuxContext *s = ctx->priv_data;
1231 StreamInfo *stream;
1232 int i;
1233
1234 for(;;){
1235 int ret= output_packet(ctx, 1);
1236 if(ret<0)
1237 return ret;
1238 else if(ret==0)
1239 break;
1240 }
1241
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. */
1245 //put_be32(&ctx->pb, ISO_11172_END_CODE);
1246 //put_flush_packet(&ctx->pb);
1247
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 }
1254 return 0;
1255 }
1256 #endif //CONFIG_MUXERS
1257
1258 /*********************************************/
1259 /* demux code */
1260
1261 #define MAX_SYNC_SIZE 100000
1262
1263 static int cdxa_probe(AVProbeData *p)
1264 {
1265 /* check file header */
1266 if (p->buf_size <= 32)
1267 return 0;
1268 if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1269 p->buf[2] == 'F' && p->buf[3] == 'F' &&
1270 p->buf[8] == 'C' && p->buf[9] == 'D' &&
1271 p->buf[10] == 'X' && p->buf[11] == 'A')
1272 return AVPROBE_SCORE_MAX;
1273 else
1274 return 0;
1275 }
1276
1277 static int mpegps_probe(AVProbeData *p)
1278 {
1279 uint32_t code= -1;
1280 int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1281 int i;
1282 int score=0;
1283
1284 score = cdxa_probe(p);
1285 if (score > 0) return score;
1286
1287 /* Search for MPEG stream */
1288 for(i=0; i<p->buf_size; i++){
1289 code = (code<<8) + p->buf[i];
1290 if ((code & 0xffffff00) == 0x100) {
1291 if(code == SYSTEM_HEADER_START_CODE) sys++;
1292 else if(code == PRIVATE_STREAM_1) priv1++;
1293 else if(code == PACK_START_CODE) pspack++;
1294 else if((code & 0xf0) == VIDEO_ID) vid++;
1295 else if((code & 0xe0) == AUDIO_ID) audio++;
1296 }
1297 }
1298
1299 if(vid || audio) /* invalid VDR files nd short PES streams */
1300 score= AVPROBE_SCORE_MAX/4;
1301
1302 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1303 if(sys && sys*9 <= pspack*10)
1304 return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1305 if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1306 return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1307 if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1308 return AVPROBE_SCORE_MAX/2+2;
1309
1310 //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1311 return score;
1312 }
1313
1314
1315 typedef struct MpegDemuxContext {
1316 int header_state;
1317 unsigned char psm_es_type[256];
1318 } MpegDemuxContext;
1319
1320 static int mpegps_read_header(AVFormatContext *s,
1321 AVFormatParameters *ap)
1322 {
1323 MpegDemuxContext *m = s->priv_data;
1324 m->header_state = 0xff;
1325 s->ctx_flags |= AVFMTCTX_NOHEADER;
1326
1327 /* no need to do more */
1328 return 0;
1329 }
1330
1331 static int64_t get_pts(ByteIOContext *pb, int c)
1332 {
1333 int64_t pts;
1334 int val;
1335
1336 if (c < 0)
1337 c = get_byte(pb);
1338 pts = (int64_t)((c >> 1) & 0x07) << 30;
1339 val = get_be16(pb);
1340 pts |= (int64_t)(val >> 1) << 15;
1341 val = get_be16(pb);
1342 pts |= (int64_t)(val >> 1);
1343 return pts;
1344 }
1345
1346 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1347 uint32_t *header_state)
1348 {
1349 unsigned int state, v;
1350 int val, n;
1351
1352 state = *header_state;
1353 n = *size_ptr;
1354 while (n > 0) {
1355 if (url_feof(pb))
1356 break;
1357 v = get_byte(pb);
1358 n--;
1359 if (state == 0x000001) {
1360 state = ((state << 8) | v) & 0xffffff;
1361 val = state;
1362 goto found;
1363 }
1364 state = ((state << 8) | v) & 0xffffff;
1365 }
1366 val = -1;
1367 found:
1368 *header_state = state;
1369 *size_ptr = n;
1370 return val;
1371 }
1372
1373 #if 0 /* unused, remove? */
1374 /* XXX: optimize */
1375 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1376 {
1377 int64_t pos, pos_start;
1378 int max_size, start_code;
1379
1380 max_size = *size_ptr;
1381 pos_start = url_ftell(pb);
1382
1383 /* in order to go faster, we fill the buffer */
1384 pos = pos_start - 16386;
1385 if (pos < 0)
1386 pos = 0;
1387 url_fseek(pb, pos, SEEK_SET);
1388 get_byte(pb);
1389
1390 pos = pos_start;
1391 for(;;) {
1392 pos--;
1393 if (pos < 0 || (pos_start - pos) >= max_size) {
1394 start_code = -1;
1395 goto the_end;
1396 }
1397 url_fseek(pb, pos, SEEK_SET);
1398 start_code = get_be32(pb);
1399 if ((start_code & 0xffffff00) == 0x100)
1400 break;
1401 }
1402 the_end:
1403 *size_ptr = pos_start - pos;
1404 return start_code;
1405 }
1406 #endif
1407
1408 /**
1409 * Extracts stream types from a program stream map
1410 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1411 *
1412 * @return number of bytes occupied by PSM in the bitstream
1413 */
1414 static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1415 {
1416 int psm_length, ps_info_length, es_map_length;
1417
1418 psm_length = get_be16(pb);
1419 get_byte(pb);
1420 get_byte(pb);
1421 ps_info_length = get_be16(pb);
1422
1423 /* skip program_stream_info */
1424 url_fskip(pb, ps_info_length);
1425 es_map_length = get_be16(pb);
1426
1427 /* at least one es available? */
1428 while (es_map_length >= 4){
1429 unsigned char type = get_byte(pb);
1430 unsigned char es_id = get_byte(pb);
1431 uint16_t es_info_length = get_be16(pb);
1432 /* remember mapping from stream id to stream type */
1433 m->psm_es_type[es_id] = type;
1434 /* skip program_stream_info */
1435 url_fskip(pb, es_info_length);
1436 es_map_length -= 4 + es_info_length;
1437 }
1438 get_be32(pb); /* crc32 */
1439 return 2 + psm_length;
1440 }
1441
1442 /* read the next PES header. Return its position in ppos
1443 (if not NULL), and its start code, pts and dts.
1444 */
1445 static int mpegps_read_pes_header(AVFormatContext *s,
1446 int64_t *ppos, int *pstart_code,
1447 int64_t *ppts, int64_t *pdts)
1448 {
1449 MpegDemuxContext *m = s->priv_data;
1450 int len, size, startcode, c, flags, header_len;
1451 int64_t pts, dts, last_pos;
1452
1453 last_pos = -1;
1454 redo:
1455 /* next start code (should be immediately after) */
1456 m->header_state = 0xff;
1457 size = MAX_SYNC_SIZE;
1458 startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1459 //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1460 if (startcode < 0)
1461 return AVERROR_IO;
1462 if (startcode == PACK_START_CODE)
1463 goto redo;
1464 if (startcode == SYSTEM_HEADER_START_CODE)
1465 goto redo;
1466 if (startcode == PADDING_STREAM ||
1467 startcode == PRIVATE_STREAM_2) {
1468 /* skip them */
1469 len = get_be16(&s->pb);
1470 url_fskip(&s->pb, len);
1471 goto redo;
1472 }
1473 if (startcode == PROGRAM_STREAM_MAP) {
1474 mpegps_psm_parse(m, &s->pb);
1475 goto redo;
1476 }
1477
1478 /* find matching stream */
1479 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1480 (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1481 (startcode == 0x1bd)))
1482 goto redo;
1483 if (ppos) {
1484 *ppos = url_ftell(&s->pb) - 4;
1485 }
1486 len = get_be16(&s->pb);
1487 pts = AV_NOPTS_VALUE;
1488 dts = AV_NOPTS_VALUE;
1489 /* stuffing */
1490 for(;;) {
1491 if (len < 1)
1492 goto redo;
1493 c = get_byte(&s->pb);
1494 len--;
1495 /* XXX: for mpeg1, should test only bit 7 */
1496 if (c != 0xff)
1497 break;
1498 }
1499 if ((c & 0xc0) == 0x40) {
1500 /* buffer scale & size */
1501 if (len < 2)
1502 goto redo;
1503 get_byte(&s->pb);
1504 c = get_byte(&s->pb);
1505 len -= 2;
1506 }
1507 if ((c & 0xf0) == 0x20) {
1508 if (len < 4)
1509 goto redo;
1510 dts = pts = get_pts(&s->pb, c);
1511 len -= 4;
1512 } else if ((c & 0xf0) == 0x30) {
1513 if (len < 9)
1514 goto redo;
1515 pts = get_pts(&s->pb, c);
1516 dts = get_pts(&s->pb, -1);
1517 len -= 9;
1518 } else if ((c & 0xc0) == 0x80) {
1519 /* mpeg 2 PES */
1520 #if 0 /* some streams have this field set for no apparent reason */
1521 if ((c & 0x30) != 0) {
1522 /* Encrypted multiplex not handled */
1523 goto redo;
1524 }
1525 #endif
1526 flags = get_byte(&s->pb);
1527 header_len = get_byte(&s->pb);
1528 len -= 2;
1529 if (header_len > len)
1530 goto redo;
1531 if ((flags & 0xc0) == 0x80) {
1532 dts = pts = get_pts(&s->pb, -1);
1533 if (header_len < 5)
1534 goto redo;
1535 header_len -= 5;
1536 len -= 5;
1537 } if ((flags & 0xc0) == 0xc0) {
1538 pts = get_pts(&s->pb, -1);
1539 dts = get_pts(&s->pb, -1);
1540 if (header_len < 10)
1541 goto redo;
1542 header_len -= 10;
1543 len -= 10;
1544 }
1545 len -= header_len;
1546 while (header_len > 0) {
1547 get_byte(&s->pb);
1548 header_len--;
1549 }
1550 }
1551 else if( c!= 0xf )
1552 goto redo;
1553
1554 if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1555 if (len < 1)
1556 goto redo;
1557 startcode = get_byte(&s->pb);
1558 len--;
1559 if (startcode >= 0x80 && startcode <= 0xbf) {
1560 /* audio: skip header */
1561 if (len < 3)
1562 goto redo;
1563 get_byte(&s->pb);
1564 get_byte(&s->pb);
1565 get_byte(&s->pb);
1566 len -= 3;
1567 }
1568 }
1569 if(dts != AV_NOPTS_VALUE && ppos){
1570 int i;
1571 for(i=0; i<s->nb_streams; i++){
1572 if(startcode == s->streams[i]->id) {
1573 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1574 }
1575 }
1576 }
1577
1578 *pstart_code = startcode;
1579 *ppts = pts;
1580 *pdts = dts;
1581 return len;
1582 }
1583
1584 static int mpegps_read_packet(AVFormatContext *s,
1585 AVPacket *pkt)
1586 {
1587 MpegDemuxContext *m = s->priv_data;
1588 AVStream *st;
1589 int len, startcode, i, type, codec_id = 0, es_type;
1590 int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1591
1592 redo:
1593 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1594 if (len < 0)
1595 return len;
1596
1597 /* now find stream */
1598 for(i=0;i<s->nb_streams;i++) {
1599 st = s->streams[i];
1600 if (st->id == startcode)
1601 goto found;
1602 }
1603
1604 es_type = m->psm_es_type[startcode & 0xff];
1605 if(es_type > 0){
1606 if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1607 codec_id = CODEC_ID_MPEG2VIDEO;
1608 type = CODEC_TYPE_VIDEO;
1609 } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1610 codec_id = CODEC_ID_MPEG2VIDEO;
1611 type = CODEC_TYPE_VIDEO;
1612 } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1613 es_type == STREAM_TYPE_AUDIO_MPEG2){
1614 codec_id = CODEC_ID_MP3;
1615 type = CODEC_TYPE_AUDIO;
1616 } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1617 codec_id = CODEC_ID_AAC;
1618 type = CODEC_TYPE_AUDIO;
1619 } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1620 codec_id = CODEC_ID_MPEG4;
1621 type = CODEC_TYPE_VIDEO;
1622 } else if(es_type == STREAM_TYPE_VIDEO_H264){
1623 codec_id = CODEC_ID_H264;
1624 type = CODEC_TYPE_VIDEO;
1625 } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1626 codec_id = CODEC_ID_AC3;
1627 type = CODEC_TYPE_AUDIO;
1628 } else {
1629 goto skip;
1630 }
1631 } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1632 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1633 unsigned char buf[8];
1634 get_buffer(&s->pb, buf, 8);
1635 url_fseek(&s->pb, -8, SEEK_CUR);
1636 if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1637 codec_id = CODEC_ID_CAVS;
1638 else
1639 codec_id = CODEC_ID_MPEG2VIDEO;
1640 type = CODEC_TYPE_VIDEO;
1641 } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1642 type = CODEC_TYPE_AUDIO;
1643 codec_id = CODEC_ID_MP2;
1644 } else if (startcode >= 0x80 && startcode <= 0x87) {
1645 type = CODEC_TYPE_AUDIO;
1646 codec_id = CODEC_ID_AC3;
1647 } else if (startcode >= 0x88 && startcode <= 0x9f) {
1648 type = CODEC_TYPE_AUDIO;
1649 codec_id = CODEC_ID_DTS;
1650 } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1651 type = CODEC_TYPE_AUDIO;
1652 codec_id = CODEC_ID_PCM_S16BE;
1653 } else if (startcode >= 0x20 && startcode <= 0x3f) {
1654 type = CODEC_TYPE_SUBTITLE;
1655 codec_id = CODEC_ID_DVD_SUBTITLE;
1656 } else {
1657 skip:
1658 /* skip packet */
1659 url_fskip(&s->pb, len);
1660 goto redo;
1661 }
1662 /* no stream found: add a new stream */
1663 st = av_new_stream(s, startcode);
1664 if (!st)
1665 goto skip;
1666 st->codec->codec_type = type;
1667 st->codec->codec_id = codec_id;
1668 if (codec_id != CODEC_ID_PCM_S16BE)
1669 st->need_parsing = 1;
1670 found:
1671 if(st->discard >= AVDISCARD_ALL)
1672 goto skip;
1673 if (startcode >= 0xa0 && startcode <= 0xbf) {
1674 int b1, freq;
1675
1676 /* for LPCM, we just skip the header and consider it is raw
1677 audio data */
1678 if (len <= 3)
1679 goto skip;
1680 get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1681 b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1682 get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1683 len -= 3;
1684 freq = (b1 >> 4) & 3;
1685 st->codec->sample_rate = lpcm_freq_tab[freq];
1686 st->codec->channels = 1 + (b1 & 7);
1687 st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1688 }
1689 av_new_packet(pkt, len);
1690 get_buffer(&s->pb, pkt->data, pkt->size);
1691 pkt->pts = pts;
1692 pkt->dts = dts;
1693 pkt->stream_index = st->index;
1694 #if 0
1695 av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1696 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1697 #endif
1698
1699 return 0;
1700 }
1701
1702 static int mpegps_read_close(AVFormatContext *s)
1703 {
1704 return 0;
1705 }
1706
1707 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1708 int64_t *ppos, int64_t pos_limit)
1709 {
1710 int len, startcode;
1711 int64_t pos, pts, dts;
1712
1713 pos = *ppos;
1714 #ifdef DEBUG_SEEK
1715 printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1716 #endif
1717 url_fseek(&s->pb, pos, SEEK_SET);
1718 for(;;) {
1719 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1720 if (len < 0) {
1721 #ifdef DEBUG_SEEK
1722 printf("none (ret=%d)\n", len);
1723 #endif
1724 return AV_NOPTS_VALUE;
1725 }
1726 if (startcode == s->streams[stream_index]->id &&
1727 dts != AV_NOPTS_VALUE) {
1728 break;
1729 }
1730 url_fskip(&s->pb, len);
1731 }
1732 #ifdef DEBUG_SEEK
1733 printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1734 #endif
1735 *ppos = pos;
1736 return dts;
1737 }
1738
1739 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1740 AVOutputFormat mpeg1system_muxer = {
1741 "mpeg",
1742 "MPEG1 System format",
1743 "video/mpeg",
1744 "mpg,mpeg",
1745 sizeof(MpegMuxContext),
1746 CODEC_ID_MP2,
1747 CODEC_ID_MPEG1VIDEO,
1748 mpeg_mux_init,
1749 mpeg_mux_write_packet,
1750 mpeg_mux_end,
1751 };
1752 #endif
1753 #ifdef CONFIG_MPEG1VCD_MUXER
1754 AVOutputFormat mpeg1vcd_muxer = {
1755 "vcd",
1756 "MPEG1 System format (VCD)",
1757 "video/mpeg",
1758 NULL,
1759 sizeof(MpegMuxContext),
1760 CODEC_ID_MP2,
1761 CODEC_ID_MPEG1VIDEO,
1762 mpeg_mux_init,
1763 mpeg_mux_write_packet,
1764 mpeg_mux_end,
1765 };
1766 #endif
1767 #ifdef CONFIG_MPEG2VOB_MUXER
1768 AVOutputFormat mpeg2vob_muxer = {
1769 "vob",
1770 "MPEG2 PS format (VOB)",
1771 "video/mpeg",
1772 "vob",
1773 sizeof(MpegMuxContext),
1774 CODEC_ID_MP2,
1775 CODEC_ID_MPEG2VIDEO,
1776 mpeg_mux_init,
1777 mpeg_mux_write_packet,
1778 mpeg_mux_end,
1779 };
1780 #endif
1781
1782 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1783 #ifdef CONFIG_MPEG2SVCD_MUXER
1784 AVOutputFormat mpeg2svcd_muxer = {
1785 "svcd",
1786 "MPEG2 PS format (VOB)",
1787 "video/mpeg",
1788 "vob",
1789 sizeof(MpegMuxContext),
1790 CODEC_ID_MP2,
1791 CODEC_ID_MPEG2VIDEO,
1792 mpeg_mux_init,
1793 mpeg_mux_write_packet,
1794 mpeg_mux_end,
1795 };
1796 #endif
1797
1798 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1799 #ifdef CONFIG_MPEG2DVD_MUXER
1800 AVOutputFormat mpeg2dvd_muxer = {
1801 "dvd",
1802 "MPEG2 PS format (DVD VOB)",
1803 "video/mpeg",
1804 "dvd",
1805 sizeof(MpegMuxContext),
1806 CODEC_ID_MP2,
1807 CODEC_ID_MPEG2VIDEO,
1808 mpeg_mux_init,
1809 mpeg_mux_write_packet,
1810 mpeg_mux_end,
1811 };
1812 #endif
1813
1814 #ifdef CONFIG_MPEGPS_DEMUXER
1815 AVInputFormat mpegps_demuxer = {
1816 "mpeg",
1817 "MPEG PS format",
1818 sizeof(MpegDemuxContext),
1819 mpegps_probe,
1820 mpegps_read_header,
1821 mpegps_read_packet,
1822 mpegps_read_close,
1823 NULL, //mpegps_read_seek,
1824 mpegps_read_dts,
1825 .flags = AVFMT_SHOW_IDS,
1826 };
1827 #endif