3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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/put_bits.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 ff_mpeg1vcd_muxer;
80 extern AVOutputFormat ff_mpeg2dvd_muxer;
81 extern AVOutputFormat ff_mpeg2svcd_muxer;
82 extern AVOutputFormat ff_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_bits32(&pb, 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 put_bits_ptr(&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_bits32(&pb, 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 & 0xe0) == 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 = put_bits_ptr(&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 = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
301 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
302 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
303 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
304 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
305 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
307 if(ctx->packet_size) {
308 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
309 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
313 s->packet_size = ctx->packet_size;
315 s->packet_size = 2048;
317 s->vcd_padding_bytes_written = 0;
318 s->vcd_padding_bitrate=0;
328 for(i=0;i<ctx->nb_streams;i++) {
329 st = ctx->streams[i];
330 stream = av_mallocz(sizeof(StreamInfo));
333 st->priv_data = stream;
335 av_set_pts_info(st, 64, 1, 90000);
337 switch(st->codec->codec_type) {
338 case AVMEDIA_TYPE_AUDIO:
339 if (st->codec->codec_id == CODEC_ID_AC3) {
340 stream->id = ac3_id++;
341 } else if (st->codec->codec_id == CODEC_ID_DTS) {
342 stream->id = dts_id++;
343 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
344 stream->id = lpcm_id++;
345 for(j = 0; j < 4; j++) {
346 if (lpcm_freq_tab[j] == st->codec->sample_rate)
351 if (st->codec->channels > 8)
353 stream->lpcm_header[0] = 0x0c;
354 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
355 stream->lpcm_header[2] = 0x80;
356 stream->lpcm_align = st->codec->channels * 2;
358 stream->id = mpa_id++;
361 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
362 Right now it is also used for everything else.*/
363 stream->max_buffer_size = 4 * 1024;
366 case AVMEDIA_TYPE_VIDEO:
367 stream->id = mpv_id++;
368 if (st->codec->rc_buffer_size)
369 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
371 av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, muxing may fail\n");
372 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
375 /* see VCD standard, p. IV-7*/
376 stream->max_buffer_size = 46 * 1024;
378 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
379 Right now it is also used for everything else.*/
380 stream->max_buffer_size = 230 * 1024;
384 case AVMEDIA_TYPE_SUBTITLE:
385 stream->id = mps_id++;
386 stream->max_buffer_size = 16 * 1024;
391 stream->fifo= av_fifo_alloc(16);
398 for(i=0;i<ctx->nb_streams;i++) {
400 st = ctx->streams[i];
401 stream = (StreamInfo*) st->priv_data;
403 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
404 codec_rate= st->codec->rc_max_rate;
406 codec_rate= st->codec->bit_rate;
409 codec_rate= (1<<21)*8*50/ctx->nb_streams;
411 bitrate += codec_rate;
413 if ((stream->id & 0xe0) == AUDIO_ID)
414 audio_bitrate += codec_rate;
415 else if (stream->id==VIDEO_ID)
416 video_bitrate += codec_rate;
420 s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
422 /* we increase slightly the bitrate to take into account the
423 headers. XXX: compute it exactly */
424 bitrate += bitrate*5/100;
426 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
430 double overhead_rate;
432 /* The VCD standard mandates that the mux_rate field is 3528
433 (see standard p. IV-6).
434 The value is actually "wrong", i.e. if you calculate
435 it using the normal formula and the 75 sectors per second transfer
436 rate you get a different value because the real pack size is 2324,
437 not 2352. But the standard explicitly specifies that the mux_rate
438 field in the header must have this value.*/
439 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
441 /* The VCD standard states that the muxed stream must be
442 exactly 75 packs / second (the data rate of a single speed cdrom).
443 Since the video bitrate (probably 1150000 bits/sec) will be below
444 the theoretical maximum we have to add some padding packets
445 to make up for the lower data rate.
446 (cf. VCD standard p. IV-6 )*/
448 /* Add the header overhead to the data rate.
449 2279 data bytes per audio pack, 2294 data bytes per video pack*/
450 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
451 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
454 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
455 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
458 if (s->is_vcd || s->is_mpeg2)
460 s->pack_header_freq = 1;
462 /* every 2 seconds */
463 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
465 /* the above seems to make pack_header_freq zero sometimes */
466 if (s->pack_header_freq == 0)
467 s->pack_header_freq = 1;
470 /* every 200 packets. Need to look at the spec. */
471 s->system_header_freq = s->pack_header_freq * 40;
473 /* the standard mandates that there are only two system headers
474 in the whole file: one in the first packet of each stream.
475 (see standard p. IV-7 and IV-8) */
476 s->system_header_freq = 0x7fffffff;
478 s->system_header_freq = s->pack_header_freq * 5;
480 for(i=0;i<ctx->nb_streams;i++) {
481 stream = ctx->streams[i]->priv_data;
482 stream->packet_number = 0;
484 s->system_header_size = get_system_header_size(ctx);
488 for(i=0;i<ctx->nb_streams;i++) {
489 av_free(ctx->streams[i]->priv_data);
491 return AVERROR(ENOMEM);
494 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
498 (((timestamp >> 30) & 0x07) << 1) |
500 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
501 avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
505 /* return the number of padding bytes that should be inserted into
506 the multiplexed stream.*/
507 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
509 MpegMuxContext *s = ctx->priv_data;
512 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
514 int64_t full_pad_bytes;
516 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
517 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
520 /* might happen if we have already padded to a later timestamp. This
521 can occur if another stream has already advanced further.*/
529 #if 0 /* unused, remove? */
530 /* return the exact available payload size for the next packet for
531 stream 'stream_index'. 'pts' and 'dts' are only used to know if
532 timestamps are needed in the packet header. */
533 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
534 int64_t pts, int64_t dts)
536 MpegMuxContext *s = ctx->priv_data;
540 stream = ctx->streams[stream_index]->priv_data;
543 if (((s->packet_number % s->pack_header_freq) == 0)) {
544 /* pack header size */
551 /* there is exactly one system header for each stream in a VCD MPEG,
552 One in the very first video packet and one in the very first
553 audio packet (see VCD standard p. IV-7 and IV-8).*/
555 if (stream->packet_number==0)
556 /* The system headers refer only to the stream they occur in,
557 so they have a constant size.*/
561 if ((s->packet_number % s->system_header_freq) == 0)
562 buf_index += s->system_header_size;
566 if ((s->is_vcd && stream->packet_number==0)
567 || (s->is_svcd && s->packet_number==0))
568 /* the first pack of each stream contains only the pack header,
569 the system header and some padding (see VCD standard p. IV-6)
570 Add the padding size, so that the actual payload becomes 0.*/
571 buf_index += s->packet_size - buf_index;
573 /* packet header size */
577 if (stream->packet_number==0)
578 buf_index += 3; /* PES extension */
579 buf_index += 1; /* obligatory stuffing byte */
581 if (pts != AV_NOPTS_VALUE) {
592 if (stream->id < 0xc0) {
593 /* AC-3/LPCM private data header */
595 if (stream->id >= 0xa0) {
598 /* NOTE: we round the payload size to an integer number of
600 n = (s->packet_size - buf_index) % stream->lpcm_align;
602 buf_index += (stream->lpcm_align - n);
606 if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID)
607 /* The VCD standard demands that 20 zero bytes follow
608 each audio packet (see standard p. IV-8).*/
611 return s->packet_size - buf_index;
615 /* Write an MPEG padding packet header. */
616 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
618 MpegMuxContext *s = ctx->priv_data;
621 avio_wb32(pb, PADDING_STREAM);
622 avio_wb16(pb, packet_bytes - 6);
629 for(i=0;i<packet_bytes;i++)
633 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
635 PacketDesc *pkt_desc= stream->premux_packet;
638 if(pkt_desc->size == pkt_desc->unwritten_size)
640 len -= pkt_desc->unwritten_size;
641 pkt_desc= pkt_desc->next;
647 /* flush the packet on stream stream_index */
648 static int flush_packet(AVFormatContext *ctx, int stream_index,
649 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
651 MpegMuxContext *s = ctx->priv_data;
652 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
654 int size, payload_size, startcode, id, stuffing_size, i, header_len;
657 int zero_trail_bytes = 0;
658 int pad_packet_bytes = 0;
660 int general_pack = 0; /*"general" pack without data specific to one stream?*/
665 av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
669 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
670 /* output pack and systems header if needed */
671 size = put_pack_header(ctx, buf_ptr, scr);
676 /* there is exactly one system header for each stream in a VCD MPEG,
677 One in the very first video packet and one in the very first
678 audio packet (see VCD standard p. IV-7 and IV-8).*/
680 if (stream->packet_number==0) {
681 size = put_system_header(ctx, buf_ptr, id);
684 } else if (s->is_dvd) {
685 if (stream->align_iframe || s->packet_number == 0){
686 int PES_bytes_to_fill = s->packet_size - size - 10;
688 if (pts != AV_NOPTS_VALUE) {
690 PES_bytes_to_fill -= 5 + 5;
692 PES_bytes_to_fill -= 5;
695 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
696 size = put_system_header(ctx, buf_ptr, 0);
698 size = buf_ptr - buffer;
699 avio_write(ctx->pb, buffer, size);
701 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
702 avio_wb16(ctx->pb, 0x03d4); // length
703 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
704 for (i = 0; i < 979; i++)
705 avio_w8(ctx->pb, 0x00);
707 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
708 avio_wb16(ctx->pb, 0x03fa); // length
709 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
710 for (i = 0; i < 1017; i++)
711 avio_w8(ctx->pb, 0x00);
713 memset(buffer, 0, 128);
716 stream->align_iframe = 0;
717 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
718 size = put_pack_header(ctx, buf_ptr, scr);
722 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
723 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
727 if ((s->packet_number % s->system_header_freq) == 0) {
728 size = put_system_header(ctx, buf_ptr, 0);
733 size = buf_ptr - buffer;
734 avio_write(ctx->pb, buffer, size);
736 packet_size = s->packet_size - size;
738 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
739 /* The VCD standard demands that 20 zero bytes follow
740 each audio pack (see standard p. IV-8).*/
741 zero_trail_bytes += 20;
743 if ((s->is_vcd && stream->packet_number==0)
744 || (s->is_svcd && s->packet_number==0)) {
745 /* for VCD the first pack of each stream contains only the pack header,
746 the system header and lots of padding (see VCD standard p. IV-6).
747 In the case of an audio pack, 20 zero bytes are also added at
749 /* For SVCD we fill the very first pack to increase compatibility with
750 some DVD players. Not mandated by the standard.*/
752 general_pack = 1; /* the system header refers to both streams and no stream data*/
753 pad_packet_bytes = packet_size - zero_trail_bytes;
756 packet_size -= pad_packet_bytes + zero_trail_bytes;
758 if (packet_size > 0) {
760 /* packet header size */
766 if (stream->packet_number==0)
767 header_len += 3; /* PES extension */
768 header_len += 1; /* obligatory stuffing byte */
772 if (pts != AV_NOPTS_VALUE) {
782 payload_size = packet_size - header_len;
784 startcode = PRIVATE_STREAM_1;
792 startcode = 0x100 + id;
795 stuffing_size = payload_size - av_fifo_size(stream->fifo);
797 // first byte does not fit -> reset pts/dts + stuffing
798 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
802 if(pts != AV_NOPTS_VALUE)
803 timestamp_len += s->is_mpeg2 ? 5 : 4;
804 pts=dts= AV_NOPTS_VALUE;
805 header_len -= timestamp_len;
806 if (s->is_dvd && stream->align_iframe) {
807 pad_packet_bytes += timestamp_len;
808 packet_size -= timestamp_len;
810 payload_size += timestamp_len;
812 stuffing_size += timestamp_len;
813 if(payload_size > trailer_size)
814 stuffing_size += payload_size - trailer_size;
817 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
818 packet_size += pad_packet_bytes;
819 payload_size += pad_packet_bytes; // undo the previous adjustment
820 if (stuffing_size < 0) {
821 stuffing_size = pad_packet_bytes;
823 stuffing_size += pad_packet_bytes;
825 pad_packet_bytes = 0;
828 if (stuffing_size < 0)
830 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
831 pad_packet_bytes += stuffing_size;
832 packet_size -= stuffing_size;
833 payload_size -= stuffing_size;
837 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
839 avio_wb32(ctx->pb, startcode);
841 avio_wb16(ctx->pb, packet_size);
844 for(i=0;i<stuffing_size;i++)
845 avio_w8(ctx->pb, 0xff);
848 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
852 if (pts != AV_NOPTS_VALUE) {
858 /* Both the MPEG-2 and the SVCD standards demand that the
859 P-STD_buffer_size field be included in the first packet of
860 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
861 and MPEG-2 standard 2.7.7) */
862 if (stream->packet_number == 0)
865 avio_w8(ctx->pb, pes_flags); /* flags */
866 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
868 if (pes_flags & 0x80) /*write pts*/
869 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
870 if (pes_flags & 0x40) /*write dts*/
871 put_timestamp(ctx->pb, 0x01, dts);
873 if (pes_flags & 0x01) { /*write pes extension*/
874 avio_w8(ctx->pb, 0x10); /* flags */
876 /* P-STD buffer info */
877 if ((id & 0xe0) == AUDIO_ID)
878 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
880 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
884 if (pts != AV_NOPTS_VALUE) {
886 put_timestamp(ctx->pb, 0x03, pts);
887 put_timestamp(ctx->pb, 0x01, dts);
889 put_timestamp(ctx->pb, 0x02, pts);
892 avio_w8(ctx->pb, 0x0f);
897 /* special stuffing byte that is always written
898 to prevent accidental generation of start codes. */
899 avio_w8(ctx->pb, 0xff);
901 for(i=0;i<stuffing_size;i++)
902 avio_w8(ctx->pb, 0xff);
905 if (startcode == PRIVATE_STREAM_1) {
906 avio_w8(ctx->pb, id);
908 /* LPCM (XXX: check nb_frames) */
910 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
911 avio_w8(ctx->pb, stream->lpcm_header[0]);
912 avio_w8(ctx->pb, stream->lpcm_header[1]);
913 avio_w8(ctx->pb, stream->lpcm_header[2]);
914 } else if (id >= 0x40) {
916 avio_w8(ctx->pb, nb_frames);
917 avio_wb16(ctx->pb, trailer_size+1);
922 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
923 av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &avio_write);
924 stream->bytes_to_iframe -= payload_size - stuffing_size;
930 if (pad_packet_bytes > 0)
931 put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
933 for(i=0;i<zero_trail_bytes;i++)
934 avio_w8(ctx->pb, 0x00);
940 /* only increase the stream packet number if this pack actually contains
941 something that is specific to this stream! I.e. a dedicated header
944 stream->packet_number++;
946 return payload_size - stuffing_size;
949 static void put_vcd_padding_sector(AVFormatContext *ctx)
951 /* There are two ways to do this padding: writing a sector/pack
952 of 0 values, or writing an MPEG padding pack. Both seem to
953 work with most decoders, BUT the VCD standard only allows a 0-sector
954 (see standard p. IV-4, IV-5).
955 So a 0-sector it is...*/
957 MpegMuxContext *s = ctx->priv_data;
960 for(i=0;i<s->packet_size;i++)
963 s->vcd_padding_bytes_written += s->packet_size;
967 /* increasing the packet number is correct. The SCR of the following packs
968 is calculated from the packet_number and it has to include the padding
969 sector (it represents the sector index, not the MPEG pack index)
970 (see VCD standard p. IV-6)*/
974 #if 0 /* unused, remove? */
975 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
977 MpegMuxContext *s = ctx->priv_data;
980 /* Since the data delivery rate is constant, SCR is computed
981 using the formula C + i * 1200 where C is the start constant
982 and i is the pack index.
983 It is recommended that SCR 0 is at the beginning of the VCD front
984 margin (a sequence of empty Form 2 sectors on the CD).
985 It is recommended that the front margin is 30 sectors long, so
986 we use C = 30*1200 = 36000
987 (Note that even if the front margin is not 30 sectors the file
988 will still be correct according to the standard. It just won't have
989 the "recommended" value).*/
990 scr = 36000 + s->packet_number * 1200;
996 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
997 // MpegMuxContext *s = ctx->priv_data;
1000 for(i=0; i<ctx->nb_streams; i++){
1001 AVStream *st = ctx->streams[i];
1002 StreamInfo *stream = st->priv_data;
1003 PacketDesc *pkt_desc;
1005 while((pkt_desc= stream->predecode_packet)
1006 && scr > pkt_desc->dts){ //FIXME > vs >=
1007 if(stream->buffer_index < pkt_desc->size ||
1008 stream->predecode_packet == stream->premux_packet){
1009 av_log(ctx, AV_LOG_ERROR,
1010 "buffer underflow i=%d bufi=%d size=%d\n",
1011 i, stream->buffer_index, pkt_desc->size);
1014 stream->buffer_index -= pkt_desc->size;
1016 stream->predecode_packet= pkt_desc->next;
1017 av_freep(&pkt_desc);
1024 static int output_packet(AVFormatContext *ctx, int flush){
1025 MpegMuxContext *s = ctx->priv_data;
1028 int i, avail_space=0, es_size, trailer_size;
1030 int best_score= INT_MIN;
1031 int ignore_constraints=0;
1032 int64_t scr= s->last_scr;
1033 PacketDesc *timestamp_packet;
1034 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1037 for(i=0; i<ctx->nb_streams; i++){
1038 AVStream *st = ctx->streams[i];
1039 StreamInfo *stream = st->priv_data;
1040 const int avail_data= av_fifo_size(stream->fifo);
1041 const int space= stream->max_buffer_size - stream->buffer_index;
1042 int rel_space= 1024*space / stream->max_buffer_size;
1043 PacketDesc *next_pkt= stream->premux_packet;
1045 /* for subtitle, a single PES packet must be generated,
1046 so we flush after every single subtitle packet */
1047 if(s->packet_size > avail_data && !flush
1048 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1052 assert(avail_data>0);
1054 if(space < s->packet_size && !ignore_constraints)
1057 if(next_pkt && next_pkt->dts - scr > max_delay)
1060 if(rel_space > best_score){
1061 best_score= rel_space;
1068 int64_t best_dts= INT64_MAX;
1070 for(i=0; i<ctx->nb_streams; i++){
1071 AVStream *st = ctx->streams[i];
1072 StreamInfo *stream = st->priv_data;
1073 PacketDesc *pkt_desc= stream->predecode_packet;
1074 if(pkt_desc && pkt_desc->dts < best_dts)
1075 best_dts= pkt_desc->dts;
1078 av_dlog(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1079 scr / 90000.0, best_dts / 90000.0);
1080 if(best_dts == INT64_MAX)
1083 if(scr >= best_dts+1 && !ignore_constraints){
1084 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1085 ignore_constraints= 1;
1087 scr= FFMAX(best_dts+1, scr);
1088 if(remove_decoded_packets(ctx, scr) < 0)
1093 assert(best_i >= 0);
1095 st = ctx->streams[best_i];
1096 stream = st->priv_data;
1098 assert(av_fifo_size(stream->fifo) > 0);
1100 assert(avail_space >= s->packet_size || ignore_constraints);
1102 timestamp_packet= stream->premux_packet;
1103 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1106 trailer_size= timestamp_packet->unwritten_size;
1107 timestamp_packet= timestamp_packet->next;
1110 if(timestamp_packet){
1111 //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);
1112 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1114 assert(av_fifo_size(stream->fifo) == trailer_size);
1115 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1119 /* Write one or more padding sectors, if necessary, to reach
1120 the constant overall bitrate.*/
1123 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1124 put_vcd_padding_sector(ctx);
1125 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1129 stream->buffer_index += es_size;
1130 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1132 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1133 es_size -= stream->premux_packet->unwritten_size;
1134 stream->premux_packet= stream->premux_packet->next;
1137 stream->premux_packet->unwritten_size -= es_size;
1139 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1145 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1147 MpegMuxContext *s = ctx->priv_data;
1148 int stream_index= pkt->stream_index;
1149 int size= pkt->size;
1150 uint8_t *buf= pkt->data;
1151 AVStream *st = ctx->streams[stream_index];
1152 StreamInfo *stream = st->priv_data;
1154 PacketDesc *pkt_desc;
1155 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1156 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1161 if(pts != AV_NOPTS_VALUE) pts += 2*preload;
1162 if(dts != AV_NOPTS_VALUE){
1164 s->last_scr= dts + preload;
1168 //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);
1169 if (!stream->premux_packet)
1170 stream->next_packet = &stream->premux_packet;
1171 *stream->next_packet=
1172 pkt_desc= av_mallocz(sizeof(PacketDesc));
1175 pkt_desc->unwritten_size=
1176 pkt_desc->size= size;
1177 if(!stream->predecode_packet)
1178 stream->predecode_packet= pkt_desc;
1179 stream->next_packet= &pkt_desc->next;
1181 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1185 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1186 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1187 stream->align_iframe = 1;
1188 stream->vobu_start_pts = pts;
1192 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1195 int ret= output_packet(ctx, 0);
1201 static int mpeg_mux_end(AVFormatContext *ctx)
1203 // MpegMuxContext *s = ctx->priv_data;
1208 int ret= output_packet(ctx, 1);
1215 /* End header according to MPEG1 systems standard. We do not write
1216 it as it is usually not needed by decoders and because it
1217 complicates MPEG stream concatenation. */
1218 //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1219 //avio_flush(ctx->pb);
1221 for(i=0;i<ctx->nb_streams;i++) {
1222 stream = ctx->streams[i]->priv_data;
1224 assert(av_fifo_size(stream->fifo) == 0);
1225 av_fifo_free(stream->fifo);
1230 #if CONFIG_MPEG1SYSTEM_MUXER
1231 AVOutputFormat ff_mpeg1system_muxer = {
1233 NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1236 sizeof(MpegMuxContext),
1238 CODEC_ID_MPEG1VIDEO,
1240 mpeg_mux_write_packet,
1244 #if CONFIG_MPEG1VCD_MUXER
1245 AVOutputFormat ff_mpeg1vcd_muxer = {
1247 NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1250 sizeof(MpegMuxContext),
1252 CODEC_ID_MPEG1VIDEO,
1254 mpeg_mux_write_packet,
1258 #if CONFIG_MPEG2VOB_MUXER
1259 AVOutputFormat ff_mpeg2vob_muxer = {
1261 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1264 sizeof(MpegMuxContext),
1266 CODEC_ID_MPEG2VIDEO,
1268 mpeg_mux_write_packet,
1273 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1274 #if CONFIG_MPEG2SVCD_MUXER
1275 AVOutputFormat ff_mpeg2svcd_muxer = {
1277 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1280 sizeof(MpegMuxContext),
1282 CODEC_ID_MPEG2VIDEO,
1284 mpeg_mux_write_packet,
1289 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1290 #if CONFIG_MPEG2DVD_MUXER
1291 AVOutputFormat ff_mpeg2dvd_muxer = {
1293 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1296 sizeof(MpegMuxContext),
1298 CODEC_ID_MPEG2VIDEO,
1300 mpeg_mux_write_packet,