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",
318 return AVERROR(EINVAL);
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));
346 return AVERROR(ENOMEM);
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 stream->id = lpcm_id++;
369 for (j = 0; j < 4; j++) {
370 if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
375 av_log(ctx, AV_LOG_ERROR, "Invalid sampling rate for PCM stream.\n");
376 av_log(ctx, AV_LOG_INFO, "Allowed sampling rates:");
377 for (sr = 0; sr < 4; sr++)
378 av_log(ctx, AV_LOG_INFO, " %d", lpcm_freq_tab[sr]);
379 av_log(ctx, AV_LOG_INFO, "\n");
380 return AVERROR(EINVAL);
382 if (st->codecpar->channels > 8) {
383 av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");
384 return AVERROR(EINVAL);
386 stream->lpcm_header[0] = 0x0c;
387 stream->lpcm_header[1] = (st->codecpar->channels - 1) | (j << 4);
388 stream->lpcm_header[2] = 0x80;
389 stream->lpcm_align = st->codecpar->channels * 2;
390 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
393 switch (st->codecpar->sample_rate) {
394 case 48000: freq = 0; break;
395 case 96000: freq = 1; break;
396 case 44100: freq = 2; break;
397 case 32000: freq = 3; break;
399 av_log(ctx, AV_LOG_ERROR, "Unsupported sample rate.\n");
400 return AVERROR(EINVAL);
403 stream->lpcm_header[0] = 0x0c;
404 stream->lpcm_header[1] = (freq << 4) |
405 (((st->codecpar->bits_per_coded_sample - 16) / 4) << 6) |
406 st->codecpar->channels - 1;
407 stream->lpcm_header[2] = 0x80;
408 stream->id = lpcm_id++;
409 stream->lpcm_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample / 8;
410 } else if (st->codecpar->codec_id == AV_CODEC_ID_MLP ||
411 st->codecpar->codec_id == AV_CODEC_ID_TRUEHD) {
412 av_log(ctx, AV_LOG_ERROR, "Support for muxing audio codec %s not implemented.\n",
413 avcodec_get_name(st->codecpar->codec_id));
414 return AVERROR_PATCHWELCOME;
415 } else if (st->codecpar->codec_id != AV_CODEC_ID_MP1 &&
416 st->codecpar->codec_id != AV_CODEC_ID_MP2 &&
417 st->codecpar->codec_id != AV_CODEC_ID_MP3) {
418 av_log(ctx, AV_LOG_ERROR, "Unsupported audio codec. Must be one of mp1, mp2, mp3, 16-bit pcm_dvd, pcm_s16be, ac3 or dts.\n");
419 return AVERROR(EINVAL);
421 stream->id = mpa_id++;
424 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
425 * Right now it is also used for everything else. */
426 stream->max_buffer_size = 4 * 1024;
429 case AVMEDIA_TYPE_VIDEO:
430 if (st->codecpar->codec_id == AV_CODEC_ID_H264)
431 stream->id = h264_id++;
433 stream->id = mpv_id++;
435 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
436 if (props && props->buffer_size)
437 stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
439 av_log(ctx, AV_LOG_WARNING,
440 "VBV buffer size not set, using default size of 230KB\n"
441 "If you want the mpeg file to be compliant to some specification\n"
442 "Like DVD, VCD or others, make sure you set the correct buffer size\n");
443 // FIXME: this is probably too small as default
444 stream->max_buffer_size = 230 * 1024;
446 if (stream->max_buffer_size > 1024 * 8191) {
447 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
448 stream->max_buffer_size = 1024 * 8191;
452 case AVMEDIA_TYPE_SUBTITLE:
453 stream->id = mps_id++;
454 stream->max_buffer_size = 16 * 1024;
457 av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
458 av_get_media_type_string(st->codecpar->codec_type), i);
459 return AVERROR(EINVAL);
461 stream->fifo = av_fifo_alloc(16);
463 return AVERROR(ENOMEM);
468 for (i = 0; i < ctx->nb_streams; i++) {
469 AVCPBProperties *props;
471 st = ctx->streams[i];
472 stream = (StreamInfo *)st->priv_data;
474 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
476 codec_rate = props->max_bitrate;
478 codec_rate = st->codecpar->bit_rate;
481 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
483 bitrate += codec_rate;
485 if ((stream->id & 0xe0) == AUDIO_ID)
486 audio_bitrate += codec_rate;
487 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
488 video_bitrate += codec_rate;
491 if (s->user_mux_rate) {
492 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
494 /* we increase slightly the bitrate to take into account the
495 * headers. XXX: compute it exactly */
496 bitrate += bitrate / 20;
498 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
499 if (s->mux_rate >= (1<<22)) {
500 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
501 s->mux_rate = (1<<22) - 1;
506 int64_t overhead_rate;
508 /* The VCD standard mandates that the mux_rate field is 3528
509 * (see standard p. IV-6).
510 * The value is actually "wrong", i.e. if you calculate
511 * it using the normal formula and the 75 sectors per second transfer
512 * rate you get a different value because the real pack size is 2324,
513 * not 2352. But the standard explicitly specifies that the mux_rate
514 * field in the header must have this value. */
515 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
517 /* The VCD standard states that the muxed stream must be
518 * exactly 75 packs / second (the data rate of a single speed cdrom).
519 * Since the video bitrate (probably 1150000 bits/sec) will be below
520 * the theoretical maximum we have to add some padding packets
521 * to make up for the lower data rate.
522 * (cf. VCD standard p. IV-6 ) */
524 /* Add the header overhead to the data rate.
525 * 2279 data bytes per audio pack, 2294 data bytes per video pack */
526 overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
527 overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
529 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
530 s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
531 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)
534 if (s->is_vcd || s->is_mpeg2)
536 s->pack_header_freq = 1;
538 /* every 2 seconds */
539 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
541 /* the above seems to make pack_header_freq zero sometimes */
542 if (s->pack_header_freq == 0)
543 s->pack_header_freq = 1;
546 /* every 200 packets. Need to look at the spec. */
547 s->system_header_freq = s->pack_header_freq * 40;
549 /* the standard mandates that there are only two system headers
550 * in the whole file: one in the first packet of each stream.
551 * (see standard p. IV-7 and IV-8) */
552 s->system_header_freq = 0x7fffffff;
554 s->system_header_freq = s->pack_header_freq * 5;
556 for (i = 0; i < ctx->nb_streams; i++) {
557 stream = ctx->streams[i]->priv_data;
558 stream->packet_number = 0;
560 s->system_header_size = get_system_header_size(ctx);
561 s->last_scr = AV_NOPTS_VALUE;
565 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
567 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
568 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
569 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
572 /* return the number of padding bytes that should be inserted into
573 * the multiplexed stream. */
574 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
576 MpegMuxContext *s = ctx->priv_data;
579 if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
580 int64_t full_pad_bytes;
582 // FIXME: this is wrong
584 av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
585 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
588 /* might happen if we have already padded to a later timestamp. This
589 * can occur if another stream has already advanced further. */
596 /* Write an MPEG padding packet header. */
597 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
600 MpegMuxContext *s = ctx->priv_data;
603 avio_wb32(pb, PADDING_STREAM);
604 avio_wb16(pb, packet_bytes - 6);
611 for (i = 0; i < packet_bytes; i++)
615 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
618 PacketDesc *pkt_desc = stream->premux_packet;
621 if (pkt_desc->size == pkt_desc->unwritten_size)
623 len -= pkt_desc->unwritten_size;
624 pkt_desc = pkt_desc->next;
630 /* flush the packet on stream stream_index */
631 static int flush_packet(AVFormatContext *ctx, int stream_index,
632 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
634 MpegMuxContext *s = ctx->priv_data;
635 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
637 int size, payload_size, startcode, id, stuffing_size, i, header_len;
640 int zero_trail_bytes = 0;
641 int pad_packet_bytes = 0;
643 /* "general" pack without data specific to one stream? */
644 int general_pack = 0;
649 av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
653 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
654 /* output pack and systems header if needed */
655 size = put_pack_header(ctx, buf_ptr, scr);
660 /* there is exactly one system header for each stream in a VCD MPEG,
661 * One in the very first video packet and one in the very first
662 * audio packet (see VCD standard p. IV-7 and IV-8). */
664 if (stream->packet_number == 0) {
665 size = put_system_header(ctx, buf_ptr, id);
668 } else if (s->is_dvd) {
669 if (stream->align_iframe || s->packet_number == 0) {
670 int PES_bytes_to_fill = s->packet_size - size - 10;
672 if (pts != AV_NOPTS_VALUE) {
674 PES_bytes_to_fill -= 5 + 5;
676 PES_bytes_to_fill -= 5;
679 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
680 size = put_system_header(ctx, buf_ptr, 0);
682 size = buf_ptr - buffer;
683 avio_write(ctx->pb, buffer, size);
685 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
686 avio_wb16(ctx->pb, 0x03d4); // length
687 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
688 for (i = 0; i < 979; i++)
689 avio_w8(ctx->pb, 0x00);
691 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
692 avio_wb16(ctx->pb, 0x03fa); // length
693 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
694 for (i = 0; i < 1017; i++)
695 avio_w8(ctx->pb, 0x00);
697 memset(buffer, 0, 128);
700 stream->align_iframe = 0;
701 // FIXME: rounding and first few bytes of each packet
702 scr += s->packet_size * 90000LL /
703 (s->mux_rate * 50LL);
704 size = put_pack_header(ctx, buf_ptr, scr);
708 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
709 pad_packet_bytes = PES_bytes_to_fill -
710 stream->bytes_to_iframe;
714 if ((s->packet_number % s->system_header_freq) == 0) {
715 size = put_system_header(ctx, buf_ptr, 0);
720 size = buf_ptr - buffer;
721 avio_write(ctx->pb, buffer, size);
723 packet_size = s->packet_size - size;
725 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
726 /* The VCD standard demands that 20 zero bytes follow
727 * each audio pack (see standard p. IV-8). */
728 zero_trail_bytes += 20;
730 if ((s->is_vcd && stream->packet_number == 0) ||
731 (s->is_svcd && s->packet_number == 0)) {
732 /* for VCD the first pack of each stream contains only the pack header,
733 * the system header and lots of padding (see VCD standard p. IV-6).
734 * In the case of an audio pack, 20 zero bytes are also added at
736 /* For SVCD we fill the very first pack to increase compatibility with
737 * some DVD players. Not mandated by the standard. */
739 /* the system header refers to both streams and no stream data */
741 pad_packet_bytes = packet_size - zero_trail_bytes;
744 packet_size -= pad_packet_bytes + zero_trail_bytes;
746 if (packet_size > 0) {
747 /* packet header size */
753 if (stream->packet_number == 0)
754 header_len += 3; /* PES extension */
755 header_len += 1; /* obligatory stuffing byte */
759 if (pts != AV_NOPTS_VALUE) {
769 payload_size = packet_size - header_len;
771 startcode = PRIVATE_STREAM_1;
779 startcode = 0x100 + id;
782 stuffing_size = payload_size - av_fifo_size(stream->fifo);
784 // first byte does not fit -> reset pts/dts + stuffing
785 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
786 int timestamp_len = 0;
789 if (pts != AV_NOPTS_VALUE)
790 timestamp_len += s->is_mpeg2 ? 5 : 4;
792 dts = AV_NOPTS_VALUE;
793 header_len -= timestamp_len;
794 if (s->is_dvd && stream->align_iframe) {
795 pad_packet_bytes += timestamp_len;
796 packet_size -= timestamp_len;
798 payload_size += timestamp_len;
800 stuffing_size += timestamp_len;
801 if (payload_size > trailer_size)
802 stuffing_size += payload_size - trailer_size;
805 // can't use padding, so use stuffing
806 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
807 packet_size += pad_packet_bytes;
808 payload_size += pad_packet_bytes; // undo the previous adjustment
809 if (stuffing_size < 0)
810 stuffing_size = pad_packet_bytes;
812 stuffing_size += pad_packet_bytes;
813 pad_packet_bytes = 0;
816 if (stuffing_size < 0)
819 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
820 if (payload_size < av_fifo_size(stream->fifo))
821 stuffing_size += payload_size % stream->lpcm_align;
824 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
825 pad_packet_bytes += stuffing_size;
826 packet_size -= stuffing_size;
827 payload_size -= stuffing_size;
831 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
833 avio_wb32(ctx->pb, startcode);
835 avio_wb16(ctx->pb, packet_size);
838 for (i = 0; i < stuffing_size; i++)
839 avio_w8(ctx->pb, 0xff);
842 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
846 if (pts != AV_NOPTS_VALUE) {
852 /* Both the MPEG-2 and the SVCD standards demand that the
853 * P-STD_buffer_size field be included in the first packet of
854 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
855 * and MPEG-2 standard 2.7.7) */
856 if (stream->packet_number == 0)
859 avio_w8(ctx->pb, pes_flags); /* flags */
860 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
862 if (pes_flags & 0x80) /* write pts */
863 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
864 if (pes_flags & 0x40) /* write dts */
865 put_timestamp(ctx->pb, 0x01, dts);
867 if (pes_flags & 0x01) { /* write pes extension */
868 avio_w8(ctx->pb, 0x10); /* flags */
870 /* P-STD buffer info */
871 if ((id & 0xe0) == AUDIO_ID)
872 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
874 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
877 if (pts != AV_NOPTS_VALUE) {
879 put_timestamp(ctx->pb, 0x03, pts);
880 put_timestamp(ctx->pb, 0x01, dts);
882 put_timestamp(ctx->pb, 0x02, pts);
885 avio_w8(ctx->pb, 0x0f);
890 /* special stuffing byte that is always written
891 * to prevent accidental generation of start codes. */
892 avio_w8(ctx->pb, 0xff);
894 for (i = 0; i < stuffing_size; i++)
895 avio_w8(ctx->pb, 0xff);
898 if (startcode == PRIVATE_STREAM_1) {
899 avio_w8(ctx->pb, id);
901 /* LPCM (XXX: check nb_frames) */
903 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
904 avio_w8(ctx->pb, stream->lpcm_header[0]);
905 avio_w8(ctx->pb, stream->lpcm_header[1]);
906 avio_w8(ctx->pb, stream->lpcm_header[2]);
907 } else if (id >= 0x40) {
909 avio_w8(ctx->pb, nb_frames);
910 avio_wb16(ctx->pb, trailer_size + 1);
915 av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
916 av_fifo_generic_read(stream->fifo, ctx->pb,
917 payload_size - stuffing_size,
918 (void (*)(void*, void*, int))avio_write);
919 stream->bytes_to_iframe -= payload_size - stuffing_size;
925 if (pad_packet_bytes > 0)
926 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
928 for (i = 0; i < zero_trail_bytes; i++)
929 avio_w8(ctx->pb, 0x00);
935 /* only increase the stream packet number if this pack actually contains
936 * something that is specific to this stream! I.e. a dedicated header
939 stream->packet_number++;
941 return payload_size - stuffing_size;
944 static void put_vcd_padding_sector(AVFormatContext *ctx)
946 /* There are two ways to do this padding: writing a sector/pack
947 * of 0 values, or writing an MPEG padding pack. Both seem to
948 * work with most decoders, BUT the VCD standard only allows a 0-sector
949 * (see standard p. IV-4, IV-5).
950 * So a 0-sector it is... */
952 MpegMuxContext *s = ctx->priv_data;
955 for (i = 0; i < s->packet_size; i++)
958 s->vcd_padding_bytes_written += s->packet_size;
962 /* increasing the packet number is correct. The SCR of the following packs
963 * is calculated from the packet_number and it has to include the padding
964 * sector (it represents the sector index, not the MPEG pack index)
965 * (see VCD standard p. IV-6) */
969 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
973 for (i = 0; i < ctx->nb_streams; i++) {
974 AVStream *st = ctx->streams[i];
975 StreamInfo *stream = st->priv_data;
976 PacketDesc *pkt_desc;
978 while ((pkt_desc = stream->predecode_packet) &&
979 scr > pkt_desc->dts) { // FIXME: > vs >=
980 if (stream->buffer_index < pkt_desc->size ||
981 stream->predecode_packet == stream->premux_packet) {
982 av_log(ctx, AV_LOG_ERROR,
983 "buffer underflow st=%d bufi=%d size=%d\n",
984 i, stream->buffer_index, pkt_desc->size);
987 stream->buffer_index -= pkt_desc->size;
988 stream->predecode_packet = pkt_desc->next;
996 static int output_packet(AVFormatContext *ctx, int flush)
998 MpegMuxContext *s = ctx->priv_data;
1001 int i, avail_space = 0, es_size, trailer_size;
1003 int best_score = INT_MIN;
1004 int ignore_constraints = 0;
1005 int ignore_delay = 0;
1006 int64_t scr = s->last_scr;
1007 PacketDesc *timestamp_packet;
1008 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1011 for (i = 0; i < ctx->nb_streams; i++) {
1012 AVStream *st = ctx->streams[i];
1013 StreamInfo *stream = st->priv_data;
1014 const int avail_data = av_fifo_size(stream->fifo);
1015 const int space = stream->max_buffer_size - stream->buffer_index;
1016 int rel_space = 1024LL * space / stream->max_buffer_size;
1017 PacketDesc *next_pkt = stream->premux_packet;
1019 /* for subtitle, a single PES packet must be generated,
1020 * so we flush after every single subtitle packet */
1021 if (s->packet_size > avail_data && !flush
1022 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
1024 if (avail_data == 0)
1026 av_assert0(avail_data > 0);
1028 if (space < s->packet_size && !ignore_constraints)
1031 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1033 if ( stream->predecode_packet
1034 && stream->predecode_packet->size > stream->buffer_index)
1036 if (rel_space > best_score) {
1037 best_score = rel_space;
1039 avail_space = space;
1044 int64_t best_dts = INT64_MAX;
1047 for (i = 0; i < ctx->nb_streams; i++) {
1048 AVStream *st = ctx->streams[i];
1049 StreamInfo *stream = st->priv_data;
1050 PacketDesc *pkt_desc = stream->predecode_packet;
1051 if (pkt_desc && pkt_desc->dts < best_dts)
1052 best_dts = pkt_desc->dts;
1053 has_premux |= !!stream->premux_packet;
1056 if (best_dts < INT64_MAX) {
1057 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1058 scr / 90000.0, best_dts / 90000.0);
1060 if (scr >= best_dts + 1 && !ignore_constraints) {
1061 av_log(ctx, AV_LOG_ERROR,
1062 "packet too large, ignoring buffer limits to mux it\n");
1063 ignore_constraints = 1;
1065 scr = FFMAX(best_dts + 1, scr);
1066 if (remove_decoded_packets(ctx, scr) < 0)
1068 } else if (has_premux && flush) {
1069 av_log(ctx, AV_LOG_ERROR,
1070 "delay too large, ignoring ...\n");
1072 ignore_constraints = 1;
1079 av_assert0(best_i >= 0);
1081 st = ctx->streams[best_i];
1082 stream = st->priv_data;
1084 av_assert0(av_fifo_size(stream->fifo) > 0);
1086 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1088 timestamp_packet = stream->premux_packet;
1089 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1092 trailer_size = timestamp_packet->unwritten_size;
1093 timestamp_packet = timestamp_packet->next;
1096 if (timestamp_packet) {
1097 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1098 timestamp_packet->dts / 90000.0,
1099 timestamp_packet->pts / 90000.0,
1100 scr / 90000.0, best_i);
1101 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1102 timestamp_packet->dts, scr, trailer_size);
1104 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1105 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1110 /* Write one or more padding sectors, if necessary, to reach
1111 * the constant overall bitrate. */
1114 // FIXME: pts cannot be correct here
1115 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1116 put_vcd_padding_sector(ctx);
1117 // FIXME: rounding and first few bytes of each packet
1118 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1122 stream->buffer_index += es_size;
1123 // FIXME: rounding and first few bytes of each packet
1124 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1126 while (stream->premux_packet &&
1127 stream->premux_packet->unwritten_size <= es_size) {
1128 es_size -= stream->premux_packet->unwritten_size;
1129 stream->premux_packet = stream->premux_packet->next;
1132 av_assert0(stream->premux_packet);
1133 stream->premux_packet->unwritten_size -= es_size;
1136 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1142 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1144 int stream_index = pkt->stream_index;
1145 int size = pkt->size;
1146 uint8_t *buf = pkt->data;
1147 MpegMuxContext *s = ctx->priv_data;
1148 AVStream *st = ctx->streams[stream_index];
1149 StreamInfo *stream = st->priv_data;
1151 PacketDesc *pkt_desc;
1153 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1154 (pkt->flags & AV_PKT_FLAG_KEY);
1156 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1161 if (s->last_scr == AV_NOPTS_VALUE) {
1162 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1163 if (dts != AV_NOPTS_VALUE)
1164 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1167 s->last_scr = dts - preload;
1170 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1171 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1174 if (dts != AV_NOPTS_VALUE) dts += preload;
1175 if (pts != AV_NOPTS_VALUE) pts += preload;
1177 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1178 dts / 90000.0, pts / 90000.0, pkt->flags,
1179 pkt->stream_index, pts != AV_NOPTS_VALUE);
1180 if (!stream->premux_packet)
1181 stream->next_packet = &stream->premux_packet;
1182 *stream->next_packet =
1183 pkt_desc = av_mallocz(sizeof(PacketDesc));
1185 return AVERROR(ENOMEM);
1186 pkt_desc->pts = pts;
1187 pkt_desc->dts = dts;
1189 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
1191 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
1192 return AVERROR(EINVAL);
1195 /* Skip first 3 bytes of packet data, which comprise PCM header
1196 and will be written fresh by this muxer. */
1201 pkt_desc->unwritten_size =
1202 pkt_desc->size = size;
1203 if (!stream->predecode_packet)
1204 stream->predecode_packet = pkt_desc;
1205 stream->next_packet = &pkt_desc->next;
1207 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1211 // min VOBU length 0.4 seconds (mpucoder)
1213 (s->packet_number == 0 ||
1214 (pts - stream->vobu_start_pts >= 36000))) {
1215 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1216 stream->align_iframe = 1;
1217 stream->vobu_start_pts = pts;
1221 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1224 int ret = output_packet(ctx, 0);
1230 static int mpeg_mux_end(AVFormatContext *ctx)
1236 int ret = output_packet(ctx, 1);
1243 /* End header according to MPEG-1 systems standard. We do not write
1244 * it as it is usually not needed by decoders and because it
1245 * complicates MPEG stream concatenation. */
1246 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1247 // avio_flush(ctx->pb);
1249 for (i = 0; i < ctx->nb_streams; i++) {
1250 stream = ctx->streams[i]->priv_data;
1252 av_assert0(av_fifo_size(stream->fifo) == 0);
1257 static void mpeg_mux_deinit(AVFormatContext *ctx)
1259 for (int i = 0; i < ctx->nb_streams; i++) {
1260 StreamInfo *stream = ctx->streams[i]->priv_data;
1263 av_fifo_freep(&stream->fifo);
1267 #define OFFSET(x) offsetof(MpegMuxContext, x)
1268 #define E AV_OPT_FLAG_ENCODING_PARAM
1269 static const AVOption options[] = {
1270 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1271 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1275 #define MPEGENC_CLASS(flavor) \
1276 static const AVClass flavor ## _class = { \
1277 .class_name = #flavor " muxer", \
1278 .item_name = av_default_item_name, \
1279 .version = LIBAVUTIL_VERSION_INT, \
1280 .option = options, \
1283 #if CONFIG_MPEG1SYSTEM_MUXER
1285 AVOutputFormat ff_mpeg1system_muxer = {
1287 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1288 .mime_type = "video/mpeg",
1289 .extensions = "mpg,mpeg",
1290 .priv_data_size = sizeof(MpegMuxContext),
1291 .audio_codec = AV_CODEC_ID_MP2,
1292 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1293 .write_header = mpeg_mux_init,
1294 .write_packet = mpeg_mux_write_packet,
1295 .write_trailer = mpeg_mux_end,
1296 .deinit = mpeg_mux_deinit,
1297 .priv_class = &mpeg_class,
1301 #if CONFIG_MPEG1VCD_MUXER
1303 AVOutputFormat ff_mpeg1vcd_muxer = {
1305 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1306 .mime_type = "video/mpeg",
1307 .priv_data_size = sizeof(MpegMuxContext),
1308 .audio_codec = AV_CODEC_ID_MP2,
1309 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1310 .write_header = mpeg_mux_init,
1311 .write_packet = mpeg_mux_write_packet,
1312 .write_trailer = mpeg_mux_end,
1313 .deinit = mpeg_mux_deinit,
1314 .priv_class = &vcd_class,
1318 #if CONFIG_MPEG2VOB_MUXER
1320 AVOutputFormat ff_mpeg2vob_muxer = {
1322 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1323 .mime_type = "video/mpeg",
1324 .extensions = "vob",
1325 .priv_data_size = sizeof(MpegMuxContext),
1326 .audio_codec = AV_CODEC_ID_MP2,
1327 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1328 .write_header = mpeg_mux_init,
1329 .write_packet = mpeg_mux_write_packet,
1330 .write_trailer = mpeg_mux_end,
1331 .deinit = mpeg_mux_deinit,
1332 .priv_class = &vob_class,
1336 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1337 #if CONFIG_MPEG2SVCD_MUXER
1339 AVOutputFormat ff_mpeg2svcd_muxer = {
1341 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1342 .mime_type = "video/mpeg",
1343 .extensions = "vob",
1344 .priv_data_size = sizeof(MpegMuxContext),
1345 .audio_codec = AV_CODEC_ID_MP2,
1346 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1347 .write_header = mpeg_mux_init,
1348 .write_packet = mpeg_mux_write_packet,
1349 .write_trailer = mpeg_mux_end,
1350 .deinit = mpeg_mux_deinit,
1351 .priv_class = &svcd_class,
1355 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1356 #if CONFIG_MPEG2DVD_MUXER
1358 AVOutputFormat ff_mpeg2dvd_muxer = {
1360 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1361 .mime_type = "video/mpeg",
1362 .extensions = "dvd",
1363 .priv_data_size = sizeof(MpegMuxContext),
1364 .audio_codec = AV_CODEC_ID_MP2,
1365 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1366 .write_header = mpeg_mux_init,
1367 .write_packet = mpeg_mux_write_packet,
1368 .write_trailer = mpeg_mux_end,
1369 .deinit = mpeg_mux_deinit,
1370 .priv_class = &dvd_class,