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