FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/fftools/cmdutils.c
Date: 2025-11-10 16:28:23
Exec Total Coverage
Lines: 545 869 62.7%
Functions: 34 41 82.9%
Branches: 406 741 54.8%
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 "compat/va_copy.h"
34 #include "libavformat/avformat.h"
35 #include "libswscale/swscale.h"
36 #include "libswresample/swresample.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/display.h"
41 #include "libavutil/getenv_utf8.h"
42 #include "libavutil/libm.h"
43 #include "libavutil/mem.h"
44 #include "libavutil/parseutils.h"
45 #include "libavutil/eval.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/opt.h"
48 #include "cmdutils.h"
49 #include "fopen_utf8.h"
50 #include "opt_common.h"
51 #ifdef _WIN32
52 #include <windows.h>
53 #include "compat/w32dlfcn.h"
54 #endif
55
56 AVDictionary *sws_dict;
57 AVDictionary *swr_opts;
58 AVDictionary *format_opts, *codec_opts;
59
60 int hide_banner = 0;
61
62 17081 void uninit_opts(void)
63 {
64 17081 av_dict_free(&swr_opts);
65 17081 av_dict_free(&sws_dict);
66 17081 av_dict_free(&format_opts);
67 17081 av_dict_free(&codec_opts);
68 17081 }
69
70 ✗ void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
71 {
72 ✗ vfprintf(stdout, fmt, vl);
73 ✗ }
74
75 8624 void init_dynload(void)
76 {
77 #if HAVE_SETDLLDIRECTORY && defined(_WIN32)
78 /* Calling SetDllDirectory with the empty string (but not NULL) removes the
79 * current working directory from the DLL search path as a security pre-caution. */
80 SetDllDirectory("");
81 #endif
82 8624 }
83
84 38629 int parse_number(const char *context, const char *numstr, enum OptionType type,
85 double min, double max, double *dst)
86 {
87 char *tail;
88 const char *error;
89 38629 double d = av_strtod(numstr, &tail);
90
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38629 times.
 38629 if (*tail)
91 ✗ error = "Expected number for %s but found: %s\n";
92
2/4
✓ Branch 0 taken 38629 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 38629 times.
 38629 else if (d < min || d > max)
93 ✗ error = "The value for %s was %s which is not within %f - %f\n";
94
3/4
✓ Branch 0 taken 38335 times.
✓ Branch 1 taken 294 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 38335 times.
 38629 else if (type == OPT_TYPE_INT64 && (int64_t)d != d)
95 ✗ error = "Expected int64 for %s but found %s\n";
96
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 38629 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 38629 else if (type == OPT_TYPE_INT && (int)d != d)
97 ✗ error = "Expected int for %s but found %s\n";
98 else {
99 38629 *dst = d;
100 38629 return 0;
101 }
102
103 ✗ av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
104 ✗ return AVERROR(EINVAL);
105 }
106
107 ✗ void show_help_options(const OptionDef *options, const char *msg, int req_flags,
108 int rej_flags)
109 {
110 const OptionDef *po;
111 int first;
112
113 ✗ first = 1;
114 ✗ for (po = options; po->name; po++) {
115 char buf[128];
116
117 ✗ if (((po->flags & req_flags) != req_flags) ||
118 ✗ (po->flags & rej_flags))
119 ✗ continue;
120
121 ✗ if (first) {
122 ✗ printf("%s\n", msg);
123 ✗ first = 0;
124 }
125 ✗ av_strlcpy(buf, po->name, sizeof(buf));
126
127 ✗ if (po->flags & OPT_FLAG_PERSTREAM)
128 ✗ av_strlcat(buf, "[:<stream_spec>]", sizeof(buf));
129 ✗ else if (po->flags & OPT_FLAG_SPEC)
130 ✗ av_strlcat(buf, "[:<spec>]", sizeof(buf));
131
132 ✗ if (po->argname)
133 ✗ av_strlcatf(buf, sizeof(buf), " <%s>", po->argname);
134
135 ✗ printf("-%-17s %s\n", buf, po->help);
136 }
137 ✗ printf("\n");
138 ✗ }
139
140 ✗ void show_help_children(const AVClass *class, int flags)
141 {
142 ✗ void *iter = NULL;
143 const AVClass *child;
144 ✗ if (class->option) {
145 ✗ av_opt_show2(&class, NULL, flags, 0);
146 ✗ printf("\n");
147 }
148
149 ✗ while (child = av_opt_child_class_iterate(class, &iter))
150 ✗ show_help_children(child, flags);
151 ✗ }
152
153 1306499 static const OptionDef *find_option(const OptionDef *po, const char *name)
154 {
155
2/2
✓ Branch 0 taken 378 times.
✓ Branch 1 taken 1306121 times.
 1306499 if (*name == '/')
156 378 name++;
157
158
2/2
✓ Branch 0 taken 194376502 times.
✓ Branch 1 taken 744009 times.
 195120511 while (po->name) {
159 const char *end;
160
6/6
✓ Branch 1 taken 1330873 times.
✓ Branch 2 taken 193045629 times.
✓ Branch 3 taken 820340 times.
✓ Branch 4 taken 510533 times.
✓ Branch 5 taken 768383 times.
✓ Branch 6 taken 51957 times.
 194376502 if (av_strstart(name, po->name, &end) && (!*end || *end == ':'))
161 break;
162 193814012 po++;
163 }
164 1306499 return po;
165 }
166
167 /* _WIN32 means using the windows libc - cygwin doesn't define that
168 * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
169 * it doesn't provide the actual command line via GetCommandLineW(). */
170 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
171 #include <shellapi.h>
172 /* Will be leaked on exit */
173 static char** win32_argv_utf8 = NULL;
174 static int win32_argc = 0;
175
176 /**
177 * Prepare command line arguments for executable.
178 * For Windows - perform wide-char to UTF-8 conversion.
179 * Input arguments should be main() function arguments.
180 * @param argc_ptr Arguments number (including executable)
181 * @param argv_ptr Arguments list.
182 */
183 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
184 {
185 char *argstr_flat;
186 wchar_t **argv_w;
187 int i, buffsize = 0, offset = 0;
188
189 if (win32_argv_utf8) {
190 *argc_ptr = win32_argc;
191 *argv_ptr = win32_argv_utf8;
192 return;
193 }
194
195 win32_argc = 0;
196 argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
197 if (win32_argc <= 0 || !argv_w)
198 return;
199
200 /* determine the UTF-8 buffer size (including NULL-termination symbols) */
201 for (i = 0; i < win32_argc; i++)
202 buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
203 NULL, 0, NULL, NULL);
204
205 win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
206 argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
207 if (!win32_argv_utf8) {
208 LocalFree(argv_w);
209 return;
210 }
211
212 for (i = 0; i < win32_argc; i++) {
213 win32_argv_utf8[i] = &argstr_flat[offset];
214 offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
215 &argstr_flat[offset],
216 buffsize - offset, NULL, NULL);
217 }
218 win32_argv_utf8[i] = NULL;
219 LocalFree(argv_w);
220
221 *argc_ptr = win32_argc;
222 *argv_ptr = win32_argv_utf8;
223 }
224 #else
225 8624 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
226 {
227 /* nothing to do */
228 8624 }
229 #endif /* HAVE_COMMANDLINETOARGVW */
230
231 545277 static int opt_has_arg(const OptionDef *o)
232 {
233
2/2
✓ Branch 0 taken 171586 times.
✓ Branch 1 taken 373691 times.
 545277 if (o->type == OPT_TYPE_BOOL)
234 171586 return 0;
235
2/2
✓ Branch 0 taken 131065 times.
✓ Branch 1 taken 242626 times.
 373691 if (o->type == OPT_TYPE_FUNC)
236 131065 return !!(o->flags & OPT_FUNC_ARG);
237 242626 return 1;
238 }
239
240 101586 static int write_option(void *optctx, const OptionDef *po, const char *opt,
241 const char *arg, const OptionDef *defs)
242 {
243 /* new-style options contain an offset into optctx, old-style address of
244 * a global var*/
245 203172 void *dst = po->flags & OPT_FLAG_OFFSET ?
246
2/2
✓ Branch 0 taken 49092 times.
✓ Branch 1 taken 52494 times.
 101586 (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
247 101586 char *arg_allocated = NULL;
248
249 101586 enum OptionType so_type = po->type;
250
251 101586 SpecifierOptList *sol = NULL;
252 double num;
253 101586 int ret = 0;
254
255
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 101523 times.
 101586 if (*opt == '/') {
256 63 opt++;
257
258
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 63 times.
 63 if (!opt_has_arg(po)) {
259 ✗ av_log(NULL, AV_LOG_FATAL,
260 "Requested to load an argument from file for an option '%s'"
261 " which does not take an argument\n",
262 ✗ po->name);
263 ✗ return AVERROR(EINVAL);
264 }
265
266 63 arg_allocated = read_file_to_string(arg);
267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63 times.
 63 if (!arg_allocated) {
268 ✗ av_log(NULL, AV_LOG_FATAL,
269 "Error reading the value for option '%s' from file: %s\n",
270 opt, arg);
271 ✗ return AVERROR(EINVAL);
272 }
273
274 63 arg = arg_allocated;
275 }
276
277
2/2
✓ Branch 0 taken 33367 times.
✓ Branch 1 taken 68219 times.
 101586 if (po->flags & OPT_FLAG_SPEC) {
278 33367 char *p = strchr(opt, ':');
279 char *str;
280
281 33367 sol = dst;
282 33367 ret = GROW_ARRAY(sol->opt, sol->nb_opt);
283
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33367 times.
 33367 if (ret < 0)
284 ✗ goto finish;
285
286
2/2
✓ Branch 0 taken 16583 times.
✓ Branch 1 taken 16784 times.
 33367 str = av_strdup(p ? p + 1 : "");
287
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33367 times.
 33367 if (!str) {
288 ✗ ret = AVERROR(ENOMEM);
289 ✗ goto finish;
290 }
291 33367 sol->opt[sol->nb_opt - 1].specifier = str;
292
293
2/2
✓ Branch 0 taken 33115 times.
✓ Branch 1 taken 252 times.
 33367 if (po->flags & OPT_FLAG_PERSTREAM) {
294 33115 ret = stream_specifier_parse(&sol->opt[sol->nb_opt - 1].stream_spec,
295 str, 0, NULL);
296
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33115 times.
 33115 if (ret < 0)
297 ✗ goto finish;
298 }
299
300 33367 dst = &sol->opt[sol->nb_opt - 1].u;
301 }
302
303
2/2
✓ Branch 0 taken 39749 times.
✓ Branch 1 taken 61837 times.
 101586 if (po->type == OPT_TYPE_STRING) {
304 char *str;
305
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 39724 times.
 39749 if (arg_allocated) {
306 25 str = arg_allocated;
307 25 arg_allocated = NULL;
308 } else
309 39724 str = av_strdup(arg);
310 39749 av_freep(dst);
311
312
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39749 times.
 39749 if (!str) {
313 ✗ ret = AVERROR(ENOMEM);
314 ✗ goto finish;
315 }
316
317 39749 *(char **)dst = str;
318
4/4
✓ Branch 0 taken 29046 times.
✓ Branch 1 taken 32791 times.
✓ Branch 2 taken 138 times.
✓ Branch 3 taken 28908 times.
 61837 } else if (po->type == OPT_TYPE_BOOL || po->type == OPT_TYPE_INT) {
319 32929 ret = parse_number(opt, arg, OPT_TYPE_INT64, INT_MIN, INT_MAX, &num);
320
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32929 times.
 32929 if (ret < 0)
321 ✗ goto finish;
322
323 32929 *(int *)dst = num;
324 32929 so_type = OPT_TYPE_INT;
325
2/2
✓ Branch 0 taken 5406 times.
✓ Branch 1 taken 23502 times.
 28908 } else if (po->type == OPT_TYPE_INT64) {
326 5406 ret = parse_number(opt, arg, OPT_TYPE_INT64, INT64_MIN, (double)INT64_MAX, &num);
327
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5406 times.
 5406 if (ret < 0)
328 ✗ goto finish;
329
330 5406 *(int64_t *)dst = num;
331
2/2
✓ Branch 0 taken 1332 times.
✓ Branch 1 taken 22170 times.
 23502 } else if (po->type == OPT_TYPE_TIME) {
332 1332 ret = av_parse_time(dst, arg, 1);
333
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1332 times.
 1332 if (ret < 0) {
334 ✗ av_log(NULL, AV_LOG_ERROR, "Invalid duration for option %s: %s\n",
335 opt, arg);
336 ✗ goto finish;
337 }
338 1332 so_type = OPT_TYPE_INT64;
339
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 22167 times.
 22170 } else if (po->type == OPT_TYPE_FLOAT) {
340 3 ret = parse_number(opt, arg, OPT_TYPE_FLOAT, -INFINITY, INFINITY, &num);
341
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (ret < 0)
342 ✗ goto finish;
343
344 3 *(float *)dst = num;
345
2/2
✓ Branch 0 taken 291 times.
✓ Branch 1 taken 21876 times.
 22167 } else if (po->type == OPT_TYPE_DOUBLE) {
346 291 ret = parse_number(opt, arg, OPT_TYPE_DOUBLE, -INFINITY, INFINITY, &num);
347
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 291 times.
 291 if (ret < 0)
348 ✗ goto finish;
349
350 291 *(double *)dst = num;
351 } else {
352
2/4
✓ Branch 0 taken 21876 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21876 times.
 21876 av_assert0(po->type == OPT_TYPE_FUNC && po->u.func_arg);
353
354 21876 ret = po->u.func_arg(optctx, opt, arg);
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21876 times.
 21876 if (ret < 0) {
356 ✗ if ((strcmp(opt, "init_hw_device") != 0) || (strcmp(arg, "list") != 0)) {
357 ✗ av_log(NULL, AV_LOG_ERROR,
358 "Failed to set value '%s' for option '%s': %s\n",
359 ✗ arg, opt, av_err2str(ret));
360 }
361 ✗ goto finish;
362 }
363 }
364
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 101585 times.
 101586 if (po->flags & OPT_EXIT) {
365 1 ret = AVERROR_EXIT;
366 1 goto finish;
367 }
368
369
2/2
✓ Branch 0 taken 68218 times.
✓ Branch 1 taken 33367 times.
 101585 if (sol) {
370 33367 sol->type = so_type;
371
2/2
✓ Branch 0 taken 2502 times.
✓ Branch 1 taken 30865 times.
 35869 sol->opt_canon = (po->flags & OPT_HAS_CANON) ?
372 2502 find_option(defs, po->u1.name_canon) : po;
373 }
374
375 68218 finish:
376 101586 av_freep(&arg_allocated);
377 101586 return ret;
378 }
379
380 10440 int parse_option(void *optctx, const char *opt, const char *arg,
381 const OptionDef *options)
382 {
383 static const OptionDef opt_avoptions = {
384 .name = "AVOption passthrough",
385 .type = OPT_TYPE_FUNC,
386 .flags = OPT_FUNC_ARG,
387 .u.func_arg = opt_default,
388 };
389
390 const OptionDef *po;
391 int ret;
392
393 10440 po = find_option(options, opt);
394
5/6
✓ Branch 0 taken 124 times.
✓ Branch 1 taken 10316 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 123 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 10440 if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
395 /* handle 'no' bool option */
396 1 po = find_option(options, opt + 2);
397
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))
398 1 arg = "0";
399
2/2
✓ Branch 0 taken 159 times.
✓ Branch 1 taken 10280 times.
 10439 } else if (po->type == OPT_TYPE_BOOL)
