Init SCR in mpeg muxer based on first DTS.
[libav.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 & AV_PKT_FLAG_KEY);
1160
1161 pts= pkt->pts;
1162 dts= pkt->dts;
1163 if(!s->last_scr)
1164 s->last_scr= dts;
1165
1166 if(pts != AV_NOPTS_VALUE) pts += preload;
1167 if(dts != AV_NOPTS_VALUE) dts += preload;
1168
1169 //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);
1170 if (!stream->premux_packet)
1171 stream->next_packet = &stream->premux_packet;
1172 *stream->next_packet=
1173 pkt_desc= av_mallocz(sizeof(PacketDesc));
1174 pkt_desc->pts= pts;
1175 pkt_desc->dts= dts;
1176 pkt_desc->unwritten_size=
1177 pkt_desc->size= size;
1178 if(!stream->predecode_packet)
1179 stream->predecode_packet= pkt_desc;
1180 stream->next_packet= &pkt_desc->next;
1181
1182 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1183 return -1;
1184
1185 if (s->is_dvd){
1186 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1187 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1188 stream->align_iframe = 1;
1189 stream->vobu_start_pts = pts;
1190 }
1191 }
1192
1193 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1194
1195 for(;;){
1196 int ret= output_packet(ctx, 0);
1197 if(ret<=0)
1198 return ret;
1199 }
1200 }
1201
1202 static int mpeg_mux_end(AVFormatContext *ctx)
1203 {
1204 // MpegMuxContext *s = ctx->priv_data;
1205 StreamInfo *stream;
1206 int i;
1207
1208 for(;;){
1209 int ret= output_packet(ctx, 1);
1210 if(ret<0)
1211 return ret;
1212 else if(ret==0)
1213 break;
1214 }
1215
1216 /* End header according to MPEG1 systems standard. We do not write
1217 it as it is usually not needed by decoders and because it
1218 complicates MPEG stream concatenation. */
1219 //put_be32(ctx->pb, ISO_11172_END_CODE);
1220 //put_flush_packet(ctx->pb);
1221
1222 for(i=0;i<ctx->nb_streams;i++) {
1223 stream = ctx->streams[i]->priv_data;
1224
1225 assert(av_fifo_size(stream->fifo) == 0);
1226 av_fifo_free(stream->fifo);
1227 }
1228 return 0;
1229 }
1230
1231 #if CONFIG_MPEG1SYSTEM_MUXER
1232 AVOutputFormat mpeg1system_muxer = {
1233 "mpeg",
1234 NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
1235 "video/mpeg",
1236 "mpg,mpeg",
1237 sizeof(MpegMuxContext),
1238 CODEC_ID_MP2,
1239 CODEC_ID_MPEG1VIDEO,
1240 mpeg_mux_init,
1241 mpeg_mux_write_packet,
1242 mpeg_mux_end,
1243 };
1244 #endif
1245 #if CONFIG_MPEG1VCD_MUXER
1246 AVOutputFormat mpeg1vcd_muxer = {
1247 "vcd",
1248 NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
1249 "video/mpeg",
1250 NULL,
1251 sizeof(MpegMuxContext),
1252 CODEC_ID_MP2,
1253 CODEC_ID_MPEG1VIDEO,
1254 mpeg_mux_init,
1255 mpeg_mux_write_packet,
1256 mpeg_mux_end,
1257 };
1258 #endif
1259 #if CONFIG_MPEG2VOB_MUXER
1260 AVOutputFormat mpeg2vob_muxer = {
1261 "vob",
1262 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1263 "video/mpeg",
1264 "vob",
1265 sizeof(MpegMuxContext),
1266 CODEC_ID_MP2,
1267 CODEC_ID_MPEG2VIDEO,
1268 mpeg_mux_init,
1269 mpeg_mux_write_packet,
1270 mpeg_mux_end,
1271 };
1272 #endif
1273
1274 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1275 #if CONFIG_MPEG2SVCD_MUXER
1276 AVOutputFormat mpeg2svcd_muxer = {
1277 "svcd",
1278 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
1279 "video/mpeg",
1280 "vob",
1281 sizeof(MpegMuxContext),
1282 CODEC_ID_MP2,
1283 CODEC_ID_MPEG2VIDEO,
1284 mpeg_mux_init,
1285 mpeg_mux_write_packet,
1286 mpeg_mux_end,
1287 };
1288 #endif
1289
1290 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1291 #if CONFIG_MPEG2DVD_MUXER
1292 AVOutputFormat mpeg2dvd_muxer = {
1293 "dvd",
1294 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
1295 "video/mpeg",
1296 "dvd",
1297 sizeof(MpegMuxContext),
1298 CODEC_ID_MP2,
1299 CODEC_ID_MPEG2VIDEO,
1300 mpeg_mux_init,
1301 mpeg_mux_write_packet,
1302 mpeg_mux_end,
1303 };
1304 #endif