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 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");
382 if (st->codecpar->channels > 8) {
383 av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");
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");
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);
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 for (i = 0; i < ctx->nb_streams; i++)
566 av_freep(&ctx->streams[i]->priv_data);
567 return AVERROR(ENOMEM);
570 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
572 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
573 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
574 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
577 /* return the number of padding bytes that should be inserted into
578 * the multiplexed stream. */
579 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
581 MpegMuxContext *s = ctx->priv_data;
584 if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
585 int64_t full_pad_bytes;
587 // FIXME: this is wrong
589 av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
590 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
593 /* might happen if we have already padded to a later timestamp. This
594 * can occur if another stream has already advanced further. */
601 /* Write an MPEG padding packet header. */
602 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
605 MpegMuxContext *s = ctx->priv_data;
608 avio_wb32(pb, PADDING_STREAM);
609 avio_wb16(pb, packet_bytes - 6);
616 for (i = 0; i < packet_bytes; i++)
620 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
623 PacketDesc *pkt_desc = stream->premux_packet;
626 if (pkt_desc->size == pkt_desc->unwritten_size)
628 len -= pkt_desc->unwritten_size;
629 pkt_desc = pkt_desc->next;
635 /* flush the packet on stream stream_index */
636 static int flush_packet(AVFormatContext *ctx, int stream_index,
637 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
639 MpegMuxContext *s = ctx->priv_data;
640 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
642 int size, payload_size, startcode, id, stuffing_size, i, header_len;
645 int zero_trail_bytes = 0;
646 int pad_packet_bytes = 0;
648 /* "general" pack without data specific to one stream? */
649 int general_pack = 0;
654 av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
658 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
659 /* output pack and systems header if needed */
660 size = put_pack_header(ctx, buf_ptr, scr);
665 /* there is exactly one system header for each stream in a VCD MPEG,
666 * One in the very first video packet and one in the very first
667 * audio packet (see VCD standard p. IV-7 and IV-8). */
669 if (stream->packet_number == 0) {
670 size = put_system_header(ctx, buf_ptr, id);
673 } else if (s->is_dvd) {
674 if (stream->align_iframe || s->packet_number == 0) {
675 int PES_bytes_to_fill = s->packet_size - size - 10;
677 if (pts != AV_NOPTS_VALUE) {
679 PES_bytes_to_fill -= 5 + 5;
681 PES_bytes_to_fill -= 5;
684 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
685 size = put_system_header(ctx, buf_ptr, 0);
687 size = buf_ptr - buffer;
688 avio_write(ctx->pb, buffer, size);
690 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
691 avio_wb16(ctx->pb, 0x03d4); // length
692 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
693 for (i = 0; i < 979; i++)
694 avio_w8(ctx->pb, 0x00);
696 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
697 avio_wb16(ctx->pb, 0x03fa); // length
698 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
699 for (i = 0; i < 1017; i++)
700 avio_w8(ctx->pb, 0x00);
702 memset(buffer, 0, 128);
705 stream->align_iframe = 0;
706 // FIXME: rounding and first few bytes of each packet
707 scr += s->packet_size * 90000LL /
708 (s->mux_rate * 50LL);
709 size = put_pack_header(ctx, buf_ptr, scr);
713 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
714 pad_packet_bytes = PES_bytes_to_fill -
715 stream->bytes_to_iframe;
719 if ((s->packet_number % s->system_header_freq) == 0) {
720 size = put_system_header(ctx, buf_ptr, 0);
725 size = buf_ptr - buffer;
726 avio_write(ctx->pb, buffer, size);
728 packet_size = s->packet_size - size;
730 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
731 /* The VCD standard demands that 20 zero bytes follow
732 * each audio pack (see standard p. IV-8). */
733 zero_trail_bytes += 20;
735 if ((s->is_vcd && stream->packet_number == 0) ||
736 (s->is_svcd && s->packet_number == 0)) {
737 /* for VCD the first pack of each stream contains only the pack header,
738 * the system header and lots of padding (see VCD standard p. IV-6).
739 * In the case of an audio pack, 20 zero bytes are also added at
741 /* For SVCD we fill the very first pack to increase compatibility with
742 * some DVD players. Not mandated by the standard. */
744 /* the system header refers to both streams and no stream data */
746 pad_packet_bytes = packet_size - zero_trail_bytes;
749 packet_size -= pad_packet_bytes + zero_trail_bytes;
751 if (packet_size > 0) {
752 /* packet header size */
758 if (stream->packet_number == 0)
759 header_len += 3; /* PES extension */
760 header_len += 1; /* obligatory stuffing byte */
764 if (pts != AV_NOPTS_VALUE) {
774 payload_size = packet_size - header_len;
776 startcode = PRIVATE_STREAM_1;
784 startcode = 0x100 + id;
787 stuffing_size = payload_size - av_fifo_size(stream->fifo);
789 // first byte does not fit -> reset pts/dts + stuffing
790 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
791 int timestamp_len = 0;
794 if (pts != AV_NOPTS_VALUE)
795 timestamp_len += s->is_mpeg2 ? 5 : 4;
797 dts = AV_NOPTS_VALUE;
798 header_len -= timestamp_len;
799 if (s->is_dvd && stream->align_iframe) {
800 pad_packet_bytes += timestamp_len;
801 packet_size -= timestamp_len;
803 payload_size += timestamp_len;
805 stuffing_size += timestamp_len;
806 if (payload_size > trailer_size)
807 stuffing_size += payload_size - trailer_size;
810 // can't use padding, so use stuffing
811 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
812 packet_size += pad_packet_bytes;
813 payload_size += pad_packet_bytes; // undo the previous adjustment
814 if (stuffing_size < 0)
815 stuffing_size = pad_packet_bytes;
817 stuffing_size += pad_packet_bytes;
818 pad_packet_bytes = 0;
821 if (stuffing_size < 0)
824 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
825 if (payload_size < av_fifo_size(stream->fifo))
826 stuffing_size += payload_size % stream->lpcm_align;
829 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
830 pad_packet_bytes += stuffing_size;
831 packet_size -= stuffing_size;
832 payload_size -= stuffing_size;
836 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
838 avio_wb32(ctx->pb, startcode);
840 avio_wb16(ctx->pb, packet_size);
843 for (i = 0; i < stuffing_size; i++)
844 avio_w8(ctx->pb, 0xff);
847 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
851 if (pts != AV_NOPTS_VALUE) {
857 /* Both the MPEG-2 and the SVCD standards demand that the
858 * P-STD_buffer_size field be included in the first packet of
859 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
860 * and MPEG-2 standard 2.7.7) */
861 if (stream->packet_number == 0)
864 avio_w8(ctx->pb, pes_flags); /* flags */
865 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
867 if (pes_flags & 0x80) /* write pts */
868 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
869 if (pes_flags & 0x40) /* write dts */
870 put_timestamp(ctx->pb, 0x01, dts);
872 if (pes_flags & 0x01) { /* write pes extension */
873 avio_w8(ctx->pb, 0x10); /* flags */
875 /* P-STD buffer info */
876 if ((id & 0xe0) == AUDIO_ID)
877 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
879 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
882 if (pts != AV_NOPTS_VALUE) {
884 put_timestamp(ctx->pb, 0x03, pts);
885 put_timestamp(ctx->pb, 0x01, dts);
887 put_timestamp(ctx->pb, 0x02, pts);
890 avio_w8(ctx->pb, 0x0f);
895 /* special stuffing byte that is always written
896 * to prevent accidental generation of start codes. */
897 avio_w8(ctx->pb, 0xff);
899 for (i = 0; i < stuffing_size; i++)
900 avio_w8(ctx->pb, 0xff);
903 if (startcode == PRIVATE_STREAM_1) {
904 avio_w8(ctx->pb, id);
906 /* LPCM (XXX: check nb_frames) */
908 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
909 avio_w8(ctx->pb, stream->lpcm_header[0]);
910 avio_w8(ctx->pb, stream->lpcm_header[1]);
911 avio_w8(ctx->pb, stream->lpcm_header[2]);
912 } else if (id >= 0x40) {
914 avio_w8(ctx->pb, nb_frames);
915 avio_wb16(ctx->pb, trailer_size + 1);
920 av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
921 av_fifo_generic_read(stream->fifo, ctx->pb,
922 payload_size - stuffing_size,
923 (void (*)(void*, void*, int))avio_write);
924 stream->bytes_to_iframe -= payload_size - stuffing_size;
930 if (pad_packet_bytes > 0)
931 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
933 for (i = 0; i < zero_trail_bytes; i++)
934 avio_w8(ctx->pb, 0x00);
940 /* only increase the stream packet number if this pack actually contains
941 * something that is specific to this stream! I.e. a dedicated header
944 stream->packet_number++;
946 return payload_size - stuffing_size;
949 static void put_vcd_padding_sector(AVFormatContext *ctx)
951 /* There are two ways to do this padding: writing a sector/pack
952 * of 0 values, or writing an MPEG padding pack. Both seem to
953 * work with most decoders, BUT the VCD standard only allows a 0-sector
954 * (see standard p. IV-4, IV-5).
955 * So a 0-sector it is... */
957 MpegMuxContext *s = ctx->priv_data;
960 for (i = 0; i < s->packet_size; i++)
963 s->vcd_padding_bytes_written += s->packet_size;
967 /* increasing the packet number is correct. The SCR of the following packs
968 * is calculated from the packet_number and it has to include the padding
969 * sector (it represents the sector index, not the MPEG pack index)
970 * (see VCD standard p. IV-6) */
974 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
978 for (i = 0; i < ctx->nb_streams; i++) {
979 AVStream *st = ctx->streams[i];
980 StreamInfo *stream = st->priv_data;
981 PacketDesc *pkt_desc;
983 while ((pkt_desc = stream->predecode_packet) &&
984 scr > pkt_desc->dts) { // FIXME: > vs >=
985 if (stream->buffer_index < pkt_desc->size ||
986 stream->predecode_packet == stream->premux_packet) {
987 av_log(ctx, AV_LOG_ERROR,
988 "buffer underflow st=%d bufi=%d size=%d\n",
989 i, stream->buffer_index, pkt_desc->size);
992 stream->buffer_index -= pkt_desc->size;
993 stream->predecode_packet = pkt_desc->next;
1001 static int output_packet(AVFormatContext *ctx, int flush)
1003 MpegMuxContext *s = ctx->priv_data;
1006 int i, avail_space = 0, es_size, trailer_size;
1008 int best_score = INT_MIN;
1009 int ignore_constraints = 0;
1010 int ignore_delay = 0;
1011 int64_t scr = s->last_scr;
1012 PacketDesc *timestamp_packet;
1013 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1016 for (i = 0; i < ctx->nb_streams; i++) {
1017 AVStream *st = ctx->streams[i];
1018 StreamInfo *stream = st->priv_data;
1019 const int avail_data = av_fifo_size(stream->fifo);
1020 const int space = stream->max_buffer_size - stream->buffer_index;
1021 int rel_space = 1024LL * space / stream->max_buffer_size;
1022 PacketDesc *next_pkt = stream->premux_packet;
1024 /* for subtitle, a single PES packet must be generated,
1025 * so we flush after every single subtitle packet */
1026 if (s->packet_size > avail_data && !flush
1027 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
1029 if (avail_data == 0)
1031 av_assert0(avail_data > 0);
1033 if (space < s->packet_size && !ignore_constraints)
1036 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1038 if ( stream->predecode_packet
1039 && stream->predecode_packet->size > stream->buffer_index)
1041 if (rel_space > best_score) {
1042 best_score = rel_space;
1044 avail_space = space;
1049 int64_t best_dts = INT64_MAX;
1052 for (i = 0; i < ctx->nb_streams; i++) {
1053 AVStream *st = ctx->streams[i];
1054 StreamInfo *stream = st->priv_data;
1055 PacketDesc *pkt_desc = stream->predecode_packet;
1056 if (pkt_desc && pkt_desc->dts < best_dts)
1057 best_dts = pkt_desc->dts;
1058 has_premux |= !!stream->premux_packet;
1061 if (best_dts < INT64_MAX) {
1062 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1063 scr / 90000.0, best_dts / 90000.0);
1065 if (scr >= best_dts + 1 && !ignore_constraints) {
1066 av_log(ctx, AV_LOG_ERROR,
1067 "packet too large, ignoring buffer limits to mux it\n");
1068 ignore_constraints = 1;
1070 scr = FFMAX(best_dts + 1, scr);
1071 if (remove_decoded_packets(ctx, scr) < 0)
1073 } else if (has_premux && flush) {
1074 av_log(ctx, AV_LOG_ERROR,
1075 "delay too large, ignoring ...\n");
1077 ignore_constraints = 1;
1084 av_assert0(best_i >= 0);
1086 st = ctx->streams[best_i];
1087 stream = st->priv_data;
1089 av_assert0(av_fifo_size(stream->fifo) > 0);
1091 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1093 timestamp_packet = stream->premux_packet;
1094 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1097 trailer_size = timestamp_packet->unwritten_size;
1098 timestamp_packet = timestamp_packet->next;
1101 if (timestamp_packet) {
1102 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1103 timestamp_packet->dts / 90000.0,
1104 timestamp_packet->pts / 90000.0,
1105 scr / 90000.0, best_i);
1106 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1107 timestamp_packet->dts, scr, trailer_size);
1109 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1110 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1115 /* Write one or more padding sectors, if necessary, to reach
1116 * the constant overall bitrate. */
1119 // FIXME: pts cannot be correct here
1120 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1121 put_vcd_padding_sector(ctx);
1122 // FIXME: rounding and first few bytes of each packet
1123 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1127 stream->buffer_index += es_size;
1128 // FIXME: rounding and first few bytes of each packet
1129 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1131 while (stream->premux_packet &&
1132 stream->premux_packet->unwritten_size <= es_size) {
1133 es_size -= stream->premux_packet->unwritten_size;
1134 stream->premux_packet = stream->premux_packet->next;
1137 av_assert0(stream->premux_packet);
1138 stream->premux_packet->unwritten_size -= es_size;
1141 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1147 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1149 int stream_index = pkt->stream_index;
1150 int size = pkt->size;
1151 uint8_t *buf = pkt->data;
1152 MpegMuxContext *s = ctx->priv_data;
1153 AVStream *st = ctx->streams[stream_index];
1154 StreamInfo *stream = st->priv_data;
1156 PacketDesc *pkt_desc;
1158 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1159 (pkt->flags & AV_PKT_FLAG_KEY);
1161 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1166 if (s->last_scr == AV_NOPTS_VALUE) {
1167 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1168 if (dts != AV_NOPTS_VALUE)
1169 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1172 s->last_scr = dts - preload;
1175 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1176 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1179 if (dts != AV_NOPTS_VALUE) dts += preload;
1180 if (pts != AV_NOPTS_VALUE) pts += preload;
1182 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1183 dts / 90000.0, pts / 90000.0, pkt->flags,
1184 pkt->stream_index, pts != AV_NOPTS_VALUE);
1185 if (!stream->premux_packet)
1186 stream->next_packet = &stream->premux_packet;
1187 *stream->next_packet =
1188 pkt_desc = av_mallocz(sizeof(PacketDesc));
1190 return AVERROR(ENOMEM);
1191 pkt_desc->pts = pts;
1192 pkt_desc->dts = dts;
1194 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
1196 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
1197 return AVERROR(EINVAL);
1200 /* Skip first 3 bytes of packet data, which comprise PCM header
1201 and will be written fresh by this muxer. */
1206 pkt_desc->unwritten_size =
1207 pkt_desc->size = size;
1208 if (!stream->predecode_packet)
1209 stream->predecode_packet = pkt_desc;
1210 stream->next_packet = &pkt_desc->next;
1212 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1216 // min VOBU length 0.4 seconds (mpucoder)
1218 (s->packet_number == 0 ||
1219 (pts - stream->vobu_start_pts >= 36000))) {
1220 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1221 stream->align_iframe = 1;
1222 stream->vobu_start_pts = pts;
1226 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1229 int ret = output_packet(ctx, 0);
1235 static int mpeg_mux_end(AVFormatContext *ctx)
1241 int ret = output_packet(ctx, 1);
1248 /* End header according to MPEG-1 systems standard. We do not write
1249 * it as it is usually not needed by decoders and because it
1250 * complicates MPEG stream concatenation. */
1251 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1252 // avio_flush(ctx->pb);
1254 for (i = 0; i < ctx->nb_streams; i++) {
1255 stream = ctx->streams[i]->priv_data;
1257 av_assert0(av_fifo_size(stream->fifo) == 0);
1258 av_fifo_freep(&stream->fifo);
1263 #define OFFSET(x) offsetof(MpegMuxContext, x)
1264 #define E AV_OPT_FLAG_ENCODING_PARAM
1265 static const AVOption options[] = {
1266 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1267 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1271 #define MPEGENC_CLASS(flavor) \
1272 static const AVClass flavor ## _class = { \
1273 .class_name = #flavor " muxer", \
1274 .item_name = av_default_item_name, \
1275 .version = LIBAVUTIL_VERSION_INT, \
1276 .option = options, \
1279 #if CONFIG_MPEG1SYSTEM_MUXER
1281 AVOutputFormat ff_mpeg1system_muxer = {
1283 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1284 .mime_type = "video/mpeg",
1285 .extensions = "mpg,mpeg",
1286 .priv_data_size = sizeof(MpegMuxContext),
1287 .audio_codec = AV_CODEC_ID_MP2,
1288 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1289 .write_header = mpeg_mux_init,
1290 .write_packet = mpeg_mux_write_packet,
1291 .write_trailer = mpeg_mux_end,
1292 .priv_class = &mpeg_class,
1296 #if CONFIG_MPEG1VCD_MUXER
1298 AVOutputFormat ff_mpeg1vcd_muxer = {
1300 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1301 .mime_type = "video/mpeg",
1302 .priv_data_size = sizeof(MpegMuxContext),
1303 .audio_codec = AV_CODEC_ID_MP2,
1304 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1305 .write_header = mpeg_mux_init,
1306 .write_packet = mpeg_mux_write_packet,
1307 .write_trailer = mpeg_mux_end,
1308 .priv_class = &vcd_class,
1312 #if CONFIG_MPEG2VOB_MUXER
1314 AVOutputFormat ff_mpeg2vob_muxer = {
1316 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1317 .mime_type = "video/mpeg",
1318 .extensions = "vob",
1319 .priv_data_size = sizeof(MpegMuxContext),
1320 .audio_codec = AV_CODEC_ID_MP2,
1321 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1322 .write_header = mpeg_mux_init,
1323 .write_packet = mpeg_mux_write_packet,
1324 .write_trailer = mpeg_mux_end,
1325 .priv_class = &vob_class,
1329 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1330 #if CONFIG_MPEG2SVCD_MUXER
1332 AVOutputFormat ff_mpeg2svcd_muxer = {
1334 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1335 .mime_type = "video/mpeg",
1336 .extensions = "vob",
1337 .priv_data_size = sizeof(MpegMuxContext),
1338 .audio_codec = AV_CODEC_ID_MP2,
1339 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1340 .write_header = mpeg_mux_init,
1341 .write_packet = mpeg_mux_write_packet,
1342 .write_trailer = mpeg_mux_end,
1343 .priv_class = &svcd_class,
1347 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1348 #if CONFIG_MPEG2DVD_MUXER
1350 AVOutputFormat ff_mpeg2dvd_muxer = {
1352 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1353 .mime_type = "video/mpeg",
1354 .extensions = "dvd",
1355 .priv_data_size = sizeof(MpegMuxContext),
1356 .audio_codec = AV_CODEC_ID_MP2,
1357 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1358 .write_header = mpeg_mux_init,
1359 .write_packet = mpeg_mux_write_packet,
1360 .write_trailer = mpeg_mux_end,
1361 .priv_class = &dvd_class,