400 159 arg = "1";
401
402
2/2
✓ Branch 0 taken 123 times.
✓ Branch 1 taken 10317 times.
 10440 if (!po->name)
403 123 po = &opt_avoptions;
404
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10440 times.
 10440 if (!po->name) {
405 ✗ av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
406 ✗ return AVERROR(EINVAL);
407 }
408
3/4
✓ Branch 1 taken 10167 times.
✓ Branch 2 taken 273 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10167 times.
 10440 if (opt_has_arg(po) && !arg) {
409 ✗ av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
410 ✗ return AVERROR(EINVAL);
411 }
412
413 10440 ret = write_option(optctx, po, opt, arg, options);
414
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10440 times.
 10440 if (ret < 0)
415 ✗ return ret;
416
417 10440 return opt_has_arg(po);
418 }
419
420 167 int parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
421 int (*parse_arg_function)(void *, const char*))
422 {
423 const char *opt;
424 167 int optindex, handleoptions = 1, ret;
425
426 /* perform system-dependent conversions for arguments list */
427 167 prepare_app_arguments(&argc, &argv);
428
429 /* parse options */
430 167 optindex = 1;
431
2/2
✓ Branch 0 taken 842 times.
✓ Branch 1 taken 167 times.
 1009 while (optindex < argc) {
432 842 opt = argv[optindex++];
433
434
4/6
✓ Branch 0 taken 842 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 685 times.
✓ Branch 3 taken 157 times.
✓ Branch 4 taken 685 times.
✗ Branch 5 not taken.
 842 if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
435
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 685 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 685 if (opt[1] == '-' && opt[2] == '\0') {
436 ✗ handleoptions = 0;
437 ✗ continue;
438 }
439 685 opt++;
440
441
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 685 times.
 685 if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
442 ✗ return ret;
443 685 optindex += ret;
444 } else {
445
1/2
✓ Branch 0 taken 157 times.
✗ Branch 1 not taken.
 157 if (parse_arg_function) {
446 157 ret = parse_arg_function(optctx, opt);
447
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 157 times.
 157 if (ret < 0)
448 ✗ return ret;
449 }
450 }
451 }
452
453 167 return 0;
454 }
455
456 24284 int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs)
457 {
458 int i, ret;
459
460 24284 av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
461 24284 g->group_def->name, g->arg);
462
463
2/2
✓ Branch 0 taken 91146 times.
✓ Branch 1 taken 24283 times.
 115429 for (i = 0; i < g->nb_opts; i++) {
464 91146 Option *o = &g->opts[i];
465
466
2/2
✓ Branch 0 taken 49669 times.
✓ Branch 1 taken 41477 times.
 91146 if (g->group_def->flags &&
467
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 49669 times.
 49669 !(g->group_def->flags & o->opt->flags)) {
468 ✗ av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
469 "%s %s -- you are trying to apply an input option to an "
470 "output file or vice versa. Move this option before the "
471 ✗ "file it belongs to.\n", o->key, o->opt->help,
472 ✗ g->group_def->name, g->arg);
473 ✗ return AVERROR(EINVAL);
474 }
475
476 91146 av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
477 91146 o->key, o->opt->help, o->val);
478
479 91146 ret = write_option(optctx, o->opt, o->key, o->val, defs);
480
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 91145 times.
 91146 if (ret < 0)
