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