bda8d8324b8b45ac813614f516216c5e92400ce4
[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         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
836             pad_packet_bytes += stuffing_size;
837             packet_size      -= stuffing_size;
838             payload_size     -= stuffing_size;
839             stuffing_size = 0;
840         }
841
842         nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
843
844         avio_wb32(ctx->pb, startcode);
845
846         avio_wb16(ctx->pb, packet_size);
847
848         if (!s->is_mpeg2)
849             for(i=0;i<stuffing_size;i++)
850                 avio_w8(ctx->pb, 0xff);
851
852         if (s->is_mpeg2) {
853             avio_w8(ctx->pb, 0x80); /* mpeg2 id */
854
855             pes_flags=0;
856
857             if (pts != AV_NOPTS_VALUE) {
858                 pes_flags |= 0x80;
859                 if (dts != pts)
860                     pes_flags |= 0x40;
861             }
862
863             /* Both the MPEG-2 and the SVCD standards demand that the
864                P-STD_buffer_size field be included in the first packet of
865                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
866                and MPEG-2 standard 2.7.7) */
867             if (stream->packet_number == 0)
868                 pes_flags |= 0x01;
869
870             avio_w8(ctx->pb, pes_flags); /* flags */
871             avio_w8(ctx->pb, header_len - 3 + stuffing_size);
872
873             if (pes_flags & 0x80)  /*write pts*/
874                 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
875             if (pes_flags & 0x40)  /*write dts*/
876                 put_timestamp(ctx->pb, 0x01, dts);
877
878             if (pes_flags & 0x01) {  /*write pes extension*/
879                 avio_w8(ctx->pb, 0x10); /* flags */
880
881                 /* P-STD buffer info */
882                 if ((id & 0xe0) == AUDIO_ID)
883                     avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
884                 else
885                     avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
886             }
887
888         } else {
889             if (pts != AV_NOPTS_VALUE) {
890                 if (dts != pts) {
891                     put_timestamp(ctx->pb, 0x03, pts);
892                     put_timestamp(ctx->pb, 0x01, dts);
893                 } else {
894                     put_timestamp(ctx->pb, 0x02, pts);
895                 }
896             } else {
897                 avio_w8(ctx->pb, 0x0f);
898             }
899         }
900
901         if (s->is_mpeg2) {
902             /* special stuffing byte that is always written
903                to prevent accidental generation of start codes. */
904             avio_w8(ctx->pb, 0xff);
905
906             for(i=0;i<stuffing_size;i++)
907                 avio_w8(ctx->pb, 0xff);
908         }
909
910         if (startcode == PRIVATE_STREAM_1) {
911             avio_w8(ctx->pb, id);
912             if (id >= 0xa0) {
913                 /* LPCM (XXX: check nb_frames) */
914                 avio_w8(ctx->pb, 7);
915                 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
916                 avio_w8(ctx->pb, stream->lpcm_header[0]);
917                 avio_w8(ctx->pb, stream->lpcm_header[1]);
918                 avio_w8(ctx->pb, stream->lpcm_header[2]);
919             } else if (id >= 0x40) {
920                 /* AC-3 */
921                 avio_w8(ctx->pb, nb_frames);
922                 avio_wb16(ctx->pb, trailer_size+1);
923             }
924         }
925
926         /* output data */
927         assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
928         av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &avio_write);
929         stream->bytes_to_iframe -= payload_size - stuffing_size;
930     }else{
931         payload_size=
932         stuffing_size= 0;
933     }
934
935     if (pad_packet_bytes > 0)
936         put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
937
938     for(i=0;i<zero_trail_bytes;i++)
939         avio_w8(ctx->pb, 0x00);
940
941     avio_flush(ctx->pb);
942
943     s->packet_number++;
944
945     /* only increase the stream packet number if this pack actually contains
946        something that is specific to this stream! I.e. a dedicated header
947        or some data.*/
948     if (!general_pack)
949         stream->packet_number++;
950
951     return payload_size - stuffing_size;
952 }
953
954 static void put_vcd_padding_sector(AVFormatContext *ctx)
955 {
956     /* There are two ways to do this padding: writing a sector/pack
957        of 0 values, or writing an MPEG padding pack. Both seem to
958        work with most decoders, BUT the VCD standard only allows a 0-sector
959        (see standard p. IV-4, IV-5).
960        So a 0-sector it is...*/
961
962     MpegMuxContext *s = ctx->priv_data;
963     int i;
964
965     for(i=0;i<s->packet_size;i++)
966         avio_w8(ctx->pb, 0);
967
968     s->vcd_padding_bytes_written += s->packet_size;
969
970     avio_flush(ctx->pb);
971
972     /* increasing the packet number is correct. The SCR of the following packs
973        is calculated from the packet_number and it has to include the padding
974        sector (it represents the sector index, not the MPEG pack index)
975        (see VCD standard p. IV-6)*/
976     s->packet_number++;
977 }
978
979 #if 0 /* unused, remove? */
980 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
981 {
982     MpegMuxContext *s = ctx->priv_data;
983     int64_t scr;
984
985         /* Since the data delivery rate is constant, SCR is computed
986            using the formula C + i * 1200 where C is the start constant
987            and i is the pack index.
988            It is recommended that SCR 0 is at the beginning of the VCD front
989            margin (a sequence of empty Form 2 sectors on the CD).
990            It is recommended that the front margin is 30 sectors long, so
991            we use C = 30*1200 = 36000
992            (Note that even if the front margin is not 30 sectors the file
993            will still be correct according to the standard. It just won't have
994            the "recommended" value).*/
995         scr = 36000 + s->packet_number * 1200;
996
997     return scr;
998 }
999 #endif
1000
1001 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1002 //    MpegMuxContext *s = ctx->priv_data;
1003     int i;
1004
1005     for(i=0; i<ctx->nb_streams; i++){
1006         AVStream *st = ctx->streams[i];
1007         StreamInfo *stream = st->priv_data;
1008         PacketDesc *pkt_desc;
1009
1010         while((pkt_desc= stream->predecode_packet)
1011               && scr > pkt_desc->dts){ //FIXME > vs >=
1012             if(stream->buffer_index < pkt_desc->size ||
1013                stream->predecode_packet == stream->premux_packet){
1014                 av_log(ctx, AV_LOG_ERROR,
1015                        "buffer underflow i=%d bufi=%d size=%d\n",
1016                        i, stream->buffer_index, pkt_desc->size);
1017                 break;
1018             }
1019             stream->buffer_index -= pkt_desc->size;
1020
1021             stream->predecode_packet= pkt_desc->next;
1022             av_freep(&pkt_desc);
1023         }
1024     }
1025
1026     return 0;
1027 }
1028
1029 static int output_packet(AVFormatContext *ctx, int flush){
1030     MpegMuxContext *s = ctx->priv_data;
1031     AVStream *st;
1032     StreamInfo *stream;
1033     int i, avail_space=0, es_size, trailer_size;
1034     int best_i= -1;
1035     int best_score= INT_MIN;
1036     int ignore_constraints=0;
1037     int64_t scr= s->last_scr;
1038     PacketDesc *timestamp_packet;
1039     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1040
1041 retry:
1042     for(i=0; i<ctx->nb_streams; i++){
1043         AVStream *st = ctx->streams[i];
1044         StreamInfo *stream = st->priv_data;
1045         const int avail_data=  av_fifo_size(stream->fifo);
1046         const int space= stream->max_buffer_size - stream->buffer_index;
1047         int rel_space= 1024*space / stream->max_buffer_size;
1048         PacketDesc *next_pkt= stream->premux_packet;
1049
1050         /* for subtitle, a single PES packet must be generated,
1051            so we flush after every single subtitle packet */
1052         if(s->packet_size > avail_data && !flush
1053            && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
1054             return 0;
1055         if(avail_data==0)
1056             continue;
1057         assert(avail_data>0);
1058
1059         if(space < s->packet_size && !ignore_constraints)
1060             continue;
1061
1062         if(next_pkt && next_pkt->dts - scr > max_delay)
1063             continue;
1064
1065         if(rel_space > best_score){
1066             best_score= rel_space;
1067             best_i = i;
1068             avail_space= space;
1069         }
1070     }
1071
1072     if(best_i < 0){
1073         int64_t best_dts= INT64_MAX;
1074
1075         for(i=0; i<ctx->nb_streams; i++){
1076             AVStream *st = ctx->streams[i];
1077             StreamInfo *stream = st->priv_data;
1078             PacketDesc *pkt_desc= stream->predecode_packet;
1079             if(pkt_desc && pkt_desc->dts < best_dts)
1080                 best_dts= pkt_desc->dts;
1081         }
1082
1083         av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
1084                 scr / 90000.0, best_dts / 90000.0);
1085         if(best_dts == INT64_MAX)
1086             return 0;
1087
1088         if(scr >= best_dts+1 && !ignore_constraints){
1089             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1090             ignore_constraints= 1;
1091         }
1092         scr= FFMAX(best_dts+1, scr);
1093         if(remove_decoded_packets(ctx, scr) < 0)
1094             return -1;
1095         goto retry;
1096     }
1097
1098     assert(best_i >= 0);
1099
1100     st = ctx->streams[best_i];
1101     stream = st->priv_data;
1102
1103     assert(av_fifo_size(stream->fifo) > 0);
1104
1105     assert(avail_space >= s->packet_size || ignore_constraints);
1106
1107     timestamp_packet= stream->premux_packet;
1108     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1109         trailer_size= 0;
1110     }else{
1111         trailer_size= timestamp_packet->unwritten_size;
1112         timestamp_packet= timestamp_packet->next;
1113     }
1114
1115     if(timestamp_packet){
1116 //av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f scr:%f stream:%d\n", timestamp_packet->dts/90000.0, timestamp_packet->pts/90000.0, scr/90000.0, best_i);
1117         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1118     }else{
1119         assert(av_fifo_size(stream->fifo) == trailer_size);
1120         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1121     }
1122
1123     if (s->is_vcd) {
1124         /* Write one or more padding sectors, if necessary, to reach
1125            the constant overall bitrate.*/
1126         int vcd_pad_bytes;
1127
1128         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1129             put_vcd_padding_sector(ctx);
1130             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1131         }
1132     }
1133
1134     stream->buffer_index += es_size;
1135     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1136
1137     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1138         es_size -= stream->premux_packet->unwritten_size;
1139         stream->premux_packet= stream->premux_packet->next;
1140     }
1141     if(es_size)
1142         stream->premux_packet->unwritten_size -= es_size;
1143
1144     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1145         return -1;
1146
1147     return 1;
1148 }
1149
1150 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1151 {
1152     MpegMuxContext *s = ctx->priv_data;
1153     int stream_index= pkt->stream_index;
1154     int size= pkt->size;
1155     uint8_t *buf= pkt->data;
1156     AVStream *st = ctx->streams[stream_index];
1157     StreamInfo *stream = st->priv_data;
1158     int64_t pts, dts;
1159     PacketDesc *pkt_desc;
1160     int preload;
1161     const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1162
1163     preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1164
1165     pts= pkt->pts;
1166     dts= pkt->dts;
1167
1168     if(pts != AV_NOPTS_VALUE) pts += 2*preload;
1169     if(dts != AV_NOPTS_VALUE){
1170         if(!s->last_scr)
1171             s->last_scr= dts + preload;
1172         dts += 2*preload;
1173     }
1174
1175 //av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index, pts != AV_NOPTS_VALUE);
1176     if (!stream->premux_packet)
1177         stream->next_packet = &stream->premux_packet;
1178     *stream->next_packet=
1179     pkt_desc= av_mallocz(sizeof(PacketDesc));
1180     pkt_desc->pts= pts;
1181     pkt_desc->dts= dts;
1182     pkt_desc->unwritten_size=
1183     pkt_desc->size= size;
1184     if(!stream->predecode_packet)
1185         stream->predecode_packet= pkt_desc;
1186     stream->next_packet= &pkt_desc->next;
1187
1188     if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1189         return -1;
1190
1191     if (s->is_dvd){
1192         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1193             stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1194             stream->align_iframe = 1;
1195             stream->vobu_start_pts = pts;
1196         }
1197     }
1198
1199     av_fifo_generic_write(stream->fifo, buf, size, NULL);
1200
1201     for(;;){
1202         int ret= output_packet(ctx, 0);
1203         if(ret<=0)
1204             return ret;
1205     }
1206 }
1207
1208 static int mpeg_mux_end(AVFormatContext *ctx)
1209 {
1210 //    MpegMuxContext *s = ctx->priv_data;
1211     StreamInfo *stream;
1212     int i;
1213
1214     for(;;){
1215         int ret= output_packet(ctx, 1);
1216         if(ret<0)
1217             return ret;
1218         else if(ret==0)
1219             break;
1220     }
1221
1222     /* End header according to MPEG1 systems standard. We do not write
1223        it as it is usually not needed by decoders and because it
1224        complicates MPEG stream concatenation. */
1225     //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1226     //avio_flush(ctx->pb);
1227
1228     for(i=0;i<ctx->nb_streams;i++) {
1229         stream = ctx->streams[i]->priv_data;
1230
1231         assert(av_fifo_size(stream->fifo) == 0);
1232         av_fifo_free(stream->fifo);
1233     }
1234     return 0;
1235 }
1236
1237 #define OFFSET(x) offsetof(MpegMuxContext, x)
1238 #define E AV_OPT_FLAG_ENCODING_PARAM
1239 static const AVOption options[] = {
1240     { "muxrate", NULL, OFFSET(mux_rate), AV_OPT_TYPE_INT, {0}, 0, INT_MAX, E },
1241     { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload),  AV_OPT_TYPE_INT, {500000}, 0, INT_MAX, E},
1242     { NULL },
1243 };
1244
1245 #define MPEGENC_CLASS(flavor)\
1246 static const AVClass flavor ## _class = {\
1247     .class_name = #flavor " muxer",\
1248     .item_name  = av_default_item_name,\
1249     .version    = LIBAVUTIL_VERSION_INT,\
1250     .option     = options,\
1251 };
1252
1253 #if CONFIG_MPEG1SYSTEM_MUXER
1254 MPEGENC_CLASS(mpeg)
1255 AVOutputFormat ff_mpeg1system_muxer = {
1256     .name              = "mpeg",
1257     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1258     .mime_type         = "video/mpeg",
1259     .extensions        = "mpg,mpeg",
1260     .priv_data_size    = sizeof(MpegMuxContext),
1261     .audio_codec       = CODEC_ID_MP2,
1262     .video_codec       = CODEC_ID_MPEG1VIDEO,
1263     .write_header      = mpeg_mux_init,
1264     .write_packet      = mpeg_mux_write_packet,
1265     .write_trailer     = mpeg_mux_end,
1266     .priv_class        = &mpeg_class,
1267 };
1268 #endif
1269 #if CONFIG_MPEG1VCD_MUXER
1270 MPEGENC_CLASS(vcd)
1271 AVOutputFormat ff_mpeg1vcd_muxer = {
1272     .name              = "vcd",
1273     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1274     .mime_type         = "video/mpeg",
1275     .priv_data_size    = sizeof(MpegMuxContext),
1276     .audio_codec       = CODEC_ID_MP2,
1277     .video_codec       = CODEC_ID_MPEG1VIDEO,
1278     .write_header      = mpeg_mux_init,
1279     .write_packet      = mpeg_mux_write_packet,
1280     .write_trailer     = mpeg_mux_end,
1281     .priv_class        = &vcd_class,
1282 };
1283 #endif
1284 #if CONFIG_MPEG2VOB_MUXER
1285 MPEGENC_CLASS(vob)
1286 AVOutputFormat ff_mpeg2vob_muxer = {
1287     .name              = "vob",
1288     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1289     .mime_type         = "video/mpeg",
1290     .extensions        = "vob",
1291     .priv_data_size    = sizeof(MpegMuxContext),
1292     .audio_codec       = CODEC_ID_MP2,
1293     .video_codec       = CODEC_ID_MPEG2VIDEO,
1294     .write_header      = mpeg_mux_init,
1295     .write_packet      = mpeg_mux_write_packet,
1296     .write_trailer     = mpeg_mux_end,
1297     .priv_class        = &vob_class,
1298 };
1299 #endif
1300
1301 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1302 #if CONFIG_MPEG2SVCD_MUXER
1303 MPEGENC_CLASS(svcd)
1304 AVOutputFormat ff_mpeg2svcd_muxer = {
1305     .name              = "svcd",
1306     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1307     .mime_type         = "video/mpeg",
1308     .extensions        = "vob",
1309     .priv_data_size    = sizeof(MpegMuxContext),
1310     .audio_codec       = CODEC_ID_MP2,
1311     .video_codec       = CODEC_ID_MPEG2VIDEO,
1312     .write_header      = mpeg_mux_init,
1313     .write_packet      = mpeg_mux_write_packet,
1314     .write_trailer     = mpeg_mux_end,
1315     .priv_class        = &svcd_class,
1316 };
1317 #endif
1318
1319 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1320 #if CONFIG_MPEG2DVD_MUXER
1321 MPEGENC_CLASS(dvd)
1322 AVOutputFormat ff_mpeg2dvd_muxer = {
1323     .name              = "dvd",
1324     .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1325     .mime_type         = "video/mpeg",
1326     .extensions        = "dvd",
1327     .priv_data_size    = sizeof(MpegMuxContext),
1328     .audio_codec       = CODEC_ID_MP2,
1329     .video_codec       = CODEC_ID_MPEG2VIDEO,
1330     .write_header      = mpeg_mux_init,
1331     .write_packet      = mpeg_mux_write_packet,
1332     .write_trailer     = mpeg_mux_end,
1333     .priv_class        = &dvd_class,
1334 };
1335 #endif