FFmpeg
opt_common.c
Go to the documentation of this file.
1 /*
2  * Option handlers shared between the tools.
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "config.h"
22 
23 #include <stdio.h>
24 
25 #include "cmdutils.h"
26 #include "opt_common.h"
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/avstring.h"
30 #include "libavutil/bprint.h"
32 #include "libavutil/cpu.h"
33 #include "libavutil/dict.h"
34 #include "libavutil/error.h"
35 #include "libavutil/ffversion.h"
36 #include "libavutil/log.h"
37 #include "libavutil/mem.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/version.h"
41 
42 #include "libavcodec/avcodec.h"
43 #include "libavcodec/bsf.h"
44 #include "libavcodec/codec.h"
45 #include "libavcodec/codec_desc.h"
46 #include "libavcodec/version.h"
47 
48 #include "libavformat/avformat.h"
49 #include "libavformat/version.h"
50 
51 #include "libavdevice/avdevice.h"
52 #include "libavdevice/version.h"
53 
54 #include "libavfilter/avfilter.h"
55 #include "libavfilter/version.h"
56 
57 #include "libswscale/swscale.h"
58 #include "libswscale/version.h"
59 
61 #include "libswresample/version.h"
62 
64 #include "libpostproc/version.h"
65 
70 };
71 
72 static FILE *report_file;
74 
75 int show_license(void *optctx, const char *opt, const char *arg)
76 {
77 #if CONFIG_NONFREE
78  printf(
79  "This version of %s has nonfree parts compiled in.\n"
80  "Therefore it is not legally redistributable.\n",
81  program_name );
82 #elif CONFIG_GPLV3
83  printf(
84  "%s is free software; you can redistribute it and/or modify\n"
85  "it under the terms of the GNU General Public License as published by\n"
86  "the Free Software Foundation; either version 3 of the License, or\n"
87  "(at your option) any later version.\n"
88  "\n"
89  "%s is distributed in the hope that it will be useful,\n"
90  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
91  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
92  "GNU General Public License for more details.\n"
93  "\n"
94  "You should have received a copy of the GNU General Public License\n"
95  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
97 #elif CONFIG_GPL
98  printf(
99  "%s is free software; you can redistribute it and/or modify\n"
100  "it under the terms of the GNU General Public License as published by\n"
101  "the Free Software Foundation; either version 2 of the License, or\n"
102  "(at your option) any later version.\n"
103  "\n"
104  "%s is distributed in the hope that it will be useful,\n"
105  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
106  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
107  "GNU General Public License for more details.\n"
108  "\n"
109  "You should have received a copy of the GNU General Public License\n"
110  "along with %s; if not, write to the Free Software\n"
111  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
113 #elif CONFIG_LGPLV3
114  printf(
115  "%s is free software; you can redistribute it and/or modify\n"
116  "it under the terms of the GNU Lesser General Public License as published by\n"
117  "the Free Software Foundation; either version 3 of the License, or\n"
118  "(at your option) any later version.\n"
119  "\n"
120  "%s is distributed in the hope that it will be useful,\n"
121  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
122  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
123  "GNU Lesser General Public License for more details.\n"
124  "\n"
125  "You should have received a copy of the GNU Lesser General Public License\n"
126  "along with %s. If not, see <http://www.gnu.org/licenses/>.\n",
128 #else
129  printf(
130  "%s is free software; you can redistribute it and/or\n"
131  "modify it under the terms of the GNU Lesser General Public\n"
132  "License as published by the Free Software Foundation; either\n"
133  "version 2.1 of the License, or (at your option) any later version.\n"
134  "\n"
135  "%s is distributed in the hope that it will be useful,\n"
136  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
137  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
138  "Lesser General Public License for more details.\n"
139  "\n"
140  "You should have received a copy of the GNU Lesser General Public\n"
141  "License along with %s; if not, write to the Free Software\n"
142  "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
144 #endif
145 
146  return 0;
147 }
148 
149 static int warned_cfg = 0;
150 
151 #define INDENT 1
152 #define SHOW_VERSION 2
153 #define SHOW_CONFIG 4
154 #define SHOW_COPYRIGHT 8
155 
156 #define PRINT_LIB_INFO(libname, LIBNAME, flags, level) \
157  if (CONFIG_##LIBNAME) { \
158  const char *indent = flags & INDENT? " " : ""; \
159  if (flags & SHOW_VERSION) { \
160  unsigned int version = libname##_version(); \
161  av_log(NULL, level, \
162  "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n", \
163  indent, #libname, \
164  LIB##LIBNAME##_VERSION_MAJOR, \
165  LIB##LIBNAME##_VERSION_MINOR, \
166  LIB##LIBNAME##_VERSION_MICRO, \
167  AV_VERSION_MAJOR(version), AV_VERSION_MINOR(version),\
168  AV_VERSION_MICRO(version)); \
169  } \
170  if (flags & SHOW_CONFIG) { \
171  const char *cfg = libname##_configuration(); \
172  if (strcmp(FFMPEG_CONFIGURATION, cfg)) { \
173  if (!warned_cfg) { \
174  av_log(NULL, level, \
175  "%sWARNING: library configuration mismatch\n", \
176  indent); \
177  warned_cfg = 1; \
178  } \
179  av_log(NULL, level, "%s%-11s configuration: %s\n", \
180  indent, #libname, cfg); \
181  } \
182  } \
183  } \
184 
185 static void print_all_libs_info(int flags, int level)
186 {
187  PRINT_LIB_INFO(avutil, AVUTIL, flags, level);
188  PRINT_LIB_INFO(avcodec, AVCODEC, flags, level);
189  PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
190  PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
191  PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
192  PRINT_LIB_INFO(swscale, SWSCALE, flags, level);
193  PRINT_LIB_INFO(swresample, SWRESAMPLE, flags, level);
194  PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
195 }
196 
197 static void print_program_info(int flags, int level)
198 {
199  const char *indent = flags & INDENT? " " : "";
200 
201  av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
202  if (flags & SHOW_COPYRIGHT)
203  av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
204  program_birth_year, CONFIG_THIS_YEAR);
205  av_log(NULL, level, "\n");
206  av_log(NULL, level, "%sbuilt with %s\n", indent, CC_IDENT);
207 
208  av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
209 }
210 
211 static void print_buildconf(int flags, int level)
212 {
213  const char *indent = flags & INDENT ? " " : "";
214  char str[] = { FFMPEG_CONFIGURATION };
215  char *conflist, *remove_tilde, *splitconf;
216 
217  // Change all the ' --' strings to '~--' so that
218  // they can be identified as tokens.
219  while ((conflist = strstr(str, " --")) != NULL) {
220  conflist[0] = '~';
221  }
222 
223  // Compensate for the weirdness this would cause
224  // when passing 'pkg-config --static'.
225  while ((remove_tilde = strstr(str, "pkg-config~")) != NULL) {
226  remove_tilde[sizeof("pkg-config~") - 2] = ' ';
227  }
228 
229  splitconf = strtok(str, "~");
230  av_log(NULL, level, "\n%sconfiguration:\n", indent);
231  while (splitconf != NULL) {
232  av_log(NULL, level, "%s%s%s\n", indent, indent, splitconf);
233  splitconf = strtok(NULL, "~");
234  }
235 }
236 
237 void show_banner(int argc, char **argv, const OptionDef *options)
238 {
239  int idx = locate_option(argc, argv, options, "version");
240  if (hide_banner || idx)
241  return;
242 
246 }
247 
248 int show_version(void *optctx, const char *opt, const char *arg)
249 {
253 
254  return 0;
255 }
256 
257 int show_buildconf(void *optctx, const char *opt, const char *arg)
258 {
261 
262  return 0;
263 }
264 
265 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
266  if (codec->field) { \
267  const type *p = codec->field; \
268  \
269  printf(" Supported " list_name ":"); \
270  while (*p != term) { \
271  get_name(*p); \
272  printf(" %s", name); \
273  p++; \
274  } \
275  printf("\n"); \
276  } \
277 
278 static void print_codec(const AVCodec *c)
279 {
280  int encoder = av_codec_is_encoder(c);
281 
282  printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
283  c->long_name ? c->long_name : "");
284 
285  printf(" General capabilities: ");
286  if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
287  printf("horizband ");
288  if (c->capabilities & AV_CODEC_CAP_DR1)
289  printf("dr1 ");
290  if (c->capabilities & AV_CODEC_CAP_DELAY)
291  printf("delay ");
292  if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
293  printf("small ");
294  if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
295  printf("subframes ");
296  if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
297  printf("exp ");
298  if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
299  printf("chconf ");
300  if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
301  printf("paramchange ");
302  if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
303  printf("variable ");
304  if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
307  printf("threads ");
308  if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
309  printf("avoidprobe ");
310  if (c->capabilities & AV_CODEC_CAP_HARDWARE)
311  printf("hardware ");
312  if (c->capabilities & AV_CODEC_CAP_HYBRID)
313  printf("hybrid ");
314  if (!c->capabilities)
315  printf("none");
316  printf("\n");
317 
318  if (c->type == AVMEDIA_TYPE_VIDEO ||
319  c->type == AVMEDIA_TYPE_AUDIO) {
320  printf(" Threading capabilities: ");
321  switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
325  AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
326  case AV_CODEC_CAP_FRAME_THREADS: printf("frame"); break;
327  case AV_CODEC_CAP_SLICE_THREADS: printf("slice"); break;
328  case AV_CODEC_CAP_OTHER_THREADS: printf("other"); break;
329  default: printf("none"); break;
330  }
331  printf("\n");
332  }
333 
334  if (avcodec_get_hw_config(c, 0)) {
335  printf(" Supported hardware devices: ");
336  for (int i = 0;; i++) {
338  const char *name;
339  if (!config)
340  break;
341  name = av_hwdevice_get_type_name(config->device_type);
342  if (name)
343  printf("%s ", name);
344  }
345  printf("\n");
346  }
347 
348  if (c->supported_framerates) {
349  const AVRational *fps = c->supported_framerates;
350 
351  printf(" Supported framerates:");
352  while (fps->num) {
353  printf(" %d/%d", fps->num, fps->den);
354  fps++;
355  }
356  printf("\n");
357  }
358  PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
360  PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
362  PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
364 
365  if (c->ch_layouts) {
366  const AVChannelLayout *p = c->ch_layouts;
367 
368  printf(" Supported channel layouts:");
369  while (p->nb_channels) {
370  char name[128];
371  av_channel_layout_describe(p, name, sizeof(name));
372  printf(" %s", name);
373  p++;
374  }
375  printf("\n");
376  }
377 
378  if (c->priv_class) {
379  show_help_children(c->priv_class,
382  }
383 }
384 
385 static const AVCodec *next_codec_for_id(enum AVCodecID id, void **iter,
386  int encoder)
387 {
388  const AVCodec *c;
389  while ((c = av_codec_iterate(iter))) {
390  if (c->id == id &&
391  (encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
392  return c;
393  }
394  return NULL;
395 }
396 
397 static void show_help_codec(const char *name, int encoder)
398 {
399  const AVCodecDescriptor *desc;
400  const AVCodec *codec;
401 
402  if (!name) {
403  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
404  return;
405  }
406 
407  codec = encoder ? avcodec_find_encoder_by_name(name) :
409 
410  if (codec)
411  print_codec(codec);
412  else if ((desc = avcodec_descriptor_get_by_name(name))) {
413  void *iter = NULL;
414  int printed = 0;
415 
416  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
417  printed = 1;
418  print_codec(codec);
419  }
420 
421  if (!printed) {
422  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
423  "but no %s for it are available. FFmpeg might need to be "
424  "recompiled with additional external libraries.\n",
425  name, encoder ? "encoders" : "decoders");
426  }
427  } else {
428  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
429  name);
430  }
431 }
432 
433 static void show_help_demuxer(const char *name)
434 {
436 
437  if (!fmt) {
438  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
439  return;
440  }
441 
442  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
443 
444  if (fmt->extensions)
445  printf(" Common extensions: %s.\n", fmt->extensions);
446 
447  if (fmt->priv_class)
449 }
450 
451 static void show_help_protocol(const char *name)
452 {
453  const AVClass *proto_class;
454 
455  if (!name) {
456  av_log(NULL, AV_LOG_ERROR, "No protocol name specified.\n");
457  return;
458  }
459 
460  proto_class = avio_protocol_get_class(name);
461  if (!proto_class) {
462  av_log(NULL, AV_LOG_ERROR, "Unknown protocol '%s'.\n", name);
463  return;
464  }
465 
467 }
468 
469 static void show_help_muxer(const char *name)
470 {
471  const AVCodecDescriptor *desc;
472  const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
473 
474  if (!fmt) {
475  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
476  return;
477  }
478 
479  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
480 
481  if (fmt->extensions)
482  printf(" Common extensions: %s.\n", fmt->extensions);
483  if (fmt->mime_type)
484  printf(" Mime type: %s.\n", fmt->mime_type);
485  if (fmt->video_codec != AV_CODEC_ID_NONE &&
487  printf(" Default video codec: %s.\n", desc->name);
488  }
489  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
491  printf(" Default audio codec: %s.\n", desc->name);
492  }
493  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
495  printf(" Default subtitle codec: %s.\n", desc->name);
496  }
497 
498  if (fmt->priv_class)
500 }
501 
502 #if CONFIG_AVFILTER
503 static void show_help_filter(const char *name)
504 {
505 #if CONFIG_AVFILTER
507  int i, count;
508 
509  if (!name) {
510  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
511  return;
512  } else if (!f) {
513  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
514  return;
515  }
516 
517  printf("Filter %s\n", f->name);
518  if (f->description)
519  printf(" %s\n", f->description);
520 
521  if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
522  printf(" slice threading supported\n");
523 
524  printf(" Inputs:\n");
525  count = avfilter_filter_pad_count(f, 0);
526  for (i = 0; i < count; i++) {
527  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
529  }
530  if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
531  printf(" dynamic (depending on the options)\n");
532  else if (!count)
533  printf(" none (source filter)\n");
534 
535  printf(" Outputs:\n");
536  count = avfilter_filter_pad_count(f, 1);
537  for (i = 0; i < count; i++) {
538  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
540  }
541  if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
542  printf(" dynamic (depending on the options)\n");
543  else if (!count)
544  printf(" none (sink filter)\n");
545 
546  if (f->priv_class)
549  if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
550  printf("This filter has support for timeline through the 'enable' option.\n");
551 #else
552  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
553  "can not to satisfy request\n");
554 #endif
555 }
556 #endif
557 
558 static void show_help_bsf(const char *name)
559 {
561 
562  if (!name) {
563  av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
564  return;
565  } else if (!bsf) {
566  av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
567  return;
568  }
569 
570  printf("Bit stream filter %s\n", bsf->name);
571  PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
573  if (bsf->priv_class)
575 }
576 
577 int show_help(void *optctx, const char *opt, const char *arg)
578 {
579  char *topic, *par;
581 
582  topic = av_strdup(arg ? arg : "");
583  if (!topic)
584  return AVERROR(ENOMEM);
585  par = strchr(topic, '=');
586  if (par)
587  *par++ = 0;
588 
589  if (!*topic) {
590  show_help_default(topic, par);
591  } else if (!strcmp(topic, "decoder")) {
592  show_help_codec(par, 0);
593  } else if (!strcmp(topic, "encoder")) {
594  show_help_codec(par, 1);
595  } else if (!strcmp(topic, "demuxer")) {
596  show_help_demuxer(par);
597  } else if (!strcmp(topic, "muxer")) {
598  show_help_muxer(par);
599  } else if (!strcmp(topic, "protocol")) {
600  show_help_protocol(par);
601 #if CONFIG_AVFILTER
602  } else if (!strcmp(topic, "filter")) {
603  show_help_filter(par);
604 #endif
605  } else if (!strcmp(topic, "bsf")) {
606  show_help_bsf(par);
607  } else {
608  show_help_default(topic, par);
609  }
610 
611  av_freep(&topic);
612  return 0;
613 }
614 
615 static void print_codecs_for_id(enum AVCodecID id, int encoder)
616 {
617  void *iter = NULL;
618  const AVCodec *codec;
619 
620  printf(" (%s: ", encoder ? "encoders" : "decoders");
621 
622  while ((codec = next_codec_for_id(id, &iter, encoder)))
623  printf("%s ", codec->name);
624 
625  printf(")");
626 }
627 
628 static int compare_codec_desc(const void *a, const void *b)
629 {
630  const AVCodecDescriptor * const *da = a;
631  const AVCodecDescriptor * const *db = b;
632 
633  return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
634  strcmp((*da)->name, (*db)->name);
635 }
636 
637 static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
638 {
639  const AVCodecDescriptor *desc = NULL;
640  const AVCodecDescriptor **codecs;
641  unsigned nb_codecs = 0, i = 0;
642 
643  while ((desc = avcodec_descriptor_next(desc)))
644  nb_codecs++;
645  if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs))))
646  report_and_exit(AVERROR(ENOMEM));
647  desc = NULL;
648  while ((desc = avcodec_descriptor_next(desc)))
649  codecs[i++] = desc;
650  av_assert0(i == nb_codecs);
651  qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
652  *rcodecs = codecs;
653  return nb_codecs;
654 }
655 
657 {
658  switch (type) {
659  case AVMEDIA_TYPE_VIDEO: return 'V';
660  case AVMEDIA_TYPE_AUDIO: return 'A';
661  case AVMEDIA_TYPE_DATA: return 'D';
662  case AVMEDIA_TYPE_SUBTITLE: return 'S';
663  case AVMEDIA_TYPE_ATTACHMENT:return 'T';
664  default: return '?';
665  }
666 }
667 
668 int show_codecs(void *optctx, const char *opt, const char *arg)
669 {
670  const AVCodecDescriptor **codecs;
671  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
672 
673  printf("Codecs:\n"
674  " D..... = Decoding supported\n"
675  " .E.... = Encoding supported\n"
676  " ..V... = Video codec\n"
677  " ..A... = Audio codec\n"
678  " ..S... = Subtitle codec\n"
679  " ..D... = Data codec\n"
680  " ..T... = Attachment codec\n"
681  " ...I.. = Intra frame-only codec\n"
682  " ....L. = Lossy compression\n"
683  " .....S = Lossless compression\n"
684  " -------\n");
685  for (i = 0; i < nb_codecs; i++) {
686  const AVCodecDescriptor *desc = codecs[i];
687  const AVCodec *codec;
688  void *iter = NULL;
689 
690  if (strstr(desc->name, "_deprecated"))
691  continue;
692 
693  printf(" ");
694  printf(avcodec_find_decoder(desc->id) ? "D" : ".");
695  printf(avcodec_find_encoder(desc->id) ? "E" : ".");
696 
697  printf("%c", get_media_type_char(desc->type));
698  printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
699  printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
700  printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
701 
702  printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
703 
704  /* print decoders/encoders when there's more than one or their
705  * names are different from codec name */
706  while ((codec = next_codec_for_id(desc->id, &iter, 0))) {
707  if (strcmp(codec->name, desc->name)) {
708  print_codecs_for_id(desc->id, 0);
709  break;
710  }
711  }
712  iter = NULL;
713  while ((codec = next_codec_for_id(desc->id, &iter, 1))) {
714  if (strcmp(codec->name, desc->name)) {
715  print_codecs_for_id(desc->id, 1);
716  break;
717  }
718  }
719 
720  printf("\n");
721  }
722  av_free(codecs);
723  return 0;
724 }
725 
726 static void print_codecs(int encoder)
727 {
728  const AVCodecDescriptor **codecs;
729  unsigned i, nb_codecs = get_codecs_sorted(&codecs);
730 
731  printf("%s:\n"
732  " V..... = Video\n"
733  " A..... = Audio\n"
734  " S..... = Subtitle\n"
735  " .F.... = Frame-level multithreading\n"
736  " ..S... = Slice-level multithreading\n"
737  " ...X.. = Codec is experimental\n"
738  " ....B. = Supports draw_horiz_band\n"
739  " .....D = Supports direct rendering method 1\n"
740  " ------\n",
741  encoder ? "Encoders" : "Decoders");
742  for (i = 0; i < nb_codecs; i++) {
743  const AVCodecDescriptor *desc = codecs[i];
744  const AVCodec *codec;
745  void *iter = NULL;
746 
747  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
748  printf(" %c", get_media_type_char(desc->type));
749  printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
750  printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
751  printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ? "X" : ".");
752  printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
753  printf((codec->capabilities & AV_CODEC_CAP_DR1) ? "D" : ".");
754 
755  printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
756  if (strcmp(codec->name, desc->name))
757  printf(" (codec %s)", desc->name);
758 
759  printf("\n");
760  }
761  }
762  av_free(codecs);
763 }
764 
765 int show_decoders(void *optctx, const char *opt, const char *arg)
766 {
767  print_codecs(0);
768  return 0;
769 }
770 
771 int show_encoders(void *optctx, const char *opt, const char *arg)
772 {
773  print_codecs(1);
774  return 0;
775 }
776 
777 int show_bsfs(void *optctx, const char *opt, const char *arg)
778 {
779  const AVBitStreamFilter *bsf = NULL;
780  void *opaque = NULL;
781 
782  printf("Bitstream filters:\n");
783  while ((bsf = av_bsf_iterate(&opaque)))
784  printf("%s\n", bsf->name);
785  printf("\n");
786  return 0;
787 }
788 
789 int show_filters(void *optctx, const char *opt, const char *arg)
790 {
791 #if CONFIG_AVFILTER
792  const AVFilter *filter = NULL;
793  char descr[64], *descr_cur;
794  void *opaque = NULL;
795  int i, j;
796  const AVFilterPad *pad;
797 
798  printf("Filters:\n"
799  " T.. = Timeline support\n"
800  " .S. = Slice threading\n"
801  " ..C = Command support\n"
802  " A = Audio input/output\n"
803  " V = Video input/output\n"
804  " N = Dynamic number and/or type of input/output\n"
805  " | = Source or sink filter\n");
806  while ((filter = av_filter_iterate(&opaque))) {
807  descr_cur = descr;
808  for (i = 0; i < 2; i++) {
809  unsigned nb_pads;
810  if (i) {
811  *(descr_cur++) = '-';
812  *(descr_cur++) = '>';
813  }
814  pad = i ? filter->outputs : filter->inputs;
815  nb_pads = avfilter_filter_pad_count(filter, i);
816  for (j = 0; j < nb_pads; j++) {
817  if (descr_cur >= descr + sizeof(descr) - 4)
818  break;
819  *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
820  }
821  if (!j)
822  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
823  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
824  }
825  *descr_cur = 0;
826  printf(" %c%c%c %-17s %-10s %s\n",
827  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
828  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
829  filter->process_command ? 'C' : '.',
830  filter->name, descr, filter->description);
831  }
832 #else
833  printf("No filters available: libavfilter disabled\n");
834 #endif
835  return 0;
836 }
837 
838 static int is_device(const AVClass *avclass)
839 {
840  if (!avclass)
841  return 0;
842  return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
843 }
844 
845 static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
846 {
847  void *ifmt_opaque = NULL;
848  const AVInputFormat *ifmt = NULL;
849  void *ofmt_opaque = NULL;
850  const AVOutputFormat *ofmt = NULL;
851  const char *last_name;
852  int is_dev;
853 
854  printf("%s\n"
855  " D. = Demuxing supported\n"
856  " .E = Muxing supported\n"
857  " --\n", device_only ? "Devices:" : "File formats:");
858  last_name = "000";
859  for (;;) {
860  int decode = 0;
861  int encode = 0;
862  const char *name = NULL;
863  const char *long_name = NULL;
864 
865  if (muxdemuxers !=SHOW_DEMUXERS) {
866  ofmt_opaque = NULL;
867  while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
868  is_dev = is_device(ofmt->priv_class);
869  if (!is_dev && device_only)
870  continue;
871  if ((!name || strcmp(ofmt->name, name) < 0) &&
872  strcmp(ofmt->name, last_name) > 0) {
873  name = ofmt->name;
874  long_name = ofmt->long_name;
875  encode = 1;
876  }
877  }
878  }
879  if (muxdemuxers != SHOW_MUXERS) {
880  ifmt_opaque = NULL;
881  while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
882  is_dev = is_device(ifmt->priv_class);
883  if (!is_dev && device_only)
884  continue;
885  if ((!name || strcmp(ifmt->name, name) < 0) &&
886  strcmp(ifmt->name, last_name) > 0) {
887  name = ifmt->name;
888  long_name = ifmt->long_name;
889  encode = 0;
890  }
891  if (name && strcmp(ifmt->name, name) == 0)
892  decode = 1;
893  }
894  }
895  if (!name)
896  break;
897  last_name = name;
898 
899  printf(" %c%c %-15s %s\n",
900  decode ? 'D' : ' ',
901  encode ? 'E' : ' ',
902  name,
903  long_name ? long_name:" ");
904  }
905  return 0;
906 }
907 
908 int show_formats(void *optctx, const char *opt, const char *arg)
909 {
910  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
911 }
912 
913 int show_muxers(void *optctx, const char *opt, const char *arg)
914 {
915  return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
916 }
917 
918 int show_demuxers(void *optctx, const char *opt, const char *arg)
919 {
920  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
921 }
922 
923 int show_devices(void *optctx, const char *opt, const char *arg)
924 {
925  return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
926 }
927 
928 int show_protocols(void *optctx, const char *opt, const char *arg)
929 {
930  void *opaque = NULL;
931  const char *name;
932 
933  printf("Supported file protocols:\n"
934  "Input:\n");
935  while ((name = avio_enum_protocols(&opaque, 0)))
936  printf(" %s\n", name);
937  printf("Output:\n");
938  while ((name = avio_enum_protocols(&opaque, 1)))
939  printf(" %s\n", name);
940  return 0;
941 }
942 
943 int show_colors(void *optctx, const char *opt, const char *arg)
944 {
945  const char *name;
946  const uint8_t *rgb;
947  int i;
948 
949  printf("%-32s #RRGGBB\n", "name");
950 
951  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
952  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
953 
954  return 0;
955 }
956 
957 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
958 {
959  const AVPixFmtDescriptor *pix_desc = NULL;
960 
961  printf("Pixel formats:\n"
962  "I.... = Supported Input format for conversion\n"
963  ".O... = Supported Output format for conversion\n"
964  "..H.. = Hardware accelerated format\n"
965  "...P. = Paletted format\n"
966  "....B = Bitstream format\n"
967  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL BIT_DEPTHS\n"
968  "-----\n");
969 
970 #if !CONFIG_SWSCALE
971 # define sws_isSupportedInput(x) 0
972 # define sws_isSupportedOutput(x) 0
973 #endif
974 
975  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
977  printf("%c%c%c%c%c %-16s %d %3d %d",
978  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
979  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
980  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
981  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
982  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
983  pix_desc->name,
984  pix_desc->nb_components,
985  av_get_bits_per_pixel(pix_desc),
986  pix_desc->comp[0].depth);
987 
988  for (unsigned i = 1; i < pix_desc->nb_components; i++)
989  printf("-%d", pix_desc->comp[i].depth);
990  printf("\n");
991  }
992  return 0;
993 }
994 
995 int show_layouts(void *optctx, const char *opt, const char *arg)
996 {
997  const AVChannelLayout *ch_layout;
998  void *iter = NULL;
999  char buf[128], buf2[128];
1000  int i = 0;
1001 
1002  printf("Individual channels:\n"
1003  "NAME DESCRIPTION\n");
1004  for (i = 0; i < 63; i++) {
1005  av_channel_name(buf, sizeof(buf), i);
1006  if (strstr(buf, "USR"))
1007  continue;
1008  av_channel_description(buf2, sizeof(buf2), i);
1009  printf("%-14s %s\n", buf, buf2);
1010  }
1011  printf("\nStandard channel layouts:\n"
1012  "NAME DECOMPOSITION\n");
1013  while (ch_layout = av_channel_layout_standard(&iter)) {
1014  av_channel_layout_describe(ch_layout, buf, sizeof(buf));
1015  printf("%-14s ", buf);
1016  for (i = 0; i < 63; i++) {
1017  int idx = av_channel_layout_index_from_channel(ch_layout, i);
1018  if (idx >= 0) {
1019  av_channel_name(buf2, sizeof(buf2), i);
1020  printf("%s%s", idx ? "+" : "", buf2);
1021  }
1022  }
1023  printf("\n");
1024  }
1025  return 0;
1026 }
1027 
1028 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1029 {
1030  int i;
1031  char fmt_str[128];
1032  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1033  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1034  return 0;
1035 }
1036 
1037 int show_dispositions(void *optctx, const char *opt, const char *arg)
1038 {
1039  for (int i = 0; i < 32; i++) {
1040  const char *str = av_disposition_to_string(1U << i);
1041  if (str)
1042  printf("%s\n", str);
1043  }
1044  return 0;
1045 }
1046 
1047 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1048 {
1049  int ret;
1050  unsigned flags = av_get_cpu_flags();
1051 
1052  if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
1053  return ret;
1054 
1056  return 0;
1057 }
1058 
1059 int opt_cpucount(void *optctx, const char *opt, const char *arg)
1060 {
1061  int ret;
1062  int count;
1063 
1064  static const AVOption opts[] = {
1065  {"count", NULL, 0, AV_OPT_TYPE_INT, { .i64 = -1}, -1, INT_MAX},
1066  {NULL},
1067  };
1068  static const AVClass class = {
1069  .class_name = "cpucount",
1070  .item_name = av_default_item_name,
1071  .option = opts,
1072  .version = LIBAVUTIL_VERSION_INT,
1073  };
1074  const AVClass *pclass = &class;
1075 
1076  ret = av_opt_eval_int(&pclass, opts, arg, &count);
1077 
1078  if (!ret) {
1079  av_cpu_force_count(count);
1080  }
1081 
1082  return ret;
1083 }
1084 
1085 static void expand_filename_template(AVBPrint *bp, const char *template,
1086  struct tm *tm)
1087 {
1088  int c;
1089 
1090  while ((c = *(template++))) {
1091  if (c == '%') {
1092  if (!(c = *(template++)))
1093  break;
1094  switch (c) {
1095  case 'p':
1096  av_bprintf(bp, "%s", program_name);
1097  break;
1098  case 't':
1099  av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
1100  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1101  tm->tm_hour, tm->tm_min, tm->tm_sec);
1102  break;
1103  case '%':
1104  av_bprint_chars(bp, c, 1);
1105  break;
1106  }
1107  } else {
1108  av_bprint_chars(bp, c, 1);
1109  }
1110  }
1111 }
1112 
1113 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
1114 {
1115  va_list vl2;
1116  char line[1024];
1117  static int print_prefix = 1;
1118 
1119  va_copy(vl2, vl);
1120  av_log_default_callback(ptr, level, fmt, vl);
1121  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
1122  va_end(vl2);
1123  if (report_file_level >= level) {
1124  fputs(line, report_file);
1125  fflush(report_file);
1126  }
1127 }
1128 
1129 int init_report(const char *env, FILE **file)
1130 {
1131  char *filename_template = NULL;
1132  char *key, *val;
1133  int ret, count = 0;
1134  int prog_loglevel, envlevel = 0;
1135  time_t now;
1136  struct tm *tm;
1137  AVBPrint filename;
1138 
1139  if (report_file) /* already opened */
1140  return 0;
1141  time(&now);
1142  tm = localtime(&now);
1143 
1144  while (env && *env) {
1145  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
1146  if (count)
1148  "Failed to parse FFREPORT environment variable: %s\n",
1149  av_err2str(ret));
1150  break;
1151  }
1152  if (*env)
1153  env++;
1154  count++;
1155  if (!strcmp(key, "file")) {
1156  av_free(filename_template);
1157  filename_template = val;
1158  val = NULL;
1159  } else if (!strcmp(key, "level")) {
1160  char *tail;
1161  report_file_level = strtol(val, &tail, 10);
1162  if (*tail) {
1163  av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1164  exit_program(1);
1165  }
1166  envlevel = 1;
1167  } else {
1168  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1169  }
1170  av_free(val);
1171  av_free(key);
1172  }
1173 
1175  expand_filename_template(&filename,
1176  av_x_if_null(filename_template, "%p-%t.log"), tm);
1177  av_free(filename_template);
1178  if (!av_bprint_is_complete(&filename)) {
1179  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1180  return AVERROR(ENOMEM);
1181  }
1182 
1183  prog_loglevel = av_log_get_level();
1184  if (!envlevel)
1185  report_file_level = FFMAX(report_file_level, prog_loglevel);
1186 
1187  report_file = fopen(filename.str, "w");
1188  if (!report_file) {
1189  int ret = AVERROR(errno);
1190  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1191  filename.str, strerror(errno));
1192  return ret;
1193  }
1196  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1197  "Report written to \"%s\"\n"
1198  "Log level: %d\n",
1199  program_name,
1200  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1201  tm->tm_hour, tm->tm_min, tm->tm_sec,
1202  filename.str, report_file_level);
1203  av_bprint_finalize(&filename, NULL);
1204 
1205  if (file)
1206  *file = report_file;
1207 
1208  return 0;
1209 }
1210 
1211 int opt_report(void *optctx, const char *opt, const char *arg)
1212 {
1213  return init_report(NULL, NULL);
1214 }
1215 
1216 int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1217 {
1218  char *tail;
1219  size_t max;
1220 
1221  max = strtol(arg, &tail, 10);
1222  if (*tail) {
1223  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1224  exit_program(1);
1225  }
1226  av_max_alloc(max);
1227  return 0;
1228 }
1229 
1230 int opt_loglevel(void *optctx, const char *opt, const char *arg)
1231 {
1232  const struct { const char *name; int level; } log_levels[] = {
1233  { "quiet" , AV_LOG_QUIET },
1234  { "panic" , AV_LOG_PANIC },
1235  { "fatal" , AV_LOG_FATAL },
1236  { "error" , AV_LOG_ERROR },
1237  { "warning", AV_LOG_WARNING },
1238  { "info" , AV_LOG_INFO },
1239  { "verbose", AV_LOG_VERBOSE },
1240  { "debug" , AV_LOG_DEBUG },
1241  { "trace" , AV_LOG_TRACE },
1242  };
1243  const char *token;
1244  char *tail;
1245  int flags = av_log_get_flags();
1246  int level = av_log_get_level();
1247  int cmd, i = 0;
1248 
1249  av_assert0(arg);
1250  while (*arg) {
1251  token = arg;
1252  if (*token == '+' || *token == '-') {
1253  cmd = *token++;
1254  } else {
1255  cmd = 0;
1256  }
1257  if (!i && !cmd) {
1258  flags = 0; /* missing relative prefix, build absolute value */
1259  }
1260  if (av_strstart(token, "repeat", &arg)) {
1261  if (cmd == '-') {
1263  } else {
1265  }
1266  } else if (av_strstart(token, "level", &arg)) {
1267  if (cmd == '-') {
1269  } else {
1271  }
1272  } else {
1273  break;
1274  }
1275  i++;
1276  }
1277  if (!*arg) {
1278  goto end;
1279  } else if (*arg == '+') {
1280  arg++;
1281  } else if (!i) {
1282  flags = av_log_get_flags(); /* level value without prefix, reset flags */
1283  }
1284 
1285  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
1286  if (!strcmp(log_levels[i].name, arg)) {
1287  level = log_levels[i].level;
1288  goto end;
1289  }
1290  }
1291 
1292  level = strtol(arg, &tail, 10);
1293  if (*tail) {
1294  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
1295  "Possible levels are numbers or:\n", arg);
1296  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
1297  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
1298  exit_program(1);
1299  }
1300 
1301 end:
1304  return 0;
1305 }
1306 
1307 #if CONFIG_AVDEVICE
1308 static void print_device_list(const AVDeviceInfoList *device_list)
1309 {
1310  // print devices
1311  for (int i = 0; i < device_list->nb_devices; i++) {
1312  const AVDeviceInfo *device = device_list->devices[i];
1313  printf("%c %s [%s] (", device_list->default_device == i ? '*' : ' ',
1314  device->device_name, device->device_description);
1315  if (device->nb_media_types > 0) {
1316  for (int j = 0; j < device->nb_media_types; ++j) {
1317  const char* media_type = av_get_media_type_string(device->media_types[j]);
1318  if (j > 0)
1319  printf(", ");
1320  printf("%s", media_type ? media_type : "unknown");
1321  }
1322  } else {
1323  printf("none");
1324  }
1325  printf(")\n");
1326  }
1327 }
1328 
1329 static int print_device_sources(const AVInputFormat *fmt, AVDictionary *opts)
1330 {
1331  int ret;
1332  AVDeviceInfoList *device_list = NULL;
1333 
1334  if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
1335  return AVERROR(EINVAL);
1336 
1337  printf("Auto-detected sources for %s:\n", fmt->name);
1338  if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
1339  printf("Cannot list sources: %s\n", av_err2str(ret));
1340  goto fail;
1341  }
1342 
1343  print_device_list(device_list);
1344 
1345  fail:
1346  avdevice_free_list_devices(&device_list);
1347  return ret;
1348 }
1349 
1350 static int print_device_sinks(const AVOutputFormat *fmt, AVDictionary *opts)
1351 {
1352  int ret;
1353  AVDeviceInfoList *device_list = NULL;
1354 
1355  if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
1356  return AVERROR(EINVAL);
1357 
1358  printf("Auto-detected sinks for %s:\n", fmt->name);
1359  if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
1360  printf("Cannot list sinks: %s\n", av_err2str(ret));
1361  goto fail;
1362  }
1363 
1364  print_device_list(device_list);
1365 
1366  fail:
1367  avdevice_free_list_devices(&device_list);
1368  return ret;
1369 }
1370 
1371 static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
1372 {
1373  int ret;
1374  if (arg) {
1375  char *opts_str = NULL;
1376  av_assert0(dev && opts);
1377  *dev = av_strdup(arg);
1378  if (!*dev)
1379  return AVERROR(ENOMEM);
1380  if ((opts_str = strchr(*dev, ','))) {
1381  *(opts_str++) = '\0';
1382  if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
1383  av_freep(dev);
1384  return ret;
1385  }
1386  }
1387  } else
1388  printf("\nDevice name is not provided.\n"
1389  "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
1390  return 0;
1391 }
1392 
1393 int show_sources(void *optctx, const char *opt, const char *arg)
1394 {
1395  const AVInputFormat *fmt = NULL;
1396  char *dev = NULL;
1397  AVDictionary *opts = NULL;
1398  int ret = 0;
1399  int error_level = av_log_get_level();
1400 
1402 
1403  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1404  goto fail;
1405 
1406  do {
1407  fmt = av_input_audio_device_next(fmt);
1408  if (fmt) {
1409  if (!strcmp(fmt->name, "lavfi"))
1410  continue; //it's pointless to probe lavfi
1411  if (dev && !av_match_name(dev, fmt->name))
1412  continue;
1413  print_device_sources(fmt, opts);
1414  }
1415  } while (fmt);
1416  do {
1417  fmt = av_input_video_device_next(fmt);
1418  if (fmt) {
1419  if (dev && !av_match_name(dev, fmt->name))
1420  continue;
1421  print_device_sources(fmt, opts);
1422  }
1423  } while (fmt);
1424  fail:
1425  av_dict_free(&opts);
1426  av_free(dev);
1427  av_log_set_level(error_level);
1428  return ret;
1429 }
1430 
1431 int show_sinks(void *optctx, const char *opt, const char *arg)
1432 {
1433  const AVOutputFormat *fmt = NULL;
1434  char *dev = NULL;
1435  AVDictionary *opts = NULL;
1436  int ret = 0;
1437  int error_level = av_log_get_level();
1438 
1440 
1441  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1442  goto fail;
1443 
1444  do {
1445  fmt = av_output_audio_device_next(fmt);
1446  if (fmt) {
1447  if (dev && !av_match_name(dev, fmt->name))
1448  continue;
1449  print_device_sinks(fmt, opts);
1450  }
1451  } while (fmt);
1452  do {
1453  fmt = av_output_video_device_next(fmt);
1454  if (fmt) {
1455  if (dev && !av_match_name(dev, fmt->name))
1456  continue;
1457  print_device_sinks(fmt, opts);
1458  }
1459  } while (fmt);
1460  fail:
1461  av_dict_free(&opts);
1462  av_free(dev);
1463  av_log_set_level(error_level);
1464  return ret;
1465 }
1466 #endif /* CONFIG_AVDEVICE */
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: opt_common.c:918
av_force_cpu_flags
void av_force_cpu_flags(int arg)
Disables cpu detection and forces the specified flags.
Definition: cpu.c:75
AVCodec
AVCodec.
Definition: codec.h:204
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:1133
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:186
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
level
uint8_t level
Definition: svq3.c:204
avfilter_filter_pad_count
unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
Get the number of elements in an AVFilter's inputs or outputs array.
Definition: avfilter.c:584
AVOutputFormat::extensions
const char * extensions
comma-separated filename extensions
Definition: avformat.h:518
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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:215
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
avio_protocol_get_class
const AVClass * avio_protocol_get_class(const char *name)
Get AVClass by names of available protocols.
Definition: protocols.c:110
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:284
GET_SAMPLE_RATE_NAME
#define GET_SAMPLE_RATE_NAME(rate)
Definition: cmdutils.h:457
AV_IS_INPUT_DEVICE
#define AV_IS_INPUT_DEVICE(category)
Definition: log.h:49
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:963
AVCodec::long_name
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:216
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: opt_common.c:789
sws_isSupportedOutput
#define sws_isSupportedOutput(x)
AV_CODEC_PROP_LOSSY
#define AV_CODEC_PROP_LOSSY
Codec supports lossy compression.
Definition: codec_desc.h:78
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:95
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
av_cpu_force_count
void av_cpu_force_count(int count)
Overrides cpu count detection and forces the specified count.
Definition: cpu.c:260
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:162
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:947
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:162
AV_LOG_PANIC
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:167
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:464
print_program_info
static void print_program_info(int flags, int level)
Definition: opt_common.c:197
version.h
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
codecs
static struct codec_string codecs[]
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:111
av_unused
#define av_unused
Definition: attributes.h:131
is_device
static int is_device(const AVClass *avclass)
Definition: opt_common.c:838
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:475
GET_PIX_FMT_NAME
#define GET_PIX_FMT_NAME(pix_fmt)
Definition: cmdutils.h:448
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:946
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: opt_common.c:923
log_callback_report
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
Definition: opt_common.c:1113
show_formats_devices
static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
Definition: opt_common.c:845
pixdesc.h
SHOW_CONFIG
#define SHOW_CONFIG
Definition: opt_common.c:153
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:223
init_report
int init_report(const char *env, FILE **file)
Definition: opt_common.c:1129
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:334
opt_report
int opt_report(void *optctx, const char *opt, const char *arg)
Definition: opt_common.c:1211
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:70
show_muxdemuxers
show_muxdemuxers
Definition: opt_common.c:66
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
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:2865
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: opt_common.c:957
avio_enum_protocols
const char * avio_enum_protocols(void **opaque, int output)
Iterate through names of available protocols.
Definition: protocols.c:95
print_codecs_for_id
static void print_codecs_for_id(enum AVCodecID id, int encoder)
Definition: opt_common.c:615
version.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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:169
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:2810
get_media_type_char
static char get_media_type_char(enum AVMediaType type)
Definition: opt_common.c:656
max
#define max(a, b)
Definition: cuda_runtime.h:33
show_buildconf
int show_buildconf(void *optctx, const char *opt, const char *arg)
Print the build configuration of the program to stdout.
Definition: opt_common.c:257
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:32
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
show_dispositions
int show_dispositions(void *optctx, const char *opt, const char *arg)
Print a listing containing all supported stream dispositions.
Definition: opt_common.c:1037
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:103
hide_banner
int hide_banner
Definition: cmdutils.c:62
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
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:297
tf_sess_config.config
config
Definition: tf_sess_config.py:33
SHOW_MUXERS
@ SHOW_MUXERS
Definition: opt_common.c:69
show_license
int show_license(void *optctx, const char *opt, const char *arg)
Print the license of the program to stdout.
Definition: opt_common.c:75
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:522
av_input_audio_device_next
const AVInputFormat * av_input_audio_device_next(const AVInputFormat *d)
Audio input devices iterator.
Definition: alldevices.c:121
OptionDef
Definition: cmdutils.h:146
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:668
avdevice_list_output_sinks
int avdevice_list_output_sinks(const AVOutputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
Definition: avdevice.c:112
exit_program
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:99
SHOW_DEMUXERS
@ SHOW_DEMUXERS
Definition: opt_common.c:68
av_max_alloc
void av_max_alloc(size_t max)
Set the maximum size that may be allocated in one block.
Definition: mem.c:74
rgb
Definition: rpzaenc.c:59
bsf.h
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: opt_common.c:771
report_and_exit
void report_and_exit(int ret)
Reports an error corresponding to the provided AVERROR code and calls exit_program() with the corresp...
Definition: cmdutils.c:93
fail
#define fail()
Definition: checkasm.h:134
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:590
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:113
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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
report_file_level
static int report_file_level
Definition: opt_common.c:73
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:116
show_version
int show_version(void *optctx, const char *opt, const char *arg)
Print the version of the program to stdout.
Definition: opt_common.c:248
codec.h
AVRational::num
int num
Numerator.
Definition: rational.h:59
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: opt_common.c:668
show_help_muxer
static void show_help_muxer(const char *name)
Definition: opt_common.c:469
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:474
next_codec_for_id
static const AVCodec * next_codec_for_id(enum AVCodecID id, void **iter, int encoder)
Definition: opt_common.c:385
avassert.h
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:105
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:656
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:682
avdevice_list_input_sources
int avdevice_list_input_sources(const AVInputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:101
postprocess.h
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:778
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:330
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
report_file
static FILE * report_file
Definition: opt_common.c:72
compare_codec_desc
static int compare_codec_desc(const void *a, const void *b)
Definition: opt_common.c:628
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
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:281
PRINT_LIB_INFO
#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)
Definition: opt_common.c:156
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:127
AVOutputFormat::audio_codec
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:520
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_channel_layout_standard
const AVChannelLayout * av_channel_layout_standard(void **opaque)
Iterate over all standard channel layouts.
Definition: channel_layout.c:975
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
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: opt_common.c:777
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
print_codecs
static void print_codecs(int encoder)
Definition: opt_common.c:726
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: opt_common.c:237
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:93
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:295
key
const char * key
Definition: hwcontext_opencl.c:174
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AVDeviceInfo::media_types
enum AVMediaType * media_types
array indicating what media types(s), if any, a device can provide.
Definition: avdevice.h:466
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:283
arg
const char * arg
Definition: jacosubdec.c:67
AVDeviceInfo::nb_media_types
int nb_media_types
length of media_types array, 0 if device cannot provide any media types
Definition: avdevice.h:467
AV_IS_OUTPUT_DEVICE
#define AV_IS_OUTPUT_DEVICE(category)
Definition: log.h:54
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:437
print_codec
static void print_codec(const AVCodec *c)
Definition: opt_common.c:278
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:601
opts
AVDictionary * opts
Definition: movenc.c:50
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:979
print_all_libs_info
static void print_all_libs_info(int flags, int level)
Definition: opt_common.c:185
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
version.h
AVOutputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:516
GET_CODEC_NAME
#define GET_CODEC_NAME(id)
Definition: cmdutils.h:451
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:447
parseutils.h
opt_loglevel
int opt_loglevel(void *optctx, const char *opt, const char *arg)
Set the libav* libraries log level.
Definition: opt_common.c:1230
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: bsf.h:130
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: codec.h:134
warned_cfg
static int warned_cfg
Definition: opt_common.c:149
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:538
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
swresample.h
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
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: opt_common.c:1028
error.h
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:951
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:122
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
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: opt_common.c:995
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:415
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:83
options
const OptionDef options[]
f
f
Definition: af_crystalizer.c:122
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_SAMPLE_FMT_NB
@ AV_SAMPLE_FMT_NB
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:71
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:457
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:301
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:114
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:121
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
av_output_video_device_next
const AVOutputFormat * av_output_video_device_next(const AVOutputFormat *d)
Video output devices iterator.
Definition: alldevices.c:136
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:124
AVDeviceInfo
Structure describes basic parameters of the device.
Definition: avdevice.h:463
GET_SAMPLE_FMT_NAME
#define GET_SAMPLE_FMT_NAME(sample_fmt)
Definition: cmdutils.h:454
PRINT_CODEC_SUPPORTED
#define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name)
Definition: opt_common.c:265
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:579
printf
printf("static const uint8_t my_array[100] = {\n")
av_log_get_flags
int av_log_get_flags(void)
Definition: log.c:452
avdevice.h
avdevice_free_list_devices
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:123
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: opt_common.c:928
av_channel_description
int av_channel_description(char *buf, size_t buf_size, enum AVChannel channel_id)
Get a human readable string describing a given channel.
Definition: channel_layout.c:128
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:94
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
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: opt_common.c:765
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
line
Definition: graph2dot.c:48
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2877
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:223
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:37
va_copy
#define va_copy(dst, src)
Definition: va_copy.h:31
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:465
show_help_bsf
static void show_help_bsf(const char *name)
Definition: opt_common.c:558
sws_isSupportedInput
#define sws_isSupportedInput(x)
AVOutputFormat::mime_type
const char * mime_type
Definition: avformat.h:517
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
avcodec_descriptor_next
const AVCodecDescriptor * avcodec_descriptor_next(const AVCodecDescriptor *prev)
Iterate over all codec descriptors known to libavcodec.
Definition: codec_desc.c:3623
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:75
AV_CODEC_PROP_LOSSLESS
#define AV_CODEC_PROP_LOSSLESS
Codec supports lossless compression.
Definition: codec_desc.h:82
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:442
bprint.h
INDENT
#define INDENT
Definition: opt_common.c:151
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: opt_common.c:943
SHOW_VERSION
#define SHOW_VERSION
Definition: opt_common.c:152
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_channel_name
int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel_id)
Get a human readable string in an abbreviated form describing a given channel.
Definition: channel_layout.c:101
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
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:282
show_help_demuxer
static void show_help_demuxer(const char *name)
Definition: opt_common.c:433
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
opt_max_alloc
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
Definition: opt_common.c:1216
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:902
show_help_protocol
static void show_help_protocol(const char *name)
Definition: opt_common.c:451
avcodec.h
AVFilter
Filter definition.
Definition: avfilter.h:171
version.h
version.h
version.h
get_codecs_sorted
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
Definition: opt_common.c:637
ret
ret
Definition: filter_design.txt:187
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
av_bsf_iterate
const AVBitStreamFilter * av_bsf_iterate(void **opaque)
Iterate over all registered bitstream filters.
Definition: bitstream_filters.c:70
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
av_opt_eval_int
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
AVDeviceInfoList
List of devices.
Definition: avdevice.h:473
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:72
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:1645
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: opt_common.c:913
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
dict.h
opt_cpucount
int opt_cpucount(void *optctx, const char *opt, const char *arg)
Override the cpucount.
Definition: opt_common.c:1059
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:370
U
#define U(x)
Definition: vpx_arith.h:37
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:968
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:560
AVDeviceInfoList::default_device
int default_device
index of default device or -1 if no default
Definition: avdevice.h:476
channel_layout.h
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: opt_common.c:908
AVBitStreamFilter
Definition: bsf.h:111
av_channel_layout_index_from_channel
int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout, enum AVChannel channel)
Get the index of a given channel in a channel layout.
Definition: channel_layout.c:836
opt_common.h
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
version.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:356
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:200
print_buildconf
static void print_buildconf(int flags, int level)
Definition: opt_common.c:211
opt_cpuflags
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
Override the cpuflags.
Definition: opt_common.c:1047
swscale
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[], int dstSliceY, int dstSliceH)
Definition: swscale.c:234
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:521
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: codec.h:82
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:120
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:873
SHOW_DEFAULT
@ SHOW_DEFAULT
Definition: opt_common.c:67
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:121
expand_filename_template
static void expand_filename_template(AVBPrint *bp, const char *template, struct tm *tm)
Definition: opt_common.c:1085
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:127
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:348
av_guess_format
const 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:53
mem.h
av_output_audio_device_next
const AVOutputFormat * av_output_audio_device_next(const AVOutputFormat *d)
Audio output devices iterator.
Definition: alldevices.c:131
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: codec.h:100
codec_ids
static enum AVCodecID codec_ids[]
Definition: aac_adtstoasc_bsf.c:148
AV_CODEC_CAP_HYBRID
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: codec.h:169
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:436
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
SHOW_COPYRIGHT
#define SHOW_COPYRIGHT
Definition: opt_common.c:154
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
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:165
show_help_codec
static void show_help_codec(const char *name, int encoder)
Definition: opt_common.c:397
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
cmdutils.h
convert_header.str
string str
Definition: convert_header.py:20
show_help
int show_help(void *optctx, const char *opt, const char *arg)
Generic -h handler common to all fftools.
Definition: opt_common.c:577
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
rgb
static const SheerTable rgb[2]
Definition: sheervideodata.h:32
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:144
AVCodecHWConfig
Definition: codec.h:358
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
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3617
av_input_video_device_next
const AVInputFormat * av_input_video_device_next(const AVInputFormat *d)
Video input devices iterator.
Definition: alldevices.c:126
avstring.h
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3632
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: codec.h:87
codec_desc.h
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:120
AV_LOG_PRINT_LEVEL
#define AV_LOG_PRINT_LEVEL
Include the log severity in messages originating from codecs.
Definition: log.h:378
swscale.h
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:686
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
version.h
avcodec_find_encoder_by_name
const AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:974
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:112
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:82