FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/fftools/ffmpeg_opt.c
Date: 2026-09-24 20:08:24
Exec Total Coverage
Lines: 373 828 45.0%
Functions: 34 58 58.6%
Branches: 210 506 41.5%
Line Branch Exec Source
1 /*
2 * ffmpeg option parsing
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "config.h"
22
23 #include <stdint.h>
24
25 #if HAVE_SYS_RESOURCE_H
26 #include <sys/time.h>
27 #include <sys/resource.h>
28 #endif
29
30 #include "ffmpeg.h"
31 #include "ffmpeg_sched.h"
32 #include "cmdutils.h"
33 #include "opt_common.h"
34
35 #include "libavformat/avformat.h"
36
37 #include "libavcodec/avcodec.h"
38 #include "libavcodec/bsf.h"
39
40 #include "libavfilter/avfilter.h"
41
42 #include "libavutil/avassert.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/avutil.h"
45 #include "libavutil/mathematics.h"
46 #include "libavutil/mem.h"
47 #include "libavutil/opt.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/stereo3d.h"
50 #include "graph/graphprint.h"
51
52 HWDevice *filter_hw_device;
53
54 char *vstats_filename;
55
56 float dts_delta_threshold = 10;
57 float dts_error_threshold = 3600*30;
58
59 float frame_drop_threshold = 0;
60 int do_benchmark = 0;
61 int do_benchmark_all = 0;
62 int do_hex_dump = 0;
63 int do_pkt_dump = 0;
64 int copy_ts = 0;
65 int start_at_zero = 0;
66 int copy_tb = -1;
67 int debug_ts = 0;
68 int exit_on_error = 0;
69 int abort_on_flags = 0;
70 int print_stats = -1;
71 int stdin_interaction = 1;
72 float max_error_rate = 2.0/3;
73 char *filter_nbthreads;
74 int filter_complex_nbthreads = 0;
75 int filter_buffered_frames = 0;
76 int vstats_version = 2;
77 int print_graphs = 0;
78 char *print_graphs_file = NULL;
79 char *print_graphs_format = NULL;
80 int auto_conversion_filters = 1;
81 int64_t stats_period = 500000;
82
83
84 static int file_overwrite = 0;
85 static int no_file_overwrite = 0;
86 int ignore_unknown_streams = 0;
87 int copy_unknown_streams = 0;
88 int recast_media = 0;
89
90 // this struct is passed as the optctx argument
91 // to func_arg() for global options
92 typedef struct GlobalOptionsContext {
93 Scheduler *sch;
94
95 char **filtergraphs;
96 int nb_filtergraphs;
97 } GlobalOptionsContext;
98
99 16572 static void uninit_options(OptionsContext *o)
100 {
101 /* all OPT_SPEC and OPT_TYPE_STRING can be freed in generic way */
102
2/2
✓ Branch 0 taken 3248112 times.
✓ Branch 1 taken 16572 times.
 3264684 for (const OptionDef *po = options; po->name; po++) {
103 void *dst;
104
105
2/2
✓ Branch 0 taken 1657200 times.
✓ Branch 1 taken 1590912 times.
 3248112 if (!(po->flags & OPT_FLAG_OFFSET))
106 1657200 continue;
107
108 1590912 dst = (uint8_t*)o + po->u.off;
109
2/2
✓ Branch 0 taken 1143468 times.
✓ Branch 1 taken 447444 times.
 1590912 if (po->flags & OPT_FLAG_SPEC) {
110 1143468 SpecifierOptList *so = dst;
111
2/2
✓ Branch 0 taken 34241 times.
✓ Branch 1 taken 1143468 times.
 1177709 for (int i = 0; i < so->nb_opt; i++) {
112 34241 av_freep(&so->opt[i].specifier);
113
2/2
✓ Branch 0 taken 33914 times.
✓ Branch 1 taken 327 times.
 34241 if (po->flags & OPT_FLAG_PERSTREAM)
114 33914 stream_specifier_uninit(&so->opt[i].stream_spec);
115
2/2
✓ Branch 0 taken 28350 times.
✓ Branch 1 taken 5891 times.
 34241 if (po->type == OPT_TYPE_STRING)
116 28350 av_freep(&so->opt[i].u.str);
117 }
118 1143468 av_freep(&so->opt);
119 1143468 so->nb_opt = 0;
120
2/2
✓ Branch 0 taken 16572 times.
✓ Branch 1 taken 430872 times.
 447444 } else if (po->type == OPT_TYPE_STRING)
121 16572 av_freep(dst);
122 }
123
124
2/2
✓ Branch 0 taken 601 times.
✓ Branch 1 taken 16572 times.
 17173 for (int i = 0; i < o->nb_stream_maps; i++)
125 601 av_freep(&o->stream_maps[i].linklabel);
126 16572 av_freep(&o->stream_maps);
127
128
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16572 times.
 16573 for (int i = 0; i < o->nb_attachments; i++)
129 1 av_freep(&o->attachments[i]);
130 16572 av_freep(&o->attachments);
131
132 16572 av_dict_free(&o->streamid);
133 16572 }
134
135 16572 static void init_options(OptionsContext *o)
136 {
137 16572 memset(o, 0, sizeof(*o));
138
139 16572 o->stop_time = INT64_MAX;
140 16572 o->mux_max_delay = 0.7;
141 16572 o->start_time = AV_NOPTS_VALUE;
142 16572 o->start_time_eof = AV_NOPTS_VALUE;
143 16572 o->recording_time = INT64_MAX;
144 16572 o->limit_filesize = INT64_MAX;
145 16572 o->chapters_input_file = INT_MAX;
146 16572 o->accurate_seek = 1;
147 16572 o->thread_queue_size = 0;
148 16572 o->input_sync_ref = -1;
149 16572 o->find_stream_info = 1;
150 16572 o->shortest_buf_duration = 10.f;
151 16572 }
152
153 ✗ static int show_hwaccels(void *optctx, const char *opt, const char *arg)
154 {
155 ✗ enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
156
157 ✗ printf("Hardware acceleration methods:\n");
158 ✗ while ((type = av_hwdevice_iterate_types(type)) !=
159 AV_HWDEVICE_TYPE_NONE)
160 ✗ printf("%s\n", av_hwdevice_get_type_name(type));
161 ✗ printf("\n");
162 ✗ return 0;
163 }
164
165 39507 const char *opt_match_per_type_str(const SpecifierOptList *sol,
166 char mediatype)
167 {
168
3/4
✓ Branch 0 taken 17353 times.
✓ Branch 1 taken 22154 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 17353 times.
 39507 av_assert0(!sol->nb_opt || sol->type == OPT_TYPE_STRING);
169
170
2/2
✓ Branch 0 taken 17458 times.
✓ Branch 1 taken 36299 times.
 53757 for (int i = 0; i < sol->nb_opt; i++) {
171 17458 const char *spec = sol->opt[i].specifier;
172
3/4
✓ Branch 0 taken 3208 times.
✓ Branch 1 taken 14250 times.
✓ Branch 2 taken 3208 times.
✗ Branch 3 not taken.
 17458 if (spec[0] == mediatype && !spec[1])
173 3208 return sol->opt[i].u.str;
174 }
175 36299 return NULL;
176 }
177
178 457843 static unsigned opt_match_per_stream(void *logctx, enum OptionType type,
179 const SpecifierOptList *sol,
180 AVFormatContext *fc, AVStream *st)
181 {
182 457843 int matches = 0, match_idx = -1;
183
184
3/4
✓ Branch 0 taken 425161 times.
✓ Branch 1 taken 32682 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 425161 times.
 457843 av_assert0((type == sol->type) || !sol->nb_opt);
185
186
2/2
✓ Branch 0 taken 35416 times.
✓ Branch 1 taken 457843 times.
 493259 for (int i = 0; i < sol->nb_opt; i++) {
187 35416 const StreamSpecifier *ss = &sol->opt[i].stream_spec;
188
189
2/2
✓ Branch 1 taken 34917 times.
✓ Branch 2 taken 499 times.
 35416 if (stream_specifier_match(ss, fc, st, logctx)) {
190 34917 match_idx = i;
191 34917 matches++;
192 }
193 }
194
195
3/4
✓ Branch 0 taken 2398 times.
✓ Branch 1 taken 455445 times.
✓ Branch 2 taken 2398 times.
✗ Branch 3 not taken.
 457843 if (matches > 1 && sol->opt_canon) {
196 2398 const SpecifierOpt *so = &sol->opt[match_idx];
197
3/4
✓ Branch 0 taken 2398 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2396 times.
✓ Branch 3 taken 2 times.
 2398 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";
198
199 2398 char namestr[128] = "";
200 char optval_buf[32];
201 2398 const char *optval = optval_buf;
202
203 2398 snprintf(namestr, sizeof(namestr), "-%s", sol->opt_canon->name);
204
1/2
✓ Branch 0 taken 2398 times.
✗ Branch 1 not taken.
 2398 if (sol->opt_canon->flags & OPT_HAS_ALT) {
205 2398 const char * const *names_alt = sol->opt_canon->u1.names_alt;
206
2/2
✓ Branch 0 taken 7318 times.
✓ Branch 1 taken 2398 times.
 9716 for (int i = 0; names_alt[i]; i++)
207 7318 av_strlcatf(namestr, sizeof(namestr), "/-%s", names_alt[i]);
208 }
209
210
3/6
✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2334 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 2398 switch (sol->type) {
211 63 case OPT_TYPE_STRING: optval = so->u.str; break;
212 ✗ case OPT_TYPE_INT: snprintf(optval_buf, sizeof(optval_buf), "%d", so->u.i); break;
213 2334 case OPT_TYPE_INT64: snprintf(optval_buf, sizeof(optval_buf), "%"PRId64, so->u.i64); break;
214 ✗ case OPT_TYPE_FLOAT: snprintf(optval_buf, sizeof(optval_buf), "%f", so->u.f); break;
215 1 case OPT_TYPE_DOUBLE: snprintf(optval_buf, sizeof(optval_buf), "%f", so->u.dbl); break;
216 ✗ default: av_assert0(0);
217 }
218
219 2398 av_log(logctx, AV_LOG_WARNING, "Multiple %s options specified for "
220 "stream %d, only the last option '-%s%s%s %s' will be used.\n",
221
2/2
✓ Branch 0 taken 2396 times.
✓ Branch 1 taken 2 times.
 4796 namestr, st->index, sol->opt_canon->name, spec[0] ? ":" : "",
222 spec, optval);
223 }
224
225 457843 return match_idx + 1;
226 }
227
228 #define OPT_MATCH_PER_STREAM(name, type, opt_type, m) \
229 void opt_match_per_stream_ ## name(void *logctx, const SpecifierOptList *sol, \
230 AVFormatContext *fc, AVStream *st, type *out) \
231 { \
232 unsigned ret = opt_match_per_stream(logctx, opt_type, sol, fc, st); \
233 if (ret > 0) \
234 *out = sol->opt[ret - 1].u.m; \
235 }
236
237
2/2
✓ Branch 1 taken 29013 times.
✓ Branch 2 taken 274009 times.
 303022 OPT_MATCH_PER_STREAM(str, const char *, OPT_TYPE_STRING, str)
238
2/2
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 121319 times.
 121379 OPT_MATCH_PER_STREAM(int, int, OPT_TYPE_INT, i)
239
2/2
✓ Branch 1 taken 3168 times.
✓ Branch 2 taken 6220 times.
 9388 OPT_MATCH_PER_STREAM(int64, int64_t, OPT_TYPE_INT64, i64)
240
2/2
✓ Branch 1 taken 278 times.
✓ Branch 2 taken 23776 times.
 24054 OPT_MATCH_PER_STREAM(dbl, double, OPT_TYPE_DOUBLE, dbl)
