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 "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 user_mux_rate; /* bitrate in units of bits/s */
69 int mux_rate; /* bitrate in units of 50 bytes/s */
77 int64_t last_scr; /* current system clock */
79 double vcd_padding_bitrate; //FIXME floats
80 int64_t vcd_padding_bytes_written;
85 extern AVOutputFormat ff_mpeg1vcd_muxer;
86 extern AVOutputFormat ff_mpeg2dvd_muxer;
87 extern AVOutputFormat ff_mpeg2svcd_muxer;
88 extern AVOutputFormat ff_mpeg2vob_muxer;
90 static int put_pack_header(AVFormatContext *ctx,
91 uint8_t *buf, int64_t timestamp)
93 MpegMuxContext *s = ctx->priv_data;
96 init_put_bits(&pb, buf, 128);
98 put_bits32(&pb, PACK_START_CODE);
100 put_bits(&pb, 2, 0x1);
102 put_bits(&pb, 4, 0x2);
104 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
106 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
108 put_bits(&pb, 15, (uint32_t)((timestamp ) & 0x7fff));
111 /* clock extension */
115 put_bits(&pb, 22, s->mux_rate);
119 put_bits(&pb, 5, 0x1f); /* reserved */
120 put_bits(&pb, 3, 0); /* stuffing length */
123 return put_bits_ptr(&pb) - pb.buf;
126 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
128 MpegMuxContext *s = ctx->priv_data;
129 int size, i, private_stream_coded, id;
132 init_put_bits(&pb, buf, 128);
134 put_bits32(&pb, SYSTEM_HEADER_START_CODE);
135 put_bits(&pb, 16, 0);
138 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
139 put_bits(&pb, 1, 1); /* marker */
140 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
141 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
144 put_bits(&pb, 6, s->audio_bound);
147 /* see VCD standard, p. IV-7*/
151 put_bits(&pb, 1, 0); /* variable bitrate*/
152 put_bits(&pb, 1, 0); /* non constrainted bit stream */
155 if (s->is_vcd || s->is_dvd) {
156 /* see VCD standard p IV-7 */
157 put_bits(&pb, 1, 1); /* audio locked */
158 put_bits(&pb, 1, 1); /* video locked */
160 put_bits(&pb, 1, 0); /* audio locked */
161 put_bits(&pb, 1, 0); /* video locked */
164 put_bits(&pb, 1, 1); /* marker */
166 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
167 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
170 put_bits(&pb, 5, s->video_bound);
173 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
174 put_bits(&pb, 7, 0x7f); /* reserved byte */
176 put_bits(&pb, 8, 0xff); /* reserved byte */
178 /* DVD-Video Stream_bound entries
179 id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
180 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)
181 id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
182 id (0xBF) private stream 2, NAV packs, set to 2x1024. */
185 int P_STD_max_video = 0;
186 int P_STD_max_mpeg_audio = 0;
187 int P_STD_max_mpeg_PS1 = 0;
189 for(i=0;i<ctx->nb_streams;i++) {
190 StreamInfo *stream = ctx->streams[i]->priv_data;
193 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
194 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
195 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
196 P_STD_max_mpeg_audio = stream->max_buffer_size;
197 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
198 P_STD_max_video = stream->max_buffer_size;
203 put_bits(&pb, 8, 0xb9); /* stream ID */
206 put_bits(&pb, 13, P_STD_max_video / 1024);
209 if (P_STD_max_mpeg_audio == 0)
210 P_STD_max_mpeg_audio = 4096;
211 put_bits(&pb, 8, 0xb8); /* stream ID */
214 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
216 /* private stream 1 */
217 put_bits(&pb, 8, 0xbd); /* stream ID */
220 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
222 /* private stream 2 */
223 put_bits(&pb, 8, 0xbf); /* stream ID */
226 put_bits(&pb, 13, 2);
229 /* audio stream info */
230 private_stream_coded = 0;
231 for(i=0;i<ctx->nb_streams;i++) {
232 StreamInfo *stream = ctx->streams[i]->priv_data;
235 /* For VCDs, only include the stream info for the stream
236 that the pack which contains this system belongs to.
237 (see VCD standard p. IV-7) */
238 if ( !s->is_vcd || stream->id==only_for_stream_id
239 || only_for_stream_id==0) {
243 /* special case for private streams (AC-3 uses that) */
244 if (private_stream_coded)
246 private_stream_coded = 1;
249 put_bits(&pb, 8, id); /* stream ID */
254 put_bits(&pb, 13, stream->max_buffer_size / 128);
258 put_bits(&pb, 13, stream->max_buffer_size / 1024);
265 size = put_bits_ptr(&pb) - pb.buf;
266 /* patch packet size */
267 buf[4] = (size - 6) >> 8;
268 buf[5] = (size - 6) & 0xff;
273 static int get_system_header_size(AVFormatContext *ctx)
275 int buf_index, i, private_stream_coded;
277 MpegMuxContext *s = ctx->priv_data;
280 return 18; // DVD-Video system headers are 18 bytes fixed length.
283 private_stream_coded = 0;
284 for(i=0;i<ctx->nb_streams;i++) {
285 stream = ctx->streams[i]->priv_data;
286 if (stream->id < 0xc0) {
287 if (private_stream_coded)
289 private_stream_coded = 1;
296 static int mpeg_mux_init(AVFormatContext *ctx)
298 MpegMuxContext *s = ctx->priv_data;
299 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
305 s->packet_number = 0;
306 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
307 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
308 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
309 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
310 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
311 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
313 if(ctx->packet_size) {
314 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
315 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
319 s->packet_size = ctx->packet_size;
321 s->packet_size = 2048;
322 if (ctx->max_delay < 0) /* Not set by the caller */
325 s->vcd_padding_bytes_written = 0;
326 s->vcd_padding_bitrate=0;
336 for(i=0;i<ctx->nb_streams;i++) {
337 st = ctx->streams[i];
338 stream = av_mallocz(sizeof(StreamInfo));
341 st->priv_data = stream;
343 avpriv_set_pts_info(st, 64, 1, 90000);
345 switch(st->codec->codec_type) {
346 case AVMEDIA_TYPE_AUDIO:
347 if (st->codec->codec_id == CODEC_ID_AC3) {
348 stream->id = ac3_id++;
349 } else if (st->codec->codec_id == CODEC_ID_DTS) {
350 stream->id = dts_id++;
351 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
352 stream->id = lpcm_id++;
353 for(j = 0; j < 4; j++) {
354 if (lpcm_freq_tab[j] == st->codec->sample_rate)
359 if (st->codec->channels > 8)
361 stream->lpcm_header[0] = 0x0c;
362 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
363 stream->lpcm_header[2] = 0x80;
364 stream->lpcm_align = st->codec->channels * 2;
366 stream->id = mpa_id++;
369 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
370 Right now it is also used for everything else.*/
371 stream->max_buffer_size = 4 * 1024;
374 case AVMEDIA_TYPE_VIDEO:
375 stream->id = mpv_id++;
376 if (st->codec->rc_buffer_size)
377 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
379 av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, muxing may fail\n");
380 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
383 /* see VCD standard, p. IV-7*/
384 stream->max_buffer_size = 46 * 1024;
386 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
387 Right now it is also used for everything else.*/
388 stream->max_buffer_size = 230 * 1024;
392 case AVMEDIA_TYPE_SUBTITLE:
393 stream->id = mps_id++;
394 stream->max_buffer_size = 16 * 1024;
399 stream->fifo= av_fifo_alloc(16);
406 for(i=0;i<ctx->nb_streams;i++) {
408 st = ctx->streams[i];
409 stream = (StreamInfo*) st->priv_data;
411 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
412 codec_rate= st->codec->rc_max_rate;
414 codec_rate= st->codec->bit_rate;
417 codec_rate= (1<<21)*8*50/ctx->nb_streams;
419 bitrate += codec_rate;
421 if ((stream->id & 0xe0) == AUDIO_ID)
422 audio_bitrate += codec_rate;
423 else if (stream->id==VIDEO_ID)
424 video_bitrate += codec_rate;
427 if (s->user_mux_rate) {
428 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
430 /* we increase slightly the bitrate to take into account the
431 headers. XXX: compute it exactly */
432 bitrate += bitrate / 20;
434 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
438 double overhead_rate;
440 /* The VCD standard mandates that the mux_rate field is 3528
441 (see standard p. IV-6).
442 The value is actually "wrong", i.e. if you calculate
443 it using the normal formula and the 75 sectors per second transfer
444 rate you get a different value because the real pack size is 2324,
445 not 2352. But the standard explicitly specifies that the mux_rate
446 field in the header must have this value.*/
447 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
449 /* The VCD standard states that the muxed stream must be
450 exactly 75 packs / second (the data rate of a single speed cdrom).
451 Since the video bitrate (probably 1150000 bits/sec) will be below
452 the theoretical maximum we have to add some padding packets
453 to make up for the lower data rate.
454 (cf. VCD standard p. IV-6 )*/
456 /* Add the header overhead to the data rate.
457 2279 data bytes per audio pack, 2294 data bytes per video pack*/
458 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
459 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
462 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
463 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
466 if (s->is_vcd || s->is_mpeg2)
468 s->pack_header_freq = 1;
470 /* every 2 seconds */
471 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
473 /* the above seems to make pack_header_freq zero sometimes */
474 if (s->pack_header_freq == 0)
475 s->pack_header_freq = 1;
478 /* every 200 packets. Need to look at the spec. */
479 s->system_header_freq = s->pack_header_freq * 40;
481 /* the standard mandates that there are only two system headers
482 in the whole file: one in the first packet of each stream.
483 (see standard p. IV-7 and IV-8) */
484 s->system_header_freq = 0x7fffffff;
486 s->system_header_freq = s->pack_header_freq * 5;
488 for(i=0;i<ctx->nb_streams;i++) {
489 stream = ctx->streams[i]->priv_data;
490 stream->packet_number = 0;
492 s->system_header_size = get_system_header_size(ctx);
496 for(i=0;i<ctx->nb_streams;i++) {
497 av_free(ctx->streams[i]->priv_data);
499 return AVERROR(ENOMEM);
502 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
506 (((timestamp >> 30) & 0x07) << 1) |
508 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
509 avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
513 /* return the number of padding bytes that should be inserted into
514 the multiplexed stream.*/
515 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
517 MpegMuxContext *s = ctx->priv_data;
520 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
522 int64_t full_pad_bytes;
524 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
525 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
528 /* might happen if we have already padded to a later timestamp. This
529 can occur if another stream has already advanced further.*/
537 #if 0 /* unused, remove? */
538 /* return the exact available payload size for the next packet for
539 stream 'stream_index'. 'pts' and 'dts' are only used to know if
540 timestamps are needed in the packet header. */
541 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
542 int64_t pts, int64_t dts)
544 MpegMuxContext *s = ctx->priv_data;
548 stream = ctx->streams[stream_index]->priv_data;
551 if (((s->packet_number % s->pack_header_freq) == 0)) {
552 /* pack header size */
559 /* there is exactly one system header for each stream in a VCD MPEG,
560 One in the very first video packet and one in the very first
561 audio packet (see VCD standard p. IV-7 and IV-8).*/
563 if (stream->packet_number==0)
564 /* The system headers refer only to the stream they occur in,
565 so they have a constant size.*/
569 if ((s->packet_number % s->system_header_freq) == 0)
570 buf_index += s->system_header_size;
574 if ((s->is_vcd && stream->packet_number==0)
575 || (s->is_svcd && s->packet_number==0))
576 /* the first pack of each stream contains only the pack header,
577 the system header and some padding (see VCD standard p. IV-6)
578 Add the padding size, so that the actual payload becomes 0.*/
579 buf_index += s->packet_size - buf_index;
581 /* packet header size */
585 if (stream->packet_number==0)
586 buf_index += 3; /* PES extension */
587 buf_index += 1; /* obligatory stuffing byte */
589 if (pts != AV_NOPTS_VALUE) {
600 if (stream->id < 0xc0) {
601 /* AC-3/LPCM private data header */
603 if (stream->id >= 0xa0) {
606 /* NOTE: we round the payload size to an integer number of
608 n = (s->packet_size - buf_index) % stream->lpcm_align;
610 buf_index += (stream->lpcm_align - n);
614 if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID)
615 /* The VCD standard demands that 20 zero bytes follow
616 each audio packet (see standard p. IV-8).*/
619 return s->packet_size - buf_index;
623 /* Write an MPEG padding packet header. */
624 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
626 MpegMuxContext *s = ctx->priv_data;
629 avio_wb32(pb, PADDING_STREAM);
630 avio_wb16(pb, packet_bytes - 6);
637 for(i=0;i<packet_bytes;i++)
641 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
643 PacketDesc *pkt_desc= stream->premux_packet;
646 if(pkt_desc->size == pkt_desc->unwritten_size)
648 len -= pkt_desc->unwritten_size;
649 pkt_desc= pkt_desc->next;
655 /* flush the packet on stream stream_index */
656 static int flush_packet(AVFormatContext *ctx, int stream_index,
657 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
659 MpegMuxContext *s = ctx->priv_data;
660 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
662 int size, payload_size, startcode, id, stuffing_size, i, header_len;
665 int zero_trail_bytes = 0;
666 int pad_packet_bytes = 0;
668 int general_pack = 0; /*"general" pack without data specific to one stream?*/
673 av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
677 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
678 /* output pack and systems header if needed */
679 size = put_pack_header(ctx, buf_ptr, scr);
684 /* there is exactly one system header for each stream in a VCD MPEG,
685 One in the very first video packet and one in the very first
686 audio packet (see VCD standard p. IV-7 and IV-8).*/
688 if (stream->packet_number==0) {
689 size = put_system_header(ctx, buf_ptr, id);
692 } else if (s->is_dvd) {
693 if (stream->align_iframe || s->packet_number == 0){
694 int PES_bytes_to_fill = s->packet_size - size - 10;
696 if (pts != AV_NOPTS_VALUE) {
698 PES_bytes_to_fill -= 5 + 5;
700 PES_bytes_to_fill -= 5;
703 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
704 size = put_system_header(ctx, buf_ptr, 0);
706 size = buf_ptr - buffer;
707 avio_write(ctx->pb, buffer, size);
709 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
710 avio_wb16(ctx->pb, 0x03d4); // length
711 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
712 for (i = 0; i < 979; i++)
713 avio_w8(ctx->pb, 0x00);
715 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
716 avio_wb16(ctx->pb, 0x03fa); // length
717 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
718 for (i = 0; i < 1017; i++)
719 avio_w8(ctx->pb, 0x00);
721 memset(buffer, 0, 128);
724 stream->align_iframe = 0;
725 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
726 size = put_pack_header(ctx, buf_ptr, scr);
730 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
731 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
735 if ((s->packet_number % s->system_header_freq) == 0) {
736 size = put_system_header(ctx, buf_ptr, 0);
741 size = buf_ptr - buffer;
742 avio_write(ctx->pb, buffer, size);
744 packet_size = s->packet_size - size;
746 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
747 /* The VCD standard demands that 20 zero bytes follow
748 each audio pack (see standard p. IV-8).*/
749 zero_trail_bytes += 20;
751 if ((s->is_vcd && stream->packet_number==0)
752 || (s->is_svcd && s->packet_number==0)) {
753 /* for VCD the first pack of each stream contains only the pack header,
754 the system header and lots of padding (see VCD standard p. IV-6).
755 In the case of an audio pack, 20 zero bytes are also added at
757 /* For SVCD we fill the very first pack to increase compatibility with
758 some DVD players. Not mandated by the standard.*/
760 general_pack = 1; /* the system header refers to both streams and no stream data*/
761 pad_packet_bytes = packet_size - zero_trail_bytes;
764 packet_size -= pad_packet_bytes + zero_trail_bytes;
766 if (packet_size > 0) {
768 /* packet header size */
774 if (stream->packet_number==0)
775 header_len += 3; /* PES extension */
776 header_len += 1; /* obligatory stuffing byte */
780 if (pts != AV_NOPTS_VALUE) {
790 payload_size = packet_size - header_len;
792 startcode = PRIVATE_STREAM_1;
800 startcode = 0x100 + id;
803 stuffing_size = payload_size - av_fifo_size(stream->fifo);
805 // first byte does not fit -> reset pts/dts + stuffing
806 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
810 if(pts != AV_NOPTS_VALUE)
811 timestamp_len += s->is_mpeg2 ? 5 : 4;
812 pts=dts= AV_NOPTS_VALUE;
813 header_len -= timestamp_len;
814 if (s->is_dvd && stream->align_iframe) {
815 pad_packet_bytes += timestamp_len;
816 packet_size -= timestamp_len;
818 payload_size += timestamp_len;
820 stuffing_size += timestamp_len;
821 if(payload_size > trailer_size)
822 stuffing_size += payload_size - trailer_size;
825 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
826 packet_size += pad_packet_bytes;
827 payload_size += pad_packet_bytes; // undo the previous adjustment
828 if (stuffing_size < 0) {
829 stuffing_size = pad_packet_bytes;
831 stuffing_size += pad_packet_bytes;
833 pad_packet_bytes = 0;
836 if (stuffing_size < 0)
839 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
840 if (payload_size < av_fifo_size(stream->fifo))
841 stuffing_size += payload_size % stream->lpcm_align;
844 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
845 pad_packet_bytes += stuffing_size;
846 packet_size -= stuffing_size;
847 payload_size -= stuffing_size;
851 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
853 avio_wb32(ctx->pb, startcode);
855 avio_wb16(ctx->pb, packet_size);
858 for(i=0;i<stuffing_size;i++)
859 avio_w8(ctx->pb, 0xff);
862 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
866 if (pts != AV_NOPTS_VALUE) {
872 /* Both the MPEG-2 and the SVCD standards demand that the
873 P-STD_buffer_size field be included in the first packet of
874 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
875 and MPEG-2 standard 2.7.7) */
876 if (stream->packet_number == 0)
879 avio_w8(ctx->pb, pes_flags); /* flags */
880 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
882 if (pes_flags & 0x80) /*write pts*/
883 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
884 if (pes_flags & 0x40) /*write dts*/
885 put_timestamp(ctx->pb, 0x01, dts);
887 if (pes_flags & 0x01) { /*write pes extension*/
888 avio_w8(ctx->pb, 0x10); /* flags */
890 /* P-STD buffer info */
891 if ((id & 0xe0) == AUDIO_ID)
892 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
894 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
898 if (pts != AV_NOPTS_VALUE) {
900 put_timestamp(ctx->pb, 0x03, pts);
901 put_timestamp(ctx->pb, 0x01, dts);
903 put_timestamp(ctx->pb, 0x02, pts);
906 avio_w8(ctx->pb, 0x0f);
911 /* special stuffing byte that is always written
912 to prevent accidental generation of start codes. */
913 avio_w8(ctx->pb, 0xff);
915 for(i=0;i<stuffing_size;i++)
916 avio_w8(ctx->pb, 0xff);
919 if (startcode == PRIVATE_STREAM_1) {
920 avio_w8(ctx->pb, id);
922 /* LPCM (XXX: check nb_frames) */
924 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
925 avio_w8(ctx->pb, stream->lpcm_header[0]);
926 avio_w8(ctx->pb, stream->lpcm_header[1]);
927 avio_w8(ctx->pb, stream->lpcm_header[2]);
928 } else if (id >= 0x40) {
930 avio_w8(ctx->pb, nb_frames);
931 avio_wb16(ctx->pb, trailer_size+1);
936 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
937 av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, (void*)avio_write);
938 stream->bytes_to_iframe -= payload_size - stuffing_size;
944 if (pad_packet_bytes > 0)
945 put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
947 for(i=0;i<zero_trail_bytes;i++)
948 avio_w8(ctx->pb, 0x00);
954 /* only increase the stream packet number if this pack actually contains
955 something that is specific to this stream! I.e. a dedicated header
958 stream->packet_number++;
960 return payload_size - stuffing_size;
963 static void put_vcd_padding_sector(AVFormatContext *ctx)
965 /* There are two ways to do this padding: writing a sector/pack
966 of 0 values, or writing an MPEG padding pack. Both seem to
967 work with most decoders, BUT the VCD standard only allows a 0-sector
968 (see standard p. IV-4, IV-5).
969 So a 0-sector it is...*/
971 MpegMuxContext *s = ctx->priv_data;
974 for(i=0;i<s->packet_size;i++)
977 s->vcd_padding_bytes_written += s->packet_size;
981 /* increasing the packet number is correct. The SCR of the following packs
982 is calculated from the packet_number and it has to include the padding
983 sector (it represents the sector index, not the MPEG pack index)
984 (see VCD standard p. IV-6)*/
988 #if 0 /* unused, remove? */
989 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
991 MpegMuxContext *s = ctx->priv_data;
994 /* Since the data delivery rate is constant, SCR is computed
995 using the formula C + i * 1200 where C is the start constant
996 and i is the pack index.
997 It is recommended that SCR 0 is at the beginning of the VCD front
998 margin (a sequence of empty Form 2 sectors on the CD).
999 It is recommended that the front margin is 30 sectors long, so
1000 we use C = 30*1200 = 36000
1001 (Note that even if the front margin is not 30 sectors the file
1002 will still be correct according to the standard. It just won't have
1003 the "recommended" value).*/
1004 scr = 36000 + s->packet_number * 1200;
1010 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1011 // MpegMuxContext *s = ctx->priv_data;
1014 for(i=0; i<ctx->nb_streams; i++){
1015 AVStream *st = ctx->streams[i];
1016 StreamInfo *stream = st->priv_data;
1017 PacketDesc *pkt_desc;
1019 while((pkt_desc= stream->predecode_packet)
1020 && scr > pkt_desc->dts){ //FIXME > vs >=
1021 if(stream->buffer_index < pkt_desc->size ||
1022 stream->predecode_packet == stream->premux_packet){
1023 av_log(ctx, AV_LOG_ERROR,
1024 "buffer underflow i=%d bufi=%d size=%d\n",
1025 i, stream->buffer_index, pkt_desc->size);
1028 stream->buffer_index -= pkt_desc->size;
1030 stream->predecode_packet= pkt_desc->next;
1031 av_freep(&pkt_desc);
1038 static int output_packet(AVFormatContext *ctx, int flush){
1039 MpegMuxContext *s = ctx->priv_data;
1042 int i, avail_space=0, es_size, trailer_size;
1044 int best_score= INT_MIN;
1045 int ignore_constraints=0;
1046 int64_t scr= s->last_scr;
1047 PacketDesc *timestamp_packet;
1048 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1051 for(i=0; i<ctx->nb_streams; i++){
1052 AVStream *st = ctx->streams[i];
1053 StreamInfo *stream = st->priv_data;
1054 const int avail_data= av_fifo_size(stream->fifo);
1055 const int space= stream->max_buffer_size - stream->buffer_index;
1056 int rel_space= 1024LL*space / stream->max_buffer_size;
1057 PacketDesc *next_pkt= stream->premux_packet;
1059 /* for subtitle, a single PES packet must be generated,
1060 so we flush after every single subtitle packet */
1061 if(s->packet_size > avail_data && !flush
1062 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1066 assert(avail_data>0);
1068 if(space < s->packet_size && !ignore_constraints)
1071 if(next_pkt && next_pkt->dts - scr > max_delay)
1074 if(rel_space > best_score){
1075 best_score= rel_space;
1082 int64_t best_dts= INT64_MAX;
1084 for(i=0; i<ctx->nb_streams; i++){
1085 AVStream *st = ctx->streams[i];
1086 StreamInfo *stream = st->priv_data;
1087 PacketDesc *pkt_desc= stream->predecode_packet;
1088 if(pkt_desc && pkt_desc->dts < best_dts)
1089 best_dts= pkt_desc->dts;
1092 av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1093 scr / 90000.0, best_dts / 90000.0);
1094 if(best_dts == INT64_MAX)
1097 if(scr >= best_dts+1 && !ignore_constraints){
1098 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1099 ignore_constraints= 1;
1101 scr= FFMAX(best_dts+1, scr);
1102 if(remove_decoded_packets(ctx, scr) < 0)
1107 assert(best_i >= 0);
1109 st = ctx->streams[best_i];
1110 stream = st->priv_data;
1112 assert(av_fifo_size(stream->fifo) > 0);
1114 assert(avail_space >= s->packet_size || ignore_constraints);
1116 timestamp_packet= stream->premux_packet;
1117 if(timestamp_packet->unwritten_size == timestamp_packet->size){
1120 trailer_size= timestamp_packet->unwritten_size;
1121 timestamp_packet= timestamp_packet->next;
1124 if(timestamp_packet){
1125 //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);
1126 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1128 assert(av_fifo_size(stream->fifo) == trailer_size);
1129 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1133 /* Write one or more padding sectors, if necessary, to reach
1134 the constant overall bitrate.*/
1137 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1138 put_vcd_padding_sector(ctx);
1139 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1143 stream->buffer_index += es_size;
1144 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1146 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1147 es_size -= stream->premux_packet->unwritten_size;
1148 stream->premux_packet= stream->premux_packet->next;
1151 stream->premux_packet->unwritten_size -= es_size;
1153 if(remove_decoded_packets(ctx, s->last_scr) < 0)
1159 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1161 MpegMuxContext *s = ctx->priv_data;
1162 int stream_index= pkt->stream_index;
1163 int size= pkt->size;
1164 uint8_t *buf= pkt->data;
1165 AVStream *st = ctx->streams[stream_index];
1166 StreamInfo *stream = st->priv_data;
1168 PacketDesc *pkt_desc;
1170 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1172 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1177 if(pts != AV_NOPTS_VALUE) pts += 2*preload;
1178 if(dts != AV_NOPTS_VALUE){
1180 s->last_scr= dts + preload;
1184 //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);
1185 if (!stream->premux_packet)
1186 stream->next_packet = &stream->premux_packet;
1187 *stream->next_packet=
1188 pkt_desc= av_mallocz(sizeof(PacketDesc));
1191 pkt_desc->unwritten_size=
1192 pkt_desc->size= size;
1193 if(!stream->predecode_packet)
1194 stream->predecode_packet= pkt_desc;
1195 stream->next_packet= &pkt_desc->next;
1197 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1201 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1202 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1203 stream->align_iframe = 1;
1204 stream->vobu_start_pts = pts;
1208 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1211 int ret= output_packet(ctx, 0);
1217 static int mpeg_mux_end(AVFormatContext *ctx)
1219 // MpegMuxContext *s = ctx->priv_data;
1224 int ret= output_packet(ctx, 1);
1231 /* End header according to MPEG1 systems standard. We do not write
1232 it as it is usually not needed by decoders and because it
1233 complicates MPEG stream concatenation. */
1234 //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1235 //avio_flush(ctx->pb);
1237 for(i=0;i<ctx->nb_streams;i++) {
1238 stream = ctx->streams[i]->priv_data;
1240 assert(av_fifo_size(stream->fifo) == 0);
1241 av_fifo_free(stream->fifo);
1246 #define OFFSET(x) offsetof(MpegMuxContext, x)
1247 #define E AV_OPT_FLAG_ENCODING_PARAM
1248 static const AVOption options[] = {
1249 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, {0}, 0, INT_MAX, E },
1250 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, {500000}, 0, INT_MAX, E},
1254 #define MPEGENC_CLASS(flavor)\
1255 static const AVClass flavor ## _class = {\
1256 .class_name = #flavor " muxer",\
1257 .item_name = av_default_item_name,\
1258 .version = LIBAVUTIL_VERSION_INT,\
1262 #if CONFIG_MPEG1SYSTEM_MUXER
1264 AVOutputFormat ff_mpeg1system_muxer = {
1266 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1267 .mime_type = "video/mpeg",
1268 .extensions = "mpg,mpeg",
1269 .priv_data_size = sizeof(MpegMuxContext),
1270 .audio_codec = CODEC_ID_MP2,
1271 .video_codec = CODEC_ID_MPEG1VIDEO,
1272 .write_header = mpeg_mux_init,
1273 .write_packet = mpeg_mux_write_packet,
1274 .write_trailer = mpeg_mux_end,
1275 .priv_class = &mpeg_class,
1278 #if CONFIG_MPEG1VCD_MUXER
1280 AVOutputFormat ff_mpeg1vcd_muxer = {
1282 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1283 .mime_type = "video/mpeg",
1284 .priv_data_size = sizeof(MpegMuxContext),
1285 .audio_codec = CODEC_ID_MP2,
1286 .video_codec = CODEC_ID_MPEG1VIDEO,
1287 .write_header = mpeg_mux_init,
1288 .write_packet = mpeg_mux_write_packet,
1289 .write_trailer = mpeg_mux_end,
1290 .priv_class = &vcd_class,
1293 #if CONFIG_MPEG2VOB_MUXER
1295 AVOutputFormat ff_mpeg2vob_muxer = {
1297 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1298 .mime_type = "video/mpeg",
1299 .extensions = "vob",
1300 .priv_data_size = sizeof(MpegMuxContext),
1301 .audio_codec = CODEC_ID_MP2,
1302 .video_codec = CODEC_ID_MPEG2VIDEO,
1303 .write_header = mpeg_mux_init,
1304 .write_packet = mpeg_mux_write_packet,
1305 .write_trailer = mpeg_mux_end,
1306 .priv_class = &vob_class,
1310 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1311 #if CONFIG_MPEG2SVCD_MUXER
1313 AVOutputFormat ff_mpeg2svcd_muxer = {
1315 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1316 .mime_type = "video/mpeg",
1317 .extensions = "vob",
1318 .priv_data_size = sizeof(MpegMuxContext),
1319 .audio_codec = CODEC_ID_MP2,
1320 .video_codec = CODEC_ID_MPEG2VIDEO,
1321 .write_header = mpeg_mux_init,
1322 .write_packet = mpeg_mux_write_packet,
1323 .write_trailer = mpeg_mux_end,
1324 .priv_class = &svcd_class,
1328 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1329 #if CONFIG_MPEG2DVD_MUXER
1331 AVOutputFormat ff_mpeg2dvd_muxer = {
1333 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1334 .mime_type = "video/mpeg",
1335 .extensions = "dvd",
1336 .priv_data_size = sizeof(MpegMuxContext),
1337 .audio_codec = CODEC_ID_MP2,
1338 .video_codec = CODEC_ID_MPEG2VIDEO,
1339 .write_header = mpeg_mux_init,
1340 .write_packet = mpeg_mux_write_packet,
1341 .write_trailer = mpeg_mux_end,
1342 .priv_class = &dvd_class,