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