2 * MPEG1/2 muxer and demuxer
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "bitstream.h"
25 #define MAX_PAYLOAD_SIZE 4096
31 typedef struct PacketDesc {
37 struct PacketDesc *next;
43 int max_buffer_size; /* in bytes */
45 PacketDesc *predecode_packet;
46 PacketDesc *premux_packet;
47 PacketDesc **next_packet;
49 uint8_t lpcm_header[3];
53 int64_t vobu_start_pts;
57 int packet_size; /* required packet size */
59 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
60 int system_header_freq;
61 int system_header_size;
62 int mux_rate; /* bitrate in units of 50 bytes/s */
70 int64_t last_scr; /* current system clock */
72 double vcd_padding_bitrate; //FIXME floats
73 int64_t vcd_padding_bytes_written;
77 #define PACK_START_CODE ((unsigned int)0x000001ba)
78 #define SYSTEM_HEADER_START_CODE ((unsigned int)0x000001bb)
79 #define SEQUENCE_END_CODE ((unsigned int)0x000001b7)
80 #define PACKET_START_CODE_MASK ((unsigned int)0xffffff00)
81 #define PACKET_START_CODE_PREFIX ((unsigned int)0x00000100)
82 #define ISO_11172_END_CODE ((unsigned int)0x000001b9)
85 #define PROGRAM_STREAM_MAP 0x1bc
86 #define PRIVATE_STREAM_1 0x1bd
87 #define PADDING_STREAM 0x1be
88 #define PRIVATE_STREAM_2 0x1bf
98 #define STREAM_TYPE_VIDEO_MPEG1 0x01
99 #define STREAM_TYPE_VIDEO_MPEG2 0x02
100 #define STREAM_TYPE_AUDIO_MPEG1 0x03
101 #define STREAM_TYPE_AUDIO_MPEG2 0x04
102 #define STREAM_TYPE_PRIVATE_SECTION 0x05
103 #define STREAM_TYPE_PRIVATE_DATA 0x06
104 #define STREAM_TYPE_AUDIO_AAC 0x0f
105 #define STREAM_TYPE_VIDEO_MPEG4 0x10
106 #define STREAM_TYPE_VIDEO_H264 0x1b
108 #define STREAM_TYPE_AUDIO_AC3 0x81
109 #define STREAM_TYPE_AUDIO_DTS 0x8a
111 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
114 AVOutputFormat mpeg1system_muxer;
115 AVOutputFormat mpeg1vcd_muxer;
116 AVOutputFormat mpeg2vob_muxer;
117 AVOutputFormat mpeg2svcd_muxer;
118 AVOutputFormat mpeg2dvd_muxer;
120 static int put_pack_header(AVFormatContext *ctx,
121 uint8_t *buf, int64_t timestamp)
123 MpegMuxContext *s = ctx->priv_data;
126 init_put_bits(&pb, buf, 128);
128 put_bits(&pb, 32, PACK_START_CODE);
130 put_bits(&pb, 2, 0x1);
132 put_bits(&pb, 4, 0x2);
134 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
136 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
138 put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
141 /* clock extension */
145 put_bits(&pb, 22, s->mux_rate);
149 put_bits(&pb, 5, 0x1f); /* reserved */
150 put_bits(&pb, 3, 0); /* stuffing length */
153 return pbBufPtr(&pb) - pb.buf;
156 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
158 MpegMuxContext *s = ctx->priv_data;
159 int size, i, private_stream_coded, id;
162 init_put_bits(&pb, buf, 128);
164 put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
165 put_bits(&pb, 16, 0);
168 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
169 put_bits(&pb, 1, 1); /* marker */
170 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
171 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
174 put_bits(&pb, 6, s->audio_bound);
177 /* see VCD standard, p. IV-7*/
181 put_bits(&pb, 1, 0); /* variable bitrate*/
182 put_bits(&pb, 1, 0); /* non constrainted bit stream */
185 if (s->is_vcd || s->is_dvd) {
186 /* see VCD standard p IV-7 */
187 put_bits(&pb, 1, 1); /* audio locked */
188 put_bits(&pb, 1, 1); /* video locked */
190 put_bits(&pb, 1, 0); /* audio locked */
191 put_bits(&pb, 1, 0); /* video locked */
194 put_bits(&pb, 1, 1); /* marker */
196 if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
197 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
200 put_bits(&pb, 5, s->video_bound);
203 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
204 put_bits(&pb, 7, 0x7f); /* reserved byte */
206 put_bits(&pb, 8, 0xff); /* reserved byte */
208 /* DVD-Video Stream_bound entries
209 id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
210 id (0xB8) audio, maximum P-STD for any MPEG audio (0xC0 to 0xC7) streams. If there are none set to 4096 (32x128). (P-STD_buffer_bound_scale = 0)
211 id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
212 id (0xBF) private stream 2, NAV packs, set to 2x1024. */
215 int P_STD_max_video = 0;
216 int P_STD_max_mpeg_audio = 0;
217 int P_STD_max_mpeg_PS1 = 0;
219 for(i=0;i<ctx->nb_streams;i++) {
220 StreamInfo *stream = ctx->streams[i]->priv_data;
223 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
224 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
225 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
226 P_STD_max_mpeg_audio = stream->max_buffer_size;
227 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
228 P_STD_max_video = stream->max_buffer_size;
233 put_bits(&pb, 8, 0xb9); /* stream ID */
236 put_bits(&pb, 13, P_STD_max_video / 1024);
239 if (P_STD_max_mpeg_audio == 0)
240 P_STD_max_mpeg_audio = 4096;
241 put_bits(&pb, 8, 0xb8); /* stream ID */
244 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
246 /* private stream 1 */
247 put_bits(&pb, 8, 0xbd); /* stream ID */
250 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
252 /* private stream 2 */
253 put_bits(&pb, 8, 0xbf); /* stream ID */
256 put_bits(&pb, 13, 2);
259 /* audio stream info */
260 private_stream_coded = 0;
261 for(i=0;i<ctx->nb_streams;i++) {
262 StreamInfo *stream = ctx->streams[i]->priv_data;
265 /* For VCDs, only include the stream info for the stream
266 that the pack which contains this system belongs to.
267 (see VCD standard p. IV-7) */
268 if ( !s->is_vcd || stream->id==only_for_stream_id
269 || only_for_stream_id==0) {
273 /* special case for private streams (AC3 use that) */
274 if (private_stream_coded)
276 private_stream_coded = 1;
279 put_bits(&pb, 8, id); /* stream ID */
284 put_bits(&pb, 13, stream->max_buffer_size / 128);
288 put_bits(&pb, 13, stream->max_buffer_size / 1024);
295 size = pbBufPtr(&pb) - pb.buf;
296 /* patch packet size */
297 buf[4] = (size - 6) >> 8;
298 buf[5] = (size - 6) & 0xff;
303 static int get_system_header_size(AVFormatContext *ctx)
305 int buf_index, i, private_stream_coded;
307 MpegMuxContext *s = ctx->priv_data;
310 return 18; // DVD-Video system headers are 18 bytes fixed length.
313 private_stream_coded = 0;
314 for(i=0;i<ctx->nb_streams;i++) {
315 stream = ctx->streams[i]->priv_data;
316 if (stream->id < 0xc0) {
317 if (private_stream_coded)
319 private_stream_coded = 1;
326 static int mpeg_mux_init(AVFormatContext *ctx)
328 MpegMuxContext *s = ctx->priv_data;
329 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
335 s->packet_number = 0;
336 s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
337 s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
338 s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
339 s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
342 s->packet_size = ctx->packet_size;
344 s->packet_size = 2048;
346 s->vcd_padding_bytes_written = 0;
347 s->vcd_padding_bitrate=0;
357 for(i=0;i<ctx->nb_streams;i++) {
358 st = ctx->streams[i];
359 stream = av_mallocz(sizeof(StreamInfo));
362 st->priv_data = stream;
364 av_set_pts_info(st, 64, 1, 90000);
366 switch(st->codec->codec_type) {
367 case CODEC_TYPE_AUDIO:
368 if (st->codec->codec_id == CODEC_ID_AC3) {
369 stream->id = ac3_id++;
370 } else if (st->codec->codec_id == CODEC_ID_DTS) {
371 stream->id = dts_id++;
372 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
373 stream->id = lpcm_id++;
374 for(j = 0; j < 4; j++) {
375 if (lpcm_freq_tab[j] == st->codec->sample_rate)
380 if (st->codec->channels > 8)
382 stream->lpcm_header[0] = 0x0c;
383 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
384 stream->lpcm_header[2] = 0x80;
385 stream->lpcm_align = st->codec->channels * 2;
387 stream->id = mpa_id++;
390 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
391 Right now it is also used for everything else.*/
392 stream->max_buffer_size = 4 * 1024;
395 case CODEC_TYPE_VIDEO:
396 stream->id = mpv_id++;
397 if (st->codec->rc_buffer_size)
398 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
400 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
402 /* see VCD standard, p. IV-7*/
403 stream->max_buffer_size = 46 * 1024;
405 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
406 Right now it is also used for everything else.*/
407 stream->max_buffer_size = 230 * 1024;
411 case CODEC_TYPE_SUBTITLE:
412 stream->id = mps_id++;
413 stream->max_buffer_size = 16 * 1024;
418 av_fifo_init(&stream->fifo, 16);
423 for(i=0;i<ctx->nb_streams;i++) {
425 st = ctx->streams[i];
426 stream = (StreamInfo*) st->priv_data;
428 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
429 codec_rate= st->codec->rc_max_rate;
431 codec_rate= st->codec->bit_rate;
434 codec_rate= (1<<21)*8*50/ctx->nb_streams;
436 bitrate += codec_rate;
438 if (stream->id==AUDIO_ID)
439 audio_bitrate += codec_rate;
440 else if (stream->id==VIDEO_ID)
441 video_bitrate += codec_rate;
445 s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
447 /* we increase slightly the bitrate to take into account the
448 headers. XXX: compute it exactly */
449 bitrate += bitrate*5/100;
451 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
455 double overhead_rate;
457 /* The VCD standard mandates that the mux_rate field is 3528
458 (see standard p. IV-6).
459 The value is actually "wrong", i.e. if you calculate
460 it using the normal formula and the 75 sectors per second transfer
461 rate you get a different value because the real pack size is 2324,
462 not 2352. But the standard explicitly specifies that the mux_rate
463 field in the header must have this value.*/
464 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
466 /* The VCD standard states that the muxed stream must be
467 exactly 75 packs / second (the data rate of a single speed cdrom).
468 Since the video bitrate (probably 1150000 bits/sec) will be below
469 the theoretical maximum we have to add some padding packets
470 to make up for the lower data rate.
471 (cf. VCD standard p. IV-6 )*/
473 /* Add the header overhead to the data rate.
474 2279 data bytes per audio pack, 2294 data bytes per video pack*/
475 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
476 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
479 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
480 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
483 if (s->is_vcd || s->is_mpeg2)
485 s->pack_header_freq = 1;
487 /* every 2 seconds */
488 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
490 /* the above seems to make pack_header_freq zero sometimes */
491 if (s->pack_header_freq == 0)
492 s->pack_header_freq = 1;
495 /* every 200 packets. Need to look at the spec. */
496 s->system_header_freq = s->pack_header_freq * 40;
498 /* the standard mandates that there are only two system headers
499 in the whole file: one in the first packet of each stream.
500 (see standard p. IV-7 and IV-8) */
501 s->system_header_freq = 0x7fffffff;
503 s->system_header_freq = s->pack_header_freq * 5;
505 for(i=0;i<ctx->nb_streams;i++) {
506 stream = ctx->streams[i]->priv_data;
507 stream->packet_number = 0;
509 s->system_header_size = get_system_header_size(ctx);
513 for(i=0;i<ctx->nb_streams;i++) {
514 av_free(ctx->streams[i]->priv_data);
516 return AVERROR(ENOMEM);
519 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
523 (((timestamp >> 30) & 0x07) << 1) |
525 put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
526 put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
530 /* return the number of padding bytes that should be inserted into
531 the multiplexed stream.*/
532 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
534 MpegMuxContext *s = ctx->priv_data;
537 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
539 int64_t full_pad_bytes;
541 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
542 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
545 /* might happen if we have already padded to a later timestamp. This
546 can occur if another stream has already advanced further.*/
554 #if 0 /* unused, remove? */
555 /* return the exact available payload size for the next packet for
556 stream 'stream_index'. 'pts' and 'dts' are only used to know if
557 timestamps are needed in the packet header. */
558 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
559 int64_t pts, int64_t dts)
561 MpegMuxContext *s = ctx->priv_data;
565 stream = ctx->streams[stream_index]->priv_data;
568 if (((s->packet_number % s->pack_header_freq) == 0)) {
569 /* pack header size */
576 /* there is exactly one system header for each stream in a VCD MPEG,
577 One in the very first video packet and one in the very first
578 audio packet (see VCD standard p. IV-7 and IV-8).*/
580 if (stream->packet_number==0)
581 /* The system headers refer only to the stream they occur in,
582 so they have a constant size.*/
586 if ((s->packet_number % s->system_header_freq) == 0)
587 buf_index += s->system_header_size;
591 if ((s->is_vcd && stream->packet_number==0)
592 || (s->is_svcd && s->packet_number==0))
593 /* the first pack of each stream contains only the pack header,
594 the system header and some padding (see VCD standard p. IV-6)
595 Add the padding size, so that the actual payload becomes 0.*/
596 buf_index += s->packet_size - buf_index;
598 /* packet header size */
602 if (stream->packet_number==0)
603 buf_index += 3; /* PES extension */
604 buf_index += 1; /* obligatory stuffing byte */
606 if (pts != AV_NOPTS_VALUE) {
617 if (stream->id < 0xc0) {
618 /* AC3/LPCM private data header */
620 if (stream->id >= 0xa0) {
623 /* NOTE: we round the payload size to an integer number of
625 n = (s->packet_size - buf_index) % stream->lpcm_align;
627 buf_index += (stream->lpcm_align - n);
631 if (s->is_vcd && stream->id == AUDIO_ID)
632 /* The VCD standard demands that 20 zero bytes follow
633 each audio packet (see standard p. IV-8).*/
636 return s->packet_size - buf_index;
640 /* Write an MPEG padding packet header. */
641 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
643 MpegMuxContext *s = ctx->priv_data;
646 put_be32(pb, PADDING_STREAM);
647 put_be16(pb, packet_bytes - 6);
654 for(i=0;i<packet_bytes;i++)
658 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
660 PacketDesc *pkt_desc= stream->premux_packet;
663 if(pkt_desc->size == pkt_desc->unwritten_size)
665 len -= pkt_desc->unwritten_size;
666 pkt_desc= pkt_desc->next;
672 /* flush the packet on stream stream_index */
673 static int flush_packet(AVFormatContext *ctx, int stream_index,
674 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
676 MpegMuxContext *s = ctx->priv_data;
677 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
679 int size, payload_size, startcode, id, stuffing_size, i, header_len;
682 int zero_trail_bytes = 0;
683 int pad_packet_bytes = 0;
685 int general_pack = 0; /*"general" pack without data specific to one stream?*/
691 printf("packet ID=%2x PTS=%0.3f\n",
697 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
698 /* output pack and systems header if needed */
699 size = put_pack_header(ctx, buf_ptr, scr);
704 /* there is exactly one system header for each stream in a VCD MPEG,
705 One in the very first video packet and one in the very first
706 audio packet (see VCD standard p. IV-7 and IV-8).*/
708 if (stream->packet_number==0) {
709 size = put_system_header(ctx, buf_ptr, id);
712 } else if (s->is_dvd) {
713 if (stream->align_iframe || s->packet_number == 0){
714 int PES_bytes_to_fill = s->packet_size - size - 10;
716 if (pts != AV_NOPTS_VALUE) {
718 PES_bytes_to_fill -= 5 + 5;
720 PES_bytes_to_fill -= 5;
723 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
724 size = put_system_header(ctx, buf_ptr, 0);
726 size = buf_ptr - buffer;
727 put_buffer(&ctx->pb, buffer, size);
729 put_be32(&ctx->pb, PRIVATE_STREAM_2);
730 put_be16(&ctx->pb, 0x03d4); // length
731 put_byte(&ctx->pb, 0x00); // substream ID, 00=PCI
732 for (i = 0; i < 979; i++)
733 put_byte(&ctx->pb, 0x00);
735 put_be32(&ctx->pb, PRIVATE_STREAM_2);
736 put_be16(&ctx->pb, 0x03fa); // length
737 put_byte(&ctx->pb, 0x01); // substream ID, 01=DSI
738 for (i = 0; i < 1017; i++)
739 put_byte(&ctx->pb, 0x00);
741 memset(buffer, 0, 128);
744 stream->align_iframe = 0;
745 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
746 size = put_pack_header(ctx, buf_ptr, scr);
750 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
751 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
755 if ((s->packet_number % s->system_header_freq) == 0) {
756 size = put_system_header(ctx, buf_ptr, 0);
761 size = buf_ptr - buffer;
762 put_buffer(&ctx->pb, buffer, size);
764 packet_size = s->packet_size - size;
766 if (s->is_vcd && id == AUDIO_ID)
767 /* The VCD standard demands that 20 zero bytes follow
768 each audio pack (see standard p. IV-8).*/
769 zero_trail_bytes += 20;
771 if ((s->is_vcd && stream->packet_number==0)
772 || (s->is_svcd && s->packet_number==0)) {
773 /* for VCD the first pack of each stream contains only the pack header,
774 the system header and lots of padding (see VCD standard p. IV-6).
775 In the case of an audio pack, 20 zero bytes are also added at
777 /* For SVCD we fill the very first pack to increase compatibility with
778 some DVD players. Not mandated by the standard.*/
780 general_pack = 1; /* the system header refers to both streams and no stream data*/
781 pad_packet_bytes = packet_size - zero_trail_bytes;
784 packet_size -= pad_packet_bytes + zero_trail_bytes;
786 if (packet_size > 0) {
788 /* packet header size */
794 if (stream->packet_number==0)
795 header_len += 3; /* PES extension */
796 header_len += 1; /* obligatory stuffing byte */
800 if (pts != AV_NOPTS_VALUE) {
810 payload_size = packet_size - header_len;
812 startcode = PRIVATE_STREAM_1;
820 startcode = 0x100 + id;
823 stuffing_size = payload_size - av_fifo_size(&stream->fifo);
825 // first byte doesnt fit -> reset pts/dts + stuffing
826 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
830 if(pts != AV_NOPTS_VALUE)
831 timestamp_len += s->is_mpeg2 ? 5 : 4;
832 pts=dts= AV_NOPTS_VALUE;
833 header_len -= timestamp_len;
834 if (s->is_dvd && stream->align_iframe) {
835 pad_packet_bytes += timestamp_len;
836 packet_size -= timestamp_len;
838 payload_size += timestamp_len;
840 stuffing_size += timestamp_len;
841 if(payload_size > trailer_size)
842 stuffing_size += payload_size - trailer_size;
845 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
846 packet_size += pad_packet_bytes;
847 payload_size += pad_packet_bytes; // undo the previous adjustment
848 if (stuffing_size < 0) {
849 stuffing_size = pad_packet_bytes;
851 stuffing_size += pad_packet_bytes;
853 pad_packet_bytes = 0;
856 if (stuffing_size < 0)
858 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
859 pad_packet_bytes += stuffing_size;
860 packet_size -= stuffing_size;
861 payload_size -= stuffing_size;
865 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
867 put_be32(&ctx->pb, startcode);
869 put_be16(&ctx->pb, packet_size);
872 for(i=0;i<stuffing_size;i++)
873 put_byte(&ctx->pb, 0xff);
876 put_byte(&ctx->pb, 0x80); /* mpeg2 id */
880 if (pts != AV_NOPTS_VALUE) {
886 /* Both the MPEG-2 and the SVCD standards demand that the
887 P-STD_buffer_size field be included in the first packet of
888 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
889 and MPEG-2 standard 2.7.7) */
890 if (stream->packet_number == 0)
893 put_byte(&ctx->pb, pes_flags); /* flags */
894 put_byte(&ctx->pb, header_len - 3 + stuffing_size);
896 if (pes_flags & 0x80) /*write pts*/
897 put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
898 if (pes_flags & 0x40) /*write dts*/
899 put_timestamp(&ctx->pb, 0x01, dts);
901 if (pes_flags & 0x01) { /*write pes extension*/
902 put_byte(&ctx->pb, 0x10); /* flags */
904 /* P-STD buffer info */
906 put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
908 put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
912 if (pts != AV_NOPTS_VALUE) {
914 put_timestamp(&ctx->pb, 0x03, pts);
915 put_timestamp(&ctx->pb, 0x01, dts);
917 put_timestamp(&ctx->pb, 0x02, pts);
920 put_byte(&ctx->pb, 0x0f);
925 /* special stuffing byte that is always written
926 to prevent accidental generation of start codes. */
927 put_byte(&ctx->pb, 0xff);
929 for(i=0;i<stuffing_size;i++)
930 put_byte(&ctx->pb, 0xff);
933 if (startcode == PRIVATE_STREAM_1) {
934 put_byte(&ctx->pb, id);
936 /* LPCM (XXX: check nb_frames) */
937 put_byte(&ctx->pb, 7);
938 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
939 put_byte(&ctx->pb, stream->lpcm_header[0]);
940 put_byte(&ctx->pb, stream->lpcm_header[1]);
941 put_byte(&ctx->pb, stream->lpcm_header[2]);
942 } else if (id >= 0x40) {
944 put_byte(&ctx->pb, nb_frames);
945 put_be16(&ctx->pb, trailer_size+1);
950 if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
952 stream->bytes_to_iframe -= payload_size - stuffing_size;
958 if (pad_packet_bytes > 0)
959 put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
961 for(i=0;i<zero_trail_bytes;i++)
962 put_byte(&ctx->pb, 0x00);
964 put_flush_packet(&ctx->pb);
968 /* only increase the stream packet number if this pack actually contains
969 something that is specific to this stream! I.e. a dedicated header
972 stream->packet_number++;
974 return payload_size - stuffing_size;
977 static void put_vcd_padding_sector(AVFormatContext *ctx)
979 /* There are two ways to do this padding: writing a sector/pack
980 of 0 values, or writing an MPEG padding pack. Both seem to
981 work with most decoders, BUT the VCD standard only allows a 0-sector
982 (see standard p. IV-4, IV-5).
983 So a 0-sector it is...*/
985 MpegMuxContext *s = ctx->priv_data;
988 for(i=0;i<s->packet_size;i++)
989 put_byte(&ctx->pb, 0);
991 s->vcd_padding_bytes_written += s->packet_size;
993 put_flush_packet(&ctx->pb);
995 /* increasing the packet number is correct. The SCR of the following packs
996 is calculated from the packet_number and it has to include the padding
997 sector (it represents the sector index, not the MPEG pack index)
998 (see VCD standard p. IV-6)*/
1002 #if 0 /* unused, remove? */
1003 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
1005 MpegMuxContext *s = ctx->priv_data;
1008 /* Since the data delivery rate is constant, SCR is computed
1009 using the formula C + i * 1200 where C is the start constant
1010 and i is the pack index.
1011 It is recommended that SCR 0 is at the beginning of the VCD front
1012 margin (a sequence of empty Form 2 sectors on the CD).
1013 It is recommended that the front margin is 30 sectors long, so
1014 we use C = 30*1200 = 36000
1015 (Note that even if the front margin is not 30 sectors the file
1016 will still be correct according to the standard. It just won't have
1017 the "recommended" value).*/
1018 scr = 36000 + s->packet_number * 1200;
1024 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1025 // MpegMuxContext *s = ctx->priv_data;
1028 for(i=0; i<ctx->nb_streams; i++){
1029 AVStream *st = ctx->streams[i];
1030 StreamInfo *stream = st->priv_data;
1031 PacketDesc *pkt_desc= stream->predecode_packet;
1033 while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1034 if(stream->buffer_index < pkt_desc->size ||
1035 stream->predecode_packet == stream->premux_packet){
1036 av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1039 stream->buffer_index -= pkt_desc->size;
1041 stream->predecode_packet= pkt_desc->next;
1042 av_freep(&pkt_desc);
1049 static int output_packet(AVFormatContext *ctx, int flush){
1050 MpegMuxContext *s = ctx->priv_data;
1053 int i, avail_space, es_size, trailer_size;
1055 int best_score= INT_MIN;
1056 int ignore_constraints=0;
1057 int64_t scr= s->last_scr;
1058 PacketDesc *timestamp_packet;
1059 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1062 for(i=0; i<ctx->nb_streams; i++){
1063 AVStream *st = ctx->streams[i];
1064 StreamInfo *stream = st->priv_data;
1065 const int avail_data= av_fifo_size(&stream->fifo);
1066 const int space= stream->max_buffer_size - stream->buffer_index;
1067 int rel_space= 1024*space / stream->max_buffer_size;
1068 PacketDesc *next_pkt= stream->premux_packet;
1070 /* for subtitle, a single PES packet must be generated,
1071 so we flush after every single subtitle packet */
1072 if(s->packet_size > avail_data && !flush
1073 && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1077 assert(avail_data>0);
1079 if(space < s->packet_size && !ignore_constraints)
1082 if(next_pkt && next_pkt->dts - scr > max_delay)
1085 if(rel_space > best_score){
1086 best_score= rel_space;
1093 int64_t best_dts= INT64_MAX;
1095 for(i=0; i<ctx->nb_streams; i++){
1096 AVStream *st = ctx->streams[i];
1097 StreamInfo *stream = st->priv_data;
1098 PacketDesc *pkt_desc= stream->predecode_packet;
1099 if(pkt_desc && pkt_desc->dts < best_dts)
1100 best_dts= pkt_desc->dts;
1104 av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1105 scr/90000.0, best_dts/90000.0);
1107 if(best_dts == INT64_MAX)
1110 if(scr >= best_dts+1 && !ignore_constraints){
1111 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1112 ignore_constraints= 1;
1114 scr= FFMAX(best_dts+1, scr);
1115 if(remove_decoded_packets(ctx, scr) < 0)
1120 assert(best_i >= 0);
1122 st = ctx->streams[best_i];
1123 stream = st->priv_data;
1125 assert(av_fifo_size(&stream->fifo) > 0);
1127 assert(avail_space >= s->packet_size || ignore_constraints);
1129 timestamp_packet= stream->premux_packet;
1130 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1133 trailer_size= timestamp_packet->unwritten_size;
1134 timestamp_packet= timestamp_packet->next;
1137 if(timestamp_packet){
1138 //av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f scr:%f stream:%d\n", timestamp_packet->dts/90000.0, timestamp_packet->pts/90000.0, scr/90000.0, best_i);
1139 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1141 assert(av_fifo_size(&stream->fifo) == trailer_size);
1142 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1146 /* Write one or more padding sectors, if necessary, to reach
1147 the constant overall bitrate.*/
1150 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1151 put_vcd_padding_sector(ctx);
1152 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1156 stream->buffer_index += es_size;
1157 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1159 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1160 es_size -= stream->premux_packet->unwritten_size;
1161 stream->premux_packet= stream->premux_packet->next;
1164 stream->premux_packet->unwritten_size -= es_size;
1166 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1172 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1174 MpegMuxContext *s = ctx->priv_data;
1175 int stream_index= pkt->stream_index;
1176 int size= pkt->size;
1177 uint8_t *buf= pkt->data;
1178 AVStream *st = ctx->streams[stream_index];
1179 StreamInfo *stream = st->priv_data;
1181 PacketDesc *pkt_desc;
1182 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1183 const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1188 if(pts != AV_NOPTS_VALUE) pts += preload;
1189 if(dts != AV_NOPTS_VALUE) dts += preload;
1191 //av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index, pts != AV_NOPTS_VALUE);
1192 if (!stream->premux_packet)
1193 stream->next_packet = &stream->premux_packet;
1194 *stream->next_packet=
1195 pkt_desc= av_mallocz(sizeof(PacketDesc));
1198 pkt_desc->unwritten_size=
1199 pkt_desc->size= size;
1200 if(!stream->predecode_packet)
1201 stream->predecode_packet= pkt_desc;
1202 stream->next_packet= &pkt_desc->next;
1204 av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1207 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1208 stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1209 stream->align_iframe = 1;
1210 stream->vobu_start_pts = pts;
1212 stream->align_iframe = 0;
1216 av_fifo_write(&stream->fifo, buf, size);
1219 int ret= output_packet(ctx, 0);
1225 static int mpeg_mux_end(AVFormatContext *ctx)
1227 // MpegMuxContext *s = ctx->priv_data;
1232 int ret= output_packet(ctx, 1);
1239 /* End header according to MPEG1 systems standard. We do not write
1240 it as it is usually not needed by decoders and because it
1241 complicates MPEG stream concatenation. */
1242 //put_be32(&ctx->pb, ISO_11172_END_CODE);
1243 //put_flush_packet(&ctx->pb);
1245 for(i=0;i<ctx->nb_streams;i++) {
1246 stream = ctx->streams[i]->priv_data;
1248 assert(av_fifo_size(&stream->fifo) == 0);
1249 av_fifo_free(&stream->fifo);
1253 #endif //CONFIG_MUXERS
1255 /*********************************************/
1258 #define MAX_SYNC_SIZE 100000
1260 static int cdxa_probe(AVProbeData *p)
1262 /* check file header */
1263 if (p->buf_size <= 32)
1265 if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1266 p->buf[2] == 'F' && p->buf[3] == 'F' &&
1267 p->buf[8] == 'C' && p->buf[9] == 'D' &&
1268 p->buf[10] == 'X' && p->buf[11] == 'A')
1269 return AVPROBE_SCORE_MAX;
1274 static int mpegps_probe(AVProbeData *p)
1277 int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1281 score = cdxa_probe(p);
1282 if (score > 0) return score;
1284 /* Search for MPEG stream */
1285 for(i=0; i<p->buf_size; i++){
1286 code = (code<<8) + p->buf[i];
1287 if ((code & 0xffffff00) == 0x100) {
1288 if(code == SYSTEM_HEADER_START_CODE) sys++;
1289 else if(code == PRIVATE_STREAM_1) priv1++;
1290 else if(code == PACK_START_CODE) pspack++;
1291 else if((code & 0xf0) == VIDEO_ID) vid++;
1292 else if((code & 0xe0) == AUDIO_ID) audio++;
1296 if(vid || audio) /* invalid VDR files nd short PES streams */
1297 score= AVPROBE_SCORE_MAX/4;
1299 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1300 if(sys && sys*9 <= pspack*10)
1301 return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1302 if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1303 return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1304 if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1305 return AVPROBE_SCORE_MAX/2+2;
1307 //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1312 typedef struct MpegDemuxContext {
1313 int32_t header_state;
1314 unsigned char psm_es_type[256];
1317 static int mpegps_read_header(AVFormatContext *s,
1318 AVFormatParameters *ap)
1320 MpegDemuxContext *m = s->priv_data;
1321 m->header_state = 0xff;
1322 s->ctx_flags |= AVFMTCTX_NOHEADER;
1324 /* no need to do more */
1328 static int64_t get_pts(ByteIOContext *pb, int c)
1335 pts = (int64_t)((c >> 1) & 0x07) << 30;
1337 pts |= (int64_t)(val >> 1) << 15;
1339 pts |= (int64_t)(val >> 1);
1343 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1344 int32_t *header_state)
1346 unsigned int state, v;
1349 state = *header_state;
1356 if (state == 0x000001) {
1357 state = ((state << 8) | v) & 0xffffff;
1361 state = ((state << 8) | v) & 0xffffff;
1365 *header_state = state;
1370 #if 0 /* unused, remove? */
1372 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1374 int64_t pos, pos_start;
1375 int max_size, start_code;
1377 max_size = *size_ptr;
1378 pos_start = url_ftell(pb);
1380 /* in order to go faster, we fill the buffer */
1381 pos = pos_start - 16386;
1384 url_fseek(pb, pos, SEEK_SET);
1390 if (pos < 0 || (pos_start - pos) >= max_size) {
1394 url_fseek(pb, pos, SEEK_SET);
1395 start_code = get_be32(pb);
1396 if ((start_code & 0xffffff00) == 0x100)
1400 *size_ptr = pos_start - pos;
1406 * Extracts stream types from a program stream map
1407 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1409 * @return number of bytes occupied by PSM in the bitstream
1411 static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1413 int psm_length, ps_info_length, es_map_length;
1415 psm_length = get_be16(pb);
1418 ps_info_length = get_be16(pb);
1420 /* skip program_stream_info */
1421 url_fskip(pb, ps_info_length);
1422 es_map_length = get_be16(pb);
1424 /* at least one es available? */
1425 while (es_map_length >= 4){
1426 unsigned char type = get_byte(pb);
1427 unsigned char es_id = get_byte(pb);
1428 uint16_t es_info_length = get_be16(pb);
1429 /* remember mapping from stream id to stream type */
1430 m->psm_es_type[es_id] = type;
1431 /* skip program_stream_info */
1432 url_fskip(pb, es_info_length);
1433 es_map_length -= 4 + es_info_length;
1435 get_be32(pb); /* crc32 */
1436 return 2 + psm_length;
1439 /* read the next PES header. Return its position in ppos
1440 (if not NULL), and its start code, pts and dts.
1442 static int mpegps_read_pes_header(AVFormatContext *s,
1443 int64_t *ppos, int *pstart_code,
1444 int64_t *ppts, int64_t *pdts)
1446 MpegDemuxContext *m = s->priv_data;
1447 int len, size, startcode, c, flags, header_len;
1448 int pes_ext, ext2_len, id_ext, skip;
1450 int64_t last_sync= url_ftell(&s->pb);
1453 url_fseek(&s->pb, last_sync, SEEK_SET);
1455 /* next start code (should be immediately after) */
1456 m->header_state = 0xff;
1457 size = MAX_SYNC_SIZE;
1458 startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1459 last_sync = url_ftell(&s->pb);
1460 //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(&s->pb));
1463 if (startcode == PACK_START_CODE)
1465 if (startcode == SYSTEM_HEADER_START_CODE)
1467 if (startcode == PADDING_STREAM ||
1468 startcode == PRIVATE_STREAM_2) {
1470 len = get_be16(&s->pb);
1471 url_fskip(&s->pb, len);
1474 if (startcode == PROGRAM_STREAM_MAP) {
1475 mpegps_psm_parse(m, &s->pb);
1479 /* find matching stream */
1480 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1481 (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1482 (startcode == 0x1bd) || (startcode == 0x1fd)))
1485 *ppos = url_ftell(&s->pb) - 4;
1487 len = get_be16(&s->pb);
1489 dts = AV_NOPTS_VALUE;
1494 c = get_byte(&s->pb);
1496 /* XXX: for mpeg1, should test only bit 7 */
1500 if ((c & 0xc0) == 0x40) {
1501 /* buffer scale & size */
1503 c = get_byte(&s->pb);
1506 if ((c & 0xe0) == 0x20) {
1507 dts = pts = get_pts(&s->pb, c);
1510 dts = get_pts(&s->pb, -1);
1513 } else if ((c & 0xc0) == 0x80) {
1515 #if 0 /* some streams have this field set for no apparent reason */
1516 if ((c & 0x30) != 0) {
1517 /* Encrypted multiplex not handled */
1521 flags = get_byte(&s->pb);
1522 header_len = get_byte(&s->pb);
1524 if (header_len > len)
1528 dts = pts = get_pts(&s->pb, -1);
1531 dts = get_pts(&s->pb, -1);
1535 if (flags & 0x01) { /* PES extension */
1536 pes_ext = get_byte(&s->pb);
1538 if (pes_ext & 0x40) { /* pack header - should be zero in PS */
1541 /* Skip PES private data, program packet sequence counter and P-STD buffer */
1542 skip = (pes_ext >> 4) & 0xb;
1544 url_fskip(&s->pb, skip);
1547 if (pes_ext & 0x01) { /* PES extension 2 */
1548 ext2_len = get_byte(&s->pb);
1550 if ((ext2_len & 0x7f) > 0) {
1551 id_ext = get_byte(&s->pb);
1552 if ((id_ext & 0x80) == 0)
1553 startcode = ((startcode & 0xff) << 8) | id_ext;
1560 url_fskip(&s->pb, header_len);
1565 if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1566 startcode = get_byte(&s->pb);
1568 if (startcode >= 0x80 && startcode <= 0xcf) {
1569 /* audio: skip header */
1574 if (startcode >= 0xb0 && startcode <= 0xbf) {
1575 /* MLP/TrueHD audio has a 4-byte header */
1583 if(dts != AV_NOPTS_VALUE && ppos){
1585 for(i=0; i<s->nb_streams; i++){
1586 if(startcode == s->streams[i]->id) {
1587 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1592 *pstart_code = startcode;
1598 static int mpegps_read_packet(AVFormatContext *s,
1601 MpegDemuxContext *m = s->priv_data;
1603 int len, startcode, i, type, codec_id = 0, es_type;
1604 int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1607 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1611 /* now find stream */
1612 for(i=0;i<s->nb_streams;i++) {
1614 if (st->id == startcode)
1618 es_type = m->psm_es_type[startcode & 0xff];
1620 if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1621 codec_id = CODEC_ID_MPEG2VIDEO;
1622 type = CODEC_TYPE_VIDEO;
1623 } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1624 codec_id = CODEC_ID_MPEG2VIDEO;
1625 type = CODEC_TYPE_VIDEO;
1626 } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1627 es_type == STREAM_TYPE_AUDIO_MPEG2){
1628 codec_id = CODEC_ID_MP3;
1629 type = CODEC_TYPE_AUDIO;
1630 } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1631 codec_id = CODEC_ID_AAC;
1632 type = CODEC_TYPE_AUDIO;
1633 } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1634 codec_id = CODEC_ID_MPEG4;
1635 type = CODEC_TYPE_VIDEO;
1636 } else if(es_type == STREAM_TYPE_VIDEO_H264){
1637 codec_id = CODEC_ID_H264;
1638 type = CODEC_TYPE_VIDEO;
1639 } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1640 codec_id = CODEC_ID_AC3;
1641 type = CODEC_TYPE_AUDIO;
1645 } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1646 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1647 unsigned char buf[8];
1648 get_buffer(&s->pb, buf, 8);
1649 url_fseek(&s->pb, -8, SEEK_CUR);
1650 if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1651 codec_id = CODEC_ID_CAVS;
1653 codec_id = CODEC_ID_MPEG2VIDEO;
1654 type = CODEC_TYPE_VIDEO;
1655 } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1656 type = CODEC_TYPE_AUDIO;
1657 codec_id = CODEC_ID_MP2;
1658 } else if (startcode >= 0x80 && startcode <= 0x87) {
1659 type = CODEC_TYPE_AUDIO;
1660 codec_id = CODEC_ID_AC3;
1661 } else if ((startcode >= 0x88 && startcode <= 0x8f)
1662 ||( startcode >= 0x98 && startcode <= 0x9f)) {
1663 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
1664 type = CODEC_TYPE_AUDIO;
1665 codec_id = CODEC_ID_DTS;
1666 } else if (startcode >= 0xa0 && startcode <= 0xaf) {
1667 type = CODEC_TYPE_AUDIO;
1668 codec_id = CODEC_ID_PCM_S16BE;
1669 } else if (startcode >= 0xb0 && startcode <= 0xbf) {
1670 type = CODEC_TYPE_AUDIO;
1671 codec_id = CODEC_ID_MLP;
1672 } else if (startcode >= 0xc0 && startcode <= 0xcf) {
1673 /* Used for both AC-3 and E-AC-3 in EVOB files */
1674 type = CODEC_TYPE_AUDIO;
1675 codec_id = CODEC_ID_AC3;
1676 } else if (startcode >= 0x20 && startcode <= 0x3f) {
1677 type = CODEC_TYPE_SUBTITLE;
1678 codec_id = CODEC_ID_DVD_SUBTITLE;
1679 } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
1680 type = CODEC_TYPE_VIDEO;
1681 codec_id = CODEC_ID_VC1;
1685 url_fskip(&s->pb, len);
1688 /* no stream found: add a new stream */
1689 st = av_new_stream(s, startcode);
1692 st->codec->codec_type = type;
1693 st->codec->codec_id = codec_id;
1694 if (codec_id != CODEC_ID_PCM_S16BE)
1695 st->need_parsing = 1;
1697 if(st->discard >= AVDISCARD_ALL)
1699 if (startcode >= 0xa0 && startcode <= 0xaf) {
1702 /* for LPCM, we just skip the header and consider it is raw
1706 get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1707 b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1708 get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1710 freq = (b1 >> 4) & 3;
1711 st->codec->sample_rate = lpcm_freq_tab[freq];
1712 st->codec->channels = 1 + (b1 & 7);
1713 st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1715 av_new_packet(pkt, len);
1716 get_buffer(&s->pb, pkt->data, pkt->size);
1719 pkt->stream_index = st->index;
1721 av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1722 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1728 static int mpegps_read_close(AVFormatContext *s)
1733 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1734 int64_t *ppos, int64_t pos_limit)
1737 int64_t pos, pts, dts;
1741 printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
1743 url_fseek(&s->pb, pos, SEEK_SET);
1745 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1748 printf("none (ret=%d)\n", len);
1750 return AV_NOPTS_VALUE;
1752 if (startcode == s->streams[stream_index]->id &&
1753 dts != AV_NOPTS_VALUE) {
1756 url_fskip(&s->pb, len);
1759 printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
1765 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1766 AVOutputFormat mpeg1system_muxer = {
1768 "MPEG1 System format",
1771 sizeof(MpegMuxContext),
1773 CODEC_ID_MPEG1VIDEO,
1775 mpeg_mux_write_packet,
1779 #ifdef CONFIG_MPEG1VCD_MUXER
1780 AVOutputFormat mpeg1vcd_muxer = {
1782 "MPEG1 System format (VCD)",
1785 sizeof(MpegMuxContext),
1787 CODEC_ID_MPEG1VIDEO,
1789 mpeg_mux_write_packet,
1793 #ifdef CONFIG_MPEG2VOB_MUXER
1794 AVOutputFormat mpeg2vob_muxer = {
1796 "MPEG2 PS format (VOB)",
1799 sizeof(MpegMuxContext),
1801 CODEC_ID_MPEG2VIDEO,
1803 mpeg_mux_write_packet,
1808 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1809 #ifdef CONFIG_MPEG2SVCD_MUXER
1810 AVOutputFormat mpeg2svcd_muxer = {
1812 "MPEG2 PS format (VOB)",
1815 sizeof(MpegMuxContext),
1817 CODEC_ID_MPEG2VIDEO,
1819 mpeg_mux_write_packet,
1824 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1825 #ifdef CONFIG_MPEG2DVD_MUXER
1826 AVOutputFormat mpeg2dvd_muxer = {
1828 "MPEG2 PS format (DVD VOB)",
1831 sizeof(MpegMuxContext),
1833 CODEC_ID_MPEG2VIDEO,
1835 mpeg_mux_write_packet,
1840 #ifdef CONFIG_MPEGPS_DEMUXER
1841 AVInputFormat mpegps_demuxer = {
1844 sizeof(MpegDemuxContext),
1849 NULL, //mpegps_read_seek,
1851 .flags = AVFMT_SHOW_IDS,