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