FFmpeg: cmdutils.c Source File

FFmpeg
[フレーム]
cmdutils.c
Go to the documentation of this file.
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/avassert.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/bprint.h"
44 #include "libavutil/mathematics.h"
45 #include "libavutil/imgutils.h"
46 #include "libavutil/parseutils.h"
47 #include "libavutil/pixdesc.h"
48 #include "libavutil/eval.h"
49 #include "libavutil/dict.h"
50 #include "libavutil/opt.h"
51 #include "libavutil/cpu.h"
52 #include "libavutil/ffversion.h"
53 #include "cmdutils.h"
54 #if CONFIG_NETWORK
55 #include "libavformat/network.h"
56 #endif
57 #if HAVE_SYS_RESOURCE_H
58 #include <sys/time.h>
59 #include <sys/resource.h>
60 #endif
61 
62 static int init_report(const char *env);
63 
64  struct SwsContext *sws_opts;
65  AVDictionary *swr_opts;
66  AVDictionary *format_opts, *codec_opts, *resample_opts;
67 
68  static FILE *report_file;
69  int hide_banner = 0;
70 
71  void init_opts(void)
72 {
73 
74  if(CONFIG_SWSCALE)
75  sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
76  NULL, NULL, NULL);
77 }
78 
79  void uninit_opts(void)
80 {
81 #if CONFIG_SWSCALE
82  sws_freeContext(sws_opts);
83  sws_opts = NULL;
84 #endif
85 
86  av_dict_free(&swr_opts);
87  av_dict_free(&format_opts);
88  av_dict_free(&codec_opts);
89  av_dict_free(&resample_opts);
90 }
91 
92  void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
93 {
94  vfprintf(stdout, fmt, vl);
95 }
96 
97  static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
98 {
99  va_list vl2;
100  char line[1024];
101  static int print_prefix = 1;
102 
103  va_copy(vl2, vl);
104  av_log_default_callback(ptr, level, fmt, vl);
105  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
106  va_end(vl2);
107  fputs(line, report_file);
108  fflush(report_file);
109 }
110 
111  static void (*program_exit)(int ret);
112 
113  void register_exit(void (*cb)(int ret))
114 {
115  program_exit = cb;
116 }
117 
118  void exit_program(int ret)
119 {
120  if (program_exit)
121  program_exit(ret);
122 
123  exit(ret);
124 }
125 
126  double parse_number_or_die(const char *context, const char *numstr, int type,
127  double min, double max)
128 {
129  char *tail;
130  const char *error;
131  double d = av_strtod(numstr, &tail);
132  if (*tail)
133  error = "Expected number for %s but found: %s\n";
134  else if (d < min || d > max)
135  error = "The value for %s was %s which is not within %f - %f\n";
136  else if (type == OPT_INT64 && (int64_t)d != d)
137  error = "Expected int64 for %s but found %s\n";
138  else if (type == OPT_INT && (int)d != d)
139  error = "Expected int for %s but found %s\n";
140  else
141  return d;
142  av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
143  exit_program(1);
144  return 0;
145 }
146 
147  int64_t parse_time_or_die(const char *context, const char *timestr,
148  int is_duration)
149 {
150  int64_t us;
151  if (av_parse_time(&us, timestr, is_duration) < 0) {
152  av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
153  is_duration ? "duration" : "date", context, timestr);
154  exit_program(1);
155  }
156  return us;
157 }
158 
159  void show_help_options(const OptionDef *options, const char *msg, int req_flags,
160  int rej_flags, int alt_flags)
161 {
162  const OptionDef *po;
163  int first;
164 
165  first = 1;
166  for (po = options; po->name != NULL; po++) {
167  char buf[64];
168 
169  if (((po->flags & req_flags) != req_flags) ||
170  (alt_flags && !(po->flags & alt_flags)) ||
171  (po->flags & rej_flags))
172  continue;
173 
174  if (first) {
175  printf("%s\n", msg);
176  first = 0;
177  }
178  av_strlcpy(buf, po->name, sizeof(buf));
179  if (po->argname) {
180  av_strlcat(buf, " ", sizeof(buf));
181  av_strlcat(buf, po->argname, sizeof(buf));
182  }
183  printf("-%-17s %s\n", buf, po->help);
184  }
185  printf("\n");
186 }
187 
188  void show_help_children(const AVClass *class, int flags)
189 {
190  const AVClass *child = NULL;
191  if (class->option) {
192  av_opt_show2(&class, NULL, flags, 0);
193  printf("\n");
194  }
195 
196  while (child = av_opt_child_class_next(class, child))
197  show_help_children(child, flags);
198 }
199 
200  static const OptionDef *find_option(const OptionDef *po, const char *name)
201 {
202  const char *p = strchr(name, ':');
203  int len = p ? p - name : strlen(name);
204 
205  while (po->name != NULL) {
206  if (!strncmp(name, po->name, len) && strlen(po->name) == len)
207  break;
208  po++;
209  }
210  return po;
211 }
212 
213 /* _WIN32 means using the windows libc - cygwin doesn't define that
214  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
215  * it doesn't provide the actual command line via GetCommandLineW(). */
216 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
217 #include <windows.h>
218 #include <shellapi.h>
219 /* Will be leaked on exit */
220 static char** win32_argv_utf8 = NULL;
221 static int win32_argc = 0;
222 
223 /**
224  * Prepare command line arguments for executable.
225  * For Windows - perform wide-char to UTF-8 conversion.
226  * Input arguments should be main() function arguments.
227  * @param argc_ptr Arguments number (including executable)
228  * @param argv_ptr Arguments list.
229  */
230 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
231 {
232  char *argstr_flat;
233  wchar_t **argv_w;
234  int i, buffsize = 0, offset = 0;
235 
236  if (win32_argv_utf8) {
237  *argc_ptr = win32_argc;
238  *argv_ptr = win32_argv_utf8;
239  return;
240  }
241 
242  win32_argc = 0;
243  argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
244  if (win32_argc <= 0 || !argv_w)
245  return;
246 
247  /* determine the UTF-8 buffer size (including NULL-termination symbols) */
248  for (i = 0; i < win32_argc; i++)
249  buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
250  NULL, 0, NULL, NULL);
251 
252  win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
253  argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
254  if (win32_argv_utf8 == NULL) {
255  LocalFree(argv_w);
256  return;
257  }
258 
259  for (i = 0; i < win32_argc; i++) {
260  win32_argv_utf8[i] = &argstr_flat[offset];
261  offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
262  &argstr_flat[offset],
263  buffsize - offset, NULL, NULL);
264  }
265  win32_argv_utf8[i] = NULL;
266  LocalFree(argv_w);
267 
268  *argc_ptr = win32_argc;
269  *argv_ptr = win32_argv_utf8;
270 }
271 #else
272  static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
273 {
274  /* nothing to do */
275 }
276 #endif /* HAVE_COMMANDLINETOARGVW */
277 
278  static int write_option(void *optctx, const OptionDef *po, const char *opt,
279  const char *arg)
280 {
281  /* new-style options contain an offset into optctx, old-style address of
282  * a global var*/
283  void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
284  (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
285  int *dstcount;
286 
287  if (po->flags & OPT_SPEC) {
288  SpecifierOpt **so = dst;
289  char *p = strchr(opt, ':');
290 
291  dstcount = (int *)(so + 1);
292  *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
293  (*so)[*dstcount - 1].specifier = av_strdup(p ? p + 1 : "");
294  dst = &(*so)[*dstcount - 1].u;
295  }
296 
297  if (po->flags & OPT_STRING) {
298  char *str;
299  str = av_strdup(arg);
300  av_freep(dst);
301  *(char **)dst = str;
302  } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
303  *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
304  } else if (po->flags & OPT_INT64) {
305  *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
306  } else if (po->flags & OPT_TIME) {
307  *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
308  } else if (po->flags & OPT_FLOAT) {
309  *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
310  } else if (po->flags & OPT_DOUBLE) {
311  *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
312  } else if (po->u.func_arg) {
313  int ret = po->u.func_arg(optctx, opt, arg);
314  if (ret < 0) {
315  av_log(NULL, AV_LOG_ERROR,
316  "Failed to set value '%s' for option '%s': %s\n",
317  arg, opt, av_err2str(ret));
318  return ret;
319  }
320  }
321  if (po->flags & OPT_EXIT)
322  exit_program(0);
323 
324  return 0;
325 }
326 
327  int parse_option(void *optctx, const char *opt, const char *arg,
328  const OptionDef *options)
329 {
330  const OptionDef *po;
331  int ret;
332 
333  po = find_option(options, opt);
334  if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
335  /* handle 'no' bool option */
336  po = find_option(options, opt + 2);
337  if ((po->name && (po->flags & OPT_BOOL)))
338  arg = "0";
339  } else if (po->flags & OPT_BOOL)
340  arg = "1";
341 
342  if (!po->name)
343  po = find_option(options, "default");
344  if (!po->name) {
345  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
346  return AVERROR(EINVAL);
347  }
348  if (po->flags & HAS_ARG && !arg) {
349  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
350  return AVERROR(EINVAL);
351  }
352 
353  ret = write_option(optctx, po, opt, arg);
354  if (ret < 0)
355  return ret;
356 
357  return !!(po->flags & HAS_ARG);
358 }
359 
360  void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
361  void (*parse_arg_function)(void *, const char*))
362 {
363  const char *opt;
364  int optindex, handleoptions = 1, ret;
365 
366  /* perform system-dependent conversions for arguments list */
367  prepare_app_arguments(&argc, &argv);
368 
369  /* parse options */
370  optindex = 1;
371  while (optindex < argc) {
372  opt = argv[optindex++];
373 
374  if (handleoptions && opt[0] == '-' && opt[1] != '0円') {
375  if (opt[1] == '-' && opt[2] == '0円') {
376  handleoptions = 0;
377  continue;
378  }
379  opt++;
380 
381  if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
382  exit_program(1);
383  optindex += ret;
384  } else {
385  if (parse_arg_function)
386  parse_arg_function(optctx, opt);
387  }
388  }
389 }
390 
391  int parse_optgroup(void *optctx, OptionGroup *g)
392 {
393  int i, ret;
394 
395  av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
396  g->group_def->name, g->arg);
397 
398  for (i = 0; i < g->nb_opts; i++) {
399  Option *o = &g->opts[i];
400 
401  if (g->group_def->flags &&
402  !(g->group_def->flags & o->opt->flags)) {
403  av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
404  "%s %s -- you are trying to apply an input option to an "
405  "output file or vice versa. Move this option before the "
406  "file it belongs to.\n", o->key, o->opt->help,
407  g->group_def->name, g->arg);
408  return AVERROR(EINVAL);
409  }
410 
411  av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
412  o->key, o->opt->help, o->val);
413 
414  ret = write_option(optctx, o->opt, o->key, o->val);
415  if (ret < 0)
416  return ret;
417  }
418 
419  av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
420 
421  return 0;
422 }
423 
424  int locate_option(int argc, char **argv, const OptionDef *options,
425  const char *optname)
426 {
427  const OptionDef *po;
428  int i;
429 
430  for (i = 1; i < argc; i++) {
431  const char *cur_opt = argv[i];
432 
433  if (*cur_opt++ != '-')
434  continue;
435 
436  po = find_option(options, cur_opt);
437  if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
438  po = find_option(options, cur_opt + 2);
439 
440  if ((!po->name && !strcmp(cur_opt, optname)) ||
441  (po->name && !strcmp(optname, po->name)))
442  return i;
443 
444  if (po->flags & HAS_ARG)
445  i++;
446  }
447  return 0;
448 }
449 
450  static void dump_argument(const char *a)
451 {
452  const unsigned char *p;
453 
454  for (p = a; *p; p++)
455  if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
456  *p == '_' || (*p >= 'a' && *p <= 'z')))
457  break;
458  if (!*p) {
459  fputs(a, report_file);
460  return;
461  }
462  fputc('"', report_file);
463  for (p = a; *p; p++) {
464  if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
465  fprintf(report_file, "\\%c", *p);
466  else if (*p < ' ' || *p > '~')
467  fprintf(report_file, "\\x%02x", *p);
468  else
469  fputc(*p, report_file);
470  }
471  fputc('"', report_file);
472 }
473 
474  void parse_loglevel(int argc, char **argv, const OptionDef *options)
475 {
476  int idx = locate_option(argc, argv, options, "loglevel");
477  const char *env;
478  if (!idx)
479  idx = locate_option(argc, argv, options, "v");
480  if (idx && argv[idx + 1])
481  opt_loglevel(NULL, "loglevel", argv[idx + 1]);
482  idx = locate_option(argc, argv, options, "report");
483  if ((env = getenv("FFREPORT")) || idx) {
484  init_report(env);
485  if (report_file) {
486  int i;
487  fprintf(report_file, "Command line:\n");
488  for (i = 0; i < argc; i++) {
489  dump_argument(argv[i]);
490  fputc(i < argc - 1 ? ' ' : '\n', report_file);
491  }
492  fflush(report_file);
493  }
494  }
495  idx = locate_option(argc, argv, options, "hide_banner");
496  if (idx)
497  hide_banner = 1;
498 }
499 
500  static const AVOption *opt_find(void *obj, const char *name, const char *unit,
501  int opt_flags, int search_flags)
502 {
503  const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
504  if(o && !o->flags)
505  return NULL;
506  return o;
507 }
508 
509  #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
510  int opt_default(void *optctx, const char *opt, const char *arg)
511 {
512  const AVOption *o;
513  int consumed = 0;
514  char opt_stripped[128];
515  const char *p;
516  const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
517 #if CONFIG_AVRESAMPLE
518  const AVClass *rc = avresample_get_class();
519 #endif
520  const AVClass *sc, *swr_class;
521 
522  if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
523  av_log_set_level(AV_LOG_DEBUG);
524 
525  if (!(p = strchr(opt, ':')))
526  p = opt + strlen(opt);
527  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
528 
529  if ((o = opt_find(&cc, opt_stripped, NULL, 0,
530  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
531  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
532  (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
533  av_dict_set(&codec_opts, opt, arg, FLAGS);
534  consumed = 1;
535  }
536  if ((o = opt_find(&fc, opt, NULL, 0,
537  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
538  av_dict_set(&format_opts, opt, arg, FLAGS);
539  if (consumed)
540  av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
541  consumed = 1;
542  }
543 #if CONFIG_SWSCALE
544  sc = sws_get_class();
545  if (!consumed && opt_find(&sc, opt, NULL, 0,
546  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
547  // XXX we only support sws_flags, not arbitrary sws options
548  int ret = av_opt_set(sws_opts, opt, arg, 0);
549  if (ret < 0) {
550  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
551  return ret;
552  }
553  consumed = 1;
554  }
555 #endif
556 #if CONFIG_SWRESAMPLE
557  swr_class = swr_get_class();
558  if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
559  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
560  struct SwrContext *swr = swr_alloc();
561  int ret = av_opt_set(swr, opt, arg, 0);
562  swr_free(&swr);
563  if (ret < 0) {
564  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
565  return ret;
566  }
567  av_dict_set(&swr_opts, opt, arg, FLAGS);
568  consumed = 1;
569  }
570 #endif
571 #if CONFIG_AVRESAMPLE
572  if ((o=opt_find(&rc, opt, NULL, 0,
573  AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
574  av_dict_set(&resample_opts, opt, arg, FLAGS);
575  consumed = 1;
576  }
577 #endif
578 
579  if (consumed)
580  return 0;
581  return AVERROR_OPTION_NOT_FOUND;
582 }
583 
584 /*
585  * Check whether given option is a group separator.
586  *
587  * @return index of the group definition that matched or -1 if none
588  */
589  static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
590  const char *opt)
591 {
592  int i;
593 
594  for (i = 0; i < nb_groups; i++) {
595  const OptionGroupDef *p = &groups[i];
596  if (p->sep && !strcmp(p->sep, opt))
597  return i;
598  }
599 
600  return -1;
601 }
602 
603 /*
604  * Finish parsing an option group.
605  *
606  * @param group_idx which group definition should this group belong to
607  * @param arg argument of the group delimiting option
608  */
609  static void finish_group(OptionParseContext *octx, int group_idx,
610  const char *arg)
611 {
612  OptionGroupList *l = &octx->groups[group_idx];
613  OptionGroup *g;
614 
615  GROW_ARRAY(l->groups, l->nb_groups);
616  g = &l->groups[l->nb_groups - 1];
617 
618  *g = octx->cur_group;
619  g->arg = arg;
620  g->group_def = l->group_def;
621 #if CONFIG_SWSCALE
622  g->sws_opts = sws_opts;
623 #endif
624  g->swr_opts = swr_opts;
625  g->codec_opts = codec_opts;
626  g->format_opts = format_opts;
627  g->resample_opts = resample_opts;
628 
629  codec_opts = NULL;
630  format_opts = NULL;
631  resample_opts = NULL;
632 #if CONFIG_SWSCALE
633  sws_opts = NULL;
634 #endif
635  swr_opts = NULL;
636  init_opts();
637 
638  memset(&octx->cur_group, 0, sizeof(octx->cur_group));
639 }
640 
641 /*
642  * Add an option instance to currently parsed group.
643  */
644  static void add_opt(OptionParseContext *octx, const OptionDef *opt,
645  const char *key, const char *val)
646 {
647  int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
648  OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
649 
650  GROW_ARRAY(g->opts, g->nb_opts);
651  g->opts[g->nb_opts - 1].opt = opt;
652  g->opts[g->nb_opts - 1].key = key;
653  g->opts[g->nb_opts - 1].val = val;
654 }
655 
656  static void init_parse_context(OptionParseContext *octx,
657  const OptionGroupDef *groups, int nb_groups)
658 {
659  static const OptionGroupDef global_group = { "global" };
660  int i;
661 
662  memset(octx, 0, sizeof(*octx));
663 
664  octx->nb_groups = nb_groups;
665  octx->groups = av_mallocz(sizeof(*octx->groups) * octx->nb_groups);
666  if (!octx->groups)
667  exit_program(1);
668 
669  for (i = 0; i < octx->nb_groups; i++)
670  octx->groups[i].group_def = &groups[i];
671 
672  octx->global_opts.group_def = &global_group;
673  octx->global_opts.arg = "";
674 
675  init_opts();
676 }
677 
678  void uninit_parse_context(OptionParseContext *octx)
679 {
680  int i, j;
681 
682  for (i = 0; i < octx->nb_groups; i++) {
683  OptionGroupList *l = &octx->groups[i];
684 
685  for (j = 0; j < l->nb_groups; j++) {
686  av_freep(&l->groups[j].opts);
687  av_dict_free(&l->groups[j].codec_opts);
688  av_dict_free(&l->groups[j].format_opts);
689  av_dict_free(&l->groups[j].resample_opts);
690 #if CONFIG_SWSCALE
691  sws_freeContext(l->groups[j].sws_opts);
692 #endif
693  av_dict_free(&l->groups[j].swr_opts);
694  }
695  av_freep(&l->groups);
696  }
697  av_freep(&octx->groups);
698 
699  av_freep(&octx->cur_group.opts);
700  av_freep(&octx->global_opts.opts);
701 
702  uninit_opts();
703 }
704 
705  int split_commandline(OptionParseContext *octx, int argc, char *argv[],
706  const OptionDef *options,
707  const OptionGroupDef *groups, int nb_groups)
708 {
709  int optindex = 1;
710  int dashdash = -2;
711 
712  /* perform system-dependent conversions for arguments list */
713  prepare_app_arguments(&argc, &argv);
714 
715  init_parse_context(octx, groups, nb_groups);
716  av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
717 
718  while (optindex < argc) {
719  const char *opt = argv[optindex++], *arg;
720  const OptionDef *po;
721  int ret;
722 
723  av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
724 
725  if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
726  dashdash = optindex;
727  continue;
728  }
729  /* unnamed group separators, e.g. output filename */
730  if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
731  finish_group(octx, 0, opt);
732  av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
733  continue;
734  }
735  opt++;
736 
737 #define GET_ARG(arg) \
738 do { \
739  arg = argv[optindex++]; \
740  if (!arg) { \
741  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
742  return AVERROR(EINVAL); \
743  } \
744 } while (0)
745 
746  /* named group separators, e.g. -i */
747  if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
748  GET_ARG(arg);
749  finish_group(octx, ret, arg);
750  av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
751  groups[ret].name, arg);
752  continue;
753  }
754 
755  /* normal options */
756  po = find_option(options, opt);
757  if (po->name) {
758  if (po->flags & OPT_EXIT) {
759  /* optional argument, e.g. -h */
760  arg = argv[optindex++];
761  } else if (po->flags & HAS_ARG) {
762  GET_ARG(arg);
763  } else {
764  arg = "1";
765  }
766 
767  add_opt(octx, po, opt, arg);
768  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
769  "argument '%s'.\n", po->name, po->help, arg);
770  continue;
771  }
772 
773  /* AVOptions */
774  if (argv[optindex]) {
775  ret = opt_default(NULL, opt, argv[optindex]);
776  if (ret >= 0) {
777  av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
778  "argument '%s'.\n", opt, argv[optindex]);
779  optindex++;
780  continue;
781  } else if (ret != AVERROR_OPTION_NOT_FOUND) {
782  av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
783  "with argument '%s'.\n", opt, argv[optindex]);
784  return ret;
785  }
786  }
787 
788  /* boolean -nofoo options */
789  if (opt[0] == 'n' && opt[1] == 'o' &&
790  (po = find_option(options, opt + 2)) &&
791  po->name && po->flags & OPT_BOOL) {
792  add_opt(octx, po, opt, "0");
793  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
794  "argument 0.\n", po->name, po->help);
795  continue;
796  }
797 
798  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
799  return AVERROR_OPTION_NOT_FOUND;
800  }
801 
802  if (octx->cur_group.nb_opts || codec_opts || format_opts || resample_opts)
803  av_log(NULL, AV_LOG_WARNING, "Trailing options were found on the "
804  "commandline.\n");
805 
806  av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
807 
808  return 0;
809 }
810 
811  int opt_cpuflags(void *optctx, const char *opt, const char *arg)
812 {
813  int ret;
814  unsigned flags = av_get_cpu_flags();
815 
816  if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
817  return ret;
818 
819  av_force_cpu_flags(flags);
820  return 0;
821 }
822 
823  int opt_loglevel(void *optctx, const char *opt, const char *arg)
824 {
825  const struct { const char *name; int level; } log_levels[] = {
826  { "quiet" , AV_LOG_QUIET },
827  { "panic" , AV_LOG_PANIC },
828  { "fatal" , AV_LOG_FATAL },
829  { "error" , AV_LOG_ERROR },
830  { "warning", AV_LOG_WARNING },
831  { "info" , AV_LOG_INFO },
832  { "verbose", AV_LOG_VERBOSE },
833  { "debug" , AV_LOG_DEBUG },
834  };
835  char *tail;
836  int level;
837  int i;
838 
839  tail = strstr(arg, "repeat");
840  av_log_set_flags(tail ? 0 : AV_LOG_SKIP_REPEATED);
841  if (tail == arg)
842  arg += 6 + (arg[6]=='+');
843  if(tail && !*arg)
844  return 0;
845 
846  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
847  if (!strcmp(log_levels[i].name, arg)) {
848  av_log_set_level(log_levels[i].level);
849  return 0;
850  }
851  }
852 
853  level = strtol(arg, &tail, 10);
854  if (*tail) {
855  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
856  "Possible levels are numbers or:\n", arg);
857  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
858  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
859  exit_program(1);
860  }
861  av_log_set_level(level);
862  return 0;
863 }
864 
865  static void expand_filename_template(AVBPrint *bp, const char *template,
866  struct tm *tm)
867 {
868  int c;
869 
870  while ((c = *(template++))) {
871  if (c == '%') {
872  if (!(c = *(template++)))
873  break;
874  switch (c) {
875  case 'p':
876  av_bprintf(bp, "%s", program_name);
877  break;
878  case 't':
879  av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
880  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
881  tm->tm_hour, tm->tm_min, tm->tm_sec);
882  break;
883  case '%':
884  av_bprint_chars(bp, c, 1);
885  break;
886  }
887  } else {
888  av_bprint_chars(bp, c, 1);
889  }
890  }
891 }
892 
893  static int init_report(const char *env)
894 {
895  char *filename_template = NULL;
896  char *key, *val;
897  int ret, count = 0;
898  time_t now;
899  struct tm *tm;
900  AVBPrint filename;
901 
902  if (report_file) /* already opened */
903  return 0;
904  time(&now);
905  tm = localtime(&now);
906 
907  while (env && *env) {
908  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
909  if (count)
910  av_log(NULL, AV_LOG_ERROR,
911  "Failed to parse FFREPORT environment variable: %s\n",
912  av_err2str(ret));
913  break;
914  }
915  if (*env)
916  env++;
917  count++;
918  if (!strcmp(key, "file")) {
919  av_free(filename_template);
920  filename_template = val;
921  val = NULL;
922  } else {
923  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
924  }
925  av_free(val);
926  av_free(key);
927  }
928 
929  av_bprint_init(&filename, 0, 1);
930  expand_filename_template(&filename,
931  av_x_if_null(filename_template, "%p-%t.log"), tm);
932  av_free(filename_template);
933  if (!av_bprint_is_complete(&filename)) {
934  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
935  return AVERROR(ENOMEM);
936  }
937 
938  report_file = fopen(filename.str, "w");
939  if (!report_file) {
940  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
941  filename.str, strerror(errno));
942  return AVERROR(errno);
943  }
944  av_log_set_callback(log_callback_report);
945  av_log(NULL, AV_LOG_INFO,
946  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
947  "Report written to \"%s\"\n",
948  program_name,
949  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
950  tm->tm_hour, tm->tm_min, tm->tm_sec,
951  filename.str);
952  av_bprint_finalize(&filename, NULL);
953  return 0;
954 }
955 
956  int opt_report(const char *opt)
957 {
958  return init_report(NULL);
959 }
960 
961  int opt_max_alloc(void *optctx, const char *opt, const char *arg)
962 {
963  char *tail;
964  size_t max;
965 
966  max = strtol(arg, &tail, 10);
967  if (*tail) {
968  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
969  exit_program(1);
970  }
971  av_max_alloc(max);
972  return 0;
973 }
974 
975  int opt_timelimit(void *optctx, const char *opt, const char *arg)
976 {
977 #if HAVE_SETRLIMIT
978  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
979  struct rlimit rl = { lim, lim + 1 };
980  if (setrlimit(RLIMIT_CPU, &rl))
981  perror("setrlimit");
982 #else
983  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
984 #endif
985  return 0;
986 }
987 
988  void print_error(const char *filename, int err)
989 {
990  char errbuf[128];
991  const char *errbuf_ptr = errbuf;
992 
993  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
994  errbuf_ptr = strerror(AVUNERROR(err));
995  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
996 }
997 
998  static int warned_cfg = 0;
999 
1000  #define INDENT 1
1001  #define SHOW_VERSION 2
1002  #define SHOW_CONFIG 4
1003  #define SHOW_COPYRIGHT 8
1004 
1005  #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
1006  if (CONFIG_##LIBNAME) { \
1007  const char *indent = flags & INDENT? " " : ""; \
1008  if (flags & SHOW_VERSION) { \
1009  unsigned int version = libname##_version(); \
1010  av_log(NULL, level, \
1011  "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
1012  indent, #libname, \
1013  LIB##LIBNAME##_VERSION_MAJOR, \
1014  LIB##LIBNAME##_VERSION_MINOR, \
1015  LIB##LIBNAME##_VERSION_MICRO, \
1016  version >> 16, version >> 8 & 0xff, version & 0xff); \
1017  } \
1018  if (flags & SHOW_CONFIG) { \
1019  const char *cfg = libname##_configuration(); \
1020  if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
1021  if (!warned_cfg) { \
1022  av_log(NULL, level, \
1023  "%sWARNING: library configuration mismatch\n", \
1024  indent); \
1025  warned_cfg = 1; \
1026  } \
1027  av_log(NULL, level, "%s%-11s configuration: %s\n", \
1028  indent, #libname, cfg); \
1029  } \
1030  } \
1031  } \
1032 
1033  static void print_all_libs_info(int flags, int level)
1034 {
1035  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
1036  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
1037  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
1038  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
1039  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
1040  PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
1041  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
1042  PRINT_LIB_INFO(swresample,SWRESAMPLE, flags, level);
1043  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
1044 }
1045 
1046  static void print_program_info(int flags, int level)
1047 {
1048  const char *indent = flags & INDENT? " " : "";
1049 
1050  av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
1051  if (flags & SHOW_COPYRIGHT)
1052  av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
1053  program_birth_year, CONFIG_THIS_YEAR);
1054  av_log(NULL, level, "\n");
1055  av_log(NULL, level, "%sbuilt on %s %s with %s\n",
1056  indent, __DATE__, __TIME__, CC_IDENT);
1057 
1058  av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
1059 }
1060 
1061  static void print_buildconf(int flags, int level)
1062 {
1063  const char *indent = flags & INDENT ? " " : "";
1064  char str[] = { FFMPEG_CONFIGURATION };
1065  char *conflist, *remove_tilde, *splitconf;
1066 
1067  // Change all the ' --' strings to '~--' so that
1068  // they can be identified as tokens.
1069  while ((conflist = strstr(str, " --")) != NULL) {
1070  strncpy(conflist, "~--", 3);
1071  }
1072 
1073  // Compensate for the weirdness this would cause
1074  // when passing 'pkg-config --static'.
1075  while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
1076  strncpy(remove_tilde, "pkg-config ", 11);
1077  }
1078 
1079  splitconf = strtok(str, "~");
1080  av_log(NULL, level, "\n%sconfiguration:\n", indent);
1081  while (splitconf != NULL) {
1082  av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
1083  splitconf = strtok(NULL, "~");
1084  }
1085 }
1086 
1087  void show_banner(int argc, char **argv, const OptionDef *options)
1088 {
1089  int idx = locate_option(argc, argv, options, "version");
1090  if (hide_banner || idx)
1091  return;
1092 
1093  print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
1094  print_all_libs_info(INDENT|SHOW_CONFIG, AV_LOG_INFO);
1095  print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
1096 }
1097 
1098  int show_version(void *optctx, const char *opt, const char *arg)
1099 {
1100  av_log_set_callback(log_callback_help);
1101  print_program_info (0 , AV_LOG_INFO);
1102  print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
1103 
1104  return 0;
1105 }
1106 
1107  int show_buildconf(void *optctx, const char *opt, const char *arg)
1108 {
1109  av_log_set_callback(log_callback_help);
1110  print_buildconf (INDENT|0, AV_LOG_INFO);
1111 
1112  return 0;
1113 }
1114 
1115  int show_license(void *optctx, const char *opt, const char *arg)
1116 {
1117 #if CONFIG_NONFREE
1118  printf(
1119  "This version of %s has nonfree parts compiled in.\n"
1120  "Therefore it is not legally redistributable.\n",
1121  program_name );
1122 #elif CONFIG_GPLV3
1123  printf(
1124  "%s is free software; you can redistribute it and/or modify\n"
1125  "it under the terms of the GNU General Public License as published by\n"
1126  "the Free Software Foundation; either version 3 of the License, or\n"
1127  "(at your option) any later version.\n"
1128  "\n"
1129  "%s is distributed in the hope that it will be useful,\n"
1130  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1131  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1132  "GNU General Public License for more details.\n"
1133  "\n"
1134  "You should have received a copy of the GNU General Public License\n"
1135  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1136  program_name, program_name, program_name );
1137 #elif CONFIG_GPL
1138  printf(
1139  "%s is free software; you can redistribute it and/or modify\n"
1140  "it under the terms of the GNU General Public License as published by\n"
1141  "the Free Software Foundation; either version 2 of the License, or\n"
1142  "(at your option) any later version.\n"
1143  "\n"
1144  "%s is distributed in the hope that it will be useful,\n"
1145  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1146  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1147  "GNU General Public License for more details.\n"
1148  "\n"
1149  "You should have received a copy of the GNU General Public License\n"
1150  "along with %s; if not, write to the Free Software\n"
1151  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1152  program_name, program_name, program_name );
1153 #elif CONFIG_LGPLV3
1154  printf(
1155  "%s is free software; you can redistribute it and/or modify\n"
1156  "it under the terms of the GNU Lesser General Public License as published by\n"
1157  "the Free Software Foundation; either version 3 of the License, or\n"
1158  "(at your option) any later version.\n"
1159  "\n"
1160  "%s is distributed in the hope that it will be useful,\n"
1161  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1162  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1163  "GNU Lesser General Public License for more details.\n"
1164  "\n"
1165  "You should have received a copy of the GNU Lesser General Public License\n"
1166  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1167  program_name, program_name, program_name );
1168 #else
1169  printf(
1170  "%s is free software; you can redistribute it and/or\n"
1171  "modify it under the terms of the GNU Lesser General Public\n"
1172  "License as published by the Free Software Foundation; either\n"
1173  "version 2.1 of the License, or (at your option) any later version.\n"
1174  "\n"
1175  "%s is distributed in the hope that it will be useful,\n"
1176  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1177  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
1178  "Lesser General Public License for more details.\n"
1179  "\n"
1180  "You should have received a copy of the GNU Lesser General Public\n"
1181  "License along with %s; if not, write to the Free Software\n"
1182  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1183  program_name, program_name, program_name );
1184 #endif
1185 
1186  return 0;
1187 }
1188 
1189  int show_formats(void *optctx, const char *opt, const char *arg)
1190 {
1191  AVInputFormat *ifmt = NULL;
1192  AVOutputFormat *ofmt = NULL;
1193  const char *last_name;
1194 
1195  printf("File formats:\n"
1196  " D. = Demuxing supported\n"
1197  " .E = Muxing supported\n"
1198  " --\n");
1199  last_name = "000";
1200  for (;;) {
1201  int decode = 0;
1202  int encode = 0;
1203  const char *name = NULL;
1204  const char *long_name = NULL;
1205 
1206  while ((ofmt = av_oformat_next(ofmt))) {
1207  if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
1208  strcmp(ofmt->name, last_name) > 0) {
1209  name = ofmt->name;
1210  long_name = ofmt->long_name;
1211  encode = 1;
1212  }
1213  }
1214  while ((ifmt = av_iformat_next(ifmt))) {
1215  if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
1216  strcmp(ifmt->name, last_name) > 0) {
1217  name = ifmt->name;
1218  long_name = ifmt->long_name;
1219  encode = 0;
1220  }
1221  if (name && strcmp(ifmt->name, name) == 0)
1222  decode = 1;
1223  }
1224  if (name == NULL)
1225  break;
1226  last_name = name;
1227 
1228  printf(" %s%s %-15s %s\n",
1229  decode ? "D" : " ",
1230  encode ? "E" : " ",
1231  name,
1232  long_name ? long_name:" ");
1233  }
1234  return 0;
1235 }
1236 
1237  #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
1238  if (codec->field) { \
1239  const type *p = codec->field; \
1240  \
1241  printf(" Supported " list_name ":"); \
1242  while (*p != term) { \
1243  get_name(*p); \
1244  printf(" %s", name); \
1245  p++; \
1246  } \
1247  printf("\n"); \
1248  } \
1249 
1250  static void print_codec(const AVCodec *c)
1251 {
1252  int encoder = av_codec_is_encoder(c);
1253 
1254  printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
1255  c->long_name ? c->long_name : "");
1256 
1257  if (c->type == AVMEDIA_TYPE_VIDEO ||
1258  c->type == AVMEDIA_TYPE_AUDIO) {
1259  printf(" Threading capabilities: ");
1260  switch (c->capabilities & (CODEC_CAP_FRAME_THREADS |
1261  CODEC_CAP_SLICE_THREADS)) {
1262  case CODEC_CAP_FRAME_THREADS |
1263  CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
1264  case CODEC_CAP_FRAME_THREADS: printf("frame"); break;
1265  case CODEC_CAP_SLICE_THREADS: printf("slice"); break;
1266  default: printf("no"); break;
1267  }
1268  printf("\n");
1269  }
1270 
1271  if (c->supported_framerates) {
1272  const AVRational *fps = c->supported_framerates;
1273 
1274  printf(" Supported framerates:");
1275  while (fps->num) {
1276  printf(" %d/%d", fps->num, fps->den);
1277  fps++;
1278  }
1279  printf("\n");
1280  }
1281  PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
1282  AV_PIX_FMT_NONE, GET_PIX_FMT_NAME);
1283  PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
1284  GET_SAMPLE_RATE_NAME);
1285  PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
1286  AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME);
1287  PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
1288  0, GET_CH_LAYOUT_DESC);
1289 
1290  if (c->priv_class) {
1291  show_help_children(c->priv_class,
1292  AV_OPT_FLAG_ENCODING_PARAM |
1293  AV_OPT_FLAG_DECODING_PARAM);
1294  }
1295 }
1296 
1297  static char get_media_type_char(enum AVMediaType type)
1298 {
1299  switch (type) {
1300  case AVMEDIA_TYPE_VIDEO: return 'V';
1301  case AVMEDIA_TYPE_AUDIO: return 'A';
1302  case AVMEDIA_TYPE_DATA: return 'D';
1303  case AVMEDIA_TYPE_SUBTITLE: return 'S';
1304  case AVMEDIA_TYPE_ATTACHMENT:return 'T';
1305  default: return '?';
1306  }
1307 }
1308 
1309  static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
1310  int encoder)
1311 {
1312  while ((prev = av_codec_next(prev))) {
1313  if (prev->id == id &&
1314  (encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
1315  return prev;
1316  }
1317  return NULL;
1318 }
1319 
1320  static int compare_codec_desc(const void *a, const void *b)
1321 {
1322  const AVCodecDescriptor * const *da = a;
1323  const AVCodecDescriptor * const *db = b;
1324 
1325  return (*da)->type != (*db)->type ? (*da)->type - (*db)->type :
1326  strcmp((*da)->name, (*db)->name);
1327 }
1328 
1329  static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
1330 {
1331  const AVCodecDescriptor *desc = NULL;
1332  const AVCodecDescriptor **codecs;
1333  unsigned nb_codecs = 0, i = 0;
1334 
1335  while ((desc = avcodec_descriptor_next(desc)))
1336  nb_codecs++;
1337  if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
1338  av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
1339  exit_program(1);
1340  }
1341  desc = NULL;
1342  while ((desc = avcodec_descriptor_next(desc)))
1343  codecs[i++] = desc;
1344  av_assert0(i == nb_codecs);
1345  qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
1346  *rcodecs = codecs;
1347  return nb_codecs;
1348 }
1349 
1350  static void print_codecs_for_id(enum AVCodecID id, int encoder)
1351 {
1352  const AVCodec *codec = NULL;
1353 
1354  printf(" (%s: ", encoder ? "encoders" : "decoders");
1355 
1356  while ((codec = next_codec_for_id(id, codec, encoder)))
1357  printf("%s ", codec->name);
1358 
1359  printf(")");
1360 }
1361 
1362  int show_codecs(void *optctx, const char *opt, const char *arg)
1363 {
1364  const AVCodecDescriptor **codecs;
1365  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1366 
1367  printf("Codecs:\n"
1368  " D..... = Decoding supported\n"
1369  " .E.... = Encoding supported\n"
1370  " ..V... = Video codec\n"
1371  " ..A... = Audio codec\n"
1372  " ..S... = Subtitle codec\n"
1373  " ...I.. = Intra frame-only codec\n"
1374  " ....L. = Lossy compression\n"
1375  " .....S = Lossless compression\n"
1376  " -------\n");
1377  for (i = 0; i < nb_codecs; i++) {
1378  const AVCodecDescriptor *desc = codecs[i];
1379  const AVCodec *codec = NULL;
1380 
1381  printf(" ");
1382  printf(avcodec_find_decoder(desc->id) ? "D" : ".");
1383  printf(avcodec_find_encoder(desc->id) ? "E" : ".");
1384 
1385  printf("%c", get_media_type_char(desc->type));
1386  printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
1387  printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
1388  printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
1389 
1390  printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
1391 
1392  /* print decoders/encoders when there's more than one or their
1393  * names are different from codec name */
1394  while ((codec = next_codec_for_id(desc->id, codec, 0))) {
1395  if (strcmp(codec->name, desc->name)) {
1396  print_codecs_for_id(desc->id, 0);
1397  break;
1398  }
1399  }
1400  codec = NULL;
1401  while ((codec = next_codec_for_id(desc->id, codec, 1))) {
1402  if (strcmp(codec->name, desc->name)) {
1403  print_codecs_for_id(desc->id, 1);
1404  break;
1405  }
1406  }
1407 
1408  printf("\n");
1409  }
1410  av_free(codecs);
1411  return 0;
1412 }
1413 
1414  static void print_codecs(int encoder)
1415 {
1416  const AVCodecDescriptor **codecs;
1417  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1418 
1419  printf("%s:\n"
1420  " V..... = Video\n"
1421  " A..... = Audio\n"
1422  " S..... = Subtitle\n"
1423  " .F.... = Frame-level multithreading\n"
1424  " ..S... = Slice-level multithreading\n"
1425  " ...X.. = Codec is experimental\n"
1426  " ....B. = Supports draw_horiz_band\n"
1427  " .....D = Supports direct rendering method 1\n"
1428  " ------\n",
1429  encoder ? "Encoders" : "Decoders");
1430  for (i = 0; i < nb_codecs; i++) {
1431  const AVCodecDescriptor *desc = codecs[i];
1432  const AVCodec *codec = NULL;
1433 
1434  while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1435  printf(" %c", get_media_type_char(desc->type));
1436  printf((codec->capabilities & CODEC_CAP_FRAME_THREADS) ? "F" : ".");
1437  printf((codec->capabilities & CODEC_CAP_SLICE_THREADS) ? "S" : ".");
1438  printf((codec->capabilities & CODEC_CAP_EXPERIMENTAL) ? "X" : ".");
1439  printf((codec->capabilities & CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
1440  printf((codec->capabilities & CODEC_CAP_DR1) ? "D" : ".");
1441 
1442  printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
1443  if (strcmp(codec->name, desc->name))
1444  printf(" (codec %s)", desc->name);
1445 
1446  printf("\n");
1447  }
1448  }
1449  av_free(codecs);
1450 }
1451 
1452  int show_decoders(void *optctx, const char *opt, const char *arg)
1453 {
1454  print_codecs(0);
1455  return 0;
1456 }
1457 
1458  int show_encoders(void *optctx, const char *opt, const char *arg)
1459 {
1460  print_codecs(1);
1461  return 0;
1462 }
1463 
1464  int show_bsfs(void *optctx, const char *opt, const char *arg)
1465 {
1466  AVBitStreamFilter *bsf = NULL;
1467 
1468  printf("Bitstream filters:\n");
1469  while ((bsf = av_bitstream_filter_next(bsf)))
1470  printf("%s\n", bsf->name);
1471  printf("\n");
1472  return 0;
1473 }
1474 
1475  int show_protocols(void *optctx, const char *opt, const char *arg)
1476 {
1477  void *opaque = NULL;
1478  const char *name;
1479 
1480  printf("Supported file protocols:\n"
1481  "Input:\n");
1482  while ((name = avio_enum_protocols(&opaque, 0)))
1483  printf("%s\n", name);
1484  printf("Output:\n");
1485  while ((name = avio_enum_protocols(&opaque, 1)))
1486  printf("%s\n", name);
1487  return 0;
1488 }
1489 
1490  int show_filters(void *optctx, const char *opt, const char *arg)
1491 {
1492  const AVFilter av_unused(*filter) = NULL;
1493  char descr[64], *descr_cur;
1494  int i, j;
1495  const AVFilterPad *pad;
1496 
1497  printf("Filters:\n"
1498  " T.. = Timeline support\n"
1499  " .S. = Slice threading\n"
1500  " ..C = Commmand support\n"
1501  " A = Audio input/output\n"
1502  " V = Video input/output\n"
1503  " N = Dynamic number and/or type of input/output\n"
1504  " | = Source or sink filter\n");
1505 #if CONFIG_AVFILTER
1506  while ((filter = avfilter_next(filter))) {
1507  descr_cur = descr;
1508  for (i = 0; i < 2; i++) {
1509  if (i) {
1510  *(descr_cur++) = '-';
1511  *(descr_cur++) = '>';
1512  }
1513  pad = i ? filter->outputs : filter->inputs;
1514  for (j = 0; pad && pad[j].name; j++) {
1515  if (descr_cur >= descr + sizeof(descr) - 4)
1516  break;
1517  *(descr_cur++) = get_media_type_char(pad[j].type);
1518  }
1519  if (!j)
1520  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
1521  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
1522  }
1523  *descr_cur = 0;
1524  printf(" %c%c%c %-16s %-10s %s\n",
1525  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
1526  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
1527  filter->process_command ? 'C' : '.',
1528  filter->name, descr, filter->description);
1529  }
1530 #endif
1531  return 0;
1532 }
1533 
1534  int show_colors(void *optctx, const char *opt, const char *arg)
1535 {
1536  const char *name;
1537  const uint8_t *rgb;
1538  int i;
1539 
1540  printf("%-32s #RRGGBB\n", "name");
1541 
1542  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
1543  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
1544 
1545  return 0;
1546 }
1547 
1548  int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1549 {
1550  const AVPixFmtDescriptor *pix_desc = NULL;
1551 
1552  printf("Pixel formats:\n"
1553  "I.... = Supported Input format for conversion\n"
1554  ".O... = Supported Output format for conversion\n"
1555  "..H.. = Hardware accelerated format\n"
1556  "...P. = Paletted format\n"
1557  "....B = Bitstream format\n"
1558  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
1559  "-----\n");
1560 
1561 #if !CONFIG_SWSCALE
1562 # define sws_isSupportedInput(x) 0
1563 # define sws_isSupportedOutput(x) 0
1564 #endif
1565 
1566  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1567  enum AVPixelFormat pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
1568  printf("%c%c%c%c%c %-16s %d %2d\n",
1569  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
1570  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
1571  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
1572  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
1573  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1574  pix_desc->name,
1575  pix_desc->nb_components,
1576  av_get_bits_per_pixel(pix_desc));
1577  }
1578  return 0;
1579 }
1580 
1581  int show_layouts(void *optctx, const char *opt, const char *arg)
1582 {
1583  int i = 0;
1584  uint64_t layout, j;
1585  const char *name, *descr;
1586 
1587  printf("Individual channels:\n"
1588  "NAME DESCRIPTION\n");
1589  for (i = 0; i < 63; i++) {
1590  name = av_get_channel_name((uint64_t)1 << i);
1591  if (!name)
1592  continue;
1593  descr = av_get_channel_description((uint64_t)1 << i);
1594  printf("%-12s%s\n", name, descr);
1595  }
1596  printf("\nStandard channel layouts:\n"
1597  "NAME DECOMPOSITION\n");
1598  for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
1599  if (name) {
1600  printf("%-12s", name);
1601  for (j = 1; j; j <<= 1)
1602  if ((layout & j))
1603  printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
1604  printf("\n");
1605  }
1606  }
1607  return 0;
1608 }
1609 
1610  int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1611 {
1612  int i;
1613  char fmt_str[128];
1614  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1615  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1616  return 0;
1617 }
1618 
1619  static void show_help_codec(const char *name, int encoder)
1620 {
1621  const AVCodecDescriptor *desc;
1622  const AVCodec *codec;
1623 
1624  if (!name) {
1625  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1626  return;
1627  }
1628 
1629  codec = encoder ? avcodec_find_encoder_by_name(name) :
1630  avcodec_find_decoder_by_name(name);
1631 
1632  if (codec)
1633  print_codec(codec);
1634  else if ((desc = avcodec_descriptor_get_by_name(name))) {
1635  int printed = 0;
1636 
1637  while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1638  printed = 1;
1639  print_codec(codec);
1640  }
1641 
1642  if (!printed) {
1643  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
1644  "but no %s for it are available. FFmpeg might need to be "
1645  "recompiled with additional external libraries.\n",
1646  name, encoder ? "encoders" : "decoders");
1647  }
1648  } else {
1649  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
1650  name);
1651  }
1652 }
1653 
1654  static void show_help_demuxer(const char *name)
1655 {
1656  const AVInputFormat *fmt = av_find_input_format(name);
1657 
1658  if (!fmt) {
1659  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1660  return;
1661  }
1662 
1663  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1664 
1665  if (fmt->extensions)
1666  printf(" Common extensions: %s.\n", fmt->extensions);
1667 
1668  if (fmt->priv_class)
1669  show_help_children(fmt->priv_class, AV_OPT_FLAG_DECODING_PARAM);
1670 }
1671 
1672  static void show_help_muxer(const char *name)
1673 {
1674  const AVCodecDescriptor *desc;
1675  const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
1676 
1677  if (!fmt) {
1678  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1679  return;
1680  }
1681 
1682  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1683 
1684  if (fmt->extensions)
1685  printf(" Common extensions: %s.\n", fmt->extensions);
1686  if (fmt->mime_type)
1687  printf(" Mime type: %s.\n", fmt->mime_type);
1688  if (fmt->video_codec != AV_CODEC_ID_NONE &&
1689  (desc = avcodec_descriptor_get(fmt->video_codec))) {
1690  printf(" Default video codec: %s.\n", desc->name);
1691  }
1692  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1693  (desc = avcodec_descriptor_get(fmt->audio_codec))) {
1694  printf(" Default audio codec: %s.\n", desc->name);
1695  }
1696  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1697  (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
1698  printf(" Default subtitle codec: %s.\n", desc->name);
1699  }
1700 
1701  if (fmt->priv_class)
1702  show_help_children(fmt->priv_class, AV_OPT_FLAG_ENCODING_PARAM);
1703 }
1704 
1705 #if CONFIG_AVFILTER
1706 static void show_help_filter(const char *name)
1707 {
1708 #if CONFIG_AVFILTER
1709  const AVFilter *f = avfilter_get_by_name(name);
1710  int i, count;
1711 
1712  if (!name) {
1713  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1714  return;
1715  } else if (!f) {
1716  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1717  return;
1718  }
1719 
1720  printf("Filter %s\n", f->name);
1721  if (f->description)
1722  printf(" %s\n", f->description);
1723 
1724  if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
1725  printf(" slice threading supported\n");
1726 
1727  printf(" Inputs:\n");
1728  count = avfilter_pad_count(f->inputs);
1729  for (i = 0; i < count; i++) {
1730  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1731  media_type_string(avfilter_pad_get_type(f->inputs, i)));
1732  }
1733  if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
1734  printf(" dynamic (depending on the options)\n");
1735  else if (!count)
1736  printf(" none (source filter)\n");
1737 
1738  printf(" Outputs:\n");
1739  count = avfilter_pad_count(f->outputs);
1740  for (i = 0; i < count; i++) {
1741  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1742  media_type_string(avfilter_pad_get_type(f->outputs, i)));
1743  }
1744  if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
1745  printf(" dynamic (depending on the options)\n");
1746  else if (!count)
1747  printf(" none (sink filter)\n");
1748 
1749  if (f->priv_class)
1750  show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
1751  AV_OPT_FLAG_AUDIO_PARAM);
1752  if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
1753  printf("This filter has support for timeline through the 'enable' option.\n");
1754 #else
1755  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
1756  "can not to satisfy request\n");
1757 #endif
1758 }
1759 #endif
1760 
1761  int show_help(void *optctx, const char *opt, const char *arg)
1762 {
1763  char *topic, *par;
1764  av_log_set_callback(log_callback_help);
1765 
1766  topic = av_strdup(arg ? arg : "");
1767  par = strchr(topic, '=');
1768  if (par)
1769  *par++ = 0;
1770 
1771  if (!*topic) {
1772  show_help_default(topic, par);
1773  } else if (!strcmp(topic, "decoder")) {
1774  show_help_codec(par, 0);
1775  } else if (!strcmp(topic, "encoder")) {
1776  show_help_codec(par, 1);
1777  } else if (!strcmp(topic, "demuxer")) {
1778  show_help_demuxer(par);
1779  } else if (!strcmp(topic, "muxer")) {
1780  show_help_muxer(par);
1781 #if CONFIG_AVFILTER
1782  } else if (!strcmp(topic, "filter")) {
1783  show_help_filter(par);
1784 #endif
1785  } else {
1786  show_help_default(topic, par);
1787  }
1788 
1789  av_freep(&topic);
1790  return 0;
1791 }
1792 
1793  int read_yesno(void)
1794 {
1795  int c = getchar();
1796  int yesno = (av_toupper(c) == 'Y');
1797 
1798  while (c != '\n' && c != EOF)
1799  c = getchar();
1800 
1801  return yesno;
1802 }
1803 
1804  int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
1805 {
1806  int ret;
1807  FILE *f = av_fopen_utf8(filename, "rb");
1808 
1809  if (!f) {
1810  av_log(NULL, AV_LOG_ERROR, "Cannot read file '%s': %s\n", filename,
1811  strerror(errno));
1812  return AVERROR(errno);
1813  }
1814  fseek(f, 0, SEEK_END);
1815  *size = ftell(f);
1816  fseek(f, 0, SEEK_SET);
1817  if (*size == (size_t)-1) {
1818  av_log(NULL, AV_LOG_ERROR, "IO error: %s\n", strerror(errno));
1819  fclose(f);
1820  return AVERROR(errno);
1821  }
1822  *bufptr = av_malloc(*size + 1);
1823  if (!*bufptr) {
1824  av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
1825  fclose(f);
1826  return AVERROR(ENOMEM);
1827  }
1828  ret = fread(*bufptr, 1, *size, f);
1829  if (ret < *size) {
1830  av_free(*bufptr);
1831  if (ferror(f)) {
1832  av_log(NULL, AV_LOG_ERROR, "Error while reading file '%s': %s\n",
1833  filename, strerror(errno));
1834  ret = AVERROR(errno);
1835  } else
1836  ret = AVERROR_EOF;
1837  } else {
1838  ret = 0;
1839  (*bufptr)[(*size)++] = '0円';
1840  }
1841 
1842  fclose(f);
1843  return ret;
1844 }
1845 
1846  FILE *get_preset_file(char *filename, size_t filename_size,
1847  const char *preset_name, int is_path,
1848  const char *codec_name)
1849 {
1850  FILE *f = NULL;
1851  int i;
1852  const char *base[3] = { getenv("FFMPEG_DATADIR"),
1853  getenv("HOME"),
1854  FFMPEG_DATADIR, };
1855 
1856  if (is_path) {
1857  av_strlcpy(filename, preset_name, filename_size);
1858  f = fopen(filename, "r");
1859  } else {
1860 #ifdef _WIN32
1861  char datadir[MAX_PATH], *ls;
1862  base[2] = NULL;
1863 
1864  if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
1865  {
1866  for (ls = datadir; ls < datadir + strlen(datadir); ls++)
1867  if (*ls == '\\') *ls = '/';
1868 
1869  if (ls = strrchr(datadir, '/'))
1870  {
1871  *ls = 0;
1872  strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
1873  base[2] = datadir;
1874  }
1875  }
1876 #endif
1877  for (i = 0; i < 3 && !f; i++) {
1878  if (!base[i])
1879  continue;
1880  snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
1881  i != 1 ? "" : "/.ffmpeg", preset_name);
1882  f = fopen(filename, "r");
1883  if (!f && codec_name) {
1884  snprintf(filename, filename_size,
1885  "%s%s/%s-%s.ffpreset",
1886  base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
1887  preset_name);
1888  f = fopen(filename, "r");
1889  }
1890  }
1891  }
1892 
1893  return f;
1894 }
1895 
1896  int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
1897 {
1898  int ret = avformat_match_stream_specifier(s, st, spec);
1899  if (ret < 0)
1900  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
1901  return ret;
1902 }
1903 
1904  AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
1905  AVFormatContext *s, AVStream *st, AVCodec *codec)
1906 {
1907  AVDictionary *ret = NULL;
1908  AVDictionaryEntry *t = NULL;
1909  int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
1910  : AV_OPT_FLAG_DECODING_PARAM;
1911  char prefix = 0;
1912  const AVClass *cc = avcodec_get_class();
1913 
1914  if (!codec)
1915  codec = s->oformat ? avcodec_find_encoder(codec_id)
1916  : avcodec_find_decoder(codec_id);
1917 
1918  switch (st->codec->codec_type) {
1919  case AVMEDIA_TYPE_VIDEO:
1920  prefix = 'v';
1921  flags |= AV_OPT_FLAG_VIDEO_PARAM;
1922  break;
1923  case AVMEDIA_TYPE_AUDIO:
1924  prefix = 'a';
1925  flags |= AV_OPT_FLAG_AUDIO_PARAM;
1926  break;
1927  case AVMEDIA_TYPE_SUBTITLE:
1928  prefix = 's';
1929  flags |= AV_OPT_FLAG_SUBTITLE_PARAM;
1930  break;
1931  }
1932 
1933  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
1934  char *p = strchr(t->key, ':');
1935 
1936  /* check stream specification in opt name */
1937  if (p)
1938  switch (check_stream_specifier(s, st, p + 1)) {
1939  case 1: *p = 0; break;
1940  case 0: continue;
1941  default: return NULL;
1942  }
1943 
1944  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
1945  (codec && codec->priv_class &&
1946  av_opt_find(&codec->priv_class, t->key, NULL, flags,
1947  AV_OPT_SEARCH_FAKE_OBJ)))
1948  av_dict_set(&ret, t->key, t->value, 0);
1949  else if (t->key[0] == prefix &&
1950  av_opt_find(&cc, t->key + 1, NULL, flags,
1951  AV_OPT_SEARCH_FAKE_OBJ))
1952  av_dict_set(&ret, t->key + 1, t->value, 0);
1953 
1954  if (p)
1955  *p = ':';
1956  }
1957  return ret;
1958 }
1959 
1960  AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
1961  AVDictionary *codec_opts)
1962 {
1963  int i;
1964  AVDictionary **opts;
1965 
1966  if (!s->nb_streams)
1967  return NULL;
1968  opts = av_mallocz(s->nb_streams * sizeof(*opts));
1969  if (!opts) {
1970  av_log(NULL, AV_LOG_ERROR,
1971  "Could not alloc memory for stream options.\n");
1972  return NULL;
1973  }
1974  for (i = 0; i < s->nb_streams; i++)
1975  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codec->codec_id,
1976  s, s->streams[i], NULL);
1977  return opts;
1978 }
1979 
1980  void *grow_array(void *array, int elem_size, int *size, int new_size)
1981 {
1982  if (new_size >= INT_MAX / elem_size) {
1983  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
1984  exit_program(1);
1985  }
1986  if (*size < new_size) {
1987  uint8_t *tmp = av_realloc(array, new_size*elem_size);
1988  if (!tmp) {
1989  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
1990  exit_program(1);
1991  }
1992  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
1993  *size = new_size;
1994  return tmp;
1995  }
1996  return array;
1997 }
Generated on Sun Mar 23 2014 23:49:48 for FFmpeg by   doxygen 1.8.2

AltStyle によって変換されたページ (->オリジナル) /