3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
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.
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.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #define MAX_PAYLOAD_SIZE 4096
28 uint8_t buffer[MAX_PAYLOAD_SIZE];
30 int nb_frames; /* number of starting frame encountered (AC3) */
31 int frame_start_offset; /* starting offset of the frame + 1 (0 if none) */
33 int max_buffer_size; /* in bytes */
37 uint8_t lpcm_header[3];
42 int packet_size; /* required packet size */
44 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
45 int system_header_freq;
46 int system_header_size;
47 int mux_rate; /* bitrate in units of 50 bytes/s */
54 int scr_stream_index; /* stream from which the system clock is
55 computed (VBR case) */
56 int64_t last_scr; /* current system clock */
58 double vcd_padding_bitrate;
59 int64_t vcd_padding_bytes_written;
63 #define PACK_START_CODE ((unsigned int)0x000001ba)
64 #define SYSTEM_HEADER_START_CODE ((unsigned int)0x000001bb)
65 #define SEQUENCE_END_CODE ((unsigned int)0x000001b7)
66 #define PACKET_START_CODE_MASK ((unsigned int)0xffffff00)
67 #define PACKET_START_CODE_PREFIX ((unsigned int)0x00000100)
68 #define ISO_11172_END_CODE ((unsigned int)0x000001b9)
71 #define PROGRAM_STREAM_MAP 0x1bc
72 #define PRIVATE_STREAM_1 0x1bd
73 #define PADDING_STREAM 0x1be
74 #define PRIVATE_STREAM_2 0x1bf
82 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
84 #ifdef CONFIG_ENCODERS
85 static AVOutputFormat mpeg1system_mux;
86 static AVOutputFormat mpeg1vcd_mux;
87 static AVOutputFormat mpeg2vob_mux;
88 static AVOutputFormat mpeg2svcd_mux;
90 static int put_pack_header(AVFormatContext *ctx,
91 uint8_t *buf, int64_t timestamp)
93 MpegMuxContext *s = ctx->priv_data;
96 init_put_bits(&pb, buf, 128);
98 put_bits(&pb, 32, PACK_START_CODE);
100 put_bits(&pb, 2, 0x1);
102 put_bits(&pb, 4, 0x2);
104 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
106 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
108 put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
111 /* clock extension */
115 put_bits(&pb, 22, s->mux_rate);
119 put_bits(&pb, 5, 0x1f); /* reserved */
120 put_bits(&pb, 3, 0); /* stuffing length */
123 return pbBufPtr(&pb) - pb.buf;
126 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
128 MpegMuxContext *s = ctx->priv_data;
129 int size, rate_bound, i, private_stream_coded, id;
132 init_put_bits(&pb, buf, 128);
134 put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
135 put_bits(&pb, 16, 0);
138 rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
139 put_bits(&pb, 22, rate_bound);
140 put_bits(&pb, 1, 1); /* marker */
141 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
142 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
145 put_bits(&pb, 6, s->audio_bound);
148 /* see VCD standard, p. IV-7*/
152 put_bits(&pb, 1, 0); /* variable bitrate*/
153 put_bits(&pb, 1, 0); /* non constrainted bit stream */
157 /* see VCD standard p IV-7 */
158 put_bits(&pb, 1, 1); /* audio locked */
159 put_bits(&pb, 1, 1); /* video locked */
161 put_bits(&pb, 1, 0); /* audio locked */
162 put_bits(&pb, 1, 0); /* video locked */
165 put_bits(&pb, 1, 1); /* marker */
167 if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
168 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
171 put_bits(&pb, 5, s->video_bound);
173 put_bits(&pb, 8, 0xff); /* reserved byte */
175 /* audio stream info */
176 private_stream_coded = 0;
177 for(i=0;i<ctx->nb_streams;i++) {
178 StreamInfo *stream = ctx->streams[i]->priv_data;
180 /* For VCDs, only include the stream info for the stream
181 that the pack which contains this system belongs to.
182 (see VCD standard p. IV-7) */
183 if ( !s->is_vcd || stream->id==only_for_stream_id
184 || only_for_stream_id==0) {
188 /* special case for private streams (AC3 use that) */
189 if (private_stream_coded)
191 private_stream_coded = 1;
194 put_bits(&pb, 8, id); /* stream ID */
199 put_bits(&pb, 13, stream->max_buffer_size / 128);
203 put_bits(&pb, 13, stream->max_buffer_size / 1024);
208 size = pbBufPtr(&pb) - pb.buf;
209 /* patch packet size */
210 buf[4] = (size - 6) >> 8;
211 buf[5] = (size - 6) & 0xff;
216 static int get_system_header_size(AVFormatContext *ctx)
218 int buf_index, i, private_stream_coded;
222 private_stream_coded = 0;
223 for(i=0;i<ctx->nb_streams;i++) {
224 stream = ctx->streams[i]->priv_data;
225 if (stream->id < 0xc0) {
226 if (private_stream_coded)
228 private_stream_coded = 1;
235 static int mpeg_mux_init(AVFormatContext *ctx)
237 MpegMuxContext *s = ctx->priv_data;
238 int bitrate, i, mpa_id, mpv_id, ac3_id, lpcm_id, j;
244 s->packet_number = 0;
245 s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
246 s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
247 s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux);
249 if (s->is_vcd || s->is_svcd)
250 s->packet_size = 2324; /* VCD/SVCD packet size */
252 s->packet_size = 2048;
254 s->vcd_padding_bytes_written = 0;
255 s->vcd_padding_bitrate=0;
263 s->scr_stream_index = -1;
264 for(i=0;i<ctx->nb_streams;i++) {
265 st = ctx->streams[i];
266 stream = av_mallocz(sizeof(StreamInfo));
269 st->priv_data = stream;
271 switch(st->codec.codec_type) {
272 case CODEC_TYPE_AUDIO:
273 if (st->codec.codec_id == CODEC_ID_AC3) {
274 stream->id = ac3_id++;
275 } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
276 stream->id = lpcm_id++;
277 for(j = 0; j < 4; j++) {
278 if (lpcm_freq_tab[j] == st->codec.sample_rate)
283 if (st->codec.channels > 8)
285 stream->lpcm_header[0] = 0x0c;
286 stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
287 stream->lpcm_header[2] = 0x80;
288 stream->lpcm_align = st->codec.channels * 2;
290 stream->id = mpa_id++;
293 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
294 Right now it is also used for everything else.*/
295 stream->max_buffer_size = 4 * 1024;
298 case CODEC_TYPE_VIDEO:
299 /* by default, video is used for the SCR computation */
300 if (s->scr_stream_index == -1)
301 s->scr_stream_index = i;
302 stream->id = mpv_id++;
304 /* see VCD standard, p. IV-7*/
305 stream->max_buffer_size = 46 * 1024;
307 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
308 Right now it is also used for everything else.*/
309 stream->max_buffer_size = 230 * 1024;
316 /* if no SCR, use first stream (audio) */
317 if (s->scr_stream_index == -1)
318 s->scr_stream_index = 0;
323 for(i=0;i<ctx->nb_streams;i++) {
324 st = ctx->streams[i];
325 stream = (StreamInfo*) st->priv_data;
327 bitrate += st->codec.bit_rate;
329 if (stream->id==AUDIO_ID)
330 audio_bitrate += st->codec.bit_rate;
331 else if (stream->id==VIDEO_ID)
332 video_bitrate += st->codec.bit_rate;
336 double overhead_rate;
338 /* The VCD standard mandates that the mux_rate field is 3528
339 (see standard p. IV-6).
340 The value is actually "wrong", i.e. if you calculate
341 it using the normal formula and the 75 sectors per second transfer
342 rate you get a different value because the real pack size is 2324,
343 not 2352. But the standard explicitly specifies that the mux_rate
344 field in the header must have this value.*/
345 s->mux_rate=2352 * 75 / 50; /* = 3528*/
347 /* The VCD standard states that the muxed stream must be
348 exactly 75 packs / second (the data rate of a single speed cdrom).
349 Since the video bitrate (probably 1150000 bits/sec) will be below
350 the theoretical maximum we have to add some padding packets
351 to make up for the lower data rate.
352 (cf. VCD standard p. IV-6 )*/
354 /* Add the header overhead to the data rate.
355 2279 data bytes per audio pack, 2294 data bytes per video pack*/
356 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
357 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
360 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
361 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
364 /* we increase slightly the bitrate to take into account the
365 headers. XXX: compute it exactly */
367 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
370 if (s->is_vcd || s->is_mpeg2)
372 s->pack_header_freq = 1;
374 /* every 2 seconds */
375 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
377 /* the above seems to make pack_header_freq zero sometimes */
378 if (s->pack_header_freq == 0)
379 s->pack_header_freq = 1;
382 /* every 200 packets. Need to look at the spec. */
383 s->system_header_freq = s->pack_header_freq * 40;
385 /* the standard mandates that there are only two system headers
386 in the whole file: one in the first packet of each stream.
387 (see standard p. IV-7 and IV-8) */
388 s->system_header_freq = 0x7fffffff;
390 s->system_header_freq = s->pack_header_freq * 5;
392 for(i=0;i<ctx->nb_streams;i++) {
393 stream = ctx->streams[i]->priv_data;
394 stream->buffer_ptr = 0;
395 stream->packet_number = 0;
396 stream->start_pts = AV_NOPTS_VALUE;
397 stream->start_dts = AV_NOPTS_VALUE;
399 s->system_header_size = get_system_header_size(ctx);
403 for(i=0;i<ctx->nb_streams;i++) {
404 av_free(ctx->streams[i]->priv_data);
409 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
413 (((timestamp >> 30) & 0x07) << 1) |
415 put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
416 put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
420 /* return the number of padding bytes that should be inserted into
421 the multiplexed stream.*/
422 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
424 MpegMuxContext *s = ctx->priv_data;
427 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
429 int64_t full_pad_bytes;
431 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0);
432 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
435 /* might happen if we have already padded to a later timestamp. This
436 can occur if another stream has already advanced further.*/
444 /* return the exact available payload size for the next packet for
445 stream 'stream_index'. 'pts' and 'dts' are only used to know if
446 timestamps are needed in the packet header. */
447 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
448 int64_t pts, int64_t dts)
450 MpegMuxContext *s = ctx->priv_data;
454 stream = ctx->streams[stream_index]->priv_data;
457 if (((s->packet_number % s->pack_header_freq) == 0)) {
458 /* pack header size */
465 /* there is exactly one system header for each stream in a VCD MPEG,
466 One in the very first video packet and one in the very first
467 audio packet (see VCD standard p. IV-7 and IV-8).*/
469 if (stream->packet_number==0)
470 /* The system headers refer only to the stream they occur in,
471 so they have a constant size.*/
475 if ((s->packet_number % s->system_header_freq) == 0)
476 buf_index += s->system_header_size;
480 if ((s->is_vcd && stream->packet_number==0)
481 || (s->is_svcd && s->packet_number==0))
482 /* the first pack of each stream contains only the pack header,
483 the system header and some padding (see VCD standard p. IV-6)
484 Add the padding size, so that the actual payload becomes 0.*/
485 buf_index += s->packet_size - buf_index;
487 /* packet header size */
491 if (stream->packet_number==0)
492 buf_index += 3; /* PES extension */
493 buf_index += 1; /* obligatory stuffing byte */
495 if (pts != AV_NOPTS_VALUE) {
506 if (stream->id < 0xc0) {
507 /* AC3/LPCM private data header */
509 if (stream->id >= 0xa0) {
512 /* NOTE: we round the payload size to an integer number of
514 n = (s->packet_size - buf_index) % stream->lpcm_align;
516 buf_index += (stream->lpcm_align - n);
520 if (s->is_vcd && stream->id == AUDIO_ID)
521 /* The VCD standard demands that 20 zero bytes follow
522 each audio packet (see standard p. IV-8).*/
525 return s->packet_size - buf_index;
528 /* Write an MPEG padding packet header. */
529 static int put_padding_header(AVFormatContext *ctx,uint8_t* buf, int full_padding_size)
531 MpegMuxContext *s = ctx->priv_data;
532 int size = full_padding_size - 6; /* subtract header length */
534 buf[0] = (uint8_t)(PADDING_STREAM >> 24);
535 buf[1] = (uint8_t)(PADDING_STREAM >> 16);
536 buf[2] = (uint8_t)(PADDING_STREAM >> 8);
537 buf[3] = (uint8_t)(PADDING_STREAM);
538 buf[4] = (uint8_t)(size >> 8);
539 buf[5] = (uint8_t)(size & 0xff);
548 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
553 size = put_padding_header(ctx,buffer, packet_bytes);
554 put_buffer(pb, buffer, size);
555 packet_bytes -= size;
557 for(i=0;i<packet_bytes;i++)
562 /* flush the packet on stream stream_index */
563 static void flush_packet(AVFormatContext *ctx, int stream_index,
564 int64_t pts, int64_t dts, int64_t scr)
566 MpegMuxContext *s = ctx->priv_data;
567 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
569 int size, payload_size, startcode, id, stuffing_size, i, header_len;
572 int zero_trail_bytes = 0;
573 int pad_packet_bytes = 0;
575 int general_pack = 0; /*"general" pack without data specific to one stream?*/
580 printf("packet ID=%2x PTS=%0.3f\n",
586 if (((s->packet_number % s->pack_header_freq) == 0)) {
587 /* output pack and systems header if needed */
588 size = put_pack_header(ctx, buf_ptr, scr);
592 /* there is exactly one system header for each stream in a VCD MPEG,
593 One in the very first video packet and one in the very first
594 audio packet (see VCD standard p. IV-7 and IV-8).*/
596 if (stream->packet_number==0) {
597 size = put_system_header(ctx, buf_ptr, id);
601 if ((s->packet_number % s->system_header_freq) == 0) {
602 size = put_system_header(ctx, buf_ptr, 0);
607 size = buf_ptr - buffer;
608 put_buffer(&ctx->pb, buffer, size);
610 packet_size = s->packet_size - size;
612 if (s->is_vcd && id == AUDIO_ID)
613 /* The VCD standard demands that 20 zero bytes follow
614 each audio pack (see standard p. IV-8).*/
615 zero_trail_bytes += 20;
617 if ((s->is_vcd && stream->packet_number==0)
618 || (s->is_svcd && s->packet_number==0)) {
619 /* for VCD the first pack of each stream contains only the pack header,
620 the system header and lots of padding (see VCD standard p. IV-6).
621 In the case of an audio pack, 20 zero bytes are also added at
623 /* For SVCD we fill the very first pack to increase compatibility with
624 some DVD players. Not mandated by the standard.*/
626 general_pack = 1; /* the system header refers to both streams and no stream data*/
627 pad_packet_bytes = packet_size - zero_trail_bytes;
630 packet_size -= pad_packet_bytes + zero_trail_bytes;
632 if (packet_size > 0) {
634 /* packet header size */
640 if (stream->packet_number==0)
641 header_len += 3; /* PES extension */
642 header_len += 1; /* obligatory stuffing byte */
646 if (pts != AV_NOPTS_VALUE) {
656 payload_size = packet_size - header_len;
658 startcode = PRIVATE_STREAM_1;
663 startcode = 0x100 + id;
666 stuffing_size = payload_size - stream->buffer_ptr;
667 if (stuffing_size < 0)
669 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
670 pad_packet_bytes += stuffing_size;
671 packet_size -= stuffing_size;
672 payload_size -= stuffing_size;
676 put_be32(&ctx->pb, startcode);
678 put_be16(&ctx->pb, packet_size);
681 for(i=0;i<stuffing_size;i++)
682 put_byte(&ctx->pb, 0xff);
685 put_byte(&ctx->pb, 0x80); /* mpeg2 id */
689 if (pts != AV_NOPTS_VALUE) {
695 /* Both the MPEG-2 and the SVCD standards demand that the
696 P-STD_buffer_size field be included in the first packet of
697 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
698 and MPEG-2 standard 2.7.7) */
699 if (stream->packet_number == 0)
702 put_byte(&ctx->pb, pes_flags); /* flags */
703 put_byte(&ctx->pb, header_len - 3 + stuffing_size);
705 if (pes_flags & 0x80) /*write pts*/
706 put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
707 if (pes_flags & 0x40) /*write dts*/
708 put_timestamp(&ctx->pb, 0x01, dts);
710 if (pes_flags & 0x01) { /*write pes extension*/
711 put_byte(&ctx->pb, 0x10); /* flags */
713 /* P-STD buffer info */
715 put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
717 put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
721 if (pts != AV_NOPTS_VALUE) {
723 put_timestamp(&ctx->pb, 0x03, pts);
724 put_timestamp(&ctx->pb, 0x01, dts);
726 put_timestamp(&ctx->pb, 0x02, pts);
729 put_byte(&ctx->pb, 0x0f);
733 if (startcode == PRIVATE_STREAM_1) {
734 put_byte(&ctx->pb, id);
736 /* LPCM (XXX: check nb_frames) */
737 put_byte(&ctx->pb, 7);
738 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
739 put_byte(&ctx->pb, stream->lpcm_header[0]);
740 put_byte(&ctx->pb, stream->lpcm_header[1]);
741 put_byte(&ctx->pb, stream->lpcm_header[2]);
744 put_byte(&ctx->pb, stream->nb_frames);
745 put_be16(&ctx->pb, stream->frame_start_offset);
750 /* special stuffing byte that is always written
751 to prevent accidental generation of start codes. */
752 put_byte(&ctx->pb, 0xff);
754 for(i=0;i<stuffing_size;i++)
755 put_byte(&ctx->pb, 0xff);
759 put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
762 if (pad_packet_bytes > 0)
763 put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
765 for(i=0;i<zero_trail_bytes;i++)
766 put_byte(&ctx->pb, 0x00);
768 put_flush_packet(&ctx->pb);
772 /* only increase the stream packet number if this pack actually contains
773 something that is specific to this stream! I.e. a dedicated header
776 stream->packet_number++;
777 stream->nb_frames = 0;
778 stream->frame_start_offset = 0;
781 static void put_vcd_padding_sector(AVFormatContext *ctx)
783 /* There are two ways to do this padding: writing a sector/pack
784 of 0 values, or writing an MPEG padding pack. Both seem to
785 work with most decoders, BUT the VCD standard only allows a 0-sector
786 (see standard p. IV-4, IV-5).
787 So a 0-sector it is...*/
789 MpegMuxContext *s = ctx->priv_data;
792 for(i=0;i<s->packet_size;i++)
793 put_byte(&ctx->pb, 0);
795 s->vcd_padding_bytes_written += s->packet_size;
797 put_flush_packet(&ctx->pb);
799 /* increasing the packet number is correct. The SCR of the following packs
800 is calculated from the packet_number and it has to include the padding
801 sector (it represents the sector index, not the MPEG pack index)
802 (see VCD standard p. IV-6)*/
806 /* XXX: move that to upper layer */
807 /* XXX: we assume that there are always 'max_b_frames' between
808 reference frames. A better solution would be to use the AVFrame pts
810 static void compute_pts_dts(AVStream *st, int64_t *ppts, int64_t *pdts,
816 if (st->codec.codec_type == CODEC_TYPE_VIDEO &&
817 st->codec.max_b_frames != 0) {
818 frame_delay = (st->codec.frame_rate_base * 90000LL) /
819 st->codec.frame_rate;
820 if (timestamp == 0) {
821 /* specific case for first frame : DTS just before */
823 dts = timestamp - frame_delay;
825 timestamp -= frame_delay;
826 if (st->codec.coded_frame->pict_type == FF_B_TYPE) {
827 /* B frames has identical pts/dts */
831 /* a reference frame has a pts equal to the dts of the
834 pts = timestamp + (st->codec.max_b_frames + 1) * frame_delay;
838 av_log(&st->codec, AV_LOG_DEBUG, "pts=%0.3f dts=%0.3f pict_type=%c\n",
839 pts / 90000.0, dts / 90000.0,
840 av_get_pict_type_char(st->codec.coded_frame->pict_type));
847 *ppts = pts & ((1LL << 33) - 1);
848 *pdts = dts & ((1LL << 33) - 1);
851 static int64_t update_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
853 MpegMuxContext *s = ctx->priv_data;
859 /* Since the data delivery rate is constant, SCR is computed
860 using the formula C + i * 1200 where C is the start constant
861 and i is the pack index.
862 It is recommended that SCR 0 is at the beginning of the VCD front
863 margin (a sequence of empty Form 2 sectors on the CD).
864 It is recommended that the front margin is 30 sectors long, so
865 we use C = 30*1200 = 36000
866 (Note that even if the front margin is not 30 sectors the file
867 will still be correct according to the standard. It just won't have
868 the "recommended" value).*/
869 scr = 36000 + s->packet_number * 1200;
873 for(i=0;i<ctx->nb_streams;i++) {
874 stream = ctx->streams[i]->priv_data;
876 if(scr > stream->start_pts && stream->start_pts!=AV_NOPTS_VALUE) {
877 av_log(ctx, AV_LOG_DEBUG, "mpeg vcd: SCR above PTS (scr=%0.3f, stream index=%d, stream_pts=%0.3f).\n", scr/90000.0, i, stream->start_pts / 90000.0);
885 /* XXX I believe this calculation of SCR is wrong. SCR
886 specifies at which time the data should enter the decoder.
887 Two packs cannot enter the decoder at the same time. */
889 /* XXX: system clock should be computed precisely, especially for
890 CBR case. The current mode gives at least something coherent */
891 if (stream_index == s->scr_stream_index
892 && pts != AV_NOPTS_VALUE)
897 /* "Sanity hack": make sure that the SCR does not overtake the pts of
898 buffered data that is still waiting to be written.*/
899 for(i=0;i<ctx->nb_streams;i++) {
900 stream = ctx->streams[i]->priv_data;
902 if(scr > stream->start_pts && stream->start_pts!=AV_NOPTS_VALUE) {
903 /* av_log(ctx, AV_LOG_DEBUG, "mpeg: restricting scr to stream pts (scr=%0.3f, stream index=%d, stream_pts=%0.3f).\n", scr/90000.0, i, stream->start_pts / 90000.0); */
904 scr = stream->start_pts;
915 static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
916 const uint8_t *buf, int size,
919 MpegMuxContext *s = ctx->priv_data;
920 AVStream *st = ctx->streams[stream_index];
921 StreamInfo *stream = st->priv_data;
922 int64_t pts, dts, new_start_pts, new_start_dts;
925 compute_pts_dts(st, &pts, &dts, timestamp);
928 /* offset pts and dts slightly into the future to be able
929 to do the compatibility fix below.*/
930 pts = (pts + 2) & ((1LL << 33) - 1);
931 dts = (dts + 2) & ((1LL << 33) - 1);
933 if (stream->packet_number == 0 && dts == pts)
934 /* For the very first packet we want to force the DTS to be included.
935 This increases compatibility with lots of DVD players.
936 Since the MPEG-2 standard mandates that DTS is only written when
937 it is different from PTS we have to move it slightly into the past.*/
938 dts = (dts - 2) & ((1LL << 33) - 1);
941 /* We have to offset the PTS, so that it is consistent with the SCR.
942 SCR starts at 36000, but the first two packs contain only padding
943 and the first pack from the other stream, respectively, may also have
945 So the real data starts at SCR 36000+3*1200. */
946 pts = (pts + 36000 + 3600) & ((1LL << 33) - 1);
947 dts = (dts + 36000 + 3600) & ((1LL << 33) - 1);
951 update_scr(ctx,stream_index,pts);
953 printf("%d: pts=%0.3f dts=%0.3f scr=%0.3f\n",
957 s->last_scr / 90000.0);
960 /* we assume here that pts != AV_NOPTS_VALUE */
961 new_start_pts = stream->start_pts;
962 new_start_dts = stream->start_dts;
964 if (stream->start_pts == AV_NOPTS_VALUE) {
968 avail_size = get_packet_payload_size(ctx, stream_index,
971 if (stream->buffer_ptr >= avail_size) {
973 update_scr(ctx,stream_index,stream->start_pts);
975 /* unlikely case: outputing the pts or dts increase the packet
976 size so that we cannot write the start of the next
977 packet. In this case, we must flush the current packet with
979 Note: this always happens for the first audio and video packet
980 in a VCD file, since they do not carry any data.*/
981 flush_packet(ctx, stream_index,
982 stream->start_pts, stream->start_dts, s->last_scr);
983 stream->buffer_ptr = 0;
985 stream->start_pts = new_start_pts;
986 stream->start_dts = new_start_dts;
988 if (stream->frame_start_offset == 0)
989 stream->frame_start_offset = stream->buffer_ptr;
991 avail_size = get_packet_payload_size(ctx, stream_index,
994 len = avail_size - stream->buffer_ptr;
997 memcpy(stream->buffer + stream->buffer_ptr, buf, len);
998 stream->buffer_ptr += len;
1001 if (stream->buffer_ptr >= avail_size) {
1003 update_scr(ctx,stream_index,stream->start_pts);
1005 /* if packet full, we send it now */
1006 flush_packet(ctx, stream_index,
1007 stream->start_pts, stream->start_dts, s->last_scr);
1008 stream->buffer_ptr = 0;
1011 /* Write one or more padding sectors, if necessary, to reach
1012 the constant overall bitrate.*/
1015 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->start_pts) ) >= s->packet_size)
1016 put_vcd_padding_sector(ctx);
1019 /* Make sure only the FIRST pes packet for this frame has
1021 stream->start_pts = AV_NOPTS_VALUE;
1022 stream->start_dts = AV_NOPTS_VALUE;
1029 static int mpeg_mux_end(AVFormatContext *ctx)
1031 MpegMuxContext *s = ctx->priv_data;
1035 /* flush each packet */
1036 for(i=0;i<ctx->nb_streams;i++) {
1037 stream = ctx->streams[i]->priv_data;
1038 if (stream->buffer_ptr > 0) {
1039 update_scr(ctx,i,stream->start_pts);
1041 /* NOTE: we can always write the remaining data as it was
1042 tested before in mpeg_mux_write_packet() */
1043 flush_packet(ctx, i, stream->start_pts, stream->start_dts,
1048 /* End header according to MPEG1 systems standard. We do not write
1049 it as it is usually not needed by decoders and because it
1050 complicates MPEG stream concatenation. */
1051 //put_be32(&ctx->pb, ISO_11172_END_CODE);
1052 //put_flush_packet(&ctx->pb);
1054 for(i=0;i<ctx->nb_streams;i++)
1055 av_freep(&ctx->streams[i]->priv_data);
1059 #endif //CONFIG_ENCODERS
1061 /*********************************************/
1064 #define MAX_SYNC_SIZE 100000
1066 static int mpegps_probe(AVProbeData *p)
1071 /* we search the first start code. If it is a packet start code,
1072 then we decide it is mpeg ps. We do not send highest value to
1073 give a chance to mpegts */
1074 /* NOTE: the search range was restricted to avoid too many false
1077 if (p->buf_size < 6)
1080 for (i = 0; i < 20; i++) {
1082 code = (code << 8) | c;
1083 if ((code & 0xffffff00) == 0x100) {
1084 if (code == PACK_START_CODE ||
1085 code == SYSTEM_HEADER_START_CODE ||
1086 (code >= 0x1e0 && code <= 0x1ef) ||
1087 (code >= 0x1c0 && code <= 0x1df) ||
1088 code == PRIVATE_STREAM_2 ||
1089 code == PROGRAM_STREAM_MAP ||
1090 code == PRIVATE_STREAM_1 ||
1091 code == PADDING_STREAM)
1092 return AVPROBE_SCORE_MAX - 2;
1101 typedef struct MpegDemuxContext {
1105 static int mpegps_read_header(AVFormatContext *s,
1106 AVFormatParameters *ap)
1108 MpegDemuxContext *m = s->priv_data;
1109 m->header_state = 0xff;
1110 s->ctx_flags |= AVFMTCTX_NOHEADER;
1112 /* no need to do more */
1116 static int64_t get_pts(ByteIOContext *pb, int c)
1123 pts = (int64_t)((c >> 1) & 0x07) << 30;
1125 pts |= (int64_t)(val >> 1) << 15;
1127 pts |= (int64_t)(val >> 1);
1131 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1132 uint32_t *header_state)
1134 unsigned int state, v;
1137 state = *header_state;
1144 if (state == 0x000001) {
1145 state = ((state << 8) | v) & 0xffffff;
1149 state = ((state << 8) | v) & 0xffffff;
1153 *header_state = state;
1159 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1161 int64_t pos, pos_start;
1162 int max_size, start_code;
1164 max_size = *size_ptr;
1165 pos_start = url_ftell(pb);
1167 /* in order to go faster, we fill the buffer */
1168 pos = pos_start - 16386;
1171 url_fseek(pb, pos, SEEK_SET);
1177 if (pos < 0 || (pos_start - pos) >= max_size) {
1181 url_fseek(pb, pos, SEEK_SET);
1182 start_code = get_be32(pb);
1183 if ((start_code & 0xffffff00) == 0x100)
1187 *size_ptr = pos_start - pos;
1191 /* read the next PES header. Return its position in ppos
1192 (if not NULL), and its start code, pts and dts.
1194 static int mpegps_read_pes_header(AVFormatContext *s,
1195 int64_t *ppos, int *pstart_code,
1196 int64_t *ppts, int64_t *pdts)
1198 MpegDemuxContext *m = s->priv_data;
1199 int len, size, startcode, c, flags, header_len;
1200 int64_t pts, dts, last_pos;
1204 /* next start code (should be immediately after) */
1205 m->header_state = 0xff;
1206 size = MAX_SYNC_SIZE;
1207 startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1208 //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1211 if (startcode == PACK_START_CODE)
1213 if (startcode == SYSTEM_HEADER_START_CODE)
1215 if (startcode == PADDING_STREAM ||
1216 startcode == PRIVATE_STREAM_2) {
1218 len = get_be16(&s->pb);
1219 url_fskip(&s->pb, len);
1222 /* find matching stream */
1223 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1224 (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1225 (startcode == 0x1bd)))
1228 *ppos = url_ftell(&s->pb) - 4;
1230 len = get_be16(&s->pb);
1231 pts = AV_NOPTS_VALUE;
1232 dts = AV_NOPTS_VALUE;
1237 c = get_byte(&s->pb);
1239 /* XXX: for mpeg1, should test only bit 7 */
1243 if ((c & 0xc0) == 0x40) {
1244 /* buffer scale & size */
1248 c = get_byte(&s->pb);
1251 if ((c & 0xf0) == 0x20) {
1254 dts = pts = get_pts(&s->pb, c);
1256 } else if ((c & 0xf0) == 0x30) {
1259 pts = get_pts(&s->pb, c);
1260 dts = get_pts(&s->pb, -1);
1262 } else if ((c & 0xc0) == 0x80) {
1264 if ((c & 0x30) != 0) {
1265 /* Encrypted multiplex not handled */
1268 flags = get_byte(&s->pb);
1269 header_len = get_byte(&s->pb);
1271 if (header_len > len)
1273 if ((flags & 0xc0) == 0x80) {
1274 dts = pts = get_pts(&s->pb, -1);
1279 } if ((flags & 0xc0) == 0xc0) {
1280 pts = get_pts(&s->pb, -1);
1281 dts = get_pts(&s->pb, -1);
1282 if (header_len < 10)
1288 while (header_len > 0) {
1296 if (startcode == 0x1bd) {
1299 startcode = get_byte(&s->pb);
1301 if (startcode >= 0x80 && startcode <= 0xbf) {
1302 /* audio: skip header */
1311 if(dts != AV_NOPTS_VALUE && ppos){
1313 for(i=0; i<s->nb_streams; i++){
1314 if(startcode == s->streams[i]->id) {
1315 av_add_index_entry(s->streams[i], *ppos, dts*AV_TIME_BASE/90000, 0, 0 /* FIXME keyframe? */);
1320 *pstart_code = startcode;
1326 static int mpegps_read_packet(AVFormatContext *s,
1330 int len, startcode, i, type, codec_id;
1331 int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1334 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1338 /* now find stream */
1339 for(i=0;i<s->nb_streams;i++) {
1341 if (st->id == startcode)
1344 if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1345 type = CODEC_TYPE_VIDEO;
1346 codec_id = CODEC_ID_MPEG2VIDEO;
1347 } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1348 type = CODEC_TYPE_AUDIO;
1349 codec_id = CODEC_ID_MP2;
1350 } else if (startcode >= 0x80 && startcode <= 0x9f) {
1351 type = CODEC_TYPE_AUDIO;
1352 codec_id = CODEC_ID_AC3;
1353 } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1354 type = CODEC_TYPE_AUDIO;
1355 codec_id = CODEC_ID_PCM_S16BE;
1359 url_fskip(&s->pb, len);
1362 /* no stream found: add a new stream */
1363 st = av_new_stream(s, startcode);
1366 st->codec.codec_type = type;
1367 st->codec.codec_id = codec_id;
1368 if (codec_id != CODEC_ID_PCM_S16BE)
1369 st->need_parsing = 1;
1371 if (startcode >= 0xa0 && startcode <= 0xbf) {
1374 /* for LPCM, we just skip the header and consider it is raw
1378 get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1379 b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1380 get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1382 freq = (b1 >> 4) & 3;
1383 st->codec.sample_rate = lpcm_freq_tab[freq];
1384 st->codec.channels = 1 + (b1 & 7);
1385 st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
1387 av_new_packet(pkt, len);
1388 get_buffer(&s->pb, pkt->data, pkt->size);
1391 pkt->stream_index = st->index;
1393 printf("%d: pts=%0.3f dts=%0.3f\n",
1394 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
1399 static int mpegps_read_close(AVFormatContext *s)
1404 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1405 int64_t *ppos, int64_t pos_limit)
1408 int64_t pos, pts, dts;
1412 printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1414 url_fseek(&s->pb, pos, SEEK_SET);
1416 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1419 printf("none (ret=%d)\n", len);
1421 return AV_NOPTS_VALUE;
1423 if (startcode == s->streams[stream_index]->id &&
1424 dts != AV_NOPTS_VALUE) {
1427 url_fskip(&s->pb, len);
1430 printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1433 return dts*AV_TIME_BASE/90000;
1436 #ifdef CONFIG_ENCODERS
1437 static AVOutputFormat mpeg1system_mux = {
1439 "MPEG1 System format",
1442 sizeof(MpegMuxContext),
1444 CODEC_ID_MPEG1VIDEO,
1446 mpeg_mux_write_packet,
1450 static AVOutputFormat mpeg1vcd_mux = {
1452 "MPEG1 System format (VCD)",
1455 sizeof(MpegMuxContext),
1457 CODEC_ID_MPEG1VIDEO,
1459 mpeg_mux_write_packet,
1463 static AVOutputFormat mpeg2vob_mux = {
1465 "MPEG2 PS format (VOB)",
1468 sizeof(MpegMuxContext),
1470 CODEC_ID_MPEG2VIDEO,
1472 mpeg_mux_write_packet,
1476 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1477 static AVOutputFormat mpeg2svcd_mux = {
1479 "MPEG2 PS format (VOB)",
1482 sizeof(MpegMuxContext),
1484 CODEC_ID_MPEG2VIDEO,
1486 mpeg_mux_write_packet,
1492 #endif //CONFIG_ENCODERS
1494 AVInputFormat mpegps_demux = {
1497 sizeof(MpegDemuxContext),
1502 NULL, //mpegps_read_seek,
1506 int mpegps_init(void)
1508 #ifdef CONFIG_ENCODERS
1509 av_register_output_format(&mpeg1system_mux);
1510 av_register_output_format(&mpeg1vcd_mux);
1511 av_register_output_format(&mpeg2vob_mux);
1512 av_register_output_format(&mpeg2svcd_mux);
1513 #endif //CONFIG_ENCODERS
1514 av_register_input_format(&mpegps_demux);