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_EXPERIMENTAL)
295  printf("exp ");
296  if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
297  printf("chconf ");
298  if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
299  printf("paramchange ");
300  if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
301  printf("variable ");
302  if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
305  printf("threads ");
306  if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
307  printf("avoidprobe ");
308  if (c->capabilities & AV_CODEC_CAP_HARDWARE)
309  printf("hardware ");
310  if (c->capabilities & AV_CODEC_CAP_HYBRID)
311  printf("hybrid ");
312  if (!c->capabilities)
313  printf("none");
314  printf("\n");
315 
316  if (c->type == AVMEDIA_TYPE_VIDEO ||
317  c->type == AVMEDIA_TYPE_AUDIO) {
318  printf(" Threading capabilities: ");
319  switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
323  AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
324  case AV_CODEC_CAP_FRAME_THREADS: printf("frame"); break;
325  case AV_CODEC_CAP_SLICE_THREADS: printf("slice"); break;
326  case AV_CODEC_CAP_OTHER_THREADS: printf("other"); break;
327  default: printf("none"); break;
328  }
329  printf("\n");
330  }
331 
332  if (avcodec_get_hw_config(c, 0)) {
333  printf(" Supported hardware devices: ");
334  for (int i = 0;; i++) {
336  const char *name;
337  if (!config)
338  break;
339  name = av_hwdevice_get_type_name(config->device_type);
340  if (name)
341  printf("%s ", name);
342  }
343  printf("\n");
344  }
345 
346  if (c->supported_framerates) {
347  const AVRational *fps = c->supported_framerates;
348 
349  printf(" Supported framerates:");
350  while (fps->num) {
351  printf(" %d/%d", fps->num, fps->den);
352  fps++;
353  }
354  printf("\n");
355  }
356  PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
358  PRINT_CODEC_SUPPORTED(c, supported_samplerates, int, "sample rates", 0,
360  PRINT_CODEC_SUPPORTED(c, sample_fmts, enum AVSampleFormat, "sample formats",
362 
363  if (c->ch_layouts) {
364  const AVChannelLayout *p = c->ch_layouts;
365 
366  printf(" Supported channel layouts:");
367  while (p->nb_channels) {
368  char name[128];
369  av_channel_layout_describe(p, name, sizeof(name));
370  printf(" %s", name);
371  p++;
372  }
373  printf("\n");
374  }
375 
376  if (c->priv_class) {
377  show_help_children(c->priv_class,
380  }
381 }
382 
383 static const AVCodec *next_codec_for_id(enum AVCodecID id, void **iter,
384  int encoder)
385 {
386  const AVCodec *c;
387  while ((c = av_codec_iterate(iter))) {
388  if (c->id == id &&
389  (encoder ? av_codec_is_encoder(c) : av_codec_is_decoder(c)))
390  return c;
391  }
392  return NULL;
393 }
394 
395 static void show_help_codec(const char *name, int encoder)
396 {
397  const AVCodecDescriptor *desc;
398  const AVCodec *codec;
399 
400  if (!name) {
401  av_log(NULL, AV_LOG_ERROR, "No codec name specified.\n");
402  return;
403  }
404 
405  codec = encoder ? avcodec_find_encoder_by_name(name) :
407 
408  if (codec)
409  print_codec(codec);
410  else if ((desc = avcodec_descriptor_get_by_name(name))) {
411  void *iter = NULL;
412  int printed = 0;
413 
414  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
415  printed = 1;
416  print_codec(codec);
417  }
418 
419  if (!printed) {
420  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
421  "but no %s for it are available. FFmpeg might need to be "
422  "recompiled with additional external libraries.\n",
423  name, encoder ? "encoders" : "decoders");
424  }
425  } else {
426  av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
427  name);
428  }
429 }
430 
431 static void show_help_demuxer(const char *name)
432 {
434 
435  if (!fmt) {
436  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
437  return;
438  }
439 
440  printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
441 
442  if (fmt->extensions)
443  printf(" Common extensions: %s.\n", fmt->extensions);
444 
445  if (fmt->priv_class)
447 }
448 
449 static void show_help_protocol(const char *name)
450 {
451  const AVClass *proto_class;
452 
453  if (!name) {
454  av_log(NULL, AV_LOG_ERROR, "No protocol name specified.\n");
455  return;
456  }
457 
458  proto_class = avio_protocol_get_class(name);
459  if (!proto_class) {
460  av_log(NULL, AV_LOG_ERROR, "Unknown protocol '%s'.\n", name);
461  return;
462  }
463 
465 }
466 
467 static void show_help_muxer(const char *name)
468 {
469  const AVCodecDescriptor *desc;
470  const AVOutputFormat *fmt = av_guess_format(name, NULL, NULL);
471 
472  if (!fmt) {
473  av_log(NULL, AV_LOG_ERROR, "Unknown format '%s'.\n", name);
474  return;
475  }
476 
477  printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
478 
479  if (fmt->extensions)
480  printf(" Common extensions: %s.\n", fmt->extensions);
481  if (fmt->mime_type)
482  printf(" Mime type: %s.\n", fmt->mime_type);
483  if (fmt->video_codec != AV_CODEC_ID_NONE &&
485  printf(" Default video codec: %s.\n", desc->name);
486  }
487  if (fmt->audio_codec != AV_CODEC_ID_NONE &&
489  printf(" Default audio codec: %s.\n", desc->name);
490  }
491  if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
493  printf(" Default subtitle codec: %s.\n", desc->name);
494  }
495 
496  if (fmt->priv_class)
498 }
499 
500 #if CONFIG_AVFILTER
501 static void show_help_filter(const char *name)
502 {
503 #if CONFIG_AVFILTER
505  int i, count;
506 
507  if (!name) {
508  av_log(NULL, AV_LOG_ERROR, "No filter name specified.\n");
509  return;
510  } else if (!f) {
511  av_log(NULL, AV_LOG_ERROR, "Unknown filter '%s'.\n", name);
512  return;
513  }
514 
515  printf("Filter %s\n", f->name);
516  if (f->description)
517  printf(" %s\n", f->description);
518 
519  if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
520  printf(" slice threading supported\n");
521 
522  printf(" Inputs:\n");
523  count = avfilter_filter_pad_count(f, 0);
524  for (i = 0; i < count; i++) {
525  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
527  }
528  if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
529  printf(" dynamic (depending on the options)\n");
530  else if (!count)
531  printf(" none (source filter)\n");
532 
533  printf(" Outputs:\n");
534  count = avfilter_filter_pad_count(f, 1);
535  for (i = 0; i < count; i++) {
536  printf(" #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
538  }
539  if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
540  printf(" dynamic (depending on the options)\n");
541  else if (!count)
542  printf(" none (sink filter)\n");
543 
544  if (f->priv_class)
547  if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
548  printf("This filter has support for timeline through the 'enable' option.\n");
549 #else
550  av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
551  "can not to satisfy request\n");
552 #endif
553 }
554 #endif
555 
556 static void show_help_bsf(const char *name)
557 {
559 
560  if (!name) {
561  av_log(NULL, AV_LOG_ERROR, "No bitstream filter name specified.\n");
562  return;
563  } else if (!bsf) {
564  av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
565  return;
566  }
567 
568  printf("Bit stream filter %s\n", bsf->name);
569  PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
571  if (bsf->priv_class)
573 }
574 
575 int show_help(void *optctx, const char *opt, const char *arg)
576 {
577  char *topic, *par;
579 
580  topic = av_strdup(arg ? arg : "");
581  if (!topic)
582  return AVERROR(ENOMEM);
583  par = strchr(topic, '=');
584  if (par)
585  *par++ = 0;
586 
587  if (!*topic) {
588  show_help_default(topic, par);
589  } else if (!strcmp(topic, "decoder")) {
590  show_help_codec(par, 0);
591  } else if (!strcmp(topic, "encoder")) {
592  show_help_codec(par, 1);
593  } else if (!strcmp(topic, "demuxer")) {
594  show_help_demuxer(par);
595  } else if (!strcmp(topic, "muxer")) {
596  show_help_muxer(par);
597  } else if (!strcmp(topic, "protocol")) {
598  show_help_protocol(par);
599 #if CONFIG_AVFILTER
600  } else if (!strcmp(topic, "filter")) {
601  show_help_filter(par);
602 #endif
603  } else if (!strcmp(topic, "bsf")) {
604  show_help_bsf(par);
605  } else {
606  show_help_default(topic, par);
607  }
608 
609  av_freep(&topic);
610  return 0;
611 }
612 
613 static void print_codecs_for_id(enum AVCodecID id, int encoder)
614 {
615  void *iter = NULL;
616  const AVCodec *codec;
617 
618  printf(" (%s:", encoder ? "encoders" : "decoders");
619 
620  while ((codec = next_codec_for_id(id, &iter, encoder)))
621  printf(" %s", codec->name);
622 
623  printf(")");
624 }
625 
626 static int compare_codec_desc(const void *a, const void *b)
627 {
628  const AVCodecDescriptor * const *da = a;
629  const AVCodecDescriptor * const *db = b;
630 
631  return (*da)->type != (*db)->type ? FFDIFFSIGN((*da)->type, (*db)->type) :
632  strcmp((*da)->name, (*db)->name);
633 }
634 
635 static int get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
636 {
637  const AVCodecDescriptor *desc = NULL;
638  const AVCodecDescriptor **codecs;
639  unsigned nb_codecs = 0, i = 0;
640 
641  while ((desc = avcodec_descriptor_next(desc)))
642  nb_codecs++;
643  if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs))))
644  return AVERROR(ENOMEM);
645  desc = NULL;
646  while ((desc = avcodec_descriptor_next(desc)))
647  codecs[i++] = desc;
648  av_assert0(i == nb_codecs);
649  qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
650  *rcodecs = codecs;
651  return nb_codecs;
652 }
653 
655 {
656  switch (type) {
657  case AVMEDIA_TYPE_VIDEO: return 'V';
658  case AVMEDIA_TYPE_AUDIO: return 'A';
659  case AVMEDIA_TYPE_DATA: return 'D';
660  case AVMEDIA_TYPE_SUBTITLE: return 'S';
661  case AVMEDIA_TYPE_ATTACHMENT:return 'T';
662  default: return '?';
663  }
664 }
665 
666 int show_codecs(void *optctx, const char *opt, const char *arg)
667 {
668  const AVCodecDescriptor **codecs;
669  unsigned i;
670  int nb_codecs = get_codecs_sorted(&codecs);
671 
672  if (nb_codecs < 0)
673  return nb_codecs;
674 
675  printf("Codecs:\n"
676  " D..... = Decoding supported\n"
677  " .E.... = Encoding supported\n"
678  " ..V... = Video codec\n"
679  " ..A... = Audio codec\n"
680  " ..S... = Subtitle codec\n"
681  " ..D... = Data codec\n"
682  " ..T... = Attachment codec\n"
683  " ...I.. = Intra frame-only codec\n"
684  " ....L. = Lossy compression\n"
685  " .....S = Lossless compression\n"
686  " -------\n");
687  for (i = 0; i < nb_codecs; i++) {
688  const AVCodecDescriptor *desc = codecs[i];
689  const AVCodec *codec;
690  void *iter = NULL;
691 
692  if (strstr(desc->name, "_deprecated"))
693  continue;
694 
695  printf(" %c%c%c%c%c%c",
696  avcodec_find_decoder(desc->id) ? 'D' : '.',
697  avcodec_find_encoder(desc->id) ? 'E' : '.',
698  get_media_type_char(desc->type),
699  (desc->props & AV_CODEC_PROP_INTRA_ONLY) ? 'I' : '.',
700  (desc->props & AV_CODEC_PROP_LOSSY) ? 'L' : '.',
701  (desc->props & AV_CODEC_PROP_LOSSLESS) ? 'S' : '.');
702 
703  printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
704 
705  /* print decoders/encoders when there's more than one or their
706  * names are different from codec name */
707  while ((codec = next_codec_for_id(desc->id, &iter, 0))) {
708  if (strcmp(codec->name, desc->name)) {
709  print_codecs_for_id(desc->id, 0);
710  break;
711  }
712  }
713  iter = NULL;
714  while ((codec = next_codec_for_id(desc->id, &iter, 1))) {
715  if (strcmp(codec->name, desc->name)) {
716  print_codecs_for_id(desc->id, 1);
717  break;
718  }
719  }
720 
721  printf("\n");
722  }
723  av_free(codecs);
724  return 0;
725 }
726 
727 static int print_codecs(int encoder)
728 {
729  const AVCodecDescriptor **codecs;
730  int i, nb_codecs = get_codecs_sorted(&codecs);
731 
732  if (nb_codecs < 0)
733  return nb_codecs;
734 
735  printf("%s:\n"
736  " V..... = Video\n"
737  " A..... = Audio\n"
738  " S..... = Subtitle\n"
739  " .F.... = Frame-level multithreading\n"
740  " ..S... = Slice-level multithreading\n"
741  " ...X.. = Codec is experimental\n"
742  " ....B. = Supports draw_horiz_band\n"
743  " .....D = Supports direct rendering method 1\n"
744  " ------\n",
745  encoder ? "Encoders" : "Decoders");
746  for (i = 0; i < nb_codecs; i++) {
747  const AVCodecDescriptor *desc = codecs[i];
748  const AVCodec *codec;
749  void *iter = NULL;
750 
751  while ((codec = next_codec_for_id(desc->id, &iter, encoder))) {
752  printf(" %c%c%c%c%c%c",
753  get_media_type_char(desc->type),
754  (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? 'F' : '.',
755  (codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? 'S' : '.',
756  (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) ? 'X' : '.',
757  (codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND) ? 'B' : '.',
758  (codec->capabilities & AV_CODEC_CAP_DR1) ? 'D' : '.');
759 
760  printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
761  if (strcmp(codec->name, desc->name))
762  printf(" (codec %s)", desc->name);
763 
764  printf("\n");
765  }
766  }
767  av_free(codecs);
768  return 0;
769 }
770 
771 int show_decoders(void *optctx, const char *opt, const char *arg)
772 {
773  return print_codecs(0);
774 }
775 
776 int show_encoders(void *optctx, const char *opt, const char *arg)
777 {
778  return print_codecs(1);
779 }
780 
781 int show_bsfs(void *optctx, const char *opt, const char *arg)
782 {
783  const AVBitStreamFilter *bsf = NULL;
784  void *opaque = NULL;
785 
786  printf("Bitstream filters:\n");
787  while ((bsf = av_bsf_iterate(&opaque)))
788  printf("%s\n", bsf->name);
789  printf("\n");
790  return 0;
791 }
792 
793 int show_filters(void *optctx, const char *opt, const char *arg)
794 {
795 #if CONFIG_AVFILTER
796  const AVFilter *filter = NULL;
797  char descr[64], *descr_cur;
798  void *opaque = NULL;
799  int i, j;
800  const AVFilterPad *pad;
801 
802  printf("Filters:\n"
803  " T.. = Timeline support\n"
804  " .S. = Slice threading\n"
805  " ..C = Command support\n"
806  " A = Audio input/output\n"
807  " V = Video input/output\n"
808  " N = Dynamic number and/or type of input/output\n"
809  " | = Source or sink filter\n");
810  while ((filter = av_filter_iterate(&opaque))) {
811  descr_cur = descr;
812  for (i = 0; i < 2; i++) {
813  unsigned nb_pads;
814  if (i) {
815  *(descr_cur++) = '-';
816  *(descr_cur++) = '>';
817  }
818  pad = i ? filter->outputs : filter->inputs;
819  nb_pads = avfilter_filter_pad_count(filter, i);
820  for (j = 0; j < nb_pads; j++) {
821  if (descr_cur >= descr + sizeof(descr) - 4)
822  break;
823  *(descr_cur++) = get_media_type_char(avfilter_pad_get_type(pad, j));
824  }
825  if (!j)
826  *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
827  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
828  }
829  *descr_cur = 0;
830  printf(" %c%c%c %-17s %-10s %s\n",
831  filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
832  filter->flags & AVFILTER_FLAG_SLICE_THREADS ? 'S' : '.',
833  filter->process_command ? 'C' : '.',
834  filter->name, descr, filter->description);
835  }
836 #else
837  printf("No filters available: libavfilter disabled\n");
838 #endif
839  return 0;
840 }
841 
842 static int is_device(const AVClass *avclass)
843 {
844  if (!avclass)
845  return 0;
846  return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
847 }
848 
849 static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
850 {
851  void *ifmt_opaque = NULL;
852  const AVInputFormat *ifmt = NULL;
853  void *ofmt_opaque = NULL;
854  const AVOutputFormat *ofmt = NULL;
855  const char *last_name;
856  int is_dev;
857  const char *is_device_placeholder = device_only ? "" : ".";
858 
859  printf("%s:\n"
860  " D.%s = Demuxing supported\n"
861  " .E%s = Muxing supported\n"
862  "%s"
863  " ---\n",
864  device_only ? "Devices" : "Formats",
865  is_device_placeholder, is_device_placeholder,
866  device_only ? "": " ..d = Is a device\n");
867 
868  last_name = "000";
869  for (;;) {
870  int decode = 0;
871  int encode = 0;
872  int device = 0;
873  const char *name = NULL;
874  const char *long_name = NULL;
875 
876  if (muxdemuxers !=SHOW_DEMUXERS) {
877  ofmt_opaque = NULL;
878  while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
879  is_dev = is_device(ofmt->priv_class);
880  if (!is_dev && device_only)
881  continue;
882  if ((!name || strcmp(ofmt->name, name) < 0) &&
883  strcmp(ofmt->name, last_name) > 0) {
884  name = ofmt->name;
885  long_name = ofmt->long_name;
886  encode = 1;
887  device = is_dev;
888  }
889  }
890  }
891  if (muxdemuxers != SHOW_MUXERS) {
892  ifmt_opaque = NULL;
893  while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
894  is_dev = is_device(ifmt->priv_class);
895  if (!is_dev && device_only)
896  continue;
897  if ((!name || strcmp(ifmt->name, name) < 0) &&
898  strcmp(ifmt->name, last_name) > 0) {
899  name = ifmt->name;
900  long_name = ifmt->long_name;
901  encode = 0;
902  device = is_dev;
903  }
904  if (name && strcmp(ifmt->name, name) == 0) {
905  decode = 1;
906  device = is_dev;
907  }
908  }
909  }
910  if (!name)
911  break;
912  last_name = name;
913 
914  printf(" %c%c%s %-15s %s\n",
915  decode ? 'D' : ' ',
916  encode ? 'E' : ' ',
917  device_only ? "" : (device ? "d" : " "),
918  name,
919  long_name ? long_name : " ");
920  }
921  return 0;
922 }
923 
924 int show_formats(void *optctx, const char *opt, const char *arg)
925 {
926  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
927 }
928 
929 int show_muxers(void *optctx, const char *opt, const char *arg)
930 {
931  return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
932 }
933 
934 int show_demuxers(void *optctx, const char *opt, const char *arg)
935 {
936  return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
937 }
938 
939 int show_devices(void *optctx, const char *opt, const char *arg)
940 {
941  return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
942 }
943 
944 int show_protocols(void *optctx, const char *opt, const char *arg)
945 {
946  void *opaque = NULL;
947  const char *name;
948 
949  printf("Supported file protocols:\n"
950  "Input:\n");
951  while ((name = avio_enum_protocols(&opaque, 0)))
952  printf(" %s\n", name);
953  printf("Output:\n");
954  while ((name = avio_enum_protocols(&opaque, 1)))
955  printf(" %s\n", name);
956  return 0;
957 }
958 
959 int show_colors(void *optctx, const char *opt, const char *arg)
960 {
961  const char *name;
962  const uint8_t *rgb;
963  int i;
964 
965  printf("%-32s #RRGGBB\n", "name");
966 
967  for (i = 0; name = av_get_known_color_name(i, &rgb); i++)
968  printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
969 
970  return 0;
971 }
972 
973 int show_pix_fmts(void *optctx, const char *opt, const char *arg)
974 {
975  const AVPixFmtDescriptor *pix_desc = NULL;
976 
977  printf("Pixel formats:\n"
978  "I.... = Supported Input format for conversion\n"
979  ".O... = Supported Output format for conversion\n"
980  "..H.. = Hardware accelerated format\n"
981  "...P. = Paletted format\n"
982  "....B = Bitstream format\n"
983  "FLAGS NAME NB_COMPONENTS BITS_PER_PIXEL BIT_DEPTHS\n"
984  "-----\n");
985 
986 #if !CONFIG_SWSCALE
987 # define sws_isSupportedInput(x) 0
988 # define sws_isSupportedOutput(x) 0
989 #endif
990 
991  while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
993  printf("%c%c%c%c%c %-16s %d %3d %d",
994  sws_isSupportedInput (pix_fmt) ? 'I' : '.',
995  sws_isSupportedOutput(pix_fmt) ? 'O' : '.',
996  pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL ? 'H' : '.',
997  pix_desc->flags & AV_PIX_FMT_FLAG_PAL ? 'P' : '.',
998  pix_desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ? 'B' : '.',
999  pix_desc->name,
1000  pix_desc->nb_components,
1001  av_get_bits_per_pixel(pix_desc),
1002  pix_desc->comp[0].depth);
1003 
1004  for (unsigned i = 1; i < pix_desc->nb_components; i++)
1005  printf("-%d", pix_desc->comp[i].depth);
1006  printf("\n");
1007  }
1008  return 0;
1009 }
1010 
1011 int show_layouts(void *optctx, const char *opt, const char *arg)
1012 {
1013  const AVChannelLayout *ch_layout;
1014  void *iter = NULL;
1015  char buf[128], buf2[128];
1016  int i = 0;
1017 
1018  printf("Individual channels:\n"
1019  "NAME DESCRIPTION\n");
1020  for (i = 0; i < 63; i++) {
1021  av_channel_name(buf, sizeof(buf), i);
1022  if (strstr(buf, "USR"))
1023  continue;
1024  av_channel_description(buf2, sizeof(buf2), i);
1025  printf("%-14s %s\n", buf, buf2);
1026  }
1027  printf("\nStandard channel layouts:\n"
1028  "NAME DECOMPOSITION\n");
1029  while (ch_layout = av_channel_layout_standard(&iter)) {
1030  av_channel_layout_describe(ch_layout, buf, sizeof(buf));
1031  printf("%-14s ", buf);
1032  for (i = 0; i < 63; i++) {
1033  int idx = av_channel_layout_index_from_channel(ch_layout, i);
1034  if (idx >= 0) {
1035  av_channel_name(buf2, sizeof(buf2), i);
1036  printf("%s%s", idx ? "+" : "", buf2);
1037  }
1038  }
1039  printf("\n");
1040  }
1041  return 0;
1042 }
1043 
1044 int show_sample_fmts(void *optctx, const char *opt, const char *arg)
1045 {
1046  int i;
1047  char fmt_str[128];
1048  for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
1049  printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
1050  return 0;
1051 }
1052 
1053 int show_dispositions(void *optctx, const char *opt, const char *arg)
1054 {
1055  for (int i = 0; i < 32; i++) {
1056  const char *str = av_disposition_to_string(1U << i);
1057  if (str)
1058  printf("%s\n", str);
1059  }
1060  return 0;
1061 }
1062 
1063 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1064 {
1065  int ret;
1066  unsigned flags = av_get_cpu_flags();
1067 
1068  if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
1069  return ret;
1070 
1072  return 0;
1073 }
1074 
1075 int opt_cpucount(void *optctx, const char *opt, const char *arg)
1076 {
1077  int ret;
1078  int count;
1079 
1080  static const AVOption opts[] = {
1081  {"count", NULL, 0, AV_OPT_TYPE_INT, { .i64 = -1}, -1, INT_MAX},
1082  {NULL},
1083  };
1084  static const AVClass class = {
1085  .class_name = "cpucount",
1086  .item_name = av_default_item_name,
1087  .option = opts,
1088  .version = LIBAVUTIL_VERSION_INT,
1089  };
1090  const AVClass *pclass = &class;
1091 
1092  ret = av_opt_eval_int(&pclass, opts, arg, &count);
1093 
1094  if (!ret) {
1095  av_cpu_force_count(count);
1096  }
1097 
1098  return ret;
1099 }
1100 
1101 static void expand_filename_template(AVBPrint *bp, const char *template,
1102  struct tm *tm)
1103 {
1104  int c;
1105 
1106  while ((c = *(template++))) {
1107  if (c == '%') {
1108  if (!(c = *(template++)))
1109  break;
1110  switch (c) {
1111  case 'p':
1112  av_bprintf(bp, "%s", program_name);
1113  break;
1114  case 't':
1115  av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
1116  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1117  tm->tm_hour, tm->tm_min, tm->tm_sec);
1118  break;
1119  case '%':
1120  av_bprint_chars(bp, c, 1);
1121  break;
1122  }
1123  } else {
1124  av_bprint_chars(bp, c, 1);
1125  }
1126  }
1127 }
1128 
1129 static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
1130 {
1131  va_list vl2;
1132  char line[1024];
1133  static int print_prefix = 1;
1134 
1135  va_copy(vl2, vl);
1136  av_log_default_callback(ptr, level, fmt, vl);
1137  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
1138  va_end(vl2);
1139  if (report_file_level >= level) {
1140  fputs(line, report_file);
1141  fflush(report_file);
1142  }
1143 }
1144 
1145 int init_report(const char *env, FILE **file)
1146 {
1147  char *filename_template = NULL;
1148  char *key, *val;
1149  int ret, count = 0;
1150  int prog_loglevel, envlevel = 0;
1151  time_t now;
1152  struct tm *tm;
1153  AVBPrint filename;
1154 
1155  if (report_file) /* already opened */
1156  return 0;
1157  time(&now);
1158  tm = localtime(&now);
1159 
1160  while (env && *env) {
1161  if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
1162  if (count)
1164  "Failed to parse FFREPORT environment variable: %s\n",
1165  av_err2str(ret));
1166  break;
1167  }
1168  if (*env)
1169  env++;
1170  count++;
1171  if (!strcmp(key, "file")) {
1172  av_free(filename_template);
1173  filename_template = val;
1174  val = NULL;
1175  } else if (!strcmp(key, "level")) {
1176  char *tail;
1177  report_file_level = strtol(val, &tail, 10);
1178  if (*tail) {
1179  av_log(NULL, AV_LOG_FATAL, "Invalid report file level\n");
1180  av_free(key);
1181  av_free(val);
1182  av_free(filename_template);
1183  return AVERROR(EINVAL);
1184  }
1185  envlevel = 1;
1186  } else {
1187  av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
1188  }
1189  av_free(val);
1190  av_free(key);
1191  }
1192 
1194  expand_filename_template(&filename,
1195  av_x_if_null(filename_template, "%p-%t.log"), tm);
1196  av_free(filename_template);
1197  if (!av_bprint_is_complete(&filename)) {
1198  av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
1199  return AVERROR(ENOMEM);
1200  }
1201 
1202  prog_loglevel = av_log_get_level();
1203  if (!envlevel)
1204  report_file_level = FFMAX(report_file_level, prog_loglevel);
1205 
1206  report_file = fopen(filename.str, "w");
1207  if (!report_file) {
1208  int ret = AVERROR(errno);
1209  av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
1210  filename.str, strerror(errno));
1211  return ret;
1212  }
1215  "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
1216  "Report written to \"%s\"\n"
1217  "Log level: %d\n",
1218  program_name,
1219  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1220  tm->tm_hour, tm->tm_min, tm->tm_sec,
1221  filename.str, report_file_level);
1222  av_bprint_finalize(&filename, NULL);
1223 
1224  if (file)
1225  *file = report_file;
1226 
1227  return 0;
1228 }
1229 
1230 int opt_report(void *optctx, const char *opt, const char *arg)
1231 {
1232  return init_report(NULL, NULL);
1233 }
1234 
1235 int opt_max_alloc(void *optctx, const char *opt, const char *arg)
1236 {
1237  char *tail;
1238  size_t max;
1239 
1240  max = strtol(arg, &tail, 10);
1241  if (*tail) {
1242  av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
1243  return AVERROR(EINVAL);
1244  }
1245  av_max_alloc(max);
1246  return 0;
1247 }
1248 
1249 int opt_loglevel(void *optctx, const char *opt, const char *arg)
1250 {
1251  const struct { const char *name; int level; } log_levels[] = {
1252  { "quiet" , AV_LOG_QUIET },
1253  { "panic" , AV_LOG_PANIC },
1254  { "fatal" , AV_LOG_FATAL },
1255  { "error" , AV_LOG_ERROR },
1256  { "warning", AV_LOG_WARNING },
1257  { "info" , AV_LOG_INFO },
1258  { "verbose", AV_LOG_VERBOSE },
1259  { "debug" , AV_LOG_DEBUG },
1260  { "trace" , AV_LOG_TRACE },
1261  };
1262  const char *token;
1263  char *tail;
1264  int flags = av_log_get_flags();
1265  int level = av_log_get_level();
1266  int cmd, i = 0;
1267 
1268  av_assert0(arg);
1269  while (*arg) {
1270  token = arg;
1271  if (*token == '+' || *token == '-') {
1272  cmd = *token++;
1273  } else {
1274  cmd = 0;
1275  }
1276  if (!i && !cmd) {
1277  flags = 0; /* missing relative prefix, build absolute value */
1278  }
1279  if (av_strstart(token, "repeat", &arg)) {
1280  if (cmd == '-') {
1282  } else {
1284  }
1285  } else if (av_strstart(token, "level", &arg)) {
1286  if (cmd == '-') {
1288  } else {
1290  }
1291  } else {
1292  break;
1293  }
1294  i++;
1295  }
1296  if (!*arg) {
1297  goto end;
1298  } else if (*arg == '+') {
1299  arg++;
1300  } else if (!i) {
1301  flags = av_log_get_flags(); /* level value without prefix, reset flags */
1302  }
1303 
1304  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
1305  if (!strcmp(log_levels[i].name, arg)) {
1306  level = log_levels[i].level;
1307  goto end;
1308  }
1309  }
1310 
1311  level = strtol(arg, &tail, 10);
1312  if (*tail) {
1313  av_log(NULL, AV_LOG_FATAL, "Invalid loglevel \"%s\". "
1314  "Possible levels are numbers or:\n", arg);
1315  for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
1316  av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
1317  return AVERROR(EINVAL);
1318  }
1319 
1320 end:
1323  return 0;
1324 }
1325 
1326 #if CONFIG_AVDEVICE
1327 static void print_device_list(const AVDeviceInfoList *device_list)
1328 {
1329  // print devices
1330  for (int i = 0; i < device_list->nb_devices; i++) {
1331  const AVDeviceInfo *device = device_list->devices[i];
1332  printf("%c %s [%s] (", device_list->default_device == i ? '*' : ' ',
1333  device->device_name, device->device_description);
1334  if (device->nb_media_types > 0) {
1335  for (int j = 0; j < device->nb_media_types; ++j) {
1336  const char* media_type = av_get_media_type_string(device->media_types[j]);
1337  if (j > 0)
1338  printf(", ");
1339  printf("%s", media_type ? media_type : "unknown");
1340  }
1341  } else {
1342  printf("none");
1343  }
1344  printf(")\n");
1345  }
1346 }
1347 
1348 static int print_device_sources(const AVInputFormat *fmt, AVDictionary *opts)
1349 {
1350  int ret;
1351  AVDeviceInfoList *device_list = NULL;
1352 
1353  if (!fmt || !fmt->priv_class || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
1354  return AVERROR(EINVAL);
1355 
1356  printf("Auto-detected sources for %s:\n", fmt->name);
1357  if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
1358  printf("Cannot list sources: %s\n", av_err2str(ret));
1359  goto fail;
1360  }
1361 
1362  print_device_list(device_list);
1363 
1364  fail:
1365  avdevice_free_list_devices(&device_list);
1366  return ret;
1367 }
1368 
1369 static int print_device_sinks(const AVOutputFormat *fmt, AVDictionary *opts)
1370 {
1371  int ret;
1372  AVDeviceInfoList *device_list = NULL;
1373 
1374  if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
1375  return AVERROR(EINVAL);
1376 
1377  printf("Auto-detected sinks for %s:\n", fmt->name);
1378  if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
1379  printf("Cannot list sinks: %s\n", av_err2str(ret));
1380  goto fail;
1381  }
1382 
1383  print_device_list(device_list);
1384 
1385  fail:
1386  avdevice_free_list_devices(&device_list);
1387  return ret;
1388 }
1389 
1390 static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionary **opts)
1391 {
1392  int ret;
1393  if (arg) {
1394  char *opts_str = NULL;
1395  av_assert0(dev && opts);
1396  *dev = av_strdup(arg);
1397  if (!*dev)
1398  return AVERROR(ENOMEM);
1399  if ((opts_str = strchr(*dev, ','))) {
1400  *(opts_str++) = '\0';
1401  if (opts_str[0] && ((ret = av_dict_parse_string(opts, opts_str, "=", ":", 0)) < 0)) {
1402  av_freep(dev);
1403  return ret;
1404  }
1405  }
1406  } else
1407  printf("\nDevice name is not provided.\n"
1408  "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
1409  return 0;
1410 }
1411 
1412 int show_sources(void *optctx, const char *opt, const char *arg)
1413 {
1414  const AVInputFormat *fmt = NULL;
1415  char *dev = NULL;
1416  AVDictionary *opts = NULL;
1417  int ret = 0;
1418  int error_level = av_log_get_level();
1419 
1421 
1422  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1423  goto fail;
1424 
1425  do {
1426  fmt = av_input_audio_device_next(fmt);
1427  if (fmt) {
1428  if (!strcmp(fmt->name, "lavfi"))
1429  continue; //it's pointless to probe lavfi
1430  if (dev && !av_match_name(dev, fmt->name))
1431  continue;
1432  print_device_sources(fmt, opts);
1433  }
1434  } while (fmt);
1435  do {
1436  fmt = av_input_video_device_next(fmt);
1437  if (fmt) {
1438  if (dev && !av_match_name(dev, fmt->name))
1439  continue;
1440  print_device_sources(fmt, opts);
1441  }
1442  } while (fmt);
1443  fail:
1444  av_dict_free(&opts);
1445  av_free(dev);
1446  av_log_set_level(error_level);
1447  return ret;
1448 }
1449 
1450 int show_sinks(void *optctx, const char *opt, const char *arg)
1451 {
1452  const AVOutputFormat *fmt = NULL;
1453  char *dev = NULL;
1454  AVDictionary *opts = NULL;
1455  int ret = 0;
1456  int error_level = av_log_get_level();
1457 
1459 
1460  if ((ret = show_sinks_sources_parse_arg(arg, &dev, &opts)) < 0)
1461  goto fail;
1462 
1463  do {
1464  fmt = av_output_audio_device_next(fmt);
1465  if (fmt) {
1466  if (dev && !av_match_name(dev, fmt->name))
1467  continue;
1468  print_device_sinks(fmt, opts);
1469  }
1470  } while (fmt);
1471  do {
1472  fmt = av_output_video_device_next(fmt);
1473  if (fmt) {
1474  if (dev && !av_match_name(dev, fmt->name))
1475  continue;
1476  print_device_sinks(fmt, opts);
1477  }
1478  } while (fmt);
1479  fail:
1480  av_dict_free(&opts);
1481  av_free(dev);
1482  av_log_set_level(error_level);
1483  return ret;
1484 }
1485 #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:934
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:187
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:1048
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:71
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:205
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:616
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:218
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:114
GET_SAMPLE_RATE_NAME
#define GET_SAMPLE_RATE_NAME(rate)
Definition: cmdutils.h:477
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:969
AVCodec::long_name
const char * long_name
Descriptive name for the codec, meant to be more human readable than name.
Definition: codec.h:199
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:793
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:265
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:162
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:145
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:334
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
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:85
av_unused
#define av_unused
Definition: attributes.h:131
is_device
static int is_device(const AVClass *avclass)
Definition: opt_common.c:842
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:345
GET_PIX_FMT_NAME
#define GET_PIX_FMT_NAME(pix_fmt)
Definition: cmdutils.h:468
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:959
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:939
log_callback_report
static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
Definition: opt_common.c:1129
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:849
pixdesc.h
SHOW_CONFIG
#define SHOW_CONFIG
Definition: opt_common.c:153
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
init_report
int init_report(const char *env, FILE **file)
Definition: opt_common.c:1145
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:524
opt_report
int opt_report(void *optctx, const char *opt, const char *arg)
Definition: opt_common.c:1230
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:357
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:2972
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:973
avio_enum_protocols
const char * avio_enum_protocols(void **opaque, int output)
Iterate through names of available protocols.
Definition: protocols.c:99
print_codecs_for_id
static void print_codecs_for_id(enum AVCodecID id, int encoder)
Definition: opt_common.c:613
version.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
codec_ids
static enum AVCodecID codec_ids[]
Definition: aac_adtstoasc.c:146
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:140
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:2917
get_media_type_char
static char get_media_type_char(enum AVMediaType type)
Definition: opt_common.c:654
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:34
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:1053
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:60
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
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 av_cold AVInputFormat * av_input_audio_device_next(const AVInputFormat *d)
Audio input devices iterator.
Definition: alldevices.c:127
OptionDef
Definition: cmdutils.h:126
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:560
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:96
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:76
rgb
Definition: rpzaenc.c:60
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:776
fail
#define fail()
Definition: checkasm.h:182
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:1851
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:620
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:78
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:106
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:666
show_help_muxer
static void show_help_muxer(const char *name)
Definition: opt_common.c:467
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:285
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:344
next_codec_for_id
static const AVCodec * next_codec_for_id(enum AVCodecID id, void **iter, int encoder)
Definition: opt_common.c:383
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:102
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:548
AVInputFormat::extensions
const char * extensions
If extensions are defined, then no probe is done.
Definition: avformat.h:574
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:85
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:645
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:335
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:72
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:626
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
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:553
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
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:124
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:40
av_channel_layout_standard
const AVChannelLayout * av_channel_layout_standard(void **opaque)
Iterate over all standard channel layouts.
Definition: channel_layout.c:844
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
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:781
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:112
key
const char * key
Definition: hwcontext_opencl.c:189
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:336
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:300
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:337
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:110
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
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:631
opts
AVDictionary * opts
Definition: movenc.c:51
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:992
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:471
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:452
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:1249
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: bsf.h:130
codecs
static const struct codec_string codecs[]
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:128
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
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:280
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:1044
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:964
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:112
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:106
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:1011
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:474
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
options
const OptionDef options[]
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:309
f
f
Definition: af_crystalizer.c:121
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:462
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
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:122
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
av_output_video_device_next
const av_cold AVOutputFormat * av_output_video_device_next(const AVOutputFormat *d)
Video output devices iterator.
Definition: alldevices.c:142
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:333
GET_SAMPLE_FMT_NAME
#define GET_SAMPLE_FMT_NAME(sample_fmt)
Definition: cmdutils.h:474
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:606
printf
printf("static const uint8_t my_array[100] = {\n")
av_log_get_flags
int av_log_get_flags(void)
Definition: log.c:457
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:107
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:944
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:131
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:771
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
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:2984
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:36
va_copy
#define va_copy(dst, src)
Definition: va_copy.h:31
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:335
show_help_bsf
static void show_help_bsf(const char *name)
Definition: opt_common.c:556
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:3741
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:78
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:447
bprint.h
INDENT
#define INDENT
Definition: opt_common.c:151
get_codecs_sorted
static int get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
Definition: opt_common.c:635
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:959
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:256
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:98
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
print_codecs
static int print_codecs(int encoder)
Definition: opt_common.c:727
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:286
show_help_demuxer
static void show_help_demuxer(const char *name)
Definition: opt_common.c:431
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
opt_max_alloc
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
Definition: opt_common.c:1235
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:915
show_help_protocol
static void show_help_protocol(const char *name)
Definition: opt_common.c:449
avcodec.h
AVFilter
Filter definition.
Definition: avfilter.h:166
version.h
version.h
version.h
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:74
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:343
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:70
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:929
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
dict.h
opt_cpucount
int opt_cpucount(void *optctx, const char *opt, const char *arg)
Override the cpucount.
Definition: opt_common.c:1075
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:974
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:585
AVDeviceInfoList::default_device
int default_device
index of default device or -1 if no default
Definition: avdevice.h:346
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:924
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:705
opt_common.h
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
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:345
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:1063
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:236
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:76
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:144
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:838
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:118
expand_filename_template
static void expand_filename_template(AVBPrint *bp, const char *template, struct tm *tm)
Definition: opt_common.c:1101
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:117
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
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:284
desc
const char * desc
Definition: libsvtav1.c:79
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:353
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:79
mem.h
av_output_audio_device_next
const av_cold AVOutputFormat * av_output_audio_device_next(const AVOutputFormat *d)
Audio output devices iterator.
Definition: alldevices.c:137
AV_CODEC_CAP_HYBRID
#define AV_CODEC_CAP_HYBRID
Codec is potentially backed by a hardware implementation, but not necessarily.
Definition: codec.h:152
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:160
show_help_codec
static void show_help_codec(const char *name, int encoder)
Definition: opt_common.c:395
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
cmdutils.h
show_help
int show_help(void *optctx, const char *opt, const char *arg)
Generic -h handler common to all fftools.
Definition: opt_common.c:575
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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:138
AVCodecHWConfig
Definition: codec.h:334
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:145
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3735
av_input_video_device_next
const av_cold AVInputFormat * av_input_video_device_next(const AVInputFormat *d)
Video input devices iterator.
Definition: alldevices.c:132
avstring.h
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3750
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:81
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:578
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:312
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:987
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:86
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:86