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