FFmpeg coverage

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