481 1 return ret;
482 }
483
484 24283 av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
485
486 24283 return 0;
487 }
488
489 43120 int locate_option(int argc, char **argv, const OptionDef *options,
490 const char *optname)
491 {
492 const OptionDef *po;
493 int i;
494
495
2/2
✓ Branch 0 taken 1001114 times.
✓ Branch 1 taken 43104 times.
 1044218 for (i = 1; i < argc; i++) {
496 1001114 const char *cur_opt = argv[i];
497
498
4/4
✓ Branch 0 taken 971507 times.
✓ Branch 1 taken 29607 times.
✓ Branch 2 taken 13475 times.
✓ Branch 3 taken 958032 times.
 1001114 if (!(cur_opt[0] == '-' && cur_opt[1]))
499 43082 continue;
500 958032 cur_opt++;
501
502 958032 po = find_option(options, cur_opt);
503
5/6
✓ Branch 0 taken 626112 times.
✓ Branch 1 taken 331920 times.
✓ Branch 2 taken 126645 times.
✓ Branch 3 taken 499467 times.
✓ Branch 4 taken 126645 times.
✗ Branch 5 not taken.
 958032 if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
504 126645 po = find_option(options, cur_opt + 2);
505
506
3/4
✓ Branch 0 taken 499507 times.
✓ Branch 1 taken 458525 times.
✓ Branch 2 taken 499507 times.
✗ Branch 3 not taken.
 958032 if ((!po->name && !strcmp(cur_opt, optname)) ||
507
4/4
✓ Branch 0 taken 458525 times.
✓ Branch 1 taken 499507 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 458509 times.
 958032 (po->name && !strcmp(optname, po->name)))
508 16 return i;
509
510
4/4
✓ Branch 0 taken 458509 times.
✓ Branch 1 taken 499507 times.
✓ Branch 3 taken 293984 times.
✓ Branch 4 taken 164525 times.
 958016 if (!po->name || opt_has_arg(po))
511 793491 i++;
512 }
513 43104 return 0;
514 }
515
516 ✗ static void dump_argument(FILE *report_file, const char *a)
517 {
518 const unsigned char *p;
519
520 ✗ for (p = a; *p; p++)
521 ✗ if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
522 ✗ *p == '_' || (*p >= 'a' && *p <= 'z')))
523 break;
524 ✗ if (!*p) {
525 ✗ fputs(a, report_file);
526 ✗ return;
527 }
528 ✗ fputc('"', report_file);
529 ✗ for (p = a; *p; p++) {
530 ✗ if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
531 ✗ fprintf(report_file, "\\%c", *p);
532 ✗ else if (*p < ' ' || *p > '~')
533 ✗ fprintf(report_file, "\\x%02x", *p);
534 else
535 ✗ fputc(*p, report_file);
536 }
537 ✗ fputc('"', report_file);
538 }
539
540 8624 static void check_options(const OptionDef *po)
541 {
542
2/2
✓ Branch 0 taken 1678220 times.
✓ Branch 1 taken 8624 times.
 1686844 while (po->name) {
543
2/2
✓ Branch 0 taken 1014840 times.
✓ Branch 1 taken 663380 times.
 1678220 if (po->flags & OPT_PERFILE)
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1014840 times.
 1014840 av_assert0(po->flags & (OPT_INPUT | OPT_OUTPUT | OPT_DECODER));
545
546
2/2
✓ Branch 0 taken 651750 times.
✓ Branch 1 taken 1026470 times.
 1678220 if (po->type == OPT_TYPE_FUNC)
547
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 651750 times.
 651750 av_assert0(!(po->flags & (OPT_FLAG_OFFSET | OPT_FLAG_SPEC)));
548
549 // OPT_FUNC_ARG can only be ser for OPT_TYPE_FUNC
550
3/4
✓ Branch 0 taken 1026470 times.
✓ Branch 1 taken 651750 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1026470 times.
 1678220 av_assert0((po->type == OPT_TYPE_FUNC) || !(po->flags & OPT_FUNC_ARG));
551
552 1678220 po++;
553 }
554 8624 }
555
556 8624 void parse_loglevel(int argc, char **argv, const OptionDef *options)
557 {
558 int idx;
559 char *env;
560
561 8624 check_options(options);
562
563 8624 idx = locate_option(argc, argv, options, "loglevel");
564
1/2
✓ Branch 0 taken 8624 times.
✗ Branch 1 not taken.
 8624 if (!idx)
565 8624 idx = locate_option(argc, argv, options, "v");
566
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8608 times.
✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
 8624 if (idx && argv[idx + 1])
567 16 opt_loglevel(NULL, "loglevel", argv[idx + 1]);
568 8624 idx = locate_option(argc, argv, options, "report");
569 8624 env = getenv_utf8("FFREPORT");
570
2/4
✓ Branch 0 taken 8624 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8624 times.
 8624 if (env || idx) {
571 ✗ FILE *report_file = NULL;
572 ✗ init_report(env, &report_file);
573 ✗ if (report_file) {
574 int i;
575 ✗ fprintf(report_file, "Command line:\n");
576 ✗ for (i = 0; i < argc; i++) {
577 ✗ dump_argument(report_file, argv[i]);
578 ✗ fputc(i < argc - 1 ? ' ' : '\n', report_file);
579 }
580 ✗ fflush(report_file);
581 }
582 }
583 8624 freeenv_utf8(env);
584 8624 idx = locate_option(argc, argv, options, "hide_banner");
585
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8624 times.
 8624 if (idx)
586 ✗ hide_banner = 1;
587 8624 }
588
589 317963 static const AVOption *opt_find(void *obj, const char *name, const char *unit,
590 int opt_flags, int search_flags)
591 {
592 317963 const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
593
4/4
✓ Branch 0 taken 92614 times.
✓ Branch 1 taken 225349 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 92612 times.
 317963 if(o && !o->flags)
594 2 return NULL;
595 317961 return o;
596 }
597
598 #define FLAGS ((o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0)
599 117856 int opt_default(void *optctx, const char *opt, const char *arg)
600 {
601 const AVOption *o;
602 117856 int consumed = 0;
603 char opt_stripped[128];
604 const char *p;
605 117856 const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
606 #if CONFIG_SWSCALE
607 117856 const AVClass *sc = sws_get_class();
608 #endif
609 #if CONFIG_SWRESAMPLE
610 117856 const AVClass *swr_class = swr_get_class();
611 #endif
612
613
2/4
✓ Branch 0 taken 117856 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 117856 times.
 117856 if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
614 ✗ av_log_set_level(AV_LOG_DEBUG);
615
616
2/2
✓ Branch 0 taken 117844 times.
✓ Branch 1 taken 12 times.
 117856 if (!(p = strchr(opt, ':')))
617 117844 p = opt + strlen(opt);
618 117856 av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
619
620
2/2
✓ Branch 1 taken 56850 times.
✓ Branch 2 taken 61006 times.
 117856 if ((o = opt_find(&cc, opt_stripped, NULL, 0,
621 56850 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
622
8/8
✓ Branch 0 taken 56847 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 56835 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 15810 times.
✓ Branch 5 taken 41025 times.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 15824 times.
 72675 ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
623 15825 (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
624
5/6
✓ Branch 0 taken 22873 times.
✓ Branch 1 taken 38134 times.
✓ Branch 2 taken 22873 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15733 times.
✓ Branch 5 taken 7140 times.
 61007 av_dict_set(&codec_opts, opt, arg, FLAGS);
625 61007 consumed = 1;
626 }
627
2/2
✓ Branch 1 taken 15819 times.
✓ Branch 2 taken 102037 times.
 117856 if ((o = opt_find(&fc, opt, NULL, 0,
628 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
629
5/6
✓ Branch 0 taken 15580 times.
✓ Branch 1 taken 239 times.
✓ Branch 2 taken 15580 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15572 times.
✓ Branch 5 taken 8 times.
 15819 av_dict_set(&format_opts, opt, arg, FLAGS);
630
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 15743 times.
 15819 if (consumed)
631 76 av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
632 15819 consumed = 1;
633 }
634 #if CONFIG_SWSCALE
635
4/4
✓ Branch 0 taken 41106 times.
✓ Branch 1 taken 76750 times.
✓ Branch 3 taken 15786 times.
✓ Branch 4 taken 25320 times.
 117856 if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
636 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
637
2/4
✓ Branch 0 taken 15786 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15786 times.
✗ Branch 3 not taken.
 15786 if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
638
2/4
✓ Branch 0 taken 15786 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15786 times.
✗ Branch 3 not taken.
 15786 !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
639
2/4
✓ Branch 0 taken 15786 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15786 times.
 15786 !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
640 ✗ av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
641 ✗ return AVERROR(EINVAL);
642 }
643
4/6
✓ Branch 0 taken 15786 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15786 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15571 times.
✓ Branch 5 taken 215 times.
 15786 av_dict_set(&sws_dict, opt, arg, FLAGS);
644
645 15786 consumed = 1;
646 }
647 #else
648 if (!consumed && !strcmp(opt, "sws_flags")) {
649 av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
650 consumed = 1;
651 }
652 #endif
653 #if CONFIG_SWRESAMPLE
654
3/4
✓ Branch 0 taken 25320 times.
✓ Branch 1 taken 92536 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 25320 times.
 117856 if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
655 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
656 ✗ av_dict_set(&swr_opts, opt, arg, FLAGS);
657 ✗ consumed = 1;
658 }
659 #endif
660
661
2/2
✓ Branch 0 taken 92536 times.
✓ Branch 1 taken 25320 times.
 117856 if (consumed)
662 92536 return 0;
663 25320 return AVERROR_OPTION_NOT_FOUND;
664 }
665
666 /*
667 * Check whether given option is a group separator.
668 *
669 * @return index of the group definition that matched or -1 if none
670 */
671 190926 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
672 const char *opt)
673 {
674 int i;
675
676
2/2
✓ Branch 0 taken 565412 times.
✓ Branch 1 taken 183559 times.
 748971 for (i = 0; i < nb_groups; i++) {
677 565412 const OptionGroupDef *p = &groups[i];
678
4/4
✓ Branch 0 taken 374486 times.
✓ Branch 1 taken 190926 times.
✓ Branch 2 taken 7367 times.
✓ Branch 3 taken 367119 times.
 565412 if (p->sep && !strcmp(p->sep, opt))
679 7367 return i;
680 }
681
682 183559 return -1;
683 }
684
685 /*
686 * Finish parsing an option group.
687 *
688 * @param group_idx which group definition should this group belong to
689 * @param arg argument of the group delimiting option
690 */
691 15827 static int finish_group(OptionParseContext *octx, int group_idx,
692 const char *arg)
693 {
694 15827 OptionGroupList *l = &octx->groups[group_idx];
695 OptionGroup *g;
696 int ret;
697
698 15827 ret = GROW_ARRAY(l->groups, l->nb_groups);
699
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15827 times.
 15827 if (ret < 0)
700 ✗ return ret;
701
702 15827 g = &l->groups[l->nb_groups - 1];
703
704 15827 *g = octx->cur_group;
705 15827 g->arg = arg;
706 15827 g->group_def = l->group_def;
707 15827 g->sws_dict = sws_dict;
708 15827 g->swr_opts = swr_opts;
709 15827 g->codec_opts = codec_opts;
710 15827 g->format_opts = format_opts;
711
712 15827 codec_opts = NULL;
713 15827 format_opts = NULL;
714 15827 sws_dict = NULL;
715 15827 swr_opts = NULL;
716
717 15827 memset(&octx->cur_group, 0, sizeof(octx->cur_group));
718
719 15827 return ret;
720 }
721
722 /*
723 * Add an option instance to currently parsed group.
724 */
725 91146 static int add_opt(OptionParseContext *octx, const OptionDef *opt,
726 const char *key, const char *val)
727 {
728 91146 int global = !(opt->flags & OPT_PERFILE);
729
2/2
✓ Branch 0 taken 41477 times.
✓ Branch 1 taken 49669 times.
 91146 OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
730 int ret;
731
732 91146 ret = GROW_ARRAY(g->opts, g->nb_opts);
733
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 91146 times.
 91146 if (ret < 0)
734 ✗ return ret;
735
736 91146 g->opts[g->nb_opts - 1].opt = opt;
737 91146 g->opts[g->nb_opts - 1].key = key;
738 91146 g->opts[g->nb_opts - 1].val = val;
739
740 91146 return 0;
741 }
742
743 8457 static int init_parse_context(OptionParseContext *octx,
744 const OptionGroupDef *groups, int nb_groups)
745 {
746 static const OptionGroupDef global_group = { "global" };
747 int i;
748
749 8457 memset(octx, 0, sizeof(*octx));
750
751 8457 octx->groups = av_calloc(nb_groups, sizeof(*octx->groups));
752
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8457 times.
 8457 if (!octx->groups)
753 ✗ return AVERROR(ENOMEM);
754 8457 octx->nb_groups = nb_groups;
755
756
2/2
✓ Branch 0 taken 25371 times.
✓ Branch 1 taken 8457 times.
 33828 for (i = 0; i < octx->nb_groups; i++)
757 25371 octx->groups[i].group_def = &groups[i];
758
759 8457 octx->global_opts.group_def = &global_group;
760 8457 octx->global_opts.arg = "";
761
762 8457 return 0;
763 }
764
765 8457 void uninit_parse_context(OptionParseContext *octx)
766 {
767 int i, j;
768
769
2/2
✓ Branch 0 taken 25371 times.
✓ Branch 1 taken 8457 times.
 33828 for (i = 0; i < octx->nb_groups; i++) {
770 25371 OptionGroupList *l = &octx->groups[i];
771
772
2/2
✓ Branch 0 taken 15827 times.
✓ Branch 1 taken 25371 times.
 41198 for (j = 0; j < l->nb_groups; j++) {
773 15827 av_freep(&l->groups[j].opts);
774 15827 av_dict_free(&l->groups[j].codec_opts);
775 15827 av_dict_free(&l->groups[j].format_opts);
776
777 15827 av_dict_free(&l->groups[j].sws_dict);
778 15827 av_dict_free(&l->groups[j].swr_opts);
779 }
780 25371 av_freep(&l->groups);
781 }
782 8457 av_freep(&octx->groups);
783
784 8457 av_freep(&octx->cur_group.opts);
785 8457 av_freep(&octx->global_opts.opts);
786
787 8457 uninit_opts();
788 8457 }
789
790 8457 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
791 const OptionDef *options,
792 const OptionGroupDef *groups, int nb_groups)
793 {
794 int ret;
795 8457 int optindex = 1;
796 8457 int dashdash = -2;
797
798 /* perform system-dependent conversions for arguments list */
799 8457 prepare_app_arguments(&argc, &argv);
800
801 8457 ret = init_parse_context(octx, groups, nb_groups);
802
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8457 times.
 8457 if (ret < 0)
803 ✗ return ret;
804
805 8457 av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
806
807
2/2
✓ Branch 0 taken 199386 times.
✓ Branch 1 taken 8457 times.
 207843 while (optindex < argc) {
808 199386 const char *opt = argv[optindex++], *arg;
809 const OptionDef *po;
810 int group_idx;
811
812 199386 av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
813
814
3/6
✓ Branch 0 taken 193621 times.
✓ Branch 1 taken 5765 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 193621 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 199386 if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
815 ✗ dashdash = optindex;
816 ✗ continue;
817 }
818 /* unnamed group separators, e.g. output filename */
819
5/6
✓ Branch 0 taken 193621 times.
✓ Branch 1 taken 5765 times.
✓ Branch 2 taken 190926 times.
✓ Branch 3 taken 2695 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 190926 times.
 199386 if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
820 8460 ret = finish_group(octx, 0, opt);
821
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8460 times.
 8460 if (ret < 0)
822 ✗ return ret;
823
824 8460 av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
825 8460 continue;
826 }
827 190926 opt++;
828
829 #define GET_ARG(arg) \
830 do { \
831 arg = argv[optindex++]; \
832 if (!arg) { \
833 av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
834 return AVERROR(EINVAL); \
835 } \
836 } while (0)
837
838 /* named group separators, e.g. -i */
839 190926 group_idx = match_group_separator(groups, nb_groups, opt);
840
2/2
✓ Branch 0 taken 7367 times.
✓ Branch 1 taken 183559 times.
 190926 if (group_idx >= 0) {
841
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7367 times.
 7367 GET_ARG(arg);
842 7367 ret = finish_group(octx, group_idx, arg);
843
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7367 times.
 7367 if (ret < 0)
844 ✗ return ret;
845
846 7367 av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
847 7367 groups[group_idx].name, arg);
848 7367 continue;
849 }
850
851 /* normal options */
852 183559 po = find_option(options, opt);
853
2/2
✓ Branch 0 taken 65826 times.
✓ Branch 1 taken 117733 times.
 183559 if (po->name) {
854
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 65825 times.
 65826 if (po->flags & OPT_EXIT) {
855 /* optional argument, e.g. -h */
856 1 arg = argv[optindex++];
857
2/2
✓ Branch 1 taken 58514 times.
✓ Branch 2 taken 7311 times.
 65825 } else if (opt_has_arg(po)) {
858
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58514 times.
 58514 GET_ARG(arg);
859 } else {
860 7311 arg = "1";
861 }
862
863 65826 ret = add_opt(octx, po, opt, arg);
864
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 65826 times.
 65826 if (ret < 0)
865 ✗ return ret;
866
867 65826 av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
868 65826 "argument '%s'.\n", po->name, po->help, arg);
869 65826 continue;
870 }
871
872 /* AVOptions */
873
1/2
✓ Branch 0 taken 117733 times.
✗ Branch 1 not taken.
 117733 if (argv[optindex]) {
874 117733 ret = opt_default(NULL, opt, argv[optindex]);
875
2/2
✓ Branch 0 taken 92413 times.
✓ Branch 1 taken 25320 times.
 117733 if (ret >= 0) {
876 92413 av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
877 92413 "argument '%s'.\n", opt, argv[optindex]);
878 92413 optindex++;
879 92413 continue;
880
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25320 times.
 25320 } else if (ret != AVERROR_OPTION_NOT_FOUND) {
881 ✗ av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
882 ✗ "with argument '%s'.\n", opt, argv[optindex]);
883 ✗ return ret;
884 }
885 }
886
887 /* boolean -nofoo options */
888
3/6
✓ Branch 0 taken 25320 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25320 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 25320 times.
✗ Branch 5 not taken.
 50640 if (opt[0] == 'n' && opt[1] == 'o' &&
889 25320 (po = find_option(options, opt + 2)) &&
890
2/4
✓ Branch 0 taken 25320 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25320 times.
✗ Branch 3 not taken.
 25320 po->name && po->type == OPT_TYPE_BOOL) {
891 25320 ret = add_opt(octx, po, opt, "0");
892
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25320 times.
 25320 if (ret < 0)
893 ✗ return ret;
894
895 25320 av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
896 25320 "argument 0.\n", po->name, po->help);
897 25320 continue;
898 }
899
900 ✗ av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
901 ✗ return AVERROR_OPTION_NOT_FOUND;
902 }
903
904
3/6
✓ Branch 0 taken 8457 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8457 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8457 times.
 8457 if (octx->cur_group.nb_opts || codec_opts || format_opts)
