GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/cmdutils.c Lines: 441 1222 36.1 %
Date: 2020-09-28 00:47:38 Branches: 334 1052 31.7 %

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 "libavfilter/avfilter.h"
36
#include "libavdevice/avdevice.h"
37
#include "libavresample/avresample.h"
38
#include "libswscale/swscale.h"
39
#include "libswresample/swresample.h"
40
#include "libpostproc/postprocess.h"
41
#include "libavutil/attributes.h"
42
#include "libavutil/avassert.h"
43
#include "libavutil/avstring.h"
44
#include "libavutil/bprint.h"
45
#include "libavutil/display.h"
46
#include "libavutil/mathematics.h"
47
#include "libavutil/imgutils.h"
48
#include "libavutil/libm.h"
49
#include "libavutil/parseutils.h"
50
#include "libavutil/pixdesc.h"
51
#include "libavutil/eval.h"
52
#include "libavutil/dict.h"
53
#include "libavutil/opt.h"
54
#include "libavutil/cpu.h"
55
#include "libavutil/ffversion.h"
56
#include "libavutil/version.h"
57
#include "cmdutils.h"
58
#if HAVE_SYS_RESOURCE_H
59
#include <sys/time.h>
60
#include <sys/resource.h>
61
#endif
62
#ifdef _WIN32
63
#include <windows.h>
64
#endif
65
66
static int init_report(const char *env);
67
68
AVDictionary *sws_dict;
69
AVDictionary *swr_opts;
70
AVDictionary *format_opts, *codec_opts, *resample_opts;
71
72
static FILE *report_file;
73
static int report_file_level = AV_LOG_DEBUG;
74
int hide_banner = 0;
75
76
enum show_muxdemuxers {
77
    SHOW_DEFAULT,
78
    SHOW_DEMUXERS,
79
    SHOW_MUXERS,
80
};
81
82
18018
void init_opts(void)
83
{
84
18018
    av_dict_set(&sws_dict, "flags", "bicubic", 0);
85
18018
}
86
87
12016
void uninit_opts(void)
88
{
89
12016
    av_dict_free(&swr_opts);
90
12016
    av_dict_free(&sws_dict);
91
12016
    av_dict_free(&format_opts);
92
12016
    av_dict_free(&codec_opts);
93
12016
    av_dict_free(&resample_opts);
94
12016
}
95
96
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
97
{
98
    vfprintf(stdout, fmt, vl);
99
}
100
101
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
102
{
103
    va_list vl2;
104
    char line[1024];
105
    static int print_prefix = 1;
106
107
    va_copy(vl2, vl);
108
    av_log_default_callback(ptr, level, fmt, vl);
109
    av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
110
    va_end(vl2);
111
    if (report_file_level >= level) {
112
        fputs(line, report_file);
113
        fflush(report_file);
114
    }
115
}
116
117
6046
void init_dynload(void)
118
{
119
#if HAVE_SETDLLDIRECTORY && defined(_WIN32)
120
    /* Calling SetDllDirectory with the empty string (but not NULL) removes the
121
     * current working directory from the DLL search path as a security pre-caution. */
122
    SetDllDirectory("");
123
#endif
124
6046
}
125
126
static void (*program_exit)(int ret);
127
128
6046
void register_exit(void (*cb)(int ret))
129
{
130
6046
    program_exit = cb;
131
6046
}
132
133
5972
void exit_program(int ret)
134
{
135
5972
    if (program_exit)
136
5972
        program_exit(ret);
137
138
5972
    exit(ret);
139
}
140
141
28357
double parse_number_or_die(const char *context, const char *numstr, int type,
142
                           double min, double max)
143
{
144
    char *tail;
145
    const char *error;
146
28357
    double d = av_strtod(numstr, &tail);
147
28357
    if (*tail)
148
        error = "Expected number for %s but found: %s\n";
149

28357
    else if (d < min || d > max)
150
        error = "The value for %s was %s which is not within %f - %f\n";
151

28357
    else if (type == OPT_INT64 && (int64_t)d != d)
152
        error = "Expected int64 for %s but found %s\n";
153

28357
    else if (type == OPT_INT && (int)d != d)
154
        error = "Expected int for %s but found %s\n";
155
    else
156
28357
        return d;
157
    av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
158
    exit_program(1);
159
    return 0;
160
}
161
162
155
int64_t parse_time_or_die(const char *context, const char *timestr,
163
                          int is_duration)
164
{
165
    int64_t us;
166
155
    if (av_parse_time(&us, timestr, is_duration) < 0) {
167
        av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
168
               is_duration ? "duration" : "date", context, timestr);
169
        exit_program(1);
170
    }
171
155
    return us;
172
}
173
174
void show_help_options(const OptionDef *options, const char *msg, int req_flags,
175
                       int rej_flags, int alt_flags)
176
{
177
    const OptionDef *po;
178
    int first;
179
180
    first = 1;
181
    for (po = options; po->name; po++) {
182
        char buf[128];
183
184
        if (((po->flags & req_flags) != req_flags) ||
185
            (alt_flags && !(po->flags & alt_flags)) ||
186
            (po->flags & rej_flags))
187
            continue;
188
189
        if (first) {
190
            printf("%s\n", msg);
191
            first = 0;
192
        }
193
        av_strlcpy(buf, po->name, sizeof(buf));
194
        if (po->argname) {
195
            av_strlcat(buf, " ", sizeof(buf));
196
            av_strlcat(buf, po->argname, sizeof(buf));
197
        }
198
        printf("-%-17s  %s\n", buf, po->help);
199
    }
200
    printf("\n");
201
}
202
203
void show_help_children(const AVClass *class, int flags)
204
{
205
    void *iter = NULL;
206
    const AVClass *child;
207
    if (class->option) {
208
        av_opt_show2(&class, NULL, flags, 0);
209
        printf("\n");
210
    }
211
212
    while (child = av_opt_child_class_iterate(class, &iter))
213
        show_help_children(child, flags);
214
}
215
216
897134
static const OptionDef *find_option(const OptionDef *po, const char *name)
217
{
218
897134
    const char *p = strchr(name, ':');
219
897134
    int len = p ? p - name : strlen(name);
220
221
121458308
    while (po->name) {
222

120951635
        if (!strncmp(name, po->name, len) && strlen(po->name) == len)
223
390461
            break;
224
120561174
        po++;
225
    }
226
897134
    return po;
227
}
228
229
/* _WIN32 means using the windows libc - cygwin doesn't define that
230
 * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
231
 * it doesn't provide the actual command line via GetCommandLineW(). */
232
#if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
233
#include <shellapi.h>
234
/* Will be leaked on exit */
235
static char** win32_argv_utf8 = NULL;
236
static int win32_argc = 0;
237
238
/**
239
 * Prepare command line arguments for executable.
240
 * For Windows - perform wide-char to UTF-8 conversion.
241
 * Input arguments should be main() function arguments.
242
 * @param argc_ptr Arguments number (including executable)
243
 * @param argv_ptr Arguments list.
244
 */
245
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
246
{
247
    char *argstr_flat;
248
    wchar_t **argv_w;
249
    int i, buffsize = 0, offset = 0;
250
251
    if (win32_argv_utf8) {
252
        *argc_ptr = win32_argc;
253
        *argv_ptr = win32_argv_utf8;
254
        return;
255
    }
256
257
    win32_argc = 0;
258
    argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
259
    if (win32_argc <= 0 || !argv_w)
260
        return;
261
262
    /* determine the UTF-8 buffer size (including NULL-termination symbols) */
263
    for (i = 0; i < win32_argc; i++)
264
        buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
265
                                        NULL, 0, NULL, NULL);
266
267
    win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
268
    argstr_flat     = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
269
    if (!win32_argv_utf8) {
270
        LocalFree(argv_w);
271
        return;
272
    }
273
274
    for (i = 0; i < win32_argc; i++) {
275
        win32_argv_utf8[i] = &argstr_flat[offset];
276
        offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
277
                                      &argstr_flat[offset],
278
                                      buffsize - offset, NULL, NULL);
279
    }
280
    win32_argv_utf8[i] = NULL;
281
    LocalFree(argv_w);
282
283
    *argc_ptr = win32_argc;
284
    *argv_ptr = win32_argv_utf8;
285
}
286
#else
287
6046
static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
288
{
289
    /* nothing to do */
290
6046
}
291
#endif /* HAVE_COMMANDLINETOARGVW */
292
293
71304
static int write_option(void *optctx, const OptionDef *po, const char *opt,
294
                        const char *arg)
295
{
296
    /* new-style options contain an offset into optctx, old-style address of
297
     * a global var*/
298
142608
    void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
299
71304
                (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
300
    int *dstcount;
301
302
71304
    if (po->flags & OPT_SPEC) {
303
24426
        SpecifierOpt **so = dst;
304
24426
        char *p = strchr(opt, ':');
305
        char *str;
306
307
24426
        dstcount = (int *)(so + 1);
308
24426
        *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
309
24426
        str = av_strdup(p ? p + 1 : "");
310
24426
        if (!str)
311
            return AVERROR(ENOMEM);
312
24426
        (*so)[*dstcount - 1].specifier = str;
313
24426
        dst = &(*so)[*dstcount - 1].u;
314
    }
315
316
71304
    if (po->flags & OPT_STRING) {
317
        char *str;
318
28542
        str = av_strdup(arg);
319
28542
        av_freep(dst);
320
28542
        if (!str)
321
            return AVERROR(ENOMEM);
322
28542
        *(char **)dst = str;
323

42762
    } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
324
23361
        *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
325
19401
    } else if (po->flags & OPT_INT64) {
326
4268
        *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
327
15133
    } else if (po->flags & OPT_TIME) {
328
153
        *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
329
14980
    } else if (po->flags & OPT_FLOAT) {
330
1
        *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
331
14979
    } else if (po->flags & OPT_DOUBLE) {
332
254
        *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
333
14725
    } else if (po->u.func_arg) {
334
14725
        int ret = po->u.func_arg(optctx, opt, arg);
335
14725
        if (ret < 0) {
336
            av_log(NULL, AV_LOG_ERROR,
337
                   "Failed to set value '%s' for option '%s': %s\n",
338
                   arg, opt, av_err2str(ret));
339
            return ret;
340
        }
341
    }
342
71304
    if (po->flags & OPT_EXIT)
343
1
        exit_program(0);
344
345
71303
    return 0;
346
}
347
348
7742
int parse_option(void *optctx, const char *opt, const char *arg,
349
                 const OptionDef *options)
