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; /* start of packet queue */
52 PacketDesc *last_packet; /* end of packet queue */
53 PacketDesc *premux_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);
931 avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
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;
960 avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
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;
989 if (!stream->predecode_packet)
990 stream->last_packet = NULL;
998 static int output_packet(AVFormatContext *ctx, int flush)
1000 MpegMuxContext *s = ctx->priv_data;
1003 int i, avail_space = 0, es_size, trailer_size;
1005 int best_score = INT_MIN;
1006 int ignore_constraints = 0;
1007 int ignore_delay = 0;
1008 int64_t scr = s->last_scr;
1009 PacketDesc *timestamp_packet;
1010 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1013 for (i = 0; i < ctx->nb_streams; i++) {
1014 AVStream *st = ctx->streams[i];
1015 StreamInfo *stream = st->priv_data;
1016 const int avail_data = av_fifo_size(stream->fifo);
1017 const int space = stream->max_buffer_size - stream->buffer_index;
1018 int rel_space = 1024LL * space / stream->max_buffer_size;
1019 PacketDesc *next_pkt = stream->premux_packet;
1021 /* for subtitle, a single PES packet must be generated,
1022 * so we flush after every single subtitle packet */
1023 if (s->packet_size > avail_data && !flush
1024 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
1026 if (avail_data == 0)
1028 av_assert0(avail_data > 0);
1030 if (space < s->packet_size && !ignore_constraints)
1033 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1035 if ( stream->predecode_packet
1036 && stream->predecode_packet->size > stream->buffer_index)
1038 if (rel_space > best_score) {
1039 best_score = rel_space;
1041 avail_space = space;
1046 int64_t best_dts = INT64_MAX;
1049 for (i = 0; i < ctx->nb_streams; i++) {
1050 AVStream *st = ctx->streams[i];
1051 StreamInfo *stream = st->priv_data;
1052 PacketDesc *pkt_desc = stream->predecode_packet;
1053 if (pkt_desc && pkt_desc->dts < best_dts)
1054 best_dts = pkt_desc->dts;
1055 has_premux |= !!stream->premux_packet;
1058 if (best_dts < INT64_MAX) {
1059 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1060 scr / 90000.0, best_dts / 90000.0);
1062 if (scr >= best_dts + 1 && !ignore_constraints) {
1063 av_log(ctx, AV_LOG_ERROR,
1064 "packet too large, ignoring buffer limits to mux it\n");
1065 ignore_constraints = 1;
1067 scr = FFMAX(best_dts + 1, scr);
1068 if (remove_decoded_packets(ctx, scr) < 0)
1070 } else if (has_premux && flush) {
1071 av_log(ctx, AV_LOG_ERROR,
1072 "delay too large, ignoring ...\n");
1074 ignore_constraints = 1;
1081 av_assert0(best_i >= 0);
1083 st = ctx->streams[best_i];
1084 stream = st->priv_data;
1086 av_assert0(av_fifo_size(stream->fifo) > 0);
1088 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1090 timestamp_packet = stream->premux_packet;
1091 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1094 trailer_size = timestamp_packet->unwritten_size;
1095 timestamp_packet = timestamp_packet->next;
1098 if (timestamp_packet) {
1099 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1100 timestamp_packet->dts / 90000.0,
1101 timestamp_packet->pts / 90000.0,
1102 scr / 90000.0, best_i);
1103 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1104 timestamp_packet->dts, scr, trailer_size);
1106 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1107 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1112 /* Write one or more padding sectors, if necessary, to reach
1113 * the constant overall bitrate. */
1116 // FIXME: pts cannot be correct here
1117 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1118 put_vcd_padding_sector(ctx);
1119 // FIXME: rounding and first few bytes of each packet
1120 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1124 stream->buffer_index += es_size;
1125 // FIXME: rounding and first few bytes of each packet
1126 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1128 while (stream->premux_packet &&
1129 stream->premux_packet->unwritten_size <= es_size) {
1130 es_size -= stream->premux_packet->unwritten_size;
1131 stream->premux_packet = stream->premux_packet->next;
1134 av_assert0(stream->premux_packet);
1135 stream->premux_packet->unwritten_size -= es_size;
1138 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1144 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1146 int stream_index = pkt->stream_index;
1147 int size = pkt->size;
1148 uint8_t *buf = pkt->data;
1149 MpegMuxContext *s = ctx->priv_data;
1150 AVStream *st = ctx->streams[stream_index];
1151 StreamInfo *stream = st->priv_data;
1153 PacketDesc *pkt_desc;
1155 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1156 (pkt->flags & AV_PKT_FLAG_KEY);
1158 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1163 if (s->last_scr == AV_NOPTS_VALUE) {
1164 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1165 if (dts != AV_NOPTS_VALUE)
1166 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1169 s->last_scr = dts - preload;
1172 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1173 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1176 if (dts != AV_NOPTS_VALUE) dts += preload;
1177 if (pts != AV_NOPTS_VALUE) pts += preload;
1179 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1180 dts / 90000.0, pts / 90000.0, pkt->flags,
1181 pkt->stream_index, pts != AV_NOPTS_VALUE);
1183 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
1185 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
1186 return AVERROR(EINVAL);
1189 /* Skip first 3 bytes of packet data, which comprise PCM header
1190 and will be written fresh by this muxer. */
1195 pkt_desc = av_mallocz(sizeof(PacketDesc));
1197 return AVERROR(ENOMEM);
1198 if (!stream->predecode_packet) {
1199 stream->predecode_packet = pkt_desc;
1201 stream->last_packet->next = pkt_desc;
1202 stream->last_packet = pkt_desc;
1203 if (!stream->premux_packet)
1204 stream->premux_packet = pkt_desc;
1205 pkt_desc->pts = pts;
1206 pkt_desc->dts = dts;
1207 pkt_desc->unwritten_size =
1208 pkt_desc->size = size;
1210 ret = av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size);
1215 // min VOBU length 0.4 seconds (mpucoder)
1217 (s->packet_number == 0 || pts != AV_NOPTS_VALUE &&
1218 (pts - stream->vobu_start_pts >= 36000))) {
1219 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1220 stream->align_iframe = 1;
1221 stream->vobu_start_pts = pts;
1225 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1228 int ret = output_packet(ctx, 0);
1234 static int mpeg_mux_end(AVFormatContext *ctx)
1240 int ret = output_packet(ctx, 1);
1247 /* End header according to MPEG-1 systems standard. We do not write
1248 * it as it is usually not needed by decoders and because it
1249 * complicates MPEG stream concatenation. */
1250 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1252 for (i = 0; i < ctx->nb_streams; i++) {
1253 stream = ctx->streams[i]->priv_data;
1255 av_assert0(av_fifo_size(stream->fifo) == 0);
1260 static void mpeg_mux_deinit(AVFormatContext *ctx)
1262 for (int i = 0; i < ctx->nb_streams; i++) {
1263 StreamInfo *stream = ctx->streams[i]->priv_data;
1266 for (PacketDesc *pkt = stream->predecode_packet; pkt; ) {
1267 PacketDesc *tmp = pkt->next;
1271 av_fifo_freep(&stream->fifo);
1275 #define OFFSET(x) offsetof(MpegMuxContext, x)
1276 #define E AV_OPT_FLAG_ENCODING_PARAM
1277 static const AVOption options[] = {
1278 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1279 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1283 #define MPEGENC_CLASS(flavor) \
1284 static const AVClass flavor ## _class = { \
1285 .class_name = #flavor " muxer", \
1286 .item_name = av_default_item_name, \
1287 .version = LIBAVUTIL_VERSION_INT, \
1288 .option = options, \
1291 #if CONFIG_MPEG1SYSTEM_MUXER
1293 AVOutputFormat ff_mpeg1system_muxer = {
1295 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1296 .mime_type = "video/mpeg",
1297 .extensions = "mpg,mpeg",
1298 .priv_data_size = sizeof(MpegMuxContext),
1299 .audio_codec = AV_CODEC_ID_MP2,
1300 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1301 .write_header = mpeg_mux_init,
1302 .write_packet = mpeg_mux_write_packet,
1303 .write_trailer = mpeg_mux_end,
1304 .deinit = mpeg_mux_deinit,
1305 .priv_class = &mpeg_class,
1309 #if CONFIG_MPEG1VCD_MUXER
1311 AVOutputFormat ff_mpeg1vcd_muxer = {
1313 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1314 .mime_type = "video/mpeg",
1315 .priv_data_size = sizeof(MpegMuxContext),
1316 .audio_codec = AV_CODEC_ID_MP2,
1317 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1318 .write_header = mpeg_mux_init,
1319 .write_packet = mpeg_mux_write_packet,
1320 .write_trailer = mpeg_mux_end,
1321 .deinit = mpeg_mux_deinit,
1322 .priv_class = &vcd_class,
1326 #if CONFIG_MPEG2VOB_MUXER
1328 AVOutputFormat ff_mpeg2vob_muxer = {
1330 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1331 .mime_type = "video/mpeg",
1332 .extensions = "vob",
1333 .priv_data_size = sizeof(MpegMuxContext),
1334 .audio_codec = AV_CODEC_ID_MP2,
1335 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1336 .write_header = mpeg_mux_init,
1337 .write_packet = mpeg_mux_write_packet,
1338 .write_trailer = mpeg_mux_end,
1339 .deinit = mpeg_mux_deinit,
1340 .priv_class = &vob_class,
1344 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1345 #if CONFIG_MPEG2SVCD_MUXER
1347 AVOutputFormat ff_mpeg2svcd_muxer = {
1349 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1350 .mime_type = "video/mpeg",
1351 .extensions = "vob",
1352 .priv_data_size = sizeof(MpegMuxContext),
1353 .audio_codec = AV_CODEC_ID_MP2,
1354 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1355 .write_header = mpeg_mux_init,
1356 .write_packet = mpeg_mux_write_packet,
1357 .write_trailer = mpeg_mux_end,
1358 .deinit = mpeg_mux_deinit,
1359 .priv_class = &svcd_class,
1363 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1364 #if CONFIG_MPEG2DVD_MUXER
1366 AVOutputFormat ff_mpeg2dvd_muxer = {
1368 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1369 .mime_type = "video/mpeg",
1370 .extensions = "dvd",
1371 .priv_data_size = sizeof(MpegMuxContext),
1372 .audio_codec = AV_CODEC_ID_MP2,
1373 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1374 .write_header = mpeg_mux_init,
1375 .write_packet = mpeg_mux_write_packet,
1376 .write_trailer = mpeg_mux_end,
1377 .deinit = mpeg_mux_deinit,
1378 .priv_class = &dvd_class,