905 ✗ av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
906 "command: may be ignored.\n");
907
908 8457 av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
909
910 8457 return 0;
911 }
912
913 ✗ int read_yesno(void)
914 {
915 ✗ int c = getchar();
916 ✗ int yesno = (av_toupper(c) == 'Y');
917
918 ✗ while (c != '\n' && c != EOF)
919 ✗ c = getchar();
920
921 ✗ return yesno;
922 }
923
924 ✗ FILE *get_preset_file(char *filename, size_t filename_size,
925 const char *preset_name, int is_path,
926 const char *codec_name)
927 {
928 ✗ FILE *f = NULL;
929 int i;
930 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
931 char *datadir = NULL;
932 #endif
933 ✗ char *env_home = getenv_utf8("HOME");
934 ✗ char *env_ffmpeg_datadir = getenv_utf8("FFMPEG_DATADIR");
935 ✗ const char *base[3] = { env_ffmpeg_datadir,
936 env_home, /* index=1(HOME) is special: search in a .ffmpeg subfolder */
937 FFMPEG_DATADIR, };
938
939 ✗ if (is_path) {
940 ✗ av_strlcpy(filename, preset_name, filename_size);
941 ✗ f = fopen_utf8(filename, "r");
942 } else {
943 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
944 wchar_t *datadir_w = get_module_filename(NULL);
945 base[2] = NULL;
946
947 if (wchartoutf8(datadir_w, &datadir))
948 datadir = NULL;
949 av_free(datadir_w);
950
951 if (datadir)
952 {
953 char *ls;
954 for (ls = datadir; *ls; ls++)
955 if (*ls == '\\') *ls = '/';
956
957 if (ls = strrchr(datadir, '/'))
958 {
959 ptrdiff_t datadir_len = ls - datadir;
960 size_t desired_size = datadir_len + strlen("/ffpresets") + 1;
961 char *new_datadir = av_realloc_array(
962 datadir, desired_size, sizeof *datadir);
963 if (new_datadir) {
964 datadir = new_datadir;
965 datadir[datadir_len] = 0;
966 strncat(datadir, "/ffpresets", desired_size - 1 - datadir_len);
967 base[2] = datadir;
968 }
969 }
970 }
971 #endif
972 ✗ for (i = 0; i < 3 && !f; i++) {
973 ✗ if (!base[i])
974 ✗ continue;
975 ✗ snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
976 i != 1 ? "" : "/.ffmpeg", preset_name);
977 ✗ f = fopen_utf8(filename, "r");
978 ✗ if (!f && codec_name) {
979 ✗ snprintf(filename, filename_size,
980 "%s%s/%s-%s.ffpreset",
981 base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
982 preset_name);
983 ✗ f = fopen_utf8(filename, "r");
984 }
985 }
986 }
987
988 #if HAVE_GETMODULEHANDLE && defined(_WIN32)
989 av_free(datadir);
990 #endif
991 ✗ freeenv_utf8(env_ffmpeg_datadir);
992 ✗ freeenv_utf8(env_home);
993 ✗ return f;
994 }
995
996 17137 int cmdutils_isalnum(char c)
997 {
998
4/4
✓ Branch 0 taken 245 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 48 times.
✓ Branch 3 taken 17088 times.
 17137 return (c >= '0' && c <= '9') ||
999
5/6
✓ Branch 0 taken 246 times.
✓ Branch 1 taken 16891 times.
✓ Branch 2 taken 48 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 47 times.
✓ Branch 5 taken 17089 times.
 34321 (c >= 'A' && c <= 'Z') ||
1000
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 (c >= 'a' && c <= 'z');
1001 }
1002
1003 34160 void stream_specifier_uninit(StreamSpecifier *ss)
1004 {
1005 34160 av_freep(&ss->meta_key);
1006 34160 av_freep(&ss->meta_val);
1007 34160 av_freep(&ss->remainder);
1008
1009 34160 memset(ss, 0, sizeof(*ss));
1010 34160 }
1011
1012 34156 int stream_specifier_parse(StreamSpecifier *ss, const char *spec,
1013 int allow_remainder, void *logctx)
1014 {
1015 char *endptr;
1016 int ret;
1017
1018 34156 memset(ss, 0, sizeof(*ss));
1019
1020 34156 ss->idx = -1;
1021 34156 ss->media_type = AVMEDIA_TYPE_UNKNOWN;
1022 34156 ss->stream_list = STREAM_LIST_ALL;
1023
1024 34156 av_log(logctx, AV_LOG_TRACE, "Parsing stream specifier: %s\n", spec);
1025
1026
2/2
✓ Branch 0 taken 17661 times.
✓ Branch 1 taken 33619 times.
 85436 while (*spec) {
1027
3/4
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 17211 times.
✓ Branch 2 taken 450 times.
✗ Branch 3 not taken.
 17661 if (*spec <= '9' && *spec >= '0') { /* opt:index */
1028 450 ss->idx = strtol(spec, &endptr, 0);
1029
1030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 450 times.
 450 av_assert0(endptr > spec);
1031 450 spec = endptr;
1032
1033 450 av_log(logctx, AV_LOG_TRACE,
1034 "Parsed index: %d; remainder: %s\n", ss->idx, spec);
1035
1036 // this terminates the specifier
1037 450 break;
1038
6/6
✓ Branch 0 taken 1704 times.
✓ Branch 1 taken 15507 times.
✓ Branch 2 taken 164 times.
✓ Branch 3 taken 1540 times.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 53 times.
 17211 } else if ((*spec == 'v' || *spec == 'a' || *spec == 's' ||
1039
7/8
✓ Branch 0 taken 108 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 105 times.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 105 times.
✓ Branch 6 taken 17084 times.
✓ Branch 7 taken 22 times.
 17217 *spec == 'd' || *spec == 't' || *spec == 'V') &&
1040 17106 !cmdutils_isalnum(*(spec + 1))) { /* opt:[vasdtV] */
1041
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17084 times.
 17084 if (ss->media_type != AVMEDIA_TYPE_UNKNOWN) {
1042 ✗ av_log(logctx, AV_LOG_ERROR, "Stream type specified multiple times\n");
1043 ✗ ret = AVERROR(EINVAL);
1044 ✗ goto fail;
1045 }
1046
1047
5/7
✓ Branch 0 taken 15492 times.
✓ Branch 1 taken 1536 times.
✓ Branch 2 taken 51 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 17084 switch (*spec++) {
1048 15492 case 'v': ss->media_type = AVMEDIA_TYPE_VIDEO; break;
1049 1536 case 'a': ss->media_type = AVMEDIA_TYPE_AUDIO; break;
1050 51 case 's': ss->media_type = AVMEDIA_TYPE_SUBTITLE; break;
1051 2 case 'd': ss->media_type = AVMEDIA_TYPE_DATA; break;
1052 3 case 't': ss->media_type = AVMEDIA_TYPE_ATTACHMENT; break;
1053 ✗ case 'V': ss->media_type = AVMEDIA_TYPE_VIDEO;
1054 ✗ ss->no_apic = 1; break;
1055 ✗ default: av_assert0(0);
1056 }
1057
1058 17084 av_log(logctx, AV_LOG_TRACE, "Parsed media type: %s; remainder: %s\n",
1059 av_get_media_type_string(ss->media_type), spec);
1060
3/4
✓ Branch 0 taken 39 times.
✓ Branch 1 taken 88 times.
✓ Branch 2 taken 39 times.
✗ Branch 3 not taken.
 127 } else if (*spec == 'g' && *(spec + 1) == ':') {
1061
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
 39 if (ss->stream_list != STREAM_LIST_ALL)
1062 ✗ goto multiple_stream_lists;
1063
1064 39 spec += 2;
1065
5/6
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 36 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 39 if (*spec == '#' || (*spec == 'i' && *(spec + 1) == ':')) {
1066 3 ss->stream_list = STREAM_LIST_GROUP_ID;
1067
1068
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
 3 spec += 1 + (*spec == 'i');
1069 } else
1070 36 ss->stream_list = STREAM_LIST_GROUP_IDX;
1071
1072 39 ss->list_id = strtol(spec, &endptr, 0);
1073
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
 39 if (spec == endptr) {
1074 ✗ av_log(logctx, AV_LOG_ERROR, "Expected stream group idx/ID, got: %s\n", spec);
1075 ✗ ret = AVERROR(EINVAL);
1076 ✗ goto fail;
1077 }
1078 39 spec = endptr;
1079
1080 39 av_log(logctx, AV_LOG_TRACE, "Parsed stream group %s: %"PRId64"; remainder: %s\n",
1081
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 36 times.
 39 ss->stream_list == STREAM_LIST_GROUP_ID ? "ID" : "index", ss->list_id, spec);
1082
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 88 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 88 } else if (*spec == 'p' && *(spec + 1) == ':') {
1083 ✗ if (ss->stream_list != STREAM_LIST_ALL)
1084 ✗ goto multiple_stream_lists;
1085
1086 ✗ ss->stream_list = STREAM_LIST_PROGRAM;
1087
1088 ✗ spec += 2;
1089 ✗ ss->list_id = strtol(spec, &endptr, 0);
1090 ✗ if (spec == endptr) {
1091 ✗ av_log(logctx, AV_LOG_ERROR, "Expected program ID, got: %s\n", spec);
1092 ✗ ret = AVERROR(EINVAL);
1093 ✗ goto fail;
1094 }
1095 ✗ spec = endptr;
1096
1097 ✗ av_log(logctx, AV_LOG_TRACE,
1098 "Parsed program ID: %"PRId64"; remainder: %s\n", ss->list_id, spec);
1099
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 87 times.
 88 } else if (!strncmp(spec, "disp:", 5)) {
1100 1 const AVClass *st_class = av_stream_get_class();
1101 1 const AVOption *o = av_opt_find(&st_class, "disposition", NULL, 0, AV_OPT_SEARCH_FAKE_OBJ);
1102 1 char *disp = NULL;
1103 size_t len;
1104
1105
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 av_assert0(o);
1106
1107
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ss->disposition) {
1108 ✗ av_log(logctx, AV_LOG_ERROR, "Multiple disposition specifiers\n");
1109 ✗ ret = AVERROR(EINVAL);
1110 ✗ goto fail;
1111 }
1112
1113 1 spec += 5;
1114
1115 29 for (len = 0; cmdutils_isalnum(spec[len]) ||
1116
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++)
1117 28 continue;
1118
1119 1 disp = av_strndup(spec, len);
1120
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!disp) {
1121 ✗ ret = AVERROR(ENOMEM);
1122 ✗ goto fail;
1123 }
1124
1125 1 ret = av_opt_eval_flags(&st_class, o, disp, &ss->disposition);
1126 1 av_freep(&disp);
1127
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0) {
1128 ✗ av_log(logctx, AV_LOG_ERROR, "Invalid disposition specifier\n");
1129 ✗ goto fail;
1130 }
1131
1132 1 spec += len;
1133
1134 1 av_log(logctx, AV_LOG_TRACE,
1135 "Parsed disposition: 0x%x; remainder: %s\n", ss->disposition, spec);
1136
1/2
✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
 87 } else if (*spec == '#' ||
1137
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 87 (*spec == 'i' && *(spec + 1) == ':')) {
1138 ✗ if (ss->stream_list != STREAM_LIST_ALL)
1139 ✗ goto multiple_stream_lists;
1140
1141 ✗ ss->stream_list = STREAM_LIST_STREAM_ID;
1142
1143 ✗ spec += 1 + (*spec == 'i');
1144 ✗ ss->list_id = strtol(spec, &endptr, 0);
1145 ✗ if (spec == endptr) {
1146 ✗ av_log(logctx, AV_LOG_ERROR, "Expected stream ID, got: %s\n", spec);
1147 ✗ ret = AVERROR(EINVAL);
1148 ✗ goto fail;
1149 }
1150 ✗ spec = endptr;
1151
1152 ✗ av_log(logctx, AV_LOG_TRACE,
1153 "Parsed stream ID: %"PRId64"; remainder: %s\n", ss->list_id, spec);
1154
1155 // this terminates the specifier
1156 ✗ break;
1157
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 86 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 87 } else if (*spec == 'm' && *(spec + 1) == ':') {
1158 ✗ av_assert0(!ss->meta_key && !ss->meta_val);
1159
1160 ✗ spec += 2;
1161 ✗ ss->meta_key = av_get_token(&spec, ":");
1162 ✗ if (!ss->meta_key) {
1163 ✗ ret = AVERROR(ENOMEM);
1164 ✗ goto fail;
1165 }
1166 ✗ if (*spec == ':') {
1167 ✗ spec++;
1168 ✗ ss->meta_val = av_get_token(&spec, ":");
1169 ✗ if (!ss->meta_val) {
1170 ✗ ret = AVERROR(ENOMEM);
1171 ✗ goto fail;
1172 }
1173 }
1174
1175 ✗ av_log(logctx, AV_LOG_TRACE,
1176 "Parsed metadata: %s:%s; remainder: %s", ss->meta_key,
1177 ✗ ss->meta_val ? ss->meta_val : "<any value>", spec);
1178
1179 // this terminates the specifier
1180 ✗ break;
1181
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 87 } else if (*spec == 'u' && (*(spec + 1) == '\0' || *(spec + 1) == ':')) {
1182 ✗ ss->usable_only = 1;
1183 ✗ spec++;
1184 ✗ av_log(logctx, AV_LOG_ERROR, "Parsed 'usable only'\n");
1185
1186 // this terminates the specifier
1187 ✗ break;
1188 } else
1189 break;
1190
1191
2/2
✓ Branch 0 taken 229 times.
✓ Branch 1 taken 16895 times.
 17124 if (*spec == ':')
