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