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
41 typedef struct PacketDesc {
47 struct PacketDesc *next;
53 int max_buffer_size; /* in bytes */
55 PacketDesc *predecode_packet;
56 PacketDesc *premux_packet;
57 PacketDesc **next_packet;
59 uint8_t lpcm_header[3];
63 int64_t vobu_start_pts;
68 int packet_size; /* required packet size */
70 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
71 int system_header_freq;
72 int system_header_size;
73 int user_mux_rate; /* bitrate in units of bits/s */
74 int mux_rate; /* bitrate in units of 50 bytes/s */
82 int64_t last_scr; /* current system clock */
84 double vcd_padding_bitrate; // FIXME floats
85 int64_t vcd_padding_bytes_written;
90 extern AVOutputFormat ff_mpeg1vcd_muxer;
91 extern AVOutputFormat ff_mpeg2dvd_muxer;
92 extern AVOutputFormat ff_mpeg2svcd_muxer;
93 extern AVOutputFormat ff_mpeg2vob_muxer;
95 static int put_pack_header(AVFormatContext *ctx, uint8_t *buf,
98 MpegMuxContext *s = ctx->priv_data;
101 init_put_bits(&pb, buf, 128);
103 put_bits32(&pb, PACK_START_CODE);
105 put_bits(&pb, 2, 0x1);
107 put_bits(&pb, 4, 0x2);
108 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
110 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
112 put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
115 /* clock extension */
118 put_bits(&pb, 22, s->mux_rate);
122 put_bits(&pb, 5, 0x1f); /* reserved */
123 put_bits(&pb, 3, 0); /* stuffing length */
126 return put_bits_ptr(&pb) - pb.buf;
129 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,
130 int only_for_stream_id)
132 MpegMuxContext *s = ctx->priv_data;
133 int size, i, private_stream_coded, id;
136 init_put_bits(&pb, buf, 128);
138 put_bits32(&pb, SYSTEM_HEADER_START_CODE);
139 put_bits(&pb, 16, 0);
142 /* maximum bit rate of the multiplexed stream */
143 put_bits(&pb, 22, s->mux_rate);
144 put_bits(&pb, 1, 1); /* marker */
145 if (s->is_vcd && only_for_stream_id == VIDEO_ID) {
146 /* This header applies only to the video stream
147 * (see VCD standard p. IV-7) */
150 put_bits(&pb, 6, s->audio_bound);
153 /* see VCD standard, p. IV-7 */
157 put_bits(&pb, 1, 0); /* variable bitrate */
158 put_bits(&pb, 1, 0); /* non constrainted bit stream */
161 if (s->is_vcd || s->is_dvd) {
162 /* see VCD standard p IV-7 */
163 put_bits(&pb, 1, 1); /* audio locked */
164 put_bits(&pb, 1, 1); /* video locked */
166 put_bits(&pb, 1, 0); /* audio locked */
167 put_bits(&pb, 1, 0); /* video locked */
170 put_bits(&pb, 1, 1); /* marker */
172 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
173 /* This header applies only to the audio stream
174 * (see VCD standard p. IV-7) */
177 put_bits(&pb, 5, s->video_bound);
180 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
181 put_bits(&pb, 7, 0x7f); /* reserved byte */
183 put_bits(&pb, 8, 0xff); /* reserved byte */
185 /* DVD-Video Stream_bound entries
186 * id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
187 * 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)
188 * id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
189 * id (0xBF) private stream 2, NAV packs, set to 2x1024. */
192 int P_STD_max_video = 0;
193 int P_STD_max_mpeg_audio = 0;
194 int P_STD_max_mpeg_PS1 = 0;
196 for (i = 0; i < ctx->nb_streams; i++) {
197 StreamInfo *stream = ctx->streams[i]->priv_data;
200 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
201 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
202 } else if (id >= 0xc0 && id <= 0xc7 &&
203 stream->max_buffer_size > P_STD_max_mpeg_audio) {
204 P_STD_max_mpeg_audio = stream->max_buffer_size;
205 } else if (id == 0xe0 &&
206 stream->max_buffer_size > P_STD_max_video) {
207 P_STD_max_video = stream->max_buffer_size;
212 put_bits(&pb, 8, 0xb9); /* stream ID */
215 put_bits(&pb, 13, P_STD_max_video / 1024);
218 if (P_STD_max_mpeg_audio == 0)
219 P_STD_max_mpeg_audio = 4096;
220 put_bits(&pb, 8, 0xb8); /* stream ID */
223 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
225 /* private stream 1 */
226 put_bits(&pb, 8, 0xbd); /* stream ID */
229 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
231 /* private stream 2 */
232 put_bits(&pb, 8, 0xbf); /* stream ID */
235 put_bits(&pb, 13, 2);
237 /* audio stream info */
238 private_stream_coded = 0;
239 for (i = 0; i < ctx->nb_streams; i++) {
240 StreamInfo *stream = ctx->streams[i]->priv_data;
242 /* For VCDs, only include the stream info for the stream
243 * that the pack which contains this system belongs to.
244 * (see VCD standard p. IV-7) */
245 if (!s->is_vcd || stream->id == only_for_stream_id ||
246 only_for_stream_id == 0) {
249 /* special case for private streams (AC-3 uses that) */
250 if (private_stream_coded)
252 private_stream_coded = 1;
255 put_bits(&pb, 8, id); /* stream ID */
260 put_bits(&pb, 13, stream->max_buffer_size / 128);
264 put_bits(&pb, 13, stream->max_buffer_size / 1024);
271 size = put_bits_ptr(&pb) - pb.buf;
272 /* patch packet size */
273 AV_WB16(buf + 4, size - 6);
278 static int get_system_header_size(AVFormatContext *ctx)
280 int buf_index, i, private_stream_coded;
282 MpegMuxContext *s = ctx->priv_data;
285 return 18; // DVD-Video system headers are 18 bytes fixed length.
288 private_stream_coded = 0;
289 for (i = 0; i < ctx->nb_streams; i++) {
290 stream = ctx->streams[i]->priv_data;
291 if (stream->id < 0xc0) {
292 if (private_stream_coded)
294 private_stream_coded = 1;
301 static av_cold int mpeg_mux_init(AVFormatContext *ctx)
303 MpegMuxContext *s = ctx->priv_data;
304 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
310 s->packet_number = 0;
311 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
312 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
313 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
314 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
315 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
316 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
318 if (ctx->packet_size) {
319 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
320 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
324 s->packet_size = ctx->packet_size;
326 s->packet_size = 2048;
327 if (ctx->max_delay < 0) /* Not set by the caller */
328 ctx->max_delay = 0.7*AV_TIME_BASE;
330 s->vcd_padding_bytes_written = 0;
331 s->vcd_padding_bitrate = 0;
343 for (i = 0; i < ctx->nb_streams; i++) {
344 st = ctx->streams[i];
345 stream = av_mallocz(sizeof(StreamInfo));
348 st->priv_data = stream;
350 avpriv_set_pts_info(st, 64, 1, 90000);
352 switch (st->codec->codec_type) {
353 case AVMEDIA_TYPE_AUDIO:
355 (st->codec->codec_id == AV_CODEC_ID_AC3 ||
356 st->codec->codec_id == AV_CODEC_ID_DTS ||
357 st->codec->codec_id == AV_CODEC_ID_PCM_S16BE))
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->codec->codec_id));
363 if (st->codec->codec_id == AV_CODEC_ID_AC3) {
364 stream->id = ac3_id++;
365 } else if (st->codec->codec_id == AV_CODEC_ID_DTS) {
366 stream->id = dts_id++;
367 } else if (st->codec->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->codec->sample_rate)
375 if (st->codec->channels > 8)
377 stream->lpcm_header[0] = 0x0c;
378 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
379 stream->lpcm_header[2] = 0x80;
380 stream->lpcm_align = st->codec->channels * 2;
382 stream->id = mpa_id++;
385 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
386 * Right now it is also used for everything else. */
387 stream->max_buffer_size = 4 * 1024;
390 case AVMEDIA_TYPE_VIDEO:
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 || stream->id == VIDEO_ID)
428 codec_rate = st->codec->rc_max_rate;
430 codec_rate = st->codec->bit_rate;
433 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
435 bitrate += codec_rate;
437 if ((stream->id & 0xe0) == AUDIO_ID)
438 audio_bitrate += codec_rate;
439 else if (stream->id == VIDEO_ID)
440 video_bitrate += codec_rate;
443 if (s->user_mux_rate) {
444 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
446 /* we increase slightly the bitrate to take into account the
447 * headers. XXX: compute it exactly */
448 bitrate += bitrate / 20;
450 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
451 if (s->mux_rate >= (1<<22)) {
452 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
453 s->mux_rate = (1<<22) - 1;
458 double overhead_rate;
460 /* The VCD standard mandates that the mux_rate field is 3528
461 * (see standard p. IV-6).
462 * The value is actually "wrong", i.e. if you calculate
463 * it using the normal formula and the 75 sectors per second transfer
464 * rate you get a different value because the real pack size is 2324,
465 * not 2352. But the standard explicitly specifies that the mux_rate
466 * field in the header must have this value. */
467 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
469 /* The VCD standard states that the muxed stream must be
470 * exactly 75 packs / second (the data rate of a single speed cdrom).
471 * Since the video bitrate (probably 1150000 bits/sec) will be below
472 * the theoretical maximum we have to add some padding packets
473 * to make up for the lower data rate.
474 * (cf. VCD standard p. IV-6 ) */
476 /* Add the header overhead to the data rate.
477 * 2279 data bytes per audio pack, 2294 data bytes per video pack */
478 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
479 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
482 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
483 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
486 if (s->is_vcd || s->is_mpeg2)
488 s->pack_header_freq = 1;
490 /* every 2 seconds */
491 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
493 /* the above seems to make pack_header_freq zero sometimes */
494 if (s->pack_header_freq == 0)
495 s->pack_header_freq = 1;
498 /* every 200 packets. Need to look at the spec. */
499 s->system_header_freq = s->pack_header_freq * 40;
501 /* the standard mandates that there are only two system headers
502 * in the whole file: one in the first packet of each stream.
503 * (see standard p. IV-7 and IV-8) */
504 s->system_header_freq = 0x7fffffff;
506 s->system_header_freq = s->pack_header_freq * 5;
508 for (i = 0; i < ctx->nb_streams; i++) {
509 stream = ctx->streams[i]->priv_data;
510 stream->packet_number = 0;
512 s->system_header_size = get_system_header_size(ctx);
513 s->last_scr = AV_NOPTS_VALUE;
517 for (i = 0; i < ctx->nb_streams; i++)
518 av_free(ctx->streams[i]->priv_data);
519 return AVERROR(ENOMEM);
522 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
524 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
525 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
526 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
529 /* return the number of padding bytes that should be inserted into
530 * the multiplexed stream. */
531 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
533 MpegMuxContext *s = ctx->priv_data;
536 if (s->vcd_padding_bitrate > 0 && pts != AV_NOPTS_VALUE) {
537 int64_t full_pad_bytes;
539 // FIXME: this is wrong
541 (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0);
542 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
545 /* might happen if we have already padded to a later timestamp. This
546 * can occur if another stream has already advanced further. */
553 /* Write an MPEG padding packet header. */
554 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
557 MpegMuxContext *s = ctx->priv_data;
560 avio_wb32(pb, PADDING_STREAM);
561 avio_wb16(pb, packet_bytes - 6);
568 for (i = 0; i < packet_bytes; i++)
572 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
575 PacketDesc *pkt_desc = stream->premux_packet;
578 if (pkt_desc->size == pkt_desc->unwritten_size)
580 len -= pkt_desc->unwritten_size;
581 pkt_desc = pkt_desc->next;
587 /* flush the packet on stream stream_index */
588 static int flush_packet(AVFormatContext *ctx, int stream_index,
589 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
591 MpegMuxContext *s = ctx->priv_data;
592 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
594 int size, payload_size, startcode, id, stuffing_size, i, header_len;
597 int zero_trail_bytes = 0;
598 int pad_packet_bytes = 0;
600 /* "general" pack without data specific to one stream? */
601 int general_pack = 0;
606 av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
610 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
611 /* output pack and systems header if needed */
612 size = put_pack_header(ctx, buf_ptr, scr);
617 /* there is exactly one system header for each stream in a VCD MPEG,
618 * One in the very first video packet and one in the very first
619 * audio packet (see VCD standard p. IV-7 and IV-8). */
621 if (stream->packet_number == 0) {
622 size = put_system_header(ctx, buf_ptr, id);
625 } else if (s->is_dvd) {
626 if (stream->align_iframe || s->packet_number == 0) {
627 int PES_bytes_to_fill = s->packet_size - size - 10;
629 if (pts != AV_NOPTS_VALUE) {
631 PES_bytes_to_fill -= 5 + 5;
633 PES_bytes_to_fill -= 5;
636 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
637 size = put_system_header(ctx, buf_ptr, 0);
639 size = buf_ptr - buffer;
640 avio_write(ctx->pb, buffer, size);
642 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
643 avio_wb16(ctx->pb, 0x03d4); // length
644 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
645 for (i = 0; i < 979; i++)
646 avio_w8(ctx->pb, 0x00);
648 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
649 avio_wb16(ctx->pb, 0x03fa); // length
650 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
651 for (i = 0; i < 1017; i++)
652 avio_w8(ctx->pb, 0x00);
654 memset(buffer, 0, 128);
657 stream->align_iframe = 0;
658 // FIXME: rounding and first few bytes of each packet
659 scr += s->packet_size * 90000LL /
660 (s->mux_rate * 50LL);
661 size = put_pack_header(ctx, buf_ptr, scr);
665 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
666 pad_packet_bytes = PES_bytes_to_fill -
667 stream->bytes_to_iframe;
671 if ((s->packet_number % s->system_header_freq) == 0) {
672 size = put_system_header(ctx, buf_ptr, 0);
677 size = buf_ptr - buffer;
678 avio_write(ctx->pb, buffer, size);
680 packet_size = s->packet_size - size;
682 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
683 /* The VCD standard demands that 20 zero bytes follow
684 * each audio pack (see standard p. IV-8). */
685 zero_trail_bytes += 20;
687 if ((s->is_vcd && stream->packet_number == 0) ||
688 (s->is_svcd && s->packet_number == 0)) {
689 /* for VCD the first pack of each stream contains only the pack header,
690 * the system header and lots of padding (see VCD standard p. IV-6).
691 * In the case of an audio pack, 20 zero bytes are also added at
693 /* For SVCD we fill the very first pack to increase compatibility with
694 * some DVD players. Not mandated by the standard. */
696 /* the system header refers to both streams and no stream data */
698 pad_packet_bytes = packet_size - zero_trail_bytes;
701 packet_size -= pad_packet_bytes + zero_trail_bytes;
703 if (packet_size > 0) {
704 /* packet header size */
710 if (stream->packet_number == 0)
711 header_len += 3; /* PES extension */
712 header_len += 1; /* obligatory stuffing byte */
716 if (pts != AV_NOPTS_VALUE) {
726 payload_size = packet_size - header_len;
728 startcode = PRIVATE_STREAM_1;
736 startcode = 0x100 + id;
739 stuffing_size = payload_size - av_fifo_size(stream->fifo);
741 // first byte does not fit -> reset pts/dts + stuffing
742 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
743 int timestamp_len = 0;
746 if (pts != AV_NOPTS_VALUE)
747 timestamp_len += s->is_mpeg2 ? 5 : 4;
749 dts = AV_NOPTS_VALUE;
750 header_len -= timestamp_len;
751 if (s->is_dvd && stream->align_iframe) {
752 pad_packet_bytes += timestamp_len;
753 packet_size -= timestamp_len;
755 payload_size += timestamp_len;
757 stuffing_size += timestamp_len;
758 if (payload_size > trailer_size)
759 stuffing_size += payload_size - trailer_size;
762 // can't use padding, so use stuffing
763 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
764 packet_size += pad_packet_bytes;
765 payload_size += pad_packet_bytes; // undo the previous adjustment
766 if (stuffing_size < 0)
767 stuffing_size = pad_packet_bytes;
769 stuffing_size += pad_packet_bytes;
770 pad_packet_bytes = 0;
773 if (stuffing_size < 0)
776 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
777 if (payload_size < av_fifo_size(stream->fifo))
778 stuffing_size += payload_size % stream->lpcm_align;
781 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
782 pad_packet_bytes += stuffing_size;
783 packet_size -= stuffing_size;
784 payload_size -= stuffing_size;
788 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
790 avio_wb32(ctx->pb, startcode);
792 avio_wb16(ctx->pb, packet_size);
795 for (i = 0; i < stuffing_size; i++)
796 avio_w8(ctx->pb, 0xff);
799 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
803 if (pts != AV_NOPTS_VALUE) {
809 /* Both the MPEG-2 and the SVCD standards demand that the
810 * P-STD_buffer_size field be included in the first packet of
811 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
812 * and MPEG-2 standard 2.7.7) */
813 if (stream->packet_number == 0)
816 avio_w8(ctx->pb, pes_flags); /* flags */
817 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
819 if (pes_flags & 0x80) /* write pts */
820 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
821 if (pes_flags & 0x40) /* write dts */
822 put_timestamp(ctx->pb, 0x01, dts);
824 if (pes_flags & 0x01) { /* write pes extension */
825 avio_w8(ctx->pb, 0x10); /* flags */
827 /* P-STD buffer info */
828 if ((id & 0xe0) == AUDIO_ID)
829 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
831 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
834 if (pts != AV_NOPTS_VALUE) {
836 put_timestamp(ctx->pb, 0x03, pts);
837 put_timestamp(ctx->pb, 0x01, dts);
839 put_timestamp(ctx->pb, 0x02, pts);
842 avio_w8(ctx->pb, 0x0f);
847 /* special stuffing byte that is always written
848 * to prevent accidental generation of start codes. */
849 avio_w8(ctx->pb, 0xff);
851 for (i = 0; i < stuffing_size; i++)
852 avio_w8(ctx->pb, 0xff);
855 if (startcode == PRIVATE_STREAM_1) {
856 avio_w8(ctx->pb, id);
858 /* LPCM (XXX: check nb_frames) */
860 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
861 avio_w8(ctx->pb, stream->lpcm_header[0]);
862 avio_w8(ctx->pb, stream->lpcm_header[1]);
863 avio_w8(ctx->pb, stream->lpcm_header[2]);
864 } else if (id >= 0x40) {
866 avio_w8(ctx->pb, nb_frames);
867 avio_wb16(ctx->pb, trailer_size + 1);
872 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
873 av_fifo_generic_read(stream->fifo, ctx->pb,
874 payload_size - stuffing_size,
875 (void (*)(void*, void*, int))avio_write);
876 stream->bytes_to_iframe -= payload_size - stuffing_size;
882 if (pad_packet_bytes > 0)
883 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
885 for (i = 0; i < zero_trail_bytes; i++)
886 avio_w8(ctx->pb, 0x00);
892 /* only increase the stream packet number if this pack actually contains
893 * something that is specific to this stream! I.e. a dedicated header
896 stream->packet_number++;
898 return payload_size - stuffing_size;
901 static void put_vcd_padding_sector(AVFormatContext *ctx)
903 /* There are two ways to do this padding: writing a sector/pack
904 * of 0 values, or writing an MPEG padding pack. Both seem to
905 * work with most decoders, BUT the VCD standard only allows a 0-sector
906 * (see standard p. IV-4, IV-5).
907 * So a 0-sector it is... */
909 MpegMuxContext *s = ctx->priv_data;
912 for (i = 0; i < s->packet_size; i++)
915 s->vcd_padding_bytes_written += s->packet_size;
919 /* increasing the packet number is correct. The SCR of the following packs
920 * is calculated from the packet_number and it has to include the padding
921 * sector (it represents the sector index, not the MPEG pack index)
922 * (see VCD standard p. IV-6) */
926 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
930 for (i = 0; i < ctx->nb_streams; i++) {
931 AVStream *st = ctx->streams[i];
932 StreamInfo *stream = st->priv_data;
933 PacketDesc *pkt_desc;
935 while ((pkt_desc = stream->predecode_packet) &&
936 scr > pkt_desc->dts) { // FIXME: > vs >=
937 if (stream->buffer_index < pkt_desc->size ||
938 stream->predecode_packet == stream->premux_packet) {
939 av_log(ctx, AV_LOG_ERROR,
940 "buffer underflow st=%d bufi=%d size=%d\n",
941 i, stream->buffer_index, pkt_desc->size);
944 stream->buffer_index -= pkt_desc->size;
945 stream->predecode_packet = pkt_desc->next;
953 static int output_packet(AVFormatContext *ctx, int flush)
955 MpegMuxContext *s = ctx->priv_data;
958 int i, avail_space = 0, es_size, trailer_size;
960 int best_score = INT_MIN;
961 int ignore_constraints = 0;
962 int64_t scr = s->last_scr;
963 PacketDesc *timestamp_packet;
964 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
967 for (i = 0; i < ctx->nb_streams; i++) {
968 AVStream *st = ctx->streams[i];
969 StreamInfo *stream = st->priv_data;
970 const int avail_data = av_fifo_size(stream->fifo);
971 const int space = stream->max_buffer_size - stream->buffer_index;
972 int rel_space = 1024LL * space / stream->max_buffer_size;
973 PacketDesc *next_pkt = stream->premux_packet;
975 /* for subtitle, a single PES packet must be generated,
976 * so we flush after every single subtitle packet */
977 if (s->packet_size > avail_data && !flush
978 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
982 av_assert0(avail_data > 0);
984 if (space < s->packet_size && !ignore_constraints)
987 if (next_pkt && next_pkt->dts - scr > max_delay)
989 if ( stream->predecode_packet
990 && stream->predecode_packet->size > stream->buffer_index)
992 if (rel_space > best_score) {
993 best_score = rel_space;
1000 int64_t best_dts = INT64_MAX;
1002 for (i = 0; i < ctx->nb_streams; i++) {
1003 AVStream *st = ctx->streams[i];
1004 StreamInfo *stream = st->priv_data;
1005 PacketDesc *pkt_desc = stream->predecode_packet;
1006 if (pkt_desc && pkt_desc->dts < best_dts)
1007 best_dts = pkt_desc->dts;
1010 av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1011 scr / 90000.0, best_dts / 90000.0);
1012 if (best_dts == INT64_MAX)
1015 if (scr >= best_dts + 1 && !ignore_constraints) {
1016 av_log(ctx, AV_LOG_ERROR,
1017 "packet too large, ignoring buffer limits to mux it\n");
1018 ignore_constraints = 1;
1020 scr = FFMAX(best_dts + 1, scr);
1021 if (remove_decoded_packets(ctx, scr) < 0)
1026 assert(best_i >= 0);
1028 st = ctx->streams[best_i];
1029 stream = st->priv_data;
1031 assert(av_fifo_size(stream->fifo) > 0);
1033 assert(avail_space >= s->packet_size || ignore_constraints);
1035 timestamp_packet = stream->premux_packet;
1036 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1039 trailer_size = timestamp_packet->unwritten_size;
1040 timestamp_packet = timestamp_packet->next;
1043 if (timestamp_packet) {
1044 av_dlog(ctx, "dts:%f pts:%f scr:%f stream:%d\n",
1045 timestamp_packet->dts / 90000.0,
1046 timestamp_packet->pts / 90000.0,
1047 scr / 90000.0, best_i);
1048 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1049 timestamp_packet->dts, scr, trailer_size);
1051 assert(av_fifo_size(stream->fifo) == trailer_size);
1052 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1057 /* Write one or more padding sectors, if necessary, to reach
1058 * the constant overall bitrate. */
1061 // FIXME: pts cannot be correct here
1062 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1063 put_vcd_padding_sector(ctx);
1064 // FIXME: rounding and first few bytes of each packet
1065 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1069 stream->buffer_index += es_size;
1070 // FIXME: rounding and first few bytes of each packet
1071 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1073 while (stream->premux_packet &&
1074 stream->premux_packet->unwritten_size <= es_size) {
1075 es_size -= stream->premux_packet->unwritten_size;
1076 stream->premux_packet = stream->premux_packet->next;
1079 stream->premux_packet->unwritten_size -= es_size;
1081 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1087 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1089 int stream_index = pkt->stream_index;
1090 int size = pkt->size;
1091 uint8_t *buf = pkt->data;
1092 MpegMuxContext *s = ctx->priv_data;
1093 AVStream *st = ctx->streams[stream_index];
1094 StreamInfo *stream = st->priv_data;
1096 PacketDesc *pkt_desc;
1098 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1099 (pkt->flags & AV_PKT_FLAG_KEY);
1101 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1106 if (s->last_scr == AV_NOPTS_VALUE) {
1107 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1108 if (dts != AV_NOPTS_VALUE)
1109 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1112 s->last_scr = dts - preload;
1115 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1116 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1119 if (dts != AV_NOPTS_VALUE) dts += preload;
1120 if (pts != AV_NOPTS_VALUE) pts += preload;
1122 av_dlog(ctx, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1123 dts / 90000.0, pts / 90000.0, pkt->flags,
1124 pkt->stream_index, pts != AV_NOPTS_VALUE);
1125 if (!stream->premux_packet)
1126 stream->next_packet = &stream->premux_packet;
1127 *stream->next_packet =
1128 pkt_desc = av_mallocz(sizeof(PacketDesc));
1129 pkt_desc->pts = pts;
1130 pkt_desc->dts = dts;
1131 pkt_desc->unwritten_size =
1132 pkt_desc->size = size;
1133 if (!stream->predecode_packet)
1134 stream->predecode_packet = pkt_desc;
1135 stream->next_packet = &pkt_desc->next;
1137 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1141 // min VOBU length 0.4 seconds (mpucoder)
1143 (s->packet_number == 0 ||
1144 (pts - stream->vobu_start_pts >= 36000))) {
1145 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1146 stream->align_iframe = 1;
1147 stream->vobu_start_pts = pts;
1151 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1154 int ret = output_packet(ctx, 0);
1160 static int mpeg_mux_end(AVFormatContext *ctx)
1166 int ret = output_packet(ctx, 1);
1173 /* End header according to MPEG1 systems standard. We do not write
1174 * it as it is usually not needed by decoders and because it
1175 * complicates MPEG stream concatenation. */
1176 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1177 // avio_flush(ctx->pb);
1179 for (i = 0; i < ctx->nb_streams; i++) {
1180 stream = ctx->streams[i]->priv_data;
1182 assert(av_fifo_size(stream->fifo) == 0);
1183 av_fifo_freep(&stream->fifo);
1188 #define OFFSET(x) offsetof(MpegMuxContext, x)
1189 #define E AV_OPT_FLAG_ENCODING_PARAM
1190 static const AVOption options[] = {
1191 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1192 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1196 #define MPEGENC_CLASS(flavor) \
1197 static const AVClass flavor ## _class = { \
1198 .class_name = #flavor " muxer", \
1199 .item_name = av_default_item_name, \
1200 .version = LIBAVUTIL_VERSION_INT, \
1201 .option = options, \
1204 #if CONFIG_MPEG1SYSTEM_MUXER
1206 AVOutputFormat ff_mpeg1system_muxer = {
1208 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1209 .mime_type = "video/mpeg",
1210 .extensions = "mpg,mpeg",
1211 .priv_data_size = sizeof(MpegMuxContext),
1212 .audio_codec = AV_CODEC_ID_MP2,
1213 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1214 .write_header = mpeg_mux_init,
1215 .write_packet = mpeg_mux_write_packet,
1216 .write_trailer = mpeg_mux_end,
1217 .priv_class = &mpeg_class,
1221 #if CONFIG_MPEG1VCD_MUXER
1223 AVOutputFormat ff_mpeg1vcd_muxer = {
1225 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1226 .mime_type = "video/mpeg",
1227 .priv_data_size = sizeof(MpegMuxContext),
1228 .audio_codec = AV_CODEC_ID_MP2,
1229 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1230 .write_header = mpeg_mux_init,
1231 .write_packet = mpeg_mux_write_packet,
1232 .write_trailer = mpeg_mux_end,
1233 .priv_class = &vcd_class,
1237 #if CONFIG_MPEG2VOB_MUXER
1239 AVOutputFormat ff_mpeg2vob_muxer = {
1241 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1242 .mime_type = "video/mpeg",
1243 .extensions = "vob",
1244 .priv_data_size = sizeof(MpegMuxContext),
1245 .audio_codec = AV_CODEC_ID_MP2,
1246 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1247 .write_header = mpeg_mux_init,
1248 .write_packet = mpeg_mux_write_packet,
1249 .write_trailer = mpeg_mux_end,
1250 .priv_class = &vob_class,
1254 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1255 #if CONFIG_MPEG2SVCD_MUXER
1257 AVOutputFormat ff_mpeg2svcd_muxer = {
1259 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1260 .mime_type = "video/mpeg",
1261 .extensions = "vob",
1262 .priv_data_size = sizeof(MpegMuxContext),
1263 .audio_codec = AV_CODEC_ID_MP2,
1264 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1265 .write_header = mpeg_mux_init,
1266 .write_packet = mpeg_mux_write_packet,
1267 .write_trailer = mpeg_mux_end,
1268 .priv_class = &svcd_class,
1272 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1273 #if CONFIG_MPEG2DVD_MUXER
1275 AVOutputFormat ff_mpeg2dvd_muxer = {
1277 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1278 .mime_type = "video/mpeg",
1279 .extensions = "dvd",
1280 .priv_data_size = sizeof(MpegMuxContext),
1281 .audio_codec = AV_CODEC_ID_MP2,
1282 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1283 .write_header = mpeg_mux_init,
1284 .write_packet = mpeg_mux_write_packet,
1285 .write_trailer = mpeg_mux_end,
1286 .priv_class = &dvd_class,