FFmpeg: fftools/opt_common.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /