FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/fftools/cmdutils.c
Date: 2026-10-12 16:00:46
Exec Total Coverage
Lines: 554 887 62.5%
Functions: 34 42 81.0%
Branches: 413 759 54.4%
Line Branch Exec Source
1 /*
2 * Various utilities for command line tools
3 * Copyright (c) 2000-2003 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 <string.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <errno.h>
26 #include <math.h>
27
28 /* Include only the enabled headers since some compilers (namely, Sun
29 Studio) will not omit unused inline functions and create undefined
30 references to libraries that are not being built. */
31
32 #include "config.h"
33 #include "libavformat/avformat.h"
34 #include "libswscale/swscale.h"
35 #include "libswresample/swresample.h"
36 #include "libavutil/avassert.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/bprint.h"
39 #include "libavutil/display.h"
40 #include "libavutil/getenv_utf8.h"
41 #include "libavutil/mem.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/eval.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/opt.h"
46 #include "cmdutils.h"
47 #include "fopen_utf8.h"
48 #include "opt_common.h"
49 #ifdef _WIN32
50 #include <windows.h>
51 #include "compat/w32dlfcn.h"
52 #endif
53
54 AVDictionary *sws_dict;
55 AVDictionary *swr_opts;
56 AVDictionary *format_opts, *codec_opts;
57
58 int hide_banner = 0;
59
60 18115 void uninit_opts(void)
61 {
62 18115 av_dict_free(&swr_opts);
63 18115 av_dict_free(&sws_dict);
64 18115 av_dict_free(&format_opts);
65 18115 av_dict_free(&codec_opts);
66 18115 }
67
68 ✗ void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
69 {
70 ✗ vfprintf(stdout, fmt, vl);
71 ✗ }
72
73 9213 void init_dynload(void)
74 {
75 #if HAVE_SETDLLDIRECTORY && defined(_WIN32)
76 /* Calling SetDllDirectory with the empty string (but not NULL) removes the
77 * current working directory from the DLL search path as a security pre-caution. */
78 SetDllDirectory("");
79 #endif
80 9213 }
81
82 40539 int parse_number(const char *context, const char *numstr, enum OptionType type,
83 double min, double max, double *dst)
84 {
85 char *tail;
86 const char *error;
87 40539 double d = av_strtod(numstr, &tail);
88
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40539 times.
 40539 if (*tail)
89 ✗ error = "Expected number for %s but found: %s\n";
90
2/4
✓ Branch 0 taken 40539 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 40539 times.
 40539 else if (d < min || d > max)
91 ✗ error = "The value for %s was %s which is not within %f - %f\n";
92
3/4
✓ Branch 0 taken 40230 times.
✓ Branch 1 taken 309 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 40230 times.
 40539 else if (type == OPT_TYPE_INT64 && (int64_t)d != d)
93 ✗ error = "Expected int64 for %s but found %s\n";
94
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 40539 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 40539 else if (type == OPT_TYPE_INT && (int)d != d)
95 ✗ error = "Expected int for %s but found %s\n";
96 else {
97 40539 *dst = d;
98 40539 return 0;
99 }
100
101 ✗ av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
102 ✗ return AVERROR(EINVAL);
103 }
104
105 ✗ void show_help_options(const OptionDef *options, const char *msg, int req_flags,
106 int rej_flags)
107 {
108 const OptionDef *po;
109 int first;
110
111 ✗ first = 1;
112 ✗ for (po = options; po->name; po++) {
113 char buf[128];
114
115 ✗ if (((po->flags & req_flags) != req_flags) ||
116 ✗ (po->flags & rej_flags))
117 ✗ continue;
118
119 ✗ if (first) {
120 ✗ printf("%s\n", msg);
121 ✗ first = 0;
122 }
123 ✗ av_strlcpy(buf, po->name, sizeof(buf));
124
125 ✗ if (po->flags & OPT_FLAG_PERSTREAM)
126 ✗ av_strlcat(buf, "[:<stream_spec>]", sizeof(buf));
127 ✗ else if (po->flags & OPT_FLAG_SPEC)
128 ✗ av_strlcat(buf, "[:<spec>]", sizeof(buf));
129
130 ✗ if (po->argname)
131 ✗ av_strlcatf(buf, sizeof(buf), " <%s>", po->argname);
132
133 ✗ printf("-%-17s %s\n", buf, po->help);
134 }
135 ✗ printf("\n");
136 ✗ }
137
138 ✗ void show_help_children(const AVClass *class, int flags)
139 {
140 ✗ void *iter = NULL;
141 const AVClass *child;
142 ✗ if (class->option) {
143 ✗ av_opt_show2(&class, NULL, flags, 0);
144 ✗ printf("\n");
145 }
146
147 ✗ while (child = av_opt_child_class_iterate(class, &iter))
148 ✗ show_help_children(child, flags);
149 ✗ }
150
151 1365612 static const OptionDef *find_option(const OptionDef *po, const char *name)
152 {
153
2/2
✓ Branch 0 taken 402 times.
✓ Branch 1 taken 1365210 times.
 1365612 if (*name == '/')
154 402 name++;
155
156
2/2
✓ Branch 0 taken 202287172 times.
✓ Branch 1 taken 777365 times.
 203064537 while (po->name) {
157 const char *end;
158
6/6
✓ Branch 1 taken 1388520 times.
✓ Branch 2 taken 200898652 times.
✓ Branch 3 taken 854622 times.
✓ Branch 4 taken 533898 times.
✓ Branch 5 taken 800273 times.
✓ Branch 6 taken 54349 times.
 202287172 if (av_strstart(name, po->name, &end) && (!*end || *end == ':'))
159 break;
160 201698925 po++;
161 }
162 1365612 return po;
163 }
164
165 /* _WIN32 means using the windows libc - cygwin doesn't define that
166 * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
167 * it doesn't provide the actual command line via GetCommandLineW(). */
168 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
169 #include <shellapi.h>
170 /* Will be leaked on exit */
171 static char** win32_argv_utf8 = NULL;
172 static int win32_argc = 0;
173
174 /**
175 * Prepare command line arguments for executable.
176 * For Windows - perform wide-char to UTF-8 conversion.
177 * Input arguments should be main() function arguments.
178 * @param argc_ptr Arguments number (including executable)
179 * @param argv_ptr Arguments list.
180 */
181 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
182 {
183 char *argstr_flat;
184 wchar_t **argv_w;
185 int i, buffsize = 0, offset = 0;
186
187 if (win32_argv_utf8) {
188 *argc_ptr = win32_argc;
189 *argv_ptr = win32_argv_utf8;
190 return;
191 }
192
193 win32_argc = 0;
194 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
195 if (win32_argc <= 0 || !argv_w)
196 return;
197
198 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
199 for (i = 0; i < win32_argc; i++)
200 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
201 NULL, 0, NULL, NULL);
202
203 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
204 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
205 if (!win32_argv_utf8) {
206 LocalFree(argv_w);
207 return;
208 }
209
210 for (i = 0; i < win32_argc; i++) {
211 win32_argv_utf8[i] = &argstr_flat[offset];
212 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
213 &argstr_flat[offset],
214 buffsize - offset, NULL, NULL);
215 }
216 win32_argv_utf8[i] = NULL;
217 LocalFree(argv_w);
218
219 *argc_ptr = win32_argc;
220 *argv_ptr = win32_argv_utf8;
221 }
222 #else
223 9213 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
224 {
225 /* nothing to do */
226 9213 }
227 #endif /* HAVE_COMMANDLINETOARGVW */
228
229 570175 static int opt_has_arg(const OptionDef *o)
230 {
231
2/2
✓ Branch 0 taken 181218 times.
✓ Branch 1 taken 388957 times.
 570175 if (o->type == OPT_TYPE_BOOL)
232 181218 return 0;
233
2/2
✓ Branch 0 taken 136912 times.
✓ Branch 1 taken 252045 times.
 388957 if (o->type == OPT_TYPE_FUNC)
234 136912 return !!(o->flags & OPT_FUNC_ARG);
235 252045 return 1;
236 }
237
238 106126 static int write_option(void *optctx, const OptionDef *po, const char *opt,
239 const char *arg, const OptionDef *defs)
240 {
241 /* new-style options contain an offset into optctx, old-style address of
242 * a global var*/
243 212252 void *dst = po->flags & OPT_FLAG_OFFSET ?
244
2/2
✓ Branch 0 taken 50881 times.
✓ Branch 1 taken 55245 times.
 106126 (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
245 106126 char *arg_allocated = NULL;
246
247 106126 enum OptionType so_type = po->type;
248
249 106126 SpecifierOptList *sol = NULL;
250 double num;
251 106126 int ret = 0;
252
253
2/2
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 106059 times.
 106126 if (*opt == '/') {
254 67 opt++;
255
256
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 67 times.
 67 if (!opt_has_arg(po)) {
257 ✗ av_log(NULL, AV_LOG_FATAL,
258 "Requested to load an argument from file for an option '%s'"
259 " which does not take an argument\n",
260 ✗ po->name);
261 ✗ return AVERROR(EINVAL);
262 }
263
264 67 arg_allocated = read_file_to_string(arg);
265
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 67 times.
 67 if (!arg_allocated) {
266 ✗ av_log(NULL, AV_LOG_FATAL,
267 "Error reading the value for option '%s' from file: %s\n",
268 opt, arg);
269 ✗ return AVERROR(EINVAL);
270 }
271
272 67 arg = arg_allocated;
273 }
274
275
2/2
✓ Branch 0 taken 34333 times.
✓ Branch 1 taken 71793 times.
 106126 if (po->flags & OPT_FLAG_SPEC) {
276 34333 const char *p = strchr(opt, ':');
277 char *str;
278
279 34333 sol = dst;
280 34333 ret = GROW_ARRAY(sol->opt, sol->nb_opt);
281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34333 times.
 34333 if (ret < 0)
282 ✗ goto finish;
283
284
2/2
✓ Branch 0 taken 17032 times.
✓ Branch 1 taken 17301 times.
 34333 str = av_strdup(p ? p + 1 : "");
285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34333 times.
 34333 if (!str) {
286 ✗ ret = AVERROR(ENOMEM);
287 ✗ goto finish;
288 }
289 34333 sol->opt[sol->nb_opt - 1].specifier = str;
290
291
2/2
✓ Branch 0 taken 34005 times.
✓ Branch 1 taken 328 times.
 34333 if (po->flags & OPT_FLAG_PERSTREAM) {
292 34005 ret = stream_specifier_parse(&sol->opt[sol->nb_opt - 1].stream_spec,
293 str, 0, NULL);
294
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34005 times.
 34005 if (ret < 0)
295 ✗ goto finish;
296 }
297
298 34333 dst = &sol->opt[sol->nb_opt - 1].u;
299 }
300
301
2/2
✓ Branch 0 taken 41263 times.
✓ Branch 1 taken 64863 times.
 106126 if (po->type == OPT_TYPE_STRING) {
302 char *str;
303
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 41236 times.
 41263 if (arg_allocated) {
304 27 str = arg_allocated;
305 27 arg_allocated = NULL;
306 } else
307 41236 str = av_strdup(arg);
308 41263 av_freep(dst);
309
310
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41263 times.
 41263 if (!str) {
311 ✗ ret = AVERROR(ENOMEM);
312 ✗ goto finish;
313 }
314
315 41263 *(char **)dst = str;
316
4/4
✓ Branch 0 taken 30252 times.
✓ Branch 1 taken 34611 times.
✓ Branch 2 taken 151 times.
✓ Branch 3 taken 30101 times.
 64863 } else if (po->type == OPT_TYPE_BOOL || po->type == OPT_TYPE_INT) {
317 34762 ret = parse_number(opt, arg, OPT_TYPE_INT64, INT_MIN, INT_MAX, &num);
318
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34762 times.
 34762 if (ret < 0)
319 ✗ goto finish;
320
321 34762 *(int *)dst = num;
322 34762 so_type = OPT_TYPE_INT;
323
2/2
✓ Branch 0 taken 5468 times.
✓ Branch 1 taken 24633 times.
 30101 } else if (po->type == OPT_TYPE_INT64) {
324 5468 ret = parse_number(opt, arg, OPT_TYPE_INT64, INT64_MIN, (double)INT64_MAX, &num);
325
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5468 times.
 5468 if (ret < 0)
326 ✗ goto finish;
327
328 5468 *(int64_t *)dst = num;
329
2/2
✓ Branch 0 taken 1392 times.
✓ Branch 1 taken 23241 times.
 24633 } else if (po->type == OPT_TYPE_TIME) {
330 1392 ret = av_parse_time(dst, arg, 1);
331
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1392 times.
 1392 if (ret < 0) {
332 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid duration for option %s: %s\n",
333 opt, arg);
334 ✗ goto finish;
335 }
336 1392 so_type = OPT_TYPE_INT64;
337
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 23236 times.
 23241 } else if (po->type == OPT_TYPE_FLOAT) {
338 5 ret = parse_number(opt, arg, OPT_TYPE_FLOAT, -INFINITY, INFINITY, &num);
339
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (ret < 0)
340 ✗ goto finish;
341
342 5 *(float *)dst = num;
343
2/2
✓ Branch 0 taken 304 times.
✓ Branch 1 taken 22932 times.
 23236 } else if (po->type == OPT_TYPE_DOUBLE) {
344 304 ret = parse_number(opt, arg, OPT_TYPE_DOUBLE, -INFINITY, INFINITY, &num);
345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 304 times.
 304 if (ret < 0)
346 ✗ goto finish;
347
348 304 *(double *)dst = num;
349 } else {
350
2/4
✓ Branch 0 taken 22932 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22932 times.
 22932 av_assert0(po->type == OPT_TYPE_FUNC && po->u.func_arg);
351
352 22932 ret = po->u.func_arg(optctx, opt, arg);
353
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22932 times.
 22932 if (ret < 0) {
354 ✗ if ((strcmp(opt, "init_hw_device") != 0) || (strcmp(arg, "list") != 0)) {
355 ✗ av_log(NULL, AV_LOG_ERROR,
356 "Failed to set value '%s' for option '%s': %s\n",
357 ✗ arg, opt, av_err2str(ret));
358 }
359 ✗ goto finish;
360 }
361 }
362
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 106124 times.
 106126 if (po->flags & OPT_EXIT) {
363 2 ret = AVERROR_EXIT;
364 2 goto finish;
365 }
366
367
2/2
✓ Branch 0 taken 71791 times.
✓ Branch 1 taken 34333 times.
 106124 if (sol) {
368 34333 sol->type = so_type;
369
2/2
✓ Branch 0 taken 2843 times.
✓ Branch 1 taken 31490 times.
 37176 sol->opt_canon = (po->flags & OPT_HAS_CANON) ?
370 2843 find_option(defs, po->u1.name_canon) : po;
371 }
372
373 71791 finish:
374 106126 av_freep(&arg_allocated);
375 106126 return ret;
376 }
377
378 11080 int parse_option(void *optctx, const char *opt, const char *arg,
379 const OptionDef *options)
380 {
381 static const OptionDef opt_avoptions = {
382 .name = "AVOption passthrough",
383 .type = OPT_TYPE_FUNC,
384 .flags = OPT_FUNC_ARG,
385 .u.func_arg = opt_default,
386 };
387
388 const OptionDef *po;
389 int ret;
390
391 11080 po = find_option(options, opt);
392
5/6
✓ Branch 0 taken 254 times.
✓ Branch 1 taken 10826 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 253 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 11080 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
393 /* handle 'no' bool option */
394 1 po = find_option(options, opt + 2);
395
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 if ((po->name && po->type == OPT_TYPE_BOOL))
396 1 arg = "0";
397
2/2
✓ Branch 0 taken 292 times.
✓ Branch 1 taken 10787 times.
 11079 } else if (po->type == OPT_TYPE_BOOL)
398 292 arg = "1";
399
400
2/2
✓ Branch 0 taken 253 times.
✓ Branch 1 taken 10827 times.
 11080 if (!po->name)
401 253 po = &opt_avoptions;
402
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11080 times.
 11080 if (!po->name) {
403 ✗ av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
404 ✗ return AVERROR(EINVAL);
405 }
406
3/4
✓ Branch 1 taken 10635 times.
✓ Branch 2 taken 445 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10635 times.
 11080 if (opt_has_arg(po) && !arg) {
407 ✗ av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
408 ✗ return AVERROR(EINVAL);
409 }
410
411 11080 ret = write_option(optctx, po, opt, arg, options);
412
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11080 times.
 11080 if (ret < 0)
413 ✗ return ret;
414
415 11080 return opt_has_arg(po);
416 }
417
418 311 int parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
419 int (*parse_arg_function)(void *, const char*))
420 {
421 const char *opt;
422 311 int optindex, handleoptions = 1, ret;
423
424 /* perform system-dependent conversions for arguments list */
425 311 prepare_app_arguments(&argc, &argv);
426
427 /* parse options */
428 311 optindex = 1;
429
2/2
✓ Branch 0 taken 1552 times.
✓ Branch 1 taken 311 times.
 1863 while (optindex < argc) {
430 1552 opt = argv[optindex++];
431
432
4/6
✓ Branch 0 taken 1552 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1256 times.
✓ Branch 3 taken 296 times.
✓ Branch 4 taken 1256 times.
✗ Branch 5 not taken.
 1552 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
433
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1256 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1256 if (opt[1] == '-' && opt[2] == '\0') {
434 ✗ handleoptions = 0;
435 ✗ continue;
436 }
437 1256 opt++;
438
439
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1256 times.
 1256 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
440 ✗ return ret;
441 1256 optindex += ret;
442 } else {
443
1/2
✓ Branch 0 taken 296 times.
✗ Branch 1 not taken.
 296 if (parse_arg_function) {
444 296 ret = parse_arg_function(optctx, opt);
445
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 296 times.
 296 if (ret < 0)
446 ✗ return ret;
447 }
448 }
449 }
450
451 311 return 0;
452 }
453
454 25572 int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs)
455 {
456 int i, ret;
457
458 25572 av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
459 25572 g->group_def->name, g->arg);
460
461
2/2
✓ Branch 0 taken 95046 times.
✓ Branch 1 taken 25570 times.
 120616 for (i = 0; i < g->nb_opts; i++) {
462 95046 Option *o = &g->opts[i];
463
464
2/2
✓ Branch 0 taken 51593 times.
✓ Branch 1 taken 43453 times.
 95046 if (g->group_def->flags &&
465
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51593 times.
 51593 !(g->group_def->flags & o->opt->flags)) {
466 ✗ av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
467 "%s %s -- you are trying to apply an input option to an "
468 "output file or vice versa. Move this option before the "
469 ✗ "file it belongs to.\n", o->key, o->opt->help,
470 ✗ g->group_def->name, g->arg);
471 ✗ return AVERROR(EINVAL);
472 }
473
474 95046 av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
475 95046 o->key, o->opt->help, o->val);
476
477 95046 ret = write_option(optctx, o->opt, o->key, o->val, defs);
478
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 95044 times.
 95046 if (ret < 0)