1192 229 spec++;
1193 }
1194
1195
2/2
✓ Branch 0 taken 87 times.
✓ Branch 1 taken 34069 times.
 34156 if (*spec) {
1196
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
 87 if (!allow_remainder) {
1197 ✗ av_log(logctx, AV_LOG_ERROR,
1198 "Trailing garbage at the end of a stream specifier: %s\n",
1199 spec);
1200 ✗ ret = AVERROR(EINVAL);
1201 ✗ goto fail;
1202 }
1203
1204
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
 87 if (*spec == ':')
1205 ✗ spec++;
1206
1207 87 ss->remainder = av_strdup(spec);
1208
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
 87 if (!ss->remainder) {
1209 ✗ ret = AVERROR(EINVAL);
1210 ✗ goto fail;
1211 }
1212 }
1213
1214 34156 return 0;
1215
1216 ✗ multiple_stream_lists:
1217 ✗ av_log(logctx, AV_LOG_ERROR,
1218 "Cannot combine multiple program/group designators in a "
1219 "single stream specifier");
1220 ✗ ret = AVERROR(EINVAL);
1221
1222 ✗ fail:
1223 ✗ stream_specifier_uninit(ss);
1224 ✗ return ret;
1225 }
1226
1227 35935 unsigned stream_specifier_match(const StreamSpecifier *ss,
1228 const AVFormatContext *s, const AVStream *st,
1229 void *logctx)
1230 {
1231 35935 const AVStreamGroup *g = NULL;
1232 35935 const AVProgram *p = NULL;
1233 35935 int start_stream = 0, nb_streams;
1234 35935 int nb_matched = 0;
1235
1236
3/6
✗ Branch 0 not taken.
✓ Branch 1 taken 35844 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 82 times.
✗ Branch 5 not taken.
 35935 switch (ss->stream_list) {
1237 ✗ case STREAM_LIST_STREAM_ID:
1238 // <n-th> stream with given ID makes no sense and should be impossible to request
1239 ✗ av_assert0(ss->idx < 0);
1240 // return early if we know for sure the stream does not match
1241 ✗ if (st->id != ss->list_id)
1242 ✗ return 0;
1243 ✗ start_stream = st->index;
1244 ✗ nb_streams = st->index + 1;
1245 ✗ break;
1246 35844 case STREAM_LIST_ALL:
1247
2/2
✓ Branch 0 taken 35138 times.
✓ Branch 1 taken 706 times.
 35844 start_stream = ss->idx >= 0 ? 0 : st->index;
1248 35844 nb_streams = st->index + 1;
1249 35844 break;
1250 ✗ case STREAM_LIST_PROGRAM:
1251 ✗ for (unsigned i = 0; i < s->nb_programs; i++) {
1252 ✗ if (s->programs[i]->id == ss->list_id) {
1253 ✗ p = s->programs[i];
1254 ✗ break;
1255 }
1256 }
1257 ✗ if (!p) {
1258 ✗ av_log(logctx, AV_LOG_WARNING, "No program with ID %"PRId64" exists,"
1259 ✗ " stream specifier can never match\n", ss->list_id);
1260 ✗ return 0;
1261 }
1262 ✗ nb_streams = p->nb_stream_indexes;
1263 ✗ break;
1264 9 case STREAM_LIST_GROUP_ID:
1265
1/2
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
 18 for (unsigned i = 0; i < s->nb_stream_groups; i++) {
1266
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
 18 if (ss->list_id == s->stream_groups[i]->id) {
1267 9 g = s->stream_groups[i];
1268 9 break;
1269 }
1270 }
1271 // fall-through
1272 case STREAM_LIST_GROUP_IDX:
1273
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 9 times.
 91 if (ss->stream_list == STREAM_LIST_GROUP_IDX &&
1274
2/4
✓ Branch 0 taken 82 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 82 times.
✗ Branch 3 not taken.
 82 ss->list_id >= 0 && ss->list_id < s->nb_stream_groups)
1275 82 g = s->stream_groups[ss->list_id];
1276
1277
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 91 times.
 91 if (!g) {
1278 ✗ av_log(logctx, AV_LOG_WARNING, "No stream group with group %s %"
1279 PRId64" exists, stream specifier can never match\n",
1280 ✗ ss->stream_list == STREAM_LIST_GROUP_ID ? "ID" : "index",
1281 ✗ ss->list_id);
1282 ✗ return 0;
1283 }
1284 91 nb_streams = g->nb_streams;
1285 91 break;
1286 ✗ default: av_assert0(0);
1287 }
1288
1289
2/2
✓ Branch 0 taken 37475 times.
✓ Branch 1 taken 474 times.
 37949 for (int i = start_stream; i < nb_streams; i++) {
1290
3/4
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 37294 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 37294 times.
 37475 const AVStream *candidate = s->streams[g ? g->streams[i]->index :
1291 ✗ p ? p->stream_index[i] : i];
1292
1293
2/2
✓ Branch 0 taken 21413 times.
✓ Branch 1 taken 16062 times.
 37475 if (ss->media_type != AVMEDIA_TYPE_UNKNOWN &&
1294
2/2
✓ Branch 0 taken 20700 times.
✓ Branch 1 taken 713 times.
 21413 (ss->media_type != candidate->codecpar->codec_type ||
1295
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 20700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 20700 (ss->no_apic && (candidate->disposition & AV_DISPOSITION_ATTACHED_PIC))))
1296 713 continue;
1297
1298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36762 times.
 36762 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 36762 times.
 36762 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 36707 times.
 36762 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 35461 times.
✓ Branch 1 taken 1257 times.
 36718 if (st == candidate)
1331
4/4
✓ Branch 0 taken 689 times.
✓ Branch 1 taken 34772 times.
✓ Branch 2 taken 237 times.
✓ Branch 3 taken 452 times.
 35461 return ss->idx < 0 || ss->idx == nb_matched;
1332
1333 1257 nb_matched++;
1334 }
1335
1336 474 return 0;
1337 }
1338
1339 521 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1340 {
1341 StreamSpecifier ss;
1342 int ret;
1343
1344 521 ret = stream_specifier_parse(&ss, spec, 0, NULL);
1345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 521 times.
 521 if (ret < 0)
1346 ✗ return ret;
1347
1348 521 ret = stream_specifier_match(&ss, s, st, NULL);
1349 521 stream_specifier_uninit(&ss);
1350 521 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->nb_tiles)
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 25242 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 25242 AVDictionary *ret = NULL;
1429 25242 const AVDictionaryEntry *t = NULL;
1430 50484 int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1431
2/2
✓ Branch 0 taken 8950 times.
✓ Branch 1 taken 16292 times.
 25242 : AV_OPT_FLAG_DECODING_PARAM;
