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 st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD))
358 av_log(ctx, AV_LOG_WARNING,
359 "%s in MPEG-1 system streams is not widely supported, "
360 "consider using the vob or the dvd muxer "
361 "to force a MPEG-2 program stream.\n",
362 avcodec_get_name(st->codecpar->codec_id));
363 if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
364 stream->id = ac3_id++;
365 } else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {
366 stream->id = dts_id++;
367 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ||
368 st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
369 if (st->codecpar->bits_per_coded_sample != 16) {
370 av_log(ctx, AV_LOG_ERROR, "Only 16 bit LPCM streams can be muxed.\n");
373 stream->id = lpcm_id++;
374 for (j = 0; j < 4; j++) {
375 if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
380 av_log(ctx, AV_LOG_ERROR, "Invalid sampling rate for PCM stream.\n");
381 av_log(ctx, AV_LOG_INFO, "Allowed sampling rates:");
382 for (sr = 0; sr < 4; sr++)
383 av_log(ctx, AV_LOG_INFO, " %d", lpcm_freq_tab[sr]);
384 av_log(ctx, AV_LOG_INFO, "\n");
387 if (st->codecpar->channels > 8) {
388 av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");
391 stream->lpcm_header[0] = 0x0c;
392 stream->lpcm_header[1] = (st->codecpar->channels - 1) | (j << 4);
393 stream->lpcm_header[2] = 0x80;
394 stream->lpcm_align = st->codecpar->channels * 2;
396 stream->id = mpa_id++;
399 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
400 * Right now it is also used for everything else. */
401 stream->max_buffer_size = 4 * 1024;
404 case AVMEDIA_TYPE_VIDEO:
405 if (st->codecpar->codec_id == AV_CODEC_ID_H264)
406 stream->id = h264_id++;
408 stream->id = mpv_id++;
410 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
411 if (props && props->buffer_size)
412 stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
414 av_log(ctx, AV_LOG_WARNING,
415 "VBV buffer size not set, using default size of 230KB\n"
416 "If you want the mpeg file to be compliant to some specification\n"
417 "Like DVD, VCD or others, make sure you set the correct buffer size\n");
418 // FIXME: this is probably too small as default
419 stream->max_buffer_size = 230 * 1024;
421 if (stream->max_buffer_size > 1024 * 8191) {
422 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
423 stream->max_buffer_size = 1024 * 8191;
427 case AVMEDIA_TYPE_SUBTITLE:
428 stream->id = mps_id++;
429 stream->max_buffer_size = 16 * 1024;
432 av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
433 av_get_media_type_string(st->codecpar->codec_type), i);
434 return AVERROR(EINVAL);
436 stream->fifo = av_fifo_alloc(16);
443 for (i = 0; i < ctx->nb_streams; i++) {
444 AVCPBProperties *props;
446 st = ctx->streams[i];
447 stream = (StreamInfo *)st->priv_data;
449 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
451 codec_rate = props->max_bitrate;
453 codec_rate = st->codecpar->bit_rate;
456 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
458 bitrate += codec_rate;
460 if ((stream->id & 0xe0) == AUDIO_ID)
461 audio_bitrate += codec_rate;
462 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
463 video_bitrate += codec_rate;
466 if (s->user_mux_rate) {
467 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
469 /* we increase slightly the bitrate to take into account the
470 * headers. XXX: compute it exactly */
471 bitrate += bitrate / 20;
473 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
474 if (s->mux_rate >= (1<<22)) {
475 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
476 s->mux_rate = (1<<22) - 1;
481 int64_t overhead_rate;
483 /* The VCD standard mandates that the mux_rate field is 3528
484 * (see standard p. IV-6).
485 * The value is actually "wrong", i.e. if you calculate
486 * it using the normal formula and the 75 sectors per second transfer
487 * rate you get a different value because the real pack size is 2324,
488 * not 2352. But the standard explicitly specifies that the mux_rate
489 * field in the header must have this value. */
490 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
492 /* The VCD standard states that the muxed stream must be
493 * exactly 75 packs / second (the data rate of a single speed cdrom).
494 * Since the video bitrate (probably 1150000 bits/sec) will be below
495 * the theoretical maximum we have to add some padding packets
496 * to make up for the lower data rate.
497 * (cf. VCD standard p. IV-6 ) */
499 /* Add the header overhead to the data rate.
500 * 2279 data bytes per audio pack, 2294 data bytes per video pack */
501 overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
502 overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
504 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
505 s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
506 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)
509 if (s->is_vcd || s->is_mpeg2)
511 s->pack_header_freq = 1;
513 /* every 2 seconds */
514 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
516 /* the above seems to make pack_header_freq zero sometimes */
517 if (s->pack_header_freq == 0)
518 s->pack_header_freq = 1;
521 /* every 200 packets. Need to look at the spec. */
522 s->system_header_freq = s->pack_header_freq * 40;
524 /* the standard mandates that there are only two system headers
525 * in the whole file: one in the first packet of each stream.
526 * (see standard p. IV-7 and IV-8) */
527 s->system_header_freq = 0x7fffffff;
529 s->system_header_freq = s->pack_header_freq * 5;
531 for (i = 0; i < ctx->nb_streams; i++) {
532 stream = ctx->streams[i]->priv_data;
533 stream->packet_number = 0;
535 s->system_header_size = get_system_header_size(ctx);
536 s->last_scr = AV_NOPTS_VALUE;
540 for (i = 0; i < ctx->nb_streams; i++)
541 av_freep(&ctx->streams[i]->priv_data);
542 return AVERROR(ENOMEM);
545 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
547 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
548 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
549 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
552 /* return the number of padding bytes that should be inserted into
553 * the multiplexed stream. */
554 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
556 MpegMuxContext *s = ctx->priv_data;
559 if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
560 int64_t full_pad_bytes;
562 // FIXME: this is wrong
564 av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
565 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
568 /* might happen if we have already padded to a later timestamp. This
569 * can occur if another stream has already advanced further. */
576 /* Write an MPEG padding packet header. */
577 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
580 MpegMuxContext *s = ctx->priv_data;
583 avio_wb32(pb, PADDING_STREAM);
584 avio_wb16(pb, packet_bytes - 6);
591 for (i = 0; i < packet_bytes; i++)
595 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
598 PacketDesc *pkt_desc = stream->premux_packet;
601 if (pkt_desc->size == pkt_desc->unwritten_size)
603 len -= pkt_desc->unwritten_size;
604 pkt_desc = pkt_desc->next;
610 /* flush the packet on stream stream_index */
611 static int flush_packet(AVFormatContext *ctx, int stream_index,
612 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
614 MpegMuxContext *s = ctx->priv_data;
615 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
617 int size, payload_size, startcode, id, stuffing_size, i, header_len;
620 int zero_trail_bytes = 0;
621 int pad_packet_bytes = 0;
623 /* "general" pack without data specific to one stream? */
624 int general_pack = 0;
629 av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
633 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
634 /* output pack and systems header if needed */
635 size = put_pack_header(ctx, buf_ptr, scr);
640 /* there is exactly one system header for each stream in a VCD MPEG,
641 * One in the very first video packet and one in the very first
642 * audio packet (see VCD standard p. IV-7 and IV-8). */
644 if (stream->packet_number == 0) {
645 size = put_system_header(ctx, buf_ptr, id);
648 } else if (s->is_dvd) {
649 if (stream->align_iframe || s->packet_number == 0) {
650 int PES_bytes_to_fill = s->packet_size - size - 10;
652 if (pts != AV_NOPTS_VALUE) {
654 PES_bytes_to_fill -= 5 + 5;
656 PES_bytes_to_fill -= 5;
659 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
660 size = put_system_header(ctx, buf_ptr, 0);
662 size = buf_ptr - buffer;
663 avio_write(ctx->pb, buffer, size);
665 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
666 avio_wb16(ctx->pb, 0x03d4); // length
667 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
668 for (i = 0; i < 979; i++)
669 avio_w8(ctx->pb, 0x00);
671 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
672 avio_wb16(ctx->pb, 0x03fa); // length
673 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
674 for (i = 0; i < 1017; i++)
675 avio_w8(ctx->pb, 0x00);
677 memset(buffer, 0, 128);
680 stream->align_iframe = 0;
681 // FIXME: rounding and first few bytes of each packet
682 scr += s->packet_size * 90000LL /
683 (s->mux_rate * 50LL);
684 size = put_pack_header(ctx, buf_ptr, scr);
688 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
689 pad_packet_bytes = PES_bytes_to_fill -
690 stream->bytes_to_iframe;
694 if ((s->packet_number % s->system_header_freq) == 0) {
695 size = put_system_header(ctx, buf_ptr, 0);
700 size = buf_ptr - buffer;
701 avio_write(ctx->pb, buffer, size);
703 packet_size = s->packet_size - size;
705 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
706 /* The VCD standard demands that 20 zero bytes follow
707 * each audio pack (see standard p. IV-8). */
708 zero_trail_bytes += 20;
710 if ((s->is_vcd && stream->packet_number == 0) ||
711 (s->is_svcd && s->packet_number == 0)) {
712 /* for VCD the first pack of each stream contains only the pack header,
713 * the system header and lots of padding (see VCD standard p. IV-6).
714 * In the case of an audio pack, 20 zero bytes are also added at
716 /* For SVCD we fill the very first pack to increase compatibility with
717 * some DVD players. Not mandated by the standard. */
719 /* the system header refers to both streams and no stream data */
721 pad_packet_bytes = packet_size - zero_trail_bytes;
724 packet_size -= pad_packet_bytes + zero_trail_bytes;
726 if (packet_size > 0) {
727 /* packet header size */
733 if (stream->packet_number == 0)
734 header_len += 3; /* PES extension */
735 header_len += 1; /* obligatory stuffing byte */
739 if (pts != AV_NOPTS_VALUE) {
749 payload_size = packet_size - header_len;
751 startcode = PRIVATE_STREAM_1;
759 startcode = 0x100 + id;
762 stuffing_size = payload_size - av_fifo_size(stream->fifo);
764 // first byte does not fit -> reset pts/dts + stuffing
765 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
766 int timestamp_len = 0;
769 if (pts != AV_NOPTS_VALUE)
770 timestamp_len += s->is_mpeg2 ? 5 : 4;
772 dts = AV_NOPTS_VALUE;
773 header_len -= timestamp_len;
774 if (s->is_dvd && stream->align_iframe) {
775 pad_packet_bytes += timestamp_len;
776 packet_size -= timestamp_len;
778 payload_size += timestamp_len;
780 stuffing_size += timestamp_len;
781 if (payload_size > trailer_size)
782 stuffing_size += payload_size - trailer_size;
785 // can't use padding, so use stuffing
786 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
787 packet_size += pad_packet_bytes;
788 payload_size += pad_packet_bytes; // undo the previous adjustment
789 if (stuffing_size < 0)
790 stuffing_size = pad_packet_bytes;
792 stuffing_size += pad_packet_bytes;
793 pad_packet_bytes = 0;
796 if (stuffing_size < 0)
799 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
800 if (payload_size < av_fifo_size(stream->fifo))
801 stuffing_size += payload_size % stream->lpcm_align;
804 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
805 pad_packet_bytes += stuffing_size;
806 packet_size -= stuffing_size;
807 payload_size -= stuffing_size;
811 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
813 avio_wb32(ctx->pb, startcode);
815 avio_wb16(ctx->pb, packet_size);
818 for (i = 0; i < stuffing_size; i++)
819 avio_w8(ctx->pb, 0xff);
822 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
826 if (pts != AV_NOPTS_VALUE) {
832 /* Both the MPEG-2 and the SVCD standards demand that the
833 * P-STD_buffer_size field be included in the first packet of
834 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
835 * and MPEG-2 standard 2.7.7) */
836 if (stream->packet_number == 0)
839 avio_w8(ctx->pb, pes_flags); /* flags */
840 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
842 if (pes_flags & 0x80) /* write pts */
843 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
844 if (pes_flags & 0x40) /* write dts */
845 put_timestamp(ctx->pb, 0x01, dts);
847 if (pes_flags & 0x01) { /* write pes extension */
848 avio_w8(ctx->pb, 0x10); /* flags */
850 /* P-STD buffer info */
851 if ((id & 0xe0) == AUDIO_ID)
852 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
854 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
857 if (pts != AV_NOPTS_VALUE) {
859 put_timestamp(ctx->pb, 0x03, pts);
860 put_timestamp(ctx->pb, 0x01, dts);
862 put_timestamp(ctx->pb, 0x02, pts);
865 avio_w8(ctx->pb, 0x0f);
870 /* special stuffing byte that is always written
871 * to prevent accidental generation of start codes. */
872 avio_w8(ctx->pb, 0xff);
874 for (i = 0; i < stuffing_size; i++)
875 avio_w8(ctx->pb, 0xff);
878 if (startcode == PRIVATE_STREAM_1) {
879 avio_w8(ctx->pb, id);
881 /* LPCM (XXX: check nb_frames) */
883 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
884 avio_w8(ctx->pb, stream->lpcm_header[0]);
885 avio_w8(ctx->pb, stream->lpcm_header[1]);
886 avio_w8(ctx->pb, stream->lpcm_header[2]);
887 } else if (id >= 0x40) {
889 avio_w8(ctx->pb, nb_frames);
890 avio_wb16(ctx->pb, trailer_size + 1);
895 av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
896 av_fifo_generic_read(stream->fifo, ctx->pb,
897 payload_size - stuffing_size,
898 (void (*)(void*, void*, int))avio_write);
899 stream->bytes_to_iframe -= payload_size - stuffing_size;
905 if (pad_packet_bytes > 0)
906 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
908 for (i = 0; i < zero_trail_bytes; i++)
909 avio_w8(ctx->pb, 0x00);
915 /* only increase the stream packet number if this pack actually contains
916 * something that is specific to this stream! I.e. a dedicated header
919 stream->packet_number++;
921 return payload_size - stuffing_size;
924 static void put_vcd_padding_sector(AVFormatContext *ctx)
926 /* There are two ways to do this padding: writing a sector/pack
927 * of 0 values, or writing an MPEG padding pack. Both seem to
928 * work with most decoders, BUT the VCD standard only allows a 0-sector
929 * (see standard p. IV-4, IV-5).
930 * So a 0-sector it is... */
932 MpegMuxContext *s = ctx->priv_data;
935 for (i = 0; i < s->packet_size; i++)
938 s->vcd_padding_bytes_written += s->packet_size;
942 /* increasing the packet number is correct. The SCR of the following packs
943 * is calculated from the packet_number and it has to include the padding
944 * sector (it represents the sector index, not the MPEG pack index)
945 * (see VCD standard p. IV-6) */
949 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
953 for (i = 0; i < ctx->nb_streams; i++) {
954 AVStream *st = ctx->streams[i];
955 StreamInfo *stream = st->priv_data;
956 PacketDesc *pkt_desc;
958 while ((pkt_desc = stream->predecode_packet) &&
959 scr > pkt_desc->dts) { // FIXME: > vs >=
960 if (stream->buffer_index < pkt_desc->size ||
961 stream->predecode_packet == stream->premux_packet) {
962 av_log(ctx, AV_LOG_ERROR,
963 "buffer underflow st=%d bufi=%d size=%d\n",
964 i, stream->buffer_index, pkt_desc->size);
967 stream->buffer_index -= pkt_desc->size;
968 stream->predecode_packet = pkt_desc->next;
976 static int output_packet(AVFormatContext *ctx, int flush)
978 MpegMuxContext *s = ctx->priv_data;
981 int i, avail_space = 0, es_size, trailer_size;
983 int best_score = INT_MIN;
984 int ignore_constraints = 0;
985 int ignore_delay = 0;
986 int64_t scr = s->last_scr;
987 PacketDesc *timestamp_packet;
988 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
991 for (i = 0; i < ctx->nb_streams; i++) {
992 AVStream *st = ctx->streams[i];
993 StreamInfo *stream = st->priv_data;
994 const int avail_data = av_fifo_size(stream->fifo);
995 const int space = stream->max_buffer_size - stream->buffer_index;
996 int rel_space = 1024LL * space / stream->max_buffer_size;
997 PacketDesc *next_pkt = stream->premux_packet;
999 /* for subtitle, a single PES packet must be generated,
1000 * so we flush after every single subtitle packet */
1001 if (s->packet_size > avail_data && !flush
1002 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
1004 if (avail_data == 0)
1006 av_assert0(avail_data > 0);
1008 if (space < s->packet_size && !ignore_constraints)
1011 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1013 if ( stream->predecode_packet
1014 && stream->predecode_packet->size > stream->buffer_index)
1016 if (rel_space > best_score) {
1017 best_score = rel_space;
1019 avail_space = space;
1024 int64_t best_dts = INT64_MAX;
1027 for (i = 0; i < ctx->nb_streams; i++) {
1028 AVStream *st = ctx->streams[i];
1029 StreamInfo *stream = st->priv_data;
1030 PacketDesc *pkt_desc = stream->predecode_packet;
1031 if (pkt_desc && pkt_desc->dts < best_dts)
1032 best_dts = pkt_desc->dts;
1033 has_premux |= !!stream->premux_packet;
1036 if (best_dts < INT64_MAX) {
1037 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1038 scr / 90000.0, best_dts / 90000.0);
1040 if (scr >= best_dts + 1 && !ignore_constraints) {
1041 av_log(ctx, AV_LOG_ERROR,
1042 "packet too large, ignoring buffer limits to mux it\n");
1043 ignore_constraints = 1;
1045 scr = FFMAX(best_dts + 1, scr);
1046 if (remove_decoded_packets(ctx, scr) < 0)
1048 } else if (has_premux && flush) {
1049 av_log(ctx, AV_LOG_ERROR,
1050 "delay too large, ignoring ...\n");
1052 ignore_constraints = 1;
1059 av_assert0(best_i >= 0);
1061 st = ctx->streams[best_i];
1062 stream = st->priv_data;
1064 av_assert0(av_fifo_size(stream->fifo) > 0);
1066 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1068 timestamp_packet = stream->premux_packet;
1069 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1072 trailer_size = timestamp_packet->unwritten_size;
1073 timestamp_packet = timestamp_packet->next;
1076 if (timestamp_packet) {
1077 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1078 timestamp_packet->dts / 90000.0,
1079 timestamp_packet->pts / 90000.0,
1080 scr / 90000.0, best_i);
1081 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1082 timestamp_packet->dts, scr, trailer_size);
1084 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1085 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1090 /* Write one or more padding sectors, if necessary, to reach
1091 * the constant overall bitrate. */
1094 // FIXME: pts cannot be correct here
1095 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1096 put_vcd_padding_sector(ctx);
1097 // FIXME: rounding and first few bytes of each packet
1098 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1102 stream->buffer_index += es_size;
1103 // FIXME: rounding and first few bytes of each packet
1104 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1106 while (stream->premux_packet &&
1107 stream->premux_packet->unwritten_size <= es_size) {
1108 es_size -= stream->premux_packet->unwritten_size;
1109 stream->premux_packet = stream->premux_packet->next;
1112 av_assert0(stream->premux_packet);
1113 stream->premux_packet->unwritten_size -= es_size;
1116 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1122 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1124 int stream_index = pkt->stream_index;
1125 int size = pkt->size;
1126 uint8_t *buf = pkt->data;
1127 MpegMuxContext *s = ctx->priv_data;
1128 AVStream *st = ctx->streams[stream_index];
1129 StreamInfo *stream = st->priv_data;
1131 PacketDesc *pkt_desc;
1133 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1134 (pkt->flags & AV_PKT_FLAG_KEY);
1136 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1141 if (s->last_scr == AV_NOPTS_VALUE) {
1142 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1143 if (dts != AV_NOPTS_VALUE)
1144 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1147 s->last_scr = dts - preload;
1150 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1151 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1154 if (dts != AV_NOPTS_VALUE) dts += preload;
1155 if (pts != AV_NOPTS_VALUE) pts += preload;
1157 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1158 dts / 90000.0, pts / 90000.0, pkt->flags,
1159 pkt->stream_index, pts != AV_NOPTS_VALUE);
1160 if (!stream->premux_packet)
1161 stream->next_packet = &stream->premux_packet;
1162 *stream->next_packet =
1163 pkt_desc = av_mallocz(sizeof(PacketDesc));
1165 return AVERROR(ENOMEM);
1166 pkt_desc->pts = pts;
1167 pkt_desc->dts = dts;
1169 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
1171 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
1172 return AVERROR(EINVAL);
1175 /* Skip first 3 bytes of packet data, which comprise PCM header
1176 and will be written fresh by this muxer. */
1181 pkt_desc->unwritten_size =
1182 pkt_desc->size = size;
1183 if (!stream->predecode_packet)
1184 stream->predecode_packet = pkt_desc;
1185 stream->next_packet = &pkt_desc->next;
1187 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1191 // min VOBU length 0.4 seconds (mpucoder)
1193 (s->packet_number == 0 ||
1194 (pts - stream->vobu_start_pts >= 36000))) {
1195 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1196 stream->align_iframe = 1;
1197 stream->vobu_start_pts = pts;
1201 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1204 int ret = output_packet(ctx, 0);
1210 static int mpeg_mux_end(AVFormatContext *ctx)
1216 int ret = output_packet(ctx, 1);
1223 /* End header according to MPEG-1 systems standard. We do not write
1224 * it as it is usually not needed by decoders and because it
1225 * complicates MPEG stream concatenation. */
1226 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1227 // avio_flush(ctx->pb);
1229 for (i = 0; i < ctx->nb_streams; i++) {
1230 stream = ctx->streams[i]->priv_data;
1232 av_assert0(av_fifo_size(stream->fifo) == 0);
1233 av_fifo_freep(&stream->fifo);
1238 #define OFFSET(x) offsetof(MpegMuxContext, x)
1239 #define E AV_OPT_FLAG_ENCODING_PARAM
1240 static const AVOption options[] = {
1241 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1242 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1246 #define MPEGENC_CLASS(flavor) \
1247 static const AVClass flavor ## _class = { \
1248 .class_name = #flavor " muxer", \
1249 .item_name = av_default_item_name, \
1250 .version = LIBAVUTIL_VERSION_INT, \
1251 .option = options, \
1254 #if CONFIG_MPEG1SYSTEM_MUXER
1256 AVOutputFormat ff_mpeg1system_muxer = {
1258 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1259 .mime_type = "video/mpeg",
1260 .extensions = "mpg,mpeg",
1261 .priv_data_size = sizeof(MpegMuxContext),
1262 .audio_codec = AV_CODEC_ID_MP2,
1263 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1264 .write_header = mpeg_mux_init,
1265 .write_packet = mpeg_mux_write_packet,
1266 .write_trailer = mpeg_mux_end,
1267 .priv_class = &mpeg_class,
1271 #if CONFIG_MPEG1VCD_MUXER
1273 AVOutputFormat ff_mpeg1vcd_muxer = {
1275 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1276 .mime_type = "video/mpeg",
1277 .priv_data_size = sizeof(MpegMuxContext),
1278 .audio_codec = AV_CODEC_ID_MP2,
1279 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1280 .write_header = mpeg_mux_init,
1281 .write_packet = mpeg_mux_write_packet,
1282 .write_trailer = mpeg_mux_end,
1283 .priv_class = &vcd_class,
1287 #if CONFIG_MPEG2VOB_MUXER
1289 AVOutputFormat ff_mpeg2vob_muxer = {
1291 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1292 .mime_type = "video/mpeg",
1293 .extensions = "vob",
1294 .priv_data_size = sizeof(MpegMuxContext),
1295 .audio_codec = AV_CODEC_ID_MP2,
1296 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1297 .write_header = mpeg_mux_init,
1298 .write_packet = mpeg_mux_write_packet,
1299 .write_trailer = mpeg_mux_end,
1300 .priv_class = &vob_class,
1304 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1305 #if CONFIG_MPEG2SVCD_MUXER
1307 AVOutputFormat ff_mpeg2svcd_muxer = {
1309 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1310 .mime_type = "video/mpeg",
1311 .extensions = "vob",
1312 .priv_data_size = sizeof(MpegMuxContext),
1313 .audio_codec = AV_CODEC_ID_MP2,
1314 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1315 .write_header = mpeg_mux_init,
1316 .write_packet = mpeg_mux_write_packet,
1317 .write_trailer = mpeg_mux_end,
1318 .priv_class = &svcd_class,
1322 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1323 #if CONFIG_MPEG2DVD_MUXER
1325 AVOutputFormat ff_mpeg2dvd_muxer = {
1327 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1328 .mime_type = "video/mpeg",
1329 .extensions = "dvd",
1330 .priv_data_size = sizeof(MpegMuxContext),
1331 .audio_codec = AV_CODEC_ID_MP2,
1332 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1333 .write_header = mpeg_mux_init,
1334 .write_packet = mpeg_mux_write_packet,
1335 .write_trailer = mpeg_mux_end,
1336 .priv_class = &dvd_class,