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 does not 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;
1033 while((pkt_desc= stream->predecode_packet)
1034 && scr > pkt_desc->dts){ //FIXME > vs >=
1035 if(stream->buffer_index < pkt_desc->size ||
1036 stream->predecode_packet == stream->premux_packet){
1037 av_log(ctx, AV_LOG_ERROR,
1038 "buffer underflow i=%d bufi=%d size=%d\n",
1039 i, stream->buffer_index, pkt_desc->size);
1042 stream->buffer_index -= pkt_desc->size;
1044 stream->predecode_packet= pkt_desc->next;
1045 av_freep(&pkt_desc);
1052 static int output_packet(AVFormatContext *ctx, int flush){
1053 MpegMuxContext *s = ctx->priv_data;
1056 int i, avail_space, es_size, trailer_size;
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);
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= av_fifo_size(&stream->fifo);
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;
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)
1080 assert(avail_data>0);
1082 if(space < s->packet_size && !ignore_constraints)
1085 if(next_pkt && next_pkt->dts - scr > max_delay)
1088 if(rel_space > best_score){
1089 best_score= rel_space;
1096 int64_t best_dts= INT64_MAX;
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;
1107 av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1108 scr/90000.0, best_dts/90000.0);
1110 if(best_dts == INT64_MAX)
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;
1117 scr= FFMAX(best_dts+1, scr);
1118 if(remove_decoded_packets(ctx, scr) < 0)
1123 assert(best_i >= 0);
1125 st = ctx->streams[best_i];
1126 stream = st->priv_data;
1128 assert(av_fifo_size(&stream->fifo) > 0);
1130 assert(avail_space >= s->packet_size || ignore_constraints);
1132 timestamp_packet= stream->premux_packet;
1133 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1136 trailer_size= timestamp_packet->unwritten_size;
1137 timestamp_packet= timestamp_packet->next;
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);
1144 assert(av_fifo_size(&stream->fifo) == trailer_size);
1145 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1149 /* Write one or more padding sectors, if necessary, to reach
1150 the constant overall bitrate.*/
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
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
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;
1167 stream->premux_packet->unwritten_size -= es_size;
1169 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1175 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
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;
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);
1191 if(pts != AV_NOPTS_VALUE) pts += preload;
1192 if(dts != AV_NOPTS_VALUE) dts += preload;
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));
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;
1207 av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1210 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1211 stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1212 stream->align_iframe = 1;
1213 stream->vobu_start_pts = pts;
1215 stream->align_iframe = 0;
1219 av_fifo_write(&stream->fifo, buf, size);
1222 int ret= output_packet(ctx, 0);
1228 static int mpeg_mux_end(AVFormatContext *ctx)
1230 // MpegMuxContext *s = ctx->priv_data;
1235 int ret= output_packet(ctx, 1);
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);
1248 for(i=0;i<ctx->nb_streams;i++) {
1249 stream = ctx->streams[i]->priv_data;
1251 assert(av_fifo_size(&stream->fifo) == 0);
1252 av_fifo_free(&stream->fifo);
1256 #endif //CONFIG_MUXERS
1258 /*********************************************/
1261 #define MAX_SYNC_SIZE 100000
1263 static int cdxa_probe(AVProbeData *p)
1265 /* check file header */
1266 if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1267 p->buf[2] == 'F' && p->buf[3] == 'F' &&
1268 p->buf[8] == 'C' && p->buf[9] == 'D' &&
1269 p->buf[10] == 'X' && p->buf[11] == 'A')
1270 return AVPROBE_SCORE_MAX;
1275 static int mpegps_probe(AVProbeData *p)
1278 int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1282 score = cdxa_probe(p);
1283 if (score > 0) return score;
1285 /* Search for MPEG stream */
1286 for(i=0; i<p->buf_size; i++){
1287 code = (code<<8) + p->buf[i];
1288 if ((code & 0xffffff00) == 0x100) {
1289 if(code == SYSTEM_HEADER_START_CODE) sys++;
1290 else if(code == PRIVATE_STREAM_1) priv1++;
1291 else if(code == PACK_START_CODE) pspack++;
1292 else if((code & 0xf0) == VIDEO_ID) vid++;
1293 else if((code & 0xe0) == AUDIO_ID) audio++;
1297 if(vid || audio) /* invalid VDR files nd short PES streams */
1298 score= AVPROBE_SCORE_MAX/4;
1300 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1301 if(sys && sys*9 <= pspack*10)
1302 return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1303 if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1304 return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1305 if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1306 return AVPROBE_SCORE_MAX/2+2;
1308 //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1313 typedef struct MpegDemuxContext {
1314 int32_t header_state;
1315 unsigned char psm_es_type[256];
1318 static int mpegps_read_header(AVFormatContext *s,
1319 AVFormatParameters *ap)
1321 MpegDemuxContext *m = s->priv_data;
1322 m->header_state = 0xff;
1323 s->ctx_flags |= AVFMTCTX_NOHEADER;
1325 /* no need to do more */
1329 static int64_t get_pts(ByteIOContext *pb, int c)
1336 pts = (int64_t)((c >> 1) & 0x07) << 30;
1338 pts |= (int64_t)(val >> 1) << 15;
1340 pts |= (int64_t)(val >> 1);
1344 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1345 int32_t *header_state)
1347 unsigned int state, v;
1350 state = *header_state;
1357 if (state == 0x000001) {
1358 state = ((state << 8) | v) & 0xffffff;
1362 state = ((state << 8) | v) & 0xffffff;
1366 *header_state = state;
1371 #if 0 /* unused, remove? */
1373 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1375 int64_t pos, pos_start;
1376 int max_size, start_code;
1378 max_size = *size_ptr;
1379 pos_start = url_ftell(pb);
1381 /* in order to go faster, we fill the buffer */
1382 pos = pos_start - 16386;
1385 url_fseek(pb, pos, SEEK_SET);
1391 if (pos < 0 || (pos_start - pos) >= max_size) {
1395 url_fseek(pb, pos, SEEK_SET);
1396 start_code = get_be32(pb);
1397 if ((start_code & 0xffffff00) == 0x100)
1401 *size_ptr = pos_start - pos;
1407 * Extracts stream types from a program stream map
1408 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1410 * @return number of bytes occupied by PSM in the bitstream
1412 static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1414 int psm_length, ps_info_length, es_map_length;
1416 psm_length = get_be16(pb);
1419 ps_info_length = get_be16(pb);
1421 /* skip program_stream_info */
1422 url_fskip(pb, ps_info_length);
1423 es_map_length = get_be16(pb);
1425 /* at least one es available? */
1426 while (es_map_length >= 4){
1427 unsigned char type = get_byte(pb);
1428 unsigned char es_id = get_byte(pb);
1429 uint16_t es_info_length = get_be16(pb);
1430 /* remember mapping from stream id to stream type */
1431 m->psm_es_type[es_id] = type;
1432 /* skip program_stream_info */
1433 url_fskip(pb, es_info_length);
1434 es_map_length -= 4 + es_info_length;
1436 get_be32(pb); /* crc32 */
1437 return 2 + psm_length;
1440 /* read the next PES header. Return its position in ppos
1441 (if not NULL), and its start code, pts and dts.
1443 static int mpegps_read_pes_header(AVFormatContext *s,
1444 int64_t *ppos, int *pstart_code,
1445 int64_t *ppts, int64_t *pdts)
1447 MpegDemuxContext *m = s->priv_data;
1448 int len, size, startcode, c, flags, header_len;
1449 int pes_ext, ext2_len, id_ext, skip;
1451 int64_t last_sync= url_ftell(&s->pb);
1454 url_fseek(&s->pb, last_sync, SEEK_SET);
1456 /* next start code (should be immediately after) */
1457 m->header_state = 0xff;
1458 size = MAX_SYNC_SIZE;
1459 startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1460 last_sync = url_ftell(&s->pb);
1461 //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(&s->pb));
1464 if (startcode == PACK_START_CODE)
1466 if (startcode == SYSTEM_HEADER_START_CODE)
1468 if (startcode == PADDING_STREAM ||
1469 startcode == PRIVATE_STREAM_2) {
1471 len = get_be16(&s->pb);
1472 url_fskip(&s->pb, len);
1475 if (startcode == PROGRAM_STREAM_MAP) {
1476 mpegps_psm_parse(m, &s->pb);
1480 /* find matching stream */
1481 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1482 (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1483 (startcode == 0x1bd) || (startcode == 0x1fd)))
1486 *ppos = url_ftell(&s->pb) - 4;
1488 len = get_be16(&s->pb);
1490 dts = AV_NOPTS_VALUE;
1495 c = get_byte(&s->pb);
1497 /* XXX: for mpeg1, should test only bit 7 */
1501 if ((c & 0xc0) == 0x40) {
1502 /* buffer scale & size */
1504 c = get_byte(&s->pb);
1507 if ((c & 0xe0) == 0x20) {
1508 dts = pts = get_pts(&s->pb, c);
1511 dts = get_pts(&s->pb, -1);
1514 } else if ((c & 0xc0) == 0x80) {
1516 #if 0 /* some streams have this field set for no apparent reason */
1517 if ((c & 0x30) != 0) {
1518 /* Encrypted multiplex not handled */
1522 flags = get_byte(&s->pb);
1523 header_len = get_byte(&s->pb);
1525 if (header_len > len)
1529 dts = pts = get_pts(&s->pb, -1);
1532 dts = get_pts(&s->pb, -1);
1536 if (flags & 0x01) { /* PES extension */
1537 pes_ext = get_byte(&s->pb);
1539 if (pes_ext & 0x40) { /* pack header - should be zero in PS */
1542 /* Skip PES private data, program packet sequence counter and P-STD buffer */
1543 skip = (pes_ext >> 4) & 0xb;
1545 url_fskip(&s->pb, skip);
1548 if (pes_ext & 0x01) { /* PES extension 2 */
1549 ext2_len = get_byte(&s->pb);
1551 if ((ext2_len & 0x7f) > 0) {
1552 id_ext = get_byte(&s->pb);
1553 if ((id_ext & 0x80) == 0)
1554 startcode = ((startcode & 0xff) << 8) | id_ext;
1561 url_fskip(&s->pb, header_len);
1566 if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1567 startcode = get_byte(&s->pb);
1569 if (startcode >= 0x80 && startcode <= 0xcf) {
1570 /* audio: skip header */
1575 if (startcode >= 0xb0 && startcode <= 0xbf) {
1576 /* MLP/TrueHD audio has a 4-byte header */
1584 if(dts != AV_NOPTS_VALUE && ppos){
1586 for(i=0; i<s->nb_streams; i++){
1587 if(startcode == s->streams[i]->id) {
1588 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1593 *pstart_code = startcode;
1599 static int mpegps_read_packet(AVFormatContext *s,
1602 MpegDemuxContext *m = s->priv_data;
1604 int len, startcode, i, type, codec_id = 0, es_type;
1605 int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1608 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1612 /* now find stream */
1613 for(i=0;i<s->nb_streams;i++) {
1615 if (st->id == startcode)
1619 es_type = m->psm_es_type[startcode & 0xff];
1621 if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1622 codec_id = CODEC_ID_MPEG2VIDEO;
1623 type = CODEC_TYPE_VIDEO;
1624 } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1625 codec_id = CODEC_ID_MPEG2VIDEO;
1626 type = CODEC_TYPE_VIDEO;
1627 } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1628 es_type == STREAM_TYPE_AUDIO_MPEG2){
1629 codec_id = CODEC_ID_MP3;
1630 type = CODEC_TYPE_AUDIO;
1631 } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1632 codec_id = CODEC_ID_AAC;
1633 type = CODEC_TYPE_AUDIO;
1634 } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1635 codec_id = CODEC_ID_MPEG4;
1636 type = CODEC_TYPE_VIDEO;
1637 } else if(es_type == STREAM_TYPE_VIDEO_H264){
1638 codec_id = CODEC_ID_H264;
1639 type = CODEC_TYPE_VIDEO;
1640 } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1641 codec_id = CODEC_ID_AC3;
1642 type = CODEC_TYPE_AUDIO;
1646 } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1647 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1648 unsigned char buf[8];
1649 get_buffer(&s->pb, buf, 8);
1650 url_fseek(&s->pb, -8, SEEK_CUR);
1651 if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1652 codec_id = CODEC_ID_CAVS;
1654 codec_id = CODEC_ID_MPEG2VIDEO;
1655 type = CODEC_TYPE_VIDEO;
1656 } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1657 type = CODEC_TYPE_AUDIO;
1658 codec_id = CODEC_ID_MP2;
1659 } else if (startcode >= 0x80 && startcode <= 0x87) {
1660 type = CODEC_TYPE_AUDIO;
1661 codec_id = CODEC_ID_AC3;
1662 } else if ((startcode >= 0x88 && startcode <= 0x8f)
1663 ||( startcode >= 0x98 && startcode <= 0x9f)) {
1664 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
1665 type = CODEC_TYPE_AUDIO;
1666 codec_id = CODEC_ID_DTS;
1667 } else if (startcode >= 0xa0 && startcode <= 0xaf) {
1668 type = CODEC_TYPE_AUDIO;
1669 codec_id = CODEC_ID_PCM_S16BE;
1670 } else if (startcode >= 0xb0 && startcode <= 0xbf) {
1671 type = CODEC_TYPE_AUDIO;
1672 codec_id = CODEC_ID_MLP;
1673 } else if (startcode >= 0xc0 && startcode <= 0xcf) {
1674 /* Used for both AC-3 and E-AC-3 in EVOB files */
1675 type = CODEC_TYPE_AUDIO;
1676 codec_id = CODEC_ID_AC3;
1677 } else if (startcode >= 0x20 && startcode <= 0x3f) {
1678 type = CODEC_TYPE_SUBTITLE;
1679 codec_id = CODEC_ID_DVD_SUBTITLE;
1680 } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
1681 type = CODEC_TYPE_VIDEO;
1682 codec_id = CODEC_ID_VC1;
1686 url_fskip(&s->pb, len);
1689 /* no stream found: add a new stream */
1690 st = av_new_stream(s, startcode);
1693 st->codec->codec_type = type;
1694 st->codec->codec_id = codec_id;
1695 if (codec_id != CODEC_ID_PCM_S16BE)
1696 st->need_parsing = AVSTREAM_PARSE_FULL;
1698 if(st->discard >= AVDISCARD_ALL)
1700 if (startcode >= 0xa0 && startcode <= 0xaf) {
1703 /* for LPCM, we just skip the header and consider it is raw
1707 get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1708 b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1709 get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1711 freq = (b1 >> 4) & 3;
1712 st->codec->sample_rate = lpcm_freq_tab[freq];
1713 st->codec->channels = 1 + (b1 & 7);
1714 st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1716 av_new_packet(pkt, len);
1717 get_buffer(&s->pb, pkt->data, pkt->size);
1720 pkt->stream_index = st->index;
1722 av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1723 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1729 static int mpegps_read_close(AVFormatContext *s)
1734 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1735 int64_t *ppos, int64_t pos_limit)
1738 int64_t pos, pts, dts;
1742 printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
1744 url_fseek(&s->pb, pos, SEEK_SET);
1746 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1749 printf("none (ret=%d)\n", len);
1751 return AV_NOPTS_VALUE;
1753 if (startcode == s->streams[stream_index]->id &&
1754 dts != AV_NOPTS_VALUE) {
1757 url_fskip(&s->pb, len);
1760 printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
1766 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1767 AVOutputFormat mpeg1system_muxer = {
1769 "MPEG1 System format",
1772 sizeof(MpegMuxContext),
1774 CODEC_ID_MPEG1VIDEO,
1776 mpeg_mux_write_packet,
1780 #ifdef CONFIG_MPEG1VCD_MUXER
1781 AVOutputFormat mpeg1vcd_muxer = {
1783 "MPEG1 System format (VCD)",
1786 sizeof(MpegMuxContext),
1788 CODEC_ID_MPEG1VIDEO,
1790 mpeg_mux_write_packet,
1794 #ifdef CONFIG_MPEG2VOB_MUXER
1795 AVOutputFormat mpeg2vob_muxer = {
1797 "MPEG2 PS format (VOB)",
1800 sizeof(MpegMuxContext),
1802 CODEC_ID_MPEG2VIDEO,
1804 mpeg_mux_write_packet,
1809 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1810 #ifdef CONFIG_MPEG2SVCD_MUXER
1811 AVOutputFormat mpeg2svcd_muxer = {
1813 "MPEG2 PS format (VOB)",
1816 sizeof(MpegMuxContext),
1818 CODEC_ID_MPEG2VIDEO,
1820 mpeg_mux_write_packet,
1825 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1826 #ifdef CONFIG_MPEG2DVD_MUXER
1827 AVOutputFormat mpeg2dvd_muxer = {
1829 "MPEG2 PS format (DVD VOB)",
1832 sizeof(MpegMuxContext),
1834 CODEC_ID_MPEG2VIDEO,
1836 mpeg_mux_write_packet,
1841 #ifdef CONFIG_MPEGPS_DEMUXER
1842 AVInputFormat mpegps_demuxer = {
1845 sizeof(MpegDemuxContext),
1850 NULL, //mpegps_read_seek,
1852 .flags = AVFMT_SHOW_IDS,