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