479 2 return ret;
480 }
481
482 25570 av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
483
484 25570 return 0;
485 }
486
487 46023 int locate_option(int argc, char **argv, const OptionDef *options,
488 const char *optname)
489 {
490 const OptionDef *po;
491 int i;
492
493
2/2
✓ Branch 0 taken 1047127 times.
✓ Branch 1 taken 45893 times.
 1093020 for (i = 1; i < argc; i++) {
494 1047127 const char *cur_opt = argv[i];
495
496
4/4
✓ Branch 0 taken 1016066 times.
✓ Branch 1 taken 31061 times.
✓ Branch 2 taken 14794 times.
✓ Branch 3 taken 1001272 times.
 1047127 if (!(cur_opt[0] == '-' && cur_opt[1]))
497 45855 continue;
498 1001272 cur_opt++;
499
500 1001272 po = find_option(options, cur_opt);
501
5/6
✓ Branch 0 taken 654190 times.
✓ Branch 1 taken 347082 times.
✓ Branch 2 taken 132486 times.
✓ Branch 3 taken 521704 times.
✓ Branch 4 taken 132486 times.
✗ Branch 5 not taken.
 1001272 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
502 132486 po = find_option(options, cur_opt + 2);
503
504
3/4
✓ Branch 0 taken 521744 times.
✓ Branch 1 taken 479528 times.
✓ Branch 2 taken 521744 times.
✗ Branch 3 not taken.
 1001272 if ((!po->name && !strcmp(cur_opt, optname)) ||
505
4/4
✓ Branch 0 taken 479528 times.
✓ Branch 1 taken 521744 times.
✓ Branch 2 taken 130 times.
✓ Branch 3 taken 479398 times.
 1001272 (po->name && !strcmp(optname, po->name)))
506 130 return i;
507
508
4/4
✓ Branch 0 taken 479398 times.
✓ Branch 1 taken 521744 times.
✓ Branch 3 taken 305819 times.
✓ Branch 4 taken 173579 times.
 1001142 if (!po->name || opt_has_arg(po))
509 827563 i++;
510 }
511 45893 return 0;
512 }
513
514 ✗ static void dump_argument(FILE *report_file, const char *a)
515 {
516 const unsigned char *p;
517
518 ✗ for (p = a; *p; p++)
519 ✗ if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
520 ✗ *p == '_' || (*p >= 'a' && *p <= 'z')))
521 break;
522 ✗ if (!*p) {
523 ✗ fputs(a, report_file);
524 ✗ return;
525 }
526 ✗ fputc('"', report_file);
527 ✗ for (p = a; *p; p++) {
528 ✗ if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
529 ✗ fprintf(report_file, "\\%c", *p);
530 ✗ else if (*p < ' ' || *p > '~')
531 ✗ fprintf(report_file, "\\x%02x", *p);
532 else
533 ✗ fputc(*p, report_file);
534 }
535 ✗ fputc('"', report_file);
536 }
537
538 9213 static void check_options(const OptionDef *po)
539 {
540
2/2
✓ Branch 0 taken 1767806 times.
✓ Branch 1 taken 9213 times.
 1777019 while (po->name) {
541
2/2
✓ Branch 0 taken 1094946 times.
✓ Branch 1 taken 672860 times.
 1767806 if (po->flags & OPT_PERFILE)
542
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1094946 times.
 1094946 av_assert0(po->flags & (OPT_INPUT | OPT_OUTPUT | OPT_DECODER));
543
544
2/2
✓ Branch 0 taken 657738 times.
✓ Branch 1 taken 1110068 times.
 1767806 if (po->type == OPT_TYPE_FUNC)
545
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 657738 times.
 657738 av_assert0(!(po->flags & (OPT_FLAG_OFFSET | OPT_FLAG_SPEC)));
546
547 // OPT_FUNC_ARG can only be ser for OPT_TYPE_FUNC
548
3/4
✓ Branch 0 taken 1110068 times.
✓ Branch 1 taken 657738 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1110068 times.
 1767806 av_assert0((po->type == OPT_TYPE_FUNC) || !(po->flags & OPT_FUNC_ARG));
549
550 1767806 po++;
551 }
552 9213 }
553
554 9213 void parse_loglevel(int argc, char **argv, const OptionDef *options)
555 {
556 int idx;
557 char *env;
558
559 9213 check_options(options);
560
561 9213 idx = locate_option(argc, argv, options, "loglevel");
562
2/2
✓ Branch 0 taken 9171 times.
✓ Branch 1 taken 42 times.
 9213 if (!idx)
563 9171 idx = locate_option(argc, argv, options, "v");
564
3/4
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 9120 times.
✓ Branch 2 taken 93 times.
✗ Branch 3 not taken.
 9213 if (idx && argv[idx + 1])
565 93 opt_loglevel(NULL, "loglevel", argv[idx + 1]);
566 9213 idx = locate_option(argc, argv, options, "report");
567 9213 env = getenv_utf8("FFREPORT");
568
2/4
✓ Branch 0 taken 9213 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9213 times.
 9213 if (env || idx) {
569 ✗ FILE *report_file = NULL;
570 ✗ init_report(env, &report_file);
571 ✗ if (report_file) {
572 int i;
573 ✗ fprintf(report_file, "Command line:\n");
574 ✗ for (i = 0; i < argc; i++) {
575 ✗ dump_argument(report_file, argv[i]);
576 ✗ fputc(i < argc - 1 ? ' ' : '\n', report_file);
577 }
578 ✗ fflush(report_file);
579 }
580 }
581 9213 freeenv_utf8(env);
582 9213 idx = locate_option(argc, argv, options, "hide_banner");
583
2/2
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 9176 times.
 9213 if (idx)
584 37 hide_banner = 1;
585 9213 }
586
587 331810 static const AVOption *opt_find(void *obj, const char *name, const char *unit,
588 int opt_flags, int search_flags)
589 {
590 331810 const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
591
4/4
✓ Branch 0 taken 96731 times.
✓ Branch 1 taken 235079 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 96725 times.
 331810 if(o && !o->flags)
592 6 return NULL;
593 331804 return o;
594 }
595
596 #define FLAGS ((o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0)
597 123134 int opt_default(void *optctx, const char *opt, const char *arg)
598 {
599 const AVOption *o;
600 123134 int consumed = 0;
601 char opt_stripped[128];
602 const char *p;
603 123134 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
604 #if CONFIG_SWSCALE
605 123134 const AVClass *sc = sws_get_class();
606 #endif
607 #if CONFIG_SWRESAMPLE
608 123134 const AVClass *swr_class = swr_get_class();
609 #endif
610
611
2/4
✓ Branch 0 taken 123134 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 123134 times.
 123134 if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
612 ✗ av_log_set_level(AV_LOG_DEBUG);
613
614
2/2
✓ Branch 0 taken 123122 times.
✓ Branch 1 taken 12 times.
 123134 if (!(p = strchr(opt, ':')))
615 123122 p = opt + strlen(opt);
616 123134 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
617
618
2/2
✓ Branch 1 taken 59111 times.
✓ Branch 2 taken 64023 times.
 123134 if ((o = opt_find(&cc, opt_stripped, NULL, 0,
619 59111 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
620
8/8
✓ Branch 0 taken 59105 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 59092 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 16280 times.
✓ Branch 5 taken 42812 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 16298 times.
 75410 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
621 16299 (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
622
5/6
✓ Branch 0 taken 23564 times.
✓ Branch 1 taken 40460 times.
✓ Branch 2 taken 23564 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16210 times.
✓ Branch 5 taken 7354 times.
 64024 av_dict_set(&codec_opts, opt, arg, FLAGS);
623 64024 consumed = 1;
624 }
625
2/2
✓ Branch 1 taken 16452 times.
✓ Branch 2 taken 106682 times.
 123134 if ((o = opt_find(&fc, opt, NULL, 0,
626 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
627
5/6
✓ Branch 0 taken 16100 times.
✓ Branch 1 taken 352 times.
✓ Branch 2 taken 16100 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16082 times.
✓ Branch 5 taken 18 times.
 16452 av_dict_set(&format_opts, opt, arg, FLAGS);
628
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 16364 times.
 16452 if (consumed)
629 88 av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
630 16452 consumed = 1;
631 }
632 #if CONFIG_SWSCALE
633
4/4
✓ Branch 0 taken 42746 times.
✓ Branch 1 taken 80388 times.
✓ Branch 3 taken 16249 times.
✓ Branch 4 taken 26497 times.
 123134 if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
634 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
635
2/4
✓ Branch 0 taken 16249 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16249 times.
✗ Branch 3 not taken.
 16249 if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
636
2/4
✓ Branch 0 taken 16249 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16249 times.
✗ Branch 3 not taken.
 16249 !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
637
2/4
✓ Branch 0 taken 16249 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16249 times.
 16249 !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
638 ✗ av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
639 ✗ return AVERROR(EINVAL);
640 }
641
4/6
✓ Branch 0 taken 16249 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16249 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16034 times.
✓ Branch 5 taken 215 times.
 16249 av_dict_set(&sws_dict, opt, arg, FLAGS);
642
643 16249 consumed = 1;
644 }
645 #else
646 if (!consumed && !strcmp(opt, "sws_flags")) {
647 av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
648 consumed = 1;
649 }
650 #endif
651 #if CONFIG_SWRESAMPLE
652
3/4
✓ Branch 0 taken 26497 times.
✓ Branch 1 taken 96637 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 26497 times.
 123134 if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
653 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
654 ✗ av_dict_set(&swr_opts, opt, arg, FLAGS);
655 ✗ consumed = 1;
656 }
657 #endif
658
659
2/2
✓ Branch 0 taken 96637 times.
✓ Branch 1 taken 26497 times.
 123134 if (consumed)
660 96637 return 0;
661 26497 return AVERROR_OPTION_NOT_FOUND;
662 }
663
664 /*
665 * Check whether given option is a group separator.
666 *
667 * @return index of the group definition that matched or -1 if none
668 */
669 199200 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
670 const char *opt)
671 {
672 int i;
673
674
2/2
✓ Branch 0 taken 589834 times.
✓ Branch 1 taken 191433 times.
 781267 for (i = 0; i < nb_groups; i++) {
675 589834 const OptionGroupDef *p = &groups[i];
676
4/4
✓ Branch 0 taken 390634 times.
✓ Branch 1 taken 199200 times.
✓ Branch 2 taken 7767 times.
✓ Branch 3 taken 382867 times.
 589834 if (p->sep && !strcmp(p->sep, opt))
677 7767 return i;
678 }
679
680 191433 return -1;
681 }
682
683 /*
684 * Finish parsing an option group.
685 *
686 * @param group_idx which group definition should this group belong to
687 * @param arg argument of the group delimiting option
688 */
689 16672 static int finish_group(OptionParseContext *octx, int group_idx,
690 const char *arg)
691 {
692 16672 OptionGroupList *l = &octx->groups[group_idx];
693 OptionGroup *g;
694 int ret;
695
696 16672 ret = GROW_ARRAY(l->groups, l->nb_groups);
697
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16672 times.
 16672 if (ret < 0)
698 ✗ return ret;
699
700 16672 g = &l->groups[l->nb_groups - 1];
701
702 16672 *g = octx->cur_group;
703 16672 g->arg = arg;
704 16672 g->group_def = l->group_def;
705 16672 g->sws_dict = sws_dict;
706 16672 g->swr_opts = swr_opts;
707 16672 g->codec_opts = codec_opts;
708 16672 g->format_opts = format_opts;
709
710 16672 codec_opts = NULL;
711 16672 format_opts = NULL;
712 16672 sws_dict = NULL;
713 16672 swr_opts = NULL;
714
715 16672 memset(&octx->cur_group, 0, sizeof(octx->cur_group));
716
717 16672 return ret;
718 }
719
720 /*
721 * Add an option instance to currently parsed group.
722 */
723 95049 static int add_opt(OptionParseContext *octx, const OptionDef *opt,
724 const char *key, const char *val)
725 {
726 95049 int global = !(opt->flags & OPT_PERFILE);
727
2/2
✓ Branch 0 taken 43453 times.
✓ Branch 1 taken 51596 times.
 95049 OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
728 int ret;
729
730 95049 ret = GROW_ARRAY(g->opts, g->nb_opts);
731
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 95049 times.
 95049 if (ret < 0)
732 ✗ return ret;
733
734 95049 g->opts[g->nb_opts - 1].opt = opt;
735 95049 g->opts[g->nb_opts - 1].key = key;
736 95049 g->opts[g->nb_opts - 1].val = val;
737
738 95049 return 0;
739 }
740
741 8902 static int init_parse_context(OptionParseContext *octx,
742 const OptionGroupDef *groups, int nb_groups)
743 {
744 static const OptionGroupDef global_group = { "global" };
745 int i;
746
747 8902 memset(octx, 0, sizeof(*octx));
748
749 8902 octx->groups = av_calloc(nb_groups, sizeof(*octx->groups));
750
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8902 times.
 8902 if (!octx->groups)
751 ✗ return AVERROR(ENOMEM);
752 8902 octx->nb_groups = nb_groups;
753
754
2/2
✓ Branch 0 taken 26706 times.
✓ Branch 1 taken 8902 times.
 35608 for (i = 0; i < octx->nb_groups; i++)
755 26706 octx->groups[i].group_def = &groups[i];
756
757 8902 octx->global_opts.group_def = &global_group;
758 8902 octx->global_opts.arg = "";
759
760 8902 return 0;
761 }
762
763 8902 void uninit_parse_context(OptionParseContext *octx)
764 {
765 int i, j;
766
767
2/2
✓ Branch 0 taken 26706 times.
✓ Branch 1 taken 8902 times.
 35608 for (i = 0; i < octx->nb_groups; i++) {
768 26706 OptionGroupList *l = &octx->groups[i];
769
770
2/2
✓ Branch 0 taken 16672 times.
✓ Branch 1 taken 26706 times.
 43378 for (j = 0; j < l->nb_groups; j++) {
771 16672 av_freep(&l->groups[j].opts);
772 16672 av_dict_free(&l->groups[j].codec_opts);
773 16672 av_dict_free(&l->groups[j].format_opts);
774
775 16672 av_dict_free(&l->groups[j].sws_dict);
776 16672 av_dict_free(&l->groups[j].swr_opts);
777 }
778 26706 av_freep(&l->groups);
779 }
780 8902 av_freep(&octx->groups);
781
782 8902 av_freep(&octx->cur_group.opts);
783 8902 av_freep(&octx->global_opts.opts);
784
785 8902 uninit_opts();
786 8902 }
787
788 8902 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
789 const OptionDef *options,
790 const OptionGroupDef *groups, int nb_groups)
791 {
792 int ret;
793 8902 int optindex = 1;
794 8902 int dashdash = -2;
795
796 /* perform system-dependent conversions for arguments list */
797 8902 prepare_app_arguments(&argc, &argv);
798
799 8902 ret = init_parse_context(octx, groups, nb_groups);
800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8902 times.
 8902 if (ret < 0)
801 ✗ return ret;
802
803 8902 av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
804
805
2/2
✓ Branch 0 taken 208105 times.
✓ Branch 1 taken 8902 times.
 217007 while (optindex < argc) {
806 208105 const char *opt = argv[optindex++], *arg;
807 const OptionDef *po;
808 int group_idx;
809
810 208105 av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
811
812
3/6
✓ Branch 0 taken 202160 times.
✓ Branch 1 taken 5945 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 202160 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 208105 if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
813 ✗ dashdash = optindex;
814 ✗ continue;
815 }
816 /* unnamed group separators, e.g. output filename */
817
5/6
✓ Branch 0 taken 202160 times.
✓ Branch 1 taken 5945 times.
✓ Branch 2 taken 199200 times.
✓ Branch 3 taken 2960 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 199200 times.
 208105 if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
818 8905 ret = finish_group(octx, 0, opt);
819
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8905 times.
 8905 if (ret < 0)
820 ✗ return ret;
821
822 8905 av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
823 8905 continue;
824 }
825 199200 opt++;
826
827 #define GET_ARG(arg) \
828 do { \
829 arg = argv[optindex++]; \
830 if (!arg) { \
831 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
832 return AVERROR(EINVAL); \
833 } \
834 } while (0)
835
836 /* named group separators, e.g. -i */
837 199200 group_idx = match_group_separator(groups, nb_groups, opt);
838
2/2
✓ Branch 0 taken 7767 times.
✓ Branch 1 taken 191433 times.
 199200 if (group_idx >= 0) {
839
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7767 times.
 7767 GET_ARG(arg);
840 7767 ret = finish_group(octx, group_idx, arg);
841
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7767 times.
 7767 if (ret < 0)
842 ✗ return ret;
843
844 7767 av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
845 7767 groups[group_idx].name, arg);
846 7767 continue;
847 }
848
849 /* normal options */
850 191433 po = find_option(options, opt);
851
2/2
✓ Branch 0 taken 68552 times.
✓ Branch 1 taken 122881 times.
 191433 if (po->name) {
852
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 68550 times.
 68552 if (po->flags & OPT_EXIT) {
853 /* optional argument, e.g. -h */
854 2 arg = argv[optindex++];
855
2/2
✓ Branch 1 taken 60729 times.
✓ Branch 2 taken 7821 times.
 68550 } else if (opt_has_arg(po)) {
856
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60729 times.
 60729 GET_ARG(arg);
857 } else {
858 7821 arg = "1";
859 }
860
861 68552 ret = add_opt(octx, po, opt, arg);
862
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68552 times.
 68552 if (ret < 0)
863 ✗ return ret;
864
865 68552 av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
866 68552 "argument '%s'.\n", po->name, po->help, arg);
867 68552 continue;
868 }
869
870 /* AVOptions */
871
1/2
✓ Branch 0 taken 122881 times.
✗ Branch 1 not taken.
 122881 if (argv[optindex]) {
872 122881 ret = opt_default(NULL, opt, argv[optindex]);
873
2/2
✓ Branch 0 taken 96384 times.
✓ Branch 1 taken 26497 times.
 122881 if (ret >= 0) {
874 96384 av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
875 96384 "argument '%s'.\n", opt, argv[optindex]);
876 96384 optindex++;
877 96384 continue;
878
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26497 times.
 26497 } else if (ret != AVERROR_OPTION_NOT_FOUND) {
879 ✗ av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
880 ✗ "with argument '%s'.\n", opt, argv[optindex]);
881 ✗ return ret;
882 }
883 }
884
885 /* boolean -nofoo options */
886
3/6
✓ Branch 0 taken 26497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26497 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 26497 times.
✗ Branch 5 not taken.
 52994 if (opt[0] == 'n' && opt[1] == 'o' &&
887 26497 (po = find_option(options, opt + 2)) &&
888
2/4
✓ Branch 0 taken 26497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26497 times.
✗ Branch 3 not taken.
 26497 po->name && po->type == OPT_TYPE_BOOL) {
889 26497 ret = add_opt(octx, po, opt, "0");
890
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26497 times.
 26497 if (ret < 0)
891 ✗ return ret;
892
893 26497 av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
894 26497 "argument 0.\n", po->name, po->help);
895 26497 continue;
896 }
897
898 ✗ av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
899 ✗ return AVERROR_OPTION_NOT_FOUND;
900 }
901
902
3/6
✓ Branch 0 taken 8902 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8902 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8902 times.
 8902 if (octx->cur_group.nb_opts || codec_opts || format_opts)
