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 double vcd_padding_bitrate; // FIXME floats
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); /* non constrainted bit stream */
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 = 0.7*AV_TIME_BASE;
326 s->vcd_padding_bytes_written = 0;
327 s->vcd_padding_bitrate = 0;
340 for (i = 0; i < ctx->nb_streams; i++) {
341 st = ctx->streams[i];
342 stream = av_mallocz(sizeof(StreamInfo));
345 st->priv_data = stream;
347 avpriv_set_pts_info(st, 64, 1, 90000);
349 switch (st->codec->codec_type) {
350 case AVMEDIA_TYPE_AUDIO:
352 (st->codec->codec_id == AV_CODEC_ID_AC3 ||
353 st->codec->codec_id == AV_CODEC_ID_DTS ||
354 st->codec->codec_id == AV_CODEC_ID_PCM_S16BE))
355 av_log(ctx, AV_LOG_WARNING,
356 "%s in MPEG-1 system streams is not widely supported, "
357 "consider using the vob or the dvd muxer "
358 "to force a MPEG-2 program stream.\n",
359 avcodec_get_name(st->codec->codec_id));
360 if (st->codec->codec_id == AV_CODEC_ID_AC3) {
361 stream->id = ac3_id++;
362 } else if (st->codec->codec_id == AV_CODEC_ID_DTS) {
363 stream->id = dts_id++;
364 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
365 stream->id = lpcm_id++;
366 for (j = 0; j < 4; j++) {
367 if (lpcm_freq_tab[j] == st->codec->sample_rate)
372 if (st->codec->channels > 8)
374 stream->lpcm_header[0] = 0x0c;
375 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
376 stream->lpcm_header[2] = 0x80;
377 stream->lpcm_align = st->codec->channels * 2;
379 stream->id = mpa_id++;
382 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
383 * Right now it is also used for everything else. */
384 stream->max_buffer_size = 4 * 1024;
387 case AVMEDIA_TYPE_VIDEO:
388 if (st->codec->codec_id == AV_CODEC_ID_H264)
389 stream->id = h264_id++;
391 stream->id = mpv_id++;
392 if (st->codec->rc_buffer_size)
393 stream->max_buffer_size = 6 * 1024 + st->codec->rc_buffer_size / 8;
395 av_log(ctx, AV_LOG_WARNING,
396 "VBV buffer size not set, using default size of 130KB\n"
397 "If you want the mpeg file to be compliant to some specification\n"
398 "Like DVD, VCD or others, make sure you set the correct buffer size\n");
399 // FIXME: this is probably too small as default
400 stream->max_buffer_size = 230 * 1024;
402 if (stream->max_buffer_size > 1024 * 8191) {
403 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
404 stream->max_buffer_size = 1024 * 8191;
408 case AVMEDIA_TYPE_SUBTITLE:
409 stream->id = mps_id++;
410 stream->max_buffer_size = 16 * 1024;
415 stream->fifo = av_fifo_alloc(16);
422 for (i = 0; i < ctx->nb_streams; i++) {
424 st = ctx->streams[i];
425 stream = (StreamInfo *)st->priv_data;
427 if (st->codec->rc_max_rate ||
428 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
429 codec_rate = st->codec->rc_max_rate;
431 codec_rate = st->codec->bit_rate;
434 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
436 bitrate += codec_rate;
438 if ((stream->id & 0xe0) == AUDIO_ID)
439 audio_bitrate += codec_rate;
440 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
441 video_bitrate += codec_rate;
444 if (s->user_mux_rate) {
445 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
447 /* we increase slightly the bitrate to take into account the
448 * headers. XXX: compute it exactly */
449 bitrate += bitrate / 20;
451 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
452 if (s->mux_rate >= (1<<22)) {
453 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
454 s->mux_rate = (1<<22) - 1;
459 double overhead_rate;
461 /* The VCD standard mandates that the mux_rate field is 3528
462 * (see standard p. IV-6).
463 * The value is actually "wrong", i.e. if you calculate
464 * it using the normal formula and the 75 sectors per second transfer
465 * rate you get a different value because the real pack size is 2324,
466 * not 2352. But the standard explicitly specifies that the mux_rate
467 * field in the header must have this value. */
468 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
470 /* The VCD standard states that the muxed stream must be
471 * exactly 75 packs / second (the data rate of a single speed cdrom).
472 * Since the video bitrate (probably 1150000 bits/sec) will be below
473 * the theoretical maximum we have to add some padding packets
474 * to make up for the lower data rate.
475 * (cf. VCD standard p. IV-6 ) */
477 /* Add the header overhead to the data rate.
478 * 2279 data bytes per audio pack, 2294 data bytes per video pack */
479 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
480 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
483 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
484 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
487 if (s->is_vcd || s->is_mpeg2)
489 s->pack_header_freq = 1;
491 /* every 2 seconds */
492 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
494 /* the above seems to make pack_header_freq zero sometimes */
495 if (s->pack_header_freq == 0)
496 s->pack_header_freq = 1;
499 /* every 200 packets. Need to look at the spec. */
500 s->system_header_freq = s->pack_header_freq * 40;
502 /* the standard mandates that there are only two system headers
503 * in the whole file: one in the first packet of each stream.
504 * (see standard p. IV-7 and IV-8) */
505 s->system_header_freq = 0x7fffffff;
507 s->system_header_freq = s->pack_header_freq * 5;
509 for (i = 0; i < ctx->nb_streams; i++) {
510 stream = ctx->streams[i]->priv_data;
511 stream->packet_number = 0;
513 s->system_header_size = get_system_header_size(ctx);
514 s->last_scr = AV_NOPTS_VALUE;
518 for (i = 0; i < ctx->nb_streams; i++)
519 av_freep(&ctx->streams[i]->priv_data);
520 return AVERROR(ENOMEM);
523 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
525 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
526 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
527 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
530 /* return the number of padding bytes that should be inserted into
531 * the multiplexed stream. */
532 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
534 MpegMuxContext *s = ctx->priv_data;
537 if (s->vcd_padding_bitrate > 0 && pts != AV_NOPTS_VALUE) {
538 int64_t full_pad_bytes;
540 // FIXME: this is wrong
542 (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0);
543 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
546 /* might happen if we have already padded to a later timestamp. This
547 * can occur if another stream has already advanced further. */
554 /* Write an MPEG padding packet header. */
555 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
558 MpegMuxContext *s = ctx->priv_data;
561 avio_wb32(pb, PADDING_STREAM);
562 avio_wb16(pb, packet_bytes - 6);
569 for (i = 0; i < packet_bytes; i++)
573 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
576 PacketDesc *pkt_desc = stream->premux_packet;
579 if (pkt_desc->size == pkt_desc->unwritten_size)
581 len -= pkt_desc->unwritten_size;
582 pkt_desc = pkt_desc->next;
588 /* flush the packet on stream stream_index */
589 static int flush_packet(AVFormatContext *ctx, int stream_index,
590 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
592 MpegMuxContext *s = ctx->priv_data;
593 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
595 int size, payload_size, startcode, id, stuffing_size, i, header_len;
598 int zero_trail_bytes = 0;
599 int pad_packet_bytes = 0;
601 /* "general" pack without data specific to one stream? */
602 int general_pack = 0;
607 av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
611 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
612 /* output pack and systems header if needed */
613 size = put_pack_header(ctx, buf_ptr, scr);
618 /* there is exactly one system header for each stream in a VCD MPEG,
619 * One in the very first video packet and one in the very first
620 * audio packet (see VCD standard p. IV-7 and IV-8). */
622 if (stream->packet_number == 0) {
623 size = put_system_header(ctx, buf_ptr, id);
626 } else if (s->is_dvd) {
627 if (stream->align_iframe || s->packet_number == 0) {
628 int PES_bytes_to_fill = s->packet_size - size - 10;
630 if (pts != AV_NOPTS_VALUE) {
632 PES_bytes_to_fill -= 5 + 5;
634 PES_bytes_to_fill -= 5;
637 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
638 size = put_system_header(ctx, buf_ptr, 0);
640 size = buf_ptr - buffer;
641 avio_write(ctx->pb, buffer, size);
643 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
644 avio_wb16(ctx->pb, 0x03d4); // length
645 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
646 for (i = 0; i < 979; i++)
647 avio_w8(ctx->pb, 0x00);
649 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
650 avio_wb16(ctx->pb, 0x03fa); // length
651 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
652 for (i = 0; i < 1017; i++)
653 avio_w8(ctx->pb, 0x00);
655 memset(buffer, 0, 128);
658 stream->align_iframe = 0;
659 // FIXME: rounding and first few bytes of each packet
660 scr += s->packet_size * 90000LL /
661 (s->mux_rate * 50LL);
662 size = put_pack_header(ctx, buf_ptr, scr);
666 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
667 pad_packet_bytes = PES_bytes_to_fill -
668 stream->bytes_to_iframe;
672 if ((s->packet_number % s->system_header_freq) == 0) {
673 size = put_system_header(ctx, buf_ptr, 0);
678 size = buf_ptr - buffer;
679 avio_write(ctx->pb, buffer, size);
681 packet_size = s->packet_size - size;
683 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
684 /* The VCD standard demands that 20 zero bytes follow
685 * each audio pack (see standard p. IV-8). */
686 zero_trail_bytes += 20;
688 if ((s->is_vcd && stream->packet_number == 0) ||
689 (s->is_svcd && s->packet_number == 0)) {
690 /* for VCD the first pack of each stream contains only the pack header,
691 * the system header and lots of padding (see VCD standard p. IV-6).
692 * In the case of an audio pack, 20 zero bytes are also added at
694 /* For SVCD we fill the very first pack to increase compatibility with
695 * some DVD players. Not mandated by the standard. */
697 /* the system header refers to both streams and no stream data */
699 pad_packet_bytes = packet_size - zero_trail_bytes;
702 packet_size -= pad_packet_bytes + zero_trail_bytes;
704 if (packet_size > 0) {
705 /* packet header size */
711 if (stream->packet_number == 0)
712 header_len += 3; /* PES extension */
713 header_len += 1; /* obligatory stuffing byte */
717 if (pts != AV_NOPTS_VALUE) {
727 payload_size = packet_size - header_len;
729 startcode = PRIVATE_STREAM_1;
737 startcode = 0x100 + id;
740 stuffing_size = payload_size - av_fifo_size(stream->fifo);
742 // first byte does not fit -> reset pts/dts + stuffing
743 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
744 int timestamp_len = 0;
747 if (pts != AV_NOPTS_VALUE)
748 timestamp_len += s->is_mpeg2 ? 5 : 4;
750 dts = AV_NOPTS_VALUE;
751 header_len -= timestamp_len;
752 if (s->is_dvd && stream->align_iframe) {
753 pad_packet_bytes += timestamp_len;
754 packet_size -= timestamp_len;
756 payload_size += timestamp_len;
758 stuffing_size += timestamp_len;
759 if (payload_size > trailer_size)
760 stuffing_size += payload_size - trailer_size;
763 // can't use padding, so use stuffing
764 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
765 packet_size += pad_packet_bytes;
766 payload_size += pad_packet_bytes; // undo the previous adjustment
767 if (stuffing_size < 0)
768 stuffing_size = pad_packet_bytes;
770 stuffing_size += pad_packet_bytes;
771 pad_packet_bytes = 0;
774 if (stuffing_size < 0)
777 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
778 if (payload_size < av_fifo_size(stream->fifo))
779 stuffing_size += payload_size % stream->lpcm_align;
782 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
783 pad_packet_bytes += stuffing_size;
784 packet_size -= stuffing_size;
785 payload_size -= stuffing_size;
789 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
791 avio_wb32(ctx->pb, startcode);
793 avio_wb16(ctx->pb, packet_size);
796 for (i = 0; i < stuffing_size; i++)
797 avio_w8(ctx->pb, 0xff);
800 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
804 if (pts != AV_NOPTS_VALUE) {
810 /* Both the MPEG-2 and the SVCD standards demand that the
811 * P-STD_buffer_size field be included in the first packet of
812 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
813 * and MPEG-2 standard 2.7.7) */
814 if (stream->packet_number == 0)
817 avio_w8(ctx->pb, pes_flags); /* flags */
818 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
820 if (pes_flags & 0x80) /* write pts */
821 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
822 if (pes_flags & 0x40) /* write dts */
823 put_timestamp(ctx->pb, 0x01, dts);
825 if (pes_flags & 0x01) { /* write pes extension */
826 avio_w8(ctx->pb, 0x10); /* flags */
828 /* P-STD buffer info */
829 if ((id & 0xe0) == AUDIO_ID)
830 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
832 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
835 if (pts != AV_NOPTS_VALUE) {
837 put_timestamp(ctx->pb, 0x03, pts);
838 put_timestamp(ctx->pb, 0x01, dts);
840 put_timestamp(ctx->pb, 0x02, pts);
843 avio_w8(ctx->pb, 0x0f);
848 /* special stuffing byte that is always written
849 * to prevent accidental generation of start codes. */
850 avio_w8(ctx->pb, 0xff);
852 for (i = 0; i < stuffing_size; i++)
853 avio_w8(ctx->pb, 0xff);
856 if (startcode == PRIVATE_STREAM_1) {
857 avio_w8(ctx->pb, id);
859 /* LPCM (XXX: check nb_frames) */
861 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
862 avio_w8(ctx->pb, stream->lpcm_header[0]);
863 avio_w8(ctx->pb, stream->lpcm_header[1]);
864 avio_w8(ctx->pb, stream->lpcm_header[2]);
865 } else if (id >= 0x40) {
867 avio_w8(ctx->pb, nb_frames);
868 avio_wb16(ctx->pb, trailer_size + 1);
873 av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
874 av_fifo_generic_read(stream->fifo, ctx->pb,
875 payload_size - stuffing_size,
876 (void (*)(void*, void*, int))avio_write);
877 stream->bytes_to_iframe -= payload_size - stuffing_size;
883 if (pad_packet_bytes > 0)
884 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
886 for (i = 0; i < zero_trail_bytes; i++)
887 avio_w8(ctx->pb, 0x00);
893 /* only increase the stream packet number if this pack actually contains
894 * something that is specific to this stream! I.e. a dedicated header
897 stream->packet_number++;
899 return payload_size - stuffing_size;
902 static void put_vcd_padding_sector(AVFormatContext *ctx)
904 /* There are two ways to do this padding: writing a sector/pack
905 * of 0 values, or writing an MPEG padding pack. Both seem to
906 * work with most decoders, BUT the VCD standard only allows a 0-sector
907 * (see standard p. IV-4, IV-5).
908 * So a 0-sector it is... */
910 MpegMuxContext *s = ctx->priv_data;
913 for (i = 0; i < s->packet_size; i++)
916 s->vcd_padding_bytes_written += s->packet_size;
920 /* increasing the packet number is correct. The SCR of the following packs
921 * is calculated from the packet_number and it has to include the padding
922 * sector (it represents the sector index, not the MPEG pack index)
923 * (see VCD standard p. IV-6) */
927 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
931 for (i = 0; i < ctx->nb_streams; i++) {
932 AVStream *st = ctx->streams[i];
933 StreamInfo *stream = st->priv_data;
934 PacketDesc *pkt_desc;
936 while ((pkt_desc = stream->predecode_packet) &&
937 scr > pkt_desc->dts) { // FIXME: > vs >=
938 if (stream->buffer_index < pkt_desc->size ||
939 stream->predecode_packet == stream->premux_packet) {
940 av_log(ctx, AV_LOG_ERROR,
941 "buffer underflow st=%d bufi=%d size=%d\n",
942 i, stream->buffer_index, pkt_desc->size);
945 stream->buffer_index -= pkt_desc->size;
946 stream->predecode_packet = pkt_desc->next;
954 static int output_packet(AVFormatContext *ctx, int flush)
956 MpegMuxContext *s = ctx->priv_data;
959 int i, avail_space = 0, es_size, trailer_size;
961 int best_score = INT_MIN;
962 int ignore_constraints = 0;
963 int ignore_delay = 0;
964 int64_t scr = s->last_scr;
965 PacketDesc *timestamp_packet;
966 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
969 for (i = 0; i < ctx->nb_streams; i++) {
970 AVStream *st = ctx->streams[i];
971 StreamInfo *stream = st->priv_data;
972 const int avail_data = av_fifo_size(stream->fifo);
973 const int space = stream->max_buffer_size - stream->buffer_index;
974 int rel_space = 1024LL * space / stream->max_buffer_size;
975 PacketDesc *next_pkt = stream->premux_packet;
977 /* for subtitle, a single PES packet must be generated,
978 * so we flush after every single subtitle packet */
979 if (s->packet_size > avail_data && !flush
980 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
984 av_assert0(avail_data > 0);
986 if (space < s->packet_size && !ignore_constraints)
989 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
991 if ( stream->predecode_packet
992 && stream->predecode_packet->size > stream->buffer_index)
994 if (rel_space > best_score) {
995 best_score = rel_space;
1002 int64_t best_dts = INT64_MAX;
1005 for (i = 0; i < ctx->nb_streams; i++) {
1006 AVStream *st = ctx->streams[i];
1007 StreamInfo *stream = st->priv_data;
1008 PacketDesc *pkt_desc = stream->predecode_packet;
1009 if (pkt_desc && pkt_desc->dts < best_dts)
1010 best_dts = pkt_desc->dts;
1011 has_premux |= !!stream->premux_packet;
1014 if (best_dts < INT64_MAX) {
1015 av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1016 scr / 90000.0, best_dts / 90000.0);
1018 if (scr >= best_dts + 1 && !ignore_constraints) {
1019 av_log(ctx, AV_LOG_ERROR,
1020 "packet too large, ignoring buffer limits to mux it\n");
1021 ignore_constraints = 1;
1023 scr = FFMAX(best_dts + 1, scr);
1024 if (remove_decoded_packets(ctx, scr) < 0)
1026 } else if (has_premux && flush) {
1027 av_log(ctx, AV_LOG_ERROR,
1028 "delay too large, ignoring ...\n");
1030 ignore_constraints = 1;
1037 av_assert0(best_i >= 0);
1039 st = ctx->streams[best_i];
1040 stream = st->priv_data;
1042 av_assert0(av_fifo_size(stream->fifo) > 0);
1044 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1046 timestamp_packet = stream->premux_packet;
1047 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1050 trailer_size = timestamp_packet->unwritten_size;
1051 timestamp_packet = timestamp_packet->next;
1054 if (timestamp_packet) {
1055 av_dlog(ctx, "dts:%f pts:%f scr:%f stream:%d\n",
1056 timestamp_packet->dts / 90000.0,
1057 timestamp_packet->pts / 90000.0,
1058 scr / 90000.0, best_i);
1059 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1060 timestamp_packet->dts, scr, trailer_size);
1062 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1063 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1068 /* Write one or more padding sectors, if necessary, to reach
1069 * the constant overall bitrate. */
1072 // FIXME: pts cannot be correct here
1073 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1074 put_vcd_padding_sector(ctx);
1075 // FIXME: rounding and first few bytes of each packet
1076 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1080 stream->buffer_index += es_size;
1081 // FIXME: rounding and first few bytes of each packet
1082 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1084 while (stream->premux_packet &&
1085 stream->premux_packet->unwritten_size <= es_size) {
1086 es_size -= stream->premux_packet->unwritten_size;
1087 stream->premux_packet = stream->premux_packet->next;
1090 av_assert0(stream->premux_packet);
1091 stream->premux_packet->unwritten_size -= es_size;
1094 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1100 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1102 int stream_index = pkt->stream_index;
1103 int size = pkt->size;
1104 uint8_t *buf = pkt->data;
1105 MpegMuxContext *s = ctx->priv_data;
1106 AVStream *st = ctx->streams[stream_index];
1107 StreamInfo *stream = st->priv_data;
1109 PacketDesc *pkt_desc;
1111 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1112 (pkt->flags & AV_PKT_FLAG_KEY);
1114 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1119 if (s->last_scr == AV_NOPTS_VALUE) {
1120 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1121 if (dts != AV_NOPTS_VALUE)
1122 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1125 s->last_scr = dts - preload;
1128 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1129 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1132 if (dts != AV_NOPTS_VALUE) dts += preload;
1133 if (pts != AV_NOPTS_VALUE) pts += preload;
1135 av_dlog(ctx, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1136 dts / 90000.0, pts / 90000.0, pkt->flags,
1137 pkt->stream_index, pts != AV_NOPTS_VALUE);
1138 if (!stream->premux_packet)
1139 stream->next_packet = &stream->premux_packet;
1140 *stream->next_packet =
1141 pkt_desc = av_mallocz(sizeof(PacketDesc));
1142 pkt_desc->pts = pts;
1143 pkt_desc->dts = dts;
1144 pkt_desc->unwritten_size =
1145 pkt_desc->size = size;
1146 if (!stream->predecode_packet)
1147 stream->predecode_packet = pkt_desc;
1148 stream->next_packet = &pkt_desc->next;
1150 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1154 // min VOBU length 0.4 seconds (mpucoder)
1156 (s->packet_number == 0 ||
1157 (pts - stream->vobu_start_pts >= 36000))) {
1158 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1159 stream->align_iframe = 1;
1160 stream->vobu_start_pts = pts;
1164 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1167 int ret = output_packet(ctx, 0);
1173 static int mpeg_mux_end(AVFormatContext *ctx)
1179 int ret = output_packet(ctx, 1);
1186 /* End header according to MPEG1 systems standard. We do not write
1187 * it as it is usually not needed by decoders and because it
1188 * complicates MPEG stream concatenation. */
1189 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1190 // avio_flush(ctx->pb);
1192 for (i = 0; i < ctx->nb_streams; i++) {
1193 stream = ctx->streams[i]->priv_data;
1195 av_assert0(av_fifo_size(stream->fifo) == 0);
1196 av_fifo_freep(&stream->fifo);
1201 #define OFFSET(x) offsetof(MpegMuxContext, x)
1202 #define E AV_OPT_FLAG_ENCODING_PARAM
1203 static const AVOption options[] = {
1204 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1205 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1209 #define MPEGENC_CLASS(flavor) \
1210 static const AVClass flavor ## _class = { \
1211 .class_name = #flavor " muxer", \
1212 .item_name = av_default_item_name, \
1213 .version = LIBAVUTIL_VERSION_INT, \
1214 .option = options, \
1217 #if CONFIG_MPEG1SYSTEM_MUXER
1219 AVOutputFormat ff_mpeg1system_muxer = {
1221 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1222 .mime_type = "video/mpeg",
1223 .extensions = "mpg,mpeg",
1224 .priv_data_size = sizeof(MpegMuxContext),
1225 .audio_codec = AV_CODEC_ID_MP2,
1226 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1227 .write_header = mpeg_mux_init,
1228 .write_packet = mpeg_mux_write_packet,
1229 .write_trailer = mpeg_mux_end,
1230 .priv_class = &mpeg_class,
1234 #if CONFIG_MPEG1VCD_MUXER
1236 AVOutputFormat ff_mpeg1vcd_muxer = {
1238 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1239 .mime_type = "video/mpeg",
1240 .priv_data_size = sizeof(MpegMuxContext),
1241 .audio_codec = AV_CODEC_ID_MP2,
1242 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1243 .write_header = mpeg_mux_init,
1244 .write_packet = mpeg_mux_write_packet,
1245 .write_trailer = mpeg_mux_end,
1246 .priv_class = &vcd_class,
1250 #if CONFIG_MPEG2VOB_MUXER
1252 AVOutputFormat ff_mpeg2vob_muxer = {
1254 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1255 .mime_type = "video/mpeg",
1256 .extensions = "vob",
1257 .priv_data_size = sizeof(MpegMuxContext),
1258 .audio_codec = AV_CODEC_ID_MP2,
1259 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1260 .write_header = mpeg_mux_init,
1261 .write_packet = mpeg_mux_write_packet,
1262 .write_trailer = mpeg_mux_end,
1263 .priv_class = &vob_class,
1267 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1268 #if CONFIG_MPEG2SVCD_MUXER
1270 AVOutputFormat ff_mpeg2svcd_muxer = {
1272 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1273 .mime_type = "video/mpeg",
1274 .extensions = "vob",
1275 .priv_data_size = sizeof(MpegMuxContext),
1276 .audio_codec = AV_CODEC_ID_MP2,
1277 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1278 .write_header = mpeg_mux_init,
1279 .write_packet = mpeg_mux_write_packet,
1280 .write_trailer = mpeg_mux_end,
1281 .priv_class = &svcd_class,
1285 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1286 #if CONFIG_MPEG2DVD_MUXER
1288 AVOutputFormat ff_mpeg2dvd_muxer = {
1290 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1291 .mime_type = "video/mpeg",
1292 .extensions = "dvd",
1293 .priv_data_size = sizeof(MpegMuxContext),
1294 .audio_codec = AV_CODEC_ID_MP2,
1295 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1296 .write_header = mpeg_mux_init,
1297 .write_packet = mpeg_mux_write_packet,
1298 .write_trailer = mpeg_mux_end,
1299 .priv_class = &dvd_class,