350
{
351
    const OptionDef *po;
352
    int ret;
353
354
7742
    po = find_option(options, opt);
355

7742
    if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
356
        /* handle 'no' bool option */
357
        po = find_option(options, opt + 2);
358
        if ((po->name && (po->flags & OPT_BOOL)))
359
            arg = "0";
360
7742
    } else if (po->flags & OPT_BOOL)
361
56
        arg = "1";
362
363
7742
    if (!po->name)
364
6
        po = find_option(options, "default");
365
7742
    if (!po->name) {
366
        av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
367
        return AVERROR(EINVAL);
368
    }
369

7742
    if (po->flags & HAS_ARG && !arg) {
370
        av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
371
        return AVERROR(EINVAL);
372
    }
373
374
7742
    ret = write_option(optctx, po, opt, arg);
375
7742
    if (ret < 0)
376
        return ret;
377
378
7742
    return !!(po->flags & HAS_ARG);
379
}
380
381
74
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
382
                   void (*parse_arg_function)(void *, const char*))
383
{
384
    const char *opt;
385
74
    int optindex, handleoptions = 1, ret;
386
387
    /* perform system-dependent conversions for arguments list */
388
74
    prepare_app_arguments(&argc, &argv);
389
390
    /* parse options */
391
74
    optindex = 1;
392
418
    while (optindex < argc) {
393
344
        opt = argv[optindex++];
394
395

344
        if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
396

277
            if (opt[1] == '-' && opt[2] == '\0') {
397
                handleoptions = 0;
398
                continue;
399
            }
400
277
            opt++;
401
402
277
            if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
403
                exit_program(1);
404
277
            optindex += ret;
405
        } else {
406
67
            if (parse_arg_function)
407
67
                parse_arg_function(optctx, opt);
408
        }
409
    }
410
74
}
411
412
17943
int parse_optgroup(void *optctx, OptionGroup *g)
413
{
414
    int i, ret;
415
416
17943
    av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
417
17943
           g->group_def->name, g->arg);
418
419
81504
    for (i = 0; i < g->nb_opts; i++) {
420
63562
        Option *o = &g->opts[i];
421
422
63562
        if (g->group_def->flags &&
423
35576
            !(g->group_def->flags & o->opt->flags)) {
424
            av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
425
                   "%s %s -- you are trying to apply an input option to an "
426
                   "output file or vice versa. Move this option before the "
427
                   "file it belongs to.\n", o->key, o->opt->help,
428
                   g->group_def->name, g->arg);
429
            return AVERROR(EINVAL);
430
        }
431
432
63562
        av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
433
63562
               o->key, o->opt->help, o->val);
434
435
63562
        ret = write_option(optctx, o->opt, o->key, o->val);
436
63561
        if (ret < 0)
437
            return ret;
438
    }
439
440
17942
    av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
441
442
17942
    return 0;
443
}
444
445
30230
int locate_option(int argc, char **argv, const OptionDef *options,
446
                  const char *optname)
447
{
448
    const OptionDef *po;
449
    int i;
450
451
708412
    for (i = 1; i < argc; i++) {
452
678196
        const char *cur_opt = argv[i];
453
454
678196
        if (*cur_opt++ != '-')
455
19113
            continue;
456
457
659083
        po = find_option(options, cur_opt);
458

659083
        if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
459
89150
            po = find_option(options, cur_opt + 2);
460
461

659083
        if ((!po->name && !strcmp(cur_opt, optname)) ||
462

659083
             (po->name && !strcmp(optname, po->name)))
463
14
            return i;
464
465

659069
        if (!po->name || po->flags & HAS_ARG)
466
542609
            i++;
467
    }
468
30216
    return 0;
469
}
470
471
static void dump_argument(const char *a)
472
{
473
    const unsigned char *p;
474
475
    for (p = a; *p; p++)
476
        if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
477
              *p == '_' || (*p >= 'a' && *p <= 'z')))
478
            break;
479
    if (!*p) {
480
        fputs(a, report_file);
481
        return;
482
    }
483
    fputc('"', report_file);
484
    for (p = a; *p; p++) {
485
        if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
486
            fprintf(report_file, "\\%c", *p);
487
        else if (*p < ' ' || *p > '~')
488
            fprintf(report_file, "\\x%02x", *p);
489
        else
490
            fputc(*p, report_file);
491
    }
492
    fputc('"', report_file);
493
}
494
495
6046
static void check_options(const OptionDef *po)
496
{
497
1079844
    while (po->name) {
498
1073798
        if (po->flags & OPT_PERFILE)
499
191104
            av_assert0(po->flags & (OPT_INPUT | OPT_OUTPUT));
500
1073798
        po++;
501
    }
502
6046
}
503
504
6046
void parse_loglevel(int argc, char **argv, const OptionDef *options)
505
{
506
6046
    int idx = locate_option(argc, argv, options, "loglevel");
507
    const char *env;
508
509
6046
    check_options(options);
510
511
6046
    if (!idx)
512
6046
        idx = locate_option(argc, argv, options, "v");
513

6046
    if (idx && argv[idx + 1])
514
14
        opt_loglevel(NULL, "loglevel", argv[idx + 1]);
515
6046
    idx = locate_option(argc, argv, options, "report");
516

6046
    if ((env = getenv("FFREPORT")) || idx) {
517
        init_report(env);
518
        if (report_file) {
519
            int i;
520
            fprintf(report_file, "Command line:\n");
521
            for (i = 0; i < argc; i++) {
522
                dump_argument(argv[i]);
523
                fputc(i < argc - 1 ? ' ' : '\n', report_file);
524
            }
525
            fflush(report_file);
526
        }
527
    }
528
6046
    idx = locate_option(argc, argv, options, "hide_banner");
529
6046
    if (idx)
530
        hide_banner = 1;
531
6046
}
532
533
288993
static const AVOption *opt_find(void *obj, const char *name, const char *unit,
534
                            int opt_flags, int search_flags)