903 ✗ av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
904 "command: may be ignored.\n");
905
906 8902 av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
907
908 8902 return 0;
909 }
910
911 ✗ int read_yesno(void)
912 {
913 ✗ int c = getchar();
914 ✗ int yesno = (av_toupper(c) == 'Y');
915
916 ✗ while (c != '\n' && c != EOF)
917 ✗ c = getchar();
918
919 ✗ return yesno;
920 }
921
922 ✗ FILE *get_preset_file(char *filename, size_t filename_size,
923 const char *preset_name, int is_path,
924 const char *codec_name)
925 {
926 ✗ FILE *f = NULL;
927 int i;
928 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
929 char *datadir = NULL;
930 #endif
931 ✗ char *env_home = getenv_utf8("HOME");
932 ✗ char *env_ffmpeg_datadir = getenv_utf8("FFMPEG_DATADIR");
933 ✗ const char *base[3] = { env_ffmpeg_datadir,
934 env_home, /* index=1(HOME) is special: search in a .ffmpeg subfolder */
935 FFMPEG_DATADIR, };
936
937 ✗ if (is_path) {
938 ✗ av_strlcpy(filename, preset_name, filename_size);
939 ✗ f = fopen_utf8(filename, "r");
940 } else {
941 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
942 wchar_t *datadir_w = get_module_filename(NULL);
943 base[2] = NULL;
944
945 if (wchartoutf8(datadir_w, &datadir))
946 datadir = NULL;
947 av_free(datadir_w);
948
949 if (datadir)
950 {
951 char *ls;
952 for (ls = datadir; *ls; ls++)
953 if (*ls == '\\') *ls = '/';
954
955 if (ls = strrchr(datadir, '/'))
956 {
957 ptrdiff_t datadir_len = ls - datadir;
958 size_t desired_size = datadir_len + strlen("/ffpresets") + 1;
959 char *new_datadir = av_realloc_array(
960 datadir, desired_size, sizeof *datadir);
961 if (new_datadir) {
962 datadir = new_datadir;
963 strcpy(datadir + datadir_len, "/ffpresets");
964 base[2] = datadir;
965 }
966 }
967 }
968 #endif
969 ✗ for (i = 0; i < 3 && !f; i++) {
970 ✗ if (!base[i])
971 ✗ continue;
972 ✗ snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
973 i != 1 ? "" : "/.ffmpeg", preset_name);
974 ✗ f = fopen_utf8(filename, "r");
975 ✗ if (!f && codec_name) {
976 ✗ snprintf(filename, filename_size,
977 "%s%s/%s-%s.ffpreset",
978 base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
979 preset_name);
980 ✗ f = fopen_utf8(filename, "r");
981 }
982 }
983 }
984
985 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
986 av_free(datadir);
987 #endif
988 ✗ freeenv_utf8(env_ffmpeg_datadir);
989 ✗ freeenv_utf8(env_home);
990 ✗ return f;
991 }
992
993 17829 int cmdutils_isalnum(char c)
994 {
995
4/4
✓ Branch 0 taken 318 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 52 times.
✓ Branch 3 taken 17776 times.
 17829 return (c >= '0' && c <= '9') ||
996
5/6
✓ Branch 0 taken 319 times.
✓ Branch 1 taken 17510 times.
✓ Branch 2 taken 52 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 49 times.
✓ Branch 5 taken 17779 times.
 35707 (c >= 'A' && c <= 'Z') ||
997
1/2
✓ Branch 0 taken 49 times.
✗ Branch 1 not taken.
 49 (c >= 'a' && c <= 'z');
998 }
999
1000 35347 void stream_specifier_uninit(StreamSpecifier *ss)
1001 {
1002 35347 av_freep(&ss->meta_key);
1003 35347 av_freep(&ss->meta_val);
1004 35347 av_freep(&ss->remainder);
1005
1006 35347 memset(ss, 0, sizeof(*ss));
1007 35347 }
1008
1009 35340 int stream_specifier_parse(StreamSpecifier *ss, const char *spec,
1010 int allow_remainder, void *logctx)
1011 {
1012 char *endptr;
1013 int ret;
1014
1015 35340 memset(ss, 0, sizeof(*ss));
1016
1017 35340 ss->idx = -1;
1018 35340 ss->media_type = AVMEDIA_TYPE_UNKNOWN;
1019 35340 ss->stream_list = STREAM_LIST_ALL;
1020
1021 35340 av_log(logctx, AV_LOG_TRACE, "Parsing stream specifier: %s\n", spec);
1022
1023
2/2
✓ Branch 0 taken 18451 times.
✓ Branch 1 taken 34714 times.
 88505 while (*spec) {
1024
3/4
✓ Branch 0 taken 530 times.
✓ Branch 1 taken 17921 times.
✓ Branch 2 taken 530 times.
✗ Branch 3 not taken.
 18451 if (*spec <= '9' && *spec >= '0') { /* opt:index */
1025 530 ss->idx = strtol(spec, &endptr, 0);
1026
1027
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 530 times.
 530 av_assert0(endptr > spec);
1028 530 spec = endptr;
1029
1030 530 av_log(logctx, AV_LOG_TRACE,
1031 "Parsed index: %d; remainder: %s\n", ss->idx, spec);
1032
1033 // this terminates the specifier
1034 530 break;
1035
6/6
✓ Branch 0 taken 2105 times.
✓ Branch 1 taken 15816 times.
✓ Branch 2 taken 184 times.
✓ Branch 3 taken 1921 times.
✓ Branch 4 taken 129 times.
✓ Branch 5 taken 55 times.
 17921 } else if ((*spec == 'v' || *spec == 'a' || *spec == 's' ||
1036
7/8
✓ Branch 0 taken 126 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 123 times.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 123 times.
✓ Branch 6 taken 17774 times.
✓ Branch 7 taken 24 times.
 17927 *spec == 'd' || *spec == 't' || *spec == 'V') &&
1037 17798 !cmdutils_isalnum(*(spec + 1))) { /* opt:[vasdtV] */
1038
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17774 times.
 17774 if (ss->media_type != AVMEDIA_TYPE_UNKNOWN) {
1039 ✗ av_log(logctx, AV_LOG_ERROR, "Stream type specified multiple times\n");
1040 ✗ ret = AVERROR(EINVAL);
1041 ✗ goto fail;
1042 }
1043
1044
5/7
✓ Branch 0 taken 15801 times.
✓ Branch 1 taken 1915 times.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 17774 switch (*spec++) {
1045 15801 case 'v': ss->media_type = AVMEDIA_TYPE_VIDEO; break;
1046 1915 case 'a': ss->media_type = AVMEDIA_TYPE_AUDIO; break;
1047 53 case 's': ss->media_type = AVMEDIA_TYPE_SUBTITLE; break;
1048 2 case 'd': ss->media_type = AVMEDIA_TYPE_DATA; break;
1049 3 case 't': ss->media_type = AVMEDIA_TYPE_ATTACHMENT; break;
1050 ✗ case 'V': ss->media_type = AVMEDIA_TYPE_VIDEO;
1051 ✗ ss->no_apic = 1; break;
1052 ✗ default: av_assert0(0);
1053 }
1054
1055 17774 av_log(logctx, AV_LOG_TRACE, "Parsed media type: %s; remainder: %s\n",
1056 av_get_media_type_string(ss->media_type), spec);
1057
3/4
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 97 times.
✓ Branch 2 taken 50 times.
✗ Branch 3 not taken.
 147 } else if (*spec == 'g' && *(spec + 1) == ':') {
1058
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (ss->stream_list != STREAM_LIST_ALL)
1059 ✗ goto multiple_stream_lists;
1060
1061 50 spec += 2;
1062
5/6
✓ Branch 0 taken 46 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 43 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 50 if (*spec == '#' || (*spec == 'i' && *(spec + 1) == ':')) {
1063 7 ss->stream_list = STREAM_LIST_GROUP_ID;
1064
1065
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 4 times.
 7 spec += 1 + (*spec == 'i');
1066 } else
1067 43 ss->stream_list = STREAM_LIST_GROUP_IDX;
1068
1069 50 ss->list_id = strtol(spec, &endptr, 0);
1070
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (spec == endptr) {
1071 ✗ av_log(logctx, AV_LOG_ERROR, "Expected stream group idx/ID, got: %s\n", spec);
1072 ✗ ret = AVERROR(EINVAL);
1073 ✗ goto fail;
1074 }
1075 50 spec = endptr;
1076
1077 50 av_log(logctx, AV_LOG_TRACE, "Parsed stream group %s: %"PRId64"; remainder: %s\n",
1078
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 43 times.
 50 ss->stream_list == STREAM_LIST_GROUP_ID ? "ID" : "index", ss->list_id, spec);
1079
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 97 } else if (*spec == 'p' && *(spec + 1) == ':') {
1080 ✗ if (ss->stream_list != STREAM_LIST_ALL)
1081 ✗ goto multiple_stream_lists;
1082
1083 ✗ ss->stream_list = STREAM_LIST_PROGRAM;
1084
1085 ✗ spec += 2;
1086 ✗ ss->list_id = strtol(spec, &endptr, 0);
1087 ✗ if (spec == endptr) {
1088 ✗ av_log(logctx, AV_LOG_ERROR, "Expected program ID, got: %s\n", spec);
1089 ✗ ret = AVERROR(EINVAL);
1090 ✗ goto fail;
1091 }
1092 ✗ spec = endptr;
1093
1094 ✗ av_log(logctx, AV_LOG_TRACE,
1095 "Parsed program ID: %"PRId64"; remainder: %s\n", ss->list_id, spec);
1096
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 96 times.
 97 } else if (!strncmp(spec, "disp:", 5)) {
1097 1 const AVClass *st_class = av_stream_get_class();
1098 1 const AVOption *o = av_opt_find(&st_class, "disposition", NULL, 0, AV_OPT_SEARCH_FAKE_OBJ);
1099 1 char *disp = NULL;
1100 size_t len;
1101
1102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 av_assert0(o);
1103
1104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ss->disposition) {
1105 ✗ av_log(logctx, AV_LOG_ERROR, "Multiple disposition specifiers\n");
1106 ✗ ret = AVERROR(EINVAL);
1107 ✗ goto fail;
1108 }
1109
1110 1 spec += 5;
1111
1112 29 for (len = 0; cmdutils_isalnum(spec[len]) ||
1113
6/6
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
 57 spec[len] == '_' || spec[len] == '+'; len++)
1114 28 continue;
1115
1116 1 disp = av_strndup(spec, len);
1117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!disp) {
1118 ✗ ret = AVERROR(ENOMEM);
1119 ✗ goto fail;
1120 }
1121
1122 1 ret = av_opt_eval_flags(&st_class, o, disp, &ss->disposition);
1123 1 av_freep(&disp);
1124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0) {
1125 ✗ av_log(logctx, AV_LOG_ERROR, "Invalid disposition specifier\n");
1126 ✗ goto fail;
1127 }
1128
1129 1 spec += len;
1130
1131 1 av_log(logctx, AV_LOG_TRACE,
1132 "Parsed disposition: 0x%x; remainder: %s\n", ss->disposition, spec);
1133
1/2
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
 96 } else if (*spec == '#' ||
1134
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 96 (*spec == 'i' && *(spec + 1) == ':')) {
1135 ✗ if (ss->stream_list != STREAM_LIST_ALL)
1136 ✗ goto multiple_stream_lists;
1137
1138 ✗ ss->stream_list = STREAM_LIST_STREAM_ID;
1139
1140 ✗ spec += 1 + (*spec == 'i');
1141 ✗ ss->list_id = strtol(spec, &endptr, 0);
1142 ✗ if (spec == endptr) {
1143 ✗ av_log(logctx, AV_LOG_ERROR, "Expected stream ID, got: %s\n", spec);
1144 ✗ ret = AVERROR(EINVAL);
1145 ✗ goto fail;
1146 }
1147 ✗ spec = endptr;
1148
1149 ✗ av_log(logctx, AV_LOG_TRACE,
1150 "Parsed stream ID: %"PRId64"; remainder: %s\n", ss->list_id, spec);
1151
1152 // this terminates the specifier
1153 ✗ break;
1154
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 95 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 96 } else if (*spec == 'm' && *(spec + 1) == ':') {
1155 ✗ av_assert0(!ss->meta_key && !ss->meta_val);
1156
1157 ✗ spec += 2;
1158 ✗ ss->meta_key = av_get_token(&spec, ":");
1159 ✗ if (!ss->meta_key) {
1160 ✗ ret = AVERROR(ENOMEM);
1161 ✗ goto fail;
1162 }
1163 ✗ if (*spec == ':') {
1164 ✗ spec++;
1165 ✗ ss->meta_val = av_get_token(&spec, ":");
1166 ✗ if (!ss->meta_val) {
1167 ✗ ret = AVERROR(ENOMEM);
1168 ✗ goto fail;
1169 }
1170 }
1171
1172 ✗ av_log(logctx, AV_LOG_TRACE,
1173 "Parsed metadata: %s:%s; remainder: %s", ss->meta_key,
1174 ✗ ss->meta_val ? ss->meta_val : "<any value>", spec);
1175
1176 // this terminates the specifier
1177 ✗ break;
1178
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 96 } else if (*spec == 'u' && (*(spec + 1) == '\0' || *(spec + 1) == ':')) {
1179 ✗ ss->usable_only = 1;
1180 ✗ spec++;
1181 ✗ av_log(logctx, AV_LOG_ERROR, "Parsed 'usable only'\n");
1182
1183 // this terminates the specifier
1184 ✗ break;
1185 } else
1186 break;
1187
1188
2/2
✓ Branch 0 taken 304 times.
✓ Branch 1 taken 17521 times.
 17825 if (*spec == ':')
