3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/fifo.h"
23 #include "libavutil/log.h"
24 #include "libavutil/mathematics.h"
25 #include "libavutil/opt.h"
26 #include "libavcodec/put_bits.h"
31 #define MAX_PAYLOAD_SIZE 4096
36 typedef struct PacketDesc {
42 struct PacketDesc *next;
48 int max_buffer_size; /* in bytes */
50 PacketDesc *predecode_packet;
51 PacketDesc *premux_packet;
52 PacketDesc **next_packet;
54 uint8_t lpcm_header[3];
58 int64_t vobu_start_pts;
63 int packet_size; /* required packet size */
65 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
66 int system_header_freq;
67 int system_header_size;
68 int mux_rate; /* bitrate in units of 50 bytes/s */
76 int64_t last_scr; /* current system clock */
78 double vcd_padding_bitrate; //FIXME floats
79 int64_t vcd_padding_bytes_written;
84 extern AVOutputFormat ff_mpeg1vcd_muxer;
85 extern AVOutputFormat ff_mpeg2dvd_muxer;
86 extern AVOutputFormat ff_mpeg2svcd_muxer;
87 extern AVOutputFormat ff_mpeg2vob_muxer;
89 static int put_pack_header(AVFormatContext *ctx,
90 uint8_t *buf, int64_t timestamp)
92 MpegMuxContext *s = ctx->priv_data;
95 init_put_bits(&pb, buf, 128);
97 put_bits32(&pb, PACK_START_CODE);
99 put_bits(&pb, 2, 0x1);
101 put_bits(&pb, 4, 0x2);
103 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
105 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
107 put_bits(&pb, 15, (uint32_t)((timestamp ) & 0x7fff));
110 /* 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,int only_for_stream_id)
127 MpegMuxContext *s = ctx->priv_data;
128 int size, i, private_stream_coded, id;
131 init_put_bits(&pb, buf, 128);
133 put_bits32(&pb, SYSTEM_HEADER_START_CODE);
134 put_bits(&pb, 16, 0);
137 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
138 put_bits(&pb, 1, 1); /* marker */
139 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
140 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
143 put_bits(&pb, 6, s->audio_bound);
146 /* see VCD standard, p. IV-7*/
150 put_bits(&pb, 1, 0); /* variable bitrate*/
151 put_bits(&pb, 1, 0); /* non constrainted bit stream */
154 if (s->is_vcd || s->is_dvd) {
155 /* see VCD standard p IV-7 */
156 put_bits(&pb, 1, 1); /* audio locked */
157 put_bits(&pb, 1, 1); /* video locked */
159 put_bits(&pb, 1, 0); /* audio locked */
160 put_bits(&pb, 1, 0); /* video locked */
163 put_bits(&pb, 1, 1); /* marker */
165 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
166 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
169 put_bits(&pb, 5, s->video_bound);
172 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
173 put_bits(&pb, 7, 0x7f); /* reserved byte */
175 put_bits(&pb, 8, 0xff); /* reserved byte */
177 /* DVD-Video Stream_bound entries
178 id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
179 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)
180 id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
181 id (0xBF) private stream 2, NAV packs, set to 2x1024. */
184 int P_STD_max_video = 0;
185 int P_STD_max_mpeg_audio = 0;
186 int P_STD_max_mpeg_PS1 = 0;
188 for(i=0;i<ctx->nb_streams;i++) {
189 StreamInfo *stream = ctx->streams[i]->priv_data;
192 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
193 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
194 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
195 P_STD_max_mpeg_audio = stream->max_buffer_size;
196 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
197 P_STD_max_video = stream->max_buffer_size;
202 put_bits(&pb, 8, 0xb9); /* stream ID */
205 put_bits(&pb, 13, P_STD_max_video / 1024);
208 if (P_STD_max_mpeg_audio == 0)
209 P_STD_max_mpeg_audio = 4096;
210 put_bits(&pb, 8, 0xb8); /* stream ID */
213 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
215 /* private stream 1 */
216 put_bits(&pb, 8, 0xbd); /* stream ID */
219 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
221 /* private stream 2 */
222 put_bits(&pb, 8, 0xbf); /* stream ID */
225 put_bits(&pb, 13, 2);
228 /* audio stream info */
229 private_stream_coded = 0;
230 for(i=0;i<ctx->nb_streams;i++) {
231 StreamInfo *stream = ctx->streams[i]->priv_data;
234 /* For VCDs, only include the stream info for the stream
235 that the pack which contains this system belongs to.
236 (see VCD standard p. IV-7) */
237 if ( !s->is_vcd || stream->id==only_for_stream_id
238 || only_for_stream_id==0) {
242 /* special case for private streams (AC-3 uses that) */
243 if (private_stream_coded)
245 private_stream_coded = 1;
248 put_bits(&pb, 8, id); /* stream ID */
253 put_bits(&pb, 13, stream->max_buffer_size / 128);
257 put_bits(&pb, 13, stream->max_buffer_size / 1024);
264 size = put_bits_ptr(&pb) - pb.buf;
265 /* patch packet size */
266 buf[4] = (size - 6) >> 8;
267 buf[5] = (size - 6) & 0xff;
272 static int get_system_header_size(AVFormatContext *ctx)
274 int buf_index, i, private_stream_coded;
276 MpegMuxContext *s = ctx->priv_data;
279 return 18; // DVD-Video system headers are 18 bytes fixed length.
282 private_stream_coded = 0;
283 for(i=0;i<ctx->nb_streams;i++) {
284 stream = ctx->streams[i]->priv_data;
285 if (stream->id < 0xc0) {
286 if (private_stream_coded)
288 private_stream_coded = 1;
295 static int mpeg_mux_init(AVFormatContext *ctx)
297 MpegMuxContext *s = ctx->priv_data;
298 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
304 s->packet_number = 0;
305 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
306 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
307 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
308 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
309 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
310 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
312 if(ctx->packet_size) {
313 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
314 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
318 s->packet_size = ctx->packet_size;
320 s->packet_size = 2048;
321 if (ctx->max_delay < 0) /* Not set by the caller */
324 s->vcd_padding_bytes_written = 0;
325 s->vcd_padding_bitrate=0;
335 for(i=0;i<ctx->nb_streams;i++) {
336 st = ctx->streams[i];
337 stream = av_mallocz(sizeof(StreamInfo));
340 st->priv_data = stream;
342 avpriv_set_pts_info(st, 64, 1, 90000);
344 switch(st->codec->codec_type) {
345 case AVMEDIA_TYPE_AUDIO:
346 if (st->codec->codec_id == CODEC_ID_AC3) {
347 stream->id = ac3_id++;
348 } else if (st->codec->codec_id == CODEC_ID_DTS) {
349 stream->id = dts_id++;
350 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
351 stream->id = lpcm_id++;
352 for(j = 0; j < 4; j++) {
353 if (lpcm_freq_tab[j] == st->codec->sample_rate)
358 if (st->codec->channels > 8)
360 stream->lpcm_header[0] = 0x0c;
361 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
362 stream->lpcm_header[2] = 0x80;
363 stream->lpcm_align = st->codec->channels * 2;
365 stream->id = mpa_id++;
368 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
369 Right now it is also used for everything else.*/
370 stream->max_buffer_size = 4 * 1024;
373 case AVMEDIA_TYPE_VIDEO:
374 stream->id = mpv_id++;
375 if (st->codec->rc_buffer_size)
376 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
378 av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, muxing may fail\n");
379 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
382 /* see VCD standard, p. IV-7*/
383 stream->max_buffer_size = 46 * 1024;
385 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
386 Right now it is also used for everything else.*/
387 stream->max_buffer_size = 230 * 1024;
391 case AVMEDIA_TYPE_SUBTITLE:
392 stream->id = mps_id++;
393 stream->max_buffer_size = 16 * 1024;
398 stream->fifo= av_fifo_alloc(16);
405 for(i=0;i<ctx->nb_streams;i++) {
407 st = ctx->streams[i];
408 stream = (StreamInfo*) st->priv_data;
410 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
411 codec_rate= st->codec->rc_max_rate;
413 codec_rate= st->codec->bit_rate;
416 codec_rate= (1<<21)*8*50/ctx->nb_streams;
418 bitrate += codec_rate;
420 if ((stream->id & 0xe0) == AUDIO_ID)
421 audio_bitrate += codec_rate;
422 else if (stream->id==VIDEO_ID)
423 video_bitrate += codec_rate;
427 /* we increase slightly the bitrate to take into account the
428 headers. XXX: compute it exactly */
429 bitrate += bitrate / 20;
431 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
435 double overhead_rate;
437 /* The VCD standard mandates that the mux_rate field is 3528
438 (see standard p. IV-6).
439 The value is actually "wrong", i.e. if you calculate
440 it using the normal formula and the 75 sectors per second transfer
441 rate you get a different value because the real pack size is 2324,
442 not 2352. But the standard explicitly specifies that the mux_rate
443 field in the header must have this value.*/
444 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
446 /* The VCD standard states that the muxed stream must be
447 exactly 75 packs / second (the data rate of a single speed cdrom).
448 Since the video bitrate (probably 1150000 bits/sec) will be below
449 the theoretical maximum we have to add some padding packets
450 to make up for the lower data rate.
451 (cf. VCD standard p. IV-6 )*/
453 /* Add the header overhead to the data rate.
454 2279 data bytes per audio pack, 2294 data bytes per video pack*/
455 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
456 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
459 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
460 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
463 if (s->is_vcd || s->is_mpeg2)
465 s->pack_header_freq = 1;
467 /* every 2 seconds */
468 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
470 /* the above seems to make pack_header_freq zero sometimes */
471 if (s->pack_header_freq == 0)
472 s->pack_header_freq = 1;
475 /* every 200 packets. Need to look at the spec. */
476 s->system_header_freq = s->pack_header_freq * 40;
478 /* the standard mandates that there are only two system headers
479 in the whole file: one in the first packet of each stream.
480 (see standard p. IV-7 and IV-8) */
481 s->system_header_freq = 0x7fffffff;
483 s->system_header_freq = s->pack_header_freq * 5;
485 for(i=0;i<ctx->nb_streams;i++) {
486 stream = ctx->streams[i]->priv_data;
487 stream->packet_number = 0;
489 s->system_header_size = get_system_header_size(ctx);
493 for(i=0;i<ctx->nb_streams;i++) {
494 av_free(ctx->streams[i]->priv_data);
496 return AVERROR(ENOMEM);
499 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
503 (((timestamp >> 30) & 0x07) << 1) |
505 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
506 avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
510 /* return the number of padding bytes that should be inserted into
511 the multiplexed stream.*/
512 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
514 MpegMuxContext *s = ctx->priv_data;
517 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
519 int64_t full_pad_bytes;
521 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
522 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
525 /* might happen if we have already padded to a later timestamp. This
526 can occur if another stream has already advanced further.*/
534 #if 0 /* unused, remove? */
535 /* return the exact available payload size for the next packet for
536 stream 'stream_index'. 'pts' and 'dts' are only used to know if
537 timestamps are needed in the packet header. */
538 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
539 int64_t pts, int64_t dts)
541 MpegMuxContext *s = ctx->priv_data;
545 stream = ctx->streams[stream_index]->priv_data;
548 if (((s->packet_number % s->pack_header_freq) == 0)) {
549 /* pack header size */
556 /* there is exactly one system header for each stream in a VCD MPEG,
557 One in the very first video packet and one in the very first
558 audio packet (see VCD standard p. IV-7 and IV-8).*/
560 if (stream->packet_number==0)
561 /* The system headers refer only to the stream they occur in,
562 so they have a constant size.*/
566 if ((s->packet_number % s->system_header_freq) == 0)
567 buf_index += s->system_header_size;
571 if ((s->is_vcd && stream->packet_number==0)
572 || (s->is_svcd && s->packet_number==0))
573 /* the first pack of each stream contains only the pack header,
574 the system header and some padding (see VCD standard p. IV-6)
575 Add the padding size, so that the actual payload becomes 0.*/
576 buf_index += s->packet_size - buf_index;
578 /* packet header size */
582 if (stream->packet_number==0)
583 buf_index += 3; /* PES extension */
584 buf_index += 1; /* obligatory stuffing byte */
586 if (pts != AV_NOPTS_VALUE) {
597 if (stream->id < 0xc0) {
598 /* AC-3/LPCM private data header */
600 if (stream->id >= 0xa0) {
603 /* NOTE: we round the payload size to an integer number of
605 n = (s->packet_size - buf_index) % stream->lpcm_align;
607 buf_index += (stream->lpcm_align - n);
611 if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID)
612 /* The VCD standard demands that 20 zero bytes follow
613 each audio packet (see standard p. IV-8).*/
616 return s->packet_size - buf_index;
620 /* Write an MPEG padding packet header. */
621 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
623 MpegMuxContext *s = ctx->priv_data;
626 avio_wb32(pb, PADDING_STREAM);
627 avio_wb16(pb, packet_bytes - 6);
634 for(i=0;i<packet_bytes;i++)
638 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
640 PacketDesc *pkt_desc= stream->premux_packet;
643 if(pkt_desc->size == pkt_desc->unwritten_size)
645 len -= pkt_desc->unwritten_size;
646 pkt_desc= pkt_desc->next;
652 /* flush the packet on stream stream_index */
653 static int flush_packet(AVFormatContext *ctx, int stream_index,
654 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
656 MpegMuxContext *s = ctx->priv_data;
657 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
659 int size, payload_size, startcode, id, stuffing_size, i, header_len;
662 int zero_trail_bytes = 0;
663 int pad_packet_bytes = 0;
665 int general_pack = 0; /*"general" pack without data specific to one stream?*/
670 av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
674 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
675 /* output pack and systems header if needed */
676 size = put_pack_header(ctx, buf_ptr, scr);
681 /* there is exactly one system header for each stream in a VCD MPEG,
682 One in the very first video packet and one in the very first
683 audio packet (see VCD standard p. IV-7 and IV-8).*/
685 if (stream->packet_number==0) {
686 size = put_system_header(ctx, buf_ptr, id);
689 } else if (s->is_dvd) {
690 if (stream->align_iframe || s->packet_number == 0){
691 int PES_bytes_to_fill = s->packet_size - size - 10;
693 if (pts != AV_NOPTS_VALUE) {
695 PES_bytes_to_fill -= 5 + 5;
697 PES_bytes_to_fill -= 5;
700 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
701 size = put_system_header(ctx, buf_ptr, 0);
703 size = buf_ptr - buffer;
704 avio_write(ctx->pb, buffer, size);
706 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
707 avio_wb16(ctx->pb, 0x03d4); // length
708 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
709 for (i = 0; i < 979; i++)
710 avio_w8(ctx->pb, 0x00);
712 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
713 avio_wb16(ctx->pb, 0x03fa); // length
714 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
715 for (i = 0; i < 1017; i++)
716 avio_w8(ctx->pb, 0x00);
718 memset(buffer, 0, 128);
721 stream->align_iframe = 0;
722 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
723 size = put_pack_header(ctx, buf_ptr, scr);
727 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
728 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
732 if ((s->packet_number % s->system_header_freq) == 0) {
733 size = put_system_header(ctx, buf_ptr, 0);
738 size = buf_ptr - buffer;
739 avio_write(ctx->pb, buffer, size);
741 packet_size = s->packet_size - size;
743 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
744 /* The VCD standard demands that 20 zero bytes follow
745 each audio pack (see standard p. IV-8).*/
746 zero_trail_bytes += 20;
748 if ((s->is_vcd && stream->packet_number==0)
749 || (s->is_svcd && s->packet_number==0)) {
750 /* for VCD the first pack of each stream contains only the pack header,
751 the system header and lots of padding (see VCD standard p. IV-6).
752 In the case of an audio pack, 20 zero bytes are also added at
754 /* For SVCD we fill the very first pack to increase compatibility with
755 some DVD players. Not mandated by the standard.*/
757 general_pack = 1; /* the system header refers to both streams and no stream data*/
758 pad_packet_bytes = packet_size - zero_trail_bytes;
761 packet_size -= pad_packet_bytes + zero_trail_bytes;
763 if (packet_size > 0) {
765 /* packet header size */
771 if (stream->packet_number==0)
772 header_len += 3; /* PES extension */
773 header_len += 1; /* obligatory stuffing byte */
777 if (pts != AV_NOPTS_VALUE) {
787 payload_size = packet_size - header_len;
789 startcode = PRIVATE_STREAM_1;
797 startcode = 0x100 + id;
800 stuffing_size = payload_size - av_fifo_size(stream->fifo);
802 // first byte does not fit -> reset pts/dts + stuffing
803 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
807 if(pts != AV_NOPTS_VALUE)
808 timestamp_len += s->is_mpeg2 ? 5 : 4;
809 pts=dts= AV_NOPTS_VALUE;
810 header_len -= timestamp_len;
811 if (s->is_dvd && stream->align_iframe) {
812 pad_packet_bytes += timestamp_len;
813 packet_size -= timestamp_len;
815 payload_size += timestamp_len;
817 stuffing_size += timestamp_len;
818 if(payload_size > trailer_size)
819 stuffing_size += payload_size - trailer_size;
822 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
823 packet_size += pad_packet_bytes;
824 payload_size += pad_packet_bytes; // undo the previous adjustment
825 if (stuffing_size < 0) {
826 stuffing_size = pad_packet_bytes;
828 stuffing_size += pad_packet_bytes;
830 pad_packet_bytes = 0;
833 if (stuffing_size < 0)
835 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
836 pad_packet_bytes += stuffing_size;
837 packet_size -= stuffing_size;
838 payload_size -= stuffing_size;
842 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
844 avio_wb32(ctx->pb, startcode);
846 avio_wb16(ctx->pb, packet_size);
849 for(i=0;i<stuffing_size;i++)
850 avio_w8(ctx->pb, 0xff);
853 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
857 if (pts != AV_NOPTS_VALUE) {
863 /* Both the MPEG-2 and the SVCD standards demand that the
864 P-STD_buffer_size field be included in the first packet of
865 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
866 and MPEG-2 standard 2.7.7) */
867 if (stream->packet_number == 0)
870 avio_w8(ctx->pb, pes_flags); /* flags */
871 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
873 if (pes_flags & 0x80) /*write pts*/
874 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
875 if (pes_flags & 0x40) /*write dts*/
876 put_timestamp(ctx->pb, 0x01, dts);
878 if (pes_flags & 0x01) { /*write pes extension*/
879 avio_w8(ctx->pb, 0x10); /* flags */
881 /* P-STD buffer info */
882 if ((id & 0xe0) == AUDIO_ID)
883 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
885 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
889 if (pts != AV_NOPTS_VALUE) {
891 put_timestamp(ctx->pb, 0x03, pts);
892 put_timestamp(ctx->pb, 0x01, dts);
894 put_timestamp(ctx->pb, 0x02, pts);
897 avio_w8(ctx->pb, 0x0f);
902 /* special stuffing byte that is always written
903 to prevent accidental generation of start codes. */
904 avio_w8(ctx->pb, 0xff);
906 for(i=0;i<stuffing_size;i++)
907 avio_w8(ctx->pb, 0xff);
910 if (startcode == PRIVATE_STREAM_1) {
911 avio_w8(ctx->pb, id);
913 /* LPCM (XXX: check nb_frames) */
915 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
916 avio_w8(ctx->pb, stream->lpcm_header[0]);
917 avio_w8(ctx->pb, stream->lpcm_header[1]);
918 avio_w8(ctx->pb, stream->lpcm_header[2]);
919 } else if (id >= 0x40) {
921 avio_w8(ctx->pb, nb_frames);
922 avio_wb16(ctx->pb, trailer_size+1);
927 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
928 av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &avio_write);
929 stream->bytes_to_iframe -= payload_size - stuffing_size;
935 if (pad_packet_bytes > 0)
936 put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
938 for(i=0;i<zero_trail_bytes;i++)
939 avio_w8(ctx->pb, 0x00);
945 /* only increase the stream packet number if this pack actually contains
946 something that is specific to this stream! I.e. a dedicated header
949 stream->packet_number++;
951 return payload_size - stuffing_size;
954 static void put_vcd_padding_sector(AVFormatContext *ctx)
956 /* There are two ways to do this padding: writing a sector/pack
957 of 0 values, or writing an MPEG padding pack. Both seem to
958 work with most decoders, BUT the VCD standard only allows a 0-sector
959 (see standard p. IV-4, IV-5).
960 So a 0-sector it is...*/
962 MpegMuxContext *s = ctx->priv_data;
965 for(i=0;i<s->packet_size;i++)
968 s->vcd_padding_bytes_written += s->packet_size;
972 /* increasing the packet number is correct. The SCR of the following packs
973 is calculated from the packet_number and it has to include the padding
974 sector (it represents the sector index, not the MPEG pack index)
975 (see VCD standard p. IV-6)*/
979 #if 0 /* unused, remove? */
980 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
982 MpegMuxContext *s = ctx->priv_data;
985 /* Since the data delivery rate is constant, SCR is computed
986 using the formula C + i * 1200 where C is the start constant
987 and i is the pack index.
988 It is recommended that SCR 0 is at the beginning of the VCD front
989 margin (a sequence of empty Form 2 sectors on the CD).
990 It is recommended that the front margin is 30 sectors long, so
991 we use C = 30*1200 = 36000
992 (Note that even if the front margin is not 30 sectors the file
993 will still be correct according to the standard. It just won't have
994 the "recommended" value).*/
995 scr = 36000 + s->packet_number * 1200;
1001 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1002 // MpegMuxContext *s = ctx->priv_data;
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;
1010 while((pkt_desc= stream->predecode_packet)
1011 && scr > pkt_desc->dts){ //FIXME > vs >=
1012 if(stream->buffer_index < pkt_desc->size ||
1013 stream->predecode_packet == stream->premux_packet){
1014 av_log(ctx, AV_LOG_ERROR,
1015 "buffer underflow i=%d bufi=%d size=%d\n",
1016 i, stream->buffer_index, pkt_desc->size);
1019 stream->buffer_index -= pkt_desc->size;
1021 stream->predecode_packet= pkt_desc->next;
1022 av_freep(&pkt_desc);
1029 static int output_packet(AVFormatContext *ctx, int flush){
1030 MpegMuxContext *s = ctx->priv_data;
1033 int i, avail_space=0, es_size, trailer_size;
1035 int best_score= INT_MIN;
1036 int ignore_constraints=0;
1037 int64_t scr= s->last_scr;
1038 PacketDesc *timestamp_packet;
1039 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1042 for(i=0; i<ctx->nb_streams; i++){
1043 AVStream *st = ctx->streams[i];
1044 StreamInfo *stream = st->priv_data;
1045 const int avail_data= av_fifo_size(stream->fifo);
1046 const int space= stream->max_buffer_size - stream->buffer_index;
1047 int rel_space= 1024*space / stream->max_buffer_size;
1048 PacketDesc *next_pkt= stream->premux_packet;
1050 /* for subtitle, a single PES packet must be generated,
1051 so we flush after every single subtitle packet */
1052 if(s->packet_size > avail_data && !flush
1053 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1057 assert(avail_data>0);
1059 if(space < s->packet_size && !ignore_constraints)
1062 if(next_pkt && next_pkt->dts - scr > max_delay)
1065 if(rel_space > best_score){
1066 best_score= rel_space;
1073 int64_t best_dts= INT64_MAX;
1075 for(i=0; i<ctx->nb_streams; i++){
1076 AVStream *st = ctx->streams[i];
1077 StreamInfo *stream = st->priv_data;
1078 PacketDesc *pkt_desc= stream->predecode_packet;
1079 if(pkt_desc && pkt_desc->dts < best_dts)
1080 best_dts= pkt_desc->dts;
1083 av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1084 scr / 90000.0, best_dts / 90000.0);
1085 if(best_dts == INT64_MAX)
1088 if(scr >= best_dts+1 && !ignore_constraints){
1089 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1090 ignore_constraints= 1;
1092 scr= FFMAX(best_dts+1, scr);
1093 if(remove_decoded_packets(ctx, scr) < 0)
1098 assert(best_i >= 0);
1100 st = ctx->streams[best_i];
1101 stream = st->priv_data;
1103 assert(av_fifo_size(stream->fifo) > 0);
1105 assert(avail_space >= s->packet_size || ignore_constraints);
1107 timestamp_packet= stream->premux_packet;
1108 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1111 trailer_size= timestamp_packet->unwritten_size;
1112 timestamp_packet= timestamp_packet->next;
1115 if(timestamp_packet){
1116 //av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f scr:%f stream:%d\n", timestamp_packet->dts/90000.0, timestamp_packet->pts/90000.0, scr/90000.0, best_i);
1117 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1119 assert(av_fifo_size(stream->fifo) == trailer_size);
1120 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1124 /* Write one or more padding sectors, if necessary, to reach
1125 the constant overall bitrate.*/
1128 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1129 put_vcd_padding_sector(ctx);
1130 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1134 stream->buffer_index += es_size;
1135 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1137 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1138 es_size -= stream->premux_packet->unwritten_size;
1139 stream->premux_packet= stream->premux_packet->next;
1142 stream->premux_packet->unwritten_size -= es_size;
1144 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1150 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1152 MpegMuxContext *s = ctx->priv_data;
1153 int stream_index= pkt->stream_index;
1154 int size= pkt->size;
1155 uint8_t *buf= pkt->data;
1156 AVStream *st = ctx->streams[stream_index];
1157 StreamInfo *stream = st->priv_data;
1159 PacketDesc *pkt_desc;
1161 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1163 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1168 if(pts != AV_NOPTS_VALUE) pts += 2*preload;
1169 if(dts != AV_NOPTS_VALUE){
1171 s->last_scr= dts + preload;
1175 //av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index, pts != AV_NOPTS_VALUE);
1176 if (!stream->premux_packet)
1177 stream->next_packet = &stream->premux_packet;
1178 *stream->next_packet=
1179 pkt_desc= av_mallocz(sizeof(PacketDesc));
1182 pkt_desc->unwritten_size=
1183 pkt_desc->size= size;
1184 if(!stream->predecode_packet)
1185 stream->predecode_packet= pkt_desc;
1186 stream->next_packet= &pkt_desc->next;
1188 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1192 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1193 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1194 stream->align_iframe = 1;
1195 stream->vobu_start_pts = pts;
1199 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1202 int ret= output_packet(ctx, 0);
1208 static int mpeg_mux_end(AVFormatContext *ctx)
1210 // MpegMuxContext *s = ctx->priv_data;
1215 int ret= output_packet(ctx, 1);
1222 /* End header according to MPEG1 systems standard. We do not write
1223 it as it is usually not needed by decoders and because it
1224 complicates MPEG stream concatenation. */
1225 //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1226 //avio_flush(ctx->pb);
1228 for(i=0;i<ctx->nb_streams;i++) {
1229 stream = ctx->streams[i]->priv_data;
1231 assert(av_fifo_size(stream->fifo) == 0);
1232 av_fifo_free(stream->fifo);
1237 #define OFFSET(x) offsetof(MpegMuxContext, x)
1238 #define E AV_OPT_FLAG_ENCODING_PARAM
1239 static const AVOption options[] = {
1240 { "muxrate", NULL, OFFSET(mux_rate), AV_OPT_TYPE_INT, {0}, 0, INT_MAX, E },
1241 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, {500000}, 0, INT_MAX, E},
1245 #define MPEGENC_CLASS(flavor)\
1246 static const AVClass flavor ## _class = {\
1247 .class_name = #flavor " muxer",\
1248 .item_name = av_default_item_name,\
1249 .version = LIBAVUTIL_VERSION_INT,\
1253 #if CONFIG_MPEG1SYSTEM_MUXER
1255 AVOutputFormat ff_mpeg1system_muxer = {
1257 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1258 .mime_type = "video/mpeg",
1259 .extensions = "mpg,mpeg",
1260 .priv_data_size = sizeof(MpegMuxContext),
1261 .audio_codec = CODEC_ID_MP2,
1262 .video_codec = CODEC_ID_MPEG1VIDEO,
1263 .write_header = mpeg_mux_init,
1264 .write_packet = mpeg_mux_write_packet,
1265 .write_trailer = mpeg_mux_end,
1266 .priv_class = &mpeg_class,
1269 #if CONFIG_MPEG1VCD_MUXER
1271 AVOutputFormat ff_mpeg1vcd_muxer = {
1273 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1274 .mime_type = "video/mpeg",
1275 .priv_data_size = sizeof(MpegMuxContext),
1276 .audio_codec = CODEC_ID_MP2,
1277 .video_codec = CODEC_ID_MPEG1VIDEO,
1278 .write_header = mpeg_mux_init,
1279 .write_packet = mpeg_mux_write_packet,
1280 .write_trailer = mpeg_mux_end,
1281 .priv_class = &vcd_class,
1284 #if CONFIG_MPEG2VOB_MUXER
1286 AVOutputFormat ff_mpeg2vob_muxer = {
1288 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1289 .mime_type = "video/mpeg",
1290 .extensions = "vob",
1291 .priv_data_size = sizeof(MpegMuxContext),
1292 .audio_codec = CODEC_ID_MP2,
1293 .video_codec = CODEC_ID_MPEG2VIDEO,
1294 .write_header = mpeg_mux_init,
1295 .write_packet = mpeg_mux_write_packet,
1296 .write_trailer = mpeg_mux_end,
1297 .priv_class = &vob_class,
1301 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1302 #if CONFIG_MPEG2SVCD_MUXER
1304 AVOutputFormat ff_mpeg2svcd_muxer = {
1306 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1307 .mime_type = "video/mpeg",
1308 .extensions = "vob",
1309 .priv_data_size = sizeof(MpegMuxContext),
1310 .audio_codec = CODEC_ID_MP2,
1311 .video_codec = CODEC_ID_MPEG2VIDEO,
1312 .write_header = mpeg_mux_init,
1313 .write_packet = mpeg_mux_write_packet,
1314 .write_trailer = mpeg_mux_end,
1315 .priv_class = &svcd_class,
1319 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1320 #if CONFIG_MPEG2DVD_MUXER
1322 AVOutputFormat ff_mpeg2dvd_muxer = {
1324 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1325 .mime_type = "video/mpeg",
1326 .extensions = "dvd",
1327 .priv_data_size = sizeof(MpegMuxContext),
1328 .audio_codec = CODEC_ID_MP2,
1329 .video_codec = CODEC_ID_MPEG2VIDEO,
1330 .write_header = mpeg_mux_init,
1331 .write_packet = mpeg_mux_write_packet,
1332 .write_trailer = mpeg_mux_end,
1333 .priv_class = &dvd_class,