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"
38 #include "libswscale/swscale.h"
41 #include "libavutil/attributes.h"
42 #include "libavutil/avassert.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/bprint.h"
45 #include "libavutil/display.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/imgutils.h"
48 #include "libavutil/libm.h"
49 #include "libavutil/parseutils.h"
50 #include "libavutil/pixdesc.h"
51 #include "libavutil/eval.h"
52 #include "libavutil/dict.h"
53 #include "libavutil/opt.h"
54 #include "libavutil/cpu.h"
55 #include "libavutil/ffversion.h"
56 #include "libavutil/version.h"
57 #include "cmdutils.h"
58 #if CONFIG_NETWORK
59 #include "libavformat/network.h"
60 #endif
61 #if HAVE_SYS_RESOURCE_H
62 #include <sys/time.h>
63 #include <sys/resource.h>
64 #endif
65 #ifdef _WIN32
66 #include <windows.h>
67 #endif
68 
69 static int init_report(const char *env);
70 
74 
75 static FILE *report_file;
77 int hide_banner = 0;
78 
83 };
84 
85 void init_opts(void)
86 {
87  av_dict_set(&sws_dict, "flags", "bicubic", 0);
88 }
89 
90 void uninit_opts(void)
91 {
97 }
98 
99 void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
100 {
101  vfprintf(stdout, fmt, vl);
102 }
103 
104 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
105 {
106  va_list vl2;
107  char line[1024];
108  static int print_prefix = 1;
109 
110  va_copy(vl2, vl);
111  av_log_default_callback(ptr, level, fmt, vl);
112  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
113  va_end(vl2);
114  if (report_file_level >= level) {
115  fputs(line, report_file);
116  fflush(report_file);
117  }
118 }
119 
120 void init_dynload(void)
121 {
122 #ifdef _WIN32
123  /* Calling SetDllDirectory with the empty string (but not NULL) removes the
124  * current working directory from the DLL search path as a security pre-caution. */
125  SetDllDirectory("");
126 #endif
127 }
128 
129 static void (*program_exit)(int ret);
130 
131 void register_exit(void (*cb)(int ret))
132 {
133  program_exit = cb;
134 }
135 
136 void exit_program(int ret)
137 {
138  if (program_exit)
139  program_exit(ret);
140 
141  exit(ret);
142 }
143 
144 double parse_number_or_die(const char *context, const char *numstr, int type,
145  double min, double max)
146 {
147  char *tail;
148  const char *error;
149  double d = av_strtod(numstr, &tail);
150  if (*tail)
151  error = "Expected number for %s but found: %s\n";
152  else if (d < min || d > max)
153  error = "The value for %s was %s which is not within %f - %f\n";
154  else if (type == OPT_INT64 && (int64_t)d != d)
155  error = "Expected int64 for %s but found %s\n";
156  else if (type == OPT_INT && (int)d != d)
157  error = "Expected int for %s but found %s\n";
158  else
159  return d;
160  av_log(NULL, AV_LOG_FATAL, error, context, numstr, min, max);
161  exit_program(1);
162  return 0;
163 }
164 
165 int64_t parse_time_or_die(const char *context, const char *timestr,
166  int is_duration)
167 {
168  int64_t us;
169  if (av_parse_time(&us, timestr, is_duration) < 0) {
170  av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n",
171  is_duration ? "duration" : "date", context, timestr);
172  exit_program(1);
173  }
174  return us;
175 }
176 
177 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
178  int rej_flags, int alt_flags)
179 {
180  const OptionDef *po;
181  int first;
182 
183  first = 1;
184  for (po = options; po->name; po++) {
185  char buf[64];
186 
187  if (((po->flags & req_flags) != req_flags) ||
188  (alt_flags && !(po->flags & alt_flags)) ||
189  (po->flags & rej_flags))
190  continue;
191 
192  if (first) {
193  printf("%s\n", msg);
194  first = 0;
195  }
196  av_strlcpy(buf, po->name, sizeof(buf));
197  if (po->argname) {
198  av_strlcat(buf, " ", sizeof(buf));
199  av_strlcat(buf, po->argname, sizeof(buf));
200  }
201  printf("-%-17s %s\n", buf, po->help);
202  }
203  printf("\n");
204 }
205 
206 void show_help_children(const AVClass *class, int flags)
207 {
208  const AVClass *child = NULL;
209  if (class->option) {
210  av_opt_show2(&class, NULL, flags, 0);
211  printf("\n");
212  }
213 
214  while (child = av_opt_child_class_next(class, child))
216 }
217 
218 static const OptionDef *find_option(const OptionDef *po, const char *name)
219 {
220  const char *p = strchr(name, ':');
221  int len = p ? p - name : strlen(name);
222 
223  while (po->name) {
224  if (!strncmp(name, po->name, len) && strlen(po->name) == len)
225  break;
226  po++;
227  }
228  return po;
229 }
230 
231 /* _WIN32 means using the windows libc - cygwin doesn't define that
232  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
233  * it doesn't provide the actual command line via GetCommandLineW(). */
234 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
235 #include <shellapi.h>
236 /* Will be leaked on exit */
237 static char** win32_argv_utf8 = NULL;
238 static int win32_argc = 0;
239 
240 /**
241  * Prepare command line arguments for executable.
242  * For Windows - perform wide-char to UTF-8 conversion.
243  * Input arguments should be main() function arguments.
244  * @param argc_ptr Arguments number (including executable)
245  * @param argv_ptr Arguments list.
246  */
247 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
248 {
249  char *argstr_flat;
250  wchar_t **argv_w;
251  int i, buffsize = 0, offset = 0;
252 
253  if (win32_argv_utf8) {
254  *argc_ptr = win32_argc;
255  *argv_ptr = win32_argv_utf8;
256  return;
257  }
258 
259  win32_argc = 0;
260  argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
261  if (win32_argc <= 0 || !argv_w)
262  return;
263 
264  /* determine the UTF-8 buffer size (including NULL-termination symbols) */
265  for (i = 0; i < win32_argc; i++)
266  buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
267  NULL, 0, NULL, NULL);
268 
269  win32_argv_utf8 = av_mallocz(sizeof(char *) * (win32_argc + 1) + buffsize);
270  argstr_flat = (char *)win32_argv_utf8 + sizeof(char *) * (win32_argc + 1);
271  if (!win32_argv_utf8) {
272  LocalFree(argv_w);
273  return;
274  }
275 
276  for (i = 0; i < win32_argc; i++) {
277  win32_argv_utf8[i] = &argstr_flat[offset];
278  offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
279  &argstr_flat[offset],
280  buffsize - offset, NULL, NULL);
281  }
282  win32_argv_utf8[i] = NULL;
283  LocalFree(argv_w);
284 
285  *argc_ptr = win32_argc;
286  *argv_ptr = win32_argv_utf8;
287 }
288 #else
289 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
290 {
291  /* nothing to do */
292 }
293 #endif /* HAVE_COMMANDLINETOARGVW */
294 
295 static int write_option(void *optctx, const OptionDef *po, const char *opt,
296  const char *arg)
297 {
298  /* new-style options contain an offset into optctx, old-style address of
299  * a global var*/
300  void *dst = po->flags & (OPT_OFFSET | OPT_SPEC) ?
301  (uint8_t *)optctx + po->u.off : po->u.dst_ptr;
302  int *dstcount;
303 
304  if (po->flags & OPT_SPEC) {
305  SpecifierOpt **so = dst;
306  char *p = strchr(opt, ':');
307  char *str;
308 
309  dstcount = (int *)(so + 1);
310  *so = grow_array(*so, sizeof(**so), dstcount, *dstcount + 1);
311  str = av_strdup(p ? p + 1 : "");
312  if (!str)
313  return AVERROR(ENOMEM);
314  (*so)[*dstcount - 1].specifier = str;
315  dst = &(*so)[*dstcount - 1].u;
316  }
317 
318  if (po->flags & OPT_STRING) {
319  char *str;
320  str = av_strdup(arg);
321  av_freep(dst);
322  if (!str)
323  return AVERROR(ENOMEM);
324  *(char **)dst = str;
325  } else if (po->flags & OPT_BOOL || po->flags & OPT_INT) {
326  *(int *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
327  } else if (po->flags & OPT_INT64) {
328  *(int64_t *)dst = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
329  } else if (po->flags & OPT_TIME) {
330  *(int64_t *)dst = parse_time_or_die(opt, arg, 1);
331  } else if (po->flags & OPT_FLOAT) {
332  *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
333  } else if (po->flags & OPT_DOUBLE) {
334  *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
335  } else if (po->u.func_arg) {
336  int ret = po->u.func_arg(optctx, opt, arg);
337  if (ret < 0) {
339  "Failed to set value '%s' for option '%s': %s\n",
340  arg, opt, av_err2str(ret));
341  return ret;
342  }
343  }
344  if (po->flags & OPT_EXIT)
345  exit_program(0);
346 
347  return 0;
348 }
349 
350 int parse_option(void *optctx, const char *opt, const char *arg,
351  const OptionDef *options)
352 {
353  const OptionDef *po;
354  int ret;
355 
356  po = find_option(options, opt);
357  if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
358  /* handle 'no' bool option */
359  po = find_option(options, opt + 2);
360  if ((po->name && (po->flags & OPT_BOOL)))
361  arg = "0";
362  } else if (po->flags & OPT_BOOL)
363  arg = "1";
364 
365  if (!po->name)
366  po = find_option(options, "default");
367  if (!po->name) {
368  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt);
369  return AVERROR(EINVAL);
370  }
371  if (po->flags & HAS_ARG && !arg) {
372  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'\n", opt);
373  return AVERROR(EINVAL);
374  }
375 
376  ret = write_option(optctx, po, opt, arg);
377  if (ret < 0)
378  return ret;
379 
380  return !!(po->flags & HAS_ARG);
381 }
382 
383 void parse_options(void *optctx, int argc, char **argv, const OptionDef *options,
384  void (*parse_arg_function)(void *, const char*))
385 {
386  const char *opt;
387  int optindex, handleoptions = 1, ret;
388 
389  /* perform system-dependent conversions for arguments list */
390  prepare_app_arguments(&argc, &argv);
391 
392  /* parse options */
393  optindex = 1;
394  while (optindex < argc) {
395  opt = argv[optindex++];
396 
397  if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
398  if (opt[1] == '-' && opt[2] == '\0') {
399  handleoptions = 0;
400  continue;
401  }
402  opt++;
403 
404  if ((ret = parse_option(optctx, opt, argv[optindex], options)) < 0)
405  exit_program(1);
406  optindex += ret;
407  } else {
408  if (parse_arg_function)
409  parse_arg_function(optctx, opt);
410  }
411  }
412 }
413 
414 int parse_optgroup(void *optctx, OptionGroup *g)
415 {
416  int i, ret;
417 
418  av_log(NULL, AV_LOG_DEBUG, "Parsing a group of options: %s %s.\n",
419  g->group_def->name, g->arg);
420 
421  for (i = 0; i < g->nb_opts; i++) {
422  Option *o = &g->opts[i];
423 
424  if (g->group_def->flags &&
425  !(g->group_def->flags & o->opt->flags)) {
426  av_log(NULL, AV_LOG_ERROR, "Option %s (%s) cannot be applied to "
427  "%s %s -- you are trying to apply an input option to an "
428  "output file or vice versa. Move this option before the "
429  "file it belongs to.\n", o->key, o->opt->help,
430  g->group_def->name, g->arg);
431  return AVERROR(EINVAL);
432  }
433 
434  av_log(NULL, AV_LOG_DEBUG, "Applying option %s (%s) with argument %s.\n",
435  o->key, o->opt->help, o->val);
436 
437  ret = write_option(optctx, o->opt, o->key, o->val);
438  if (ret < 0)
439  return ret;
440  }
441 
442  av_log(NULL, AV_LOG_DEBUG, "Successfully parsed a group of options.\n");
443 
444  return 0;
445 }
446 
447 int locate_option(int argc, char **argv, const OptionDef *options,
448  const char *optname)
449 {
450  const OptionDef *po;
451  int i;
452 
453  for (i = 1; i < argc; i++) {
454  const char *cur_opt = argv[i];
455 
456  if (*cur_opt++ != '-')
457  continue;
458 
459  po = find_option(options, cur_opt);
460  if (!po->name && cur_opt[0] == 'n' && cur_opt[1] == 'o')
461  po = find_option(options, cur_opt + 2);
462 
463  if ((!po->name && !strcmp(cur_opt, optname)) ||
464  (po->name && !strcmp(optname, po->name)))
465  return i;
466 
467  if (!po->name || po->flags & HAS_ARG)
468  i++;
469  }
470  return 0;
471 }
472 
473 static void dump_argument(const char *a)
474 {
475  const unsigned char *p;
476 
477  for (p = a; *p; p++)
478  if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
479  *p == '_' || (*p >= 'a' && *p <= 'z')))
480  break;
481  if (!*p) {
482  fputs(a, report_file);
483  return;
484  }
485  fputc('"', report_file);
486  for (p = a; *p; p++) {
487  if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
488  fprintf(report_file, "\\%c", *p);
489  else if (*p < ' ' || *p > '~')
490  fprintf(report_file, "\\x%02x", *p);
491  else
492  fputc(*p, report_file);
493  }
494  fputc('"', report_file);
495 }
496 
497 static void check_options(const OptionDef *po)
498 {
499  while (po->name) {
500  if (po->flags & OPT_PERFILE)
502  po++;
503  }
504 }
505 
506 void parse_loglevel(int argc, char **argv, const OptionDef *options)
507 {
508  int idx = locate_option(argc, argv, options, "loglevel");
509  const char *env;
510 
512 
513  if (!idx)
514  idx = locate_option(argc, argv, options, "v");
515  if (idx && argv[idx + 1])
516  opt_loglevel(NULL, "loglevel", argv[idx + 1]);
517  idx = locate_option(argc, argv, options, "report");
518  if ((env = getenv("FFREPORT")) || idx) {
519  init_report(env);
520  if (report_file) {
521  int i;
522  fprintf(report_file, "Command line:\n");
523  for (i = 0; i < argc; i++) {
524  dump_argument(argv[i]);
525  fputc(i < argc - 1 ? ' ' : '\n', report_file);
526  }
527  fflush(report_file);
528  }
529  }
530  idx = locate_option(argc, argv, options, "hide_banner");
531  if (idx)
532  hide_banner = 1;
533 }
534 
535 static const AVOption *opt_find(void *obj, const char *name, const char *unit,
536  int opt_flags, int search_flags)
537 {
538  const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
539  if(o && !o->flags)
540  return NULL;
541  return o;
542 }
543 
544 #define FLAGS (o->type == AV_OPT_TYPE_FLAGS && (arg[0]=='-' || arg[0]=='+')) ? AV_DICT_APPEND : 0
545 int opt_default(void *optctx, const char *opt, const char *arg)
546 {
547  const AVOption *o;
548  int consumed = 0;
549  char opt_stripped[128];
550  const char *p;
551  const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
552 #if CONFIG_AVRESAMPLE
553  const AVClass *rc = avresample_get_class();
554 #endif
555 #if CONFIG_SWSCALE
556  const AVClass *sc = sws_get_class();
557 #endif
558 #if CONFIG_SWRESAMPLE
559  const AVClass *swr_class = swr_get_class();
560 #endif
561 
562  if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
564 
565  if (!(p = strchr(opt, ':')))
566  p = opt + strlen(opt);
567  av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
568 
569  if ((o = opt_find(&cc, opt_stripped, NULL, 0,
571  ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
572  (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
573  av_dict_set(&codec_opts, opt, arg, FLAGS);
574  consumed = 1;
575  }
576  if ((o = opt_find(&fc, opt, NULL, 0,
578  av_dict_set(&format_opts, opt, arg, FLAGS);
579  if (consumed)
580  av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
581  consumed = 1;
582  }
583 #if CONFIG_SWSCALE
584  if (!consumed && (o = opt_find(&sc, opt, NULL, 0,
586  struct SwsContext *sws = sws_alloc_context();
587  int ret = av_opt_set(sws, opt, arg, 0);
588  sws_freeContext(sws);
589  if (!strcmp(opt, "srcw") || !strcmp(opt, "srch") ||
590  !strcmp(opt, "dstw") || !strcmp(opt, "dsth") ||
591  !strcmp(opt, "src_format") || !strcmp(opt, "dst_format")) {
592  av_log(NULL, AV_LOG_ERROR, "Directly using swscale dimensions/format options is not supported, please use the -s or -pix_fmt options\n");
593  return AVERROR(EINVAL);
594  }
595  if (ret < 0) {
596  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
597  return ret;
598  }
599 
600  av_dict_set(&sws_dict, opt, arg, FLAGS);
601 
602  consumed = 1;
603  }
604 #else
605  if (!consumed && !strcmp(opt, "sws_flags")) {
606  av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
607  consumed = 1;
608  }
609 #endif
610 #if CONFIG_SWRESAMPLE
611  if (!consumed && (o=opt_find(&swr_class, opt, NULL, 0,
613  struct SwrContext *swr = swr_alloc();
614  int ret = av_opt_set(swr, opt, arg, 0);
615  swr_free(&swr);
616  if (ret < 0) {
617  av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
618  return ret;
619  }
620  av_dict_set(&swr_opts, opt, arg, FLAGS);
621  consumed = 1;
622  }
623 #endif
624 #if CONFIG_AVRESAMPLE
625  if ((o=opt_find(&rc, opt, NULL, 0,
628  consumed = 1;
629  }
630 #endif
631 
632  if (consumed)
633  return 0;
635 }
636 
637 /*
638  * Check whether given option is a group separator.
639  *
640  * @return index of the group definition that matched or -1 if none
641  */
642 static int match_group_separator(const OptionGroupDef *groups, int nb_groups,
643  const char *opt)
644 {
645  int i;
646 
647  for (i = 0; i < nb_groups; i++) {
648  const OptionGroupDef *p = &groups[i];
649  if (p->sep && !strcmp(p->sep, opt))
650  return i;
651  }
652 
653  return -1;
654 }
655 
656 /*
657  * Finish parsing an option group.
658  *
659  * @param group_idx which group definition should this group belong to
660  * @param arg argument of the group delimiting option
661  */
662 static void finish_group(OptionParseContext *octx, int group_idx,
663  const char *arg)
664 {
665  OptionGroupList *l = &octx->groups[group_idx];
666  OptionGroup *g;
667 
668  GROW_ARRAY(l->groups, l->nb_groups);
669  g = &l->groups[l->nb_groups - 1];
670 
671  *g = octx->cur_group;
672  g->arg = arg;
673  g->group_def = l->group_def;
674  g->sws_dict = sws_dict;
675  g->swr_opts = swr_opts;
676  g->codec_opts = codec_opts;
677  g->format_opts = format_opts;
678  g->resample_opts = resample_opts;
679 
680  codec_opts = NULL;
681  format_opts = NULL;
683  sws_dict = NULL;
684  swr_opts = NULL;
685  init_opts();
686 
687  memset(&octx->cur_group, 0, sizeof(octx->cur_group));
688 }
689 
690 /*
691  * Add an option instance to currently parsed group.
692  */
693 static void add_opt(OptionParseContext *octx, const OptionDef *opt,
694  const char *key, const char *val)
695 {
696  int global = !(opt->flags & (OPT_PERFILE | OPT_SPEC | OPT_OFFSET));
697  OptionGroup *g = global ? &octx->global_opts : &octx->cur_group;
698 
699  GROW_ARRAY(g->opts, g->nb_opts);
700  g->opts[g->nb_opts - 1].opt = opt;
701  g->opts[g->nb_opts - 1].key = key;
702  g->opts[g->nb_opts - 1].val = val;
703 }
704 
706  const OptionGroupDef *groups, int nb_groups)
707 {
708  static const OptionGroupDef global_group = { "global" };
709  int i;
710 
711  memset(octx, 0, sizeof(*octx));
712 
713  octx->nb_groups = nb_groups;
714  octx->groups = av_mallocz_array(octx->nb_groups, sizeof(*octx->groups));
715  if (!octx->groups)
716  exit_program(1);
717 
718  for (i = 0; i < octx->nb_groups; i++)
719  octx->groups[i].group_def = &groups[i];
720 
721  octx->global_opts.group_def = &global_group;
722  octx->global_opts.arg = "";
723 
724  init_opts();
725 }
726 
728 {
729  int i, j;
730 
731  for (i = 0; i < octx->nb_groups; i++) {
732  OptionGroupList *l = &octx->groups[i];
733 
734  for (j = 0; j < l->nb_groups; j++) {
735  av_freep(&l->groups[j].opts);
739 
740  av_dict_free(&l->groups[j].sws_dict);
741  av_dict_free(&l->groups[j].swr_opts);
742  }
743  av_freep(&l->groups);
744  }
745  av_freep(&octx->groups);
746 
747  av_freep(&octx->cur_group.opts);
748  av_freep(&octx->global_opts.opts);
749 
750  uninit_opts();
751 }
752 
753 int split_commandline(OptionParseContext *octx, int argc, char *argv[],
754  const OptionDef *options,
755  const OptionGroupDef *groups, int nb_groups)
756 {
757  int optindex = 1;
758  int dashdash = -2;
759 
760  /* perform system-dependent conversions for arguments list */
761  prepare_app_arguments(&argc, &argv);
762 
763  init_parse_context(octx, groups, nb_groups);
764  av_log(NULL, AV_LOG_DEBUG, "Splitting the commandline.\n");
765 
766  while (optindex < argc) {
767  const char *opt = argv[optindex++], *arg;
768  const OptionDef *po;
769  int ret;
770 
771  av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
772 
773  if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
774  dashdash = optindex;
775  continue;
776  }
777  /* unnamed group separators, e.g. output filename */
778  if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
779  finish_group(octx, 0, opt);
780  av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
781  continue;
782  }
783  opt++;
784 
785 #define GET_ARG(arg) \
786 do { \
787  arg = argv[optindex++]; \
788  if (!arg) { \
789  av_log(NULL, AV_LOG_ERROR, "Missing argument for option '%s'.\n", opt);\
790  return AVERROR(EINVAL); \
791  } \
792 } while (0)
793 
794  /* named group separators, e.g. -i */
795  if ((ret = match_group_separator(groups, nb_groups, opt)) >= 0) {
796  GET_ARG(arg);
797  finish_group(octx, ret, arg);
798  av_log(NULL, AV_LOG_DEBUG, " matched as %s with argument '%s'.\n",
799  groups[ret].name, arg);
800  continue;
801  }
802 
803  /* normal options */
804  po = find_option(options, opt);
805  if (po->name) {
806  if (po->flags & OPT_EXIT) {
807  /* optional argument, e.g. -h */
808  arg = argv[optindex++];
809  } else if (po->flags & HAS_ARG) {
810  GET_ARG(arg);
811  } else {
812  arg = "1";
813  }
814 
815  add_opt(octx, po, opt, arg);
816  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
817  "argument '%s'.\n", po->name, po->help, arg);
818  continue;
819  }
820 
821  /* AVOptions */
822  if (argv[optindex]) {
823  ret = opt_default(NULL, opt, argv[optindex]);
824  if (ret >= 0) {
825  av_log(NULL, AV_LOG_DEBUG, " matched as AVOption '%s' with "
826  "argument '%s'.\n", opt, argv[optindex]);
827  optindex++;
828  continue;
829  } else if (ret != AVERROR_OPTION_NOT_FOUND) {
830  av_log(NULL, AV_LOG_ERROR, "Error parsing option '%s' "
831  "with argument '%s'.\n", opt, argv[optindex]);
832  return ret;
833  }
834  }
835 
836  /* boolean -nofoo options */
837  if (opt[0] == 'n' && opt[1] == 'o' &&
838  (po = find_option(options, opt + 2)) &&
839  po->name && po->flags & OPT_BOOL) {
840  add_opt(octx, po, opt, "0");
841  av_log(NULL, AV_LOG_DEBUG, " matched as option '%s' (%s) with "
842  "argument 0.\n", po->name, po->help);
843  continue;
844  }
845 
846  av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'.\n", opt);
848  }
849 
851  av_log(NULL, AV_LOG_WARNING, "Trailing options were found on the "
852  "commandline.\n");
853 
854  av_log(NULL, AV_LOG_DEBUG, "Finished splitting the commandline.\n");
855 
856  return 0;
857 }
858 
859 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
860 {
861  int ret;
862  unsigned flags = av_get_cpu_flags();
863 
864  if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
865  return ret;
866 
868  return 0;
869 }
870 
871 int opt_loglevel(void *optctx, const char *opt, const char *arg)
872 {
873  const struct { const char *name; int level; } log_levels[] = {
874  { "quiet" , AV_LOG_QUIET },
875  { "panic" , AV_LOG_PANIC },
876  { "fatal" , AV_LOG_FATAL },
877  { "error" , AV_LOG_ERROR },
878  { "warning", AV_LOG_WARNING },
879  { "info" , AV_LOG_INFO },
880  { "verbose", AV_LOG_VERBOSE },
881  { "debug" , AV_LOG_DEBUG },
882  { "trace" , AV_LOG_TRACE },
883  };
884  const char *token;
885  char *tail;
886  int flags = av_log_get_flags();
887  int level = av_log_get_level();
888  int cmd, i = 0;
889 
890  av_assert0(arg);
891  while (*arg) {
892  token = arg;
893  if (*token == '+' || *token == '-') {
894  cmd = *token++;
895  } else {
896  cmd = 0;
897  }
898  if (!i && !cmd) {
899  flags = 0; /* missing relative prefix, build absolute value */
900  }
901  if (!strncmp(token, "repeat", 6)) {
902  if (cmd == '-') {
904  } else {
906  }
907  arg = token + 6;
908  } else if (!strncmp(token, "level", 5)) {
909  if (cmd == '-') {
911  } else {
913  }
914  arg = token + 5;
915  } else {
916  break;
917  }
918  i++;
919  }
920  if (!*arg) {
921  goto end;
922  } else if (*arg == '+') {
923  arg++;
924  } else if (!i) {
925  flags = av_log_get_flags(); /* level value without prefix, reset flags */
926  }
927 
928  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
929  if (!strcmp(log_levels[i].name, arg)) {
930  level = log_levels[i].level;
931  goto end;
932  }
933  }
934 
935  level = strtol(arg, &tail, 10);
936  if (*tail) {
937  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
938  "Possible levels are numbers or:\n", arg);
939  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
940  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
941  exit_program(1);
942  }
943 
944 end:
947  return 0;
948 }
949 
950 static void expand_filename_template(AVBPrint *bp, const char *template,
951  struct tm *tm)
952 {
953  int c;
954 
955  while ((c = *(template++))) {
956  if (c == '%') {
957  if (!(c = *(template++)))
958  break;
959  switch (c) {
960  case 'p':
961  av_bprintf(bp, "%s", program_name);
962  break;
963  case 't':
964  av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
965  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
966  tm->tm_hour, tm->tm_min, tm->tm_sec);
967  break;
968  case '%':
969  av_bprint_chars(bp, c, 1);
970  break;
971  }
972  } else {
973  av_bprint_chars(bp, c, 1);
974  }
975  }
976 }
977 
978 static int init_report(const char *env)
979 {
980  char *filename_template = NULL;
981  char *key, *val;
982  int ret, count = 0;
983  time_t now;
984  struct tm *tm;
985  AVBPrint filename;
986 
987  if (report_file) /* already opened */
988  return 0;
989  time(&now);
990  tm = localtime(&now);
991 
992  while (env && *env) {
993  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
994  if (count)
996  "Failed to parse FFREPORT environment variable: %s\n",
997  av_err2str(ret));
998  break;
999  }
1000  if (*env)
1001  env++;
1002  count++;
1003  if (!strcmp(key, "file")) {
1004  av_free(filename_template);
1005  filename_template = val;
1006  val = NULL;
1007  } else if (!strcmp(key, "level")) {
1008  char *tail;
1009  report_file_level = strtol(val, &tail, 10);
1010  if (*tail) {
1011  av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1012  exit_program(1);
1013  }
1014  } else {
1015  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1016  }
1017  av_free(val);
1018  av_free(key);
1019  }
1020 
1022  expand_filename_template(&filename,
1023  av_x_if_null(filename_template, "%p-%t.log"), tm);
1024  av_free(filename_template);
1025  if (!av_bprint_is_complete(&filename)) {
1026  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1027  return AVERROR(ENOMEM);
1028  }
1029 
1030  report_file = fopen(filename.str, "w");
1031  if (!report_file) {
1032  int ret = AVERROR(errno);
1033  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1034  filename.str, strerror(errno));
1035  return ret;
1036  }
1039  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1040  "Report written to \"%s\"\n",
1041  program_name,
1042  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1043  tm->tm_hour, tm->tm_min, tm->tm_sec,
1044  filename.str);
1045  av_bprint_finalize(&filename, NULL);
1046  return 0;
1047 }
1048 
1049 int opt_report(const char *opt)
1050 {
1051  return init_report(NULL);
1052 }
1053 
1054 int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1055 {
1056  char *tail;
1057  size_t max;
1058 
1059  max = strtol(arg, &tail, 10);
1060  if (*tail) {
1061  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1062  exit_program(1);
1063  }
1064  av_max_alloc(max);
1065  return 0;
1066 }
1067 
1068 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1069 {
1070 #if HAVE_SETRLIMIT
1071  int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
1072  struct rlimit rl = { lim, lim + 1 };
1073  if (setrlimit(RLIMIT_CPU, &rl))
1074  perror("setrlimit");
1075 #else
1076  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1077 #endif
1078  return 0;
1079 }
1080 
1081 void print_error(const char *filename, int err)
1082 {
1083  char errbuf[128];
1084  const char *errbuf_ptr = errbuf;
1085 
1086  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
1087  errbuf_ptr = strerror(AVUNERROR(err));
1088  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", filename, errbuf_ptr);
1089 }
1090 
1091 static int warned_cfg = 0;
1092 
1093 #define INDENT 1
1094 #define SHOW_VERSION 2
1095 #define SHOW_CONFIG 4
1096 #define SHOW_COPYRIGHT 8
1097 
1098 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
1099  if (CONFIG_##LIBNAME) { \
1100  const char *indent = flags & INDENT? " " : ""; \
1101  if (flags & SHOW_VERSION) { \
1102  unsigned int version = libname##_version(); \
1103  av_log(NULL, level, \
1104  "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
1105  indent, #libname, \
1106  LIB##LIBNAME##_VERSION_MAJOR, \
1107  LIB##LIBNAME##_VERSION_MINOR, \
1108  LIB##LIBNAME##_VERSION_MICRO, \
1109  AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
1110  AV_VERSION_MICRO(version)); \
1111  } \
1112  if (flags & SHOW_CONFIG) { \
1113  const char *cfg = libname##_configuration(); \
1114  if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
1115  if (!warned_cfg) { \
1116  av_log(NULL, level, \
1117  "%sWARNING: library configuration mismatch\n", \
1118  indent); \
1119  warned_cfg = 1; \
1120  } \
1121  av_log(NULL, level, "%s%-11s configuration: %s\n", \
1122  indent, #libname, cfg); \
1123  } \
1124  } \
1125  } \
1126 
1127 static void print_all_libs_info(int flags, int level)
1128 {
1129  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
1130  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
1131  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
1132  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
1133  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
1134  PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
1135  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
1136  PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
1137  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
1138 }
1139 
1140 static void print_program_info(int flags, int level)
1141 {
1142  const char *indent = flags & INDENT? " " : "";
1143 
1144  av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
1145  if (flags & SHOW_COPYRIGHT)
1146  av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
1147  program_birth_year, CONFIG_THIS_YEAR);
1148  av_log(NULL, level, "\n");
1149  av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
1150 
1151  av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
1152 }
1153 
1154 static void print_buildconf(int flags, int level)
1155 {
1156  const char *indent = flags & INDENT ? " " : "";
1157  char str[] = { FFMPEG_CONFIGURATION };
1158  char *conflist, *remove_tilde, *splitconf;
1159 
1160  // Change all the ' --' strings to '~--' so that
1161  // they can be identified as tokens.
1162  while ((conflist = strstr(str, " --")) != NULL) {
1163  strncpy(conflist, "~--", 3);
1164  }
1165 
1166  // Compensate for the weirdness this would cause
1167  // when passing 'pkg-config --static'.
1168  while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
1169  strncpy(remove_tilde, "pkg-config ", 11);
1170  }
1171 
1172  splitconf = strtok(str, "~");
1173  av_log(NULL, level, "\n%sconfiguration:\n", indent);
1174  while (splitconf != NULL) {
1175  av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
1176  splitconf = strtok(NULL, "~");
1177  }
1178 }
1179 
1180 void show_banner(int argc, char **argv, const OptionDef *options)
1181 {
1182  int idx = locate_option(argc, argv, options, "version");
1183  if (hide_banner || idx)
1184  return;
1185 
1189 }
1190 
1191 int show_version(void *optctx, const char *opt, const char *arg)
1192 {
1196 
1197  return 0;
1198 }
1199 
1200 int show_buildconf(void *optctx, const char *opt, const char *arg)
1201 {
1204 
1205  return 0;
1206 }
1207 
1208 int show_license(void *optctx, const char *opt, const char *arg)
1209 {
1210 #if CONFIG_NONFREE
1211  printf(
1212  "This version of %s has nonfree parts compiled in.\n"
1213  "Therefore it is not legally redistributable.\n",
1214  program_name );
1215 #elif CONFIG_GPLV3
1216  printf(
1217  "%s is free software; you can redistribute it and/or modify\n"
1218  "it under the terms of the GNU General Public License as published by\n"
1219  "the Free Software Foundation; either version 3 of the License, or\n"
1220  "(at your option) any later version.\n"
1221  "\n"
1222  "%s is distributed in the hope that it will be useful,\n"
1223  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1224  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1225  "GNU General Public License for more details.\n"
1226  "\n"
1227  "You should have received a copy of the GNU General Public License\n"
1228  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1230 #elif CONFIG_GPL
1231  printf(
1232  "%s is free software; you can redistribute it and/or modify\n"
1233  "it under the terms of the GNU General Public License as published by\n"
1234  "the Free Software Foundation; either version 2 of the License, or\n"
1235  "(at your option) any later version.\n"
1236  "\n"
1237  "%s is distributed in the hope that it will be useful,\n"
1238  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1239  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1240  "GNU General Public License for more details.\n"
1241  "\n"
1242  "You should have received a copy of the GNU General Public License\n"
1243  "along with %s; if not, write to the Free Software\n"
1244  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1246 #elif CONFIG_LGPLV3
1247  printf(
1248  "%s is free software; you can redistribute it and/or modify\n"
1249  "it under the terms of the GNU Lesser General Public License as published by\n"
1250  "the Free Software Foundation; either version 3 of the License, or\n"
1251  "(at your option) any later version.\n"
1252  "\n"
1253  "%s is distributed in the hope that it will be useful,\n"
1254  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1255  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1256  "GNU Lesser General Public License for more details.\n"
1257  "\n"
1258  "You should have received a copy of the GNU Lesser General Public License\n"
1259  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
1261 #else
1262  printf(
1263  "%s is free software; you can redistribute it and/or\n"
1264  "modify it under the terms of the GNU Lesser General Public\n"
1265  "License as published by the Free Software Foundation; either\n"
1266  "version 2.1 of the License, or (at your option) any later version.\n"
1267  "\n"
1268  "%s is distributed in the hope that it will be useful,\n"
1269  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1270  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
1271  "Lesser General Public License for more details.\n"
1272  "\n"
1273  "You should have received a copy of the GNU Lesser General Public\n"
1274  "License along with %s; if not, write to the Free Software\n"
1275  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
1277 #endif
1278 
1279  return 0;
1280 }
1281 
1282 static int is_device(const AVClass *avclass)
1283 {
1284  if (!avclass)
1285  return 0;
1286  return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
1287 }
1288 
1289 static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
1290 {
1291  void *ifmt_opaque = NULL;
1292  const AVInputFormat *ifmt = NULL;
1293  void *ofmt_opaque = NULL;
1294  const AVOutputFormat *ofmt = NULL;
1295  const char *last_name;
1296  int is_dev;
1297 
1298  printf("%s\n"
1299  " D. = Demuxing supported\n"
1300  " .E = Muxing supported\n"
1301  " --\n", device_only ? "Devices:" : "File formats:");
1302  last_name = "000";
1303  for (;;) {
1304  int decode = 0;
1305  int encode = 0;
1306  const char *name = NULL;
1307  const char *long_name = NULL;
1308 
1309  if (muxdemuxers !=SHOW_DEMUXERS) {
1310  ofmt_opaque = NULL;
1311  while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
1312  is_dev = is_device(ofmt->priv_class);
1313  if (!is_dev && device_only)
1314  continue;
1315  if ((!name || strcmp(ofmt->name, name) < 0) &&
1316  strcmp(ofmt->name, last_name) > 0) {
1317  name = ofmt->name;
1318  long_name = ofmt->long_name;
1319  encode = 1;
1320  }
1321  }
1322  }
1323  if (muxdemuxers != SHOW_MUXERS) {
1324  ifmt_opaque = NULL;
1325  while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
1326  is_dev = is_device(ifmt->priv_class);
1327  if (!is_dev && device_only)
1328  continue;
1329  if ((!name || strcmp(ifmt->name, name) < 0) &&
1330  strcmp(ifmt->name, last_name) > 0) {
1331  name = ifmt->name;
1332  long_name = ifmt->long_name;
1333  encode = 0;
1334  }
1335  if (name && strcmp(ifmt->name, name) == 0)
1336  decode = 1;
1337  }
1338  }
1339  if (!name)
1340  break;
1341  last_name = name;
1342 
1343  printf(" %s%s %-15s %s\n",
1344  decode ? "D" : " ",
1345  encode ? "E" : " ",
1346  name,
1347  long_name ? long_name:" ");
1348  }
1349  return 0;
1350 }
1351 
1352 int show_formats(void *optctx, const char *opt, const char *arg)
1353 {
1354  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
1355 }
1356 
1357 int show_muxers(void *optctx, const char *opt, const char *arg)
1358 {
1359  return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
1360 }
1361 
1362 int show_demuxers(void *optctx, const char *opt, const char *arg)
1363 {
1364  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
1365 }
1366 
1367 int show_devices(void *optctx, const char *opt, const char *arg)
1368 {
1369  return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
1370 }
1371 
1372 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
1373  if (codec->field) { \
1374  const type *p = codec->field; \
1375  \
1376  printf(" Supported " list_name ":"); \
1377  while (*p != term) { \
1378  get_name(*p); \
1379  printf(" %s", name); \
1380  p++; \
1381  } \
1382  printf("\n"); \
1383  } \
1384 
1385 static void print_codec(const AVCodec *c)
1386 {
1387  int encoder = av_codec_is_encoder(c);
1388 
1389  printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
1390  c->long_name ? c->long_name : "");
1391 
1392  printf(" General capabilities: ");
1393  if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
1394  printf("horizband ");
1395  if (c->capabilities & AV_CODEC_CAP_DR1)
1396  printf("dr1 ");
1397  if (c->capabilities & AV_CODEC_CAP_TRUNCATED)
1398  printf("trunc ");
1399  if (c->capabilities & AV_CODEC_CAP_DELAY)
1400  printf("delay ");
1401  if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
1402  printf("small ");
1403  if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
1404  printf("subframes ");
1405  if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
1406  printf("exp ");
1407  if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
1408  printf("chconf ");
1409  if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
1410  printf("paramchange ");
1411  if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
1412  printf("variable ");
1413  if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
1416  printf("threads ");
1417  if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
1418  printf("avoidprobe ");
1419  if (c->capabilities & AV_CODEC_CAP_INTRA_ONLY)
1420  printf("intraonly ");
1421  if (c->capabilities & AV_CODEC_CAP_LOSSLESS)
1422  printf("lossless ");
1423  if (c->capabilities & AV_CODEC_CAP_HARDWARE)
1424  printf("hardware ");
1425  if (c->capabilities & AV_CODEC_CAP_HYBRID)
1426  printf("hybrid ");
1427  if (!c->capabilities)
1428  printf("none");
1429  printf("\n");
1430 
1431  if (c->type == AVMEDIA_TYPE_VIDEO ||
1432  c->type == AVMEDIA_TYPE_AUDIO) {
1433  printf(" Threading capabilities: ");
1434  switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
1438  AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
1439  case AV_CODEC_CAP_FRAME_THREADS: printf("frame"); break;
1440  case AV_CODEC_CAP_SLICE_THREADS: printf("slice"); break;
1441  case AV_CODEC_CAP_AUTO_THREADS : printf("auto"); break;
1442  default: printf("none"); break;
1443  }
1444  printf("\n");
1445  }
1446 
1447  if (avcodec_get_hw_config(c, 0)) {
1448  printf(" Supported hardware devices: ");
1449  for (int i = 0;; i++) {
1450  const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
1451  if (!config)
1452  break;
1453  printf("%s ", av_hwdevice_get_type_name(config->device_type));
1454  }
1455  printf("\n");
1456  }
1457 
1458  if (c->supported_framerates) {
1459  const AVRational *fps = c->supported_framerates;
1460 
1461  printf(" Supported framerates:");
1462  while (fps->num) {
1463  printf(" %d/%d", fps->num, fps->den);
1464  fps++;
1465  }
1466  printf("\n");
1467  }
1468  PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
1470  PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
1472  PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
1474  PRINT_CODEC_SUPPORTED(c, channel_layouts, uint64_t, "channel layouts",
1475  0, GET_CH_LAYOUT_DESC);
1476 
1477  if (c->priv_class) {
1478  show_help_children(c->priv_class,
1481  }
1482 }
1483 
1485 {
1486  switch (type) {
1487  case AVMEDIA_TYPE_VIDEO: return 'V';
1488  case AVMEDIA_TYPE_AUDIO: return 'A';
1489  case AVMEDIA_TYPE_DATA: return 'D';
1490  case AVMEDIA_TYPE_SUBTITLE: return 'S';
1491  case AVMEDIA_TYPE_ATTACHMENT:return 'T';
1492  default: return '?';
1493  }
1494 }
1495 
1496 static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
1497  int encoder)
1498 {
1499  while ((prev = av_codec_next(prev))) {
1500  if (prev->id == id &&
1501  (encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
1502  return prev;
1503  }
1504  return NULL;
1505 }
1506 
1507 static int compare_codec_desc(const void *a, const void *b)
1508 {
1509  const AVCodecDescriptor * const *da = a;
1510  const AVCodecDescriptor * const *db = b;
1511 
1512  return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
1513  strcmp((*da)->name, (*db)->name);
1514 }
1515 
1516 static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
1517 {
1518  const AVCodecDescriptor *desc = NULL;
1519  const AVCodecDescriptor **codecs;
1520  unsigned nb_codecs = 0, i = 0;
1521 
1522  while ((desc = avcodec_descriptor_next(desc)))
1523  nb_codecs++;
1524  if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
1525  av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
1526  exit_program(1);
1527  }
1528  desc = NULL;
1529  while ((desc = avcodec_descriptor_next(desc)))
1530  codecs[i++] = desc;
1531  av_assert0(i == nb_codecs);
1532  qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
1533  *rcodecs = codecs;
1534  return nb_codecs;
1535 }
1536 
1537 static void print_codecs_for_id(enum AVCodecID id, int encoder)
1538 {
1539  const AVCodec *codec = NULL;
1540 
1541  printf(" (%s: ", encoder ? "encoders" : "decoders");
1542 
1543  while ((codec = next_codec_for_id(id, codec, encoder)))
1544  printf("%s ", codec->name);
1545 
1546  printf(")");
1547 }
1548 
1549 int show_codecs(void *optctx, const char *opt, const char *arg)
1550 {
1551  const AVCodecDescriptor **codecs;
1552  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1553 
1554  printf("Codecs:\n"
1555  " D..... = Decoding supported\n"
1556  " .E.... = Encoding supported\n"
1557  " ..V... = Video codec\n"
1558  " ..A... = Audio codec\n"
1559  " ..S... = Subtitle codec\n"
1560  " ...I.. = Intra frame-only codec\n"
1561  " ....L. = Lossy compression\n"
1562  " .....S = Lossless compression\n"
1563  " -------\n");
1564  for (i = 0; i < nb_codecs; i++) {
1565  const AVCodecDescriptor *desc = codecs[i];
1566  const AVCodec *codec = NULL;
1567 
1568  if (strstr(desc->name, "_deprecated"))
1569  continue;
1570 
1571  printf(" ");
1572  printf(avcodec_find_decoder(desc->id) ? "D" : ".");
1573  printf(avcodec_find_encoder(desc->id) ? "E" : ".");
1574 
1575  printf("%c", get_media_type_char(desc->type));
1576  printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
1577  printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
1578  printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
1579 
1580  printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
1581 
1582  /* print decoders/encoders when there's more than one or their
1583  * names are different from codec name */
1584  while ((codec = next_codec_for_id(desc->id, codec, 0))) {
1585  if (strcmp(codec->name, desc->name)) {
1586  print_codecs_for_id(desc->id, 0);
1587  break;
1588  }
1589  }
1590  codec = NULL;
1591  while ((codec = next_codec_for_id(desc->id, codec, 1))) {
1592  if (strcmp(codec->name, desc->name)) {
1593  print_codecs_for_id(desc->id, 1);
1594  break;
1595  }
1596  }
1597 
1598  printf("\n");
1599  }
1600  av_free(codecs);
1601  return 0;
1602 }
1603 
1604 static void print_codecs(int encoder)
1605 {
1606  const AVCodecDescriptor **codecs;
1607  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
1608 
1609  printf("%s:\n"
1610  " V..... = Video\n"
1611  " A..... = Audio\n"
1612  " S..... = Subtitle\n"
1613  " .F.... = Frame-level multithreading\n"
1614  " ..S... = Slice-level multithreading\n"
1615  " ...X.. = Codec is experimental\n"
1616  " ....B. = Supports draw_horiz_band\n"
1617  " .....D = Supports direct rendering method 1\n"
1618  " ------\n",
1619  encoder ? "Encoders" : "Decoders");
1620  for (i = 0; i < nb_codecs; i++) {
1621  const AVCodecDescriptor *desc = codecs[i];
1622  const AVCodec *codec = NULL;
1623 
1624  while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1625  printf(" %c", get_media_type_char(desc->type));
1626  printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
1627  printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
1628  printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ? "X" : ".");
1629  printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
1630  printf((codec->capabilities & AV_CODEC_CAP_DR1) ? "D" : ".");
1631 
1632  printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
1633  if (strcmp(codec->name, desc->name))
1634  printf(" (codec %s)", desc->name);
1635 
1636  printf("\n");
1637  }
1638  }
1639  av_free(codecs);
1640 }
1641 
1642 int show_decoders(void *optctx, const char *opt, const char *arg)
1643 {
1644  print_codecs(0);
1645  return 0;
1646 }
1647 
1648 int show_encoders(void *optctx, const char *opt, const char *arg)
1649 {
1650  print_codecs(1);
1651  return 0;
1652 }
1653 
1654 int show_bsfs(void *optctx, const char *opt, const char *arg)
1655 {
1656  const AVBitStreamFilter *bsf = NULL;
1657  void *opaque = NULL;
1658 
1659  printf("Bitstream filters:\n");
1660  while ((bsf = av_bsf_iterate(&opaque)))
1661  printf("%s\n", bsf->name);
1662  printf("\n");
1663  return 0;
1664 }
1665 
1666 int show_protocols(void *optctx, const char *opt, const char *arg)
1667 {
1668  void *opaque = NULL;
1669  const char *name;
1670 
1671  printf("Supported file protocols:\n"
1672  "Input:\n");
1673  while ((name = avio_enum_protocols(&opaque, 0)))
1674  printf(" %s\n", name);
1675  printf("Output:\n");
1676  while ((name = avio_enum_protocols(&opaque, 1)))
1677  printf(" %s\n", name);
1678  return 0;
1679 }
1680 
1681 int show_filters(void *optctx, const char *opt, const char *arg)
1682 {
1683 #if CONFIG_AVFILTER
1684  const AVFilter *filter = NULL;
1685  char descr[64], *descr_cur;
1686  void *opaque = NULL;
1687  int i, j;
1688  const AVFilterPad *pad;
1689 
1690  printf("Filters:\n"
1691  " T.. = Timeline support\n"
1692  " .S. = Slice threading\n"
1693  " ..C = Command support\n"
1694  " A = Audio input/output\n"
1695  " V = Video input/output\n"
1696  " N = Dynamic number and/or type of input/output\n"
1697  " | = Source or sink filter\n");
1698  while ((filter = av_filter_iterate(&opaque))) {
1699  descr_cur = descr;
1700  for (i = 0; i < 2; i++) {
1701  if (i) {
1702  *(descr_cur++) = '-';
1703  *(descr_cur++) = '>';
1704  }
1705  pad = i ? filter->outputs : filter->inputs;
1706  for (j = 0; pad && avfilter_pad_get_name(pad, j); j++) {
1707  if (descr_cur >= descr + sizeof(descr) - 4)
1708  break;
1709  *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
1710  }
1711  if (!j)
1712  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
1713  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
1714  }
1715  *descr_cur = 0;
1716  printf(" %c%c%c %-17s %-10s %s\n",
1717  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
1718  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
1719  filter->process_command ? 'C' : '.',
1720  filter->name, descr, filter->description);
1721  }
1722 #else
1723  printf("No filters available: libavfilter disabled\n");
1724 #endif
1725  return 0;
1726 }
1727 
1728 int show_colors(void *optctx, const char *opt, const char *arg)
1729 {
1730  const char *name;
1731  const uint8_t *rgb;
1732  int i;
1733 
1734  printf("%-32s #RRGGBB\n", "name");
1735 
1736  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
1737  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
1738 
1739  return 0;
1740 }
1741 
1742 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
1743 {
1744  const AVPixFmtDescriptor *pix_desc = NULL;
1745 
1746  printf("Pixel formats:\n"
1747  "I.... = Supported Input format for conversion\n"
1748  ".O... = Supported Output format for conversion\n"
1749  "..H.. = Hardware accelerated format\n"
1750  "...P. = Paletted format\n"
1751  "....B = Bitstream format\n"
1752  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL\n"
1753  "-----\n");
1754 
1755 #if !CONFIG_SWSCALE
1756 # define sws_isSupportedInput(x) 0
1757 # define sws_isSupportedOutput(x) 0
1758 #endif
1759 
1760  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
1762  printf("%c%c%c%c%c %-16s %d %2d\n",
1763  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
1764  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
1765  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
1766  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
1767  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
1768  pix_desc->name,
1769  pix_desc->nb_components,
1770  av_get_bits_per_pixel(pix_desc));
1771  }
1772  return 0;
1773 }
1774 
1775 int show_layouts(void *optctx, const char *opt, const char *arg)
1776 {
1777  int i = 0;
1778  uint64_t layout, j;
1779  const char *name, *descr;
1780 
1781  printf("Individual channels:\n"
1782  "NAME DESCRIPTION\n");
1783  for (i = 0; i < 63; i++) {
1784  name = av_get_channel_name((uint64_t)1 << i);
1785  if (!name)
1786  continue;
1787  descr = av_get_channel_description((uint64_t)1 << i);
1788  printf("%-14s %s\n", name, descr);
1789  }
1790  printf("\nStandard channel layouts:\n"
1791  "NAME DECOMPOSITION\n");
1792  for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
1793  if (name) {
1794  printf("%-14s ", name);
1795  for (j = 1; j; j <<= 1)
1796  if ((layout & j))
1797  printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
1798  printf("\n");
1799  }
1800  }
1801  return 0;
1802 }
1803 
1804 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1805 {
1806  int i;
1807  char fmt_str[128];
1808  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1809  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1810  return 0;
1811 }
1812 
1813 static void show_help_codec(const char *name, int encoder)
1814 {
1815  const AVCodecDescriptor *desc;
1816  const AVCodec *codec;
1817 
1818  if (!name) {
1819  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
1820  return;
1821  }
1822 
1823  codec = encoder ? avcodec_find_encoder_by_name(name) :
1825 
1826  if (codec)
1827  print_codec(codec);
1828  else if ((desc = avcodec_descriptor_get_by_name(name))) {
1829  int printed = 0;
1830 
1831  while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
1832  printed = 1;
1833  print_codec(codec);
1834  }
1835 
1836  if (!printed) {
1837  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
1838  "but no %s for it are available. FFmpeg might need to be "
1839  "recompiled with additional external libraries.\n",
1840  name, encoder ? "encoders" : "decoders");
1841  }
1842  } else {
1843  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
1844  name);
1845  }
1846 }
1847 
1848 static void show_help_demuxer(const char *name)
1849 {
1851 
1852  if (!fmt) {
1853  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1854  return;
1855  }
1856 
1857  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
1858 
1859  if (fmt->extensions)
1860  printf(" Common extensions: %s.\n", fmt->extensions);
1861 
1862  if (fmt->priv_class)
1864 }
1865 
1866 static void show_help_muxer(const char *name)
1867 {
1868  const AVCodecDescriptor *desc;
1870 
1871  if (!fmt) {
1872  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
1873  return;
1874  }
1875 
1876  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
1877 
1878  if (fmt->extensions)
1879  printf(" Common extensions: %s.\n", fmt->extensions);
1880  if (fmt->mime_type)
1881  printf(" Mime type: %s.\n", fmt->mime_type);
1882  if (fmt->video_codec != AV_CODEC_ID_NONE &&
1883  (desc = avcodec_descriptor_get(fmt->video_codec))) {
1884  printf(" Default video codec: %s.\n", desc->name);
1885  }
1886  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
1887  (desc = avcodec_descriptor_get(fmt->audio_codec))) {
1888  printf(" Default audio codec: %s.\n", desc->name);
1889  }
1890  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
1891  (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
1892  printf(" Default subtitle codec: %s.\n", desc->name);
1893  }
1894 
1895  if (fmt->priv_class)
1897 }
1898 
1899 #if CONFIG_AVFILTER
1900 static void show_help_filter(const char *name)
1901 {
1902 #if CONFIG_AVFILTER
1903  const AVFilter *f = avfilter_get_by_name(name);
1904  int i, count;
1905 
1906  if (!name) {
1907  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
1908  return;
1909  } else if (!f) {
1910  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
1911  return;
1912  }
1913 
1914  printf("Filter %s\n", f->name);
1915  if (f->description)
1916  printf(" %s\n", f->description);
1917 
1918  if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
1919  printf(" slice threading supported\n");
1920 
1921  printf(" Inputs:\n");
1922  count = avfilter_pad_count(f->inputs);
1923  for (i = 0; i < count; i++) {
1924  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
1926  }
1927  if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
1928  printf(" dynamic (depending on the options)\n");
1929  else if (!count)
1930  printf(" none (source filter)\n");
1931 
1932  printf(" Outputs:\n");
1933  count = avfilter_pad_count(f->outputs);
1934  for (i = 0; i < count; i++) {
1935  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
1937  }
1938  if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
1939  printf(" dynamic (depending on the options)\n");
1940  else if (!count)
1941  printf(" none (sink filter)\n");
1942 
1943  if (f->priv_class)
1946  if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
1947  printf("This filter has support for timeline through the 'enable' option.\n");
1948 #else
1949  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
1950  "can not to satisfy request\n");
1951 #endif
1952 }
1953 #endif
1954 
1955 static void show_help_bsf(const char *name)
1956 {
1958 
1959  if (!name) {
1960  av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
1961  return;
1962  } else if (!bsf) {
1963  av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
1964  return;
1965  }
1966 
1967  printf("Bit stream filter %s\n", bsf->name);
1968  PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
1970  if (bsf->priv_class)
1972 }
1973 
1974 int show_help(void *optctx, const char *opt, const char *arg)
1975 {
1976  char *topic, *par;
1978 
1979  topic = av_strdup(arg ? arg : "");
1980  if (!topic)
1981  return AVERROR(ENOMEM);
1982  par = strchr(topic, '=');
1983  if (par)
1984  *par++ = 0;
1985 
1986  if (!*topic) {
1987  show_help_default(topic, par);
1988  } else if (!strcmp(topic, "decoder")) {
1989  show_help_codec(par, 0);
1990  } else if (!strcmp(topic, "encoder")) {
1991  show_help_codec(par, 1);
1992  } else if (!strcmp(topic, "demuxer")) {
1993  show_help_demuxer(par);
1994  } else if (!strcmp(topic, "muxer")) {
1995  show_help_muxer(par);
1996 #if CONFIG_AVFILTER
1997  } else if (!strcmp(topic, "filter")) {
1998  show_help_filter(par);
1999 #endif
2000  } else if (!strcmp(topic, "bsf")) {
2001  show_help_bsf(par);
2002  } else {
2003  show_help_default(topic, par);
2004  }
2005 
2006  av_freep(&topic);
2007  return 0;
2008 }
2009 
2010 int read_yesno(void)
2011 {
2012  int c = getchar();
2013  int yesno = (av_toupper(c) == 'Y');
2014 
2015  while (c != '\n' && c != EOF)
2016  c = getchar();
2017 
2018  return yesno;
2019 }
2020 
2021 FILE *get_preset_file(char *filename, size_t filename_size,
2022  const char *preset_name, int is_path,
2023  const char *codec_name)
2024 {
2025  FILE *f = NULL;
2026  int i;
2027  const char *base[3] = { getenv("FFMPEG_DATADIR"),
2028  getenv("HOME"),
2029  FFMPEG_DATADIR, };
2030 
2031  if (is_path) {
2032  av_strlcpy(filename, preset_name, filename_size);
2033  f = fopen(filename, "r");
2034  } else {
2035 #ifdef _WIN32
2036  char datadir[MAX_PATH], *ls;
2037  base[2] = NULL;
2038 
2039  if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
2040  {
2041  for (ls = datadir; ls < datadir + strlen(datadir); ls++)
2042  if (*ls == '\\') *ls = '/';
2043 
2044  if (ls = strrchr(datadir, '/'))
2045  {
2046  *ls = 0;
2047  strncat(datadir, "/ffpresets", sizeof(datadir) - 1 - strlen(datadir));
2048  base[2] = datadir;
2049  }
2050  }
2051 #endif
2052  for (i = 0; i < 3 && !f; i++) {
2053  if (!base[i])
2054  continue;
2055  snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
2056  i != 1 ? "" : "/.ffmpeg", preset_name);
2057  f = fopen(filename, "r");
2058  if (!f && codec_name) {
2059  snprintf(filename, filename_size,
2060  "%s%s/%s-%s.ffpreset",
2061  base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
2062  preset_name);
2063  f = fopen(filename, "r");
2064  }
2065  }
2066  }
2067 
2068  return f;
2069 }
2070 
2071 int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
2072 {
2073  int ret = avformat_match_stream_specifier(s, st, spec);
2074  if (ret < 0)
2075  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
2076  return ret;
2077 }
2078 
2080  AVFormatContext *s, AVStream *st, AVCodec *codec)
2081 {
2082  AVDictionary *ret = NULL;
2083  AVDictionaryEntry *t = NULL;
2084  int flags = s->oformat ? AV_OPT_FLAG_ENCODING_PARAM
2086  char prefix = 0;
2087  const AVClass *cc = avcodec_get_class();
2088 
2089  if (!codec)
2090  codec = s->oformat ? avcodec_find_encoder(codec_id)
2092 
2093  switch (st->codecpar->codec_type) {
2094  case AVMEDIA_TYPE_VIDEO:
2095  prefix = 'v';
2097  break;
2098  case AVMEDIA_TYPE_AUDIO:
2099  prefix = 'a';
2101  break;
2102  case AVMEDIA_TYPE_SUBTITLE:
2103  prefix = 's';
2105  break;
2106  }
2107 
2108  while (t = av_dict_get(opts, "", t, AV_DICT_IGNORE_SUFFIX)) {
2109  char *p = strchr(t->key, ':');
2110 
2111  /* check stream specification in opt name */
2112  if (p)
2113  switch (check_stream_specifier(s, st, p + 1)) {
2114  case 1: *p = 0; break;
2115  case 0: continue;
2116  default: exit_program(1);
2117  }
2118 
2119  if (av_opt_find(&cc, t->key, NULL, flags, AV_OPT_SEARCH_FAKE_OBJ) ||
2120  !codec ||
2121  (codec->priv_class &&
2122  av_opt_find(&codec->priv_class, t->key, NULL, flags,
2124  av_dict_set(&ret, t->key, t->value, 0);
2125  else if (t->key[0] == prefix &&
2126  av_opt_find(&cc, t->key + 1, NULL, flags,
2128  av_dict_set(&ret, t->key + 1, t->value, 0);
2129 
2130  if (p)
2131  *p = ':';
2132  }
2133  return ret;
2134 }
2135 
2138 {
2139  int i;
2140  AVDictionary **opts;
2141 
2142  if (!s->nb_streams)
2143  return NULL;
2144  opts = av_mallocz_array(s->nb_streams, sizeof(*opts));
2145  if (!opts) {
2147  "Could not alloc memory for stream options.\n");
2148  return NULL;
2149  }
2150  for (i = 0; i < s->nb_streams; i++)
2151  opts[i] = filter_codec_opts(codec_opts, s->streams[i]->codecpar->codec_id,
2152  s, s->streams[i], NULL);
2153  return opts;
2154 }
2155 
2156 void *grow_array(void *array, int elem_size, int *size, int new_size)
2157 {
2158  if (new_size >= INT_MAX / elem_size) {
2159  av_log(NULL, AV_LOG_ERROR, "Array too big.\n");
2160  exit_program(1);
2161  }
2162  if (*size < new_size) {
2163  uint8_t *tmp = av_realloc_array(array, new_size, elem_size);
2164  if (!tmp) {
2165  av_log(NULL, AV_LOG_ERROR, "Could not alloc buffer.\n");
2166  exit_program(1);
2167  }
2168  memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
2169  *size = new_size;
2170  return tmp;
2171  }
2172  return array;
2173 }
2174 
2176 {
2177  uint8_t* displaymatrix = av_stream_get_side_data(st,
2179  double theta = 0;
2180  if (displaymatrix)
2181  theta = -av_display_rotation_get((int32_t*) displaymatrix);
2182 
2183  theta -= 360*floor(theta/360 + 0.9/360);
2184 
2185  if (fabs(theta - 90*round(theta/90)) > 2)
2186  av_log(NULL, AV_LOG_WARNING, "Odd rotation angle.\n"
2187  "If you want to help, upload a sample "
2188  "of this file to ftp://upload.ffmpeg.org/incoming/ "
2189  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)");
2190 
2191  return theta;
2192 }
2193 
2194 #if CONFIG_AVDEVICE
2195 static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
2196 {
2197  int ret, i;
2198  AVDeviceInfoList *device_list = NULL;
2199 
2200  if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
2201  return AVERROR(EINVAL);
2202 
2203  printf("Auto-detected sources for %s:\n", fmt->name);
2204  if (!fmt->get_device_list) {
2205  ret = AVERROR(ENOSYS);
2206  printf("Cannot list sources. Not implemented.\n");
2207  goto fail;
2208  }
2209 
2210  if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
2211  printf("Cannot list sources.\n");
2212  goto fail;
2213  }
2214 
2215  for (i = 0; i < device_list->nb_devices; i++) {
2216  printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2217  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2218  }
2219 
2220  fail:
2221  avdevice_free_list_devices(&device_list);
2222  return ret;
2223 }
2224 
2225 static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
2226 {
2227  int ret, i;
2228  AVDeviceInfoList *device_list = NULL;
2229 
2230  if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
2231  return AVERROR(EINVAL);
2232 
2233  printf("Auto-detected sinks for %s:\n", fmt->name);
2234  if (!fmt->get_device_list) {
2235  ret = AVERROR(ENOSYS);
2236  printf("Cannot list sinks. Not implemented.\n");
2237  goto fail;
2238  }
2239 
2240  if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
2241  printf("Cannot list sinks.\n");
2242  goto fail;
2243  }
2244 
2245  for (i = 0; i < device_list->nb_devices; i++) {
2246  printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
2247  device_list->devices[i]->device_name, device_list->devices[i]->device_description);
2248  }
2249 
2250  fail:
2251  avdevice_free_list_devices(&device_list);
2252  return ret;
2253 }
2254 
2255 static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
2256 {
2257  int ret;
2258  if (arg) {
2259  char *opts_str = NULL;
2260  av_assert0(dev && opts);
2261  *dev = av_strdup(arg);
2262  if (!*dev)
2263  return AVERROR(ENOMEM);
2264  if ((opts_str = strchr(*dev, ','))) {
2265  *(opts_str++) = '\0';
2266  if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
2267  av_freep(dev);
2268  return ret;
2269  }
2270  }
2271  } else
2272  printf("\nDevice name is not provided.\n"
2273  "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
2274  return 0;
2275 }
2276 
2277 int show_sources(void *optctx, const char *opt, const char *arg)
2278 {
2279  AVInputFormat *fmt = NULL;
2280  char *dev = NULL;
2281  AVDictionary *opts = NULL;
2282  int ret = 0;
2283  int error_level = av_log_get_level();
2284 
2286 
2287  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2288  goto fail;
2289 
2290  do {
2292  if (fmt) {
2293  if (!strcmp(fmt->name, "lavfi"))
2294  continue; //it's pointless to probe lavfi
2295  if (dev && !av_match_name(dev, fmt->name))
2296  continue;
2297  print_device_sources(fmt, opts);
2298  }
2299  } while (fmt);
2300  do {
2302  if (fmt) {
2303  if (dev && !av_match_name(dev, fmt->name))
2304  continue;
2305  print_device_sources(fmt, opts);
2306  }
2307  } while (fmt);
2308  fail:
2309  av_dict_free(&opts);
2310  av_free(dev);
2311  av_log_set_level(error_level);
2312  return ret;
2313 }
2314 
2315 int show_sinks(void *optctx, const char *opt, const char *arg)
2316 {
2317  AVOutputFormat *fmt = NULL;
2318  char *dev = NULL;
2319  AVDictionary *opts = NULL;
2320  int ret = 0;
2321  int error_level = av_log_get_level();
2322 
2324 
2325  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
2326  goto fail;
2327 
2328  do {
2330  if (fmt) {
2331  if (dev && !av_match_name(dev, fmt->name))
2332  continue;
2333  print_device_sinks(fmt, opts);
2334  }
2335  } while (fmt);
2336  do {
2338  if (fmt) {
2339  if (dev && !av_match_name(dev, fmt->name))
2340  continue;
2341  print_device_sinks(fmt, opts);
2342  }
2343  } while (fmt);
2344  fail:
2345  av_dict_free(&opts);
2346  av_free(dev);
2347  av_log_set_level(error_level);
2348  return ret;
2349 }
2350 
2351 #endif
AV_CODEC_CAP_INTRA_ONLY
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1067
OPT_FLOAT
#define OPT_FLOAT
Definition: cmdutils.h:168
add_bytes
static void add_bytes(HYuvContext *s, uint8_t *dst, uint8_t *src, int w)
Definition: huffyuvdec.c:888
formats
formats
Definition: signature.h:48
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
GET_ARG
#define GET_ARG(arg)
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:171
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
AVCodec
AVCodec.
Definition: avcodec.h:3481
av_force_cpu_flags
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Definition: cpu.c:65
print_codecs_for_id
static void print_codecs_for_id(enum AVCodecID id, int encoder)
Definition: cmdutils.c:1537
L1
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L1
Definition: snow.txt:554
OptionGroup::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:309
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:3170
stride
int stride
Definition: mace.c:144
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
draw_horiz_band
static void draw_horiz_band(AVCodecContext *ctx, const AVFrame *fr, int offset[4], int slice_position, int type, int height)
Definition: api-band-test.c:36
sws_isSupportedOutput
#define sws_isSupportedOutput(x)
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
L2
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L2
Definition: snow.txt:554
level
uint8_t level
Definition: svq3.c:207
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
INFINITY
#define INFINITY
Definition: mathematics.h:67
cast
The reader does not expect b to be semantically here and if the code is changed by maybe adding a cast
Definition: undefined.txt:36
avdevice_list_input_sources
int avdevice_list_input_sources(AVInputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:228
draw_edges
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with as it s useful too and the implementation is trivial when you re doing this Note that draw_edges() needs to be called before reporting progress. Before accessing a reference frame or its MVs
sws_isSupportedInput
#define sws_isSupportedInput(x)
av_bsf_iterate
const AVBitStreamFilter * av_bsf_iterate(void **opaque)
Iterate over all registered bitstream filters.
Definition: bitstream_filters.c:63
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
mix
static int mix(int c0, int c1)
Definition: 4xm.c:714
child
AVS_FilterInfo AVS_Value child
Definition: avisynth_c.h:808
AVOutputFormat::name
const char * name
Definition: avformat.h:496
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
nb_input_files
int nb_input_files
Definition: ffmpeg.c:150
opt.h
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:279
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
GET_SAMPLE_RATE_NAME
#define GET_SAMPLE_RATE_NAME(rate)
Definition: cmdutils.h:631
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
space
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated space
Definition: undefined.txt:4
AV_IS_INPUT_DEVICE
#define AV_IS_INPUT_DEVICE(category)
Definition: log.h:50
avfilter_pad_get_name
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:1034
codec_id
enum AVCodecID codec_id
Definition: qsv.c:72
OptionDef::off
size_t off
Definition: cmdutils.h:183
Then
status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input Then
Definition: filter_design.txt:165
AVCodec::long_name
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: avcodec.h:3493
libm.h
report_file
static FILE * report_file
Definition: cmdutils.c:75
show_formats
int show_formats(void *optctx, const char *opt, const char *arg)
Print a listing containing all the formats supported by the program (including devices).
Definition: cmdutils.c:1352
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
out
FILE * out
Definition: movenc.c:54
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:324
AV_CODEC_PROP_LOSSY
#define AV_CODEC_PROP_LOSSY
Codec supports lossy compression.
Definition: avcodec.h:756
elements
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
scheduling
===============The purpose of these rules is to ensure that frames flow in the filter graph without getting stuck and accumulating somewhere. Simple filters that output one frame for each input frame should not have to worry about it. There are two design for filters:one using the filter_frame() and request_frame() callbacks and the other using the activate() callback. The design using filter_frame() and request_frame() is legacy, but it is suitable for filters that have a single input and process one frame at a time. New filters with several inputs, that treat several frames at a time or that require a special treatment at EOF should probably use the design using activate(). activate -------- This method is called when something must be done in a filter scheduling
Definition: filter_design.txt:142
MID_STATE
#define MID_STATE
Definition: snow.h:40
av_get_sample_fmt_string
char * av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt)
Generate a string corresponding to the sample format with sample_fmt, or a header if sample_fmt is ne...
Definition: samplefmt.c:93
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
show_layouts
int show_layouts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the standard channel layouts supported by the program.
Definition: cmdutils.c:1775
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
nothing
static void nothing(void *foo)
Definition: dshow_capture.h:52
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
playlist
Definition: hls.c:93
n
int n
Definition: avisynth_c.h:760
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:158
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:3507
init_parse_context
static void init_parse_context(OptionParseContext *octx, const OptionGroupDef *groups, int nb_groups)
Definition: cmdutils.c:705
developers
The official guide to swscale for confused developers
Definition: swscale.txt:2
SHOW_DEFAULT
@ SHOW_DEFAULT
Definition: cmdutils.c:80
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
log_callback_report
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
Definition: cmdutils.c:104
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
va_copy.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: avcodec.h:1078
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
filters
static const struct PPFilter filters[]
Definition: postprocess.c:134
AV_LOG_PANIC
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:163
edgedetect
This document is a tutorial initiation for writing simple filters in libavfilter libavfilter is which means that it is highly recommended that you submit your filters to the FFmpeg development mailing list and make sure that they are applied your filters are likely to have a very short lifetime due to more or less regular internal API and a limited and testing changes the pixels in whatever fashion you and outputs the modified frame The most simple way of doing this is to take a similar filter We ll pick edgedetect
Definition: writing_filters.txt:16
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:453
sws_dict
AVDictionary * sws_dict
Definition: cmdutils.c:71
GCC
#define GCC
Definition: config.h:58
show_help_codec
static void show_help_codec(const char *name, int encoder)
Definition: cmdutils.c:1813
get_media_type_char
static char get_media_type_char(enum AVMediaType type)
Definition: cmdutils.c:1484
AVBitStreamFilter::name
const char * name
Definition: avcodec.h:5813
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
codecs
static struct codec_string codecs[]
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
show_version
int show_version(void *optctx, const char *opt, const char *arg)
Print the version of the program to stdout.
Definition: cmdutils.c:1191
basis
static int16_t basis[64][64]
Definition: mpegvideo_enc.c:4270
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:168
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:109
count
void INT64 INT64 count
Definition: avisynth_c.h:767
design
Filter design
Definition: filter_design.txt:2
av_unused
#define av_unused
Definition: attributes.h:125
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:462
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:885
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
GET_PIX_FMT_NAME
#define GET_PIX_FMT_NAME(pix_fmt)
Definition: cmdutils.h:622
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
callbacks
static const OMX_CALLBACKTYPE callbacks
Definition: omx.c:332
AV_CODEC_CAP_TRUNCATED
#define AV_CODEC_CAP_TRUNCATED
Definition: avcodec.h:982
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
av_frame_make_writable
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:611
pixdesc.h
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
print_codec
static void print_codec(const AVCodec *c)
Definition: cmdutils.c:1385
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: avcodec.h:3500
w
uint8_t w
Definition: llviddspenc.c:38
Rate
Rate
G723.1 rate values.
Definition: g723_1.h:72
pixels
int pixels
Definition: avisynth_c.h:390
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:178
even
Tag MUST be even
Definition: snow.txt:206
name
const char * name
Definition: avisynth_c.h:867
sources
Note except for filters that can have queued frames and sources
Definition: filter_design.txt:285
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:82
AVOption
AVOption.
Definition: opt.h:246
HAS_ARG
#define HAS_ARG
Definition: cmdutils.h:161
OptionGroupList::groups
OptionGroup * groups
Definition: cmdutils.h:329
b
#define b
Definition: input.c:41
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1511
table
static const uint16_t table[]
Definition: prosumer.c:206
likely
#define likely(x)
Definition: asm.h:33
OptionDef::dst_ptr
void * dst_ptr
Definition: cmdutils.h:181
OptionGroupList::nb_groups
int nb_groups
Definition: cmdutils.h:330
data
const char data[16]
Definition: mxf.c:91
linear
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:121
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2529
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:73
avio_enum_protocols
const char * avio_enum_protocols(void **opaque, int output)
Iterate through names of available protocols.
Definition: protocols.c:94
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:407
integer
int integer
Definition: swresample_internal.h:37
convert
Definition: convert.py:1
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:70
possible
the frame and frame reference mechanism is intended to as much as possible
Definition: filter_design.txt:45
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
FLAGS
#define FLAGS
Definition: cmdutils.c:544
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
F
#define F(x)
base
uint8_t base
Definition: vp3data.h:202
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:555
avresample.h
OptionGroup::swr_opts
AVDictionary * swr_opts
Definition: cmdutils.h:319
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:412
show_help_children
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:206
AVOption::flags
int flags
Definition: opt.h:275
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2474
SHOW_COPYRIGHT
#define SHOW_COPYRIGHT
Definition: cmdutils.c:1096
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
AVDictionary
Definition: dict.c:30
Frame
Definition: ffplay.c:154
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:93
processed
status_in is a status change that must be taken into account after all frames in fifo have been processed
Definition: filter_design.txt:159
hide_banner
int hide_banner
Definition: cmdutils.c:77
config_props
static int config_props(AVFilterLink *outlink)
Definition: aeval.c:223
reverse
static uint32_t reverse(uint32_t num, int bits)
Definition: speedhq.c:565
put_pixel
static void put_pixel(uint16_t *dst, ptrdiff_t linesize, const int16_t *in, int bits_per_raw_sample)
Add bias value, clamp and output pixels of a slice.
Definition: proresdsp.c:41
though
though
Definition: snow.txt:1
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:291
Makefile
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter Makefile
Definition: writing_filters.txt:20
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
H0
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 H0
Definition: snow.txt:554
OptionDef::u
union OptionDef::@23 u
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
D
D(D(float, sse)
Definition: rematrix_init.c:28
OptionDef
Definition: cmdutils.h:158
AVUNERROR
#define AVUNERROR(e)
Definition: error.h:44
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:652
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
A
#define A(x)
Definition: vp56_arith.h:28
exit_program
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:136
InputStream
Definition: ffmpeg.h:295
Filter
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 Filter
Definition: snow.txt:554
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1481
av_max_alloc
void av_max_alloc(size_t max)
Set the maximum size that may be allocated in one block.
Definition: mem.c:73
parse_number_or_die
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:144
return
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a it should return
Definition: filter_design.txt:264
av_guess_format
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
print_error
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:1081
fmt
const char * fmt
Definition: avisynth_c.h:861
some
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that some(invalid) inputs can trigger overflows(undefined behavior). In these cases
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:330
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:94
OptionGroupList
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:326
reasons
if it could not for temporary reasons
Definition: filter_design.txt:265
fail
#define fail()
Definition: checkasm.h:120
resolution
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are horizontally scaled and put in the ring buffer[This is done for luma and chroma, each with possibly different numbers of lines per picture.] Input to YUV Converter When the input to the main path is not planar bits per component YUV or bit it is converted to planar bit YUV Two sets of converters exist for this the other leaves the full chroma resolution
Definition: swscale.txt:54
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:105
show_decoders
int show_decoders(void *optctx, const char *opt, const char *arg)
Print a listing containing all the decoders supported by the program.
Definition: cmdutils.c:1642
av_output_video_device_next
AVOutputFormat * av_output_video_device_next(AVOutputFormat *d)
Video output devices iterator.
Definition: avdevice.c:121
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
relevant
status_out is the status that have been taken into it is final when it is not The typical task of an activate callback is to first check the backward status of output and if relevant forward it to the corresponding input if relevant
Definition: filter_design.txt:165
plane
int plane
Definition: avisynth_c.h:384
SHOW_CONFIG
#define SHOW_CONFIG
Definition: cmdutils.c:1095
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:474
IA
#define IA(x)
Definition: cast5.c:26
av_parse_cpu_caps
int av_parse_cpu_caps(unsigned *flags, const char *s)
Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
Definition: cpu.c:191
tables
Writing a table generator This documentation is preliminary Parts of the API are not good and should be changed Basic concepts A table generator consists of two *_tablegen c and *_tablegen h The h file will provide the variable declarations and initialization code for the tables
Definition: tablegen.txt:10
OptionParseContext
Definition: cmdutils.h:333
future
FFmpeg s bug feature request tracker new issues and changes to existing issues can be done through a web interface Issues can be different kinds of things we want to keep track of but that do not belong into the source tree itself This includes bug feature requests and license violations We might add more items to this list in the future
Definition: issue_tracker.txt:13
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
Option
An option extracted from the commandline.
Definition: cmdutils.h:287
variant
Definition: hls.c:177
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
update
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
Definition: af_silencedetect.c:77
pts
static int64_t pts
Definition: transcode_aac.c:647
account
status_out is the status that have been taken into account
Definition: filter_design.txt:160
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:266
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1252
OptionGroup::nb_opts
int nb_opts
Definition: cmdutils.h:313
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
show_muxdemuxers
show_muxdemuxers
Definition: cmdutils.c:79
OPT_STRING
#define OPT_STRING
Definition: cmdutils.h:164
avcodec_find_encoder_by_name
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:913
OptionGroupList::group_def
const OptionGroupDef * group_def
Definition: cmdutils.h:327
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:105
fast
static int fast
Definition: ffplay.c:333
OptionDef::help
const char * help
Definition: cmdutils.h:185
AVRational::num
int num
Numerator.
Definition: rational.h:59
src
#define src
Definition: vp8dsp.c:254
idct
static void idct(int16_t block[64])
Definition: 4xm.c:163
InputFile
Definition: ffmpeg.h:393
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
show_help_bsf
static void show_help_bsf(const char *name)
Definition: cmdutils.c:1955
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:80
OptionGroupDef
Definition: cmdutils.h:293
resample
static int resample(ResampleContext *c, void *dst, const void *src, int *consumed, int src_size, int dst_size, int update_ctx, int nearest_neighbour)
Definition: resample.c:259
qlogs
spatial_decomposition_type s header_state qlog s header_state mv_scale s header_state qbias s header_state block_max_depth s header_state qlogs
Definition: snow.txt:85
LH
#define LH(psrc)
Definition: generic_macros_msa.h:93
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:461
aligned
static int aligned(int val)
Definition: dashdec.c:165
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
check_stream_specifier
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2071
SHOW_VERSION
#define SHOW_VERSION
Definition: cmdutils.c:1094
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
avassert.h
variables
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile variables
Definition: build_system.txt:7
description
Tag description
Definition: snow.txt:206
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
state
static struct @313 state
print_buildconf
static void print_buildconf(int flags, int level)
Definition: cmdutils.c:1154
initFilter
static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[2], int srcPos, int dstPos)
Definition: utils.c:331
buf
void * buf
Definition: avisynth_c.h:766
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1029
AVInputFormat
Definition: avformat.h:640
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:315
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
set
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)
Definition: swresample.c:59
expand_filename_template
static void expand_filename_template(AVBPrint *bp, const char *template, struct tm *tm)
Definition: cmdutils.c:950
check_options
static void check_options(const OptionDef *po)
Definition: cmdutils.c:497
media_type_string
#define media_type_string
Definition: cmdutils.h:617
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:557
check
#define check(x, y, S, v)
Definition: motion_est_template.c:404
YUV
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like YUV
Definition: swscale.txt:38
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
postprocess.h
class
#define class
Definition: math.h:25
av_log_format_line
void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix)
Format a line of log the same way as the default callback.
Definition: log.c:282
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
filter_codec_opts
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2079
OPT_INT
#define OPT_INT
Definition: cmdutils.h:167
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch const uint8_t **in ch off *out planar
Definition: audioconvert.c:226
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1607
input_streams
InputStream ** input_streams
Definition: ffmpeg.c:147
width
#define width
MC
#define MC(PEL, DIR, WIDTH)
Definition: hevcdsp_mips.h:26
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: avcodec.h:716
matter
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not matter(as it is from invalid input). In some cases the input can be checked easily in others checking the input is computationally too intensive. In these remaining cases a unsigned type can be used instead of a signed type. unsigned overflows are defined in C. SUINT ----- As we have above established there is a need to use "unsigned" sometimes in computations which work with signed integers(which overflow). Using "unsigned" for signed integers has the very significant potential to cause confusion as in unsigned a
s
#define s(width, name)
Definition: cbs_vp9.c:257
OptionDef::argname
const char * argname
Definition: cmdutils.h:186
split_commandline
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:753
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
resample_opts
AVDictionary * resample_opts
Definition: cmdutils.c:73
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
SWS_FULL_CHR_H_INP
#define SWS_FULL_CHR_H_INP
Definition: swscale.h:81
g
const char * g
Definition: vf_curves.c:115
changes
This document is a tutorial initiation for writing simple filters in libavfilter libavfilter is which means that it is highly recommended that you submit your filters to the FFmpeg development mailing list and make sure that they are applied your filters are likely to have a very short lifetime due to more or less regular internal API changes
Definition: writing_filters.txt:8
AVDictionaryEntry::key
char * key
Definition: dict.h:82
Option::key
const char * key
Definition: cmdutils.h:289
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
avfilter_pad_count
int avfilter_pad_count(const AVFilterPad *pads)
Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
Definition: avfilter.c:578
sse
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
Definition: mpegvideo_enc.c:2703
info
MIPS optimizations info
Definition: mips.txt:2
swr_alloc
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:149
bits
uint8_t bits
Definition: vp3data.h:202
from
const char * from
Definition: jacosubdec.c:65
to
const char * to
Definition: webvttdec.c:34
avresample_get_class
const attribute_deprecated AVClass * avresample_get_class(void)
Definition: options.c:110
form
This is the more generic form
Definition: tablegen.txt:34
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
get
static void get(uint8_t *pixels, int stride, int16_t *block)
Definition: proresenc_anatoliy.c:304
reaction
Note except for filters that can have queued frames and request_frame does not push and as a reaction
Definition: filter_design.txt:287
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
data
the buffer is automatically deallocated once all corresponding references have been destroyed The characteristics of the data(resolution, sample rate, etc.) are stored in the reference
av_get_channel_name
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
Definition: channel_layout.c:243
AVFilter::flags
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:187
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
pointers
Undefined Behavior In the C some operations are like signed integer dereferencing freed pointers
Definition: undefined.txt:4
dump_argument
static void dump_argument(const char *a)
Definition: cmdutils.c:473
report_file_level
static int report_file_level
Definition: cmdutils.c:76
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
Slice
Definition: magicyuv.c:36
on
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going on
Definition: writing_filters.txt:34
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
write_fileheader
write_fileheader() adds some minor things like a "this is a generated file" comment and some standard includes. tablegen.h defines some write functions for one- and two-dimensional arrays for standard types - they print only the "core" parts so they are easier to reuse for multi-dimensional arrays so the outermost
Definition: tablegen.txt:39
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:88
export
static int export(AVFilterContext *ctx, StreamContext *sc, int input)
Definition: vf_signature.c:570
parse_options
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:383
AV_OPT_FLAG_BSF_PARAM
#define AV_OPT_FLAG_BSF_PARAM
a generic parameter which can be set by the user for bit stream filtering
Definition: opt.h:290
key
const char * key
Definition: hwcontext_opencl.c:168
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
XMM_CLOBBERS
#define XMM_CLOBBERS(...)
Definition: asm.h:98
f
#define f(width, name)
Definition: cbs_vp9.c:255
pass
#define pass
Definition: fft_template.c:619
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:869
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
version
int version
Definition: avisynth_c.h:858
compare_codec_desc
static int compare_codec_desc(const void *a, const void *b)
Definition: cmdutils.c:1507
int32_t
int32_t
Definition: audio_convert.c:194
ff_inlink_make_frame_writable
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1525
av_opt_find
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1608
arg
const char * arg
Definition: jacosubdec.c:66
callback
static void callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time, enum dshowDeviceType devtype)
Definition: dshow.c:161
included
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do and instead of the variable declarations the generated *_tables h file should be included Since that will be generated in the build the path must be included
Definition: tablegen.txt:59
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
if
if(ret)
Definition: filter_design.txt:179
OPT_SPEC
#define OPT_SPEC
Definition: cmdutils.h:175
finish_group
static void finish_group(OptionParseContext *octx, int group_idx, const char *arg)
Definition: cmdutils.c:662
output_streams
OutputStream ** output_streams
Definition: ffmpeg.c:152
H2
vertical halfpel samples are found by H2[y][x]
Definition: snow.txt:421
AV_IS_OUTPUT_DEVICE
#define AV_IS_OUTPUT_DEVICE(category)
Definition: log.h:55
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
negotiation
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format negotiation
Definition: filter_design.txt:12
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:380
need
must be printed separately If there s no standard function for printing the type you need
Definition: tablegen.txt:45
show_buildconf
int show_buildconf(void *optctx, const char *opt, const char *arg)
Print the build configuration of the program to stdout.
Definition: cmdutils.c:1200
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: avcodec.h:750
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:485
init_dynload
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:120
opts
AVDictionary * opts
Definition: movenc.c:50
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:316
avcodec_descriptor_next
const AVCodecDescriptor * avcodec_descriptor_next(const AVCodecDescriptor *prev)
Iterate over all codec descriptors known to libavcodec.
Definition: codec_desc.c:3263
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:294
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
frames
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across frames
Definition: multithreading.txt:37
OptionParseContext::global_opts
OptionGroup global_opts
Definition: cmdutils.h:334
Option::opt
const OptionDef * opt
Definition: cmdutils.h:288
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
run
uint8_t run
Definition: svq3.c:206
prepare_app_arguments
static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
Definition: cmdutils.c:289
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
push
static void push(HysteresisContext *s, int x, int y, int w)
Definition: vf_hysteresis.c:145
pixel
uint8_t pixel
Definition: tiny_ssim.c:42
anything
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do anything
Definition: tablegen.txt:56
swr_get_class
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:144
frame_wanted_out
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the frame_wanted_out
Definition: filter_design.txt:148
LIBAVFILTER_VERSION_MICRO
#define LIBAVFILTER_VERSION_MICRO
Definition: version.h:34
contain
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should contain
Definition: tablegen.txt:55
transform
static const int8_t transform[32][32]
Definition: hevcdsp.c:27
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
period
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
Definition: writing_filters.txt:89
next_codec_for_id
static const AVCodec * next_codec_for_id(enum AVCodecID id, const AVCodec *prev, int encoder)
Definition: cmdutils.c:1496
coefficients
static double coefficients[8 *8]
Definition: dctref.c:35
greater
static int greater(MetadataContext *s, const char *value1, const char *value2)
Definition: f_metadata.c:145
AVOutputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:502
show_formats_devices
static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
Definition: cmdutils.c:1289
activate
filter_frame For filters that do not use the activate() callback
H
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 this can end with a L or a H
Definition: snow.txt:555
system
FFmpeg currently uses a custom build system
Definition: build_system.txt:1
GET_CODEC_NAME
#define GET_CODEC_NAME(id)
Definition: cmdutils.h:625
warned_cfg
static int warned_cfg
Definition: cmdutils.c:1091
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:390
work
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do and instead of the variable declarations the generated *_tables h file should be included Since that will be generated in the build the path must be i e not Makefile changes To make the automatic table creation work
Definition: tablegen.txt:66
parseutils.h
INDENT
#define INDENT
Definition: cmdutils.c:1093
sws_alloc_context
struct SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1079
show_muxers
int show_muxers(void *optctx, const char *opt, const char *arg)
Print a listing containing all the muxers supported by the program (including devices).
Definition: cmdutils.c:1357
L0
#define L0
Definition: hevcdec.h:59
init_opts
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
Definition: cmdutils.c:85
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
not
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If not
Definition: filter_design.txt:259
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: avcodec.h:5831
OPT_INT64
#define OPT_INT64
Definition: cmdutils.h:170
Prediction
Prediction
Definition: magicyuv.c:41
particular
different references for the same buffer can show different characteristics In particular
Definition: filter_design.txt:55
AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: avcodec.h:1053
av_cpu_max_align
size_t av_cpu_max_align(void)
Get the maximum data alignment that may be required by FFmpeg.
Definition: cpu.c:309
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
abs
#define abs(x)
Definition: cuda_runtime.h:35
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:524
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
nb_input_streams
int nb_input_streams
Definition: ffmpeg.c:148
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. If the codec allocates writable tables in its init()
write_option
static int write_option(void *optctx, const OptionDef *po, const char *opt, const char *arg)
Definition: cmdutils.c:295
av_get_standard_channel_layout
int av_get_standard_channel_layout(unsigned index, uint64_t *layout, const char **name)
Get the value and name of a standard channel layout.
Definition: channel_layout.c:279
OptionGroup::opts
Option * opts
Definition: cmdutils.h:312
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
OptionGroup
Definition: cmdutils.h:308
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1436
av_output_audio_device_next
AVOutputFormat * av_output_audio_device_next(AVOutputFormat *d)
Audio output devices iterator.
Definition: avdevice.c:115
diff_bytes
static void diff_bytes(HYuvContext *s, uint8_t *dst, const uint8_t *src0, const uint8_t *src1, int w)
Definition: huffyuvenc.c:41
Range
Definition: vf_colorbalance.c:38
swresample.h
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
converted
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are converted
Definition: swscale.txt:46
H1
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 H1
Definition: snow.txt:554
error
static void error(const char *err)
Definition: target_dec_fuzzer.c:61
input_files
InputFile ** input_files
Definition: ffmpeg.c:149
AV_OPT_SEARCH_FAKE_OBJ
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poin...
Definition: opt.h:564
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
av_input_video_device_next
AVInputFormat * av_input_video_device_next(AVInputFormat *d)
Video input devices iterator.
Definition: avdevice.c:109
process
static int process(struct ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed)
Definition: soxr_resample.c:84
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
methods
FFmpeg multithreading methods
Definition: multithreading.txt:2
source
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source
Definition: filter_design.txt:255
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: avcodec.h:1033
http
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i http
Definition: writing_filters.txt:29
locate_option
int locate_option(int argc, char **argv, const OptionDef *options, const char *optname)
Return index of option opt in argv or 0 if not found.
Definition: cmdutils.c:447
interleave
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:117
FF_FILTER_FORWARD_STATUS_ALL
FF_FILTER_FORWARD_STATUS_ALL(outlink, filter)
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:73
options
const OptionDef options[]
eval.h
show_help_demuxer
static void show_help_demuxer(const char *name)
Definition: cmdutils.c:1848
AV_CODEC_CAP_AUTO_THREADS
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1049
desc
const char * desc
Definition: nvenc.c:68
blur
static void blur(uint8_t *dst, int dst_step, const uint8_t *src, int src_step, int len, int radius, int pixsize)
Definition: vf_boxblur.c:160
H3
vertical horizontal halfpel samples are found by H3[y][x]
Definition: snow.txt:427
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
get_audio_buffer
static AVFrame * get_audio_buffer(AVFilterLink *inlink, int nb_samples)
Definition: avf_concat.c:195
AV_SAMPLE_FMT_NB
@ AV_SAMPLE_FMT_NB
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:74
show_help
int show_help(void *optctx, const char *opt, const char *arg)
Generic -h handler common to all fftools.
Definition: cmdutils.c:1974
AVMediaType
AVMediaType
Definition: avutil.h:199
av_log_set_callback
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:400
ff_inlink_set_status
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1615
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: utils.c:5291
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:185
Header
@ Header
Definition: mxfdec.c:63
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
av_stream_get_side_data
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5471
AVClass::category
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:130
output_files
OutputFile ** output_files
Definition: ffmpeg.c:154
opt_report
int opt_report(const char *opt)
Definition: cmdutils.c:1049
cpu.h
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
subbands
subbands
Definition: aptx.c:36
get_preset_file
FILE * get_preset_file(char *filename, size_t filename_size, const char *preset_name, int is_path, const char *codec_name)
Get a file corresponding to a preset file.
Definition: cmdutils.c:2021
PRINT_CODEC_SUPPORTED
#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name)
Definition: cmdutils.c:1372
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sample
#define sample
Definition: flacdsp_template.c:44
init_thread_copy
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an init_thread_copy() which re-allocates them for other threads. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:90
size
int size
Definition: twinvq_data.h:11134
print_codecs
static void print_codecs(int encoder)
Definition: cmdutils.c:1604
section
Definition: ffprobe.c:139
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
AV_PIX_FMT_FLAG_BITSTREAM
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:136
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:92
does
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the and we are assuming vf_foobar is as well We are also assuming vf_foobar is not an edge detector so you can update the boilerplate with your credits Doxy Next chunk is the Doxygen about the file See does
Definition: writing_filters.txt:66
setup_find_stream_info_opts
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2136
GET_SAMPLE_FMT_NAME
#define GET_SAMPLE_FMT_NAME(sample_fmt)
Definition: cmdutils.h:628
swscale
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale.c:237
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:522
printf
printf("static const uint8_t my_array[100] = {\n")
gray
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are horizontally scaled and put in the ring buffer[This is done for luma and chroma, each with possibly different numbers of lines per picture.] Input to YUV Converter When the input to the main path is not planar bits per component YUV or bit gray
Definition: swscale.txt:52
show_protocols
int show_protocols(void *optctx, const char *opt, const char *arg)
Print a listing containing all the protocols supported by the program.
Definition: cmdutils.c:1666
av_log_get_flags
int av_log_get_flags(void)
Definition: log.c:395
val
const char const char void * val
Definition: avisynth_c.h:863
avdevice.h
AVFilter::description
const char * description
A description of the filter.
Definition: avfilter.h:155
avdevice_free_list_devices
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:250
header
static const uint8_t header[24]
Definition: sdr2.c:67
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:556
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:890
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
CONFIG_FOOBAR_FILTER
#define CONFIG_FOOBAR_FILTER
av_input_audio_device_next
AVInputFormat * av_input_audio_device_next(AVInputFormat *d)
Audio input devices iterator.
Definition: avdevice.c:103
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
residual
uint64_t residual
Definition: dirac_vlc.h:29
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1041
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
line
Definition: graph2dot.c:48
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
quant_table
static float quant_table[96]
Definition: binkaudio.c:43
main
int main(int argc, char *argv[])
Definition: avio_dir_cmd.c:134
attributes.h
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2541
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
show_devices
int show_devices(void *optctx, const char *opt, const char *arg)
Print a listing containing all the devices supported by the program.
Definition: cmdutils.c:1367
AVCodecInternal
Definition: internal.h:129
that
if it could not because there are no more it should return AVERROR_EOF The typical implementation of request_frame for a filter with several inputs will look like that
Definition: filter_design.txt:273
N
#define N
Definition: af_mcompand.c:54
va_copy
#define va_copy(dst, src)
Definition: va_copy.h:31
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:454
avdevice_list_output_sinks
int avdevice_list_output_sinks(AVOutputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
Definition: avdevice.c:239
show_pix_fmts
int show_pix_fmts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the pixel formats supported by the program.
Definition: cmdutils.c:1742
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
interpolation
static int interpolation(DeclickChannel *c, const double *src, int ar_order, double *acoefficients, int *index, int nb_errors, double *auxiliary, double *interpolated)
Definition: af_adeclick.c:351
Y
#define Y
Definition: boxblur.h:38
help
static void help(void)
Definition: dct.c:450
introduced
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was introduced
Definition: undefined.txt:38
XMM_CLOBBERS_ONLY
#define XMM_CLOBBERS_ONLY(...)
Definition: asm.h:99
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
implementations
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec implementations
Definition: multithreading.txt:30
distribution
This document is a tutorial initiation for writing simple filters in libavfilter libavfilter is which means that it is highly recommended that you submit your filters to the FFmpeg development mailing list and make sure that they are applied your filters are likely to have a very short lifetime due to more or less regular internal API and a limited distribution
Definition: writing_filters.txt:8
show_sample_fmts
int show_sample_fmts(void *optctx, const char *opt, const char *arg)
Print a listing containing all the sample formats supported by the program.
Definition: cmdutils.c:1804
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3495
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:125
b
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not b
Definition: undefined.txt:32
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1180
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
program_exit
static void(* program_exit)(int ret)
Definition: cmdutils.c:129
flag
#define flag(name)
Definition: cbs_av1.c:557
register_exit
void register_exit(void(*cb)(int ret))
Register a program-specific cleanup routine.
Definition: cmdutils.c:131
GET_CH_LAYOUT_DESC
#define GET_CH_LAYOUT_DESC(ch_layout)
Definition: cmdutils.h:639
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
AV_CODEC_PROP_LOSSLESS
#define AV_CODEC_PROP_LOSSLESS
Codec supports lossless compression.
Definition: avcodec.h:760
av_find_input_format
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
tests
const TestCase tests[]
Definition: fifo_muxer.c:245
less
static int less(MetadataContext *s, const char *value1, const char *value2)
Definition: f_metadata.c:135
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:385
Type
Type
Definition: vf_idet.h:29
bprint.h
apply
const char const char AVS_ApplyFunc apply
Definition: avisynth_c.h:868
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: avcodec.h:216
AVOutputFormat
Definition: avformat.h:495
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
print_all_libs_info
static void print_all_libs_info(int flags, int level)
Definition: cmdutils.c:1127
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
OPT_TIME
#define OPT_TIME
Definition: cmdutils.h:176
swr_opts
AVDictionary * swr_opts
Definition: cmdutils.c:72
av_codec_next
AVCodec * av_codec_next(const AVCodec *c)
If c is NULL, returns the first registered codec, if c is non-NULL, returns the next registered codec...
Definition: allcodecs.c:838
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
LIBAVFILTER_VERSION_MINOR
#define LIBAVFILTER_VERSION_MINOR
Definition: version.h:33
available
if no frame is available
Definition: filter_design.txt:166
Code
One code in hash table.
Definition: lzwenc.c:42
filter_frame
static int filter_frame(DBEContext *s, AVFrame *frame)
Definition: dolby_e.c:565
display.h
needed
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is needed
Definition: filter_design.txt:212
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
delta
float delta
Definition: vorbis_enc_data.h:457
ilog2
any process which generates a stream compliant to the syntactical and semantic requirements and which is decodable by the process described in this spec shall be considered a conformant Snow encoder but not strictly required ilog2(x) is the rounded down logarithm of x with basis 2 ilog2(0)=0Type definitions
Definition: snow.txt:23
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:231
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
CONFIG_HARDCODED_TABLES
#define CONFIG_HARDCODED_TABLES
Definition: aacps_tablegen_template.c:24
description
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf description
Definition: writing_filters.txt:86
SUINT
#define SUINT
Definition: dct32_template.c:30
uint8_t
uint8_t
Definition: audio_convert.c:194
headers
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:34
SHOW_MUXERS
@ SHOW_MUXERS
Definition: cmdutils.c:82
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
get_codecs_sorted
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
Definition: cmdutils.c:1516
filter
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the and we are assuming vf_foobar is as well We are also assuming vf_foobar is not an edge detector filter
Definition: writing_filters.txt:60
pix_sum
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
Definition: snowenc.c:164
OPT_OUTPUT
#define OPT_OUTPUT
Definition: cmdutils.h:179
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
CONTEXT
#define CONTEXT
Definition: af_asetrate.c:31
len
int len
Definition: vorbis_enc_data.h:452
opt_timelimit
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:1068
OPT_OFFSET
#define OPT_OFFSET
Definition: cmdutils.h:174
mv_scale
static av_always_inline void mv_scale(Mv *dst, Mv *src, int td, int tb)
Definition: hevc_mvs.c:115
headroom
static int headroom(int *la)
Definition: nellymoser.c:104
plain
static const uint8_t plain[]
Definition: aes_ctr.c:23
opt_max_alloc
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
Definition: cmdutils.c:1054
nb_output_files
int nb_output_files
Definition: ffmpeg.c:155
OptionParseContext::groups
OptionGroupList * groups
Definition: cmdutils.h:336
log2
#define log2(x)
Definition: libm.h:404
needed
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be needed
Definition: swscale.txt:45
parse_optgroup
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:414
parse_loglevel
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the '-loglevel' option in the command line args and apply it.
Definition: cmdutils.c:506
AVFilter
Filter definition.
Definition: avfilter.h:144
version.h
OptionGroup::sws_dict
AVDictionary * sws_dict
Definition: cmdutils.h:318
directory
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object directory
Definition: build_system.txt:12
language
Undefined Behavior In the C language
Definition: undefined.txt:3
SpecifierOpt
Definition: cmdutils.h:146
OptionGroup::resample_opts
AVDictionary * resample_opts
Definition: cmdutils.h:317
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
G
#define G
Definition: huffyuvdsp.h:33
files
Writing a table generator This documentation is preliminary Parts of the API are not good and should be changed Basic concepts A table generator consists of two files
Definition: tablegen.txt:8
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:870
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
pixfmt
enum AVPixelFormat pixfmt
Definition: kmsgrab.c:202
pred
static const float pred[4]
Definition: siprdata.h:259
currently
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are horizontally scaled and put in the ring buffer[This is done for luma and chroma, each with possibly different numbers of lines per picture.] Input to YUV Converter When the input to the main path is not planar bits per component YUV or bit it is converted to planar bit YUV Two sets of converters exist for this currently
Definition: swscale.txt:54
read_yesno
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0.
Definition: cmdutils.c:2010
links
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output links
Definition: filter_design.txt:14
av_strtod
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
comment
static int FUNC() comment(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawComment *current)
Definition: cbs_jpeg_syntax_template.c:174
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:93
OptionGroup::arg
const char * arg
Definition: cmdutils.h:310
AVDeviceInfoList
List of devices.
Definition: avdevice.h:460
uninit_parse_context
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:727
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:99
OPT_PERFILE
#define OPT_PERFILE
Definition: cmdutils.h:173
av_opt_get_key_value
int av_opt_get_key_value(const char **ropts, const char *key_val_sep, const char *pairs_sep, unsigned flags, char **rkey, char **rval)
Extract a key-value pair from the beginning of a string.
Definition: opt.c:1484
align
const AVS_VideoInfo int align
Definition: avisynth_c.h:887
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
dict.h
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
network.h
av_opt_child_class_next
const AVClass * av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:1666
av_get_channel_description
const char * av_get_channel_description(uint64_t channel)
Get the description of a given channel.
Definition: channel_layout.c:254
AV_LOG_SKIP_REPEATED
#define AV_LOG_SKIP_REPEATED
Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 woul...
Definition: log.h:345
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
clients
=============================================Slice threading - *The client 's draw_horiz_band() must be thread-safe according to the comment in avcodec.h. Frame threading - *Restrictions with slice threading also apply. *For best performance, the client should set thread_safe_callbacks if it provides a thread-safe get_buffer() callback. *There is one frame of delay added for every thread beyond the first one. Clients must be able to handle this clients
Definition: multithreading.txt:26
add_opt
static void add_opt(OptionParseContext *octx, const OptionDef *opt, const char *key, const char *val)
Definition: cmdutils.c:693
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
show_codecs
int show_codecs(void *optctx, const char *opt, const char *arg)
Print a listing containing all the codecs supported by the program.
Definition: cmdutils.c:1549
init_report
static int init_report(const char *env)
Definition: cmdutils.c:978
avfilter_pad_get_type
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1039
L
#define L(x)
Definition: vp56_arith.h:36
function
AVS_ShutdownFunc function
Definition: avisynth_c.h:911
avcodec_find_decoder_by_name
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:918
await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an so the codec calls ff_thread_report await_progress()
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
compare
static float compare(const AVFrame *haystack, const AVFrame *obj, int offx, int offy)
Definition: vf_find_rect.c:104
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:505
parse_option
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:350
get_rotation
double get_rotation(AVStream *st)
Definition: cmdutils.c:2175
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVDeviceInfoList::default_device
int default_device
index of default device or -1 if no default
Definition: avdevice.h:463
opt_cpuflags
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
Override the cpuflags.
Definition: cmdutils.c:859
again
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining again
Definition: filter_design.txt:25
if
if(!keyframe)
Definition: snow.txt:61
sws_freeContext
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2311
AVBitStreamFilter
Definition: avcodec.h:5812
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
SHOW_DEMUXERS
@ SHOW_DEMUXERS
Definition: cmdutils.c:81
get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling get_buffer()
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
config.h
Compensation
Motion Compensation
Definition: snow.txt:418
Transform
Definition: deshake.h:47
avfilter.h
av_match_name
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:344
video
A Quick Description Of Rate Distortion Theory We want to encode a video
Definition: rate_distortion.txt:3
test
static void test(const char *pattern, const char *host)
Definition: noproxy.c:23
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:263
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1006
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
Option::val
const char * val
Definition: cmdutils.h:290
note
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 note
Definition: snow.txt:555
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:619
AV_CODEC_CAP_LOSSLESS
#define AV_CODEC_CAP_LOSSLESS
Codec is lossless.
Definition: avcodec.h:1071
IDCT
#define IDCT(H)
Definition: hevcdsp_template.c:240
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1824
ff_outlink_get_status
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1630
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
need
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the and we are assuming vf_foobar is as well We are also assuming vf_foobar is not an edge detector so you can update the boilerplate with your credits Doxy Next chunk is the Doxygen about the file See and add some references if you feel like it Context Skip the headers and scroll down to the definition of FoobarContext This is your state context It is already filled with when you get it so do not worry about uninitialized reads into this context This is where you put all global information that you need
Definition: writing_filters.txt:75
factor
static const int factor[16]
Definition: vf_pp7.c:75
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: avcodec.h:1045
timeline
Definition: dashdec.c:44
https
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the and we are assuming vf_foobar is as well We are also assuming vf_foobar is not an edge detector so you can update the boilerplate with your credits Doxy Next chunk is the Doxygen about the file See https
Definition: writing_filters.txt:66
bad
static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:116
print_program_info
static void print_program_info(int flags, int level)
Definition: cmdutils.c:1140
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
opt_default
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions.
Definition: cmdutils.c:545
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
review
This document is a tutorial initiation for writing simple filters in libavfilter libavfilter is which means that it is highly recommended that you submit your filters to the FFmpeg development mailing list and make sure that they are applied your filters are likely to have a very short lifetime due to more or less regular internal API and a limited review
Definition: writing_filters.txt:8
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
transforms
static const struct @99 transforms[18]
av_log_default_callback
void av_log_default_callback(void *ptr, int level, const char *fmt, va_list vl)
Default logging callback.
Definition: log.c:300
zero
#define zero
Definition: regdef.h:64
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: avcodec.h:1024
AV_OPT_FLAG_SUBTITLE_PARAM
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:280
overflow
Undefined Behavior In the C some operations are like signed integer overflow
Definition: undefined.txt:3
show_colors
int show_colors(void *optctx, const char *opt, const char *arg)
Print a listing containing all the color names and values recognized by the program.
Definition: cmdutils.c:1728
codec_ids
static enum AVCodecID codec_ids[]
Definition: aac_adtstoasc_bsf.c:148
L3
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L3
Definition: snow.txt:554
it
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s it
Definition: writing_filters.txt:31
AV_CODEC_CAP_HYBRID
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: avcodec.h:1085
av_get_known_color_name
const char * av_get_known_color_name(int color_idx, const uint8_t **rgbp)
Get the name of a color from the internal table of hard-coded named colors.
Definition: parseutils.c:434
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
OptionDef::name
const char * name
Definition: cmdutils.h:159
show_filters
int show_filters(void *optctx, const char *opt, const char *arg)
Print a listing containing all the filters supported by the program.
Definition: cmdutils.c:1681
show_encoders
int show_encoders(void *optctx, const char *opt, const char *arg)
Print a listing containing all the encoders supported by the program.
Definition: cmdutils.c:1648
functions
static const struct drawtext_function functions[]
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
opt_loglevel
int opt_loglevel(void *optctx, const char *opt, const char *arg)
Set the libav* libraries log level.
Definition: cmdutils.c:871
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
equal
static int equal(MetadataContext *s, const char *value1, const char *value2)
Definition: f_metadata.c:125
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:113
OptionGroupDef::sep
const char * sep
Option to be used as group separator.
Definition: cmdutils.h:300
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
status_in
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the status_in
Definition: filter_design.txt:154
AVFILTER_FLAG_SUPPORT_TIMELINE
#define AVFILTER_FLAG_SUPPORT_TIMELINE
Handy mask to test whether the filter supports or no the timeline feature (internally or generically)...
Definition: avfilter.h:138
avoid
the frame and frame reference mechanism is intended to avoid
Definition: filter_design.txt:45
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
cmdutils.h
ready
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already ready
Definition: filter_design.txt:258
htaps
static const double htaps[HTAPS]
The 2nd half (48 coeffs) of a 96-tap symmetric lowpass filter.
Definition: dsd_tablegen.h:55
OPT_BOOL
#define OPT_BOOL
Definition: cmdutils.h:162
once
static pthread_once_t once
Definition: ffjni.c:36
inverse
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
Definition: asfcrypt.c:35
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:244
parse_time_or_die
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds.
Definition: cmdutils.c:165
grow_array
void * grow_array(void *array, int elem_size, int *size, int new_size)
Realloc array to hold new_size elements of elem_size.
Definition: cmdutils.c:2156
imgutils.h
OutputStream
Definition: muxing.c:53
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:975
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
OptionParseContext::nb_groups
int nb_groups
Definition: cmdutils.h:337
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: avcodec.h:1063
length
const char int length
Definition: avisynth_c.h:860
pix_norm1
static int pix_norm1(uint8_t *pix, int line_size, int w)
Definition: snowenc.c:180
find_option
static const OptionDef * find_option(const OptionDef *po, const char *name)
Definition: cmdutils.c:218
AVCodecHWConfig
Definition: avcodec.h:3455
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
h
h
Definition: vp9dsp_template.c:2038
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
Sequence
@ Sequence
Definition: mxf.h:37
AVDictionaryEntry::value
char * value
Definition: dict.h:83
avstring.h
dimension
The official guide to swscale for confused that consecutive non overlapping rectangles of dimension(0, slice_top) -(picture_width
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:177
show_bsfs
int show_bsfs(void *optctx, const char *opt, const char *arg)
Print a listing containing all the bit stream filters supported by the program.
Definition: cmdutils.c:1654
Otherwise
This document is a tutorial initiation for writing simple filters in libavfilter libavfilter is which means that it is highly recommended that you submit your filters to the FFmpeg development mailing list and make sure that they are applied Otherwise
Definition: writing_filters.txt:6
show_license
int show_license(void *optctx, const char *opt, const char *arg)
Print the license of the program to stdout.
Definition: cmdutils.c:1208
PRINT_LIB_INFO
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)
Definition: cmdutils.c:1098
monolithic
This document is a tutorial initiation for writing simple filters in libavfilter libavfilter is monolithic
Definition: writing_filters.txt:4
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:1011
SwsContext
Definition: swscale_internal.h:280
av_opt_show2
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1293
show_help_muxer
static void show_help_muxer(const char *name)
Definition: cmdutils.c:1866
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
snprintf
#define snprintf
Definition: snprintf.h:34
filter
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 this can end with a L or a the number of elements shall be w s[-1] shall be considered equivalent to s[1] s[w] shall be considered equivalent to s[w-2] perform the lifting steps in order as described below Integer filter
Definition: snow.txt:562
sanitize
static void sanitize(uint8_t *line)
Definition: log.c:201
do
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they do
Definition: writing_filters.txt:90
OptionParseContext::cur_group
OptionGroup cur_group
Definition: cmdutils.h:340
passed
static int passed(HysteresisContext *s, int x, int y, int w)
Definition: vf_hysteresis.c:140
AV_LOG_PRINT_LEVEL
#define AV_LOG_PRINT_LEVEL
Include the log severity in messages originating from codecs.
Definition: log.h:353
AVCodecHWConfig::device_type
enum AVHWDeviceType device_type
The device type associated with the configuration.
Definition: avcodec.h:3471
get_video_buffer
static AVFrame * get_video_buffer(AVFilterLink *inlink, int w, int h)
Definition: avf_concat.c:186
Therefore
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input Therefore
Definition: filter_design.txt:244
undefined
Undefined Behavior In the C some operations are undefined
Definition: undefined.txt:3
is_device
static int is_device(const AVClass *avclass)
Definition: cmdutils.c:1282
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140
show_demuxers
int show_demuxers(void *optctx, const char *opt, const char *arg)
Print a listing containing all the demuxer supported by the program (including devices).
Definition: cmdutils.c:1362
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3272
channel
channel
Definition: ebur128.h:39
swscale.h
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: aeval.c:274
match_group_separator
static int match_group_separator(const OptionGroupDef *groups, int nb_groups, const char *opt)
Definition: cmdutils.c:642
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:670
foobar
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf foobar
Definition: writing_filters.txt:84
OptionDef::func_arg
int(* func_arg)(void *, const char *, const char *)
Definition: cmdutils.h:182
opt_find
static const AVOption * opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Definition: cmdutils.c:535
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
nb_output_streams
int nb_output_streams
Definition: ffmpeg.c:153
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
OutputFile
Definition: ffmpeg.h:554
re
float re
Definition: fft.c:82
GEN
#define GEN(table)
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:110
min
float min
Definition: vorbis_enc_data.h:456
OptionDef::flags
int flags
Definition: cmdutils.h:160
ff_thread_release_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with ff_thread_release_buffer(). Otherwise leave it at zero and decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
OPT_DOUBLE
#define OPT_DOUBLE
Definition: cmdutils.h:177
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57