mpegpsenc: fix user specified mux rate
[ffmpeg.git] / libavformat / mpegenc.c
1 /*
2  * MPEG1/2 muxer
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
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"
27 #include "avformat.h"
28 #include "internal.h"
29 #include "mpeg.h"
30
31 #define MAX_PAYLOAD_SIZE 4096
32
33 #undef NDEBUG
34 #include <assert.h>
35
36 typedef struct PacketDesc {
37     int64_t pts;
38     int64_t dts;
39     int size;
40     int unwritten_size;
41     int flags;
42     struct PacketDesc *next;
43 } PacketDesc;
44
45 typedef struct {
46     AVFifoBuffer *fifo;
47     uint8_t id;
48     int max_buffer_size; /* in bytes */
49     int buffer_index;
50     PacketDesc *predecode_packet;
51     PacketDesc *premux_packet;
52     PacketDesc **next_packet;
53     int packet_number;
54     uint8_t lpcm_header[3];
55     int lpcm_align;
56     int bytes_to_iframe;
57     int align_iframe;
58     int64_t vobu_start_pts;
59 } StreamInfo;
60
61 typedef struct {
62     const AVClass *class;
63     int packet_size; /* required packet size */
64     int packet_number;
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 */
70     /* stream info */
71     int audio_bound;
72     int video_bound;
73     int is_mpeg2;
74     int is_vcd;
75     int is_svcd;
76     int is_dvd;
77     int64_t last_scr; /* current system clock */
78
79     double vcd_padding_bitrate; //FIXME floats
80     int64_t vcd_padding_bytes_written;
81
82     int preload;
83 } MpegMuxContext;
84
85 extern AVOutputFormat ff_mpeg1vcd_muxer;
86 extern AVOutputFormat ff_mpeg2dvd_muxer;
87 extern AVOutputFormat ff_mpeg2svcd_muxer;
88 extern AVOutputFormat ff_mpeg2vob_muxer;
89
90 static int put_pack_header(AVFormatContext *ctx,
91                            uint8_t *buf, int64_t timestamp)
92 {
93     MpegMuxContext *s = ctx->priv_data;
94     PutBitContext pb;
95
96     init_put_bits(&pb, buf, 128);
97
98     put_bits32(&pb, PACK_START_CODE);
99     if (s->is_mpeg2) {
100         put_bits(&pb, 2, 0x1);
101     } else {
102         put_bits(&pb, 4, 0x2);
103     }
104     put_bits(&pb, 3,  (uint32_t)((timestamp >> 30) & 0x07));
105     put_bits(&pb, 1, 1);
106     put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
107     put_bits(&pb, 1, 1);
108     put_bits(&pb, 15, (uint32_t)((timestamp      ) & 0x7fff));
109     put_bits(&pb, 1, 1);
110     if (s->is_mpeg2) {
111         /* clock extension */
112         put_bits(&pb, 9, 0);
113     }
114     put_bits(&pb, 1, 1);
115     put_bits(&pb, 22, s->mux_rate);
116     put_bits(&pb, 1, 1);
117     if (s->is_mpeg2) {
118         put_bits(&pb, 1, 1);
119         put_bits(&pb, 5, 0x1f); /* reserved */
120         put_bits(&pb, 3, 0); /* stuffing length */
121     }
122     flush_put_bits(&pb);
123     return put_bits_ptr(&pb) - pb.buf;
124 }
125
126 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
127 {
128     MpegMuxContext *s = ctx->priv_data;
129     int size, i, private_stream_coded, id;
130     PutBitContext pb;
131
132     init_put_bits(&pb, buf, 128);
133
134     put_bits32(&pb, SYSTEM_HEADER_START_CODE);
135     put_bits(&pb, 16, 0);
136     put_bits(&pb, 1, 1);
137
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)*/
142         put_bits(&pb, 6, 0);
143     } else
144         put_bits(&pb, 6, s->audio_bound);
145
146     if (s->is_vcd) {
147         /* see VCD standard, p. IV-7*/
148         put_bits(&pb, 1, 0);
149         put_bits(&pb, 1, 1);
150     } else {
151         put_bits(&pb, 1, 0); /* variable bitrate*/
152         put_bits(&pb, 1, 0); /* non constrainted bit stream */
153     }
154
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 */
159     } else {
160         put_bits(&pb, 1, 0); /* audio locked */
161         put_bits(&pb, 1, 0); /* video locked */
162     }
163
164     put_bits(&pb, 1, 1); /* marker */
165
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)*/
168         put_bits(&pb, 5, 0);
169     } else
170         put_bits(&pb, 5, s->video_bound);
171
172     if (s->is_dvd) {
173         put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
174         put_bits(&pb, 7, 0x7f); /* reserved byte */
175     } else
176         put_bits(&pb, 8, 0xff); /* reserved byte */
177
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. */
183     if (s->is_dvd) {
184
185         int P_STD_max_video = 0;
186         int P_STD_max_mpeg_audio = 0;
187         int P_STD_max_mpeg_PS1 = 0;
188
189         for(i=0;i<ctx->nb_streams;i++) {
190             StreamInfo *stream = ctx->streams[i]->priv_data;
191
192             id = stream->id;
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;
199             }
200         }
201
202         /* video */
203         put_bits(&pb, 8, 0xb9); /* stream ID */
204         put_bits(&pb, 2, 3);
205         put_bits(&pb, 1, 1);
206         put_bits(&pb, 13, P_STD_max_video / 1024);
207
208         /* audio */
209         if (P_STD_max_mpeg_audio == 0)
210             P_STD_max_mpeg_audio = 4096;
211         put_bits(&pb, 8, 0xb8); /* stream ID */
212         put_bits(&pb, 2, 3);
213         put_bits(&pb, 1, 0);
214         put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
215
216         /* private stream 1 */
217         put_bits(&pb, 8, 0xbd); /* stream ID */
218         put_bits(&pb, 2, 3);
219         put_bits(&pb, 1, 0);
220         put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
221
222         /* private stream 2 */
223         put_bits(&pb, 8, 0xbf); /* stream ID */
224         put_bits(&pb, 2, 3);
225         put_bits(&pb, 1, 1);
226         put_bits(&pb, 13, 2);
227     }
228     else {
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;
233
234
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) {
240
241                 id = stream->id;
242                 if (id < 0xc0) {
243                     /* special case for private streams (AC-3 uses that) */
244                     if (private_stream_coded)
245                         continue;
246                     private_stream_coded = 1;
247                     id = 0xbd;
248                 }
249                 put_bits(&pb, 8, id); /* stream ID */
250                 put_bits(&pb, 2, 3);
251                 if (id < 0xe0) {
252                     /* audio */
253                     put_bits(&pb, 1, 0);
254                     put_bits(&pb, 13, stream->max_buffer_size / 128);
255                 } else {
256                     /* video */
257                     put_bits(&pb, 1, 1);
258                     put_bits(&pb, 13, stream->max_buffer_size / 1024);
259                 }
260             }
261         }
262     }
263
264     flush_put_bits(&pb);
265     size = put_bits_ptr(&pb) - pb.buf;
266     /* patch packet size */
267     buf[4] = (size - 6) >> 8;
268     buf[5] = (size - 6) & 0xff;
269
270     return size;
271 }
272
273 static int get_system_header_size(AVFormatContext *ctx)
274 {
275     int buf_index, i, private_stream_coded;
276     StreamInfo *stream;
277     MpegMuxContext *s = ctx->priv_data;
278
279     if (s->is_dvd)
280        return 18; // DVD-Video system headers are 18 bytes fixed length.
281
282     buf_index = 12;
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)
288                 continue;
289             private_stream_coded = 1;
290         }
291         buf_index += 3;
292     }
293     return buf_index;
294 }
295
296 static int mpeg_mux_init(AVFormatContext *ctx)
297 {
298     MpegMuxContext *s = ctx->priv_data;
299     int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
300     AVStream *st;
301     StreamInfo *stream;
302     int audio_bitrate;
303     int video_bitrate;
304
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);
312
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",
316                    ctx->packet_size);
317             goto fail;
318         }
319         s->packet_size = ctx->packet_size;
320     } else
321         s->packet_size = 2048;
322     if (ctx->max_delay < 0) /* Not set by the caller */
323         ctx->max_delay = 0;
324
325     s->vcd_padding_bytes_written = 0;
326     s->vcd_padding_bitrate=0;
327
328     s->audio_bound = 0;
329     s->video_bound = 0;
330     mpa_id = AUDIO_ID;
331     ac3_id = AC3_ID;
332     dts_id = DTS_ID;
333     mpv_id = VIDEO_ID;
334     mps_id = SUB_ID;
335     lpcm_id = LPCM_ID;
336     for(i=0;i<ctx->nb_streams;i++) {
337         st = ctx->streams[i];
338         stream = av_mallocz(sizeof(StreamInfo));
339         if (!stream)
340             goto fail;
341         st->priv_data = stream;
342
343         avpriv_set_pts_info(st, 64, 1, 90000);
344
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)
355                         break;
356                 }
357                 if (j == 4)
358                     goto fail;
359                 if (st->codec->channels > 8)
360                     return -1;
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;
365             } else {
366                 stream->id = mpa_id++;
367             }
368
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;
372             s->audio_bound++;
373             break;
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;
378             else {
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
381             }
382 #if 0
383                 /* see VCD standard, p. IV-7*/
384                 stream->max_buffer_size = 46 * 1024;
385             else
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;
389 #endif
390             s->video_bound++;
391             break;
392         case AVMEDIA_TYPE_SUBTITLE:
393             stream->id = mps_id++;
394             stream->max_buffer_size = 16 * 1024;
395             break;
396         default:
397             return -1;
398         }
399         stream->fifo= av_fifo_alloc(16);
400         if (!stream->fifo)
401             goto fail;
402     }
403     bitrate = 0;
404     audio_bitrate = 0;
405     video_bitrate = 0;
406     for(i=0;i<ctx->nb_streams;i++) {
407         int codec_rate;
408         st = ctx->streams[i];
409         stream = (StreamInfo*) st->priv_data;
410
411         if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
412             codec_rate= st->codec->rc_max_rate;
413         else
414             codec_rate= st->codec->bit_rate;
415
416         if(!codec_rate)
417             codec_rate= (1<<21)*8*50/ctx->nb_streams;
418
419         bitrate += codec_rate;
420
421         if ((stream->id & 0xe0) == AUDIO_ID)
422             audio_bitrate += codec_rate;
423         else if (stream->id==VIDEO_ID)
424             video_bitrate += codec_rate;
425     }
426
427     if (s->user_mux_rate) {
428         s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
429     } else {
430         /* we increase slightly the bitrate to take into account the
431            headers. XXX: compute it exactly */
432         bitrate += bitrate / 20;
433         bitrate += 10000;
434         s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
435     }
436
437     if (s->is_vcd) {
438         double overhead_rate;
439
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*/
448
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 )*/
455
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);
460         overhead_rate *= 8;
461
462         /* Add padding so that the full bitrate is 2324*75 bytes/sec */
463         s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
464     }
465
466     if (s->is_vcd || s->is_mpeg2)
467         /* every packet */
468         s->pack_header_freq = 1;
469     else
470         /* every 2 seconds */
471         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
472
473     /* the above seems to make pack_header_freq zero sometimes */
474     if (s->pack_header_freq == 0)
475        s->pack_header_freq = 1;
476
477     if (s->is_mpeg2)
478         /* every 200 packets. Need to look at the spec.  */
479         s->system_header_freq = s->pack_header_freq * 40;
480     else if (s->is_vcd)
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;
485     else
486         s->system_header_freq = s->pack_header_freq * 5;
487
488     for(i=0;i<ctx->nb_streams;i++) {
489         stream = ctx->streams[i]->priv_data;
490         stream->packet_number = 0;
491     }
492     s->system_header_size = get_system_header_size(ctx);
493     s->last_scr = 0;
494     return 0;
495  fail:
496     for(i=0;i<ctx->nb_streams;i++) {
497         av_free(ctx->streams[i]->priv_data);
498     }
499     return AVERROR(ENOMEM);
500 }
501
502 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
503 {
504     avio_w8(pb,
505              (id << 4) |
506              (((timestamp >> 30) & 0x07) << 1) |
507              1);
508     avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
509     avio_wb16(pb, (uint16_t)((((timestamp      ) & 0x7fff) << 1) | 1));
510 }
511
512
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)
516 {
517     MpegMuxContext *s = ctx->priv_data;
518     int pad_bytes = 0;
519
520     if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
521     {
522         int64_t full_pad_bytes;
523
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);
526
527         if (pad_bytes<0)
528             /* might happen if we have already padded to a later timestamp. This
529                can occur if another stream has already advanced further.*/
530             pad_bytes=0;
531     }
532
533     return pad_bytes;
534 }
535
536
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)
543 {
544     MpegMuxContext *s = ctx->priv_data;
545     int buf_index;
546     StreamInfo *stream;
547
548     stream = ctx->streams[stream_index]->priv_data;
549
550     buf_index = 0;
551     if (((s->packet_number % s->pack_header_freq) == 0)) {
552         /* pack header size */
553         if (s->is_mpeg2)
554             buf_index += 14;
555         else
556             buf_index += 12;
557
558         if (s->is_vcd) {
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).*/
562
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.*/
566                 buf_index += 15;
567
568         } else {
569             if ((s->packet_number % s->system_header_freq) == 0)
570                 buf_index += s->system_header_size;
571         }
572     }
573
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;
580     else {
581         /* packet header size */
582         buf_index += 6;
583         if (s->is_mpeg2) {
584             buf_index += 3;
585             if (stream->packet_number==0)
586                 buf_index += 3; /* PES extension */
587             buf_index += 1;    /* obligatory stuffing byte */
588         }
589         if (pts != AV_NOPTS_VALUE) {
590             if (dts != pts)
591                 buf_index += 5 + 5;
592             else
593                 buf_index += 5;
594
595         } else {
596             if (!s->is_mpeg2)
597                 buf_index++;
598         }
599
600         if (stream->id < 0xc0) {
601             /* AC-3/LPCM private data header */
602             buf_index += 4;
603             if (stream->id >= 0xa0) {
604                 int n;
605                 buf_index += 3;
606                 /* NOTE: we round the payload size to an integer number of
607                    LPCM samples */
608                 n = (s->packet_size - buf_index) % stream->lpcm_align;
609                 if (n)
610                     buf_index += (stream->lpcm_align - n);
611             }
612         }
613
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).*/
617             buf_index+=20;
618     }
619     return s->packet_size - buf_index;
620 }
621 #endif
622
623 /* Write an MPEG padding packet header. */
624 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
625 {
626     MpegMuxContext *s = ctx->priv_data;
627     int i;
628
629     avio_wb32(pb, PADDING_STREAM);
630     avio_wb16(pb, packet_bytes - 6);
631     if (!s->is_mpeg2) {
632         avio_w8(pb, 0x0f);
633         packet_bytes -= 7;
634     } else
635         packet_bytes -= 6;
636
637     for(i=0;i<packet_bytes;i++)
638         avio_w8(pb, 0xff);
639 }
640
641 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
642     int nb_frames=0;
643     PacketDesc *pkt_desc= stream->premux_packet;
644
645     while(len>0){
646         if(pkt_desc->size == pkt_desc->unwritten_size)
647             nb_frames++;
648         len -= pkt_desc->unwritten_size;
649         pkt_desc= pkt_desc->next;
650     }
651
652     return nb_frames;
653 }
654
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)
658 {
659     MpegMuxContext *s = ctx->priv_data;
660     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
661     uint8_t *buf_ptr;
662     int size, payload_size, startcode, id, stuffing_size, i, header_len;
663     int packet_size;
664     uint8_t buffer[128];
665     int zero_trail_bytes = 0;
666     int pad_packet_bytes = 0;
667     int pes_flags;
668     int general_pack = 0;  /*"general" pack without data specific to one stream?*/
669     int nb_frames;
670
671     id = stream->id;
672
673     av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
674
675     buf_ptr = buffer;
676
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);
680         buf_ptr += size;
681         s->last_scr= scr;
682
683         if (s->is_vcd) {
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).*/
687
688             if (stream->packet_number==0) {
689                 size = put_system_header(ctx, buf_ptr, id);
690                 buf_ptr += size;
691             }
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;
695
696                 if (pts != AV_NOPTS_VALUE) {
697                     if (dts != pts)
698                         PES_bytes_to_fill -= 5 + 5;
699                     else
700                         PES_bytes_to_fill -= 5;
701                 }
702
703                 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
704                     size = put_system_header(ctx, buf_ptr, 0);
705                     buf_ptr += size;
706                     size = buf_ptr - buffer;
707                     avio_write(ctx->pb, buffer, size);
708
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);
714
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);
720
721                     memset(buffer, 0, 128);
722                     buf_ptr = buffer;
723                     s->packet_number++;
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);
727                     s->last_scr= scr;
728                     buf_ptr += size;
729                     /* GOP Start */
730                 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
731                     pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
732                 }
733             }
734         } else {
735             if ((s->packet_number % s->system_header_freq) == 0) {
736                 size = put_system_header(ctx, buf_ptr, 0);
737                 buf_ptr += size;
738             }
739         }
740     }
741     size = buf_ptr - buffer;
742     avio_write(ctx->pb, buffer, size);
743
744     packet_size = s->packet_size - size;
745
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;
750
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
756            the end.*/
757         /* For SVCD we fill the very first pack to increase compatibility with
758            some DVD players. Not mandated by the standard.*/
759         if (s->is_svcd)
760             general_pack = 1;    /* the system header refers to both streams and no stream data*/
761         pad_packet_bytes = packet_size - zero_trail_bytes;
762     }
763
764     packet_size -= pad_packet_bytes + zero_trail_bytes;
765
766     if (packet_size > 0) {
767
768         /* packet header size */
769         packet_size -= 6;
770
771         /* packet header */
772         if (s->is_mpeg2) {
773             header_len = 3;
774             if (stream->packet_number==0)
775                 header_len += 3; /* PES extension */
776             header_len += 1; /* obligatory stuffing byte */
777         } else {
778             header_len = 0;
779         }
780         if (pts != AV_NOPTS_VALUE) {
781             if (dts != pts)
782                 header_len += 5 + 5;
783             else
784                 header_len += 5;
785         } else {
786             if (!s->is_mpeg2)
787                 header_len++;
788         }
789
790         payload_size = packet_size - header_len;
791         if (id < 0xc0) {
792             startcode = PRIVATE_STREAM_1;
793             payload_size -= 1;
794             if (id >= 0x40) {
795                 payload_size -= 3;
796                 if (id >= 0xa0)
797                     payload_size -= 3;
798             }
799         } else {
800             startcode = 0x100 + id;
801         }
802
803         stuffing_size = payload_size - av_fifo_size(stream->fifo);
804
805         // first byte does not fit -> reset pts/dts + stuffing
806         if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
807             int timestamp_len=0;
808             if(dts != pts)
809                 timestamp_len += 5;
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;
817             } else {
818                 payload_size += timestamp_len;
819             }
820             stuffing_size += timestamp_len;
821             if(payload_size > trailer_size)
822                 stuffing_size += payload_size - trailer_size;
823         }
824
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;
830             } else {
831                 stuffing_size += pad_packet_bytes;
832             }
833             pad_packet_bytes = 0;
834         }
835
836         if (stuffing_size < 0)
837             stuffing_size = 0;
838         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
839             pad_packet_bytes += stuffing_size;
840             packet_size      -= stuffing_size;
841             payload_size     -= stuffing_size;
842             stuffing_size = 0;
843         }
844
845         nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
846
847         avio_wb32(ctx->pb, startcode);
848
849         avio_wb16(ctx->pb, packet_size);
850
851         if (!s->is_mpeg2)
852             for(i=0;i<stuffing_size;i++)
853                 avio_w8(ctx->pb, 0xff);
854
855         if (s->is_mpeg2) {
856             avio_w8(ctx->pb, 0x80); /* mpeg2 id */
857
858             pes_flags=0;
859
860             if (pts != AV_NOPTS_VALUE) {
861                 pes_flags |= 0x80;
862                 if (dts != pts)
863                     pes_flags |= 0x40;
864             }
865
866             /* Both the MPEG-2 and the SVCD standards demand that the
867                P-STD_buffer_size field be included in the first packet of
868                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
869                and MPEG-2 standard 2.7.7) */
870             if (stream->packet_number == 0)
871                 pes_flags |= 0x01;
872
873             avio_w8(ctx->pb, pes_flags); /* flags */
874             avio_w8(ctx->pb, header_len - 3 + stuffing_size);
875
876             if (pes_flags & 0x80)  /*write pts*/
877                 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
878             if (pes_flags & 0x40)  /*write dts*/
879                 put_timestamp(ctx->pb, 0x01, dts);
880
881             if (pes_flags & 0x01) {  /*write pes extension*/
882                 avio_w8(ctx->pb, 0x10); /* flags */
883
884                 /* P-STD buffer info */
885                 if ((id & 0xe0) == AUDIO_ID)
886                     avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
887                 else
888                     avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
889             }
890
891         } else {
892             if (pts != AV_NOPTS_VALUE) {
893                 if (dts != pts) {
894                     put_timestamp(ctx->pb, 0x03, pts);
895                     put_timestamp(ctx->pb, 0x01, dts);
896                 } else {
897                     put_timestamp(ctx->pb, 0x02, pts);
898                 }
899             } else {
900                 avio_w8(ctx->pb, 0x0f);
901             }
902         }
903
904         if (s->is_mpeg2) {
905             /* special stuffing byte that is always written
906                to prevent accidental generation of start codes. */
907             avio_w8(ctx->pb, 0xff);
908
909             for(i=0;i<stuffing_size;i++)
910                 avio_w8(ctx->pb, 0xff);
911         }
912
913         if (startcode == PRIVATE_STREAM_1) {
914             avio_w8(ctx->pb, id);
915             if (id >= 0xa0) {
916                 /* LPCM (XXX: check nb_frames) */
917                 avio_w8(ctx->pb, 7);
918                 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
919                 avio_w8(ctx->pb, stream->lpcm_header[0]);
920                 avio_w8(ctx->pb, stream->lpcm_header[1]);
921                 avio_w8(ctx->pb, stream->lpcm_header[2]);
922             } else if (id >= 0x40) {
923                 /* AC-3 */
924                 avio_w8(ctx->pb, nb_frames);
925                 avio_wb16(ctx->pb, trailer_size+1);
926             }
927         }
928
929         /* output data */
930         assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
931         av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, (void*)avio_write);
932         stream->bytes_to_iframe -= payload_size - stuffing_size;
933     }else{
934         payload_size=
935         stuffing_size= 0;
936     }
937
938     if (pad_packet_bytes > 0)
939         put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
940
941     for(i=0;i<zero_trail_bytes;i++)
942         avio_w8(ctx->pb, 0x00);
943
944     avio_flush(ctx->pb);
945
946     s->packet_number++;
947
948     /* only increase the stream packet number if this pack actually contains
949        something that is specific to this stream! I.e. a dedicated header
950        or some data.*/
951     if (!general_pack)
952         stream->packet_number++;
953
954     return payload_size - stuffing_size;
955 }
956
957 static void put_vcd_padding_sector(AVFormatContext *ctx)
958 {
959     /* There are two ways to do this padding: writing a sector/pack
960        of 0 values, or writing an MPEG padding pack. Both seem to
961        work with most decoders, BUT the VCD standard only allows a 0-sector
962        (see standard p. IV-4, IV-5).
963        So a 0-sector it is...*/
964
965     MpegMuxContext *s = ctx->priv_data;
966     int i;
967
968     for(i=0;i<s->packet_size;i++)
969         avio_w8(ctx->pb, 0);
970
971     s->vcd_padding_bytes_written += s->packet_size;
972
973     avio_flush(ctx->pb);
974
975     /* increasing the packet number is correct. The SCR of the following packs
976        is calculated from the packet_number and it has to include the padding
977        sector (it represents the sector index, not the MPEG pack index)
978        (see VCD standard p. IV-6)*/
979     s->packet_number++;
980 }
981
982 #if 0 /* unused, remove? */
983 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
984 {
985     MpegMuxContext *s = ctx->priv_data;
986     int64_t scr;
987
988         /* Since the data delivery rate is constant, SCR is computed
989            using the formula C + i * 1200 where C is the start constant
990            and i is the pack index.
991            It is recommended that SCR 0 is at the beginning of the VCD front
992            margin (a sequence of empty Form 2 sectors on the CD).
993            It is recommended that the front margin is 30 sectors long, so
994            we use C = 30*1200 = 36000
995            (Note that even if the front margin is not 30 sectors the file
996            will still be correct according to the standard. It just won't have
997            the "recommended" value).*/
998         scr = 36000 + s->packet_number * 1200;
999
1000     return scr;
1001 }
1002 #endif
1003
1004 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1005 //    MpegMuxContext *s = ctx->priv_data;
1006     int i;
1007
1008     for(i=0; i<ctx->nb_streams; i++){
1009         AVStream *st = ctx->streams[i];
1010         StreamInfo *stream = st->priv_data;
1011         PacketDesc *pkt_desc;
1012
1013         while((pkt_desc= stream->predecode_packet)
1014               && scr > pkt_desc->dts){ //FIXME > vs >=
1015             if(stream->buffer_index < pkt_desc->size ||
1016                stream->predecode_packet == stream->premux_packet){
1017                 av_log(ctx, AV_LOG_ERROR,
1018                        "buffer underflow i=%d bufi=%d size=%d\n",
1019                        i, stream->buffer_index, pkt_desc->size);
1020                 break;
1021             }
1022             stream->buffer_index -= pkt_desc->size;
1023
1024             stream->predecode_packet= pkt_desc->next;
1025             av_freep(&pkt_desc);
1026         }
1027     }
1028
1029     return 0;
1030 }
1031
1032 static int output_packet(AVFormatContext *ctx, int flush){
1033     MpegMuxContext *s = ctx->priv_data;
1034     AVStream *st;
1035     StreamInfo *stream;
1036     int i, avail_space=0, es_size, trailer_size;
1037     int best_i= -1;
1038     int best_score= INT_MIN;
1039     int ignore_constraints=0;
1040     int64_t scr= s->last_scr;
1041     PacketDesc *timestamp_packet;
1042     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1043
1044 retry:
1045     for(i=0; i<ctx->nb_streams; i++){
1046         AVStream *st = ctx->streams[i];
1047         StreamInfo *stream = st->priv_data;
1048         const int avail_data=  av_fifo_size(stream->fifo);
1049         const int space= stream->max_buffer_size - stream->buffer_index;
1050         int rel_space= 1024LL*space / stream->max_buffer_size;
1051         PacketDesc *next_pkt= stream->premux_packet;
1052
1053         /* for subtitle, a single PES packet must be generated,
1054            so we flush after every single subtitle packet */
1055         if(s->packet_size > avail_data && !flush
1056            && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1057             return 0;
1058         if(avail_data==0)
1059             continue;
1060         assert(avail_data>0);
1061
1062         if(space < s->packet_size && !ignore_constraints)
1063             continue;
1064
1065         if(next_pkt && next_pkt->dts - scr > max_delay)
1066             continue;
1067
1068         if(rel_space > best_score){
1069             best_score= rel_space;
1070             best_i = i;
1071             avail_space= space;
1072         }
1073     }
1074
1075     if(best_i < 0){
1076         int64_t best_dts= INT64_MAX;
1077
1078         for(i=0; i<ctx->nb_streams; i++){
1079             AVStream *st = ctx->streams[i];
1080             StreamInfo *stream = st->priv_data;
1081             PacketDesc *pkt_desc= stream->predecode_packet;
1082             if(pkt_desc && pkt_desc->dts < best_dts)
1083                 best_dts= pkt_desc->dts;
1084         }
1085
1086         av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1087                 scr / 90000.0, best_dts / 90000.0);
1088         if(best_dts == INT64_MAX)
1089             return 0;
1090
1091         if(scr >= best_dts+1 && !ignore_constraints){
1092             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1093             ignore_constraints= 1;
1094         }
1095         scr= FFMAX(best_dts+1, scr);
1096         if(remove_decoded_packets(ctx, scr) < 0)
1097             return -1;
1098         goto retry;
1099     }
1100
1101     assert(best_i >= 0);
1102
1103     st = ctx->streams[best_i];
1104     stream = st->priv_data;
1105
1106     assert(av_fifo_size(stream->fifo) > 0);
1107
1108     assert(avail_space >= s->packet_size || ignore_constraints);
1109
1110     timestamp_packet= stream->premux_packet;
1111     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1112         trailer_size= 0;
1113     }else{
1114         trailer_size= timestamp_packet->unwritten_size;
1115         timestamp_packet= timestamp_packet->next;
1116     }
1117
1118     if(timestamp_packet){
1119 //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);
1120         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1121     }else{
1122         assert(av_fifo_size(stream->fifo) == trailer_size);
1123         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1124     }
1125
1126     if (s->is_vcd) {
1127         /* Write one or more padding sectors, if necessary, to reach
1128            the constant overall bitrate.*/
1129         int vcd_pad_bytes;
1130
1131         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1132             put_vcd_padding_sector(ctx);
1133             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1134         }
1135     }
1136
1137     stream->buffer_index += es_size;
1138     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1139
1140     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1141         es_size -= stream->premux_packet->unwritten_size;
1142         stream->premux_packet= stream->premux_packet->next;
1143     }
1144     if(es_size)
1145         stream->premux_packet->unwritten_size -= es_size;
1146
1147     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1148         return -1;
1149
1150     return 1;
1151 }
1152
1153 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1154 {
1155     MpegMuxContext *s = ctx->priv_data;
1156     int stream_index= pkt->stream_index;
1157     int size= pkt->size;
1158     uint8_t *buf= pkt->data;
1159     AVStream *st = ctx->streams[stream_index];
1160     StreamInfo *stream = st->priv_data;
1161     int64_t pts, dts;
1162     PacketDesc *pkt_desc;
1163     int preload;
1164     const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1165
1166     preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1167
1168     pts= pkt->pts;
1169     dts= pkt->dts;
1170
1171     if(pts != AV_NOPTS_VALUE) pts += 2*preload;
1172     if(dts != AV_NOPTS_VALUE){
1173         if(!s->last_scr)
1174             s->last_scr= dts + preload;
1175         dts += 2*preload;
1176     }
1177
1178 //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);
1179     if (!stream->premux_packet)
1180         stream->next_packet = &stream->premux_packet;
1181     *stream->next_packet=
1182     pkt_desc= av_mallocz(sizeof(PacketDesc));
1183     pkt_desc->pts= pts;
1184     pkt_desc->dts= dts;
1185     pkt_desc->unwritten_size=
1186     pkt_desc->size= size;
1187     if(!stream->predecode_packet)
1188         stream->predecode_packet= pkt_desc;
1189     stream->next_packet= &pkt_desc->next;
1190
1191     if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1192         return -1;
1193
1194     if (s->is_dvd){
1195         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1196             stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1197             stream->align_iframe = 1;
1198             stream->vobu_start_pts = pts;
1199         }
1200     }
1201
1202     av_fifo_generic_write(stream->fifo, buf, size, NULL);
1203
1204     for(;;){
1205         int ret= output_packet(ctx, 0);
1206         if(ret<=0)
1207             return ret;
1208     }
1209 }
1210
1211 static int mpeg_mux_end(AVFormatContext *ctx)
1212 {
1213 //    MpegMuxContext *s = ctx->priv_data;
1214     StreamInfo *stream;
1215     int i;
1216
1217     for(;;){
1218         int ret= output_packet(ctx, 1);
1219         if(ret<0)
1220             return ret;
1221         else if(ret==0)
1222             break;
1223     }
1224
1225     /* End header according to MPEG1 systems standard. We do not write
1226        it as it is usually not needed by decoders and because it
1227        complicates MPEG stream concatenation. */
1228     //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1229     //avio_flush(ctx->pb);
1230
1231     for(i=0;i<ctx->nb_streams;i++) {
1232         stream = ctx->streams[i]->priv_data;
1233
1234         assert(av_fifo_size(stream->fifo) == 0);
1235         av_fifo_free(stream->fifo);
1236     }
1237     return 0;
1238 }
1239
1240 #define OFFSET(x) offsetof(MpegMuxContext, x)
1241 #define E AV_OPT_FLAG_ENCODING_PARAM
1242 static const AVOption options[] = {
1243     { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, {0}, 0, INT_MAX, E },
1244     { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload),  AV_OPT_TYPE_INT, {500000}, 0, INT_MAX, E},
1245     { NULL },
1246 };
1247
1248 #define MPEGENC_CLASS(flavor)\
1249 static const AVClass flavor ## _class = {\
1250     .class_name = #flavor " muxer",\
1251     .item_name  = av_default_item_name,\
1252     .version    = LIBAVUTIL_VERSION_INT,\
1253     .option     = options,\
1254 };
1255
1256 #if CONFIG_MPEG1SYSTEM_MUXER
1257 MPEGENC_CLASS(mpeg)
1258 AVOutputFormat ff_mpeg1system_muxer = {
1259     .name              = "mpeg",
1260     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1261     .mime_type         = "video/mpeg",
1262     .extensions        = "mpg,mpeg",
1263     .priv_data_size    = sizeof(MpegMuxContext),
1264     .audio_codec       = CODEC_ID_MP2,
1265     .video_codec       = CODEC_ID_MPEG1VIDEO,
1266     .write_header      = mpeg_mux_init,
1267     .write_packet      = mpeg_mux_write_packet,
1268     .write_trailer     = mpeg_mux_end,
1269     .priv_class        = &mpeg_class,
1270 };
1271 #endif
1272 #if CONFIG_MPEG1VCD_MUXER
1273 MPEGENC_CLASS(vcd)
1274 AVOutputFormat ff_mpeg1vcd_muxer = {
1275     .name              = "vcd",
1276     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1277     .mime_type         = "video/mpeg",
1278     .priv_data_size    = sizeof(MpegMuxContext),
1279     .audio_codec       = CODEC_ID_MP2,
1280     .video_codec       = CODEC_ID_MPEG1VIDEO,
1281     .write_header      = mpeg_mux_init,
1282     .write_packet      = mpeg_mux_write_packet,
1283     .write_trailer     = mpeg_mux_end,
1284     .priv_class        = &vcd_class,
1285 };
1286 #endif
1287 #if CONFIG_MPEG2VOB_MUXER
1288 MPEGENC_CLASS(vob)
1289 AVOutputFormat ff_mpeg2vob_muxer = {
1290     .name              = "vob",
1291     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1292     .mime_type         = "video/mpeg",
1293     .extensions        = "vob",
1294     .priv_data_size    = sizeof(MpegMuxContext),
1295     .audio_codec       = CODEC_ID_MP2,
1296     .video_codec       = CODEC_ID_MPEG2VIDEO,
1297     .write_header      = mpeg_mux_init,
1298     .write_packet      = mpeg_mux_write_packet,
1299     .write_trailer     = mpeg_mux_end,
1300     .priv_class        = &vob_class,
1301 };
1302 #endif
1303
1304 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1305 #if CONFIG_MPEG2SVCD_MUXER
1306 MPEGENC_CLASS(svcd)
1307 AVOutputFormat ff_mpeg2svcd_muxer = {
1308     .name              = "svcd",
1309     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1310     .mime_type         = "video/mpeg",
1311     .extensions        = "vob",
1312     .priv_data_size    = sizeof(MpegMuxContext),
1313     .audio_codec       = CODEC_ID_MP2,
1314     .video_codec       = CODEC_ID_MPEG2VIDEO,
1315     .write_header      = mpeg_mux_init,
1316     .write_packet      = mpeg_mux_write_packet,
1317     .write_trailer     = mpeg_mux_end,
1318     .priv_class        = &svcd_class,
1319 };
1320 #endif
1321
1322 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1323 #if CONFIG_MPEG2DVD_MUXER
1324 MPEGENC_CLASS(dvd)
1325 AVOutputFormat ff_mpeg2dvd_muxer = {
1326     .name              = "dvd",
1327     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1328     .mime_type         = "video/mpeg",
1329     .extensions        = "dvd",
1330     .priv_data_size    = sizeof(MpegMuxContext),
1331     .audio_codec       = CODEC_ID_MP2,
1332     .video_codec       = CODEC_ID_MPEG2VIDEO,
1333     .write_header      = mpeg_mux_init,
1334     .write_packet      = mpeg_mux_write_packet,
1335     .write_trailer     = mpeg_mux_end,
1336     .priv_class        = &dvd_class,
1337 };
1338 #endif