535
{
536
288993
    const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
537

288993
    if(o && !o->flags)
538
2
        return NULL;
539
288991
    return o;
540
}
541
542
#define FLAGS (o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0
543
77598
int opt_default(void *optctx, const char *opt, const char *arg)
544
{
545
    const AVOption *o;
546
77598
    int consumed = 0;
547
    char opt_stripped[128];
548
    const char *p;
549
77598
    const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
550
#if CONFIG_AVRESAMPLE
551
77598
    const AVClass *rc = avresample_get_class();
552
#endif
553
#if CONFIG_SWSCALE
554
77598
    const AVClass *sc = sws_get_class();
555
#endif
556
#if CONFIG_SWRESAMPLE
557
77598
    const AVClass *swr_class = swr_get_class();
558
#endif
559
560

77598
    if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
561
        av_log_set_level(AV_LOG_DEBUG);
562
563
77598
    if (!(p = strchr(opt, ':')))
564
77598
        p = opt + strlen(opt);
565
77598
    av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
566
567
77598
    if ((o = opt_find(&cc, opt_stripped, NULL, 0,
568
38253
                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
569


48543
        ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
570
10290
         (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
571

39346
        av_dict_set(&codec_opts, opt, arg, FLAGS);
572
39346
        consumed = 1;
573
    }
574
77598
    if ((o = opt_find(&fc, opt, NULL, 0,
575
                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
576

10238
        av_dict_set(&format_opts, opt, arg, FLAGS);
577
10238
        if (consumed)
578
70
            av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
579
10238
        consumed = 1;
580
    }
581
#if CONFIG_SWSCALE
582

77598
    if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
583
                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
584
10259
        struct SwsContext *sws = sws_alloc_context();
585
10259
        int ret = av_opt_set(sws, opt, arg, 0);
586
10259
        sws_freeContext(sws);
587

10259
        if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
588

10259
            !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
589

10259
            !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
590
            av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
591
            return AVERROR(EINVAL);
592
        }
593
10259
        if (ret < 0) {
594
            av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
595
            return ret;
596
        }
597
598

10259
        av_dict_set(&sws_dict, opt, arg, FLAGS);
599
600
10259
        consumed = 1;
601
    }
602
#else
603
    if (!consumed && !strcmp(opt, "sws_flags")) {
604
        av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
605
        consumed = 1;
606
    }
607
#endif
608
#if CONFIG_SWRESAMPLE
609

77598
    if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
610
                                    AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
611
        struct SwrContext *swr = swr_alloc();
612
        int ret = av_opt_set(swr, opt, arg, 0);
613
        swr_free(&swr);
614
        if (ret < 0) {
615
            av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
616
            return ret;
617
        }
618
        av_dict_set(&swr_opts, opt, arg, FLAGS);
619
        consumed = 1;
620
    }
621
#endif
622
#if CONFIG_AVRESAMPLE
623
77598
    if ((o=opt_find(&rc, opt, NULL, 0,
624
                       AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
625

6
        av_dict_set(&resample_opts, opt, arg, FLAGS);
626
6
        consumed = 1;
627
    }
628
#endif
629
630
77598
    if (consumed)
631
59773
        return 0;
632
17825
    return AVERROR_OPTION_NOT_FOUND;
633
}
634
635
/*
636
 * Check whether given option is a group separator.
637
 *
638
 * @return index of the group definition that matched or -1 if none
639
 */
640
129328
static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
641
                                 const char *opt)
642
{
643
    int i;
644
645
381984
    for (i = 0; i < nb_groups; i++) {
646
258656
        const OptionGroupDef *p = &groups[i];
647

258656
        if (p->sep && !strcmp(p->sep, opt))
648
6000
            return i;
649
    }
650
651
123328
    return -1;
652
}
653
654
/*
655
 * Finish parsing an option group.
656
 *
657
 * @param group_idx which group definition should this group belong to
658
 * @param arg argument of the group delimiting option
659
 */
660
11972
static void finish_group(OptionParseContext *octx, int group_idx,
661
                         const char *arg)
662
{
663
11972
    OptionGroupList *l = &octx->groups[group_idx];
664
    OptionGroup *g;
665
666
11972
    GROW_ARRAY(l->groups, l->nb_groups);
667
11972
    g = &l->groups[l->nb_groups - 1];
668
669
11972
    *g             = octx->cur_group;
670
11972
    g->arg         = arg;
671
11972
    g->group_def   = l->group_def;
672
11972
    g->sws_dict    = sws_dict;
673
11972
    g->swr_opts    = swr_opts;
674
11972
    g->codec_opts  = codec_opts;
675
11972
    g->format_opts = format_opts;
676
11972
    g->resample_opts = resample_opts;
677
678
11972
    codec_opts  = NULL;
679
11972
    format_opts = NULL;
680
11972
    resample_opts = NULL;
681
11972
    sws_dict    = NULL;
682
11972
    swr_opts    = NULL;
683
11972
    init_opts();
684
685
11972
    memset(&octx->cur_group, 0, sizeof(octx->cur_group));
686
11972
}
687
688
/*
689
 * Add an option instance to currently parsed group.
690
 */
691
63563
static void add_opt(OptionParseContext *octx, const OptionDef *opt,
692
                    const char *key, const char *val)
693
{
694
63563
    int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
695
63563
    OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
696
697
63563
    GROW_ARRAY(g->opts, g->nb_opts);
698
63563
    g->opts[g->nb_opts - 1].opt = opt;
699
63563
    g->opts[g->nb_opts - 1].key = key;
700
63563
    g->opts[g->nb_opts - 1].val = val;
701
63563
}
702
703
5972
static void init_parse_context(OptionParseContext *octx,
704
                               const OptionGroupDef *groups, int nb_groups)
705
{
706
    static const OptionGroupDef global_group = { "global" };
707
    int i;
708
709
5972
    memset(octx, 0, sizeof(*octx));
710
711
5972
    octx->nb_groups = nb_groups;
712
5972
    octx->groups    = av_mallocz_array(octx->nb_groups, sizeof(*octx->groups));
713
5972
    if (!octx->groups)
714
        exit_program(1);
715
716
17916
    for (i = 0; i < octx->nb_groups; i++)
717
11944
        octx->groups[i].group_def = &groups[i];
718
719
5972
    octx->global_opts.group_def = &global_group;
720
5972
    octx->global_opts.arg       = "";
721
722
5972
    init_opts();
723
5972
}
724
725
5970
void uninit_parse_context(OptionParseContext *octx)
726
{
727
    int i, j;
728
729
17910
    for (i = 0; i < octx->nb_groups; i++) {
730
11940
        OptionGroupList *l = &octx->groups[i];
731
732
23910
        for (j = 0; j < l->nb_groups; j++) {
733
11970
            av_freep(&l->groups[j].opts);
734
11970
            av_dict_free(&l->groups[j].codec_opts);
735
11970
            av_dict_free(&l->groups[j].format_opts);
736
11970
            av_dict_free(&l->groups[j].resample_opts);
737
738
11970
            av_dict_free(&l->groups[j].sws_dict);
739
11970
            av_dict_free(&l->groups[j].swr_opts);
740
        }
741
11940
        av_freep(&l->groups);
742
    }
743
5970
    av_freep(&octx->groups);
744
745
5970
    av_freep(&octx->cur_group.opts);
746
5970
    av_freep(&octx->global_opts.opts);
747
748
5970
    uninit_opts();
749
5970
}
750
751
5972
int split_commandline(OptionParseContext *octx, int argc, char *argv[],
752
                      const OptionDef *options,
753
                      const OptionGroupDef *groups, int nb_groups)
754
{
755
5972
    int optindex = 1;
756
5972
    int dashdash = -2;
757
758
    /* perform system-dependent conversions for arguments list */
759
5972
    prepare_app_arguments(&argc, &argv);
760
761
5972
    init_parse_context(octx, groups, nb_groups);
762
5972
    av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
763
764
141272
    while (optindex < argc) {
765
135300
        const char *opt = argv[optindex++], *arg;
766
        const OptionDef *po;
767
        int ret;
768
769
135300
        av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
770
771

135300
        if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
772
            dashdash = optindex;
773
            continue;
774
        }
775
        /* unnamed group separators, e.g. output filename */
776

135300
        if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
777
5972
            finish_group(octx, 0, opt);
778
5972
            av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
779
5972
            continue;
780
        }
781
129328
        opt++;
782
783
#define GET_ARG(arg)                                                           \
784
do {                                                                           \
785
    arg = argv[optindex++];                                                    \
786
    if (!arg) {                                                                \
787
        av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
788
        return AVERROR(EINVAL);                                                \
789
    }                                                                          \
790
} while (0)
791
792
        /* named group separators, e.g. -i */
793
129328
        if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
794
6000
            GET_ARG(arg);
795
6000
            finish_group(octx, ret, arg);
796
6000
            av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
797
6000
                   groups[ret].name, arg);
798
6000
            continue;
799
        }
800
801
        /* normal options */
802
123328
        po = find_option(options, opt);
803
123328
        if (po->name) {
804
45738
            if (po->flags & OPT_EXIT) {
805
                /* optional argument, e.g. -h */
806
1
                arg = argv[optindex++];
807
45737
            } else if (po->flags & HAS_ARG) {
808
40386
                GET_ARG(arg);
809
            } else {
810
5351
                arg = "1";
811
            }
812
813
45738
            add_opt(octx, po, opt, arg);
814
45738
            av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
815
                   "argument '%s'.\n", po->name, po->help, arg);
816
45738
            continue;
817
        }
818
819
        /* AVOptions */
820
77590
        if (argv[optindex]) {
821
77590
            ret = opt_default(NULL, opt, argv[optindex]);
822
77590
            if (ret >= 0) {
823
59765
                av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
824
59765
                       "argument '%s'.\n", opt, argv[optindex]);
825
59765
                optindex++;
826
59765
                continue;
827
17825
            } else if (ret != AVERROR_OPTION_NOT_FOUND) {
828
                av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
829
                       "with argument '%s'.\n", opt, argv[optindex]);
830
                return ret;
831
            }
832
        }
833
834
        /* boolean -nofoo options */
835

35650
        if (opt[0] == 'n' && opt[1] == 'o' &&
836
17825
            (po = find_option(options, opt + 2)) &&
837

17825
            po->name && po->flags & OPT_BOOL) {
838
17825
            add_opt(octx, po, opt, "0");
839
17825
            av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
840
                   "argument 0.\n", po->name, po->help);
841
17825
            continue;
842
        }
843
844
        av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
845
        return AVERROR_OPTION_NOT_FOUND;
846
    }
847
848


5972
    if (octx->cur_group.nb_opts || codec_opts || format_opts || resample_opts)
849
        av_log(NULL, AV_LOG_WARNING, "Trailing option(s) found in the "
850
               "command: may be ignored.\n");
851
852
5972
    av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
853
854
5972
    return 0;
855
}
856
857
5940
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
858
{
859
    int ret;
860
5940
    unsigned flags = av_get_cpu_flags();
861
862
5940
    if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
863
        return ret;
864
865
5940
    av_force_cpu_flags(flags);
866
5940
    return 0;
867
}
868
869
28
int opt_loglevel(void *optctx, const char *opt, const char *arg)
870
{
871
28
    const struct { const char *name; int level; } log_levels[] = {
872
        { "quiet"  , AV_LOG_QUIET   },
873
        { "panic"  , AV_LOG_PANIC   },
874
        { "fatal"  , AV_LOG_FATAL   },
875
        { "error"  , AV_LOG_ERROR   },
876
        { "warning", AV_LOG_WARNING },
877
        { "info"   , AV_LOG_INFO    },
878
        { "verbose", AV_LOG_VERBOSE },
879
        { "debug"  , AV_LOG_DEBUG   },
880
        { "trace"  , AV_LOG_TRACE   },
881
    };
882
    const char *token;
883
    char *tail;
884
28
    int flags = av_log_get_flags();
885
28
    int level = av_log_get_level();
886
28
    int cmd, i = 0;
887
888
28
    av_assert0(arg);
889
28
    while (*arg) {
890
28
        token = arg;
891

28
        if (*token == '+' || *token == '-') {
892
            cmd = *token++;
893
        } else {
894
28
            cmd = 0;
895
        }
896

28
        if (!i && !cmd) {
897
28
            flags = 0;  /* missing relative prefix, build absolute value */
898
        }
899
28
        if (!strncmp(token, "repeat", 6)) {
900
            if (cmd == '-') {
901
                flags |= AV_LOG_SKIP_REPEATED;
902
            } else {
903
                flags &= ~AV_LOG_SKIP_REPEATED;
904
            }
905
            arg = token + 6;
906
28
        } else if (!strncmp(token, "level", 5)) {
907
            if (cmd == '-') {
908
                flags &= ~AV_LOG_PRINT_LEVEL;
909
            } else {
910
                flags |= AV_LOG_PRINT_LEVEL;
911
            }
912
            arg = token + 5;
913
        } else {
914
28
            break;
915
        }
916
        i++;
917
    }
918
28
    if (!*arg) {
919
        goto end;
920
28
    } else if (*arg == '+') {
921
        arg++;
922
28
    } else if (!i) {
923
28
        flags = av_log_get_flags();  /* level value without prefix, reset flags */
924
    }
925
926
268
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
927
244
        if (!strcmp(log_levels[i].name, arg)) {
928
4
            level = log_levels[i].level;
929
4
            goto end;
930
        }
931
    }
