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, (void*)avio_write);
875 stream->bytes_to_iframe -= payload_size - stuffing_size;
881 if (pad_packet_bytes > 0)
882 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
884 for (i = 0; i < zero_trail_bytes; i++)
885 avio_w8(ctx->pb, 0x00);
891 /* only increase the stream packet number if this pack actually contains
892 * something that is specific to this stream! I.e. a dedicated header
895 stream->packet_number++;
897 return payload_size - stuffing_size;
900 static void put_vcd_padding_sector(AVFormatContext *ctx)
902 /* There are two ways to do this padding: writing a sector/pack
903 * of 0 values, or writing an MPEG padding pack. Both seem to
904 * work with most decoders, BUT the VCD standard only allows a 0-sector
905 * (see standard p. IV-4, IV-5).
906 * So a 0-sector it is... */
908 MpegMuxContext *s = ctx->priv_data;
911 for (i = 0; i < s->packet_size; i++)
914 s->vcd_padding_bytes_written += s->packet_size;
918 /* increasing the packet number is correct. The SCR of the following packs
919 * is calculated from the packet_number and it has to include the padding
920 * sector (it represents the sector index, not the MPEG pack index)
921 * (see VCD standard p. IV-6) */
925 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
929 for (i = 0; i < ctx->nb_streams; i++) {
930 AVStream *st = ctx->streams[i];
931 StreamInfo *stream = st->priv_data;
932 PacketDesc *pkt_desc;
934 while ((pkt_desc = stream->predecode_packet) &&
935 scr > pkt_desc->dts) { // FIXME: > vs >=
936 if (stream->buffer_index < pkt_desc->size ||
937 stream->predecode_packet == stream->premux_packet) {
938 av_log(ctx, AV_LOG_ERROR,
939 "buffer underflow st=%d bufi=%d size=%d\n",
940 i, stream->buffer_index, pkt_desc->size);
943 stream->buffer_index -= pkt_desc->size;
944 stream->predecode_packet = pkt_desc->next;
952 static int output_packet(AVFormatContext *ctx, int flush)
954 MpegMuxContext *s = ctx->priv_data;
957 int i, avail_space = 0, es_size, trailer_size;
959 int best_score = INT_MIN;
960 int ignore_constraints = 0;
961 int64_t scr = s->last_scr;
962 PacketDesc *timestamp_packet;
963 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
966 for (i = 0; i < ctx->nb_streams; i++) {
967 AVStream *st = ctx->streams[i];
968 StreamInfo *stream = st->priv_data;
969 const int avail_data = av_fifo_size(stream->fifo);
970 const int space = stream->max_buffer_size - stream->buffer_index;
971 int rel_space = 1024LL * space / stream->max_buffer_size;
972 PacketDesc *next_pkt = stream->premux_packet;
974 /* for subtitle, a single PES packet must be generated,
975 * so we flush after every single subtitle packet */
976 if (s->packet_size > avail_data && !flush
977 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
981 av_assert0(avail_data > 0);
983 if (space < s->packet_size && !ignore_constraints)
986 if (next_pkt && next_pkt->dts - scr > max_delay)
988 if ( stream->predecode_packet
989 && stream->predecode_packet->size > stream->buffer_index)
991 if (rel_space > best_score) {
992 best_score = rel_space;
999 int64_t best_dts = INT64_MAX;
1001 for (i = 0; i < ctx->nb_streams; i++) {
1002 AVStream *st = ctx->streams[i];
1003 StreamInfo *stream = st->priv_data;
1004 PacketDesc *pkt_desc = stream->predecode_packet;
1005 if (pkt_desc && pkt_desc->dts < best_dts)
1006 best_dts = pkt_desc->dts;
1009 av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1010 scr / 90000.0, best_dts / 90000.0);
1011 if (best_dts == INT64_MAX)
1014 if (scr >= best_dts + 1 && !ignore_constraints) {
1015 av_log(ctx, AV_LOG_ERROR,
1016 "packet too large, ignoring buffer limits to mux it\n");
1017 ignore_constraints = 1;
1019 scr = FFMAX(best_dts + 1, scr);
1020 if (remove_decoded_packets(ctx, scr) < 0)
1025 assert(best_i >= 0);
1027 st = ctx->streams[best_i];
1028 stream = st->priv_data;
1030 assert(av_fifo_size(stream->fifo) > 0);
1032 assert(avail_space >= s->packet_size || ignore_constraints);
1034 timestamp_packet = stream->premux_packet;
1035 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1038 trailer_size = timestamp_packet->unwritten_size;
1039 timestamp_packet = timestamp_packet->next;
1042 if (timestamp_packet) {
1043 av_dlog(ctx, "dts:%f pts:%f scr:%f stream:%d\n",
1044 timestamp_packet->dts / 90000.0,
1045 timestamp_packet->pts / 90000.0,
1046 scr / 90000.0, best_i);
1047 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1048 timestamp_packet->dts, scr, trailer_size);
1050 assert(av_fifo_size(stream->fifo) == trailer_size);
1051 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1056 /* Write one or more padding sectors, if necessary, to reach
1057 * the constant overall bitrate. */
1060 // FIXME: pts cannot be correct here
1061 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1062 put_vcd_padding_sector(ctx);
1063 // FIXME: rounding and first few bytes of each packet
1064 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1068 stream->buffer_index += es_size;
1069 // FIXME: rounding and first few bytes of each packet
1070 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1072 while (stream->premux_packet &&
1073 stream->premux_packet->unwritten_size <= es_size) {
1074 es_size -= stream->premux_packet->unwritten_size;
1075 stream->premux_packet = stream->premux_packet->next;
1078 stream->premux_packet->unwritten_size -= es_size;
1080 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1086 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1088 int stream_index = pkt->stream_index;
1089 int size = pkt->size;
1090 uint8_t *buf = pkt->data;
1091 MpegMuxContext *s = ctx->priv_data;
1092 AVStream *st = ctx->streams[stream_index];
1093 StreamInfo *stream = st->priv_data;
1095 PacketDesc *pkt_desc;
1097 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1098 (pkt->flags & AV_PKT_FLAG_KEY);
1100 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1105 if (s->last_scr == AV_NOPTS_VALUE) {
1106 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1107 if (dts != AV_NOPTS_VALUE)
1108 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1111 s->last_scr = dts - preload;
1114 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1115 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1118 if (dts != AV_NOPTS_VALUE) dts += preload;
1119 if (pts != AV_NOPTS_VALUE) pts += preload;
1121 av_dlog(ctx, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1122 dts / 90000.0, pts / 90000.0, pkt->flags,
1123 pkt->stream_index, pts != AV_NOPTS_VALUE);
1124 if (!stream->premux_packet)
1125 stream->next_packet = &stream->premux_packet;
1126 *stream->next_packet =
1127 pkt_desc = av_mallocz(sizeof(PacketDesc));
1128 pkt_desc->pts = pts;
1129 pkt_desc->dts = dts;
1130 pkt_desc->unwritten_size =
1131 pkt_desc->size = size;
1132 if (!stream->predecode_packet)
1133 stream->predecode_packet = pkt_desc;
1134 stream->next_packet = &pkt_desc->next;
1136 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1140 // min VOBU length 0.4 seconds (mpucoder)
1142 (s->packet_number == 0 ||
1143 (pts - stream->vobu_start_pts >= 36000))) {
1144 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1145 stream->align_iframe = 1;
1146 stream->vobu_start_pts = pts;
1150 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1153 int ret = output_packet(ctx, 0);
1159 static int mpeg_mux_end(AVFormatContext *ctx)
1165 int ret = output_packet(ctx, 1);
1172 /* End header according to MPEG1 systems standard. We do not write
1173 * it as it is usually not needed by decoders and because it
1174 * complicates MPEG stream concatenation. */
1175 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1176 // avio_flush(ctx->pb);
1178 for (i = 0; i < ctx->nb_streams; i++) {
1179 stream = ctx->streams[i]->priv_data;
1181 assert(av_fifo_size(stream->fifo) == 0);
1182 av_fifo_freep(&stream->fifo);
1187 #define OFFSET(x) offsetof(MpegMuxContext, x)
1188 #define E AV_OPT_FLAG_ENCODING_PARAM
1189 static const AVOption options[] = {
1190 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1191 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1195 #define MPEGENC_CLASS(flavor) \
1196 static const AVClass flavor ## _class = { \
1197 .class_name = #flavor " muxer", \
1198 .item_name = av_default_item_name, \
1199 .version = LIBAVUTIL_VERSION_INT, \
1200 .option = options, \
1203 #if CONFIG_MPEG1SYSTEM_MUXER
1205 AVOutputFormat ff_mpeg1system_muxer = {
1207 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1208 .mime_type = "video/mpeg",
1209 .extensions = "mpg,mpeg",
1210 .priv_data_size = sizeof(MpegMuxContext),
1211 .audio_codec = AV_CODEC_ID_MP2,
1212 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1213 .write_header = mpeg_mux_init,
1214 .write_packet = mpeg_mux_write_packet,
1215 .write_trailer = mpeg_mux_end,
1216 .priv_class = &mpeg_class,
1220 #if CONFIG_MPEG1VCD_MUXER
1222 AVOutputFormat ff_mpeg1vcd_muxer = {
1224 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1225 .mime_type = "video/mpeg",
1226 .priv_data_size = sizeof(MpegMuxContext),
1227 .audio_codec = AV_CODEC_ID_MP2,
1228 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1229 .write_header = mpeg_mux_init,
1230 .write_packet = mpeg_mux_write_packet,
1231 .write_trailer = mpeg_mux_end,
1232 .priv_class = &vcd_class,
1236 #if CONFIG_MPEG2VOB_MUXER
1238 AVOutputFormat ff_mpeg2vob_muxer = {
1240 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1241 .mime_type = "video/mpeg",
1242 .extensions = "vob",
1243 .priv_data_size = sizeof(MpegMuxContext),
1244 .audio_codec = AV_CODEC_ID_MP2,
1245 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1246 .write_header = mpeg_mux_init,
1247 .write_packet = mpeg_mux_write_packet,
1248 .write_trailer = mpeg_mux_end,
1249 .priv_class = &vob_class,
1253 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1254 #if CONFIG_MPEG2SVCD_MUXER
1256 AVOutputFormat ff_mpeg2svcd_muxer = {
1258 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1259 .mime_type = "video/mpeg",
1260 .extensions = "vob",
1261 .priv_data_size = sizeof(MpegMuxContext),
1262 .audio_codec = AV_CODEC_ID_MP2,
1263 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1264 .write_header = mpeg_mux_init,
1265 .write_packet = mpeg_mux_write_packet,
1266 .write_trailer = mpeg_mux_end,
1267 .priv_class = &svcd_class,
1271 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1272 #if CONFIG_MPEG2DVD_MUXER
1274 AVOutputFormat ff_mpeg2dvd_muxer = {
1276 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1277 .mime_type = "video/mpeg",
1278 .extensions = "dvd",
1279 .priv_data_size = sizeof(MpegMuxContext),
1280 .audio_codec = AV_CODEC_ID_MP2,
1281 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1282 .write_header = mpeg_mux_init,
1283 .write_packet = mpeg_mux_write_packet,
1284 .write_trailer = mpeg_mux_end,
1285 .priv_class = &dvd_class,