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 "libavutil/fifo.h"
23 #include "libavcodec/bitstream.h"
27 #define MAX_PAYLOAD_SIZE 4096
33 typedef struct PacketDesc {
39 struct PacketDesc *next;
45 int max_buffer_size; /* in bytes */
47 PacketDesc *predecode_packet;
48 PacketDesc *premux_packet;
49 PacketDesc **next_packet;
51 uint8_t lpcm_header[3];
55 int64_t vobu_start_pts;
59 int packet_size; /* required packet size */
61 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
62 int system_header_freq;
63 int system_header_size;
64 int mux_rate; /* bitrate in units of 50 bytes/s */
72 int64_t last_scr; /* current system clock */
74 double vcd_padding_bitrate; //FIXME floats
75 int64_t vcd_padding_bytes_written;
79 extern AVOutputFormat mpeg1vcd_muxer;
80 extern AVOutputFormat mpeg2dvd_muxer;
81 extern AVOutputFormat mpeg2svcd_muxer;
82 extern AVOutputFormat mpeg2vob_muxer;
84 static int put_pack_header(AVFormatContext *ctx,
85 uint8_t *buf, int64_t timestamp)
87 MpegMuxContext *s = ctx->priv_data;
90 init_put_bits(&pb, buf, 128);
92 put_bits(&pb, 32, PACK_START_CODE);
94 put_bits(&pb, 2, 0x1);
96 put_bits(&pb, 4, 0x2);
98 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
100 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
102 put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
105 /* clock extension */
109 put_bits(&pb, 22, s->mux_rate);
113 put_bits(&pb, 5, 0x1f); /* reserved */
114 put_bits(&pb, 3, 0); /* stuffing length */
117 return pbBufPtr(&pb) - pb.buf;
120 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
122 MpegMuxContext *s = ctx->priv_data;
123 int size, i, private_stream_coded, id;
126 init_put_bits(&pb, buf, 128);
128 put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
129 put_bits(&pb, 16, 0);
132 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
133 put_bits(&pb, 1, 1); /* marker */
134 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
135 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
138 put_bits(&pb, 6, s->audio_bound);
141 /* see VCD standard, p. IV-7*/
145 put_bits(&pb, 1, 0); /* variable bitrate*/
146 put_bits(&pb, 1, 0); /* non constrainted bit stream */
149 if (s->is_vcd || s->is_dvd) {
150 /* see VCD standard p IV-7 */
151 put_bits(&pb, 1, 1); /* audio locked */
152 put_bits(&pb, 1, 1); /* video locked */
154 put_bits(&pb, 1, 0); /* audio locked */
155 put_bits(&pb, 1, 0); /* video locked */
158 put_bits(&pb, 1, 1); /* marker */
160 if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
161 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
164 put_bits(&pb, 5, s->video_bound);
167 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
168 put_bits(&pb, 7, 0x7f); /* reserved byte */
170 put_bits(&pb, 8, 0xff); /* reserved byte */
172 /* DVD-Video Stream_bound entries
173 id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
174 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)
175 id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
176 id (0xBF) private stream 2, NAV packs, set to 2x1024. */
179 int P_STD_max_video = 0;
180 int P_STD_max_mpeg_audio = 0;
181 int P_STD_max_mpeg_PS1 = 0;
183 for(i=0;i<ctx->nb_streams;i++) {
184 StreamInfo *stream = ctx->streams[i]->priv_data;
187 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
188 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
189 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
190 P_STD_max_mpeg_audio = stream->max_buffer_size;
191 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
192 P_STD_max_video = stream->max_buffer_size;
197 put_bits(&pb, 8, 0xb9); /* stream ID */
200 put_bits(&pb, 13, P_STD_max_video / 1024);
203 if (P_STD_max_mpeg_audio == 0)
204 P_STD_max_mpeg_audio = 4096;
205 put_bits(&pb, 8, 0xb8); /* stream ID */
208 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
210 /* private stream 1 */
211 put_bits(&pb, 8, 0xbd); /* stream ID */
214 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
216 /* private stream 2 */
217 put_bits(&pb, 8, 0xbf); /* stream ID */
220 put_bits(&pb, 13, 2);
223 /* audio stream info */
224 private_stream_coded = 0;
225 for(i=0;i<ctx->nb_streams;i++) {
226 StreamInfo *stream = ctx->streams[i]->priv_data;
229 /* For VCDs, only include the stream info for the stream
230 that the pack which contains this system belongs to.
231 (see VCD standard p. IV-7) */
232 if ( !s->is_vcd || stream->id==only_for_stream_id
233 || only_for_stream_id==0) {
237 /* special case for private streams (AC-3 uses that) */
238 if (private_stream_coded)
240 private_stream_coded = 1;
243 put_bits(&pb, 8, id); /* stream ID */
248 put_bits(&pb, 13, stream->max_buffer_size / 128);
252 put_bits(&pb, 13, stream->max_buffer_size / 1024);
259 size = pbBufPtr(&pb) - pb.buf;
260 /* patch packet size */
261 buf[4] = (size - 6) >> 8;
262 buf[5] = (size - 6) & 0xff;
267 static int get_system_header_size(AVFormatContext *ctx)
269 int buf_index, i, private_stream_coded;
271 MpegMuxContext *s = ctx->priv_data;
274 return 18; // DVD-Video system headers are 18 bytes fixed length.
277 private_stream_coded = 0;
278 for(i=0;i<ctx->nb_streams;i++) {
279 stream = ctx->streams[i]->priv_data;
280 if (stream->id < 0xc0) {
281 if (private_stream_coded)
283 private_stream_coded = 1;
290 static int mpeg_mux_init(AVFormatContext *ctx)
292 MpegMuxContext *s = ctx->priv_data;
293 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
299 s->packet_number = 0;
300 s->is_vcd = (ENABLE_MPEG1VCD_MUXER && ctx->oformat == &mpeg1vcd_muxer);
301 s->is_svcd = (ENABLE_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer);
302 s->is_mpeg2 = ((ENABLE_MPEG2VOB_MUXER && ctx->oformat == &mpeg2vob_muxer) ||
303 (ENABLE_MPEG2DVD_MUXER && ctx->oformat == &mpeg2dvd_muxer) ||
304 (ENABLE_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer));
305 s->is_dvd = (ENABLE_MPEG2DVD_MUXER && ctx->oformat == &mpeg2dvd_muxer);
308 s->packet_size = ctx->packet_size;
310 s->packet_size = 2048;
312 s->vcd_padding_bytes_written = 0;
313 s->vcd_padding_bitrate=0;
323 for(i=0;i<ctx->nb_streams;i++) {
324 st = ctx->streams[i];
325 stream = av_mallocz(sizeof(StreamInfo));
328 st->priv_data = stream;
330 av_set_pts_info(st, 64, 1, 90000);
332 switch(st->codec->codec_type) {
333 case CODEC_TYPE_AUDIO:
334 if (st->codec->codec_id == CODEC_ID_AC3) {
335 stream->id = ac3_id++;
336 } else if (st->codec->codec_id == CODEC_ID_DTS) {
337 stream->id = dts_id++;
338 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
339 stream->id = lpcm_id++;
340 for(j = 0; j < 4; j++) {
341 if (lpcm_freq_tab[j] == st->codec->sample_rate)
346 if (st->codec->channels > 8)
348 stream->lpcm_header[0] = 0x0c;
349 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
350 stream->lpcm_header[2] = 0x80;
351 stream->lpcm_align = st->codec->channels * 2;
353 stream->id = mpa_id++;
356 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
357 Right now it is also used for everything else.*/
358 stream->max_buffer_size = 4 * 1024;
361 case CODEC_TYPE_VIDEO:
362 stream->id = mpv_id++;
363 if (st->codec->rc_buffer_size)
364 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
366 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
368 /* see VCD standard, p. IV-7*/
369 stream->max_buffer_size = 46 * 1024;
371 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
372 Right now it is also used for everything else.*/
373 stream->max_buffer_size = 230 * 1024;
377 case CODEC_TYPE_SUBTITLE:
378 stream->id = mps_id++;
379 stream->max_buffer_size = 16 * 1024;
384 av_fifo_init(&stream->fifo, 16);
389 for(i=0;i<ctx->nb_streams;i++) {
391 st = ctx->streams[i];
392 stream = (StreamInfo*) st->priv_data;
394 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
395 codec_rate= st->codec->rc_max_rate;
397 codec_rate= st->codec->bit_rate;
400 codec_rate= (1<<21)*8*50/ctx->nb_streams;
402 bitrate += codec_rate;
404 if (stream->id==AUDIO_ID)
405 audio_bitrate += codec_rate;
406 else if (stream->id==VIDEO_ID)
407 video_bitrate += codec_rate;
411 s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
413 /* we increase slightly the bitrate to take into account the
414 headers. XXX: compute it exactly */
415 bitrate += bitrate*5/100;
417 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
421 double overhead_rate;
423 /* The VCD standard mandates that the mux_rate field is 3528
424 (see standard p. IV-6).
425 The value is actually "wrong", i.e. if you calculate
426 it using the normal formula and the 75 sectors per second transfer
427 rate you get a different value because the real pack size is 2324,
428 not 2352. But the standard explicitly specifies that the mux_rate
429 field in the header must have this value.*/
430 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
432 /* The VCD standard states that the muxed stream must be
433 exactly 75 packs / second (the data rate of a single speed cdrom).
434 Since the video bitrate (probably 1150000 bits/sec) will be below
435 the theoretical maximum we have to add some padding packets
436 to make up for the lower data rate.
437 (cf. VCD standard p. IV-6 )*/
439 /* Add the header overhead to the data rate.
440 2279 data bytes per audio pack, 2294 data bytes per video pack*/
441 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
442 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
445 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
446 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
449 if (s->is_vcd || s->is_mpeg2)
451 s->pack_header_freq = 1;
453 /* every 2 seconds */
454 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
456 /* the above seems to make pack_header_freq zero sometimes */
457 if (s->pack_header_freq == 0)
458 s->pack_header_freq = 1;
461 /* every 200 packets. Need to look at the spec. */
462 s->system_header_freq = s->pack_header_freq * 40;
464 /* the standard mandates that there are only two system headers
465 in the whole file: one in the first packet of each stream.
466 (see standard p. IV-7 and IV-8) */
467 s->system_header_freq = 0x7fffffff;
469 s->system_header_freq = s->pack_header_freq * 5;
471 for(i=0;i<ctx->nb_streams;i++) {
472 stream = ctx->streams[i]->priv_data;
473 stream->packet_number = 0;
475 s->system_header_size = get_system_header_size(ctx);
479 for(i=0;i<ctx->nb_streams;i++) {
480 av_free(ctx->streams[i]->priv_data);
482 return AVERROR(ENOMEM);
485 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
489 (((timestamp >> 30) & 0x07) << 1) |
491 put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
492 put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
496 /* return the number of padding bytes that should be inserted into
497 the multiplexed stream.*/
498 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
500 MpegMuxContext *s = ctx->priv_data;
503 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
505 int64_t full_pad_bytes;
507 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
508 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
511 /* might happen if we have already padded to a later timestamp. This
512 can occur if another stream has already advanced further.*/
520 #if 0 /* unused, remove? */
521 /* return the exact available payload size for the next packet for
522 stream 'stream_index'. 'pts' and 'dts' are only used to know if
523 timestamps are needed in the packet header. */
524 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
525 int64_t pts, int64_t dts)
527 MpegMuxContext *s = ctx->priv_data;
531 stream = ctx->streams[stream_index]->priv_data;
534 if (((s->packet_number % s->pack_header_freq) == 0)) {
535 /* pack header size */
542 /* there is exactly one system header for each stream in a VCD MPEG,
543 One in the very first video packet and one in the very first
544 audio packet (see VCD standard p. IV-7 and IV-8).*/
546 if (stream->packet_number==0)
547 /* The system headers refer only to the stream they occur in,
548 so they have a constant size.*/
552 if ((s->packet_number % s->system_header_freq) == 0)
553 buf_index += s->system_header_size;
557 if ((s->is_vcd && stream->packet_number==0)
558 || (s->is_svcd && s->packet_number==0))
559 /* the first pack of each stream contains only the pack header,
560 the system header and some padding (see VCD standard p. IV-6)
561 Add the padding size, so that the actual payload becomes 0.*/
562 buf_index += s->packet_size - buf_index;
564 /* packet header size */
568 if (stream->packet_number==0)
569 buf_index += 3; /* PES extension */
570 buf_index += 1; /* obligatory stuffing byte */
572 if (pts != AV_NOPTS_VALUE) {
583 if (stream->id < 0xc0) {
584 /* AC-3/LPCM private data header */
586 if (stream->id >= 0xa0) {
589 /* NOTE: we round the payload size to an integer number of
591 n = (s->packet_size - buf_index) % stream->lpcm_align;
593 buf_index += (stream->lpcm_align - n);
597 if (s->is_vcd && stream->id == AUDIO_ID)
598 /* The VCD standard demands that 20 zero bytes follow
599 each audio packet (see standard p. IV-8).*/
602 return s->packet_size - buf_index;
606 /* Write an MPEG padding packet header. */
607 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
609 MpegMuxContext *s = ctx->priv_data;
612 put_be32(pb, PADDING_STREAM);
613 put_be16(pb, packet_bytes - 6);
620 for(i=0;i<packet_bytes;i++)
624 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
626 PacketDesc *pkt_desc= stream->premux_packet;
629 if(pkt_desc->size == pkt_desc->unwritten_size)
631 len -= pkt_desc->unwritten_size;
632 pkt_desc= pkt_desc->next;
638 /* flush the packet on stream stream_index */
639 static int flush_packet(AVFormatContext *ctx, int stream_index,
640 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
642 MpegMuxContext *s = ctx->priv_data;
643 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
645 int size, payload_size, startcode, id, stuffing_size, i, header_len;
648 int zero_trail_bytes = 0;
649 int pad_packet_bytes = 0;
651 int general_pack = 0; /*"general" pack without data specific to one stream?*/
657 printf("packet ID=%2x PTS=%0.3f\n",
663 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
664 /* output pack and systems header if needed */
665 size = put_pack_header(ctx, buf_ptr, scr);
670 /* there is exactly one system header for each stream in a VCD MPEG,
671 One in the very first video packet and one in the very first
672 audio packet (see VCD standard p. IV-7 and IV-8).*/
674 if (stream->packet_number==0) {
675 size = put_system_header(ctx, buf_ptr, id);
678 } else if (s->is_dvd) {
679 if (stream->align_iframe || s->packet_number == 0){
680 int PES_bytes_to_fill = s->packet_size - size - 10;
682 if (pts != AV_NOPTS_VALUE) {
684 PES_bytes_to_fill -= 5 + 5;
686 PES_bytes_to_fill -= 5;
689 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
690 size = put_system_header(ctx, buf_ptr, 0);
692 size = buf_ptr - buffer;
693 put_buffer(ctx->pb, buffer, size);
695 put_be32(ctx->pb, PRIVATE_STREAM_2);
696 put_be16(ctx->pb, 0x03d4); // length
697 put_byte(ctx->pb, 0x00); // substream ID, 00=PCI
698 for (i = 0; i < 979; i++)
699 put_byte(ctx->pb, 0x00);
701 put_be32(ctx->pb, PRIVATE_STREAM_2);
702 put_be16(ctx->pb, 0x03fa); // length
703 put_byte(ctx->pb, 0x01); // substream ID, 01=DSI
704 for (i = 0; i < 1017; i++)
705 put_byte(ctx->pb, 0x00);
707 memset(buffer, 0, 128);
710 stream->align_iframe = 0;
711 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
712 size = put_pack_header(ctx, buf_ptr, scr);
716 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
717 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
721 if ((s->packet_number % s->system_header_freq) == 0) {
722 size = put_system_header(ctx, buf_ptr, 0);
727 size = buf_ptr - buffer;
728 put_buffer(ctx->pb, buffer, size);
730 packet_size = s->packet_size - size;
732 if (s->is_vcd && id == AUDIO_ID)
733 /* The VCD standard demands that 20 zero bytes follow
734 each audio pack (see standard p. IV-8).*/
735 zero_trail_bytes += 20;
737 if ((s->is_vcd && stream->packet_number==0)
738 || (s->is_svcd && s->packet_number==0)) {
739 /* for VCD the first pack of each stream contains only the pack header,
740 the system header and lots of padding (see VCD standard p. IV-6).
741 In the case of an audio pack, 20 zero bytes are also added at
743 /* For SVCD we fill the very first pack to increase compatibility with
744 some DVD players. Not mandated by the standard.*/
746 general_pack = 1; /* the system header refers to both streams and no stream data*/
747 pad_packet_bytes = packet_size - zero_trail_bytes;
750 packet_size -= pad_packet_bytes + zero_trail_bytes;
752 if (packet_size > 0) {
754 /* packet header size */
760 if (stream->packet_number==0)
761 header_len += 3; /* PES extension */
762 header_len += 1; /* obligatory stuffing byte */
766 if (pts != AV_NOPTS_VALUE) {
776 payload_size = packet_size - header_len;
778 startcode = PRIVATE_STREAM_1;
786 startcode = 0x100 + id;
789 stuffing_size = payload_size - av_fifo_size(&stream->fifo);
791 // first byte does not fit -> reset pts/dts + stuffing
792 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
796 if(pts != AV_NOPTS_VALUE)
797 timestamp_len += s->is_mpeg2 ? 5 : 4;
798 pts=dts= AV_NOPTS_VALUE;
799 header_len -= timestamp_len;
800 if (s->is_dvd && stream->align_iframe) {
801 pad_packet_bytes += timestamp_len;
802 packet_size -= timestamp_len;
804 payload_size += timestamp_len;
806 stuffing_size += timestamp_len;
807 if(payload_size > trailer_size)
808 stuffing_size += payload_size - trailer_size;
811 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
812 packet_size += pad_packet_bytes;
813 payload_size += pad_packet_bytes; // undo the previous adjustment
814 if (stuffing_size < 0) {
815 stuffing_size = pad_packet_bytes;
817 stuffing_size += pad_packet_bytes;
819 pad_packet_bytes = 0;
822 if (stuffing_size < 0)
824 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
825 pad_packet_bytes += stuffing_size;
826 packet_size -= stuffing_size;
827 payload_size -= stuffing_size;
831 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
833 put_be32(ctx->pb, startcode);
835 put_be16(ctx->pb, packet_size);
838 for(i=0;i<stuffing_size;i++)
839 put_byte(ctx->pb, 0xff);
842 put_byte(ctx->pb, 0x80); /* mpeg2 id */
846 if (pts != AV_NOPTS_VALUE) {
852 /* Both the MPEG-2 and the SVCD standards demand that the
853 P-STD_buffer_size field be included in the first packet of
854 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
855 and MPEG-2 standard 2.7.7) */
856 if (stream->packet_number == 0)
859 put_byte(ctx->pb, pes_flags); /* flags */
860 put_byte(ctx->pb, header_len - 3 + stuffing_size);
862 if (pes_flags & 0x80) /*write pts*/
863 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
864 if (pes_flags & 0x40) /*write dts*/
865 put_timestamp(ctx->pb, 0x01, dts);
867 if (pes_flags & 0x01) { /*write pes extension*/
868 put_byte(ctx->pb, 0x10); /* flags */
870 /* P-STD buffer info */
872 put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/128);
874 put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
878 if (pts != AV_NOPTS_VALUE) {
880 put_timestamp(ctx->pb, 0x03, pts);
881 put_timestamp(ctx->pb, 0x01, dts);
883 put_timestamp(ctx->pb, 0x02, pts);
886 put_byte(ctx->pb, 0x0f);
891 /* special stuffing byte that is always written
892 to prevent accidental generation of start codes. */
893 put_byte(ctx->pb, 0xff);
895 for(i=0;i<stuffing_size;i++)
896 put_byte(ctx->pb, 0xff);
899 if (startcode == PRIVATE_STREAM_1) {
900 put_byte(ctx->pb, id);
902 /* LPCM (XXX: check nb_frames) */
903 put_byte(ctx->pb, 7);
904 put_be16(ctx->pb, 4); /* skip 3 header bytes */
905 put_byte(ctx->pb, stream->lpcm_header[0]);
906 put_byte(ctx->pb, stream->lpcm_header[1]);
907 put_byte(ctx->pb, stream->lpcm_header[2]);
908 } else if (id >= 0x40) {
910 put_byte(ctx->pb, nb_frames);
911 put_be16(ctx->pb, trailer_size+1);
916 assert(payload_size - stuffing_size <= av_fifo_size(&stream->fifo));
917 av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, ctx->pb);
918 stream->bytes_to_iframe -= payload_size - stuffing_size;
924 if (pad_packet_bytes > 0)
925 put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
927 for(i=0;i<zero_trail_bytes;i++)
928 put_byte(ctx->pb, 0x00);
930 put_flush_packet(ctx->pb);
934 /* only increase the stream packet number if this pack actually contains
935 something that is specific to this stream! I.e. a dedicated header
938 stream->packet_number++;
940 return payload_size - stuffing_size;
943 static void put_vcd_padding_sector(AVFormatContext *ctx)
945 /* There are two ways to do this padding: writing a sector/pack
946 of 0 values, or writing an MPEG padding pack. Both seem to
947 work with most decoders, BUT the VCD standard only allows a 0-sector
948 (see standard p. IV-4, IV-5).
949 So a 0-sector it is...*/
951 MpegMuxContext *s = ctx->priv_data;
954 for(i=0;i<s->packet_size;i++)
955 put_byte(ctx->pb, 0);
957 s->vcd_padding_bytes_written += s->packet_size;
959 put_flush_packet(ctx->pb);
961 /* increasing the packet number is correct. The SCR of the following packs
962 is calculated from the packet_number and it has to include the padding
963 sector (it represents the sector index, not the MPEG pack index)
964 (see VCD standard p. IV-6)*/
968 #if 0 /* unused, remove? */
969 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
971 MpegMuxContext *s = ctx->priv_data;
974 /* Since the data delivery rate is constant, SCR is computed
975 using the formula C + i * 1200 where C is the start constant
976 and i is the pack index.
977 It is recommended that SCR 0 is at the beginning of the VCD front
978 margin (a sequence of empty Form 2 sectors on the CD).
979 It is recommended that the front margin is 30 sectors long, so
980 we use C = 30*1200 = 36000
981 (Note that even if the front margin is not 30 sectors the file
982 will still be correct according to the standard. It just won't have
983 the "recommended" value).*/
984 scr = 36000 + s->packet_number * 1200;
990 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
991 // MpegMuxContext *s = ctx->priv_data;
994 for(i=0; i<ctx->nb_streams; i++){
995 AVStream *st = ctx->streams[i];
996 StreamInfo *stream = st->priv_data;
997 PacketDesc *pkt_desc;
999 while((pkt_desc= stream->predecode_packet)
1000 && scr > pkt_desc->dts){ //FIXME > vs >=
1001 if(stream->buffer_index < pkt_desc->size ||
1002 stream->predecode_packet == stream->premux_packet){
1003 av_log(ctx, AV_LOG_ERROR,
1004 "buffer underflow i=%d bufi=%d size=%d\n",
1005 i, stream->buffer_index, pkt_desc->size);
1008 stream->buffer_index -= pkt_desc->size;
1010 stream->predecode_packet= pkt_desc->next;
1011 av_freep(&pkt_desc);
1018 static int output_packet(AVFormatContext *ctx, int flush){
1019 MpegMuxContext *s = ctx->priv_data;
1022 int i, avail_space=0, es_size, trailer_size;
1024 int best_score= INT_MIN;
1025 int ignore_constraints=0;
1026 int64_t scr= s->last_scr;
1027 PacketDesc *timestamp_packet;
1028 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1031 for(i=0; i<ctx->nb_streams; i++){
1032 AVStream *st = ctx->streams[i];
1033 StreamInfo *stream = st->priv_data;
1034 const int avail_data= av_fifo_size(&stream->fifo);
1035 const int space= stream->max_buffer_size - stream->buffer_index;
1036 int rel_space= 1024*space / stream->max_buffer_size;
1037 PacketDesc *next_pkt= stream->premux_packet;
1039 /* for subtitle, a single PES packet must be generated,
1040 so we flush after every single subtitle packet */
1041 if(s->packet_size > avail_data && !flush
1042 && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1046 assert(avail_data>0);
1048 if(space < s->packet_size && !ignore_constraints)
1051 if(next_pkt && next_pkt->dts - scr > max_delay)
1054 if(rel_space > best_score){
1055 best_score= rel_space;
1062 int64_t best_dts= INT64_MAX;
1064 for(i=0; i<ctx->nb_streams; i++){
1065 AVStream *st = ctx->streams[i];
1066 StreamInfo *stream = st->priv_data;
1067 PacketDesc *pkt_desc= stream->predecode_packet;
1068 if(pkt_desc && pkt_desc->dts < best_dts)
1069 best_dts= pkt_desc->dts;
1073 av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1074 scr/90000.0, best_dts/90000.0);
1076 if(best_dts == INT64_MAX)
1079 if(scr >= best_dts+1 && !ignore_constraints){
1080 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1081 ignore_constraints= 1;
1083 scr= FFMAX(best_dts+1, scr);
1084 if(remove_decoded_packets(ctx, scr) < 0)
1089 assert(best_i >= 0);
1091 st = ctx->streams[best_i];
1092 stream = st->priv_data;
1094 assert(av_fifo_size(&stream->fifo) > 0);
1096 assert(avail_space >= s->packet_size || ignore_constraints);
1098 timestamp_packet= stream->premux_packet;
1099 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1102 trailer_size= timestamp_packet->unwritten_size;
1103 timestamp_packet= timestamp_packet->next;
1106 if(timestamp_packet){
1107 //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);
1108 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1110 assert(av_fifo_size(&stream->fifo) == trailer_size);
1111 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1115 /* Write one or more padding sectors, if necessary, to reach
1116 the constant overall bitrate.*/
1119 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1120 put_vcd_padding_sector(ctx);
1121 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1125 stream->buffer_index += es_size;
1126 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1128 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1129 es_size -= stream->premux_packet->unwritten_size;
1130 stream->premux_packet= stream->premux_packet->next;
1133 stream->premux_packet->unwritten_size -= es_size;
1135 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1141 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1143 MpegMuxContext *s = ctx->priv_data;
1144 int stream_index= pkt->stream_index;
1145 int size= pkt->size;
1146 uint8_t *buf= pkt->data;
1147 AVStream *st = ctx->streams[stream_index];
1148 StreamInfo *stream = st->priv_data;
1150 PacketDesc *pkt_desc;
1151 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1152 const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1157 if(pts != AV_NOPTS_VALUE) pts += preload;
1158 if(dts != AV_NOPTS_VALUE) dts += preload;
1160 //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);
1161 if (!stream->premux_packet)
1162 stream->next_packet = &stream->premux_packet;
1163 *stream->next_packet=
1164 pkt_desc= av_mallocz(sizeof(PacketDesc));
1167 pkt_desc->unwritten_size=
1168 pkt_desc->size= size;
1169 if(!stream->predecode_packet)
1170 stream->predecode_packet= pkt_desc;
1171 stream->next_packet= &pkt_desc->next;
1173 if (av_fifo_realloc2(&stream->fifo, av_fifo_size(&stream->fifo) + size) < 0)
1177 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1178 stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1179 stream->align_iframe = 1;
1180 stream->vobu_start_pts = pts;
1184 av_fifo_generic_write(&stream->fifo, buf, size, NULL);
1187 int ret= output_packet(ctx, 0);
1193 static int mpeg_mux_end(AVFormatContext *ctx)
1195 // MpegMuxContext *s = ctx->priv_data;
1200 int ret= output_packet(ctx, 1);
1207 /* End header according to MPEG1 systems standard. We do not write
1208 it as it is usually not needed by decoders and because it
1209 complicates MPEG stream concatenation. */
1210 //put_be32(ctx->pb, ISO_11172_END_CODE);
1211 //put_flush_packet(ctx->pb);
1213 for(i=0;i<ctx->nb_streams;i++) {
1214 stream = ctx->streams[i]->priv_data;
1216 assert(av_fifo_size(&stream->fifo) == 0);
1217 av_fifo_free(&stream->fifo);
1222 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1223 AVOutputFormat mpeg1system_muxer = {
1225 NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1228 sizeof(MpegMuxContext),
1230 CODEC_ID_MPEG1VIDEO,
1232 mpeg_mux_write_packet,
1236 #ifdef CONFIG_MPEG1VCD_MUXER
1237 AVOutputFormat mpeg1vcd_muxer = {
1239 NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1242 sizeof(MpegMuxContext),
1244 CODEC_ID_MPEG1VIDEO,
1246 mpeg_mux_write_packet,
1250 #ifdef CONFIG_MPEG2VOB_MUXER
1251 AVOutputFormat mpeg2vob_muxer = {
1253 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1256 sizeof(MpegMuxContext),
1258 CODEC_ID_MPEG2VIDEO,
1260 mpeg_mux_write_packet,
1265 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1266 #ifdef CONFIG_MPEG2SVCD_MUXER
1267 AVOutputFormat mpeg2svcd_muxer = {
1269 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1272 sizeof(MpegMuxContext),
1274 CODEC_ID_MPEG2VIDEO,
1276 mpeg_mux_write_packet,
1281 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1282 #ifdef CONFIG_MPEG2DVD_MUXER
1283 AVOutputFormat mpeg2dvd_muxer = {
1285 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1288 sizeof(MpegMuxContext),
1290 CODEC_ID_MPEG2VIDEO,
1292 mpeg_mux_write_packet,