932
933
24
    level = strtol(arg, &tail, 10);
934
24
    if (*tail) {
935
        av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
936
               "Possible levels are numbers or:\n", arg);
937
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
938
            av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
939
        exit_program(1);
940
    }
941
942
24
end:
943
28
    av_log_set_flags(flags);
944
28
    av_log_set_level(level);
945
28
    return 0;
946
}
947
948
static void expand_filename_template(AVBPrint *bp, const char *template,
949
                                     struct tm *tm)
950
{
951
    int c;
952
953
    while ((c = *(template++))) {
954
        if (c == '%') {
955
            if (!(c = *(template++)))
956
                break;
957
            switch (c) {
958
            case 'p':
959
                av_bprintf(bp, "%s", program_name);
960
                break;
961
            case 't':
962
                av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
963
                           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
964
                           tm->tm_hour, tm->tm_min, tm->tm_sec);
965
                break;
966
            case '%':
967
                av_bprint_chars(bp, c, 1);
968
                break;
969
            }
970
        } else {
971
            av_bprint_chars(bp, c, 1);
972
        }
973
    }
974
}
975
976
static int init_report(const char *env)
977
{
978
    char *filename_template = NULL;
979
    char *key, *val;
980
    int ret, count = 0;
981
    int prog_loglevel, envlevel = 0;
982
    time_t now;
983
    struct tm *tm;
984
    AVBPrint filename;
985
986
    if (report_file) /* already opened */
987
        return 0;
988
    time(&now);
989
    tm = localtime(&now);
990
991
    while (env && *env) {
992
        if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
993
            if (count)
994
                av_log(NULL, AV_LOG_ERROR,
995
                       "Failed to parse FFREPORT environment variable: %s\n",
996
                       av_err2str(ret));
997
            break;
998
        }
999
        if (*env)
1000
            env++;
1001
        count++;
1002
        if (!strcmp(key, "file")) {
1003
            av_free(filename_template);
1004
            filename_template = val;
1005
            val = NULL;
1006
        } else if (!strcmp(key, "level")) {
1007
            char *tail;
1008
            report_file_level = strtol(val, &tail, 10);
1009
            if (*tail) {
1010
                av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1011
                exit_program(1);
1012
            }
1013
            envlevel = 1;
1014
        } else {
1015
            av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1016
        }
1017
        av_free(val);
1018
        av_free(key);
1019
    }
1020
1021
    av_bprint_init(&filename, 0, AV_BPRINT_SIZE_AUTOMATIC);
1022
    expand_filename_template(&filename,
1023
                             av_x_if_null(filename_template, "%p-%t.log"), tm);
1024
    av_free(filename_template);
1025
    if (!av_bprint_is_complete(&filename)) {
1026
        av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1027
        return AVERROR(ENOMEM);
1028
    }
1029
1030
    prog_loglevel = av_log_get_level();
1031
    if (!envlevel)
1032
        report_file_level = FFMAX(report_file_level, prog_loglevel);
1033
1034
    report_file = fopen(filename.str, "w");
1035
    if (!report_file) {
1036
        int ret = AVERROR(errno);
1037
        av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1038
               filename.str, strerror(errno));
1039
        return ret;
1040
    }
1041
    av_log_set_callback(log_callback_report);
1042
    av_log(NULL, AV_LOG_INFO,
1043
           "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1044
           "Report written to \"%s\"\n"
1045
           "Log level: %d\n",
1046
           program_name,
1047
           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1048
           tm->tm_hour, tm->tm_min, tm->tm_sec,
1049
           filename.str, report_file_level);
1050
    av_bprint_finalize(&filename, NULL);
1051
    return 0;
1052
}
1053
1054
int opt_report(void *optctx, const char *opt, const char *arg)
1055
{
1056
    return init_report(NULL);
1057
}
1058
1059
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1060
{
1061
    char *tail;
1062
    size_t max;
1063
1064
    max = strtol(arg, &tail, 10);
1065
    if (*tail) {
1066
        av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1067
        exit_program(1);
1068
    }
1069
    av_max_alloc(max);
1070
    return 0;
1071
}
1072
1073
int opt_timelimit(void *optctx, const char *opt, const char *arg)
1074
{
1075
#if HAVE_SETRLIMIT
1076
    int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
1077
    struct rlimit rl = { lim, lim + 1 };
1078
    if (setrlimit(RLIMIT_CPU, &rl))
1079
        perror("setrlimit");
1080
#else
1081
    av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1082
#endif
1083
    return 0;
1084
}
1085
1086
81
void print_error(const char *filename, int err)
1087
{
1088
    char errbuf[128];
1089
81
    const char *errbuf_ptr = errbuf;
1090
1091
81
    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
1092
        errbuf_ptr = strerror(AVUNERROR(err));
1093
81
    av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
1094
81
}
1095
1096
static int warned_cfg = 0;
1097
1098
#define INDENT        1
1099
#define SHOW_VERSION  2
1100
#define SHOW_CONFIG   4
1101
#define SHOW_COPYRIGHT 8
1102
1103
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
1104
    if (CONFIG_##LIBNAME) {                                             \
1105
        const char *indent = flags & INDENT? "  " : "";                 \
1106
        if (flags & SHOW_VERSION) {                                     \
1107
            unsigned int version = libname##_version();                 \
1108
            av_log(NULL, level,                                         \
1109
                   "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
1110
                   indent, #libname,                                    \
1111
                   LIB##LIBNAME##_VERSION_MAJOR,                        \
1112
                   LIB##LIBNAME##_VERSION_MINOR,                        \
1113
                   LIB##LIBNAME##_VERSION_MICRO,                        \
1114
                   AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
1115
                   AV_VERSION_MICRO(version));                          \
1116
        }                                                               \
1117
        if (flags & SHOW_CONFIG) {                                      \
1118
            const char *cfg = libname##_configuration();                \
1119
            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
1120
                if (!warned_cfg) {                                      \
1121
                    av_log(NULL, level,                                 \
1122
                            "%sWARNING: library configuration mismatch\n", \
1123
                            indent);                                    \
1124
                    warned_cfg = 1;                                     \
1125
                }                                                       \
1126
                av_log(NULL, level, "%s%-11s configuration: %s\n",      \
1127
                        indent, #libname, cfg);                         \
1128
            }                                                           \
1129
        }                                                               \
1130
    }                                                                   \
1131
1132
12092
static void print_all_libs_info(int flags, int level)
1133
{
1134


12092
    PRINT_LIB_INFO(avutil,     AVUTIL,     flags, level);
1135


12092
    PRINT_LIB_INFO(avcodec,    AVCODEC,    flags, level);
1136


12092
    PRINT_LIB_INFO(avformat,   AVFORMAT,   flags, level);
1137


12092
    PRINT_LIB_INFO(avdevice,   AVDEVICE,   flags, level);
1138


12092
    PRINT_LIB_INFO(avfilter,   AVFILTER,   flags, level);
1139


12092
    PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
1140


12092
    PRINT_LIB_INFO(swscale,    SWSCALE,    flags, level);
1141


12092
    PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
1142


12092
    PRINT_LIB_INFO(postproc,   POSTPROC,   flags, level);
1143
12092
}
1144
1145
6046
static void print_program_info(int flags, int level)
1146
{
1147
6046
    const char *indent = flags & INDENT? "  " : "";
1148
1149
6046
    av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
1150
6046
    if (flags & SHOW_COPYRIGHT)
1151
6046
        av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
1152
               program_birth_year, CONFIG_THIS_YEAR);
1153
6046
    av_log(NULL, level, "\n");
1154
6046
    av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
1155
1156
6046
    av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
1157
6046
}
1158
1159
static void print_buildconf(int flags, int level)
1160
{
1161
    const char *indent = flags & INDENT ? "  " : "";
1162
    char str[] = { FFMPEG_CONFIGURATION };
1163
    char *conflist, *remove_tilde, *splitconf;
1164
1165
    // Change all the ' --' strings to '~--' so that
1166
    // they can be identified as tokens.
1167
    while ((conflist = strstr(str, " --")) != NULL) {
1168
        strncpy(conflist, "~--", 3);
1169
    }
1170
1171
    // Compensate for the weirdness this would cause
1172
    // when passing 'pkg-config --static'.
1173
    while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
1174
        strncpy(remove_tilde, "pkg-config ", 11);
1175
    }
1176
1177
    splitconf = strtok(str, "~");
1178
    av_log(NULL, level, "\n%sconfiguration:\n", indent);
1179
    while (splitconf != NULL) {
1180
        av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
1181
        splitconf = strtok(NULL, "~");
1182
    }
