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
22 #include "libavutil/fifo.h"
23 #include "libavcodec/put_bits.h"
27 #define MAX_PAYLOAD_SIZE 4096
32 typedef struct PacketDesc {
38 struct PacketDesc *next;
44 int max_buffer_size; /* in bytes */
46 PacketDesc *predecode_packet;
47 PacketDesc *premux_packet;
48 PacketDesc **next_packet;
50 uint8_t lpcm_header[3];
54 int64_t vobu_start_pts;
58 int packet_size; /* required packet size */
60 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
61 int system_header_freq;
62 int system_header_size;
63 int mux_rate; /* bitrate in units of 50 bytes/s */
71 int64_t last_scr; /* current system clock */
73 double vcd_padding_bitrate; //FIXME floats
74 int64_t vcd_padding_bytes_written;
78 extern AVOutputFormat ff_mpeg1vcd_muxer;
79 extern AVOutputFormat ff_mpeg2dvd_muxer;
80 extern AVOutputFormat ff_mpeg2svcd_muxer;
81 extern AVOutputFormat ff_mpeg2vob_muxer;
83 static int put_pack_header(AVFormatContext *ctx,
84 uint8_t *buf, int64_t timestamp)
86 MpegMuxContext *s = ctx->priv_data;
89 init_put_bits(&pb, buf, 128);
91 put_bits32(&pb, PACK_START_CODE);
93 put_bits(&pb, 2, 0x1);
95 put_bits(&pb, 4, 0x2);
97 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
99 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
101 put_bits(&pb, 15, (uint32_t)((timestamp ) & 0x7fff));
104 /* clock extension */
108 put_bits(&pb, 22, s->mux_rate);
112 put_bits(&pb, 5, 0x1f); /* reserved */
113 put_bits(&pb, 3, 0); /* stuffing length */
116 return put_bits_ptr(&pb) - pb.buf;
119 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
121 MpegMuxContext *s = ctx->priv_data;
122 int size, i, private_stream_coded, id;
125 init_put_bits(&pb, buf, 128);
127 put_bits32(&pb, SYSTEM_HEADER_START_CODE);
128 put_bits(&pb, 16, 0);
131 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
132 put_bits(&pb, 1, 1); /* marker */
133 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
134 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
137 put_bits(&pb, 6, s->audio_bound);
140 /* see VCD standard, p. IV-7*/
144 put_bits(&pb, 1, 0); /* variable bitrate*/
145 put_bits(&pb, 1, 0); /* non constrainted bit stream */
148 if (s->is_vcd || s->is_dvd) {
149 /* see VCD standard p IV-7 */
150 put_bits(&pb, 1, 1); /* audio locked */
151 put_bits(&pb, 1, 1); /* video locked */
153 put_bits(&pb, 1, 0); /* audio locked */
154 put_bits(&pb, 1, 0); /* video locked */
157 put_bits(&pb, 1, 1); /* marker */
159 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
160 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
163 put_bits(&pb, 5, s->video_bound);
166 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
167 put_bits(&pb, 7, 0x7f); /* reserved byte */
169 put_bits(&pb, 8, 0xff); /* reserved byte */
171 /* DVD-Video Stream_bound entries
172 id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
173 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)
174 id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
175 id (0xBF) private stream 2, NAV packs, set to 2x1024. */
178 int P_STD_max_video = 0;
179 int P_STD_max_mpeg_audio = 0;
180 int P_STD_max_mpeg_PS1 = 0;
182 for(i=0;i<ctx->nb_streams;i++) {
183 StreamInfo *stream = ctx->streams[i]->priv_data;
186 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
187 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
188 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
189 P_STD_max_mpeg_audio = stream->max_buffer_size;
190 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
191 P_STD_max_video = stream->max_buffer_size;
196 put_bits(&pb, 8, 0xb9); /* stream ID */
199 put_bits(&pb, 13, P_STD_max_video / 1024);
202 if (P_STD_max_mpeg_audio == 0)
203 P_STD_max_mpeg_audio = 4096;
204 put_bits(&pb, 8, 0xb8); /* stream ID */
207 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
209 /* private stream 1 */
210 put_bits(&pb, 8, 0xbd); /* stream ID */
213 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
215 /* private stream 2 */
216 put_bits(&pb, 8, 0xbf); /* stream ID */
219 put_bits(&pb, 13, 2);
222 /* audio stream info */
223 private_stream_coded = 0;
224 for(i=0;i<ctx->nb_streams;i++) {
225 StreamInfo *stream = ctx->streams[i]->priv_data;
228 /* For VCDs, only include the stream info for the stream
229 that the pack which contains this system belongs to.
230 (see VCD standard p. IV-7) */
231 if ( !s->is_vcd || stream->id==only_for_stream_id
232 || only_for_stream_id==0) {
236 /* special case for private streams (AC-3 uses that) */
237 if (private_stream_coded)
239 private_stream_coded = 1;
242 put_bits(&pb, 8, id); /* stream ID */
247 put_bits(&pb, 13, stream->max_buffer_size / 128);
251 put_bits(&pb, 13, stream->max_buffer_size / 1024);
258 size = put_bits_ptr(&pb) - pb.buf;
259 /* patch packet size */
260 buf[4] = (size - 6) >> 8;
261 buf[5] = (size - 6) & 0xff;
266 static int get_system_header_size(AVFormatContext *ctx)
268 int buf_index, i, private_stream_coded;
270 MpegMuxContext *s = ctx->priv_data;
273 return 18; // DVD-Video system headers are 18 bytes fixed length.
276 private_stream_coded = 0;
277 for(i=0;i<ctx->nb_streams;i++) {
278 stream = ctx->streams[i]->priv_data;
279 if (stream->id < 0xc0) {
280 if (private_stream_coded)
282 private_stream_coded = 1;
289 static int mpeg_mux_init(AVFormatContext *ctx)
291 MpegMuxContext *s = ctx->priv_data;
292 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
298 s->packet_number = 0;
299 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
300 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
301 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
302 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
303 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
304 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
306 if(ctx->packet_size) {
307 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
308 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
312 s->packet_size = ctx->packet_size;
314 s->packet_size = 2048;
316 s->vcd_padding_bytes_written = 0;
317 s->vcd_padding_bitrate=0;
327 for(i=0;i<ctx->nb_streams;i++) {
328 st = ctx->streams[i];
329 stream = av_mallocz(sizeof(StreamInfo));
332 st->priv_data = stream;
334 av_set_pts_info(st, 64, 1, 90000);
336 switch(st->codec->codec_type) {
337 case AVMEDIA_TYPE_AUDIO:
338 if (st->codec->codec_id == CODEC_ID_AC3) {
339 stream->id = ac3_id++;
340 } else if (st->codec->codec_id == CODEC_ID_DTS) {
341 stream->id = dts_id++;
342 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
343 stream->id = lpcm_id++;
344 for(j = 0; j < 4; j++) {
345 if (lpcm_freq_tab[j] == st->codec->sample_rate)
350 if (st->codec->channels > 8)
352 stream->lpcm_header[0] = 0x0c;
353 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
354 stream->lpcm_header[2] = 0x80;
355 stream->lpcm_align = st->codec->channels * 2;
357 stream->id = mpa_id++;
360 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
361 Right now it is also used for everything else.*/
362 stream->max_buffer_size = 4 * 1024;
365 case AVMEDIA_TYPE_VIDEO:
366 stream->id = mpv_id++;
367 if (st->codec->rc_buffer_size)
368 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
370 av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, muxing may fail\n");
371 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
374 /* see VCD standard, p. IV-7*/
375 stream->max_buffer_size = 46 * 1024;
377 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
378 Right now it is also used for everything else.*/
379 stream->max_buffer_size = 230 * 1024;
383 case AVMEDIA_TYPE_SUBTITLE:
384 stream->id = mps_id++;
385 stream->max_buffer_size = 16 * 1024;
390 stream->fifo= av_fifo_alloc(16);
397 for(i=0;i<ctx->nb_streams;i++) {
399 st = ctx->streams[i];
400 stream = (StreamInfo*) st->priv_data;
402 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
403 codec_rate= st->codec->rc_max_rate;
405 codec_rate= st->codec->bit_rate;
408 codec_rate= (1<<21)*8*50/ctx->nb_streams;
410 bitrate += codec_rate;
412 if ((stream->id & 0xe0) == AUDIO_ID)
413 audio_bitrate += codec_rate;
414 else if (stream->id==VIDEO_ID)
415 video_bitrate += codec_rate;
419 s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
421 /* we increase slightly the bitrate to take into account the
422 headers. XXX: compute it exactly */
423 bitrate += bitrate*5/100;
425 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
429 double overhead_rate;
431 /* The VCD standard mandates that the mux_rate field is 3528
432 (see standard p. IV-6).
433 The value is actually "wrong", i.e. if you calculate
434 it using the normal formula and the 75 sectors per second transfer
435 rate you get a different value because the real pack size is 2324,
436 not 2352. But the standard explicitly specifies that the mux_rate
437 field in the header must have this value.*/
438 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
440 /* The VCD standard states that the muxed stream must be
441 exactly 75 packs / second (the data rate of a single speed cdrom).
442 Since the video bitrate (probably 1150000 bits/sec) will be below
443 the theoretical maximum we have to add some padding packets
444 to make up for the lower data rate.
445 (cf. VCD standard p. IV-6 )*/
447 /* Add the header overhead to the data rate.
448 2279 data bytes per audio pack, 2294 data bytes per video pack*/
449 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
450 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
453 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
454 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
457 if (s->is_vcd || s->is_mpeg2)
459 s->pack_header_freq = 1;
461 /* every 2 seconds */
462 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
464 /* the above seems to make pack_header_freq zero sometimes */
465 if (s->pack_header_freq == 0)
466 s->pack_header_freq = 1;
469 /* every 200 packets. Need to look at the spec. */
470 s->system_header_freq = s->pack_header_freq * 40;
472 /* the standard mandates that there are only two system headers
473 in the whole file: one in the first packet of each stream.
474 (see standard p. IV-7 and IV-8) */
475 s->system_header_freq = 0x7fffffff;
477 s->system_header_freq = s->pack_header_freq * 5;
479 for(i=0;i<ctx->nb_streams;i++) {
480 stream = ctx->streams[i]->priv_data;
481 stream->packet_number = 0;
483 s->system_header_size = get_system_header_size(ctx);
487 for(i=0;i<ctx->nb_streams;i++) {
488 av_free(ctx->streams[i]->priv_data);
490 return AVERROR(ENOMEM);
493 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
497 (((timestamp >> 30) & 0x07) << 1) |
499 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
500 avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
504 /* return the number of padding bytes that should be inserted into
505 the multiplexed stream.*/
506 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
508 MpegMuxContext *s = ctx->priv_data;
511 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
513 int64_t full_pad_bytes;
515 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
516 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
519 /* might happen if we have already padded to a later timestamp. This
520 can occur if another stream has already advanced further.*/
528 #if 0 /* unused, remove? */
529 /* return the exact available payload size for the next packet for
530 stream 'stream_index'. 'pts' and 'dts' are only used to know if
531 timestamps are needed in the packet header. */
532 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
533 int64_t pts, int64_t dts)
535 MpegMuxContext *s = ctx->priv_data;
539 stream = ctx->streams[stream_index]->priv_data;
542 if (((s->packet_number % s->pack_header_freq) == 0)) {
543 /* pack header size */
550 /* there is exactly one system header for each stream in a VCD MPEG,
551 One in the very first video packet and one in the very first
552 audio packet (see VCD standard p. IV-7 and IV-8).*/
554 if (stream->packet_number==0)
555 /* The system headers refer only to the stream they occur in,
556 so they have a constant size.*/
560 if ((s->packet_number % s->system_header_freq) == 0)
561 buf_index += s->system_header_size;
565 if ((s->is_vcd && stream->packet_number==0)
566 || (s->is_svcd && s->packet_number==0))
567 /* the first pack of each stream contains only the pack header,
568 the system header and some padding (see VCD standard p. IV-6)
569 Add the padding size, so that the actual payload becomes 0.*/
570 buf_index += s->packet_size - buf_index;
572 /* packet header size */
576 if (stream->packet_number==0)
577 buf_index += 3; /* PES extension */
578 buf_index += 1; /* obligatory stuffing byte */
580 if (pts != AV_NOPTS_VALUE) {
591 if (stream->id < 0xc0) {
592 /* AC-3/LPCM private data header */
594 if (stream->id >= 0xa0) {
597 /* NOTE: we round the payload size to an integer number of
599 n = (s->packet_size - buf_index) % stream->lpcm_align;
601 buf_index += (stream->lpcm_align - n);
605 if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID)
606 /* The VCD standard demands that 20 zero bytes follow
607 each audio packet (see standard p. IV-8).*/
610 return s->packet_size - buf_index;
614 /* Write an MPEG padding packet header. */
615 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
617 MpegMuxContext *s = ctx->priv_data;
620 avio_wb32(pb, PADDING_STREAM);
621 avio_wb16(pb, packet_bytes - 6);
628 for(i=0;i<packet_bytes;i++)
632 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
634 PacketDesc *pkt_desc= stream->premux_packet;
637 if(pkt_desc->size == pkt_desc->unwritten_size)
639 len -= pkt_desc->unwritten_size;
640 pkt_desc= pkt_desc->next;
646 /* flush the packet on stream stream_index */
647 static int flush_packet(AVFormatContext *ctx, int stream_index,
648 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
650 MpegMuxContext *s = ctx->priv_data;
651 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
653 int size, payload_size, startcode, id, stuffing_size, i, header_len;
656 int zero_trail_bytes = 0;
657 int pad_packet_bytes = 0;
659 int general_pack = 0; /*"general" pack without data specific to one stream?*/
665 printf("packet ID=%2x PTS=%0.3f\n",
671 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
672 /* output pack and systems header if needed */
673 size = put_pack_header(ctx, buf_ptr, scr);
678 /* there is exactly one system header for each stream in a VCD MPEG,
679 One in the very first video packet and one in the very first
680 audio packet (see VCD standard p. IV-7 and IV-8).*/
682 if (stream->packet_number==0) {
683 size = put_system_header(ctx, buf_ptr, id);
686 } else if (s->is_dvd) {
687 if (stream->align_iframe || s->packet_number == 0){
688 int PES_bytes_to_fill = s->packet_size - size - 10;
690 if (pts != AV_NOPTS_VALUE) {
692 PES_bytes_to_fill -= 5 + 5;
694 PES_bytes_to_fill -= 5;
697 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
698 size = put_system_header(ctx, buf_ptr, 0);
700 size = buf_ptr - buffer;
701 avio_write(ctx->pb, buffer, size);
703 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
704 avio_wb16(ctx->pb, 0x03d4); // length
705 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
706 for (i = 0; i < 979; i++)
707 avio_w8(ctx->pb, 0x00);
709 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
710 avio_wb16(ctx->pb, 0x03fa); // length
711 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
712 for (i = 0; i < 1017; i++)
713 avio_w8(ctx->pb, 0x00);
715 memset(buffer, 0, 128);
718 stream->align_iframe = 0;
719 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
720 size = put_pack_header(ctx, buf_ptr, scr);
724 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
725 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
729 if ((s->packet_number % s->system_header_freq) == 0) {
730 size = put_system_header(ctx, buf_ptr, 0);
735 size = buf_ptr - buffer;
736 avio_write(ctx->pb, buffer, size);
738 packet_size = s->packet_size - size;
740 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
741 /* The VCD standard demands that 20 zero bytes follow
742 each audio pack (see standard p. IV-8).*/
743 zero_trail_bytes += 20;
745 if ((s->is_vcd && stream->packet_number==0)
746 || (s->is_svcd && s->packet_number==0)) {
747 /* for VCD the first pack of each stream contains only the pack header,
748 the system header and lots of padding (see VCD standard p. IV-6).
749 In the case of an audio pack, 20 zero bytes are also added at
751 /* For SVCD we fill the very first pack to increase compatibility with
752 some DVD players. Not mandated by the standard.*/
754 general_pack = 1; /* the system header refers to both streams and no stream data*/
755 pad_packet_bytes = packet_size - zero_trail_bytes;
758 packet_size -= pad_packet_bytes + zero_trail_bytes;
760 if (packet_size > 0) {
762 /* packet header size */
768 if (stream->packet_number==0)
769 header_len += 3; /* PES extension */
770 header_len += 1; /* obligatory stuffing byte */
774 if (pts != AV_NOPTS_VALUE) {
784 payload_size = packet_size - header_len;
786 startcode = PRIVATE_STREAM_1;
794 startcode = 0x100 + id;
797 stuffing_size = payload_size - av_fifo_size(stream->fifo);
799 // first byte does not fit -> reset pts/dts + stuffing
800 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
804 if(pts != AV_NOPTS_VALUE)
805 timestamp_len += s->is_mpeg2 ? 5 : 4;
806 pts=dts= AV_NOPTS_VALUE;
807 header_len -= timestamp_len;
808 if (s->is_dvd && stream->align_iframe) {
809 pad_packet_bytes += timestamp_len;
810 packet_size -= timestamp_len;
812 payload_size += timestamp_len;
814 stuffing_size += timestamp_len;
815 if(payload_size > trailer_size)
816 stuffing_size += payload_size - trailer_size;
819 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
820 packet_size += pad_packet_bytes;
821 payload_size += pad_packet_bytes; // undo the previous adjustment
822 if (stuffing_size < 0) {
823 stuffing_size = pad_packet_bytes;
825 stuffing_size += pad_packet_bytes;
827 pad_packet_bytes = 0;
830 if (stuffing_size < 0)
832 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
833 pad_packet_bytes += stuffing_size;
834 packet_size -= stuffing_size;
835 payload_size -= stuffing_size;
839 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
841 avio_wb32(ctx->pb, startcode);
843 avio_wb16(ctx->pb, packet_size);
846 for(i=0;i<stuffing_size;i++)
847 avio_w8(ctx->pb, 0xff);
850 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
854 if (pts != AV_NOPTS_VALUE) {
860 /* Both the MPEG-2 and the SVCD standards demand that the
861 P-STD_buffer_size field be included in the first packet of
862 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
863 and MPEG-2 standard 2.7.7) */
864 if (stream->packet_number == 0)
867 avio_w8(ctx->pb, pes_flags); /* flags */
868 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
870 if (pes_flags & 0x80) /*write pts*/
871 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
872 if (pes_flags & 0x40) /*write dts*/
873 put_timestamp(ctx->pb, 0x01, dts);
875 if (pes_flags & 0x01) { /*write pes extension*/
876 avio_w8(ctx->pb, 0x10); /* flags */
878 /* P-STD buffer info */
879 if ((id & 0xe0) == AUDIO_ID)
880 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
882 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
886 if (pts != AV_NOPTS_VALUE) {
888 put_timestamp(ctx->pb, 0x03, pts);
889 put_timestamp(ctx->pb, 0x01, dts);
891 put_timestamp(ctx->pb, 0x02, pts);
894 avio_w8(ctx->pb, 0x0f);
899 /* special stuffing byte that is always written
900 to prevent accidental generation of start codes. */
901 avio_w8(ctx->pb, 0xff);
903 for(i=0;i<stuffing_size;i++)
904 avio_w8(ctx->pb, 0xff);
907 if (startcode == PRIVATE_STREAM_1) {
908 avio_w8(ctx->pb, id);
910 /* LPCM (XXX: check nb_frames) */
912 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
913 avio_w8(ctx->pb, stream->lpcm_header[0]);
914 avio_w8(ctx->pb, stream->lpcm_header[1]);
915 avio_w8(ctx->pb, stream->lpcm_header[2]);
916 } else if (id >= 0x40) {
918 avio_w8(ctx->pb, nb_frames);
919 avio_wb16(ctx->pb, trailer_size+1);
924 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
925 av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, (void*)avio_write);
926 stream->bytes_to_iframe -= payload_size - stuffing_size;
932 if (pad_packet_bytes > 0)
933 put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
935 for(i=0;i<zero_trail_bytes;i++)
936 avio_w8(ctx->pb, 0x00);
942 /* only increase the stream packet number if this pack actually contains
943 something that is specific to this stream! I.e. a dedicated header
946 stream->packet_number++;
948 return payload_size - stuffing_size;
951 static void put_vcd_padding_sector(AVFormatContext *ctx)
953 /* There are two ways to do this padding: writing a sector/pack
954 of 0 values, or writing an MPEG padding pack. Both seem to
955 work with most decoders, BUT the VCD standard only allows a 0-sector
956 (see standard p. IV-4, IV-5).
957 So a 0-sector it is...*/
959 MpegMuxContext *s = ctx->priv_data;
962 for(i=0;i<s->packet_size;i++)
965 s->vcd_padding_bytes_written += s->packet_size;
969 /* increasing the packet number is correct. The SCR of the following packs
970 is calculated from the packet_number and it has to include the padding
971 sector (it represents the sector index, not the MPEG pack index)
972 (see VCD standard p. IV-6)*/
976 #if 0 /* unused, remove? */
977 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
979 MpegMuxContext *s = ctx->priv_data;
982 /* Since the data delivery rate is constant, SCR is computed
983 using the formula C + i * 1200 where C is the start constant
984 and i is the pack index.
985 It is recommended that SCR 0 is at the beginning of the VCD front
986 margin (a sequence of empty Form 2 sectors on the CD).
987 It is recommended that the front margin is 30 sectors long, so
988 we use C = 30*1200 = 36000
989 (Note that even if the front margin is not 30 sectors the file
990 will still be correct according to the standard. It just won't have
991 the "recommended" value).*/
992 scr = 36000 + s->packet_number * 1200;
998 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
999 // MpegMuxContext *s = ctx->priv_data;
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;
1007 while((pkt_desc= stream->predecode_packet)
1008 && scr > pkt_desc->dts){ //FIXME > vs >=
1009 if(stream->buffer_index < pkt_desc->size ||
1010 stream->predecode_packet == stream->premux_packet){
1011 av_log(ctx, AV_LOG_ERROR,
1012 "buffer underflow i=%d bufi=%d size=%d\n",
1013 i, stream->buffer_index, pkt_desc->size);
1016 stream->buffer_index -= pkt_desc->size;
1018 stream->predecode_packet= pkt_desc->next;
1019 av_freep(&pkt_desc);
1026 static int output_packet(AVFormatContext *ctx, int flush){
1027 MpegMuxContext *s = ctx->priv_data;
1030 int i, avail_space=0, es_size, trailer_size;
1032 int best_score= INT_MIN;
1033 int ignore_constraints=0;
1034 int64_t scr= s->last_scr;
1035 PacketDesc *timestamp_packet;
1036 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1039 for(i=0; i<ctx->nb_streams; i++){
1040 AVStream *st = ctx->streams[i];
1041 StreamInfo *stream = st->priv_data;
1042 const int avail_data= av_fifo_size(stream->fifo);
1043 const int space= stream->max_buffer_size - stream->buffer_index;
1044 int rel_space= 1024*space / stream->max_buffer_size;
1045 PacketDesc *next_pkt= stream->premux_packet;
1047 /* for subtitle, a single PES packet must be generated,
1048 so we flush after every single subtitle packet */
1049 if(s->packet_size > avail_data && !flush
1050 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1054 assert(avail_data>0);
1056 if(space < s->packet_size && !ignore_constraints)
1059 if(next_pkt && next_pkt->dts - scr > max_delay)
1062 if(rel_space > best_score){
1063 best_score= rel_space;
1070 int64_t best_dts= INT64_MAX;
1072 for(i=0; i<ctx->nb_streams; i++){
1073 AVStream *st = ctx->streams[i];
1074 StreamInfo *stream = st->priv_data;
1075 PacketDesc *pkt_desc= stream->predecode_packet;
1076 if(pkt_desc && pkt_desc->dts < best_dts)
1077 best_dts= pkt_desc->dts;
1080 av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1081 scr / 90000.0, best_dts / 90000.0);
1082 if(best_dts == INT64_MAX)
1085 if(scr >= best_dts+1 && !ignore_constraints){
1086 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1087 ignore_constraints= 1;
1089 scr= FFMAX(best_dts+1, scr);
1090 if(remove_decoded_packets(ctx, scr) < 0)
1095 assert(best_i >= 0);
1097 st = ctx->streams[best_i];
1098 stream = st->priv_data;
1100 assert(av_fifo_size(stream->fifo) > 0);
1102 assert(avail_space >= s->packet_size || ignore_constraints);
1104 timestamp_packet= stream->premux_packet;
1105 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1108 trailer_size= timestamp_packet->unwritten_size;
1109 timestamp_packet= timestamp_packet->next;
1112 if(timestamp_packet){
1113 //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);
1114 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1116 assert(av_fifo_size(stream->fifo) == trailer_size);
1117 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1121 /* Write one or more padding sectors, if necessary, to reach
1122 the constant overall bitrate.*/
1125 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1126 put_vcd_padding_sector(ctx);
1127 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1131 stream->buffer_index += es_size;
1132 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1134 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1135 es_size -= stream->premux_packet->unwritten_size;
1136 stream->premux_packet= stream->premux_packet->next;
1139 stream->premux_packet->unwritten_size -= es_size;
1141 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1147 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1149 MpegMuxContext *s = ctx->priv_data;
1150 int stream_index= pkt->stream_index;
1151 int size= pkt->size;
1152 uint8_t *buf= pkt->data;
1153 AVStream *st = ctx->streams[stream_index];
1154 StreamInfo *stream = st->priv_data;
1156 PacketDesc *pkt_desc;
1157 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1158 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1163 if(pts != AV_NOPTS_VALUE) pts += 2*preload;
1164 if(dts != AV_NOPTS_VALUE){
1166 s->last_scr= dts + preload;
1170 //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);
1171 if (!stream->premux_packet)
1172 stream->next_packet = &stream->premux_packet;
1173 *stream->next_packet=
1174 pkt_desc= av_mallocz(sizeof(PacketDesc));
1177 pkt_desc->unwritten_size=
1178 pkt_desc->size= size;
1179 if(!stream->predecode_packet)
1180 stream->predecode_packet= pkt_desc;
1181 stream->next_packet= &pkt_desc->next;
1183 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1187 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1188 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1189 stream->align_iframe = 1;
1190 stream->vobu_start_pts = pts;
1194 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1197 int ret= output_packet(ctx, 0);
1203 static int mpeg_mux_end(AVFormatContext *ctx)
1205 // MpegMuxContext *s = ctx->priv_data;
1210 int ret= output_packet(ctx, 1);
1217 /* End header according to MPEG1 systems standard. We do not write
1218 it as it is usually not needed by decoders and because it
1219 complicates MPEG stream concatenation. */
1220 //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1221 //avio_flush(ctx->pb);
1223 for(i=0;i<ctx->nb_streams;i++) {
1224 stream = ctx->streams[i]->priv_data;
1226 assert(av_fifo_size(stream->fifo) == 0);
1227 av_fifo_free(stream->fifo);
1232 #if CONFIG_MPEG1SYSTEM_MUXER
1233 AVOutputFormat ff_mpeg1system_muxer = {
1235 NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1238 sizeof(MpegMuxContext),
1240 CODEC_ID_MPEG1VIDEO,
1242 mpeg_mux_write_packet,
1246 #if CONFIG_MPEG1VCD_MUXER
1247 AVOutputFormat ff_mpeg1vcd_muxer = {
1249 NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1252 sizeof(MpegMuxContext),
1254 CODEC_ID_MPEG1VIDEO,
1256 mpeg_mux_write_packet,
1260 #if CONFIG_MPEG2VOB_MUXER
1261 AVOutputFormat ff_mpeg2vob_muxer = {
1263 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1266 sizeof(MpegMuxContext),
1268 CODEC_ID_MPEG2VIDEO,
1270 mpeg_mux_write_packet,
1275 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1276 #if CONFIG_MPEG2SVCD_MUXER
1277 AVOutputFormat ff_mpeg2svcd_muxer = {
1279 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1282 sizeof(MpegMuxContext),
1284 CODEC_ID_MPEG2VIDEO,
1286 mpeg_mux_write_packet,
1291 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1292 #if CONFIG_MPEG2DVD_MUXER
1293 AVOutputFormat ff_mpeg2dvd_muxer = {
1295 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1298 sizeof(MpegMuxContext),
1300 CODEC_ID_MPEG2VIDEO,
1302 mpeg_mux_write_packet,