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
38 typedef struct PacketDesc {
39 int64_t pts;
40 int64_t dts;
41 int size;
42 int unwritten_size;
43 struct PacketDesc *next;
44 } PacketDesc;
45
46 typedef struct StreamInfo {
47 AVFifoBuffer *fifo;
48 uint8_t id;
49 int max_buffer_size; /* in bytes */
50 int buffer_index;
51 PacketDesc *predecode_packet; /* start of packet queue */
52 PacketDesc *last_packet; /* end of packet queue */
53 PacketDesc *premux_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
62 typedef 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
86 extern AVOutputFormat ff_mpeg1vcd_muxer;
87 extern AVOutputFormat ff_mpeg2dvd_muxer;
88 extern AVOutputFormat ff_mpeg2svcd_muxer;
89 extern AVOutputFormat ff_mpeg2vob_muxer;
90
put_pack_header(AVFormatContext * ctx,uint8_t * buf,int64_t timestamp)91 static 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
put_system_header(AVFormatContext * ctx,uint8_t * buf,int only_for_stream_id)125 static 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
get_system_header_size(AVFormatContext * ctx)274 static 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
mpeg_mux_init(AVFormatContext * ctx)297 static 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 return AVERROR(EINVAL);
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 return AVERROR(ENOMEM);
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 st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD))
358 av_log(ctx, AV_LOG_WARNING,
359 "%s in MPEG-1 system streams is not widely supported, "
360 "consider using the vob or the dvd muxer "
361 "to force a MPEG-2 program stream.\n",
362 avcodec_get_name(st->codecpar->codec_id));
363 if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
364 stream->id = ac3_id++;
365 } else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {
366 stream->id = dts_id++;
367 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
368 stream->id = lpcm_id++;
369 for (j = 0; j < 4; j++) {
370 if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
371 break;
372 }
373 if (j == 4) {
374 int sr;
375 av_log(ctx, AV_LOG_ERROR, "Invalid sampling rate for PCM stream.\n");
376 av_log(ctx, AV_LOG_INFO, "Allowed sampling rates:");
377 for (sr = 0; sr < 4; sr++)
378 av_log(ctx, AV_LOG_INFO, " %d", lpcm_freq_tab[sr]);
379 av_log(ctx, AV_LOG_INFO, "\n");
380 return AVERROR(EINVAL);
381 }
382 if (st->codecpar->channels > 8) {
383 av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");
384 return AVERROR(EINVAL);
385 }
386 stream->lpcm_header[0] = 0x0c;
387 stream->lpcm_header[1] = (st->codecpar->channels - 1) | (j << 4);
388 stream->lpcm_header[2] = 0x80;
389 stream->lpcm_align = st->codecpar->channels * 2;
390 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
391 int freq;
392
393 switch (st->codecpar->sample_rate) {
394 case 48000: freq = 0; break;
395 case 96000: freq = 1; break;
396 case 44100: freq = 2; break;
397 case 32000: freq = 3; break;
398 default:
399 av_log(ctx, AV_LOG_ERROR, "Unsupported sample rate.\n");
400 return AVERROR(EINVAL);
401 }
402
403 stream->lpcm_header[0] = 0x0c;
404 stream->lpcm_header[1] = (freq << 4) |
405 (((st->codecpar->bits_per_coded_sample - 16) / 4) << 6) |
406 st->codecpar->channels - 1;
407 stream->lpcm_header[2] = 0x80;
408 stream->id = lpcm_id++;
409 stream->lpcm_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample / 8;
410 } else if (st->codecpar->codec_id == AV_CODEC_ID_MLP ||
411 st->codecpar->codec_id == AV_CODEC_ID_TRUEHD) {
412 av_log(ctx, AV_LOG_ERROR, "Support for muxing audio codec %s not implemented.\n",
413 avcodec_get_name(st->codecpar->codec_id));
414 return AVERROR_PATCHWELCOME;
415 } else if (st->codecpar->codec_id != AV_CODEC_ID_MP1 &&
416 st->codecpar->codec_id != AV_CODEC_ID_MP2 &&
417 st->codecpar->codec_id != AV_CODEC_ID_MP3) {
418 av_log(ctx, AV_LOG_ERROR, "Unsupported audio codec. Must be one of mp1, mp2, mp3, 16-bit pcm_dvd, pcm_s16be, ac3 or dts.\n");
419 return AVERROR(EINVAL);
420 } else {
421 stream->id = mpa_id++;
422 }
423
424 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
425 * Right now it is also used for everything else. */
426 stream->max_buffer_size = 4 * 1024;
427 s->audio_bound++;
428 break;
429 case AVMEDIA_TYPE_VIDEO:
430 if (st->codecpar->codec_id == AV_CODEC_ID_H264)
431 stream->id = h264_id++;
432 else
433 stream->id = mpv_id++;
434
435 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
436 if (props && props->buffer_size)
437 stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
438 else {
439 av_log(ctx, AV_LOG_WARNING,
440 "VBV buffer size not set, using default size of 230KB\n"
441 "If you want the mpeg file to be compliant to some specification\n"
442 "Like DVD, VCD or others, make sure you set the correct buffer size\n");
443 // FIXME: this is probably too small as default
444 stream->max_buffer_size = 230 * 1024;
445 }
446 if (stream->max_buffer_size > 1024 * 8191) {
447 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
448 stream->max_buffer_size = 1024 * 8191;
449 }
450 s->video_bound++;
451 break;
452 case AVMEDIA_TYPE_SUBTITLE:
453 stream->id = mps_id++;
454 stream->max_buffer_size = 16 * 1024;
455 break;
456 default:
457 av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
458 av_get_media_type_string(st->codecpar->codec_type), i);
459 return AVERROR(EINVAL);
460 }
461 stream->fifo = av_fifo_alloc(16);
462 if (!stream->fifo)
463 return AVERROR(ENOMEM);
464 }
465 bitrate = 0;
466 audio_bitrate = 0;
467 video_bitrate = 0;
468 for (i = 0; i < ctx->nb_streams; i++) {
469 AVCPBProperties *props;
470 int codec_rate;
471 st = ctx->streams[i];
472 stream = (StreamInfo *)st->priv_data;
473
474 props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
475 if (props)
476 codec_rate = props->max_bitrate;
477 else
478 codec_rate = st->codecpar->bit_rate;
479
480 if (!codec_rate)
481 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
482
483 bitrate += codec_rate;
484
485 if ((stream->id & 0xe0) == AUDIO_ID)
486 audio_bitrate += codec_rate;
487 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
488 video_bitrate += codec_rate;
489 }
490
491 if (s->user_mux_rate) {
492 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
493 } else {
494 /* we increase slightly the bitrate to take into account the
495 * headers. XXX: compute it exactly */
496 bitrate += bitrate / 20;
497 bitrate += 10000;
498 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
499 if (s->mux_rate >= (1<<22)) {
500 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
501 s->mux_rate = (1<<22) - 1;
502 }
503 }
504
505 if (s->is_vcd) {
506 int64_t overhead_rate;
507
508 /* The VCD standard mandates that the mux_rate field is 3528
509 * (see standard p. IV-6).
510 * The value is actually "wrong", i.e. if you calculate
511 * it using the normal formula and the 75 sectors per second transfer
512 * rate you get a different value because the real pack size is 2324,
513 * not 2352. But the standard explicitly specifies that the mux_rate
514 * field in the header must have this value. */
515 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
516
517 /* The VCD standard states that the muxed stream must be
518 * exactly 75 packs / second (the data rate of a single speed cdrom).
519 * Since the video bitrate (probably 1150000 bits/sec) will be below
520 * the theoretical maximum we have to add some padding packets
521 * to make up for the lower data rate.
522 * (cf. VCD standard p. IV-6 ) */
523
524 /* Add the header overhead to the data rate.
525 * 2279 data bytes per audio pack, 2294 data bytes per video pack */
526 overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
527 overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
528
529 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
530 s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
531 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)
532 }
533
534 if (s->is_vcd || s->is_mpeg2)
535 /* every packet */
536 s->pack_header_freq = 1;
537 else
538 /* every 2 seconds */
539 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
540
541 /* the above seems to make pack_header_freq zero sometimes */
542 if (s->pack_header_freq == 0)
543 s->pack_header_freq = 1;
544
545 if (s->is_mpeg2)
546 /* every 200 packets. Need to look at the spec. */
547 s->system_header_freq = s->pack_header_freq * 40;
548 else if (s->is_vcd)
549 /* the standard mandates that there are only two system headers
550 * in the whole file: one in the first packet of each stream.
551 * (see standard p. IV-7 and IV-8) */
552 s->system_header_freq = 0x7fffffff;
553 else
554 s->system_header_freq = s->pack_header_freq * 5;
555
556 for (i = 0; i < ctx->nb_streams; i++) {
557 stream = ctx->streams[i]->priv_data;
558 stream->packet_number = 0;
559 }
560 s->system_header_size = get_system_header_size(ctx);
561 s->last_scr = AV_NOPTS_VALUE;
562 return 0;
563 }
564
put_timestamp(AVIOContext * pb,int id,int64_t timestamp)565 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
566 {
567 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
568 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
569 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
570 }
571
572 /* return the number of padding bytes that should be inserted into
573 * the multiplexed stream. */
get_vcd_padding_size(AVFormatContext * ctx,int64_t pts)574 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
575 {
576 MpegMuxContext *s = ctx->priv_data;
577 int pad_bytes = 0;
578
579 if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
580 int64_t full_pad_bytes;
581
582 // FIXME: this is wrong
583 full_pad_bytes =
584 av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
585 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
586
587 if (pad_bytes < 0)
588 /* might happen if we have already padded to a later timestamp. This
589 * can occur if another stream has already advanced further. */
590 pad_bytes = 0;
591 }
592
593 return pad_bytes;
594 }
595
596 /* Write an MPEG padding packet header. */
put_padding_packet(AVFormatContext * ctx,AVIOContext * pb,int packet_bytes)597 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
598 int packet_bytes)
599 {
600 MpegMuxContext *s = ctx->priv_data;
601 int i;
602
603 avio_wb32(pb, PADDING_STREAM);
604 avio_wb16(pb, packet_bytes - 6);
605 if (!s->is_mpeg2) {
606 avio_w8(pb, 0x0f);
607 packet_bytes -= 7;
608 } else
609 packet_bytes -= 6;
610
611 for (i = 0; i < packet_bytes; i++)
612 avio_w8(pb, 0xff);
613 }
614
get_nb_frames(AVFormatContext * ctx,StreamInfo * stream,int len)615 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
616 {
617 int nb_frames = 0;
618 PacketDesc *pkt_desc = stream->premux_packet;
619
620 while (len > 0) {
621 if (pkt_desc->size == pkt_desc->unwritten_size)
622 nb_frames++;
623 len -= pkt_desc->unwritten_size;
624 pkt_desc = pkt_desc->next;
625 }
626
627 return nb_frames;
628 }
629
630 /* flush the packet on stream stream_index */
flush_packet(AVFormatContext * ctx,int stream_index,int64_t pts,int64_t dts,int64_t scr,int trailer_size)631 static int flush_packet(AVFormatContext *ctx, int stream_index,
632 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
633 {
634 MpegMuxContext *s = ctx->priv_data;
635 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
636 uint8_t *buf_ptr;
637 int size, payload_size, startcode, id, stuffing_size, i, header_len;
638 int packet_size;
639 uint8_t buffer[128];
640 int zero_trail_bytes = 0;
641 int pad_packet_bytes = 0;
642 int pes_flags;
643 /* "general" pack without data specific to one stream? */
644 int general_pack = 0;
645 int nb_frames;
646
647 id = stream->id;
648
649 av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
650
651 buf_ptr = buffer;
652
653 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
654 /* output pack and systems header if needed */
655 size = put_pack_header(ctx, buf_ptr, scr);
656 buf_ptr += size;
657 s->last_scr = scr;
658
659 if (s->is_vcd) {
660 /* there is exactly one system header for each stream in a VCD MPEG,
661 * One in the very first video packet and one in the very first
662 * audio packet (see VCD standard p. IV-7 and IV-8). */
663
664 if (stream->packet_number == 0) {
665 size = put_system_header(ctx, buf_ptr, id);
666 buf_ptr += size;
667 }
668 } else if (s->is_dvd) {
669 if (stream->align_iframe || s->packet_number == 0) {
670 int PES_bytes_to_fill = s->packet_size - size - 10;
671
672 if (pts != AV_NOPTS_VALUE) {
673 if (dts != pts)
674 PES_bytes_to_fill -= 5 + 5;
675 else
676 PES_bytes_to_fill -= 5;
677 }
678
679 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
680 size = put_system_header(ctx, buf_ptr, 0);
681 buf_ptr += size;
682 size = buf_ptr - buffer;
683 avio_write(ctx->pb, buffer, size);
684
685 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
686 avio_wb16(ctx->pb, 0x03d4); // length
687 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
688 for (i = 0; i < 979; i++)
689 avio_w8(ctx->pb, 0x00);
690
691 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
692 avio_wb16(ctx->pb, 0x03fa); // length
693 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
694 for (i = 0; i < 1017; i++)
695 avio_w8(ctx->pb, 0x00);
696
697 memset(buffer, 0, 128);
698 buf_ptr = buffer;
699 s->packet_number++;
700 stream->align_iframe = 0;
701 // FIXME: rounding and first few bytes of each packet
702 scr += s->packet_size * 90000LL /
703 (s->mux_rate * 50LL);
704 size = put_pack_header(ctx, buf_ptr, scr);
705 s->last_scr = scr;
706 buf_ptr += size;
707 /* GOP Start */
708 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
709 pad_packet_bytes = PES_bytes_to_fill -
710 stream->bytes_to_iframe;
711 }
712 }
713 } else {
714 if ((s->packet_number % s->system_header_freq) == 0) {
715 size = put_system_header(ctx, buf_ptr, 0);
716 buf_ptr += size;
717 }
718 }
719 }
720 size = buf_ptr - buffer;
721 avio_write(ctx->pb, buffer, size);
722
723 packet_size = s->packet_size - size;
724
725 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
726 /* The VCD standard demands that 20 zero bytes follow
727 * each audio pack (see standard p. IV-8). */
728 zero_trail_bytes += 20;
729
730 if ((s->is_vcd && stream->packet_number == 0) ||
731 (s->is_svcd && s->packet_number == 0)) {
732 /* for VCD the first pack of each stream contains only the pack header,
733 * the system header and lots of padding (see VCD standard p. IV-6).
734 * In the case of an audio pack, 20 zero bytes are also added at
735 * the end. */
736 /* For SVCD we fill the very first pack to increase compatibility with
737 * some DVD players. Not mandated by the standard. */
738 if (s->is_svcd)
739 /* the system header refers to both streams and no stream data */
740 general_pack = 1;
741 pad_packet_bytes = packet_size - zero_trail_bytes;
742 }
743
744 packet_size -= pad_packet_bytes + zero_trail_bytes;
745
746 if (packet_size > 0) {
747 /* packet header size */
748 packet_size -= 6;
749
750 /* packet header */
751 if (s->is_mpeg2) {
752 header_len = 3;
753 if (stream->packet_number == 0)
754 header_len += 3; /* PES extension */
755 header_len += 1; /* obligatory stuffing byte */
756 } else {
757 header_len = 0;
758 }
759 if (pts != AV_NOPTS_VALUE) {
760 if (dts != pts)
761 header_len += 5 + 5;
762 else
763 header_len += 5;
764 } else {
765 if (!s->is_mpeg2)
766 header_len++;
767 }
768
769 payload_size = packet_size - header_len;
770 if (id < 0xc0) {
771 startcode = PRIVATE_STREAM_1;
772 payload_size -= 1;
773 if (id >= 0x40) {
774 payload_size -= 3;
775 if (id >= 0xa0)
776 payload_size -= 3;
777 }
778 } else {
779 startcode = 0x100 + id;
780 }
781
782 stuffing_size = payload_size - av_fifo_size(stream->fifo);
783
784 // first byte does not fit -> reset pts/dts + stuffing
785 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
786 int timestamp_len = 0;
787 if (dts != pts)
788 timestamp_len += 5;
789 if (pts != AV_NOPTS_VALUE)
790 timestamp_len += s->is_mpeg2 ? 5 : 4;
791 pts =
792 dts = AV_NOPTS_VALUE;
793 header_len -= timestamp_len;
794 if (s->is_dvd && stream->align_iframe) {
795 pad_packet_bytes += timestamp_len;
796 packet_size -= timestamp_len;
797 } else {
798 payload_size += timestamp_len;
799 }
800 stuffing_size += timestamp_len;
801 if (payload_size > trailer_size)
802 stuffing_size += payload_size - trailer_size;
803 }
804
805 // can't use padding, so use stuffing
806 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
807 packet_size += pad_packet_bytes;
808 payload_size += pad_packet_bytes; // undo the previous adjustment
809 if (stuffing_size < 0)
810 stuffing_size = pad_packet_bytes;
811 else
812 stuffing_size += pad_packet_bytes;
813 pad_packet_bytes = 0;
814 }
815
816 if (stuffing_size < 0)
817 stuffing_size = 0;
818
819 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
820 if (payload_size < av_fifo_size(stream->fifo))
821 stuffing_size += payload_size % stream->lpcm_align;
822 }
823
824 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
825 pad_packet_bytes += stuffing_size;
826 packet_size -= stuffing_size;
827 payload_size -= stuffing_size;
828 stuffing_size = 0;
829 }
830
831 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
832
833 avio_wb32(ctx->pb, startcode);
834
835 avio_wb16(ctx->pb, packet_size);
836
837 if (!s->is_mpeg2)
838 for (i = 0; i < stuffing_size; i++)
839 avio_w8(ctx->pb, 0xff);
840
841 if (s->is_mpeg2) {
842 avio_w8(ctx->pb, 0x80); /* mpeg2 id */
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
859 avio_w8(ctx->pb, pes_flags); /* flags */
860 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
861
862 if (pes_flags & 0x80) /* write pts */
863 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
864 if (pes_flags & 0x40) /* write dts */
865 put_timestamp(ctx->pb, 0x01, dts);
866
867 if (pes_flags & 0x01) { /* write pes extension */
868 avio_w8(ctx->pb, 0x10); /* flags */
869
870 /* P-STD buffer info */
871 if ((id & 0xe0) == AUDIO_ID)
872 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
873 else
874 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
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 avio_w8(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 avio_w8(ctx->pb, 0xff);
893
894 for (i = 0; i < stuffing_size; i++)
895 avio_w8(ctx->pb, 0xff);
896 }
897
898 if (startcode == PRIVATE_STREAM_1) {
899 avio_w8(ctx->pb, id);
900 if (id >= 0xa0) {
901 /* LPCM (XXX: check nb_frames) */
902 avio_w8(ctx->pb, 7);
903 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
904 avio_w8(ctx->pb, stream->lpcm_header[0]);
905 avio_w8(ctx->pb, stream->lpcm_header[1]);
906 avio_w8(ctx->pb, stream->lpcm_header[2]);
907 } else if (id >= 0x40) {
908 /* AC-3 */
909 avio_w8(ctx->pb, nb_frames);
910 avio_wb16(ctx->pb, trailer_size + 1);
911 }
912 }
913
914 /* output data */
915 av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
916 av_fifo_generic_read(stream->fifo, ctx->pb,
917 payload_size - stuffing_size,
918 (void (*)(void*, void*, int))avio_write);
919 stream->bytes_to_iframe -= payload_size - stuffing_size;
920 } else {
921 payload_size =
922 stuffing_size = 0;
923 }
924
925 if (pad_packet_bytes > 0)
926 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
927
928 for (i = 0; i < zero_trail_bytes; i++)
929 avio_w8(ctx->pb, 0x00);
930
931 avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
932
933 s->packet_number++;
934
935 /* only increase the stream packet number if this pack actually contains
936 * something that is specific to this stream! I.e. a dedicated header
937 * or some data. */
938 if (!general_pack)
939 stream->packet_number++;
940
941 return payload_size - stuffing_size;
942 }
943
put_vcd_padding_sector(AVFormatContext * ctx)944 static void put_vcd_padding_sector(AVFormatContext *ctx)
945 {
946 /* There are two ways to do this padding: writing a sector/pack
947 * of 0 values, or writing an MPEG padding pack. Both seem to
948 * work with most decoders, BUT the VCD standard only allows a 0-sector
949 * (see standard p. IV-4, IV-5).
950 * So a 0-sector it is... */
951
952 MpegMuxContext *s = ctx->priv_data;
953 int i;
954
955 for (i = 0; i < s->packet_size; i++)
956 avio_w8(ctx->pb, 0);
957
958 s->vcd_padding_bytes_written += s->packet_size;
959
960 avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
961
962 /* increasing the packet number is correct. The SCR of the following packs
963 * is calculated from the packet_number and it has to include the padding
964 * sector (it represents the sector index, not the MPEG pack index)
965 * (see VCD standard p. IV-6) */
966 s->packet_number++;
967 }
968
remove_decoded_packets(AVFormatContext * ctx,int64_t scr)969 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
970 {
971 int i;
972
973 for (i = 0; i < ctx->nb_streams; i++) {
974 AVStream *st = ctx->streams[i];
975 StreamInfo *stream = st->priv_data;
976 PacketDesc *pkt_desc;
977
978 while ((pkt_desc = stream->predecode_packet) &&
979 scr > pkt_desc->dts) { // FIXME: > vs >=
980 if (stream->buffer_index < pkt_desc->size ||
981 stream->predecode_packet == stream->premux_packet) {
982 av_log(ctx, AV_LOG_ERROR,
983 "buffer underflow st=%d bufi=%d size=%d\n",
984 i, stream->buffer_index, pkt_desc->size);
985 break;
986 }
987 stream->buffer_index -= pkt_desc->size;
988 stream->predecode_packet = pkt_desc->next;
989 if (!stream->predecode_packet)
990 stream->last_packet = NULL;
991 av_freep(&pkt_desc);
992 }
993 }
994
995 return 0;
996 }
997
output_packet(AVFormatContext * ctx,int flush)998 static int output_packet(AVFormatContext *ctx, int flush)
999 {
1000 MpegMuxContext *s = ctx->priv_data;
1001 AVStream *st;
1002 StreamInfo *stream;
1003 int i, avail_space = 0, es_size, trailer_size;
1004 int best_i = -1;
1005 int best_score = INT_MIN;
1006 int ignore_constraints = 0;
1007 int ignore_delay = 0;
1008 int64_t scr = s->last_scr;
1009 PacketDesc *timestamp_packet;
1010 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1011
1012 retry:
1013 for (i = 0; i < ctx->nb_streams; i++) {
1014 AVStream *st = ctx->streams[i];
1015 StreamInfo *stream = st->priv_data;
1016 const int avail_data = av_fifo_size(stream->fifo);
1017 const int space = stream->max_buffer_size - stream->buffer_index;
1018 int rel_space = 1024LL * space / stream->max_buffer_size;
1019 PacketDesc *next_pkt = stream->premux_packet;
1020
1021 /* for subtitle, a single PES packet must be generated,
1022 * so we flush after every single subtitle packet */
1023 if (s->packet_size > avail_data && !flush
1024 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
1025 return 0;
1026 if (avail_data == 0)
1027 continue;
1028 av_assert0(avail_data > 0);
1029
1030 if (space < s->packet_size && !ignore_constraints)
1031 continue;
1032
1033 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1034 continue;
1035 if ( stream->predecode_packet
1036 && stream->predecode_packet->size > stream->buffer_index)
1037 rel_space += 1<<28;
1038 if (rel_space > best_score) {
1039 best_score = rel_space;
1040 best_i = i;
1041 avail_space = space;
1042 }
1043 }
1044
1045 if (best_i < 0) {
1046 int64_t best_dts = INT64_MAX;
1047 int has_premux = 0;
1048
1049 for (i = 0; i < ctx->nb_streams; i++) {
1050 AVStream *st = ctx->streams[i];
1051 StreamInfo *stream = st->priv_data;
1052 PacketDesc *pkt_desc = stream->predecode_packet;
1053 if (pkt_desc && pkt_desc->dts < best_dts)
1054 best_dts = pkt_desc->dts;
1055 has_premux |= !!stream->premux_packet;
1056 }
1057
1058 if (best_dts < INT64_MAX) {
1059 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1060 scr / 90000.0, best_dts / 90000.0);
1061
1062 if (scr >= best_dts + 1 && !ignore_constraints) {
1063 av_log(ctx, AV_LOG_ERROR,
1064 "packet too large, ignoring buffer limits to mux it\n");
1065 ignore_constraints = 1;
1066 }
1067 scr = FFMAX(best_dts + 1, scr);
1068 if (remove_decoded_packets(ctx, scr) < 0)
1069 return -1;
1070 } else if (has_premux && flush) {
1071 av_log(ctx, AV_LOG_ERROR,
1072 "delay too large, ignoring ...\n");
1073 ignore_delay = 1;
1074 ignore_constraints = 1;
1075 } else
1076 return 0;
1077
1078 goto retry;
1079 }
1080
1081 av_assert0(best_i >= 0);
1082
1083 st = ctx->streams[best_i];
1084 stream = st->priv_data;
1085
1086 av_assert0(av_fifo_size(stream->fifo) > 0);
1087
1088 av_assert0(avail_space >= s->packet_size || ignore_constraints);
1089
1090 timestamp_packet = stream->premux_packet;
1091 if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1092 trailer_size = 0;
1093 } else {
1094 trailer_size = timestamp_packet->unwritten_size;
1095 timestamp_packet = timestamp_packet->next;
1096 }
1097
1098 if (timestamp_packet) {
1099 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1100 timestamp_packet->dts / 90000.0,
1101 timestamp_packet->pts / 90000.0,
1102 scr / 90000.0, best_i);
1103 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1104 timestamp_packet->dts, scr, trailer_size);
1105 } else {
1106 av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1107 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1108 trailer_size);
1109 }
1110
1111 if (s->is_vcd) {
1112 /* Write one or more padding sectors, if necessary, to reach
1113 * the constant overall bitrate. */
1114 int vcd_pad_bytes;
1115
1116 // FIXME: pts cannot be correct here
1117 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1118 put_vcd_padding_sector(ctx);
1119 // FIXME: rounding and first few bytes of each packet
1120 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1121 }
1122 }
1123
1124 stream->buffer_index += es_size;
1125 // FIXME: rounding and first few bytes of each packet
1126 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1127
1128 while (stream->premux_packet &&
1129 stream->premux_packet->unwritten_size <= es_size) {
1130 es_size -= stream->premux_packet->unwritten_size;
1131 stream->premux_packet = stream->premux_packet->next;
1132 }
1133 if (es_size) {
1134 av_assert0(stream->premux_packet);
1135 stream->premux_packet->unwritten_size -= es_size;
1136 }
1137
1138 if (remove_decoded_packets(ctx, s->last_scr) < 0)
1139 return -1;
1140
1141 return 1;
1142 }
1143
mpeg_mux_write_packet(AVFormatContext * ctx,AVPacket * pkt)1144 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1145 {
1146 int stream_index = pkt->stream_index;
1147 int size = pkt->size;
1148 uint8_t *buf = pkt->data;
1149 MpegMuxContext *s = ctx->priv_data;
1150 AVStream *st = ctx->streams[stream_index];
1151 StreamInfo *stream = st->priv_data;
1152 int64_t pts, dts;
1153 PacketDesc *pkt_desc;
1154 int preload, ret;
1155 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1156 (pkt->flags & AV_PKT_FLAG_KEY);
1157
1158 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1159
1160 pts = pkt->pts;
1161 dts = pkt->dts;
1162
1163 if (s->last_scr == AV_NOPTS_VALUE) {
1164 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1165 if (dts != AV_NOPTS_VALUE)
1166 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1167 s->last_scr = 0;
1168 } else {
1169 s->last_scr = dts - preload;
1170 s->preload = 0;
1171 }
1172 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1173 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1174 }
1175
1176 if (dts != AV_NOPTS_VALUE) dts += preload;
1177 if (pts != AV_NOPTS_VALUE) pts += preload;
1178
1179 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1180 dts / 90000.0, pts / 90000.0, pkt->flags,
1181 pkt->stream_index, pts != AV_NOPTS_VALUE);
1182
1183 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
1184 if (size < 3) {
1185 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
1186 return AVERROR(EINVAL);
1187 }
1188
1189 /* Skip first 3 bytes of packet data, which comprise PCM header
1190 and will be written fresh by this muxer. */
1191 buf += 3;
1192 size -= 3;
1193 }
1194
1195 pkt_desc = av_mallocz(sizeof(PacketDesc));
1196 if (!pkt_desc)
1197 return AVERROR(ENOMEM);
1198 if (!stream->predecode_packet) {
1199 stream->predecode_packet = pkt_desc;
1200 } else
1201 stream->last_packet->next = pkt_desc;
1202 stream->last_packet = pkt_desc;
1203 if (!stream->premux_packet)
1204 stream->premux_packet = pkt_desc;
1205 pkt_desc->pts = pts;
1206 pkt_desc->dts = dts;
1207 pkt_desc->unwritten_size =
1208 pkt_desc->size = size;
1209
1210 ret = av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size);
1211 if (ret < 0)
1212 return ret;
1213
1214 if (s->is_dvd) {
1215 // min VOBU length 0.4 seconds (mpucoder)
1216 if (is_iframe &&
1217 (s->packet_number == 0 || pts != AV_NOPTS_VALUE &&
1218 (pts - stream->vobu_start_pts >= 36000))) {
1219 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1220 stream->align_iframe = 1;
1221 stream->vobu_start_pts = pts;
1222 }
1223 }
1224
1225 av_fifo_generic_write(stream->fifo, buf, size, NULL);
1226
1227 for (;;) {
1228 int ret = output_packet(ctx, 0);
1229 if (ret <= 0)
1230 return ret;
1231 }
1232 }
1233
mpeg_mux_end(AVFormatContext * ctx)1234 static int mpeg_mux_end(AVFormatContext *ctx)
1235 {
1236 StreamInfo *stream;
1237 int i;
1238
1239 for (;;) {
1240 int ret = output_packet(ctx, 1);
1241 if (ret < 0)
1242 return ret;
1243 else if (ret == 0)
1244 break;
1245 }
1246
1247 /* End header according to MPEG-1 systems standard. We do not write
1248 * it as it is usually not needed by decoders and because it
1249 * complicates MPEG stream concatenation. */
1250 // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1251
1252 for (i = 0; i < ctx->nb_streams; i++) {
1253 stream = ctx->streams[i]->priv_data;
1254
1255 av_assert0(av_fifo_size(stream->fifo) == 0);
1256 }
1257 return 0;
1258 }
1259
mpeg_mux_deinit(AVFormatContext * ctx)1260 static void mpeg_mux_deinit(AVFormatContext *ctx)
1261 {
1262 for (int i = 0; i < ctx->nb_streams; i++) {
1263 StreamInfo *stream = ctx->streams[i]->priv_data;
1264 if (!stream)
1265 continue;
1266 for (PacketDesc *pkt = stream->predecode_packet; pkt; ) {
1267 PacketDesc *tmp = pkt->next;
1268 av_free(pkt);
1269 pkt = tmp;
1270 }
1271 av_fifo_freep(&stream->fifo);
1272 }
1273 }
1274
1275 #define OFFSET(x) offsetof(MpegMuxContext, x)
1276 #define E AV_OPT_FLAG_ENCODING_PARAM
1277 static const AVOption options[] = {
1278 { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1279 { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1280 { NULL },
1281 };
1282
1283 #define MPEGENC_CLASS(flavor) \
1284 static const AVClass flavor ## _class = { \
1285 .class_name = #flavor " muxer", \
1286 .item_name = av_default_item_name, \
1287 .version = LIBAVUTIL_VERSION_INT, \
1288 .option = options, \
1289 };
1290
1291 #if CONFIG_MPEG1SYSTEM_MUXER
1292 MPEGENC_CLASS(mpeg)
1293 AVOutputFormat ff_mpeg1system_muxer = {
1294 .name = "mpeg",
1295 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1296 .mime_type = "video/mpeg",
1297 .extensions = "mpg,mpeg",
1298 .priv_data_size = sizeof(MpegMuxContext),
1299 .audio_codec = AV_CODEC_ID_MP2,
1300 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1301 .write_header = mpeg_mux_init,
1302 .write_packet = mpeg_mux_write_packet,
1303 .write_trailer = mpeg_mux_end,
1304 .deinit = mpeg_mux_deinit,
1305 .priv_class = &mpeg_class,
1306 };
1307 #endif
1308
1309 #if CONFIG_MPEG1VCD_MUXER
1310 MPEGENC_CLASS(vcd)
1311 AVOutputFormat ff_mpeg1vcd_muxer = {
1312 .name = "vcd",
1313 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1314 .mime_type = "video/mpeg",
1315 .priv_data_size = sizeof(MpegMuxContext),
1316 .audio_codec = AV_CODEC_ID_MP2,
1317 .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1318 .write_header = mpeg_mux_init,
1319 .write_packet = mpeg_mux_write_packet,
1320 .write_trailer = mpeg_mux_end,
1321 .deinit = mpeg_mux_deinit,
1322 .priv_class = &vcd_class,
1323 };
1324 #endif
1325
1326 #if CONFIG_MPEG2VOB_MUXER
1327 MPEGENC_CLASS(vob)
1328 AVOutputFormat ff_mpeg2vob_muxer = {
1329 .name = "vob",
1330 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1331 .mime_type = "video/mpeg",
1332 .extensions = "vob",
1333 .priv_data_size = sizeof(MpegMuxContext),
1334 .audio_codec = AV_CODEC_ID_MP2,
1335 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1336 .write_header = mpeg_mux_init,
1337 .write_packet = mpeg_mux_write_packet,
1338 .write_trailer = mpeg_mux_end,
1339 .deinit = mpeg_mux_deinit,
1340 .priv_class = &vob_class,
1341 };
1342 #endif
1343
1344 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1345 #if CONFIG_MPEG2SVCD_MUXER
1346 MPEGENC_CLASS(svcd)
1347 AVOutputFormat ff_mpeg2svcd_muxer = {
1348 .name = "svcd",
1349 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1350 .mime_type = "video/mpeg",
1351 .extensions = "vob",
1352 .priv_data_size = sizeof(MpegMuxContext),
1353 .audio_codec = AV_CODEC_ID_MP2,
1354 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1355 .write_header = mpeg_mux_init,
1356 .write_packet = mpeg_mux_write_packet,
1357 .write_trailer = mpeg_mux_end,
1358 .deinit = mpeg_mux_deinit,
1359 .priv_class = &svcd_class,
1360 };
1361 #endif
1362
1363 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1364 #if CONFIG_MPEG2DVD_MUXER
1365 MPEGENC_CLASS(dvd)
1366 AVOutputFormat ff_mpeg2dvd_muxer = {
1367 .name = "dvd",
1368 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1369 .mime_type = "video/mpeg",
1370 .extensions = "dvd",
1371 .priv_data_size = sizeof(MpegMuxContext),
1372 .audio_codec = AV_CODEC_ID_MP2,
1373 .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1374 .write_header = mpeg_mux_init,
1375 .write_packet = mpeg_mux_write_packet,
1376 .write_trailer = mpeg_mux_end,
1377 .deinit = mpeg_mux_deinit,
1378 .priv_class = &dvd_class,
1379 };
1380 #endif
1381