1183
}
1184
1185
6046
void show_banner(int argc, char **argv, const OptionDef *options)
1186
{
1187
6046
    int idx = locate_option(argc, argv, options, "version");
1188

6046
    if (hide_banner || idx)
1189
        return;
1190
1191
6046
    print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
1192
6046
    print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
1193
6046
    print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
1194
}
1195
1196
int show_version(void *optctx, const char *opt, const char *arg)
1197
{
1198
    av_log_set_callback(log_callback_help);
1199
    print_program_info (SHOW_COPYRIGHT, AV_LOG_INFO);
1200
    print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
1201
1202
    return 0;
1203
}
1204
1205
int show_buildconf(void *optctx, const char *opt, const char *arg)
1206
{
1207
    av_log_set_callback(log_callback_help);
1208
    print_buildconf      (INDENT|0, AV_LOG_INFO);
1209
1210
    return 0;
1211
}
1212
1213
int show_license(void *optctx, const char *opt, const char *arg)
1214
{
1215
#if CONFIG_NONFREE
1216
    printf(
1217
    "This version of %s has nonfree parts compiled in.\n"
1218
    "Therefore it is not legally redistributable.\n",
1219
    program_name );
1220
#elif CONFIG_GPLV3
1221
    printf(
1222
    "%s is free software; you can redistribute it and/or modify\n"
1223
    "it under the terms of the GNU General Public License as published by\n"
1224
    "the Free Software Foundation; either version 3 of the License, or\n"
1225
    "(at your option) any later version.\n"
1226
    "\n"
1227
    "%s is distributed in the hope that it will be useful,\n"
1228
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1229
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1230
    "GNU General Public License for more details.\n"
1231
    "\n"
1232
    "You should have received a copy of the GNU General Public License\n"
1233
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
1234
    program_name, program_name, program_name );
1235
#elif CONFIG_GPL
1236
    printf(
1237
    "%s is free software; you can redistribute it and/or modify\n"
1238
    "it under the terms of the GNU General Public License as published by\n"
1239
    "the Free Software Foundation; either version 2 of the License, or\n"
1240
    "(at your option) any later version.\n"
1241
    "\n"
1242
    "%s is distributed in the hope that it will be useful,\n"
1243
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1244
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1245
    "GNU General Public License for more details.\n"
1246
    "\n"
1247
    "You should have received a copy of the GNU General Public License\n"
1248
    "along with %s; if not, write to the Free Software\n"
1249
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1250
    program_name, program_name, program_name );
1251
#elif CONFIG_LGPLV3
1252
    printf(
1253
    "%s is free software; you can redistribute it and/or modify\n"
1254
    "it under the terms of the GNU Lesser General Public License as published by\n"
1255
    "the Free Software Foundation; either version 3 of the License, or\n"
1256
    "(at your option) any later version.\n"
1257
    "\n"
1258
    "%s is distributed in the hope that it will be useful,\n"
1259
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1260
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1261
    "GNU Lesser General Public License for more details.\n"
1262
    "\n"
1263
    "You should have received a copy of the GNU Lesser General Public License\n"
1264
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
1265
    program_name, program_name, program_name );
1266
#else
1267
    printf(
1268
    "%s is free software; you can redistribute it and/or\n"
1269
    "modify it under the terms of the GNU Lesser General Public\n"
1270
    "License as published by the Free Software Foundation; either\n"
1271
    "version 2.1 of the License, or (at your option) any later version.\n"
1272
    "\n"
1273
    "%s is distributed in the hope that it will be useful,\n"
1274
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1275
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
1276
    "Lesser General Public License for more details.\n"
1277
    "\n"
1278
    "You should have received a copy of the GNU Lesser General Public\n"
1279
    "License along with %s; if not, write to the Free Software\n"
1280
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1281
    program_name, program_name, program_name );
1282
#endif
1283
1284
    return 0;
1285
}
1286
1287
static int is_device(const AVClass *avclass)
1288
{
1289
    if (!avclass)
1290
        return 0;
1291
    return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
1292
}
1293
1294
static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
1295
{
1296
    void *ifmt_opaque = NULL;
1297
    const AVInputFormat *ifmt  = NULL;
1298
    void *ofmt_opaque = NULL;
1299
    const AVOutputFormat *ofmt = NULL;
1300
    const char *last_name;
1301
    int is_dev;
1302
1303
    printf("%s\n"
1304
           " D. = Demuxing supported\n"
1305
           " .E = Muxing supported\n"
1306
           " --\n", device_only ? "Devices:" : "File formats:");
1307
    last_name = "000";
1308
    for (;;) {
1309
        int decode = 0;
1310
        int encode = 0;
1311
        const char *name      = NULL;
1312
        const char *long_name = NULL;
1313
1314
        if (muxdemuxers !=SHOW_DEMUXERS) {
1315
            ofmt_opaque = NULL;
1316
            while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
1317
                is_dev = is_device(ofmt->priv_class);
1318
                if (!is_dev && device_only)
1319
                    continue;
1320
                if ((!name || strcmp(ofmt->name, name) < 0) &&
1321
                    strcmp(ofmt->name, last_name) > 0) {
1322
                    name      = ofmt->name;
1323
                    long_name = ofmt->long_name;
1324
                    encode    = 1;
1325
                }
1326
            }
1327
        }
1328
        if (muxdemuxers != SHOW_MUXERS) {
1329
            ifmt_opaque = NULL;
1330
            while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
1331
                is_dev = is_device(ifmt->priv_class);
1332
                if (!is_dev && device_only)
1333
                    continue;
1334
                if ((!name || strcmp(ifmt->name, name) < 0) &&
1335
                    strcmp(ifmt->name, last_name) > 0) {
1336
                    name      = ifmt->name;
1337
                    long_name = ifmt->long_name;
1338
                    encode    = 0;
1339
                }
1340
                if (name && strcmp(ifmt->name, name) == 0)
1341
                    decode = 1;
1342
            }
1343
        }
1344
        if (!name)
1345
            break;
1346
        last_name = name;
1347
1348
        printf(" %s%s %-15s %s\n",
1349
               decode ? "D" : " ",
1350
               encode ? "E" : " ",
1351
               name,
1352
            long_name ? long_name:" ");
1353
    }
1354
    return 0;
1355
}
1356
1357
int show_formats(void *optctx, const char *opt, const char *arg)
1358
{
1359
    return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
1360
}
1361
1362
int show_muxers(void *optctx, const char *opt, const char *arg)
1363
{
1364
    return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
1365
}
1366
1367
int show_demuxers(void *optctx, const char *opt, const char *arg)
1368
{
1369
    return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
1370
}
1371
1372
int show_devices(void *optctx, const char *opt, const char *arg)
1373
{
1374
    return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
1375
}
1376
1377
#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
1378
    if (codec->field) {                                                      \
1379
        const type *p = codec->field;                                        \
1380
                                                                             \
1381
        printf("    Supported " list_name ":");                              \
1382
        while (*p != term) {                                                 \
1383
            get_name(*p);                                                    \
1384
            printf(" %s", name);                                             \
1385
            p++;                                                             \
1386
        }                                                                    \
1387
        printf("\n");                                                        \
1388
    }                                                                        \
1389
1390
static void print_codec(const AVCodec *c)
1391
{
1392
    int encoder = av_codec_is_encoder(c);
1393
1394
    printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
1395
           c->long_name ? c->long_name : "");
1396
1397
    printf("    General capabilities: ");
1398
    if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
1399
        printf("horizband ");
1400
    if (c->capabilities & AV_CODEC_CAP_DR1)
1401
        printf("dr1 ");
1402
    if (c->capabilities & AV_CODEC_CAP_TRUNCATED)
1403
        printf("trunc ");
1404
    if (c->capabilities & AV_CODEC_CAP_DELAY)
1405
        printf("delay ");
1406
    if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
1407
        printf("small ");
1408
    if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
1409
        printf("subframes ");
1410
    if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
1411
        printf("exp ");
1412
    if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
1413
        printf("chconf ");
1414
    if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
1415
        printf("paramchange ");
1416
    if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
1417
        printf("variable ");
1418
    if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
1419
                           AV_CODEC_CAP_SLICE_THREADS |
1420
                           AV_CODEC_CAP_AUTO_THREADS))
1421
        printf("threads ");
1422
    if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
1423
        printf("avoidprobe ");
1424
    if (c->capabilities & AV_CODEC_CAP_HARDWARE)
1425
        printf("hardware ");
1426
    if (c->capabilities & AV_CODEC_CAP_HYBRID)
1427
        printf("hybrid ");
1428
    if (!c->capabilities)
1429
        printf("none");
1430
    printf("\n");
1431
1432
    if (c->type == AVMEDIA_TYPE_VIDEO ||
1433
        c->type == AVMEDIA_TYPE_AUDIO) {
1434
        printf("    Threading capabilities: ");
1435
        switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
1436
                                   AV_CODEC_CAP_SLICE_THREADS |
1437
                                   AV_CODEC_CAP_AUTO_THREADS)) {
1438
        case AV_CODEC_CAP_FRAME_THREADS |
1439
             AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
1440
        case AV_CODEC_CAP_FRAME_THREADS: printf("frame");           break;
1441
        case AV_CODEC_CAP_SLICE_THREADS: printf("slice");           break;
1442
        case AV_CODEC_CAP_AUTO_THREADS : printf("auto");            break;
1443
        default:                         printf("none");            break;
1444
        }
1445
        printf("\n");
1446
    }
1447
1448
    if (avcodec_get_hw_config(c, 0)) {
1449
        printf("    Supported hardware devices: ");
1450
        for (int i = 0;; i++) {
1451
            const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
1452
            if (!config)
1453
                break;
1454
            printf("%s ", av_hwdevice_get_type_name(config->device_type));
1455
        }
1456
        printf("\n");
1457
    }
1458
1459
    if (c->supported_framerates) {
1460
        const AVRational *fps = c->supported_framerates;
1461
1462
        printf("    Supported framerates:");
1463
        while (fps->num) {
1464
            printf(" %d/%d", fps->num, fps->den);
1465
            fps++;
1466
        }
1467
        printf("\n");
1468
    }
1469
    PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
1470
                          AV_PIX_FMT_NONE, GET_PIX_FMT_NAME);
1471
    PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
1472
                          GET_SAMPLE_RATE_NAME);
1473
    PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
1474
                          AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME);
1475
    PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
1476
                          0, GET_CH_LAYOUT_DESC);
1477
1478
    if (c->priv_class) {
1479
        show_help_children(c->priv_class,
1480
                           AV_OPT_FLAG_ENCODING_PARAM |
1481
                           AV_OPT_FLAG_DECODING_PARAM);
1482
    }
1483
}
1484
1485
static char get_media_type_char(enum AVMediaType type)
1486
{
1487
    switch (type) {
1488
        case AVMEDIA_TYPE_VIDEO:    return 'V';
1489
        case AVMEDIA_TYPE_AUDIO:    return 'A';
1490
        case AVMEDIA_TYPE_DATA:     return 'D';
1491
        case AVMEDIA_TYPE_SUBTITLE: return 'S';
1492
        case AVMEDIA_TYPE_ATTACHMENT:return 'T';
1493
        default:                    return '?';
1494
    }
1495
}
1496
1497
static const AVCodec *next_codec_for_id(enum AVCodecID id, void **iter,
1498
                                        int encoder)