241
242 12 static unsigned opt_match_per_stream_group(void *logctx, enum OptionType type,
243 const SpecifierOptList *sol,
244 AVFormatContext *fc, AVStreamGroup *stg)
245 {
246 12 int matches = 0, match_idx = -1;
247
248
2/4
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
 12 av_assert0((type == sol->type) || !sol->nb_opt);
249
250
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 for (int i = 0; i < sol->nb_opt; i++) {
251 ✗ const StreamSpecifier *ss = &sol->opt[i].stream_spec;
252
253 ✗ if (stream_group_specifier_match(ss, fc, stg, logctx)) {
254 ✗ match_idx = i;
255 ✗ matches++;
256 }
257 }
258
259
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 12 if (matches > 1 && sol->opt_canon) {
260 ✗ const SpecifierOpt *so = &sol->opt[match_idx];
261 ✗ const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";
262
263 ✗ char namestr[128] = "";
264 char optval_buf[32];
265 ✗ const char *optval = optval_buf;
266
267 ✗ snprintf(namestr, sizeof(namestr), "-%s", sol->opt_canon->name);
268 ✗ if (sol->opt_canon->flags & OPT_HAS_ALT) {
269 ✗ const char * const *names_alt = sol->opt_canon->u1.names_alt;
270 ✗ for (int i = 0; names_alt[i]; i++)
271 ✗ av_strlcatf(namestr, sizeof(namestr), "/-%s", names_alt[i]);
272 }
273
274 ✗ switch (sol->type) {
275 ✗ case OPT_TYPE_STRING: optval = so->u.str; break;
276 ✗ case OPT_TYPE_INT: snprintf(optval_buf, sizeof(optval_buf), "%d", so->u.i); break;
277 ✗ case OPT_TYPE_INT64: snprintf(optval_buf, sizeof(optval_buf), "%"PRId64, so->u.i64); break;
278 ✗ case OPT_TYPE_FLOAT: snprintf(optval_buf, sizeof(optval_buf), "%f", so->u.f); break;
279 ✗ case OPT_TYPE_DOUBLE: snprintf(optval_buf, sizeof(optval_buf), "%f", so->u.dbl); break;
280 ✗ default: av_assert0(0);
281 }
282
283 ✗ av_log(logctx, AV_LOG_WARNING, "Multiple %s options specified for "
284 "stream group %d, only the last option '-%s%s%s %s' will be used.\n",
285 ✗ namestr, stg->index, sol->opt_canon->name, spec[0] ? ":" : "",
286 spec, optval);
287 }
288
289 12 return match_idx + 1;
290 }
291
292 #define OPT_MATCH_PER_STREAM_GROUP(name, type, opt_type, m) \
293 void opt_match_per_stream_group_ ## name(void *logctx, const SpecifierOptList *sol, \
294 AVFormatContext *fc, AVStreamGroup *stg, type *out) \
295 { \
296 unsigned ret = opt_match_per_stream_group(logctx, opt_type, sol, fc, stg); \
297 if (ret > 0) \
298 *out = sol->opt[ret - 1].u.m; \
299 }
300
301
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 OPT_MATCH_PER_STREAM_GROUP(str, const char *, OPT_TYPE_STRING, str)
302
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 OPT_MATCH_PER_STREAM_GROUP(int, int, OPT_TYPE_INT, i)
303 ✗ OPT_MATCH_PER_STREAM_GROUP(int64, int64_t, OPT_TYPE_INT64, i64)
304 ✗ OPT_MATCH_PER_STREAM_GROUP(dbl, double, OPT_TYPE_DOUBLE, dbl)
305
306 462 int view_specifier_parse(const char **pspec, ViewSpecifier *vs)
307 {
308 462 const char *spec = *pspec;
309 char *endptr;
310
311 462 vs->type = VIEW_SPECIFIER_TYPE_NONE;
312
313
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 453 times.
 462 if (!strncmp(spec, "view:", 5)) {
314 9 spec += 5;
315
316
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 8 times.
 9 if (!strncmp(spec, "all", 3)) {
317 1 spec += 3;
318 1 vs->type = VIEW_SPECIFIER_TYPE_ALL;
319 } else {
320 8 vs->type = VIEW_SPECIFIER_TYPE_ID;
321 8 vs->val = strtoul(spec, &endptr, 0);
322
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (endptr == spec) {
323 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid view ID: %s\n", spec);
324 ✗ return AVERROR(EINVAL);
325 }
326 8 spec = endptr;
327 }
328
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 450 times.
 453 } else if (!strncmp(spec, "vidx:", 5)) {
329 3 spec += 5;
330 3 vs->type = VIEW_SPECIFIER_TYPE_IDX;
331 3 vs->val = strtoul(spec, &endptr, 0);
332
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (endptr == spec) {
333 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid view index: %s\n", spec);
334 ✗ return AVERROR(EINVAL);
335 }
336 3 spec = endptr;
337
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 448 times.
 450 } else if (!strncmp(spec, "vpos:", 5)) {
338 2 spec += 5;
339 2 vs->type = VIEW_SPECIFIER_TYPE_POS;
340
341
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 2 if (!strncmp(spec, "left", 4) && !cmdutils_isalnum(spec[4])) {
342 1 spec += 4;
343 1 vs->val = AV_STEREO3D_VIEW_LEFT;
344
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 1 } else if (!strncmp(spec, "right", 5) && !cmdutils_isalnum(spec[5])) {
345 1 spec += 5;
346 1 vs->val = AV_STEREO3D_VIEW_RIGHT;
347 } else {
348 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid view position: %s\n", spec);
349 ✗ return AVERROR(EINVAL);
350 }
351 } else
352 448 return 0;
353
354 14 *pspec = spec;
355
356 14 return 0;
357 }
358
359 536 int parse_and_set_vsync(const char *arg, enum VideoSyncMethod *vsync_var, int file_idx, int st_idx)
360 {
361
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 530 times.
 536 if (!av_strcasecmp(arg, "cfr")) *vsync_var = VSYNC_CFR;
362
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 527 times.
 530 else if (!av_strcasecmp(arg, "vfr")) *vsync_var = VSYNC_VFR;
363
1/2
✓ Branch 1 taken 527 times.
✗ Branch 2 not taken.
 527 else if (!av_strcasecmp(arg, "passthrough")) *vsync_var = VSYNC_PASSTHROUGH;
364 ✗ else if (!av_strcasecmp(arg, "auto")) *vsync_var = VSYNC_AUTO;
365 else {
366 ✗ av_log(NULL, AV_LOG_FATAL, "Invalid value %s specified for fps_mode of #%d:%d.\n", arg, file_idx, st_idx);
367 ✗ return AVERROR(EINVAL);
368 }
369
370 536 return 0;
371 }
372
373 /* Correct input file start times based on enabled streams */
374 8826 static void correct_input_start_times(void)
375 {
376
2/2
✓ Branch 0 taken 7729 times.
✓ Branch 1 taken 8826 times.
 16555 for (int i = 0; i < nb_input_files; i++) {
377 7729 InputFile *ifile = input_files[i];
378 7729 AVFormatContext *is = ifile->ctx;
379 7729 int64_t new_start_time = INT64_MAX, diff, abs_start_seek;
380
381 7729 ifile->start_time_effective = is->start_time;
382
383
2/2
✓ Branch 0 taken 5908 times.
✓ Branch 1 taken 1821 times.
 7729 if (is->start_time == AV_NOPTS_VALUE ||
384
2/2
✓ Branch 0 taken 5777 times.
✓ Branch 1 taken 131 times.
 5908 !(is->iformat->flags & AVFMT_TS_DISCONT))
385 7598 continue;
386
387
2/2
✓ Branch 0 taken 193 times.
✓ Branch 1 taken 131 times.
 324 for (int j = 0; j < is->nb_streams; j++) {
388 193 AVStream *st = is->streams[j];
389
3/4
✓ Branch 0 taken 146 times.
✓ Branch 1 taken 47 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 146 times.
 193 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
390 47 continue;
391
2/2
✓ Branch 0 taken 143 times.
✓ Branch 1 taken 3 times.
 146 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
392 }
393
394 131 diff = new_start_time - is->start_time;
395
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 127 times.
 131 if (diff) {
396 4 av_log(NULL, AV_LOG_VERBOSE, "Correcting start time of Input #%d by %"PRId64" us.\n", i, diff);
397 4 ifile->start_time_effective = new_start_time;
398
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 4 if (copy_ts && start_at_zero)
399 ✗ ifile->ts_offset = -new_start_time;
400
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 else if (!copy_ts) {
401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 abs_start_seek = is->start_time + ((ifile->start_time != AV_NOPTS_VALUE) ? ifile->start_time : 0);
402
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 ifile->ts_offset = abs_start_seek > new_start_time ? -abs_start_seek : -new_start_time;
403 ✗ } else if (copy_ts)
404 ✗ ifile->ts_offset = 0;
405
406 4 ifile->ts_offset += ifile->input_ts_offset;
407 }
408 }
409 8826 }
410
411 8826 static int apply_sync_offsets(void)
412 {
413
2/2
✓ Branch 0 taken 7729 times.
✓ Branch 1 taken 8826 times.
 16555 for (int i = 0; i < nb_input_files; i++) {
414 7729 InputFile *ref, *self = input_files[i];
415 int64_t adjustment;
416 int64_t self_start_time, ref_start_time, self_seek_start, ref_seek_start;
417 7729 int start_times_set = 1;
418
419
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 7729 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 7729 if (self->input_sync_ref == -1 || self->input_sync_ref == i) continue;
420 ✗ if (self->input_sync_ref >= nb_input_files || self->input_sync_ref < -1) {
421 ✗ av_log(NULL, AV_LOG_FATAL, "-isync for input %d references non-existent input %d.\n", i, self->input_sync_ref);
422 ✗ return AVERROR(EINVAL);
423 }
424
425 ✗ if (copy_ts && !start_at_zero) {
426 ✗ av_log(NULL, AV_LOG_FATAL, "Use of -isync requires that start_at_zero be set if copyts is set.\n");
427 ✗ return AVERROR(EINVAL);
428 }
429
430 ✗ ref = input_files[self->input_sync_ref];
431 ✗ if (ref->input_sync_ref != -1 && ref->input_sync_ref != self->input_sync_ref) {
432 ✗ av_log(NULL, AV_LOG_ERROR, "-isync for input %d references a resynced input %d. Sync not set.\n", i, self->input_sync_ref);
433 ✗ continue;
434 }
435
436 ✗ if (self->ctx->start_time_realtime != AV_NOPTS_VALUE && ref->ctx->start_time_realtime != AV_NOPTS_VALUE) {
437 ✗ self_start_time = self->ctx->start_time_realtime;
438 ✗ ref_start_time = ref->ctx->start_time_realtime;
439 ✗ } else if (self->start_time_effective != AV_NOPTS_VALUE && ref->start_time_effective != AV_NOPTS_VALUE) {
440 ✗ self_start_time = self->start_time_effective;
441 ✗ ref_start_time = ref->start_time_effective;
442 } else {
443 ✗ start_times_set = 0;
444 }
445
446 ✗ if (start_times_set) {
447 ✗ self_seek_start = self->start_time == AV_NOPTS_VALUE ? 0 : self->start_time;
448 ✗ ref_seek_start = ref->start_time == AV_NOPTS_VALUE ? 0 : ref->start_time;
449
450 ✗ adjustment = (self_start_time - ref_start_time) + !copy_ts*(self_seek_start - ref_seek_start) + ref->input_ts_offset;
451
452 ✗ self->ts_offset += adjustment;
453
454 ✗ av_log(NULL, AV_LOG_INFO, "Adjusted ts offset for Input #%d by %"PRId64" us to sync with Input #%d.\n", i, adjustment, self->input_sync_ref);
455 } else {
456 ✗ av_log(NULL, AV_LOG_INFO, "Unable to identify start times for Inputs #%d and %d both. No sync adjustment made.\n", i, self->input_sync_ref);
457 }
458 }
459
460 8826 return 0;
461 }
462
463 1467 static int opt_filter_threads(void *optctx, const char *opt, const char *arg)
464 {
465 1467 av_free(filter_nbthreads);
466 1467 filter_nbthreads = av_strdup(arg);
467 1467 return 0;
468 }
469
470 ✗ static int opt_abort_on(void *optctx, const char *opt, const char *arg)
471 {
472 static const AVOption opts[] = {
473 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, (double)INT64_MAX, .unit = "flags" },
474 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
475 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
476 { NULL },
477 };
478 static const AVClass class = {
479 .class_name = "",
480 .item_name = av_default_item_name,
481 .option = opts,
482 .version = LIBAVUTIL_VERSION_INT,
483 };
484 ✗ const AVClass *pclass = &class;
485
486 ✗ return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
487 }
488
489 ✗ static int opt_stats_period(void *optctx, const char *opt, const char *arg)
490 {
491 int64_t user_stats_period;
492 ✗ int ret = av_parse_time(&user_stats_period, arg, 1);
493 ✗ if (ret < 0)
494 ✗ return ret;
495
496 ✗ if (user_stats_period <= 0) {
497 ✗ av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg);
498 ✗ return AVERROR(EINVAL);
499 }
500
501 ✗ stats_period = user_stats_period;
502 ✗ av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg);
503
504 ✗ return 0;
505 }
506
507 20 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
508 {
509 20 OptionsContext *o = optctx;
510 20 return parse_option(o, "codec:a", arg, options);
511 }
512
513 5538 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
514 {
515 5538 OptionsContext *o = optctx;
516 5538 return parse_option(o, "codec:v", arg, options);
517 }
518
519 2 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
520 {
521 2 OptionsContext *o = optctx;
522 2 return parse_option(o, "codec:s", arg, options);
523 }
524
525 ✗ static int opt_data_codec(void *optctx, const char *opt, const char *arg)
526 {
527 ✗ OptionsContext *o = optctx;
528 ✗ return parse_option(o, "codec:d", arg, options);
529 }
530
531 389 static int opt_map(void *optctx, const char *opt, const char *arg)
532 {
533 389 OptionsContext *o = optctx;
534 389 StreamMap *m = NULL;
535 StreamSpecifier ss;
536 389 int i, negative = 0, file_idx, disabled = 0;
537 389 int ret, allow_unused = 0;
538
539 389 memset(&ss, 0, sizeof(ss));
540
541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 389 times.
 389 if (*arg == '-') {
542 ✗ negative = 1;
543 ✗ arg++;
544 }
545
546
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 305 times.
 389 if (arg[0] == '[') {
547 ViewSpecifier vs;
548 /* this mapping refers to lavfi output */
549 84 const char *c = arg + 1;
550 char *endptr;
551
552 84 ret = GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
553
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84 times.
 84 if (ret < 0)
554 ✗ goto fail;
555
556 84 m = &o->stream_maps[o->nb_stream_maps - 1];
557 84 m->linklabel = av_get_token(&c, "]");
558
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84 times.
 84 if (!m->linklabel) {
559 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", arg);
560 ✗ ret = AVERROR(EINVAL);
561 ✗ goto fail;
562 }
563
564 84 arg++;
565
566 84 m->group_index = -1;
567 84 file_idx = strtol(arg, &endptr, 0);
568
3/4
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 80 times.
 84 if (file_idx >= nb_input_files || file_idx < 0)
569 82 goto end;
570
571 80 arg = endptr;
572
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 79 times.
 80 ret = stream_specifier_parse(&ss, *arg == ':' ? arg + 1 : arg, 1, NULL);
573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
 80 if (ret < 0)
574 ✗ goto end;
575
576
1/2
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
 80 arg = ss.remainder ? ss.remainder : "";
577 80 ret = view_specifier_parse(&arg, &vs);
578
4/6
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 80 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 78 times.
✓ Branch 5 taken 2 times.
 80 if (ret < 0 || (*arg && strcmp(arg, "]")))
579 78 goto end;
580
581 2 m->file_index = file_idx;
582 2 m->stream_index = ss.idx;
583
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 m->group_index = ss.stream_list == STREAM_LIST_GROUP_IDX ? ss.list_id : -1;
584 } else {
585 ViewSpecifier vs;
586 char *endptr;
587
588 305 file_idx = strtol(arg, &endptr, 0);
589
2/4
✓ Branch 0 taken 305 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 305 times.
 305 if (file_idx >= nb_input_files || file_idx < 0) {
590 ✗ av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
591 ✗ ret = AVERROR(EINVAL);
592 ✗ goto fail;
593 }
594 305 arg = endptr;
595
596
2/2
✓ Branch 0 taken 169 times.
✓ Branch 1 taken 136 times.
 305 ret = stream_specifier_parse(&ss, *arg == ':' ? arg + 1 : arg, 1, NULL);
597
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 305 times.
 305 if (ret < 0) {
598 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid stream specifier: %s\n", arg);
599 ✗ goto fail;
600 }
601
602
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 291 times.
 305 arg = ss.remainder ? ss.remainder : "";
603
604 305 ret = view_specifier_parse(&arg, &vs);
605
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 305 times.
 305 if (ret < 0)
606 ✗ goto fail;
607
608
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 305 times.
 305 if (*arg) {
609 ✗ if (!strcmp(arg, "?"))
610 ✗ allow_unused = 1;
611 else {
612 ✗ av_log(NULL, AV_LOG_ERROR,
613 "Trailing garbage after stream specifier: %s\n", arg);
614 ✗ ret = AVERROR(EINVAL);
615 ✗ goto fail;
616 }
617 }
618
619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 305 times.
 305 if (negative)
620 /* disable some already defined maps */
621 ✗ for (i = 0; i < o->nb_stream_maps; i++) {
622 ✗ m = &o->stream_maps[i];
623 ✗ if (file_idx == m->file_index &&
624 ✗ !m->linklabel &&
625 ✗ m->stream_index >= 0 &&
626 ✗ m->stream_index < input_files[m->file_index]->nb_streams &&
627 ✗ stream_specifier_match(&ss,
628 ✗ input_files[m->file_index]->ctx,
629 ✗ input_files[m->file_index]->ctx->streams[m->stream_index],
630 NULL))
631 ✗ m->disabled = 1;
632 }
633 else
634
2/2
✓ Branch 0 taken 694 times.
✓ Branch 1 taken 305 times.
 999 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
635
2/2
✓ Branch 0 taken 177 times.
✓ Branch 1 taken 517 times.
 694 if (!stream_specifier_match(&ss,
636 694 input_files[file_idx]->ctx,
637 694 input_files[file_idx]->ctx->streams[i],
638 NULL))
639 177 continue;
640
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 517 times.
 517 if (input_files[file_idx]->streams[i]->user_set_discard == AVDISCARD_ALL) {
641 ✗ disabled = 1;
642 ✗ continue;
643 }
644 517 ret = GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
645
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 517 times.
 517 if (ret < 0)
646 ✗ goto fail;
647
648 517 m = &o->stream_maps[o->nb_stream_maps - 1];
649
650 517 m->file_index = file_idx;
651 517 m->stream_index = i;
652
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 508 times.
 517 m->group_index = ss.stream_list == STREAM_LIST_GROUP_IDX ? ss.list_id : -1;
653 517 m->vs = vs;
654 }
655 }
656
657
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 307 times.
 307 if (!m) {
658 ✗ if (allow_unused) {
659 ✗ av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
660 ✗ } else if (disabled) {
661 ✗ av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
662 "To ignore this, add a trailing '?' to the map.\n", arg);
663 ✗ ret = AVERROR(EINVAL);
664 ✗ goto fail;
665 } else {
666 ✗ av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
667 "To ignore this, add a trailing '?' to the map.\n", arg);
668 ✗ ret = AVERROR(EINVAL);
669 ✗ goto fail;
670 }
671 }
672 307 end:
673 389 ret = 0;
674 389 fail:
675 389 stream_specifier_uninit(&ss);
676 389 return ret;
677 }
678
679 1 static int opt_attach(void *optctx, const char *opt, const char *arg)
680 {
681 1 OptionsContext *o = optctx;
682 1 int ret = GROW_ARRAY(o->attachments, o->nb_attachments);
683
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
684 ✗ return ret;
685
686 1 o->attachments[o->nb_attachments - 1] = av_strdup(arg);
687
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!o->attachments[o->nb_attachments - 1])
688 ✗ return AVERROR(ENOMEM);
689
690 1 return 0;
691 }
692
693 ✗ static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
694 {
695 ✗ GlobalOptionsContext *go = optctx;
696 ✗ return sch_sdp_filename(go->sch, arg);
697 }
698
699 #if CONFIG_VAAPI
700 ✗ static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
701 {
702 ✗ const char *prefix = "vaapi:";
703 char *tmp;
704 int err;
705 ✗ tmp = av_asprintf("%s%s", prefix, arg);
706 ✗ if (!tmp)
707 ✗ return AVERROR(ENOMEM);
708 ✗ err = hw_device_init_from_string(tmp, NULL);
709 ✗ av_free(tmp);
710 ✗ return err;
711 }
712 #endif
713
714 #if CONFIG_QSV
715 static int opt_qsv_device(void *optctx, const char *opt, const char *arg)
716 {
717 const char *prefix = "qsv=__qsv_device:hw_any,child_device=";
718 int err;
719 char *tmp = av_asprintf("%s%s", prefix, arg);
720
721 if (!tmp)
722 return AVERROR(ENOMEM);
723
724 err = hw_device_init_from_string(tmp, NULL);
725 av_free(tmp);
726
727 return err;
728 }
729 #endif
730
731 ✗ static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
732 {
733 ✗ if (!strcmp(arg, "list")) {
734 ✗ enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
735 ✗ printf("Supported hardware device types:\n");
736 ✗ while ((type = av_hwdevice_iterate_types(type)) !=
737 AV_HWDEVICE_TYPE_NONE)
738 ✗ printf("%s\n", av_hwdevice_get_type_name(type));
739 ✗ printf("\n");
740 ✗ return AVERROR_EXIT;
741 } else {
742 ✗ return hw_device_init_from_string(arg, NULL);
743 }
744 }
745
746 ✗ static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
747 {
748 ✗ if (filter_hw_device) {
749 ✗ av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
750 ✗ return AVERROR(EINVAL);
751 }
752 ✗ filter_hw_device = hw_device_get_by_name(arg);
753 ✗ if (!filter_hw_device) {
754 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
755 ✗ return AVERROR(EINVAL);
756 }
757 ✗ return 0;
758 }
759
760 ✗ static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
761 {
762 ✗ OptionsContext *o = optctx;
763 char buf[128];
764 int64_t recording_timestamp;
765 int ret;
766 struct tm time;
767
768 ✗ ret = av_parse_time(&recording_timestamp, arg, 0);
769 ✗ if (ret < 0)
770 ✗ return ret;
771
772 ✗ recording_timestamp /= 1e6;
773 ✗ time = *gmtime((time_t*)&recording_timestamp);
774 ✗ if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
775 ✗ return -1;
776 ✗ parse_option(o, "metadata", buf, options);
777
778 ✗ av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
779 "tag instead.\n", opt);
780 ✗ return 0;
781 }
782
783 13778 int find_codec(void *logctx, const char *name,
784 enum AVMediaType type, int encoder, const AVCodec **pcodec)
785 {
786 const AVCodecDescriptor *desc;
787
2/2
✓ Branch 0 taken 4171 times.
✓ Branch 1 taken 9607 times.
 13778 const char *codec_string = encoder ? "encoder" : "decoder";
788 const AVCodec *codec;
789
790 13778 codec = encoder ?
791
2/2
✓ Branch 0 taken 4171 times.
✓ Branch 1 taken 9607 times.
 13778 avcodec_find_encoder_by_name(name) :
792 9607 avcodec_find_decoder_by_name(name);
793
794
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 13777 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 13778 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
795
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 codec = encoder ? avcodec_find_encoder(desc->id) :
796 ✗ avcodec_find_decoder(desc->id);
797
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (codec)
798 1 av_log(logctx, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
799 1 codec_string, codec->name, desc->name);
800 }
801
802
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13778 times.
 13778 if (!codec) {
803 ✗ av_log(logctx, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
804 ✗ return encoder ? AVERROR_ENCODER_NOT_FOUND :
805 AVERROR_DECODER_NOT_FOUND;
806 }
807
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 13778 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 13778 if (codec->type != type && !recast_media) {
808 ✗ av_log(logctx, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
809 ✗ return AVERROR(EINVAL);
810 }
811
812 13778 *pcodec = codec;
813 13778 return 0;;
814 }
815
816 8705 int assert_file_overwrite(const char *filename)
817 {
818 8705 const char *proto_name = avio_find_protocol_name(filename);
819
820
3/4
✓ Branch 0 taken 3182 times.
✓ Branch 1 taken 5523 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3182 times.
 8705 if (file_overwrite && no_file_overwrite) {
821 ✗ fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
822 ✗ return AVERROR(EINVAL);
823 }
824
825
2/2
✓ Branch 0 taken 5523 times.
✓ Branch 1 taken 3182 times.
 8705 if (!file_overwrite) {
826
4/6
✓ Branch 0 taken 5523 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 5522 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
 5523 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
827
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1 if (stdin_interaction && !no_file_overwrite) {
828 ✗ fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
829 ✗ fflush(stderr);
830 ✗ term_exit();
831 ✗ signal(SIGINT, SIG_DFL);
832 ✗ if (!read_yesno()) {
833 ✗ av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
834 ✗ return AVERROR(EEXIST);
835 }
836 ✗ term_init();
837 }
838 else {
839 1 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
840 1 return AVERROR(EEXIST);
841 }
842 }
843 }
844
845
3/4
✓ Branch 0 taken 8704 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3030 times.
✓ Branch 3 taken 5674 times.
 8704 if (proto_name && !strcmp(proto_name, "file")) {
846
2/2
✓ Branch 0 taken 1976 times.
✓ Branch 1 taken 3030 times.
 5006 for (int i = 0; i < nb_input_files; i++) {
847 1976 InputFile *file = input_files[i];
848
2/2
✓ Branch 0 taken 108 times.
✓ Branch 1 taken 1868 times.
 1976 if (file->ctx->iformat->flags & AVFMT_NOFILE)
849 108 continue;
850
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1868 times.
 1868 if (!strcmp(filename, file->ctx->url)) {
851 ✗ av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
852 ✗ av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
853 ✗ return AVERROR(EINVAL);
854 }
855 }
856 }
857
858 8704 return 0;
859 }
860
861 /* arg format is "output-stream-index:streamid-value". */
862 83 static int opt_streamid(void *optctx, const char *opt, const char *arg)
863 {
864 83 OptionsContext *o = optctx;
865 char *p;
866 char idx_str[16];
867
868 83 av_strlcpy(idx_str, arg, sizeof(idx_str));
869 83 p = strchr(idx_str, ':');
870
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 83 times.
 83 if (!p) {
871 ✗ av_log(NULL, AV_LOG_FATAL,
872 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
873 arg, opt);
874 ✗ return AVERROR(EINVAL);
875 }
876 83 *p++ = '\0';
877
878 83 return av_dict_set(&o->streamid, idx_str, p, 0);
879 }
880
881 ✗ static int opt_target(void *optctx, const char *opt, const char *arg)
882 {
883 ✗ OptionsContext *o = optctx;
884 ✗ enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
885 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
886
887 ✗ if (!strncmp(arg, "pal-", 4)) {
888 ✗ norm = PAL;
889 ✗ arg += 4;
890 ✗ } else if (!strncmp(arg, "ntsc-", 5)) {
891 ✗ norm = NTSC;
892 ✗ arg += 5;
893 ✗ } else if (!strncmp(arg, "film-", 5)) {
894 ✗ norm = FILM;
895 ✗ arg += 5;
896 } else {
897 /* Try to determine PAL/NTSC by peeking in the input files */
898 ✗ if (nb_input_files) {
899 int i, j;
900 ✗ for (j = 0; j < nb_input_files; j++) {
901 ✗ for (i = 0; i < input_files[j]->nb_streams; i++) {
902 ✗ AVStream *st = input_files[j]->ctx->streams[i];
903 int64_t fr;
904 ✗ if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
905 ✗ continue;
906 ✗ fr = st->time_base.den * 1000LL / st->time_base.num;
907 ✗ if (fr == 25000) {
908 ✗ norm = PAL;
909 ✗ break;
910 ✗ } else if ((fr == 29970) || (fr == 23976)) {
911 ✗ norm = NTSC;
912 ✗ break;
913 }
914 }
915 ✗ if (norm != UNKNOWN)
916 ✗ break;
917 }
918 }
919 ✗ if (norm != UNKNOWN)
920 ✗ av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
921 }
922
923 ✗ if (norm == UNKNOWN) {
924 ✗ av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
925 ✗ av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
926 ✗ av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
927 ✗ return AVERROR(EINVAL);
928 }
929
930 ✗ if (!strcmp(arg, "vcd")) {
931 ✗ opt_video_codec(o, "c:v", "mpeg1video");
932 ✗ opt_audio_codec(o, "c:a", "mp2");
933 ✗ parse_option(o, "f", "vcd", options);
934
935 ✗ parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
936 ✗ parse_option(o, "r", frame_rates[norm], options);
937 ✗ opt_default(NULL, "g", norm == PAL ? "15" : "18");
938
939 ✗ opt_default(NULL, "b:v", "1150000");
940 ✗ opt_default(NULL, "maxrate:v", "1150000");
941 ✗ opt_default(NULL, "minrate:v", "1150000");
942 ✗ opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
943
944 ✗ opt_default(NULL, "b:a", "224000");
945 ✗ parse_option(o, "ar", "44100", options);
946 ✗ parse_option(o, "ac", "2", options);
947
948 ✗ opt_default(NULL, "packetsize", "2324");
949 ✗ opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
950
951 /* We have to offset the PTS, so that it is consistent with the SCR.
952 SCR starts at 36000, but the first two packs contain only padding
953 and the first pack from the other stream, respectively, may also have
954 been written before.
955 So the real data starts at SCR 36000+3*1200. */
956 ✗ o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
957 ✗ } else if (!strcmp(arg, "svcd")) {
958
959 ✗ opt_video_codec(o, "c:v", "mpeg2video");
960 ✗ opt_audio_codec(o, "c:a", "mp2");
961 ✗ parse_option(o, "f", "svcd", options);
962
963 ✗ parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
964 ✗ parse_option(o, "r", frame_rates[norm], options);
965 ✗ parse_option(o, "pix_fmt", "yuv420p", options);
966 ✗ opt_default(NULL, "g", norm == PAL ? "15" : "18");
967
968 ✗ opt_default(NULL, "b:v", "2040000");
969 ✗ opt_default(NULL, "maxrate:v", "2516000");
970 ✗ opt_default(NULL, "minrate:v", "0"); // 1145000;
971 ✗ opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
972 ✗ opt_default(NULL, "scan_offset", "1");
973
974 ✗ opt_default(NULL, "b:a", "224000");
975 ✗ parse_option(o, "ar", "44100", options);
976
977 ✗ opt_default(NULL, "packetsize", "2324");
978
979 ✗ } else if (!strcmp(arg, "dvd")) {
980
981 ✗ opt_video_codec(o, "c:v", "mpeg2video");
982 ✗ opt_audio_codec(o, "c:a", "ac3");
983 ✗ parse_option(o, "f", "dvd", options);
984
985 ✗ parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
986 ✗ parse_option(o, "r", frame_rates[norm], options);
987 ✗ parse_option(o, "pix_fmt", "yuv420p", options);
988 ✗ opt_default(NULL, "g", norm == PAL ? "15" : "18");
989
990 ✗ opt_default(NULL, "b:v", "6000000");
991 ✗ opt_default(NULL, "maxrate:v", "9000000");
992 ✗ opt_default(NULL, "minrate:v", "0"); // 1500000;
993 ✗ opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
994
995 ✗ opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
996 ✗ opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
997
998 ✗ opt_default(NULL, "b:a", "448000");
999 ✗ parse_option(o, "ar", "48000", options);
1000
1001 ✗ } else if (!strncmp(arg, "dv", 2)) {
1002
1003 ✗ parse_option(o, "f", "dv", options);
1004
1005 ✗ parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1006 ✗ parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1007 ✗ norm == PAL ? "yuv420p" : "yuv411p", options);
1008 ✗ parse_option(o, "r", frame_rates[norm], options);
1009
1010 ✗ parse_option(o, "ar", "48000", options);
1011 ✗ parse_option(o, "ac", "2", options);
1012
1013 } else {
1014 ✗ av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1015 ✗ return AVERROR(EINVAL);
1016 }
1017
1018 ✗ av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
1019 ✗ av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
1020
1021 ✗ return 0;
1022 }
1023
1024 ✗ static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1025 {
1026 ✗ av_free (vstats_filename);
1027 ✗ vstats_filename = av_strdup (arg);
1028 ✗ return 0;
1029 }
1030
1031 ✗ static int opt_vstats(void *optctx, const char *opt, const char *arg)
1032 {
1033 char filename[40];
1034 ✗ time_t today2 = time(NULL);
1035 ✗ struct tm *today = localtime(&today2);
1036
1037 ✗ if (!today) { // maybe tomorrow
1038 ✗ av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
1039 ✗ return AVERROR(errno);
1040 }
1041
1042 ✗ snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1043 today->tm_sec);
1044 ✗ return opt_vstats_file(NULL, opt, filename);
1045 }
1046
1047 ✗ static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1048 {
1049 ✗ OptionsContext *o = optctx;
1050 ✗ return parse_option(o, "frames:v", arg, options);
1051 }
1052
1053 7 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1054 {
1055 7 OptionsContext *o = optctx;
1056 7 return parse_option(o, "frames:a", arg, options);
1057 }
1058
1059 ✗ static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1060 {
1061 ✗ OptionsContext *o = optctx;
1062 ✗ return parse_option(o, "frames:d", arg, options);
1063 }
1064
1065 ✗ static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1066 {
1067 int ret;
1068 ✗ AVDictionary *cbak = codec_opts;
1069 ✗ AVDictionary *fbak = format_opts;
1070 ✗ codec_opts = NULL;
1071 ✗ format_opts = NULL;
1072
1073 ✗ ret = opt_default(NULL, opt, arg);
1074
1075 ✗ av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1076 ✗ av_dict_copy(&o->g->format_opts, format_opts, 0);
1077 ✗ av_dict_free(&codec_opts);
1078 ✗ av_dict_free(&format_opts);
1079 ✗ codec_opts = cbak;
1080 ✗ format_opts = fbak;
1081
1082 ✗ return ret;
1083 }
1084
1085 ✗ static int opt_preset(void *optctx, const char *opt, const char *arg)
1086 {
1087 ✗ OptionsContext *o = optctx;
1088 ✗ FILE *f=NULL;
1089 char filename[1000], line[1000], tmp_line[1000];
1090 ✗ const char *codec_name = NULL;
1091 ✗ int ret = 0;
1092 ✗ int depth = o->depth;
1093
1094 ✗ if (depth > 2) {
1095 ✗ av_log(NULL, AV_LOG_ERROR, "too deep recursion\n");
1096 ✗ return AVERROR(EINVAL);
1097 }
1098
1099 ✗ codec_name = opt_match_per_type_str(&o->codec_names, *opt);
1100
1101 ✗ if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1102 ✗ if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1103 ✗ av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1104 }else
1105 ✗ av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1106 ✗ return AVERROR(ENOENT);
1107 }
1108
1109 ✗ o->depth ++;
1110 ✗ while (fgets(line, sizeof(line), f)) {
1111 ✗ char *key = tmp_line, *value, *endptr;
1112
1113 ✗ if (strcspn(line, "#\n\r") == 0)
1114 ✗ continue;
1115 ✗ av_strlcpy(tmp_line, line, sizeof(tmp_line));
1116 ✗ if (!av_strtok(key, "=", &value) ||
1117 ✗ !av_strtok(value, "\r\n", &endptr)) {
1118 ✗ av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1119 ✗ ret = AVERROR(EINVAL);
1120 ✗ goto fail;
1121 }
1122 ✗ av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1123
1124 ✗ if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
1125 ✗ else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
1126 ✗ else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1127 ✗ else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1128 ✗ else if ((parse_option(o, key, value, options) < 0) &&
1129 ✗ (opt_default_new(o, key, value) < 0)) {
1130 ✗ av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1131 filename, line, key, value);
1132 ✗ ret = AVERROR(EINVAL);
1133 ✗ goto fail;
1134 }
1135 }
1136
1137 ✗ fail:
1138 ✗ o->depth = depth;
1139 ✗ fclose(f);
1140
1141 ✗ return ret;
1142 }
1143
1144 ✗ static int opt_old2new(void *optctx, const char *opt, const char *arg)
1145 {
1146 ✗ OptionsContext *o = optctx;
1147 int ret;
1148 ✗ char *s = av_asprintf("%s:%c", opt + 1, *opt);
1149 ✗ if (!s)
1150 ✗ return AVERROR(ENOMEM);
1151 ✗ ret = parse_option(o, s, arg, options);
1152 ✗ av_free(s);
1153 ✗ return ret;
1154 }
1155
1156 183 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
1157 {
1158 183 OptionsContext *o = optctx;
1159
1160
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 180 times.
 183 if(!strcmp(opt, "ab")){
1161 3 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
1162 3 return 0;
1163
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 136 times.
 180 } else if(!strcmp(opt, "b")){
1164 44 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
1165 44 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1166 44 return 0;
1167 }
1168 136 av_dict_set(&o->g->codec_opts, opt, arg, 0);
1169 136 return 0;
1170 }
1171
1172 297 static int opt_qscale(void *optctx, const char *opt, const char *arg)
1173 {
1174 297 OptionsContext *o = optctx;
1175 char *s;
1176 int ret;
1177
2/2
✓ Branch 0 taken 253 times.
✓ Branch 1 taken 44 times.
 297 if(!strcmp(opt, "qscale")){
1178 253 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
1179 253 return parse_option(o, "q:v", arg, options);
1180 }
1181 44 s = av_asprintf("q%s", opt + 6);
1182
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
 44 if (!s)
1183 ✗ return AVERROR(ENOMEM);
1184 44 ret = parse_option(o, s, arg, options);
1185 44 av_free(s);
1186 44 return ret;
1187 }
1188
1189 45 static int opt_profile(void *optctx, const char *opt, const char *arg)
1190 {
1191 45 OptionsContext *o = optctx;
1192
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 40 times.
 45 if(!strcmp(opt, "profile")){
1193 5 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
1194 5 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
1195 5 return 0;
1196 }
1197 40 av_dict_set(&o->g->codec_opts, opt, arg, 0);
1198 40 return 0;
1199 }
1200
1201 3342 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1202 {
1203 3342 OptionsContext *o = optctx;
1204 3342 return parse_option(o, "filter:v", arg, options);
1205 }
1206
1207 594 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1208 {
1209 594 OptionsContext *o = optctx;
1210 594 return parse_option(o, "filter:a", arg, options);
1211 }
1212
1213 15 static int opt_timecode(void *optctx, const char *opt, const char *arg)
1214 {
1215 15 OptionsContext *o = optctx;
1216 int ret;
1217 15 char *tcr = av_asprintf("timecode=%s", arg);
1218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (!tcr)
1219 ✗ return AVERROR(ENOMEM);
1220 15 ret = parse_option(o, "metadata:g", tcr, options);
1221
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 if (ret >= 0)
1222 15 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
1223 15 av_free(tcr);
1224 15 return ret;
1225 }
1226
1227 ✗ static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1228 {
1229 ✗ OptionsContext *o = optctx;
1230 ✗ return parse_option(o, "q:a", arg, options);
1231 }
1232
1233 1270 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1234 {
1235 1270 GlobalOptionsContext *go = optctx;
1236 char *graph_desc;
1237 int ret;
1238
1239 1270 graph_desc = av_strdup(arg);
1240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1270 times.
 1270 if (!graph_desc)
1241 ✗ return AVERROR(ENOMEM);
1242
1243 1270 ret = GROW_ARRAY(go->filtergraphs, go->nb_filtergraphs);
1244
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1270 times.
 1270 if (ret < 0) {
1245 ✗ av_freep(&graph_desc);
1246 ✗ return ret;
1247 }
1248 1270 go->filtergraphs[go->nb_filtergraphs - 1] = graph_desc;
1249
1250 1270 return 0;
1251 }
1252
1253 ✗ void show_help_default(const char *opt, const char *arg)
1254 {
1255 ✗ int show_advanced = 0, show_avoptions = 0;
1256
1257 ✗ if (opt && *opt) {
1258 ✗ if (!strcmp(opt, "long"))
1259 ✗ show_advanced = 1;
1260 ✗ else if (!strcmp(opt, "full"))
1261 ✗ show_advanced = show_avoptions = 1;
1262 else
1263 ✗ av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1264 }
1265
1266 ✗ show_usage();
1267
1268 ✗ printf("Getting help:\n"
1269 " -h -- print basic options\n"
1270 " -h long -- print more options\n"
1271 " -h full -- print all options (including all format and codec specific options, very long)\n"
1272 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
1273 " See man %s for detailed description of the options.\n"
1274 "\n"
1275 "Per-stream options can be followed by :<stream_spec> to apply that option to specific streams only. "
1276 "<stream_spec> can be a stream index, or v/a/s for video/audio/subtitle (see manual for full syntax).\n"
1277 "\n", program_name);
1278
1279 ✗ show_help_options(options, "Print help / information / capabilities:",
1280 OPT_EXIT, OPT_EXPERT);
1281 ✗ if (show_advanced)
1282 ✗ show_help_options(options, "Advanced information / capabilities:",
1283 OPT_EXIT | OPT_EXPERT, 0);
1284
1285 ✗ show_help_options(options, "Global options (affect whole program "
1286 "instead of just one file):",
1287 0, OPT_PERFILE | OPT_EXIT | OPT_EXPERT);
1288 ✗ if (show_advanced)
1289 ✗ show_help_options(options, "Advanced global options:", OPT_EXPERT,
1290 OPT_PERFILE | OPT_EXIT);
1291
1292 ✗ show_help_options(options, "Per-file options (input and output):",
1293 OPT_PERFILE | OPT_INPUT | OPT_OUTPUT,
1294 OPT_EXIT | OPT_FLAG_PERSTREAM | OPT_EXPERT |
1295 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1296 ✗ if (show_advanced)
1297 ✗ show_help_options(options, "Advanced per-file options (input and output):",
1298 OPT_PERFILE | OPT_INPUT | OPT_OUTPUT | OPT_EXPERT,
1299 OPT_EXIT | OPT_FLAG_PERSTREAM |
1300 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1301
1302 ✗ show_help_options(options, "Per-file options (input-only):",
1303 OPT_PERFILE | OPT_INPUT,
1304 OPT_EXIT | OPT_FLAG_PERSTREAM | OPT_OUTPUT | OPT_EXPERT |
1305 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1306 ✗ if (show_advanced)
1307 ✗ show_help_options(options, "Advanced per-file options (input-only):",
1308 OPT_PERFILE | OPT_INPUT | OPT_EXPERT,
1309 OPT_EXIT | OPT_FLAG_PERSTREAM | OPT_OUTPUT |
1310 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1311
1312 ✗ show_help_options(options, "Per-file options (output-only):",
1313 OPT_PERFILE | OPT_OUTPUT,
1314 OPT_EXIT | OPT_FLAG_PERSTREAM | OPT_INPUT | OPT_EXPERT |
1315 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1316 ✗ if (show_advanced)
1317 ✗ show_help_options(options, "Advanced per-file options (output-only):",
1318 OPT_PERFILE | OPT_OUTPUT | OPT_EXPERT,
1319 OPT_EXIT | OPT_FLAG_PERSTREAM | OPT_INPUT |
1320 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1321
1322 ✗ show_help_options(options, "Per-stream options:",
1323 OPT_FLAG_PERSTREAM,
1324 OPT_EXIT | OPT_EXPERT |
1325 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1326 ✗ if (show_advanced)
1327 ✗ show_help_options(options, "Advanced per-stream options:",
1328 OPT_FLAG_PERSTREAM | OPT_EXPERT,
1329 OPT_EXIT |
1330 OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1331
1332 ✗ show_help_options(options, "Video options:",
1333 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1334 ✗ if (show_advanced)
1335 ✗ show_help_options(options, "Advanced Video options:",
1336 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO | OPT_SUBTITLE | OPT_DATA);
1337
1338 ✗ show_help_options(options, "Audio options:",
1339 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO | OPT_SUBTITLE | OPT_DATA);
1340 ✗ if (show_advanced)
1341 ✗ show_help_options(options, "Advanced Audio options:",
1342 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO | OPT_SUBTITLE | OPT_DATA);
1343
1344 ✗ show_help_options(options, "Subtitle options:",
1345 OPT_SUBTITLE, OPT_EXPERT | OPT_VIDEO | OPT_AUDIO | OPT_DATA);
1346 ✗ if (show_advanced)
1347 ✗ show_help_options(options, "Advanced Subtitle options:",
1348 OPT_EXPERT | OPT_SUBTITLE, OPT_VIDEO | OPT_AUDIO | OPT_DATA);
1349
1350 ✗ if (show_advanced)
1351 ✗ show_help_options(options, "Data stream options:",
1352 OPT_DATA, OPT_VIDEO | OPT_AUDIO | OPT_SUBTITLE);
1353 ✗ printf("\n");
1354
1355 ✗ if (show_avoptions) {
1356 ✗ int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1357 ✗ show_help_children(avcodec_get_class(), flags);
1358 ✗ show_help_children(avformat_get_class(), flags);
1359 #if CONFIG_SWSCALE
1360 ✗ show_help_children(sws_get_class(), flags);
1361 #endif
1362 #if CONFIG_SWRESAMPLE
1363 ✗ show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
1364 #endif
1365 ✗ show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
1366 ✗ show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
1367 }
1368 ✗ }
1369
1370 ✗ void show_usage(void)
1371 {
1372 ✗ av_log(NULL, AV_LOG_INFO, "Universal media converter\n");
1373 ✗ av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1374 ✗ av_log(NULL, AV_LOG_INFO, "\n");
1375 ✗ }
1376
1377 enum OptGroup {
1378 GROUP_OUTFILE,
1379 GROUP_INFILE,
1380 GROUP_DECODER,
1381 };
1382
1383 static const OptionGroupDef groups[] = {
1384 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
1385 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
1386 [GROUP_DECODER] = { "loopback decoder", "dec", OPT_DECODER },
1387 };
1388
1389 26490 static int open_files(OptionGroupList *l, const char *inout, Scheduler *sch,
1390 int (*open_file)(const OptionsContext*, const char*,
1391 Scheduler*))
1392 {
1393 int i, ret;
1394
1395
2/2
✓ Branch 0 taken 16572 times.
✓ Branch 1 taken 26483 times.
 43055 for (i = 0; i < l->nb_groups; i++) {
1396 16572 OptionGroup *g = &l->groups[i];
1397 OptionsContext o;
1398
1399 16572 init_options(&o);
1400 16572 o.g = g;
1401
1402 16572 ret = parse_optgroup(&o, g, options);
1403
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16572 times.
 16572 if (ret < 0) {
1404 ✗ av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1405 "%s.\n", inout, g->arg);
1406 ✗ uninit_options(&o);
1407 7 return ret;
1408 }
1409
1410 16572 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1411 16572 ret = open_file(&o, g->arg, sch);
1412 16572 uninit_options(&o);
1413
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 16565 times.
 16572 if (ret < 0) {
1414 7 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1415 inout, g->arg);
1416 7 return ret;
1417 }
1418 16565 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
1419 }
1420
1421 26483 return 0;
1422 }
1423
1424 8835 int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
1425 {
1426 8835 GlobalOptionsContext go = { .sch = sch };
1427 OptionParseContext octx;
1428 8835 const char *errmsg = NULL;
1429 int ret;
1430
1431 8835 memset(&octx, 0, sizeof(octx));
1432
1433 /* split the commandline into an internal representation */
1434 8835 ret = split_commandline(&octx, argc, argv, options, groups,
1435 FF_ARRAY_ELEMS(groups));
1436
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8835 times.
 8835 if (ret < 0) {
1437 ✗ errmsg = "splitting the argument list";
1438 ✗ goto fail;
1439 }
1440
1441 /* apply global options */
1442 8835 ret = parse_optgroup(&go, &octx.global_opts, options);
1443
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8833 times.
 8835 if (ret < 0) {
1444 2 errmsg = "parsing global options";
1445 2 goto fail;
1446 }
1447
1448 /* configure terminal and setup signal handlers */
1449 8833 term_init();
1450
1451 /* create complex filtergraphs */
1452
2/2
✓ Branch 0 taken 1270 times.
✓ Branch 1 taken 8833 times.
 10103 for (int i = 0; i < go.nb_filtergraphs; i++) {
1453 1270 ret = fg_create(NULL, &go.filtergraphs[i], sch, NULL);
1454 1270 go.filtergraphs[i] = NULL;
1455
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1270 times.
 1270 if (ret < 0)
1456 ✗ goto fail;
1457 }
1458
1459 /* open input files */
1460 8833 ret = open_files(&octx.groups[GROUP_INFILE], "input", sch, ifile_open);
1461
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8831 times.
 8833 if (ret < 0) {
1462 2 errmsg = "opening input files";
1463 2 goto fail;
1464 }
1465
1466 /* open output files */
1467 8831 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", sch, of_open);
1468
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 8826 times.
 8831 if (ret < 0) {
1469 5 errmsg = "opening output files";
1470 5 goto fail;
1471 }
1472
1473 /* create loopback decoders */
1474 8826 ret = open_files(&octx.groups[GROUP_DECODER], "decoder", sch, dec_create);
1475
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8826 times.
 8826 if (ret < 0) {
1476 ✗ errmsg = "creating loopback decoders";
1477 ✗ goto fail;
1478 }
1479
1480 // bind unbound filtegraph inputs/outputs and check consistency
1481 8826 ret = fg_finalise_bindings();
1482
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8826 times.
 8826 if (ret < 0) {
1483 ✗ errmsg = "binding filtergraph inputs/outputs";
1484 ✗ goto fail;
1485 }
1486
1487 8826 correct_input_start_times();
1488
1489 8826 ret = apply_sync_offsets();
1490
1/2
✓ Branch 0 taken 8826 times.
✗ Branch 1 not taken.
 8826 if (ret < 0)
1491 ✗ goto fail;
1492
1493 8826 fail:
1494
2/2
✓ Branch 0 taken 1270 times.
✓ Branch 1 taken 8835 times.
 10105 for (int i = 0; i < go.nb_filtergraphs; i++)
1495 1270 av_freep(&go.filtergraphs[i]);
1496 8835 av_freep(&go.filtergraphs);
1497
1498 8835 uninit_parse_context(&octx);
1499
4/4
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 8826 times.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 2 times.
 8835 if (ret < 0 && ret != AVERROR_EXIT) {
1500
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 av_log(NULL, AV_LOG_FATAL, "Error %s: %s\n",
1501 7 errmsg ? errmsg : "", av_err2str(ret));
1502 }
1503 8835 return ret;
1504 }
1505
1506 ✗ static int opt_progress(void *optctx, const char *opt, const char *arg)
1507 {
1508 ✗ AVIOContext *avio = NULL;
1509 int ret;
1510
1511 ✗ if (!strcmp(arg, "-"))
1512 ✗ arg = "pipe:";
1513 ✗ ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
1514 ✗ if (ret < 0) {
1515 ✗ av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
1516 ✗ arg, av_err2str(ret));
1517 ✗ return ret;
1518 }
1519 ✗ progress_avio = avio;
1520 ✗ return 0;
1521 }
1522
1523 ✗ int opt_timelimit(void *optctx, const char *opt, const char *arg)
1524 {
1525 #if HAVE_SETRLIMIT
1526 int ret;
1527 double lim;
1528 struct rlimit rl;
1529
1530 ✗ ret = parse_number(opt, arg, OPT_TYPE_INT64, 0, INT_MAX, &lim);
1531 ✗ if (ret < 0)
1532 ✗ return ret;
1533
1534 ✗ rl = (struct rlimit){ lim, lim + 1 };
1535 ✗ if (setrlimit(RLIMIT_CPU, &rl))
1536 ✗ perror("setrlimit");
1537 #else
1538 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1539 #endif
1540 ✗ return 0;
1541 }
1542
1543 static const char *const alt_channel_layout[] = { "ch_layout", NULL};
1544 static const char *const alt_codec[] = { "c", "acodec", "vcodec", "scodec", "dcodec", NULL };
1545 static const char *const alt_filter[] = { "af", "vf", NULL };
1546 static const char *const alt_frames[] = { "aframes", "vframes", "dframes", NULL };
1547 static const char *const alt_pre[] = { "apre", "vpre", "spre", NULL};
1548 static const char *const alt_qscale[] = { "q", NULL};
1549 static const char *const alt_tag[] = { "atag", "vtag", "stag", NULL };
1550
1551 #define OFFSET(x) offsetof(OptionsContext, x)
1552 const OptionDef options[] = {
1553 /* main options */
1554 CMDUTILS_COMMON_OPTIONS
1555 { "f", OPT_TYPE_STRING, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
1556 { .off = OFFSET(format) },
1557 "force container format (auto-detected otherwise)", "fmt" },
1558 { "y", OPT_TYPE_BOOL, 0,
1559 { &file_overwrite },
1560 "overwrite output files" },
1561 { "n", OPT_TYPE_BOOL, 0,
1562 { &no_file_overwrite },
1563 "never overwrite output files" },
1564 { "ignore_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
1565 { &ignore_unknown_streams },
1566 "Ignore unknown stream types" },
1567 { "copy_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
1568 { &copy_unknown_streams },
1569 "Copy unknown stream types" },
1570 { "recast_media", OPT_TYPE_BOOL, OPT_EXPERT,
1571 { &recast_media },
1572 "allow recasting stream type in order to force a decoder of different media type" },
1573 { "c", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT | OPT_DECODER | OPT_HAS_CANON,
1574 { .off = OFFSET(codec_names) },
1575 "select encoder/decoder ('copy' to copy stream without reencoding)", "codec",
1576 .u1.name_canon = "codec", },
1577 { "codec", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT | OPT_DECODER | OPT_EXPERT | OPT_HAS_ALT,
1578 { .off = OFFSET(codec_names) },
1579 "alias for -c (select encoder/decoder)", "codec",
1580 .u1.names_alt = alt_codec, },
1581 { "pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT | OPT_HAS_ALT,
1582 { .off = OFFSET(presets) },
1583 "preset name", "preset",
1584 .u1.names_alt = alt_pre, },
1585 { "map", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
1586 { .func_arg = opt_map },
1587 "set input stream mapping",
1588 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1589 { "map_metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT | OPT_EXPERT,
1590 { .off = OFFSET(metadata_map) },
1591 "set metadata information of outfile from infile",
1592 "outfile[,metadata]:infile[,metadata]" },
1593 { "map_chapters", OPT_TYPE_INT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1594 { .off = OFFSET(chapters_input_file) },
1595 "set chapters mapping", "input_file_index" },
1596 { "t", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
1597 { .off = OFFSET(recording_time) },
1598 "stop transcoding after specified duration",
1599 "duration" },
1600 { "to", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
1601 { .off = OFFSET(stop_time) },
1602 "stop transcoding after specified time is reached",
1603 "time_stop" },
1604 { "fs", OPT_TYPE_INT64, OPT_OFFSET | OPT_OUTPUT | OPT_EXPERT,
1605 { .off = OFFSET(limit_filesize) },
1606 "set the limit file size in bytes", "limit_size" },
1607 { "ss", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
1608 { .off = OFFSET(start_time) },
1609 "start transcoding at specified time", "time_off" },
1610 { "sseof", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_EXPERT,
1611 { .off = OFFSET(start_time_eof) },
1612 "set the start time offset relative to EOF", "time_off" },
1613 { "seek_timestamp", OPT_TYPE_INT, OPT_OFFSET | OPT_INPUT | OPT_EXPERT,
1614 { .off = OFFSET(seek_timestamp) },
1615 "enable/disable seeking by timestamp with -ss" },
1616 { "accurate_seek", OPT_TYPE_BOOL, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1617 { .off = OFFSET(accurate_seek) },
1618 "enable/disable accurate seeking with -ss" },
1619 { "isync", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1620 { .off = OFFSET(input_sync_ref) },
1621 "Indicate the input index for sync reference", "sync ref" },
1622 { "itsoffset", OPT_TYPE_TIME, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1623 { .off = OFFSET(input_ts_offset) },
1624 "set the input ts offset", "time_off" },
1625 { "itsscale", OPT_TYPE_DOUBLE, OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1626 { .off = OFFSET(ts_scale) },
1627 "set the input ts scale", "scale" },
1628 { "timestamp", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_PERFILE | OPT_EXPERT | OPT_OUTPUT,
1629 { .func_arg = opt_recording_timestamp },
1630 "set the recording timestamp ('now' to set the current time)", "time" },
1631 { "metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
1632 { .off = OFFSET(metadata) },
1633 "add metadata", "key=value" },
1634 { "keep_metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
1635 { .off = OFFSET(keep_metadata) },
1636 "keep metadata key from input when re-encoding", "key" },
1637 { "program", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
1638 { .off = OFFSET(program) },
1639 "add program with specified streams", "title=string:st=number..." },
1640 { "stream_group", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT | OPT_EXPERT,
1641 { .off = OFFSET(stream_groups) },
1642 "add stream group with specified streams and group type-specific arguments", "id=number:st=number..." },
1643 { "dframes", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_PERFILE | OPT_EXPERT | OPT_OUTPUT | OPT_HAS_CANON,
1644 { .func_arg = opt_data_frames },
1645 "set the number of data frames to output", "number",
1646 .u1.name_canon = "frames" },
1647 { "benchmark", OPT_TYPE_BOOL, OPT_EXPERT,
1648 { &do_benchmark },
1649 "add timings for benchmarking" },
1650 { "benchmark_all", OPT_TYPE_BOOL, OPT_EXPERT,
1651 { &do_benchmark_all },
1652 "add timings for each task" },
1653 { "progress", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1654 { .func_arg = opt_progress },
1655 "write program-readable progress information", "url" },
1656 { "stdin", OPT_TYPE_BOOL, OPT_EXPERT,
1657 { &stdin_interaction },
1658 "enable or disable interaction on standard input" },
1659 { "timelimit", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1660 { .func_arg = opt_timelimit },
1661 "set max runtime in seconds in CPU user time", "limit" },
1662 { "dump", OPT_TYPE_BOOL, OPT_EXPERT,
1663 { &do_pkt_dump },
1664 "dump each input packet" },
1665 { "hex", OPT_TYPE_BOOL, OPT_EXPERT,
1666 { &do_hex_dump },
1667 "when dumping packets, also dump the payload" },
1668 { "re", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_INPUT,
1669 { .off = OFFSET(rate_emu) },
1670 "read input at native frame rate; equivalent to -readrate 1", "" },
1671 { "readrate", OPT_TYPE_FLOAT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1672 { .off = OFFSET(readrate) },
1673 "read input at specified rate", "speed" },
1674 { "readrate_initial_burst", OPT_TYPE_DOUBLE, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1675 { .off = OFFSET(readrate_initial_burst) },
1676 "The initial amount of input to burst read before imposing any readrate", "seconds" },
1677 { "readrate_catchup", OPT_TYPE_FLOAT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1678 { .off = OFFSET(readrate_catchup) },
1679 "Temporary readrate used to catch up if an input lags behind the specified readrate", "speed" },
1680 { "target", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_PERFILE | OPT_EXPERT | OPT_OUTPUT,
1681 { .func_arg = opt_target },
1682 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
1683 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
1684 { "frame_drop_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1685 { &frame_drop_threshold },
1686 "frame drop threshold", "" },
1687 { "copyts", OPT_TYPE_BOOL, OPT_EXPERT,
1688 { &copy_ts },
1689 "copy timestamps" },
1690 { "start_at_zero", OPT_TYPE_BOOL, OPT_EXPERT,
1691 { &start_at_zero },
1692 "shift input timestamps to start at 0 when using copyts" },
1693 { "copytb", OPT_TYPE_INT, OPT_EXPERT,
1694 { &copy_tb },
1695 "copy input stream time base when stream copying", "mode" },
1696 { "shortest", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1697 { .off = OFFSET(shortest) },
1698 "finish encoding within shortest input" },
1699 { "shortest_buf_duration", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1700 { .off = OFFSET(shortest_buf_duration) },
1701 "maximum buffering duration (in seconds) for the -shortest option" },
1702 { "bitexact", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT | OPT_INPUT,
1703 { .off = OFFSET(bitexact) },
1704 "bitexact mode" },
1705 { "dts_delta_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1706 { &dts_delta_threshold },
1707 "timestamp discontinuity delta threshold", "threshold" },
1708 { "dts_error_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1709 { &dts_error_threshold },
1710 "timestamp error delta threshold", "threshold" },
1711 { "xerror", OPT_TYPE_BOOL, OPT_EXPERT,
1712 { &exit_on_error },
1713 "exit on error", "error" },
1714 { "abort_on", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1715 { .func_arg = opt_abort_on },
1716 "abort on the specified condition flags", "flags" },
1717 { "copyinkf", OPT_TYPE_BOOL, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1718 { .off = OFFSET(copy_initial_nonkeyframes) },
1719 "copy initial non-keyframes" },
1720 { "copypriorss", OPT_TYPE_INT, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1721 { .off = OFFSET(copy_prior_start) },
1722 "copy or discard frames before start time" },
1723 { "frames", OPT_TYPE_INT64, OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT | OPT_HAS_ALT,
1724 { .off = OFFSET(max_frames) },
1725 "set the number of frames to output", "number",
1726 .u1.names_alt = alt_frames, },
1727 { "tag", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT | OPT_INPUT | OPT_HAS_ALT,
1728 { .off = OFFSET(codec_tags) },
1729 "force codec tag/fourcc", "fourcc/tag",
1730 .u1.names_alt = alt_tag, },
1731 { "q", OPT_TYPE_DOUBLE, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT | OPT_HAS_CANON,
1732 { .off = OFFSET(qscale) },
1733 "use fixed quality scale (VBR)", "q",
1734 .u1.name_canon = "qscale", },
1735 { "qscale", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT | OPT_HAS_ALT,
1736 { .func_arg = opt_qscale },
1737 "use fixed quality scale (VBR)", "q",
1738 .u1.names_alt = alt_qscale, },
1739 { "profile", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
1740 { .func_arg = opt_profile },
1741 "set profile", "profile" },
1742 { "filter", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_OUTPUT | OPT_HAS_ALT,
1743 { .off = OFFSET(filters) },
1744 "apply specified filters to audio/video", "filter_graph",
1745 .u1.names_alt = alt_filter, },
1746 { "filter_threads", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1747 { .func_arg = opt_filter_threads },
1748 "number of non-complex filter threads" },
1749 { "filter_buffered_frames", OPT_TYPE_INT, OPT_EXPERT,
1750 { &filter_buffered_frames },
1751 "maximum number of buffered frames in a filter graph" },
1752 { "reinit_filter", OPT_TYPE_INT, OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1753 { .off = OFFSET(reinit_filters) },
1754 "reinit filtergraph on input parameter changes", "" },
1755 { "drop_changed", OPT_TYPE_INT, OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1756 { .off = OFFSET(drop_changed) },
1757 "drop frame instead of reiniting filtergraph on input parameter changes", "" },
1758 { "filter_complex", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1759 { .func_arg = opt_filter_complex },
1760 "create a complex filtergraph", "graph_description" },
1761 { "filter_complex_threads", OPT_TYPE_INT, OPT_EXPERT,
1762 { &filter_complex_nbthreads },
1763 "number of threads for -filter_complex" },
1764 { "lavfi", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1765 { .func_arg = opt_filter_complex },
1766 "create a complex filtergraph", "graph_description" },
1767 { "print_graphs", OPT_TYPE_BOOL, 0,
1768 { &print_graphs },
1769 "print execution graph data to stderr" },
1770 { "print_graphs_file", OPT_TYPE_STRING, 0,
1771 { &print_graphs_file },
1772 "write execution graph data to the specified file", "filename" },
1773 { "print_graphs_format", OPT_TYPE_STRING, 0,
1774 { &print_graphs_format },
1775 "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml, mermaid, mermaidhtml)", "format" },
1776 { "auto_conversion_filters", OPT_TYPE_BOOL, OPT_EXPERT,
1777 { &auto_conversion_filters },
1778 "enable automatic conversion filters globally" },
1779 { "stats", OPT_TYPE_BOOL, 0,
1780 { &print_stats },
1781 "print progress report during encoding", },
1782 { "stats_period", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1783 { .func_arg = opt_stats_period },
1784 "set the period at which ffmpeg updates stats and -progress output", "time" },
1785 { "attach", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_PERFILE | OPT_EXPERT | OPT_OUTPUT,
1786 { .func_arg = opt_attach },
1787 "add an attachment to the output file", "filename" },
1788 { "dump_attachment", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_INPUT,
1789 { .off = OFFSET(dump_attachment) },
1790 "extract an attachment into a file", "filename" },
1791 { "stream_loop", OPT_TYPE_INT, OPT_EXPERT | OPT_INPUT | OPT_OFFSET,
1792 { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
1793 { "debug_ts", OPT_TYPE_BOOL, OPT_EXPERT,
1794 { &debug_ts },
1795 "print timestamp debugging info" },
1796 { "max_error_rate", OPT_TYPE_FLOAT, OPT_EXPERT,
1797 { &max_error_rate },
1798 "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
1799 { "discard", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1800 { .off = OFFSET(discard) },
1801 "discard", "" },
1802 { "disposition", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT,
1803 { .off = OFFSET(disposition) },
1804 "disposition", "" },
1805 { "thread_queue_size", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_OUTPUT,
1806 { .off = OFFSET(thread_queue_size) },
1807 "set the maximum number of queued packets per stream on the muxer" },
1808 { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT | OPT_OFFSET,
1809 { .off = OFFSET(find_stream_info) },
1810 "read and decode the streams to fill missing information with heuristics" },
1811 { "bits_per_raw_sample", OPT_TYPE_INT, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1812 { .off = OFFSET(bits_per_raw_sample) },
1813 "set the number of bits per raw sample", "number" },
1814
1815 { "stats_enc_pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1816 { .off = OFFSET(enc_stats_pre) },
1817 "write encoding stats before encoding" },
1818 { "stats_enc_post", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1819 { .off = OFFSET(enc_stats_post) },
1820 "write encoding stats after encoding" },
1821 { "stats_mux_pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1822 { .off = OFFSET(mux_stats) },
1823 "write packets stats before muxing" },
1824 { "stats_enc_pre_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1825 { .off = OFFSET(enc_stats_pre_fmt) },
1826 "format of the stats written with -stats_enc_pre" },
1827 { "stats_enc_post_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1828 { .off = OFFSET(enc_stats_post_fmt) },
1829 "format of the stats written with -stats_enc_post" },
1830 { "stats_mux_pre_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1831 { .off = OFFSET(mux_stats_fmt) },
1832 "format of the stats written with -stats_mux_pre" },
1833
1834 { "reinit_opts", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1835 { .off = OFFSET(enc_reinit_opts) },
1836 "List of encoder options to use to reinitialize the encoder at given timestamps",
1837 "pts1|video_size=size:g=12,pts2|video_size=size..." },
1838
1839 /* video options */
1840 { "vframes", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT | OPT_EXPERT | OPT_HAS_CANON,
1841 { .func_arg = opt_video_frames },
1842 "set the number of video frames to output", "number",
1843 .u1.name_canon = "frames", },
1844 { "r", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT,
1845 { .off = OFFSET(frame_rates) },
1846 "override input framerate/convert to given output framerate (Hz value, fraction or abbreviation)", "rate" },
1847 { "fpsmax", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT,
1848 { .off = OFFSET(max_frame_rates) },
1849 "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
1850 { "s", OPT_TYPE_STRING, OPT_VIDEO | OPT_SUBTITLE | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT,
1851 { .off = OFFSET(frame_sizes) },
1852 "set frame size (WxH or abbreviation)", "size" },
1853 { "aspect", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_OUTPUT,
1854 { .off = OFFSET(frame_aspect_ratios) },
1855 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1856 { "stereo3d", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_OUTPUT,
1857 { .off = OFFSET(stereo3ds) },
1858 "set stereoscopic 3D layout metadata (does not rearrange pixels)", "layout" },
1859 { "pix_fmt", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT,
1860 { .off = OFFSET(frame_pix_fmts) },
1861 "set pixel format", "format" },
1862 { "display_rotation", OPT_TYPE_DOUBLE, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1863 { .off = OFFSET(display_rotations) },
1864 "set pure counter-clockwise rotation in degrees for stream(s)",
1865 "angle" },
1866 { "display_hflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1867 { .off = OFFSET(display_hflips) },
1868 "set display horizontal flip for stream(s) "
1869 "(overrides any display rotation if it is not set)"},
1870 { "display_vflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1871 { .off = OFFSET(display_vflips) },
1872 "set display vertical flip for stream(s) "
1873 "(overrides any display rotation if it is not set)"},
1874 { "mastering_display", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1875 { .off = OFFSET(mastering_displays) },
1876 "set SMPTE2084 mastering display color volume info" },
1877 { "content_light", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1878 { .off = OFFSET(content_lights) },
1879 "set SMPTE2084 Max CLL and Max FALL values" },
1880 { "vn", OPT_TYPE_BOOL, OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
1881 { .off = OFFSET(video_disable) },
1882 "disable video" },
1883 { "rc_override", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1884 { .off = OFFSET(rc_overrides) },
1885 "rate control override for specific intervals", "override" },
1886 { "vcodec", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT | OPT_HAS_CANON,
1887 { .func_arg = opt_video_codec },
1888 "alias for -c:v (select encoder/decoder for video streams)", "codec",
1889 .u1.name_canon = "codec", },
1890 { "timecode", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT | OPT_EXPERT,
1891 { .func_arg = opt_timecode },
1892 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
1893 { "pass", OPT_TYPE_INT, OPT_VIDEO | OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT,
1894 { .off = OFFSET(pass) },
1895 "select the pass number (1 to 3)", "n" },
1896 { "passlogfile", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1897 { .off = OFFSET(passlogfiles) },
1898 "select two pass log file name prefix", "prefix" },
1899 { "vstats", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
1900 { .func_arg = opt_vstats },
1901 "dump video coding statistics to file" },
1902 { "vstats_file", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_EXPERT,
1903 { .func_arg = opt_vstats_file },
1904 "dump video coding statistics to file", "file" },
1905 { "vstats_version", OPT_TYPE_INT, OPT_VIDEO | OPT_EXPERT,
1906 { &vstats_version },
1907 "Version of the vstats format to use."},
1908 { "vf", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
1909 { .func_arg = opt_video_filters },
1910 "alias for -filter:v (apply filters to video streams)", "filter_graph",
1911 .u1.name_canon = "filter", },
1912 { "intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1913 { .off = OFFSET(intra_matrices) },
1914 "specify intra matrix coeffs", "matrix" },
1915 { "inter_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1916 { .off = OFFSET(inter_matrices) },
1917 "specify inter matrix coeffs", "matrix" },
1918 { "chroma_intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1919 { .off = OFFSET(chroma_intra_matrices) },
1920 "specify intra matrix coeffs", "matrix" },
1921 { "vtag", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT | OPT_HAS_CANON,
1922 { .func_arg = opt_old2new },
1923 "force video tag/fourcc", "fourcc/tag",
1924 .u1.name_canon = "tag", },
1925 { "fps_mode", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1926 { .off = OFFSET(fps_mode) },
1927 "set framerate mode for matching video streams" },
1928 { "force_fps", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1929 { .off = OFFSET(force_fps) },
1930 "force the selected framerate, disable the best supported framerate selection" },
1931 { "streamid", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
1932 { .func_arg = opt_streamid },
1933 "set the value of an outfile streamid", "streamIndex:value" },
1934 { "force_key_frames", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1935 { .off = OFFSET(forced_key_frames) },
1936 "force key frames at specified timestamps", "timestamps" },
1937 { "b", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT,
1938 { .func_arg = opt_bitrate },
1939 "video bitrate (please use -b:v)", "bitrate" },
1940 { "hwaccel", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1941 { .off = OFFSET(hwaccels) },
1942 "use HW accelerated decoding", "hwaccel name" },
1943 { "hwaccel_device", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1944 { .off = OFFSET(hwaccel_devices) },
1945 "select a device for HW acceleration", "devicename" },
1946 { "hwaccel_output_format", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1947 { .off = OFFSET(hwaccel_output_formats) },
1948 "select output format used with HW accelerated decoding", "format" },
1949 { "hwaccels", OPT_TYPE_FUNC, OPT_EXIT | OPT_EXPERT,
1950 { .func_arg = show_hwaccels },
1951 "show available HW acceleration methods" },
1952 { "autorotate", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1953 { .off = OFFSET(autorotate) },
1954 "automatically insert correct rotate filters" },
1955 { "autoscale", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1956 { .off = OFFSET(autoscale) },
1957 "automatically insert a scale filter at the end of the filter graph" },
1958 { "apply_cropping", OPT_TYPE_STRING, OPT_VIDEO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1959 { .off = OFFSET(apply_cropping) },
1960 "select the cropping to apply" },
1961 { "fix_sub_duration_heartbeat", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1962 { .off = OFFSET(fix_sub_duration_heartbeat) },
1963 "set this video output stream to be a heartbeat stream for "
1964 "fix_sub_duration, according to which subtitles should be split at "
1965 "random access points" },
1966
1967 /* audio options */
1968 { "aframes", OPT_TYPE_FUNC, OPT_AUDIO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT | OPT_EXPERT | OPT_HAS_CANON,
1969 { .func_arg = opt_audio_frames },
1970 "set the number of audio frames to output", "number",
1971 .u1.name_canon = "frames", },
1972 { "aq", OPT_TYPE_FUNC, OPT_AUDIO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT,
1973 { .func_arg = opt_audio_qscale },
1974 "set audio quality (codec-specific)", "quality", },
1975 { "ar", OPT_TYPE_INT, OPT_AUDIO | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT,
1976 { .off = OFFSET(audio_sample_rate) },
1977 "set audio sampling rate (in Hz)", "rate" },
1978 { "ac", OPT_TYPE_INT, OPT_AUDIO | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT,
1979 { .off = OFFSET(audio_channels) },
1980 "set number of audio channels", "channels" },
1981 { "an", OPT_TYPE_BOOL, OPT_AUDIO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
1982 { .off = OFFSET(audio_disable) },
1983 "disable audio" },
1984 { "acodec", OPT_TYPE_FUNC, OPT_AUDIO | OPT_FUNC_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT | OPT_HAS_CANON,
1985 { .func_arg = opt_audio_codec },
1986 "alias for -c:a (select encoder/decoder for audio streams)", "codec",
1987 .u1.name_canon = "codec", },
1988 { "ab", OPT_TYPE_FUNC, OPT_AUDIO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT,
1989 { .func_arg = opt_bitrate },
1990 "alias for -b:a (select bitrate for audio streams)", "bitrate" },
1991 { "apad", OPT_TYPE_STRING, OPT_AUDIO | OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1992 { .off = OFFSET(apad) },
1993 "audio pad", "" },
1994 { "atag", OPT_TYPE_FUNC, OPT_AUDIO | OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
1995 { .func_arg = opt_old2new },
1996 "force audio tag/fourcc", "fourcc/tag",
1997 .u1.name_canon = "tag", },
1998 { "sample_fmt", OPT_TYPE_STRING, OPT_AUDIO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT,
1999 { .off = OFFSET(sample_fmts) },
2000 "set sample format", "format" },
2001 { "channel_layout", OPT_TYPE_STRING, OPT_AUDIO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT | OPT_HAS_ALT,
2002 { .off = OFFSET(audio_ch_layouts) },
2003 "set channel layout", "layout",
2004 .u1.names_alt = alt_channel_layout, },
2005 { "ch_layout", OPT_TYPE_STRING, OPT_AUDIO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT | OPT_OUTPUT | OPT_HAS_CANON,
2006 { .off = OFFSET(audio_ch_layouts) },
2007 "set channel layout", "layout",
2008 .u1.name_canon = "channel_layout", },
2009 { "af", OPT_TYPE_FUNC, OPT_AUDIO | OPT_FUNC_ARG | OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
2010 { .func_arg = opt_audio_filters },
2011 "alias for -filter:a (apply filters to audio streams)", "filter_graph",
2012 .u1.name_canon = "filter", },
2013 { "guess_layout_max", OPT_TYPE_INT, OPT_AUDIO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
2014 { .off = OFFSET(guess_layout_max) },
2015 "set the maximum number of channels to try to guess the channel layout" },
2016
2017 /* subtitle options */
2018 { "sn", OPT_TYPE_BOOL, OPT_SUBTITLE | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
2019 { .off = OFFSET(subtitle_disable) },
2020 "disable subtitle" },
2021 { "scodec", OPT_TYPE_FUNC, OPT_SUBTITLE | OPT_FUNC_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT | OPT_HAS_CANON,
2022 { .func_arg = opt_subtitle_codec },
2023 "alias for -c:s (select encoder/decoder for subtitle streams)", "codec",
2024 .u1.name_canon = "codec", },
2025 { "stag", OPT_TYPE_FUNC, OPT_SUBTITLE | OPT_FUNC_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
2026 { .func_arg = opt_old2new }
2027 , "force subtitle tag/fourcc", "fourcc/tag",
2028 .u1.name_canon = "tag" },
2029 { "fix_sub_duration", OPT_TYPE_BOOL, OPT_EXPERT | OPT_SUBTITLE | OPT_PERSTREAM | OPT_INPUT,
2030 { .off = OFFSET(fix_sub_duration) },
2031 "fix subtitles duration" },
2032 { "canvas_size", OPT_TYPE_STRING, OPT_SUBTITLE | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
2033 { .off = OFFSET(canvas_sizes) },
2034 "set canvas size (WxH or abbreviation)", "size" },
2035
2036 /* muxer options */
2037 { "muxdelay", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
2038 { .off = OFFSET(mux_max_delay) },
2039 "set the maximum demux-decode delay", "seconds" },
2040 { "muxpreload", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
2041 { .off = OFFSET(mux_preload) },
2042 "set the initial demux-decode delay", "seconds" },
2043 { "sdp_file", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT | OPT_OUTPUT,
2044 { .func_arg = opt_sdp_file },
2045 "specify a file in which to print sdp information", "file" },
2046
2047 { "time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
2048 { .off = OFFSET(time_bases) },
2049 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
2050 { "enc_time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
2051 { .off = OFFSET(enc_time_bases) },
2052 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
2053 "two special values are defined - "
2054 "0 = use frame rate (video) or sample rate (audio),"
2055 "-1 = match source time base", "ratio" },
2056
2057 { "bsf", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,
2058 { .off = OFFSET(bitstream_filters) },
2059 "A comma-separated list of bitstream filters", "bitstream_filters", },
2060
2061 { "apre", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
2062 { .func_arg = opt_preset },
2063 "set the audio options to the indicated preset", "preset",
2064 .u1.name_canon = "pre", },
2065 { "vpre", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
2066 { .func_arg = opt_preset },
2067 "set the video options to the indicated preset", "preset",
2068 .u1.name_canon = "pre", },
2069 { "spre", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
2070 { .func_arg = opt_preset },
2071 "set the subtitle options to the indicated preset", "preset",
2072 .u1.name_canon = "pre", },
2073 { "fpre", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT | OPT_HAS_CANON,
2074 { .func_arg = opt_preset },
2075 "set options from indicated preset file", "filename",
2076 .u1.name_canon = "pre", },
2077
2078 { "max_muxing_queue_size", OPT_TYPE_INT, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
2079 { .off = OFFSET(max_muxing_queue_size) },
2080 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2081 { "muxing_queue_data_threshold", OPT_TYPE_INT, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
2082 { .off = OFFSET(muxing_queue_data_threshold) },
2083 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
2084
2085 /* data codec support */
2086 { "dcodec", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT | OPT_HAS_CANON,
2087 { .func_arg = opt_data_codec },
2088 "alias for -c:d (select encoder/decoder for data streams)", "codec",
2089 .u1.name_canon = "codec", },
2090 { "dn", OPT_TYPE_BOOL, OPT_DATA | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
2091 { .off = OFFSET(data_disable) }, "disable data" },
2092
2093 #if CONFIG_VAAPI
2094 { "vaapi_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2095 { .func_arg = opt_vaapi_device },
2096 "set VAAPI hardware device (DirectX adapter index, DRM path or X11 display name)", "device" },
2097 #endif
2098
2099 #if CONFIG_QSV
2100 { "qsv_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2101 { .func_arg = opt_qsv_device },
2102 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
2103 #endif
2104
2105 { "init_hw_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2106 { .func_arg = opt_init_hw_device },
2107 "initialise hardware device", "args" },
2108 { "filter_hw_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
2109 { .func_arg = opt_filter_hw_device },
2110 "set hardware device used when filtering", "device" },
2111
2112 { NULL, },
2113 };
2114