1432 25242 char prefix = 0;
1433 25242 const AVClass *cc = avcodec_get_class();
1434
1435
4/4
✓ Branch 0 taken 19650 times.
✓ Branch 1 taken 5236 times.
✓ Branch 2 taken 267 times.
✓ Branch 3 taken 89 times.
 25242 switch (st->codecpar->codec_type) {
1436 19650 case AVMEDIA_TYPE_VIDEO:
1437 19650 prefix = 'v';
1438 19650 flags |= AV_OPT_FLAG_VIDEO_PARAM;
1439 19650 break;
1440 5236 case AVMEDIA_TYPE_AUDIO:
1441 5236 prefix = 'a';
1442 5236 flags |= AV_OPT_FLAG_AUDIO_PARAM;
1443 5236 break;
1444 267 case AVMEDIA_TYPE_SUBTITLE:
1445 267 prefix = 's';
1446 267 flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1447 267 break;
1448 }
1449
1450
2/2
✓ Branch 1 taken 78170 times.
✓ Branch 2 taken 25242 times.
 103412 while (t = av_dict_iterate(opts, t)) {
1451 const AVClass *priv_class;
1452 78170 char *p = strchr(t->key, ':');
1453 78170 int used = 0;
1454
1455 /* check stream specification in opt name */
1456
2/2
✓ Branch 0 taken 291 times.
✓ Branch 1 taken 77879 times.
 78170 if (p) {
1457 291 int err = check_stream_specifier(s, st, p + 1);
1458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 291 times.
 291 if (err < 0) {
1459 ✗ av_dict_free(&ret);
1460 ✗ return err;
1461
2/2
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 211 times.
 291 } else if (!err)
1462 80 continue;
1463
1464 211 *p = 0;
1465 }
1466
1467
4/4
✓ Branch 1 taken 2898 times.
✓ Branch 2 taken 75192 times.
✓ Branch 3 taken 1667 times.
✓ Branch 4 taken 1231 times.
 78090 if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1468 1667 !codec ||
1469
4/4
✓ Branch 0 taken 777 times.
✓ Branch 1 taken 890 times.
✓ Branch 2 taken 348 times.
✓ Branch 3 taken 429 times.
 2444 ((priv_class = codec->priv_class) &&
1470 777 av_opt_find(&priv_class, t->key, NULL, flags,
1471 AV_OPT_SEARCH_FAKE_OBJ))) {
1472 76771 av_dict_set(&ret, t->key, t->value, 0);
1473 76771 used = 1;
1474
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1314 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 4 times.
 1324 } 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 211 times.