1499
{
1500
    const AVCodec *c;
1501
    while ((c = av_codec_iterate(iter))) {
1502
        if (c->id == id &&
1503
            (encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
1504
            return c;
1505
    }
1506
    return NULL;
1507
}
1508
1509
static int compare_codec_desc(const void *a, const void *b)
1510
{
1511
    const AVCodecDescriptor * const *da = a;
1512
    const AVCodecDescriptor * const *db = b;
1513
1514
    return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
1515
           strcmp((*da)->name, (*db)->name);
1516
}
1517
1518
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
1519
{
1520
    const AVCodecDescriptor *desc = NULL;
1521
    const AVCodecDescriptor **codecs;
1522
    unsigned nb_codecs = 0, i = 0;
1523
1524
    while ((desc = avcodec_descriptor_next(desc)))
1525
        nb_codecs++;
1526
    if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
1527
        av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
1528
        exit_program(1);
1529
    }
1530
    desc = NULL;
1531
    while ((desc = avcodec_descriptor_next(desc)))
1532
        codecs[i++] = desc;
1533
    av_assert0(i == nb_codecs);
1534
    qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
1535
    *rcodecs = codecs;
1536
    return nb_codecs;
1537
}
1538
1539
static void print_codecs_for_id(enum AVCodecID id, int encoder)
1540
{
1541
    void *iter = NULL;
1542
    const AVCodec *codec;
1543
1544
    printf(" (%s: ", encoder ? "encoders" : "decoders");
1545
1546
    while ((codec = next_codec_for_id(id, &iter, encoder)))
1547
        printf("%s ", codec->name);
1548
1549
    printf(")");
1550
}
1551
1552
int show_codecs(void *optctx, const char *opt, const char *arg)
1553
{
1554
    const AVCodecDescriptor **codecs;
1555
    unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1556
1557
    printf("Codecs:\n"
1558
           " D..... = Decoding supported\n"
1559
           " .E.... = Encoding supported\n"
1560
           " ..V... = Video codec\n"
1561
           " ..A... = Audio codec\n"
1562
           " ..S... = Subtitle codec\n"
1563
           " ...I.. = Intra frame-only codec\n"
1564
           " ....L. = Lossy compression\n"
1565
           " .....S = Lossless compression\n"
1566
           " -------\n");
1567
    for (i = 0; i < nb_codecs; i++) {
1568
        const AVCodecDescriptor *desc = codecs[i];
1569
        const AVCodec *codec;
1570
        void *iter = NULL;
1571
1572
        if (strstr(desc->name, "_deprecated"))
1573
            continue;
1574
1575
        printf(" ");
1576
        printf(avcodec_find_decoder(desc->id) ? "D" : ".");
1577
        printf(avcodec_find_encoder(desc->id) ? "E" : ".");
1578
1579
        printf("%c", get_media_type_char(desc->type));
1580
        printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
1581
        printf((desc->props & AV_CODEC_PROP_LOSSY)      ? "L" : ".");
1582
        printf((desc->props & AV_CODEC_PROP_LOSSLESS)   ? "S" : ".");
1583
1584
        printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
1585
1586
        /* print decoders/encoders when there's more than one or their
1587
         * names are different from codec name */
1588
        while ((codec = next_codec_for_id(desc->id, &iter, 0))) {
1589
            if (strcmp(codec->name, desc->name)) {
1590
                print_codecs_for_id(desc->id, 0);
1591
                break;
1592
            }
1593
        }
1594
        iter = NULL;
1595
        while ((codec = next_codec_for_id(desc->id, &iter, 1))) {
1596
            if (strcmp(codec->name, desc->name)) {
1597
                print_codecs_for_id(desc->id, 1);
1598
                break;
1599
            }
1600
        }
1601
1602
        printf("\n");
1603
    }
1604
    av_free(codecs);
1605
    return 0;
1606
}
1607
1608
static void print_codecs(int encoder)
1609
{
1610
    const AVCodecDescriptor **codecs;
1611
    unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1612
1613
    printf("%s:\n"
1614
           " V..... = Video\n"
1615
           " A..... = Audio\n"
1616
           " S..... = Subtitle\n"
1617
           " .F.... = Frame-level multithreading\n"
1618
           " ..S... = Slice-level multithreading\n"
1619
           " ...X.. = Codec is experimental\n"
1620
           " ....B. = Supports draw_horiz_band\n"
1621
           " .....D = Supports direct rendering method 1\n"
1622
           " ------\n",
1623
           encoder ? "Encoders" : "Decoders");
1624
    for (i = 0; i < nb_codecs; i++) {
1625
        const AVCodecDescriptor *desc = codecs[i];
1626
        const AVCodec *codec;
1627
        void *iter = NULL;
1628
1629
        while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
1630
            printf(" %c", get_media_type_char(desc->type));
1631
            printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
1632
            printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
1633
            printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)  ? "X" : ".");
1634
            printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
1635
            printf((codec->capabilities & AV_CODEC_CAP_DR1)           ? "D" : ".");
1636
1637
            printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
1638
            if (strcmp(codec->name, desc->name))
1639
                printf(" (codec %s)", desc->name);
1640
1641
            printf("\n");
1642
        }
1643
    }
1644
    av_free(codecs);
1645
}
1646
1647
int show_decoders(void *optctx, const char *opt, const char *arg)
1648
{
1649
    print_codecs(0);
1650
    return 0;
1651
}
1652
1653
int show_encoders(void *optctx, const char *opt, const char *arg)
1654
{
1655
    print_codecs(1);
1656
    return 0;
1657
}
1658
1659
int show_bsfs(void *optctx, const char *opt, const char *arg)
1660
{
1661
    const AVBitStreamFilter *bsf = NULL;
1662
    void *opaque = NULL;
1663
1664
    printf("Bitstream filters:\n");
1665
    while ((bsf = av_bsf_iterate(&opaque)))
1666
        printf("%s\n", bsf->name);
1667
    printf("\n");
1668
    return 0;
1669
}
1670
1671
int show_protocols(void *optctx, const char *opt, const char *arg)
1672
{
1673
    void *opaque = NULL;
1674
    const char *name;
1675
1676
    printf("Supported file protocols:\n"
1677
           "Input:\n");
1678
    while ((name = avio_enum_protocols(&opaque, 0)))
1679
        printf("  %s\n", name);
1680
    printf("Output:\n");
1681
    while ((name = avio_enum_protocols(&opaque, 1)))
1682
        printf("  %s\n", name);
1683
    return 0;
1684
}
1685
1686
int show_filters(void *optctx, const char *opt, const char *arg)
1687
{
1688
#if CONFIG_AVFILTER
1689
    const AVFilter *filter = NULL;
1690
    char descr[64], *descr_cur;
1691
    void *opaque = NULL;
1692
    int i, j;
1693
    const AVFilterPad *pad;
1694
1695
    printf("Filters:\n"
1696
           "  T.. = Timeline support\n"
1697
           "  .S. = Slice threading\n"
1698
           "  ..C = Command support\n"
1699
           "  A = Audio input/output\n"
1700
           "  V = Video input/output\n"
1701
           "  N = Dynamic number and/or type of input/output\n"
1702
           "  | = Source or sink filter\n");
1703
    while ((filter = av_filter_iterate(&opaque))) {
1704
        descr_cur = descr;
1705
        for (i = 0; i < 2; i++) {
1706
            if (i) {
1707
                *(descr_cur++) = '-';
1708
                *(descr_cur++) = '>';
1709
            }
1710
            pad = i ? filter->outputs : filter->inputs;
1711
            for (j = 0; pad && avfilter_pad_get_name(pad, j); j++) {
1712
                if (descr_cur >= descr + sizeof(descr) - 4)
1713
                    break;
1714
                *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
1715
            }
1716
            if (!j)
1717
                *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
1718
                                  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
1719
        }
1720
        *descr_cur = 0;
1721
        printf(" %c%c%c %-17s %-10s %s\n",
1722
               filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
1723
               filter->flags & AVFILTER_FLAG_SLICE_THREADS    ? 'S' : '.',
1724
               filter->process_command                        ? 'C' : '.',
1725
               filter->name, descr, filter->description);
1726
    }
1727
#else
1728
    printf("No filters available: libavfilter disabled\n");
1729
#endif
1730
    return 0;
1731
}
1732
1733
int show_colors(void *optctx, const char *opt, const char *arg)
1734
{
1735
    const char *name;
1736
    const uint8_t *rgb;
1737
    int i;
1738
1739
    printf("%-32s #RRGGBB\n", "name");
1740
1741
    for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
1742
        printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
1743
1744
    return 0;
1745
}
1746
1747
1
int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1748
{
1749
1
    const AVPixFmtDescriptor *pix_desc = NULL;
1750
1751
1
    printf("Pixel formats:\n"
1752
           "I.... = Supported Input  format for conversion\n"
1753
           ".O... = Supported Output format for conversion\n"
1754
           "..H.. = Hardware accelerated format\n"
1755
           "...P. = Paletted format\n"
1756
           "....B = Bitstream format\n"
1757
           "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
1758
           "-----\n");
1759
1760
#if !CONFIG_SWSCALE
1761
#   define sws_isSupportedInput(x)  0
1762
#   define sws_isSupportedOutput(x) 0
1763
#endif
1764
1765
199
    while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1766
198
        enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
1767

1188
        printf("%c%c%c%c%c %-16s       %d            %2d\n",
1768
198
               sws_isSupportedInput (pix_fmt)              ? 'I' : '.',
1769
198
               sws_isSupportedOutput(pix_fmt)              ? 'O' : '.',
1770
198
               pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL   ? 'H' : '.',
1771
198
               pix_desc->flags & AV_PIX_FMT_FLAG_PAL       ? 'P' : '.',
1772
198
               pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1773
               pix_desc->name,
1774
198
               pix_desc->nb_components,
1775
               av_get_bits_per_pixel(pix_desc));
1776
    }