1189 304 spec++;
1190 }
1191
1192
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 35244 times.
 35340 if (*spec) {
1193
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 95 times.
 96 if (!allow_remainder) {
1194 1 av_log(logctx, AV_LOG_ERROR,
1195 "Trailing garbage at the end of a stream specifier: %s\n",
1196 spec);
1197 1 ret = AVERROR(EINVAL);
1198 1 goto fail;
1199 }
1200
1201
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
 95 if (*spec == ':')
1202 ✗ spec++;
1203
1204 95 ss->remainder = av_strdup(spec);
1205
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
 95 if (!ss->remainder) {
1206 ✗ ret = AVERROR(EINVAL);
1207 ✗ goto fail;
1208 }
1209 }
1210
1211 35339 return 0;
1212
1213 ✗ multiple_stream_lists:
1214 ✗ av_log(logctx, AV_LOG_ERROR,
1215 "Cannot combine multiple program/group designators in a "
1216 "single stream specifier");
1217 ✗ ret = AVERROR(EINVAL);
1218
1219 1 fail:
1220 1 stream_specifier_uninit(ss);
1221 1 return ret;
1222 }
1223
1224 37409 unsigned stream_specifier_match(const StreamSpecifier *ss,
1225 const AVFormatContext *s, const AVStream *st,
1226 void *logctx)
1227 {
1228 37409 const AVStreamGroup *g = NULL;
1229 37409 const AVProgram *p = NULL;
1230 37409 int start_stream = 0, nb_streams;
1231 37409 int nb_matched = 0;
1232
1233
3/6
✗ Branch 0 not taken.
✓ Branch 1 taken 37247 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 49 times.
✓ Branch 4 taken 113 times.
✗ Branch 5 not taken.
 37409 switch (ss->stream_list) {
1234 ✗ case STREAM_LIST_STREAM_ID:
1235 // <n-th> stream with given ID makes no sense and should be impossible to request
1236 ✗ av_assert0(ss->idx < 0);
1237 // return early if we know for sure the stream does not match
1238 ✗ if (st->id != ss->list_id)
1239 ✗ return 0;
1240 ✗ start_stream = st->index;
1241 ✗ nb_streams = st->index + 1;
1242 ✗ break;
1243 37247 case STREAM_LIST_ALL:
1244
2/2
✓ Branch 0 taken 36313 times.
✓ Branch 1 taken 934 times.
 37247 start_stream = ss->idx >= 0 ? 0 : st->index;
1245 37247 nb_streams = st->index + 1;
1246 37247 break;
1247 ✗ case STREAM_LIST_PROGRAM:
1248 ✗ for (unsigned i = 0; i < s->nb_programs; i++) {
1249 ✗ if (s->programs[i]->id == ss->list_id) {
1250 ✗ p = s->programs[i];
1251 ✗ break;
1252 }
1253 }
1254 ✗ if (!p) {
1255 ✗ av_log(logctx, AV_LOG_WARNING, "No program with ID %"PRId64" exists,"
1256 ✗ " stream specifier can never match\n", ss->list_id);
1257 ✗ return 0;
1258 }
1259 ✗ nb_streams = p->nb_stream_indexes;
1260 ✗ break;
1261 49 case STREAM_LIST_GROUP_ID:
1262
1/2
✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
 58 for (unsigned i = 0; i < s->nb_stream_groups; i++) {
1263
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 9 times.
 58 if (ss->list_id == s->stream_groups[i]->id) {
1264 49 g = s->stream_groups[i];
1265 49 break;
1266 }
1267 }
1268 av_fallthrough;
1269 case STREAM_LIST_GROUP_IDX:
1270
2/2
✓ Branch 0 taken 113 times.
✓ Branch 1 taken 49 times.
 162 if (ss->stream_list == STREAM_LIST_GROUP_IDX &&
1271
2/4
✓ Branch 0 taken 113 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 113 times.
✗ Branch 3 not taken.
 113 ss->list_id >= 0 && ss->list_id < s->nb_stream_groups)
1272 113 g = s->stream_groups[ss->list_id];
1273
1274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 162 times.
 162 if (!g) {
1275 ✗ av_log(logctx, AV_LOG_WARNING, "No stream group with group %s %"
1276 PRId64" exists, stream specifier can never match\n",
1277 ✗ ss->stream_list == STREAM_LIST_GROUP_ID ? "ID" : "index",
1278 ✗ ss->list_id);
1279 ✗ return 0;
1280 }
1281 162 nb_streams = g->nb_entries;
1282 162 break;
1283 ✗ default: av_assert0(0);
1284 }
1285
1286
2/2
✓ Branch 0 taken 44320 times.
✓ Branch 1 taken 525 times.
 44845 for (int i = start_stream; i < nb_streams; i++) {
1287
3/4
✓ Branch 0 taken 577 times.
✓ Branch 1 taken 43743 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 577 times.
 44320 if (g && g->entries[i]->type != AV_STREAM_GROUP_ENTRY_STREAM)
1288 ✗ continue;
1289
1290
3/4
✓ Branch 0 taken 577 times.
✓ Branch 1 taken 43743 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 43743 times.
 44320 const AVStream *candidate = s->streams[g ? g->entries[i]->stream->index :
1291 ✗ p ? p->stream_index[i] : i];
1292
1293
2/2
✓ Branch 0 taken 27436 times.
✓ Branch 1 taken 16884 times.
 44320 if (ss->media_type != AVMEDIA_TYPE_UNKNOWN &&
1294
2/2
✓ Branch 0 taken 26649 times.
✓ Branch 1 taken 787 times.
 27436 (ss->media_type != candidate->codecpar->codec_type ||
1295
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 26649 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 26649 (ss->no_apic && (candidate->disposition & AV_DISPOSITION_ATTACHED_PIC))))
1296 787 continue;
1297
1298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43533 times.
 43533 if (ss->meta_key) {
1299 ✗ const AVDictionaryEntry *tag = av_dict_get(candidate->metadata,
1300 ✗ ss->meta_key, NULL, 0);
1301
1302 ✗ if (!tag)
1303 ✗ continue;
1304 ✗ if (ss->meta_val && strcmp(tag->value, ss->meta_val))
1305 ✗ continue;
1306 }
1307
1308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43533 times.
 43533 if (ss->usable_only) {
1309 ✗ const AVCodecParameters *par = candidate->codecpar;
1310
1311 ✗ switch (par->codec_type) {
1312 ✗ case AVMEDIA_TYPE_AUDIO:
1313 ✗ if (!par->sample_rate || !par->ch_layout.nb_channels ||
1314 ✗ par->format == AV_SAMPLE_FMT_NONE)
1315 ✗ continue;
1316 ✗ break;
1317 ✗ case AVMEDIA_TYPE_VIDEO:
1318 ✗ if (!par->width || !par->height || par->format == AV_PIX_FMT_NONE)
1319 ✗ continue;
1320 ✗ break;
1321 ✗ case AVMEDIA_TYPE_UNKNOWN:
1322 ✗ continue;
1323 }
1324 }
1325
1326
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 43478 times.
 43533 if (ss->disposition &&
1327
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 11 times.
 55 (candidate->disposition & ss->disposition) != ss->disposition)
1328 44 continue;
1329
1330
2/2
✓ Branch 0 taken 36884 times.
✓ Branch 1 taken 6605 times.
 43489 if (st == candidate)
1331
4/4
✓ Branch 0 taken 901 times.
✓ Branch 1 taken 35983 times.
✓ Branch 2 taken 301 times.
✓ Branch 3 taken 600 times.
 36884 return ss->idx < 0 || ss->idx == nb_matched;
1332
1333 6605 nb_matched++;
1334 }
1335
1336 525 return 0;
1337 }
1338
1339 692 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1340 {
1341 StreamSpecifier ss;
1342 int ret;
1343
1344 692 ret = stream_specifier_parse(&ss, spec, 0, NULL);
1345
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 691 times.
 692 if (ret < 0)
1346 1 return ret;
1347
1348 691 ret = stream_specifier_match(&ss, s, st, NULL);
1349 691 stream_specifier_uninit(&ss);
1350 691 return ret;
1351 }
1352
1353 ✗ unsigned stream_group_specifier_match(const StreamSpecifier *ss,
1354 const AVFormatContext *s, const AVStreamGroup *stg,
1355 void *logctx)
1356 {
1357 ✗ int start_stream_group = 0, nb_stream_groups;
1358 ✗ int nb_matched = 0;
1359
1360 ✗ if (ss->idx >= 0)
1361 ✗ return 0;
1362
1363 ✗ switch (ss->stream_list) {
1364 ✗ case STREAM_LIST_STREAM_ID:
1365 case STREAM_LIST_ALL:
1366 case STREAM_LIST_PROGRAM:
1367 ✗ return 0;
1368 ✗ case STREAM_LIST_GROUP_ID:
1369 // <n-th> stream with given ID makes no sense and should be impossible to request
1370 ✗ av_assert0(ss->idx < 0);
1371 // return early if we know for sure the stream does not match
1372 ✗ if (stg->id != ss->list_id)
1373 ✗ return 0;
1374 ✗ start_stream_group = stg->index;
1375 ✗ nb_stream_groups = stg->index + 1;
1376 ✗ break;
1377 ✗ case STREAM_LIST_GROUP_IDX:
1378 ✗ start_stream_group = ss->list_id >= 0 ? 0 : stg->index;
1379 ✗ nb_stream_groups = stg->index + 1;
1380 ✗ break;
1381 ✗ default: av_assert0(0);
1382 }
1383
1384 ✗ for (int i = start_stream_group; i < nb_stream_groups; i++) {
1385 ✗ const AVStreamGroup *candidate = s->stream_groups[i];
1386
1387 ✗ if (ss->meta_key) {
1388 ✗ const AVDictionaryEntry *tag = av_dict_get(candidate->metadata,
1389 ✗ ss->meta_key, NULL, 0);
1390
1391 ✗ if (!tag)
1392 ✗ continue;
1393 ✗ if (ss->meta_val && strcmp(tag->value, ss->meta_val))
1394 ✗ continue;
1395 }
1396
1397 ✗ if (ss->usable_only) {
1398 ✗ switch (candidate->type) {
1399 ✗ case AV_STREAM_GROUP_PARAMS_TILE_GRID: {
1400 ✗ const AVStreamGroupTileGrid *tg = candidate->params.tile_grid;
1401 ✗ if (!tg->coded_width || !tg->coded_height || !tg->nb_tiles ||
1402 ✗ !tg->width || !tg->height || !tg->offsets)
1403 ✗ continue;
1404 ✗ break;
1405 }
1406 ✗ default:
1407 ✗ continue;
1408 }
1409 }
1410
1411 ✗ if (ss->disposition &&
1412 ✗ (candidate->disposition & ss->disposition) != ss->disposition)
1413 ✗ continue;
1414
1415 ✗ if (stg == candidate)
1416 ✗ return ss->list_id < 0 || ss->list_id == nb_matched;
1417
1418 ✗ nb_matched++;
1419 }
1420
1421 ✗ return 0;
1422 }
1423
1424 27432 int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id,
1425 AVFormatContext *s, AVStream *st, const AVCodec *codec,
1426 AVDictionary **dst, AVDictionary **opts_used)
1427 {
1428 27432 AVDictionary *ret = NULL;
1429 27432 const AVDictionaryEntry *t = NULL;
1430 54864 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1431
2/2
✓ Branch 0 taken 9560 times.
✓ Branch 1 taken 17872 times.
 27432 : AV_OPT_FLAG_DECODING_PARAM;
1432 27432 char prefix = 0;
1433 27432 const AVClass *cc = avcodec_get_class();
1434
1435
4/4
✓ Branch 0 taken 20343 times.
✓ Branch 1 taken 6698 times.
✓ Branch 2 taken 279 times.
✓ Branch 3 taken 112 times.
 27432 switch (st->codecpar->codec_type) {
1436 20343 case AVMEDIA_TYPE_VIDEO:
1437 20343 prefix = 'v';
1438 20343 flags |= AV_OPT_FLAG_VIDEO_PARAM;
1439 20343 break;
1440 6698 case AVMEDIA_TYPE_AUDIO:
1441 6698 prefix = 'a';
1442 6698 flags |= AV_OPT_FLAG_AUDIO_PARAM;
1443 6698 break;
1444 279 case AVMEDIA_TYPE_SUBTITLE:
1445 279 prefix = 's';
1446 279 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1447 279 break;
1448 }
1449
1450
2/2
✓ Branch 1 taken 83801 times.
✓ Branch 2 taken 27432 times.
 111233 while (t = av_dict_iterate(opts, t)) {
1451 const AVClass *priv_class;
1452 83801 char *p = strchr(t->key, ':');
1453 83801 int used = 0;
1454
1455 /* check stream specification in opt name */
1456
2/2
✓ Branch 0 taken 407 times.
✓ Branch 1 taken 83394 times.
 83801 if (p) {
1457 407 int err = check_stream_specifier(s, st, p + 1);
1458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 407 times.
 407 if (err < 0) {
1459 ✗ av_dict_free(&ret);
1460 ✗ return err;
1461
2/2
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 326 times.
 407 } else if (!err)
1462 81 continue;
1463
1464 326 *p = 0;
1465 }
1466
1467
4/4
✓ Branch 1 taken 3484 times.
✓ Branch 2 taken 80236 times.
✓ Branch 3 taken 1963 times.
✓ Branch 4 taken 1521 times.
 83720 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1468 1963 !codec ||
1469
4/4
✓ Branch 0 taken 908 times.
✓ Branch 1 taken 1055 times.
✓ Branch 2 taken 382 times.
✓ Branch 3 taken 526 times.
 2871 ((priv_class = codec->priv_class) &&
1470 908 av_opt_find(&priv_class, t->key, NULL, flags,
1471 AV_OPT_SEARCH_FAKE_OBJ))) {
1472 82139 av_dict_set(&ret, t->key, t->value, 0);
1473 82139 used = 1;
1474
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1576 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 4 times.
 1586 } else if (t->key[0] == prefix &&
1475 5 av_opt_find(&cc, t->key + 1, NULL, flags,
1476 AV_OPT_SEARCH_FAKE_OBJ)) {
1477 1 av_dict_set(&ret, t->key + 1, t->value, 0);
1478 1 used = 1;
1479 }
1480
1481
2/2
✓ Branch 0 taken 326 times.
✓ Branch 1 taken 83394 times.
 83720 if (p)
1482 326 *p = ':';
1483
1484
4/4
✓ Branch 0 taken 82140 times.
✓ Branch 1 taken 1580 times.
✓ Branch 2 taken 53735 times.
✓ Branch 3 taken 28405 times.
 83720 if (used && opts_used)
1485 53735 av_dict_set(opts_used, t->key, "", 0);
1486 }
1487
1488 27432 *dst = ret;
1489 27432 return 0;
1490 }
1491
1492 8073 int setup_find_stream_info_opts(AVFormatContext *s,
1493 AVDictionary *local_codec_opts,
1494 AVDictionary ***dst)
1495 {
1496 int ret;
1497 AVDictionary **opts;
1498
1499 8073 *dst = NULL;
1500
1501
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 7976 times.
 8073 if (!s->nb_streams)
1502 97 return 0;
1503
1504 7976 opts = av_calloc(s->nb_streams, sizeof(*opts));
1505
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7976 times.
 7976 if (!opts)
1506 ✗ return AVERROR(ENOMEM);
1507
1508
2/2
✓ Branch 0 taken 8914 times.
✓ Branch 1 taken 7976 times.
 16890 for (int i = 0; i < s->nb_streams; i++) {
1509 8914 ret = filter_codec_opts(local_codec_opts, s->streams[i]->codecpar->codec_id,
1510 8914 s, s->streams[i], NULL, &opts[i], NULL);
1511
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8914 times.
 8914 if (ret < 0)
1512 ✗ goto fail;
1513 }
1514 7976 *dst = opts;
1515 7976 return 0;
1516 ✗ fail:
1517 ✗ for (int i = 0; i < s->nb_streams; i++)
1518 ✗ av_dict_free(&opts[i]);
1519 ✗ av_freep(&opts);
1520 ✗ return ret;
1521 }
1522
1523 266644 int grow_array(void **array, int elem_size, int *size, int new_size)
1524 {
1525
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 266644 times.
 266644 if (new_size >= INT_MAX / elem_size) {
1526 ✗ av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1527 ✗ return AVERROR(ERANGE);
1528 }
1529
1/2
✓ Branch 0 taken 266644 times.
✗ Branch 1 not taken.
 266644 if (*size < new_size) {
1530 266644 uint8_t *tmp = av_realloc_array(*array, new_size, elem_size);
1531
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 266644 times.
 266644 if (!tmp)
1532 ✗ return AVERROR(ENOMEM);
1533 266644 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1534 266644 *size = new_size;
1535 266644 *array = tmp;
1536 266644 return 0;
1537 }
1538 ✗ return 0;
1539 }
1540
1541 50584 void *allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
1542 {
1543 void *new_elem;
1544
1545 50584 new_elem = av_mallocz(elem_size);
1546
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50584 times.
 50584 if (!new_elem)
1547 ✗ return NULL;
1548
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 50584 times.
 50584 if (av_dynarray_add_nofree(ptr, nb_elems, new_elem) < 0)
1549 ✗ av_freep(&new_elem);
1550
1551 50584 return new_elem;
1552 }
1553
1554 5816 double get_rotation(const int32_t *displaymatrix)
1555 {
1556 5816 double theta = 0;
1557
1/2
✓ Branch 0 taken 5816 times.
✗ Branch 1 not taken.
 5816 if (displaymatrix)
1558 5816 theta = -round(av_display_rotation_get(displaymatrix));
1559
1560 5816 theta -= 360*floor(theta/360 + 0.9/360);
1561
1562
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5816 times.
 5816 if (fabs(theta - 90*round(theta/90)) > 2)
1563 ✗ av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
1564 "If you want to help, upload a sample "
1565 "of this file to https://streams.videolan.org/upload/ "
1566 "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
1567
1568 5816 return theta;
1569 }
1570
1571 /* read file contents into a string */
1572 75 char *read_file_to_string(const char *filename)
1573 {
1574 75 AVIOContext *pb = NULL;
1575 75 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1576 AVBPrint bprint;
1577 char *str;
1578
1579
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 75 times.
 75 if (ret < 0) {
1580 ✗ av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1581 ✗ return NULL;
1582 }
1583
1584 75 av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
1585 75 ret = avio_read_to_bprint(pb, &bprint, SIZE_MAX);
1586 75 avio_closep(&pb);
1587
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 75 times.
 75 if (ret < 0) {
1588 ✗ av_bprint_finalize(&bprint, NULL);
1589 ✗ return NULL;
1590 }
1591 75 ret = av_bprint_finalize(&bprint, &str);
1592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 75 times.
 75 if (ret < 0)
1593 ✗ return NULL;
1594 75 return str;
1595 }
1596
1597 7764 void remove_avoptions(AVDictionary **a, AVDictionary *b)
1598 {
1599 7764 const AVDictionaryEntry *t = NULL;
1600
1601
2/2
✓ Branch 1 taken 25821 times.
✓ Branch 2 taken 7764 times.
 33585 while ((t = av_dict_iterate(b, t))) {
1602 25821 av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
1603 }
1604 7764 }
1605
1606 32083 int check_avoptions(AVDictionary *m)
1607 {
1608 32083 const AVDictionaryEntry *t = av_dict_iterate(m, NULL);
1609
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32083 times.
 32083 if (t) {
1610 ✗ av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1611 ✗ return AVERROR_OPTION_NOT_FOUND;
1612 }
1613
1614 32083 return 0;
1615 }
1616
1617 ✗ void dump_dictionary(void *ctx, const AVDictionary *m,
1618 const char *name, const char *indent,
1619 int log_level)
1620 {
1621 ✗ const AVDictionaryEntry *tag = NULL;
1622
1623 ✗ if (!m)
1624 ✗ return;
1625
1626 ✗ av_log(ctx, log_level, "%s%s:\n", indent, name);
1627 ✗ while ((tag = av_dict_iterate(m, tag))) {
1628 ✗ const char *p = tag->value;
1629 ✗ av_log(ctx, log_level, "%s %-16s: ", indent, tag->key);
1630 ✗ while (*p) {
1631 ✗ size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
1632 ✗ av_log(ctx, log_level, "%.*s", (int)(FFMIN(255, len)), p);
1633 ✗ p += len;
1634 ✗ if (*p == 0xd) av_log(ctx, log_level, " ");
1635 ✗ if (*p == 0xa) av_log(ctx, log_level, "\n%s %-16s: ", indent, "");
1636 ✗ if (*p) p++;
1637 }
1638 ✗ av_log(ctx, log_level, "\n");
1639 }
1640 }
1641