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