1777
1
    return 0;
1778
}
1779
1780
int show_layouts(void *optctx, const char *opt, const char *arg)
1781
{
1782
    int i = 0;
1783
    uint64_t layout, j;
1784
    const char *name, *descr;
1785
1786
    printf("Individual channels:\n"
1787
           "NAME           DESCRIPTION\n");
1788
    for (i = 0; i < 63; i++) {
1789
        name = av_get_channel_name((uint64_t)1 << i);
1790
        if (!name)
1791
            continue;
1792
        descr = av_get_channel_description((uint64_t)1 << i);
1793
        printf("%-14s %s\n", name, descr);
1794
    }
1795
    printf("\nStandard channel layouts:\n"
1796
           "NAME           DECOMPOSITION\n");
1797
    for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
1798
        if (name) {
1799
            printf("%-14s ", name);
1800
            for (j = 1; j; j <<= 1)
1801
                if ((layout & j))
1802
                    printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
1803
            printf("\n");
1804
        }
1805
    }
1806
    return 0;
1807
}
1808
1809
int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1810
{
1811
    int i;
1812
    char fmt_str[128];
1813
    for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1814
        printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1815
    return 0;
1816
}
1817
1818
static void show_help_codec(const char *name, int encoder)
1819
{
1820
    const AVCodecDescriptor *desc;
1821
    const AVCodec *codec;
1822
1823
    if (!name) {
1824
        av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1825
        return;
1826
    }
1827
1828
    codec = encoder ? avcodec_find_encoder_by_name(name) :
1829
                      avcodec_find_decoder_by_name(name);
1830
1831
    if (codec)
1832
        print_codec(codec);
1833
    else if ((desc = avcodec_descriptor_get_by_name(name))) {
1834
        void *iter = NULL;
1835
        int printed = 0;
1836
1837
        while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
1838
            printed = 1;
1839
            print_codec(codec);
1840
        }
1841
1842
        if (!printed) {
1843
            av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
1844
                   "but no %s for it are available. FFmpeg might need to be "
1845
                   "recompiled with additional external libraries.\n",
1846
                   name, encoder ? "encoders" : "decoders");
1847
        }
1848
    } else {
1849
        av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
1850
               name);
1851
    }
1852
}
1853
1854
static void show_help_demuxer(const char *name)
1855
{
1856
    const AVInputFormat *fmt = av_find_input_format(name);
1857
1858
    if (!fmt) {
1859
        av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1860
        return;
1861
    }
1862
1863
    printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1864
1865
    if (fmt->extensions)
1866
        printf("    Common extensions: %s.\n", fmt->extensions);
1867
1868
    if (fmt->priv_class)
1869
        show_help_children(fmt->priv_class, AV_OPT_FLAG_DECODING_PARAM);
1870
}
1871
1872
static void show_help_protocol(const char *name)
1873
{
1874
    const AVClass *proto_class;
1875
1876
    if (!name) {
1877
        av_log(NULL, AV_LOG_ERROR, "No protocol name specified.\n");
1878
        return;
1879
    }
1880
1881
    proto_class = avio_protocol_get_class(name);
1882
    if (!proto_class) {
1883
        av_log(NULL, AV_LOG_ERROR, "Unknown protocol '%s'.\n", name);
1884
        return;
1885
    }
1886
1887
    show_help_children(proto_class, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
1888
}
1889
1890
static void show_help_muxer(const char *name)
1891
{
1892
    const AVCodecDescriptor *desc;
1893
    const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
1894
1895
    if (!fmt) {
1896
        av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1897
        return;
1898
    }
1899
1900
    printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1901
1902
    if (fmt->extensions)
1903
        printf("    Common extensions: %s.\n", fmt->extensions);
1904
    if (fmt->mime_type)
1905
        printf("    Mime type: %s.\n", fmt->mime_type);
1906
    if (fmt->video_codec != AV_CODEC_ID_NONE &&
1907
        (desc = avcodec_descriptor_get(fmt->video_codec))) {
1908
        printf("    Default video codec: %s.\n", desc->name);
1909
    }
1910
    if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1911
        (desc = avcodec_descriptor_get(fmt->audio_codec))) {
1912
        printf("    Default audio codec: %s.\n", desc->name);
1913
    }
1914
    if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1915
        (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
1916
        printf("    Default subtitle codec: %s.\n", desc->name);
1917
    }
1918
1919
    if (fmt->priv_class)
1920
        show_help_children(fmt->priv_class, AV_OPT_FLAG_ENCODING_PARAM);
1921
}
1922
1923
#if CONFIG_AVFILTER
1924
static void show_help_filter(const char *name)
1925
{
1926
#if CONFIG_AVFILTER
1927
    const AVFilter *f = avfilter_get_by_name(name);
1928
    int i, count;
1929
1930
    if (!name) {
1931
        av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1932
        return;
1933
    } else if (!f) {
1934
        av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1935
        return;
1936
    }
1937
1938
    printf("Filter %s\n", f->name);
1939
    if (f->description)
1940
        printf("  %s\n", f->description);
1941
1942
    if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
1943
        printf("    slice threading supported\n");
1944
1945
    printf("    Inputs:\n");
1946
    count = avfilter_pad_count(f->inputs);
1947
    for (i = 0; i < count; i++) {
1948
        printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1949
               media_type_string(avfilter_pad_get_type(f->inputs, i)));
1950
    }
1951
    if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
1952
        printf("        dynamic (depending on the options)\n");
1953
    else if (!count)
1954
        printf("        none (source filter)\n");
1955
1956
    printf("    Outputs:\n");
1957
    count = avfilter_pad_count(f->outputs);
1958
    for (i = 0; i < count; i++) {
1959
        printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1960
               media_type_string(avfilter_pad_get_type(f->outputs, i)));
1961
    }
1962
    if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
1963
        printf("        dynamic (depending on the options)\n");
1964
    else if (!count)
1965
        printf("        none (sink filter)\n");
1966
1967
    if (f->priv_class)
1968
        show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
1969
                                          AV_OPT_FLAG_AUDIO_PARAM);
1970
    if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
1971
        printf("This filter has support for timeline through the 'enable' option.\n");
1972
#else
1973
    av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
1974
           "can not to satisfy request\n");
1975
#endif
1976
}
1977
#endif
1978
1979
static void show_help_bsf(const char *name)
1980
{
1981
    const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
1982
1983
    if (!name) {
1984
        av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
1985
        return;
1986
    } else if (!bsf) {
1987
        av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
1988
        return;
1989
    }
1990
1991
    printf("Bit stream filter %s\n", bsf->name);
1992
    PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
1993
                          AV_CODEC_ID_NONE, GET_CODEC_NAME);
1994
    if (bsf->priv_class)
1995
        show_help_children(bsf->priv_class, AV_OPT_FLAG_BSF_PARAM);
1996
}
1997
1998
int show_help(void *optctx, const char *opt, const char *arg)
1999
{
2000
    char *topic, *par;
2001
    av_log_set_callback(log_callback_help);
2002
2003
    topic = av_strdup(arg ? arg : "");
2004
    if (!topic)
2005
        return AVERROR(ENOMEM);
2006
    par = strchr(topic, '=');
2007
    if (par)
2008
        *par++ = 0;
2009
2010
    if (!*topic) {
2011
        show_help_default(topic, par);
2012
    } else if (!strcmp(topic, "decoder")) {
2013
        show_help_codec(par, 0);
2014
    } else if (!strcmp(topic, "encoder")) {
2015
        show_help_codec(par, 1);
2016
    } else if (!strcmp(topic, "demuxer")) {
2017
        show_help_demuxer(par);
2018
    } else if (!strcmp(topic, "muxer")) {
2019
        show_help_muxer(par);
2020
    } else if (!strcmp(topic, "protocol")) {
2021
        show_help_protocol(par);
2022
#if CONFIG_AVFILTER
2023
    } else if (!strcmp(topic, "filter")) {
2024
        show_help_filter(par);
2025
#endif
2026
    } else if (!strcmp(topic, "bsf")) {
2027
        show_help_bsf(par);
2028
    } else {
2029
        show_help_default(topic, par);
2030
    }
2031
2032
    av_freep(&topic);
2033
    return 0;
2034
}
2035
2036
int read_yesno(void)
2037
{
2038
    int c = getchar();
2039
    int yesno = (av_toupper(c) == 'Y');
2040
2041
    while (c != '\n' && c != EOF)
2042
        c = getchar();
2043
2044
    return yesno;
2045
}
2046
2047
FILE *get_preset_file(char *filename, size_t filename_size,
2048
                      const char *preset_name, int is_path,
2049
                      const char *codec_name)
2050
{
2051
    FILE *f = NULL;
2052
    int i;
2053
    const char *base[3] = { getenv("FFMPEG_DATADIR"),
2054
                            getenv("HOME"),
2055
                            FFMPEG_DATADIR, };
2056
2057
    if (is_path) {
2058
        av_strlcpy(filename, preset_name, filename_size);
2059
        f = fopen(filename, "r");
2060
    } else {
2061
#if HAVE_GETMODULEHANDLE && defined(_WIN32)
2062
        char datadir[MAX_PATH], *ls;
2063
        base[2] = NULL;
2064
2065
        if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
2066
        {
2067
            for (ls = datadir; ls < datadir + strlen(datadir); ls++)
2068
                if (*ls == '\\') *ls = '/';
2069
2070
            if (ls = strrchr(datadir, '/'))
2071
            {
2072
                *ls = 0;
2073
                strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
2074
                base[2] = datadir;
2075
            }
2076
        }
2077
#endif
2078
        for (i = 0; i < 3 && !f; i++) {
2079
            if (!base[i])
2080
                continue;
2081
            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
2082
                     i != 1 ? "" : "/.ffmpeg", preset_name);
2083
            f = fopen(filename, "r");
2084
            if (!f && codec_name) {
2085
                snprintf(filename, filename_size,
2086
                         "%s%s/%s-%s.ffpreset",
2087
                         base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
2088
                         preset_name);
2089
                f = fopen(filename, "r");
2090
            }
2091
        }
2092
    }