✓ Branch 1 taken 77879 times.
 78090 if (p)
1482 211 *p = ':';
1483
1484
4/4
✓ Branch 0 taken 76772 times.
✓ Branch 1 taken 1318 times.
✓ Branch 2 taken 50600 times.
✓ Branch 3 taken 26172 times.
 78090 if (used && opts_used)
1485 50600 av_dict_set(opts_used, t->key, "", 0);
1486 }
1487
1488 25242 *dst = ret;
1489 25242 return 0;
1490 }
1491
1492 7531 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 7531 *dst = NULL;
1500
1501
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 7441 times.
 7531 if (!s->nb_streams)
1502 90 return 0;
1503
1504 7441 opts = av_calloc(s->nb_streams, sizeof(*opts));
1505
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7441 times.
 7441 if (!opts)
1506 ✗ return AVERROR(ENOMEM);
1507
1508
2/2
✓ Branch 0 taken 8108 times.
✓ Branch 1 taken 7441 times.
 15549 for (int i = 0; i < s->nb_streams; i++) {
1509 8108 ret = filter_codec_opts(local_codec_opts, s->streams[i]->codecpar->codec_id,
1510 8108 s, s->streams[i], NULL, &opts[i], NULL);
1511
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8108 times.
 8108 if (ret < 0)
1512 ✗ goto fail;
1513 }
1514 7441 *dst = opts;
1515 7441 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 255506 int grow_array(void **array, int elem_size, int *size, int new_size)
1524 {
1525
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 255506 times.
 255506 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 255506 times.
✗ Branch 1 not taken.
 255506 if (*size < new_size) {
1530 255506 uint8_t *tmp = av_realloc_array(*array, new_size, elem_size);
1531
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 255506 times.
 255506 if (!tmp)
1532 ✗ return AVERROR(ENOMEM);
1533 255506 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1534 255506 *size = new_size;
1535 255506 *array = tmp;
1536 255506 return 0;
1537 }
1538 ✗ return 0;
1539 }
1540
1541 47906 void *allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
1542 {
1543 void *new_elem;
1544
1545 47906 new_elem = av_mallocz(elem_size);
1546
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47906 times.
 47906 if (!new_elem)
1547 ✗ return NULL;
1548
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47906 times.
 47906 if (av_dynarray_add_nofree(ptr, nb_elems, new_elem) < 0)
1549 ✗ av_freep(&new_elem);
1550
1551 47906 return new_elem;
1552 }
1553
1554 5733 double get_rotation(const int32_t *displaymatrix)
1555 {
1556 5733 double theta = 0;
1557
1/2
✓ Branch 0 taken 5733 times.
✗ Branch 1 not taken.
 5733 if (displaymatrix)
1558 5733 theta = -round(av_display_rotation_get(displaymatrix));
1559
1560 5733 theta -= 360*floor(theta/360 + 0.9/360);
1561
1562
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5733 times.
 5733 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 5733 return theta;
1569 }
1570
1571 /* read file contents into a string */
1572 71 char *read_file_to_string(const char *filename)
1573 {
1574 71 AVIOContext *pb = NULL;
1575 71 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 71 times.
 71 if (ret < 0) {
1580 ✗ av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1581 ✗ return NULL;
1582 }
1583
1584 71 av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
1585 71 ret = avio_read_to_bprint(pb, &bprint, SIZE_MAX);
1586 71 avio_closep(&pb);
1587
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
 71 if (ret < 0) {
1588 ✗ av_bprint_finalize(&bprint, NULL);
1589 ✗ return NULL;
1590 }
1591 71 ret = av_bprint_finalize(&bprint, &str);
1592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
 71 if (ret < 0)
1593 ✗ return NULL;
1594 71 return str;
1595 }
1596
1597 7366 void remove_avoptions(AVDictionary **a, AVDictionary *b)
1598 {
1599 7366 const AVDictionaryEntry *t = NULL;
1600
1601
2/2
✓ Branch 1 taken 24450 times.
✓ Branch 2 taken 7366 times.
 31816 while ((t = av_dict_iterate(b, t))) {
1602 24450 av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
1603 }
1604 7366 }
1605
1606 22519 int check_avoptions(AVDictionary *m)
1607 {
1608 22519 const AVDictionaryEntry *t = av_dict_iterate(m, NULL);
1609
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22519 times.
 22519 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 22519 return 0;
1615 }
1616