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
24 #include "libavutil/attributes.h"
25 #include "libavutil/fifo.h"
26 #include "libavutil/log.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/opt.h"
30 #include "libavcodec/put_bits.h"
36 #define MAX_PAYLOAD_SIZE 4096
38 typedef struct PacketDesc {
43 struct PacketDesc *next;
46 typedef struct StreamInfo {
49 int max_buffer_size; /* in bytes */
51 PacketDesc *predecode_packet;
52 PacketDesc *premux_packet;
53 PacketDesc **next_packet;
55 uint8_t lpcm_header[3];
59 int64_t vobu_start_pts;
62 typedef struct MpegMuxContext {
64 int packet_size; /* required packet size */
66 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
67 int system_header_freq;
68 int system_header_size;
69 int user_mux_rate; /* bitrate in units of bits/s */
70 int mux_rate; /* bitrate in units of 50 bytes/s */
78 int64_t last_scr; /* current system clock */
80 int64_t vcd_padding_bitrate_num;
81 int64_t vcd_padding_bytes_written;
86 extern AVOutputFormat ff_mpeg1vcd_muxer;
87 extern AVOutputFormat ff_mpeg2dvd_muxer;
88 extern AVOutputFormat ff_mpeg2svcd_muxer;
89 extern AVOutputFormat ff_mpeg2vob_muxer;
91 static int put_pack_header(AVFormatContext *ctx, uint8_t *buf,
94 MpegMuxContext *s = ctx->priv_data;
97 init_put_bits(&pb, buf, 128);
99 put_bits32(&pb, PACK_START_CODE);
101 put_bits(&pb, 2, 0x1);
103 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 */
114 put_bits(&pb, 22, s->mux_rate);
118 put_bits(&pb, 5, 0x1f); /* reserved */
119 put_bits(&pb, 3, 0); /* stuffing length */
122 return put_bits_ptr(&pb) - pb.buf;
125 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,
126 int only_for_stream_id)
128 MpegMuxContext *s = ctx->priv_data;
129 int size, i, private_stream_coded, id;
132 init_put_bits(&pb, buf, 128);
134 put_bits32(&pb, SYSTEM_HEADER_START_CODE);
135 put_bits(&pb, 16, 0);
138 /* maximum bit rate of the multiplexed stream */
139 put_bits(&pb, 22, s->mux_rate);
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
143 * (see VCD standard p. IV-7) */
146 put_bits(&pb, 6, s->audio_bound);
149 /* see VCD standard, p. IV-7 */
153 put_bits(&pb, 1, 0); /* variable bitrate */
154 put_bits(&pb, 1, 0); /* nonconstrained bitstream */
157 if (s->is_vcd || s->is_dvd) {
158 /* see VCD standard p IV-7 */
159 put_bits(&pb, 1, 1); /* audio locked */
160 put_bits(&pb, 1, 1); /* video locked */
162 put_bits(&pb, 1, 0); /* audio locked */
163 put_bits(&pb, 1, 0); /* video locked */
166 put_bits(&pb, 1, 1); /* marker */
168 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
169 /* This header applies only to the audio stream
170 * (see VCD standard p. IV-7) */
173 put_bits(&pb, 5, s->video_bound);
176 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
177 put_bits(&pb, 7, 0x7f); /* reserved byte */
179 put_bits(&pb, 8, 0xff); /* reserved byte */
181 /* DVD-Video Stream_bound entries
182 * id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
183 * 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)
184 * id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
185 * id (0xBF) private stream 2, NAV packs, set to 2x1024. */
188 int P_STD_max_video = 0;
189 int P_STD_max_mpeg_audio = 0;
190 int P_STD_max_mpeg_PS1 = 0;
192 for (i = 0; i < ctx->nb_streams; i++) {
193 StreamInfo *stream = ctx->streams[i]->priv_data;
196 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
197 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
198 } else if (id >= 0xc0 && id <= 0xc7 &&
199 stream->max_buffer_size > P_STD_max_mpeg_audio) {
200 P_STD_max_mpeg_audio = stream->max_buffer_size;
201 } else if (id == 0xe0 &&
202 stream->max_buffer_size > P_STD_max_video) {
203 P_STD_max_video = stream->max_buffer_size;
208 put_bits(&pb, 8, 0xb9); /* stream ID */
211 put_bits(&pb, 13, P_STD_max_video / 1024);
214 if (P_STD_max_mpeg_audio == 0)
215 P_STD_max_mpeg_audio = 4096;
216 put_bits(&pb, 8, 0xb8); /* stream ID */
219 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
221 /* private stream 1 */
222 put_bits(&pb, 8, 0xbd); /* stream ID */
225 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
227 /* private stream 2 */
228 put_bits(&pb, 8, 0xbf); /* stream ID */
231 put_bits(&pb, 13, 2);
233 /* audio stream info */
234 private_stream_coded = 0;
235 for (i = 0; i < ctx->nb_streams; i++) {
236 StreamInfo *stream = ctx->streams[i]->priv_data;
238 /* For VCDs, only include the stream info for the stream
239 * that the pack which contains this system belongs to.
240 * (see VCD standard p. IV-7) */
241 if (!s->is_vcd || stream->id == only_for_stream_id ||
242 only_for_stream_id == 0) {
245 /* special case for private streams (AC-3 uses that) */
246 if (private_stream_coded)
248 private_stream_coded = 1;
251 put_bits(&pb, 8, id); /* stream ID */
256 put_bits(&pb, 13, stream->max_buffer_size / 128);
260 put_bits(&pb, 13, stream->max_buffer_size / 1024);
267 size = put_bits_ptr(&pb) - pb.buf;
268 /* patch packet size */
269 AV_WB16(buf + 4, size - 6);
274 static int get_system_header_size(AVFormatContext *ctx)
276 int buf_index, i, private_stream_coded;
278 MpegMuxContext *s = ctx->priv_data;
281 return 18; // DVD-Video system headers are 18 bytes fixed length.
284 private_stream_coded = 0;
285 for (i = 0; i < ctx->nb_streams; i++) {
286 stream = ctx->streams[i]->priv_data;
287 if (stream->id < 0xc0) {
288 if (private_stream_coded)
290 private_stream_coded = 1;
297 static av_cold int mpeg_mux_init(AVFormatContext *ctx)
299 MpegMuxContext *s = ctx->priv_data;
300 int bitrate, i, mpa_id, mpv_id, h264_id, mps_id, ac3_id, dts_id, lpcm_id, j;
306 s->packet_number = 0;
307 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
308 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
309 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
310 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
311 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
312 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
314 if (ctx->packet_size) {
315 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
316 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
320 s->packet_size = ctx->packet_size;
322 s->packet_size = 2048;
323 if (ctx->max_delay < 0) /* Not set by the caller */
324 ctx->max_delay = AV_TIME_BASE*7/10;
326 s->vcd_padding_bytes_written = 0;
327 s->vcd_padding_bitrate_num = 0;
340 for (i = 0; i < ctx->nb_streams; i++) {
341 AVCPBProperties *props;
343 st = ctx->streams[i];
344 stream = av_mallocz(sizeof(StreamInfo));
347 st->priv_data = stream;
349 avpriv_set_pts_info(st, 64, 1, 90000);
351 switch (st->codecpar->codec_type) {
352 case AVMEDIA_TYPE_AUDIO:
354 (st->codecpar->codec_id == AV_CODEC_ID_AC3 ||
355 st->codecpar->codec_id == AV_CODEC_ID_DTS ||
356 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE))
357 av_log(ctx, AV_LOG_WARNING,
358 "%s in MPEG-1 system streams is not widely supported, "
359 "consider using the vob or the dvd muxer "
360 "to force a MPEG-2 program stream.\n",
361 avcodec_get_name(st->codecpar->codec_id));
362 if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
363 stream->id = ac3_id++;
364 } else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {
365 stream->id = dts_id++;
366 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
367 stream->id = lpcm_id++;
368 for (j = 0; j < 4; j++) {
369 if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
374 if (st->codecpar->channels > 8)
376 stream->lpcm_header[0] = 0x0c;
377 stream->lpcm_header[1] = (st->codecpar->channels - 1) | (j << 4);
378 stream->lpcm_header[2] = 0x80;
379 stream->lpcm_align = st->codecpar->channels * 2;
381 stream->id = mpa_id++;
384 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
385 * Right now it is also used for everything else. */
386 stream->max_buffer_size = 4 * 1024;
389 case AVMEDIA_TYPE_VIDEO:
390 if (st->codecpar->codec_id == AV_CODEC_ID_H264)
391 stream->id = h264_id++;
393 stream->id = mpv_id++;
395 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
396 if (props && props->buffer_size)
397 stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
399 av_log(ctx, AV_LOG_WARNING,
400 "VBV buffer size not set, using default size of 130KB\n"
401 "If you want the mpeg file to be compliant to some specification\n"
402 "Like DVD, VCD or others, make sure you set the correct buffer size\n");
403 // FIXME: this is probably too small as default
404 stream->max_buffer_size = 230 * 1024;
406 if (stream->max_buffer_size > 1024 * 8191) {
407 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
408 stream->max_buffer_size = 1024 * 8191;
412 case AVMEDIA_TYPE_SUBTITLE:
413 stream->id = mps_id++;
414 stream->max_buffer_size = 16 * 1024;
417 av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
418 av_get_media_type_string(st->codecpar->codec_type), i);
419 return AVERROR(EINVAL);
421 stream->fifo = av_fifo_alloc(16);
428 for (i = 0; i < ctx->nb_streams; i++) {
429 AVCPBProperties *props;
431 st = ctx->streams[i];
432 stream = (StreamInfo *)st->priv_data;
434 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
436 codec_rate = props->max_bitrate;
438 codec_rate = st->codecpar->bit_rate;
441 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
443 bitrate += codec_rate;
445 if ((stream->id & 0xe0) == AUDIO_ID)
446 audio_bitrate += codec_rate;
447 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
448 video_bitrate += codec_rate;
451 if (s->user_mux_rate) {
452 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
454 /* we increase slightly the bitrate to take into account the
455 * headers. XXX: compute it exactly */
456 bitrate += bitrate / 20;
458 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
459 if (s->mux_rate >= (1<<22)) {
460 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
461 s->mux_rate = (1<<22) - 1;
466 int64_t overhead_rate;
468 /* The VCD standard mandates that the mux_rate field is 3528
469 * (see standard p. IV-6).
470 * The value is actually "wrong", i.e. if you calculate
471 * it using the normal formula and the 75 sectors per second transfer
472 * rate you get a different value because the real pack size is 2324,
473 * not 2352. But the standard explicitly specifies that the mux_rate
474 * field in the header must have this value. */
475 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
477 /* The VCD standard states that the muxed stream must be
478 * exactly 75 packs / second (the data rate of a single speed cdrom).
479 * Since the video bitrate (probably 1150000 bits/sec) will be below
480 * the theoretical maximum we have to add some padding packets
481 * to make up for the lower data rate.
482 * (cf. VCD standard p. IV-6 ) */
484 /* Add the header overhead to the data rate.
485 * 2279 data bytes per audio pack, 2294 data bytes per video pack */
486 overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
487 overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
489 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
490 s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
491 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)
494 if (s->is_vcd || s->is_mpeg2)
496 s->pack_header_freq = 1;
498 /* every 2 seconds */
499 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
501 /* the above seems to make pack_header_freq zero sometimes */
502 if (s->pack_header_freq == 0)
503 s->pack_header_freq = 1;
506 /* every 200 packets. Need to look at the spec. */
507 s->system_header_freq = s->pack_header_freq * 40;
509 /* the standard mandates that there are only two system headers
510 * in the whole file: one in the first packet of each stream.
511 * (see standard p. IV-7 and IV-8) */
512 s->system_header_freq = 0x7fffffff;
514 s->system_header_freq = s->pack_header_freq * 5;
516 for (i = 0; i < ctx->nb_streams; i++) {
517 stream = ctx->streams[i]->priv_data;
518 stream->packet_number = 0;
520 s->system_header_size = get_system_header_size(ctx);
521 s->last_scr = AV_NOPTS_VALUE;
525 for (i = 0; i < ctx->nb_streams; i++)
526 av_freep(&ctx->streams[i]->priv_data);
527 return AVERROR(ENOMEM);
530 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
532 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
533 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
534 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
537 /* return the number of padding bytes that should be inserted into
538 * the multiplexed stream. */
539 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
541 MpegMuxContext *s = ctx->priv_data;
544 if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
545 int64_t full_pad_bytes;
547 // FIXME: this is wrong
549 av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
550 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
553 /* might happen if we have already padded to a later timestamp. This
554 * can occur if another stream has already advanced further. */
561 /* Write an MPEG padding packet header. */
562 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
565 MpegMuxContext *s = ctx->priv_data;
568 avio_wb32(pb, PADDING_STREAM);
569 avio_wb16(pb, packet_bytes - 6);
576 for (i = 0; i < packet_bytes; i++)
580 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
583 PacketDesc *pkt_desc = stream->premux_packet;
586 if (pkt_desc->size == pkt_desc->unwritten_size)
588 len -= pkt_desc->unwritten_size;
589 pkt_desc = pkt_desc->next;
595 /* flush the packet on stream stream_index */
596 static int flush_packet(AVFormatContext *ctx, int stream_index,
597 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
599 MpegMuxContext *s = ctx->priv_data;
600 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
602 int size, payload_size, startcode, id, stuffing_size, i, header_len;
605 int zero_trail_bytes = 0;
606 int pad_packet_bytes = 0;
608 /* "general" pack without data specific to one stream? */
609 int general_pack = 0;
614 av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
618 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
619 /* output pack and systems header if needed */
620 size = put_pack_header(ctx, buf_ptr, scr);
625 /* there is exactly one system header for each stream in a VCD MPEG,
626 * One in the very first video packet and one in the very first
627 * audio packet (see VCD standard p. IV-7 and IV-8). */
629 if (stream->packet_number == 0) {
630 size = put_system_header(ctx, buf_ptr, id);
633 } else if (s->is_dvd) {
634 if (stream->align_iframe || s->packet_number == 0) {
635 int PES_bytes_to_fill = s->packet_size - size - 10;
637 if (pts != AV_NOPTS_VALUE) {
639 PES_bytes_to_fill -= 5 + 5;
641 PES_bytes_to_fill -= 5;
644 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
645 size = put_system_header(ctx, buf_ptr, 0);
647 size = buf_ptr - buffer;
648 avio_write(ctx->pb, buffer, size);
650 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
651 avio_wb16(ctx->pb, 0x03d4); // length
652 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
653 for (i = 0; i < 979; i++)
654 avio_w8(ctx->pb, 0x00);
656 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
657 avio_wb16(ctx->pb, 0x03fa); // length
658 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
659 for (i = 0; i < 1017; i++)
660 avio_w8(ctx->pb, 0x00);
662 memset(buffer, 0, 128);
665 stream->align_iframe = 0;
666 // FIXME: rounding and first few bytes of each packet
667 scr += s->packet_size * 90000LL /
668 (s->mux_rate * 50LL);
669 size = put_pack_header(ctx, buf_ptr, scr);
673 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
674 pad_packet_bytes = PES_bytes_to_fill -
675 stream->bytes_to_iframe;
679 if ((s->packet_number % s->system_header_freq) == 0) {
680 size = put_system_header(ctx, buf_ptr, 0);
685 size = buf_ptr - buffer;
686 avio_write(ctx->pb, buffer, size);
688 packet_size = s->packet_size - size;
690 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
691 /* The VCD standard demands that 20 zero bytes follow
692 * each audio pack (see standard p. IV-8). */
693 zero_trail_bytes += 20;
695 if ((s->is_vcd && stream->packet_number == 0) ||
696 (s->is_svcd && s->packet_number == 0)) {
697 /* for VCD the first pack of each stream contains only the pack header,
698 * the system header and lots of padding (see VCD standard p. IV-6).
699 * In the case of an audio pack, 20 zero bytes are also added at
701 /* For SVCD we fill the very first pack to increase compatibility with
702 * some DVD players. Not mandated by the standard. */
704 /* the system header refers to both streams and no stream data */
706 pad_packet_bytes = packet_size - zero_trail_bytes;
709 packet_size -= pad_packet_bytes + zero_trail_bytes;
711 if (packet_size > 0) {
712 /* packet header size */
718 if (stream->packet_number == 0)
719 header_len += 3; /* PES extension */
720 header_len += 1; /* obligatory stuffing byte */
724 if (pts != AV_NOPTS_VALUE) {
734 payload_size = packet_size - header_len;
736 startcode = PRIVATE_STREAM_1;
744 startcode = 0x100 + id;
747 stuffing_size = payload_size - av_fifo_size(stream->fifo);
749 // first byte does not fit -> reset pts/dts + stuffing
750 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
751 int timestamp_len = 0;
754 if (pts != AV_NOPTS_VALUE)
755 timestamp_len += s->is_mpeg2 ? 5 : 4;
757 dts = AV_NOPTS_VALUE;
758 header_len -= timestamp_len;
759 if (s->is_dvd && stream->align_iframe) {
760 pad_packet_bytes += timestamp_len;
761 packet_size -= timestamp_len;
763 payload_size += timestamp_len;
765 stuffing_size += timestamp_len;
766 if (payload_size > trailer_size)
767 stuffing_size += payload_size - trailer_size;
770 // can't use padding, so use stuffing
771 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
772 packet_size += pad_packet_bytes;
773 payload_size += pad_packet_bytes; // undo the previous adjustment
774 if (stuffing_size < 0)
775 stuffing_size = pad_packet_bytes;
777 stuffing_size += pad_packet_bytes;
778 pad_packet_bytes = 0;
781 if (stuffing_size < 0)
784 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
785 if (payload_size < av_fifo_size(stream->fifo))
786 stuffing_size += payload_size % stream->lpcm_align;
789 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
790 pad_packet_bytes += stuffing_size;
791 packet_size -= stuffing_size;
792 payload_size -= stuffing_size;
796 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
798 avio_wb32(ctx->pb, startcode);
800 avio_wb16(ctx->pb, packet_size);
803 for (i = 0; i < stuffing_size; i++)
804 avio_w8(ctx->pb, 0xff);
807 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
811 if (pts != AV_NOPTS_VALUE) {
817 /* Both the MPEG-2 and the SVCD standards demand that the
818 * P-STD_buffer_size field be included in the first packet of
819 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
820 * and MPEG-2 standard 2.7.7) */
821 if (stream->packet_number == 0)
824 avio_w8(ctx->pb, pes_flags); /* flags */
825 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
827 if (pes_flags & 0x80) /* write pts */
828 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
829 if (pes_flags & 0x40) /* write dts */
830 put_timestamp(ctx->pb, 0x01, dts);
832 if (pes_flags & 0x01) { /* write pes extension */
833 avio_w8(ctx->pb, 0x10); /* flags */
835 /* P-STD buffer info */
836 if ((id & 0xe0) == AUDIO_ID)
837 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
839 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
842 if (pts != AV_NOPTS_VALUE) {
844 put_timestamp(ctx->pb, 0x03, pts);
845 put_timestamp(ctx->pb, 0x01, dts);
847 put_timestamp(ctx->pb, 0x02, pts);
850 avio_w8(ctx->pb, 0x0f);
855 /* special stuffing byte that is always written
856 * to prevent accidental generation of start codes. */
857 avio_w8(ctx->pb, 0xff);
859 for (i = 0; i < stuffing_size; i++)
860 avio_w8(ctx->pb, 0xff);
863 if (startcode == PRIVATE_STREAM_1) {
864 avio_w8(ctx->pb, id);
866 /* LPCM (XXX: check nb_frames) */
868 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
869 avio_w8(ctx->pb, stream->lpcm_header[0]);
870 avio_w8(ctx->pb, stream->lpcm_header[1]);
871 avio_w8(ctx->pb, stream->lpcm_header[2]);
872 } else if (id >= 0x40) {
874 avio_w8(ctx->pb, nb_frames);
875 avio_wb16(ctx->pb, trailer_size + 1);
880 av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
881 av_fifo_generic_read(stream->fifo, ctx->pb,
882 payload_size - stuffing_size,
883 (void (*)(void*, void*, int))avio_write);
884 stream->bytes_to_iframe -= payload_size - stuffing_size;
890 if (pad_packet_bytes > 0)
891 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
893 for (i = 0; i < zero_trail_bytes; i++)
894 avio_w8(ctx->pb, 0x00);
900 /* only increase the stream packet number if this pack actually contains
901 * something that is specific to this stream! I.e. a dedicated header
904 stream->packet_number++;
906 return payload_size - stuffing_size;
909 static void put_vcd_padding_sector(AVFormatContext *ctx)
911 /* There are two ways to do this padding: writing a sector/pack
912 * of 0 values, or writing an MPEG padding pack. Both seem to
913 * work with most decoders, BUT the VCD standard only allows a 0-sector
914 * (see standard p. IV-4, IV-5).
915 * So a 0-sector it is... */
917 MpegMuxContext *s = ctx->priv_data;
920 for (i = 0; i < s->packet_size; i++)
923 s->vcd_padding_bytes_written += s->packet_size;
927 /* increasing the packet number is correct. The SCR of the following packs
928 * is calculated from the packet_number and it has to include the padding
929 * sector (it represents the sector index, not the MPEG pack index)
930 * (see VCD standard p. IV-6) */
934 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
938 for (i = 0; i < ctx->nb_streams; i++) {
939 AVStream *st = ctx->streams[i];
940 StreamInfo *stream = st->priv_data;
941 PacketDesc *pkt_desc;
943 while ((pkt_desc = stream->predecode_packet) &&
944 scr > pkt_desc->dts) { // FIXME: > vs >=
945 if (stream->buffer_index < pkt_desc->size ||
946 stream->predecode_packet == stream->premux_packet) {
947 av_log(ctx, AV_LOG_ERROR,
948 "buffer underflow st=%d bufi=%d size=%d\n",
949 i, stream->buffer_index, pkt_desc->size);
952 stream->buffer_index -= pkt_desc->size;
953 stream->predecode_packet = pkt_desc->next;
961 static int output_packet(AVFormatContext *ctx, int flush)
963 MpegMuxContext *s = ctx->priv_data;
966 int i, avail_space = 0, es_size, trailer_size;
968 int best_score = INT_MIN;
969 int ignore_constraints = 0;
970 int ignore_delay = 0;
971 int64_t scr = s->last_scr;
972 PacketDesc *timestamp_packet;
973 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
976 for (i = 0; i < ctx->nb_streams; i++) {
977 AVStream *st = ctx->streams[i];
978 StreamInfo *stream = st->priv_data;
979 const int avail_data = av_fifo_size(stream->fifo);
980 const int space = stream->max_buffer_size - stream->buffer_index;
981 int rel_space = 1024LL * space / stream->max_buffer_size;
982 PacketDesc *next_pkt = stream->premux_packet;
984 /* for subtitle, a single PES packet must be generated,
985 * so we flush after every single subtitle packet */
986 if (s->packet_size > avail_data && !flush
987 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
991 av_assert0(avail_data > 0);
993 if (space < s->packet_size && !ignore_constraints)
996 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
998 if ( stream->predecode_packet
999 && stream->predecode_packet->size > stream->buffer_index)
1001 if (rel_space > best_score) {
1002 best_score = rel_space;
1004 avail_space = space;
1009 int64_t best_dts = INT64_MAX;
1012 for (i = 0; i < ctx->nb_streams; i++) {
1013 AVStream *st = ctx->streams[i];
1014 StreamInfo *stream = st->priv_data;
1015 PacketDesc *pkt_desc = stream->predecode_packet;
1016 if (pkt_desc && pkt_desc->dts < best_dts)
1017 best_dts = pkt_desc->dts;
1018 has_premux |= !!stream->premux_packet;
1021 if (best_dts < INT64_MAX) {
1022 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1023 scr / 90000.0, best_dts / 90000.0);
1025 if (scr >= best_dts + 1 && !ignore_constraints) {
1026 av_log(ctx, AV_LOG_ERROR,
1027 "packet too large, ignoring buffer limits to mux it\n");
1028 ignore_constraints = 1;
1030 scr = FFMAX(best_dts + 1, scr);
1031 if (remove_decoded_packets(ctx, scr) < 0)
1033 } else if (has_premux && flush) {
1034 av_log(ctx, AV_LOG_ERROR,
1035 "delay too large, ignoring ...\n");
1037 ignore_constraints = 1;
1044 av_assert0(best_i >= 0);
1046 st = ctx->streams[best_i];
1047 stream = st->priv_data;
1049 av_assert0(av_fifo_size(stream->fifo) > 0);
1051 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1053 timestamp_packet = stream->premux_packet;
1054 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1057 trailer_size = timestamp_packet->unwritten_size;
1058 timestamp_packet = timestamp_packet->next;
1061 if (timestamp_packet) {
1062 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1063 timestamp_packet->dts / 90000.0,
1064 timestamp_packet->pts / 90000.0,
1065 scr / 90000.0, best_i);
1066 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1067 timestamp_packet->dts, scr, trailer_size);
1069 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1070 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1075 /* Write one or more padding sectors, if necessary, to reach
1076 * the constant overall bitrate. */
1079 // FIXME: pts cannot be correct here
1080 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1081 put_vcd_padding_sector(ctx);
1082 // FIXME: rounding and first few bytes of each packet
1083 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1087 stream->buffer_index += es_size;
1088 // FIXME: rounding and first few bytes of each packet
1089 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1091 while (stream->premux_packet &&
1092 stream->premux_packet->unwritten_size <= es_size) {
1093 es_size -= stream->premux_packet->unwritten_size;
1094 stream->premux_packet = stream->premux_packet->next;
1097 av_assert0(stream->premux_packet);
1098 stream->premux_packet->unwritten_size -= es_size;
1101 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1107 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1109 int stream_index = pkt->stream_index;
1110 int size = pkt->size;
1111 uint8_t *buf = pkt->data;
1112 MpegMuxContext *s = ctx->priv_data;
1113 AVStream *st = ctx->streams[stream_index];
1114 StreamInfo *stream = st->priv_data;
1116 PacketDesc *pkt_desc;
1118 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1119 (pkt->flags & AV_PKT_FLAG_KEY);
1121 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1126 if (s->last_scr == AV_NOPTS_VALUE) {
1127 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1128 if (dts != AV_NOPTS_VALUE)
1129 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1132 s->last_scr = dts - preload;
1135 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1136 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1139 if (dts != AV_NOPTS_VALUE) dts += preload;
1140 if (pts != AV_NOPTS_VALUE) pts += preload;
1142 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1143 dts / 90000.0, pts / 90000.0, pkt->flags,
1144 pkt->stream_index, pts != AV_NOPTS_VALUE);
1145 if (!stream->premux_packet)
1146 stream->next_packet = &stream->premux_packet;
1147 *stream->next_packet =
1148 pkt_desc = av_mallocz(sizeof(PacketDesc));
1150 return AVERROR(ENOMEM);
1151 pkt_desc->pts = pts;
1152 pkt_desc->dts = dts;
1153 pkt_desc->unwritten_size =
1154 pkt_desc->size = size;
1155 if (!stream->predecode_packet)
1156 stream->predecode_packet = pkt_desc;
1157 stream->next_packet = &pkt_desc->next;
1159 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1163 // min VOBU length 0.4 seconds (mpucoder)
1165 (s->packet_number == 0 ||
1166 (pts - stream->vobu_start_pts >= 36000))) {
1167 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1168 stream->align_iframe = 1;
1169 stream->vobu_start_pts = pts;
1173 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1176 int ret = output_packet(ctx, 0);
1182 static int mpeg_mux_end(AVFormatContext *ctx)
1188 int ret = output_packet(ctx, 1);
1195 /* End header according to MPEG-1 systems standard. We do not write
1196 * it as it is usually not needed by decoders and because it
1197 * complicates MPEG stream concatenation. */
1198 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1199 // avio_flush(ctx->pb);
1201 for (i = 0; i < ctx->nb_streams; i++) {
1202 stream = ctx->streams[i]->priv_data;
1204 av_assert0(av_fifo_size(stream->fifo) == 0);
1205 av_fifo_freep(&stream->fifo);
1210 #define OFFSET(x) offsetof(MpegMuxContext, x)
1211 #define E AV_OPT_FLAG_ENCODING_PARAM
1212 static const AVOption options[] = {
1213 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1214 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1218 #define MPEGENC_CLASS(flavor) \
1219 static const AVClass flavor ## _class = { \
1220 .class_name = #flavor " muxer", \
1221 .item_name = av_default_item_name, \
1222 .version = LIBAVUTIL_VERSION_INT, \
1223 .option = options, \
1226 #if CONFIG_MPEG1SYSTEM_MUXER
1228 AVOutputFormat ff_mpeg1system_muxer = {
1230 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1231 .mime_type = "video/mpeg",
1232 .extensions = "mpg,mpeg",
1233 .priv_data_size = sizeof(MpegMuxContext),
1234 .audio_codec = AV_CODEC_ID_MP2,
1235 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1236 .write_header = mpeg_mux_init,
1237 .write_packet = mpeg_mux_write_packet,
1238 .write_trailer = mpeg_mux_end,
1239 .priv_class = &mpeg_class,
1243 #if CONFIG_MPEG1VCD_MUXER
1245 AVOutputFormat ff_mpeg1vcd_muxer = {
1247 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1248 .mime_type = "video/mpeg",
1249 .priv_data_size = sizeof(MpegMuxContext),
1250 .audio_codec = AV_CODEC_ID_MP2,
1251 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1252 .write_header = mpeg_mux_init,
1253 .write_packet = mpeg_mux_write_packet,
1254 .write_trailer = mpeg_mux_end,
1255 .priv_class = &vcd_class,
1259 #if CONFIG_MPEG2VOB_MUXER
1261 AVOutputFormat ff_mpeg2vob_muxer = {
1263 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1264 .mime_type = "video/mpeg",
1265 .extensions = "vob",
1266 .priv_data_size = sizeof(MpegMuxContext),
1267 .audio_codec = AV_CODEC_ID_MP2,
1268 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1269 .write_header = mpeg_mux_init,
1270 .write_packet = mpeg_mux_write_packet,
1271 .write_trailer = mpeg_mux_end,
1272 .priv_class = &vob_class,
1276 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1277 #if CONFIG_MPEG2SVCD_MUXER
1279 AVOutputFormat ff_mpeg2svcd_muxer = {
1281 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1282 .mime_type = "video/mpeg",
1283 .extensions = "vob",
1284 .priv_data_size = sizeof(MpegMuxContext),
1285 .audio_codec = AV_CODEC_ID_MP2,
1286 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1287 .write_header = mpeg_mux_init,
1288 .write_packet = mpeg_mux_write_packet,
1289 .write_trailer = mpeg_mux_end,
1290 .priv_class = &svcd_class,
1294 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1295 #if CONFIG_MPEG2DVD_MUXER
1297 AVOutputFormat ff_mpeg2dvd_muxer = {
1299 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1300 .mime_type = "video/mpeg",
1301 .extensions = "dvd",
1302 .priv_data_size = sizeof(MpegMuxContext),
1303 .audio_codec = AV_CODEC_ID_MP2,
1304 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1305 .write_header = mpeg_mux_init,
1306 .write_packet = mpeg_mux_write_packet,
1307 .write_trailer = mpeg_mux_end,
1308 .priv_class = &dvd_class,