2093
2094
    return f;
2095
}
2096
2097
25108
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
2098
{
2099
25108
    int ret = avformat_match_stream_specifier(s, st, spec);
2100
25108
    if (ret < 0)
2101
        av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
2102
25108
    return ret;
2103
}
2104
2105
18904
AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
2106
                                AVFormatContext *s, AVStream *st, AVCodec *codec)
2107
{
2108
18904
    AVDictionary    *ret = NULL;
2109
18904
    AVDictionaryEntry *t = NULL;
2110
37808
    int            flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
2111
18904
                                      : AV_OPT_FLAG_DECODING_PARAM;
2112
18904
    char          prefix = 0;
2113
18904
    const AVClass    *cc = avcodec_get_class();
2114
2115
18904
    if (!codec)
2116
6694
        codec            = s->oformat ? avcodec_find_encoder(codec_id)
2117
6694
                                      : avcodec_find_decoder(codec_id);
2118
2119

18904
    switch (st->codecpar->codec_type) {
2120
14630
    case AVMEDIA_TYPE_VIDEO:
2121
14630
        prefix  = 'v';
2122
14630
        flags  |= AV_OPT_FLAG_VIDEO_PARAM;
2123
14630
        break;
2124
4032
    case AVMEDIA_TYPE_AUDIO:
2125
4032
        prefix  = 'a';
2126
4032
        flags  |= AV_OPT_FLAG_AUDIO_PARAM;
2127
4032
        break;
2128
130
    case AVMEDIA_TYPE_SUBTITLE:
2129
130
        prefix  = 's';
2130
130
        flags  |= AV_OPT_FLAG_SUBTITLE_PARAM;
2131
130
        break;
2132
    }
2133
2134
72525
    while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
2135
53621
        char *p = strchr(t->key, ':');
2136
2137
        /* check stream specification in opt name */
2138
53621
        if (p)
2139
230
            switch (check_stream_specifier(s, st, p + 1)) {
2140
188
            case  1: *p = 0; break;
2141
42
            case  0:         continue;
2142
            default:         exit_program(1);
2143
            }
2144
2145

53579
        if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
2146
1240
            !codec ||
2147

1615
            (codec->priv_class &&
2148
375
             av_opt_find(&codec->priv_class, t->key, NULL, flags,
2149
                         AV_OPT_SEARCH_FAKE_OBJ)))
2150
52533
            av_dict_set(&ret, t->key, t->value, 0);
2151

1047
        else if (t->key[0] == prefix &&
2152
1
                 av_opt_find(&cc, t->key + 1, NULL, flags,
2153
                             AV_OPT_SEARCH_FAKE_OBJ))
2154
1
            av_dict_set(&ret, t->key + 1, t->value, 0);
2155
2156
53579
        if (p)
2157
188
            *p = ':';
2158
    }
2159
18904
    return ret;
2160
}
2161
2162
6073
AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
2163
                                           AVDictionary *codec_opts)
2164
{
2165
    int i;
2166
    AVDictionary **opts;
2167
2168
6073
    if (!s->nb_streams)
2169
63
        return NULL;
2170
6010
    opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
2171
6010
    if (!opts) {
2172
        av_log(NULL, AV_LOG_ERROR,
2173
               "Could not alloc memory for stream options.\n");
2174
        return NULL;
2175
    }
2176
12356
    for (i = 0; i < s->nb_streams; i++)
2177
6346
        opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
2178
6346
                                    s, s->streams[i], NULL);
2179
6010
    return opts;
2180
}
2181
2182
147582
void *grow_array(void *array, int elem_size, int *size, int new_size)
2183
{
2184
147582
    if (new_size >= INT_MAX / elem_size) {
2185
        av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
2186
        exit_program(1);
2187
    }
2188
147582
    if (*size < new_size) {
2189
147582
        uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
2190
147582
        if (!tmp) {
2191
            av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
2192
            exit_program(1);
2193
        }
2194
147582
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
2195
147582
        *size = new_size;
2196
147582
        return tmp;
2197
    }
2198
    return array;
2199
}
2200
2201
4682
double get_rotation(AVStream *st)
2202
{
2203
4682
    uint8_t* displaymatrix = av_stream_get_side_data(st,
2204
                                                     AV_PKT_DATA_DISPLAYMATRIX, NULL);
2205
4682
    double theta = 0;
2206
4682
    if (displaymatrix)
2207
        theta = -av_display_rotation_get((int32_t*) displaymatrix);
2208
2209
4682
    theta -= 360*floor(theta/360 + 0.9/360);
2210
2211
4682
    if (fabs(theta - 90*round(theta/90)) > 2)
2212
        av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
2213
               "If you want to help, upload a sample "
2214
               "of this file to https://streams.videolan.org/upload/ "
2215
               "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
2216
2217
4682
    return theta;
2218
}
2219
2220
#if CONFIG_AVDEVICE
2221
static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
2222
{
2223
    int ret, i;
2224
    AVDeviceInfoList *device_list = NULL;
2225
2226
    if (!fmt || !fmt->priv_class  || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
2227
        return AVERROR(EINVAL);
2228
2229
    printf("Auto-detected sources for %s:\n", fmt->name);
2230
    if (!fmt->get_device_list) {
2231
        ret = AVERROR(ENOSYS);
2232
        printf("Cannot list sources. Not implemented.\n");
2233
        goto fail;
2234
    }
2235
2236
    if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
2237
        printf("Cannot list sources.\n");
2238
        goto fail;
2239
    }
2240
2241
    for (i = 0; i < device_list->nb_devices; i++) {
2242
        printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2243
               device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2244
    }
2245
2246
  fail:
2247
    avdevice_free_list_devices(&device_list);
2248
    return ret;
2249
}
2250
2251
static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
2252
{
2253
    int ret, i;
2254
    AVDeviceInfoList *device_list = NULL;
2255
2256
    if (!fmt || !fmt->priv_class  || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
2257
        return AVERROR(EINVAL);
2258
2259
    printf("Auto-detected sinks for %s:\n", fmt->name);
2260
    if (!fmt->get_device_list) {
2261
        ret = AVERROR(ENOSYS);
2262
        printf("Cannot list sinks. Not implemented.\n");
2263
        goto fail;
2264
    }
2265
2266
    if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
2267
        printf("Cannot list sinks.\n");
2268
        goto fail;
2269
    }
2270
2271
    for (i = 0; i < device_list->nb_devices; i++) {
2272
        printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2273
               device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2274
    }
2275
2276
  fail:
2277
    avdevice_free_list_devices(&device_list);
2278
    return ret;
2279
}
2280
2281
static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
2282
{
2283
    int ret;
2284
    if (arg) {
2285
        char *opts_str = NULL;
2286
        av_assert0(dev && opts);
2287
        *dev = av_strdup(arg);
2288
        if (!*dev)
2289
            return AVERROR(ENOMEM);
2290
        if ((opts_str = strchr(*dev, ','))) {
2291
            *(opts_str++) = '\0';
2292
            if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
2293
                av_freep(dev);
2294
                return ret;
2295
            }
2296
        }
2297
    } else
2298
        printf("\nDevice name is not provided.\n"
2299
                "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
2300
    return 0;
2301
}
2302
2303
int show_sources(void *optctx, const char *opt, const char *arg)
2304
{
2305
    AVInputFormat *fmt = NULL;
2306
    char *dev = NULL;
2307
    AVDictionary *opts = NULL;
2308
    int ret = 0;
2309
    int error_level = av_log_get_level();
2310
2311
    av_log_set_level(AV_LOG_ERROR);
2312
2313
    if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2314
        goto fail;
2315
2316
    do {
2317
        fmt = av_input_audio_device_next(fmt);
2318
        if (fmt) {
2319
            if (!strcmp(fmt->name, "lavfi"))
2320
                continue; //it's pointless to probe lavfi
2321
            if (dev && !av_match_name(dev, fmt->name))
2322
                continue;
2323
            print_device_sources(fmt, opts);
2324
        }
2325
    } while (fmt);
2326
    do {
2327
        fmt = av_input_video_device_next(fmt);
2328
        if (fmt) {
2329
            if (dev && !av_match_name(dev, fmt->name))
2330
                continue;
2331
            print_device_sources(fmt, opts);
2332
        }
2333
    } while (fmt);
2334
  fail:
2335
    av_dict_free(&opts);
2336
    av_free(dev);
2337
    av_log_set_level(error_level);
2338
    return ret;
2339
}
2340
2341
int show_sinks(void *optctx, const char *opt, const char *arg)
2342
{
2343
    AVOutputFormat *fmt = NULL;
2344
    char *dev = NULL;
2345
    AVDictionary *opts = NULL;
2346
    int ret = 0;
2347
    int error_level = av_log_get_level();
2348
2349
    av_log_set_level(AV_LOG_ERROR);
2350
2351
    if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2352
        goto fail;
2353
2354
    do {
2355
        fmt = av_output_audio_device_next(fmt);
2356
        if (fmt) {
2357
            if (dev && !av_match_name(dev, fmt->name))
2358
                continue;
2359
            print_device_sinks(fmt, opts);
2360
        }
2361
    } while (fmt);
2362
    do {
2363
        fmt = av_output_video_device_next(fmt);
2364
        if (fmt) {
2365
            if (dev && !av_match_name(dev, fmt->name))
2366
                continue;
2367
            print_device_sinks(fmt, opts);
2368
        }
2369
    } while (fmt);
2370
  fail:
2371
    av_dict_free(&opts);
2372
    av_free(dev);
2373
    av_log_set_level(error_level);
2374
    return ret;
2375
}
2376
2377
#endif