FFmpeg
ffprobe.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2007-2010 Stefano Sabatini
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 /**
22  * @file
23  * simple media prober based on the FFmpeg libraries
24  */
25 
26 #include "config.h"
27 #include "libavutil/ffversion.h"
28 
29 #include <string.h>
30 
31 #include "libavformat/avformat.h"
32 #include "libavcodec/avcodec.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/bprint.h"
36 #include "libavutil/display.h"
37 #include "libavutil/hash.h"
40 #include "libavutil/dovi_meta.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/spherical.h"
44 #include "libavutil/stereo3d.h"
45 #include "libavutil/dict.h"
46 #include "libavutil/intreadwrite.h"
47 #include "libavutil/libm.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/timecode.h"
50 #include "libavutil/timestamp.h"
51 #include "libavdevice/avdevice.h"
52 #include "libswscale/swscale.h"
55 #include "cmdutils.h"
56 
57 #include "libavutil/thread.h"
58 
59 #if !HAVE_THREADS
60 # ifdef pthread_mutex_lock
61 # undef pthread_mutex_lock
62 # endif
63 # define pthread_mutex_lock(a) do{}while(0)
64 # ifdef pthread_mutex_unlock
65 # undef pthread_mutex_unlock
66 # endif
67 # define pthread_mutex_unlock(a) do{}while(0)
68 #endif
69 
70 typedef struct InputStream {
71  AVStream *st;
72 
74 } InputStream;
75 
76 typedef struct InputFile {
78 
80  int nb_streams;
81 } InputFile;
82 
83 const char program_name[] = "ffprobe";
84 const int program_birth_year = 2007;
85 
86 static int do_bitexact = 0;
87 static int do_count_frames = 0;
88 static int do_count_packets = 0;
89 static int do_read_frames = 0;
90 static int do_read_packets = 0;
91 static int do_show_chapters = 0;
92 static int do_show_error = 0;
93 static int do_show_format = 0;
94 static int do_show_frames = 0;
95 static int do_show_packets = 0;
96 static int do_show_programs = 0;
97 static int do_show_streams = 0;
99 static int do_show_data = 0;
100 static int do_show_program_version = 0;
102 static int do_show_pixel_formats = 0;
105 static int do_show_log = 0;
106 
107 static int do_show_chapter_tags = 0;
108 static int do_show_format_tags = 0;
109 static int do_show_frame_tags = 0;
110 static int do_show_program_tags = 0;
111 static int do_show_stream_tags = 0;
112 static int do_show_packet_tags = 0;
113 
114 static int show_value_unit = 0;
115 static int use_value_prefix = 0;
118 static int show_private_data = 1;
119 
120 static char *print_format;
121 static char *stream_specifier;
122 static char *show_data_hash;
123 
124 typedef struct ReadInterval {
125  int id; ///< identifier
126  int64_t start, end; ///< start, end in second/AV_TIME_BASE units
130 } ReadInterval;
131 
133 static int read_intervals_nb = 0;
134 
135 static int find_stream_info = 1;
136 
137 /* section structure definition */
138 
139 #define SECTION_MAX_NB_CHILDREN 10
140 
141 struct section {
142  int id; ///< unique id identifying a section
143  const char *name;
144 
145 #define SECTION_FLAG_IS_WRAPPER 1 ///< the section only contains other sections, but has no data at its own level
146 #define SECTION_FLAG_IS_ARRAY 2 ///< the section contains an array of elements of the same type
147 #define SECTION_FLAG_HAS_VARIABLE_FIELDS 4 ///< the section may contain a variable number of fields with variable keys.
148  /// For these sections the element_name field is mandatory.
149  int flags;
150  int children_ids[SECTION_MAX_NB_CHILDREN+1]; ///< list of children section IDS, terminated by -1
151  const char *element_name; ///< name of the contained element, if provided
152  const char *unique_name; ///< unique section name, in case the name is ambiguous
155 };
156 
157 typedef enum {
203 } SectionID;
204 
205 static struct section sections[] = {
207  [SECTION_ID_CHAPTER] = { SECTION_ID_CHAPTER, "chapter", 0, { SECTION_ID_CHAPTER_TAGS, -1 } },
208  [SECTION_ID_CHAPTER_TAGS] = { SECTION_ID_CHAPTER_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "chapter_tags" },
209  [SECTION_ID_ERROR] = { SECTION_ID_ERROR, "error", 0, { -1 } },
210  [SECTION_ID_FORMAT] = { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },
211  [SECTION_ID_FORMAT_TAGS] = { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },
214  [SECTION_ID_FRAME_TAGS] = { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },
215  [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "frame_side_data_list" },
220  [SECTION_ID_FRAME_LOG] = { SECTION_ID_FRAME_LOG, "log", 0, { -1 }, },
222  [SECTION_ID_LIBRARY_VERSION] = { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },
226  [SECTION_ID_PACKET_TAGS] = { SECTION_ID_PACKET_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "packet_tags" },
227  [SECTION_ID_PACKET_SIDE_DATA_LIST] ={ SECTION_ID_PACKET_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "packet_side_data_list" },
228  [SECTION_ID_PACKET_SIDE_DATA] = { SECTION_ID_PACKET_SIDE_DATA, "side_data", 0, { -1 } },
231  [SECTION_ID_PIXEL_FORMAT_FLAGS] = { SECTION_ID_PIXEL_FORMAT_FLAGS, "flags", 0, { -1 }, .unique_name = "pixel_format_flags" },
232  [SECTION_ID_PIXEL_FORMAT_COMPONENTS] = { SECTION_ID_PIXEL_FORMAT_COMPONENTS, "components", SECTION_FLAG_IS_ARRAY, {SECTION_ID_PIXEL_FORMAT_COMPONENT, -1 }, .unique_name = "pixel_format_components" },
234  [SECTION_ID_PROGRAM_STREAM_DISPOSITION] = { SECTION_ID_PROGRAM_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "program_stream_disposition" },
235  [SECTION_ID_PROGRAM_STREAM_TAGS] = { SECTION_ID_PROGRAM_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_stream_tags" },
237  [SECTION_ID_PROGRAM_STREAMS] = { SECTION_ID_PROGRAM_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM_STREAM, -1 }, .unique_name = "program_streams" },
239  [SECTION_ID_PROGRAM_TAGS] = { SECTION_ID_PROGRAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_tags" },
240  [SECTION_ID_PROGRAM_VERSION] = { SECTION_ID_PROGRAM_VERSION, "program_version", 0, { -1 } },
248  [SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },
249  [SECTION_ID_STREAM_TAGS] = { SECTION_ID_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },
250  [SECTION_ID_STREAM_SIDE_DATA_LIST] ={ SECTION_ID_STREAM_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "stream_side_data_list" },
251  [SECTION_ID_STREAM_SIDE_DATA] = { SECTION_ID_STREAM_SIDE_DATA, "side_data", 0, { -1 } },
252  [SECTION_ID_SUBTITLE] = { SECTION_ID_SUBTITLE, "subtitle", 0, { -1 } },
253 };
254 
255 static const OptionDef *options;
256 
257 /* FFprobe context */
258 static const char *input_filename;
259 static const char *print_input_filename;
261 
262 static struct AVHashContext *hash;
263 
264 static const struct {
265  double bin_val;
266  double dec_val;
267  const char *bin_str;
268  const char *dec_str;
269 } si_prefixes[] = {
270  { 1.0, 1.0, "", "" },
271  { 1.024e3, 1e3, "Ki", "K" },
272  { 1.048576e6, 1e6, "Mi", "M" },
273  { 1.073741824e9, 1e9, "Gi", "G" },
274  { 1.099511627776e12, 1e12, "Ti", "T" },
275  { 1.125899906842624e15, 1e15, "Pi", "P" },
276 };
277 
278 static const char unit_second_str[] = "s" ;
279 static const char unit_hertz_str[] = "Hz" ;
280 static const char unit_byte_str[] = "byte" ;
281 static const char unit_bit_per_second_str[] = "bit/s";
282 
283 static int nb_streams;
284 static uint64_t *nb_streams_packets;
285 static uint64_t *nb_streams_frames;
286 static int *selected_streams;
287 
288 #if HAVE_THREADS
289 pthread_mutex_t log_mutex;
290 #endif
291 typedef struct LogBuffer {
294  char *log_message;
296  char *parent_name;
298 }LogBuffer;
299 
301 static int log_buffer_size;
302 
303 static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
304 {
305  AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
306  va_list vl2;
307  char line[1024];
308  static int print_prefix = 1;
309  void *new_log_buffer;
310 
311  va_copy(vl2, vl);
312  av_log_default_callback(ptr, level, fmt, vl);
313  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
314  va_end(vl2);
315 
316 #if HAVE_THREADS
317  pthread_mutex_lock(&log_mutex);
318 
319  new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer));
320  if (new_log_buffer) {
321  char *msg;
322  int i;
323 
324  log_buffer = new_log_buffer;
325  memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size]));
327  if (avc) {
330  }
333  for (i=strlen(msg) - 1; i>=0 && msg[i] == '\n'; i--) {
334  msg[i] = 0;
335  }
336  if (avc && avc->parent_log_context_offset) {
337  AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
339  if (parent && *parent) {
340  log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent));
342  (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category;
343  }
344  }
345  log_buffer_size ++;
346  }
347 
348  pthread_mutex_unlock(&log_mutex);
349 #endif
350 }
351 
352 static void ffprobe_cleanup(int ret)
353 {
354  int i;
355  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
356  av_dict_free(&(sections[i].entries_to_show));
357 
358 #if HAVE_THREADS
359  pthread_mutex_destroy(&log_mutex);
360 #endif
361 }
362 
363 struct unit_value {
364  union { double d; long long int i; } val;
365  const char *unit;
366 };
367 
368 static char *value_string(char *buf, int buf_size, struct unit_value uv)
369 {
370  double vald;
371  long long int vali;
372  int show_float = 0;
373 
374  if (uv.unit == unit_second_str) {
375  vald = uv.val.d;
376  show_float = 1;
377  } else {
378  vald = vali = uv.val.i;
379  }
380 
382  double secs;
383  int hours, mins;
384  secs = vald;
385  mins = (int)secs / 60;
386  secs = secs - mins * 60;
387  hours = mins / 60;
388  mins %= 60;
389  snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
390  } else {
391  const char *prefix_string = "";
392 
393  if (use_value_prefix && vald > 1) {
394  long long int index;
395 
397  index = (long long int) (log2(vald)) / 10;
399  vald /= si_prefixes[index].bin_val;
400  prefix_string = si_prefixes[index].bin_str;
401  } else {
402  index = (long long int) (log10(vald)) / 3;
404  vald /= si_prefixes[index].dec_val;
405  prefix_string = si_prefixes[index].dec_str;
406  }
407  vali = vald;
408  }
409 
410  if (show_float || (use_value_prefix && vald != (long long int)vald))
411  snprintf(buf, buf_size, "%f", vald);
412  else
413  snprintf(buf, buf_size, "%lld", vali);
414  av_strlcatf(buf, buf_size, "%s%s%s", *prefix_string || show_value_unit ? " " : "",
415  prefix_string, show_value_unit ? uv.unit : "");
416  }
417 
418  return buf;
419 }
420 
421 /* WRITERS API */
422 
423 typedef struct WriterContext WriterContext;
424 
425 #define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1
426 #define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2
427 
428 typedef enum {
434 
435 typedef struct Writer {
436  const AVClass *priv_class; ///< private class of the writer, if any
437  int priv_size; ///< private size for the writer context
438  const char *name;
439 
440  int (*init) (WriterContext *wctx);
441  void (*uninit)(WriterContext *wctx);
442 
445  void (*print_integer) (WriterContext *wctx, const char *, long long int);
446  void (*print_rational) (WriterContext *wctx, AVRational *q, char *sep);
447  void (*print_string) (WriterContext *wctx, const char *, const char *);
448  int flags; ///< a combination or WRITER_FLAG_*
449 } Writer;
450 
451 #define SECTION_MAX_NB_LEVELS 10
452 
454  const AVClass *class; ///< class of the writer
455  const Writer *writer; ///< the Writer of which this is an instance
456  char *name; ///< name of this writer instance
457  void *priv; ///< private data for use by the filter
458 
459  const struct section *sections; ///< array containing all sections
460  int nb_sections; ///< number of sections
461 
462  int level; ///< current level, starting from 0
463 
464  /** number of the item printed in the given section, starting from 0 */
466 
467  /** section per each level */
469  AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]; ///< generic print buffer dedicated to each section,
470  /// used by various writers
471 
472  unsigned int nb_section_packet; ///< number of the packet section in case we are in "packets_and_frames" section
473  unsigned int nb_section_frame; ///< number of the frame section in case we are in "packets_and_frames" section
474  unsigned int nb_section_packet_frame; ///< nb_section_packet or nb_section_frame according if is_packets_and_frames
475 
479 };
480 
481 static const char *writer_get_name(void *p)
482 {
483  WriterContext *wctx = p;
484  return wctx->writer->name;
485 }
486 
487 #define OFFSET(x) offsetof(WriterContext, x)
488 
489 static const AVOption writer_options[] = {
490  { "string_validation", "set string validation mode",
491  OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
492  { "sv", "set string validation mode",
493  OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
494  { "ignore", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_IGNORE}, .unit = "sv" },
495  { "replace", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_REPLACE}, .unit = "sv" },
496  { "fail", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_FAIL}, .unit = "sv" },
497  { "string_validation_replacement", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str=""}},
498  { "svr", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str="\xEF\xBF\xBD"}},
499  { NULL }
500 };
501 
502 static void *writer_child_next(void *obj, void *prev)
503 {
504  WriterContext *ctx = obj;
505  if (!prev && ctx->writer && ctx->writer->priv_class && ctx->priv)
506  return ctx->priv;
507  return NULL;
508 }
509 
510 static const AVClass writer_class = {
511  .class_name = "Writer",
512  .item_name = writer_get_name,
513  .option = writer_options,
514  .version = LIBAVUTIL_VERSION_INT,
515  .child_next = writer_child_next,
516 };
517 
518 static void writer_close(WriterContext **wctx)
519 {
520  int i;
521 
522  if (!*wctx)
523  return;
524 
525  if ((*wctx)->writer->uninit)
526  (*wctx)->writer->uninit(*wctx);
527  for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
528  av_bprint_finalize(&(*wctx)->section_pbuf[i], NULL);
529  if ((*wctx)->writer->priv_class)
530  av_opt_free((*wctx)->priv);
531  av_freep(&((*wctx)->priv));
532  av_opt_free(*wctx);
533  av_freep(wctx);
534 }
535 
536 static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
537 {
538  int i;
539  av_bprintf(bp, "0X");
540  for (i = 0; i < ubuf_size; i++)
541  av_bprintf(bp, "%02X", ubuf[i]);
542 }
543 
544 
545 static int writer_open(WriterContext **wctx, const Writer *writer, const char *args,
546  const struct section *sections, int nb_sections)
547 {
548  int i, ret = 0;
549 
550  if (!(*wctx = av_mallocz(sizeof(WriterContext)))) {
551  ret = AVERROR(ENOMEM);
552  goto fail;
553  }
554 
555  if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
556  ret = AVERROR(ENOMEM);
557  goto fail;
558  }
559 
560  (*wctx)->class = &writer_class;
561  (*wctx)->writer = writer;
562  (*wctx)->level = -1;
563  (*wctx)->sections = sections;
564  (*wctx)->nb_sections = nb_sections;
565 
566  av_opt_set_defaults(*wctx);
567 
568  if (writer->priv_class) {
569  void *priv_ctx = (*wctx)->priv;
570  *((const AVClass **)priv_ctx) = writer->priv_class;
571  av_opt_set_defaults(priv_ctx);
572  }
573 
574  /* convert options to dictionary */
575  if (args) {
577  AVDictionaryEntry *opt = NULL;
578 
579  if ((ret = av_dict_parse_string(&opts, args, "=", ":", 0)) < 0) {
580  av_log(*wctx, AV_LOG_ERROR, "Failed to parse option string '%s' provided to writer context\n", args);
581  av_dict_free(&opts);
582  goto fail;
583  }
584 
585  while ((opt = av_dict_get(opts, "", opt, AV_DICT_IGNORE_SUFFIX))) {
586  if ((ret = av_opt_set(*wctx, opt->key, opt->value, AV_OPT_SEARCH_CHILDREN)) < 0) {
587  av_log(*wctx, AV_LOG_ERROR, "Failed to set option '%s' with value '%s' provided to writer context\n",
588  opt->key, opt->value);
589  av_dict_free(&opts);
590  goto fail;
591  }
592  }
593 
594  av_dict_free(&opts);
595  }
596 
597  /* validate replace string */
598  {
599  const uint8_t *p = (*wctx)->string_validation_replacement;
600  const uint8_t *endp = p + strlen(p);
601  while (*p) {
602  const uint8_t *p0 = p;
603  int32_t code;
604  ret = av_utf8_decode(&code, &p, endp, (*wctx)->string_validation_utf8_flags);
605  if (ret < 0) {
606  AVBPrint bp;
608  bprint_bytes(&bp, p0, p-p0),
609  av_log(wctx, AV_LOG_ERROR,
610  "Invalid UTF8 sequence %s found in string validation replace '%s'\n",
611  bp.str, (*wctx)->string_validation_replacement);
612  return ret;
613  }
614  }
615  }
616 
617  for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
618  av_bprint_init(&(*wctx)->section_pbuf[i], 1, AV_BPRINT_SIZE_UNLIMITED);
619 
620  if ((*wctx)->writer->init)
621  ret = (*wctx)->writer->init(*wctx);
622  if (ret < 0)
623  goto fail;
624 
625  return 0;
626 
627 fail:
628  writer_close(wctx);
629  return ret;
630 }
631 
633  int section_id)
634 {
635  int parent_section_id;
636  wctx->level++;
638  parent_section_id = wctx->level ?
639  (wctx->section[wctx->level-1])->id : SECTION_ID_NONE;
640 
641  wctx->nb_item[wctx->level] = 0;
642  wctx->section[wctx->level] = &wctx->sections[section_id];
643 
644  if (section_id == SECTION_ID_PACKETS_AND_FRAMES) {
645  wctx->nb_section_packet = wctx->nb_section_frame =
646  wctx->nb_section_packet_frame = 0;
647  } else if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
648  wctx->nb_section_packet_frame = section_id == SECTION_ID_PACKET ?
649  wctx->nb_section_packet : wctx->nb_section_frame;
650  }
651 
652  if (wctx->writer->print_section_header)
653  wctx->writer->print_section_header(wctx);
654 }
655 
657 {
658  int section_id = wctx->section[wctx->level]->id;
659  int parent_section_id = wctx->level ?
660  wctx->section[wctx->level-1]->id : SECTION_ID_NONE;
661 
662  if (parent_section_id != SECTION_ID_NONE)
663  wctx->nb_item[wctx->level-1]++;
664  if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
665  if (section_id == SECTION_ID_PACKET) wctx->nb_section_packet++;
666  else wctx->nb_section_frame++;
667  }
668  if (wctx->writer->print_section_footer)
669  wctx->writer->print_section_footer(wctx);
670  wctx->level--;
671 }
672 
673 static inline void writer_print_integer(WriterContext *wctx,
674  const char *key, long long int val)
675 {
676  const struct section *section = wctx->section[wctx->level];
677 
679  wctx->writer->print_integer(wctx, key, val);
680  wctx->nb_item[wctx->level]++;
681  }
682 }
683 
684 static inline int validate_string(WriterContext *wctx, char **dstp, const char *src)
685 {
686  const uint8_t *p, *endp;
687  AVBPrint dstbuf;
688  int invalid_chars_nb = 0, ret = 0;
689 
691 
692  endp = src + strlen(src);
693  for (p = (uint8_t *)src; *p;) {
694  uint32_t code;
695  int invalid = 0;
696  const uint8_t *p0 = p;
697 
698  if (av_utf8_decode(&code, &p, endp, wctx->string_validation_utf8_flags) < 0) {
699  AVBPrint bp;
701  bprint_bytes(&bp, p0, p-p0);
702  av_log(wctx, AV_LOG_DEBUG,
703  "Invalid UTF-8 sequence %s found in string '%s'\n", bp.str, src);
704  invalid = 1;
705  }
706 
707  if (invalid) {
708  invalid_chars_nb++;
709 
710  switch (wctx->string_validation) {
712  av_log(wctx, AV_LOG_ERROR,
713  "Invalid UTF-8 sequence found in string '%s'\n", src);
715  goto end;
716  break;
717 
719  av_bprintf(&dstbuf, "%s", wctx->string_validation_replacement);
720  break;
721  }
722  }
723 
724  if (!invalid || wctx->string_validation == WRITER_STRING_VALIDATION_IGNORE)
725  av_bprint_append_data(&dstbuf, p0, p-p0);
726  }
727 
728  if (invalid_chars_nb && wctx->string_validation == WRITER_STRING_VALIDATION_REPLACE) {
729  av_log(wctx, AV_LOG_WARNING,
730  "%d invalid UTF-8 sequence(s) found in string '%s', replaced with '%s'\n",
731  invalid_chars_nb, src, wctx->string_validation_replacement);
732  }
733 
734 end:
735  av_bprint_finalize(&dstbuf, dstp);
736  return ret;
737 }
738 
739 #define PRINT_STRING_OPT 1
740 #define PRINT_STRING_VALIDATE 2
741 
742 static inline int writer_print_string(WriterContext *wctx,
743  const char *key, const char *val, int flags)
744 {
745  const struct section *section = wctx->section[wctx->level];
746  int ret = 0;
747 
748  if ((flags & PRINT_STRING_OPT)
750  return 0;
751 
754  char *key1 = NULL, *val1 = NULL;
755  ret = validate_string(wctx, &key1, key);
756  if (ret < 0) goto end;
757  ret = validate_string(wctx, &val1, val);
758  if (ret < 0) goto end;
759  wctx->writer->print_string(wctx, key1, val1);
760  end:
761  if (ret < 0) {
762  av_log(wctx, AV_LOG_ERROR,
763  "Invalid key=value string combination %s=%s in section %s\n",
765  }
766  av_free(key1);
767  av_free(val1);
768  } else {
769  wctx->writer->print_string(wctx, key, val);
770  }
771 
772  wctx->nb_item[wctx->level]++;
773  }
774 
775  return ret;
776 }
777 
778 static inline void writer_print_rational(WriterContext *wctx,
779  const char *key, AVRational q, char sep)
780 {
781  AVBPrint buf;
783  av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);
784  writer_print_string(wctx, key, buf.str, 0);
785 }
786 
787 static void writer_print_time(WriterContext *wctx, const char *key,
788  int64_t ts, const AVRational *time_base, int is_duration)
789 {
790  char buf[128];
791 
792  if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
794  } else {
795  double d = ts * av_q2d(*time_base);
796  struct unit_value uv;
797  uv.val.d = d;
798  uv.unit = unit_second_str;
799  value_string(buf, sizeof(buf), uv);
800  writer_print_string(wctx, key, buf, 0);
801  }
802 }
803 
804 static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
805 {
806  if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
808  } else {
809  writer_print_integer(wctx, key, ts);
810  }
811 }
812 
813 static void writer_print_data(WriterContext *wctx, const char *name,
814  uint8_t *data, int size)
815 {
816  AVBPrint bp;
817  int offset = 0, l, i;
818 
820  av_bprintf(&bp, "\n");
821  while (size) {
822  av_bprintf(&bp, "%08x: ", offset);
823  l = FFMIN(size, 16);
824  for (i = 0; i < l; i++) {
825  av_bprintf(&bp, "%02x", data[i]);
826  if (i & 1)
827  av_bprintf(&bp, " ");
828  }
829  av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);
830  for (i = 0; i < l; i++)
831  av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);
832  av_bprintf(&bp, "\n");
833  offset += l;
834  data += l;
835  size -= l;
836  }
837  writer_print_string(wctx, name, bp.str, 0);
838  av_bprint_finalize(&bp, NULL);
839 }
840 
841 static void writer_print_data_hash(WriterContext *wctx, const char *name,
842  uint8_t *data, int size)
843 {
844  char *p, buf[AV_HASH_MAX_SIZE * 2 + 64] = { 0 };
845 
846  if (!hash)
847  return;
850  snprintf(buf, sizeof(buf), "%s:", av_hash_get_name(hash));
851  p = buf + strlen(buf);
852  av_hash_final_hex(hash, p, buf + sizeof(buf) - p);
853  writer_print_string(wctx, name, buf, 0);
854 }
855 
856 static void writer_print_integers(WriterContext *wctx, const char *name,
857  uint8_t *data, int size, const char *format,
858  int columns, int bytes, int offset_add)
859 {
860  AVBPrint bp;
861  int offset = 0, l, i;
862 
864  av_bprintf(&bp, "\n");
865  while (size) {
866  av_bprintf(&bp, "%08x: ", offset);
867  l = FFMIN(size, columns);
868  for (i = 0; i < l; i++) {
869  if (bytes == 1) av_bprintf(&bp, format, *data);
870  else if (bytes == 2) av_bprintf(&bp, format, AV_RN16(data));
871  else if (bytes == 4) av_bprintf(&bp, format, AV_RN32(data));
872  data += bytes;
873  size --;
874  }
875  av_bprintf(&bp, "\n");
876  offset += offset_add;
877  }
878  writer_print_string(wctx, name, bp.str, 0);
879  av_bprint_finalize(&bp, NULL);
880 }
881 
882 #define MAX_REGISTERED_WRITERS_NB 64
883 
885 
886 static int writer_register(const Writer *writer)
887 {
888  static int next_registered_writer_idx = 0;
889 
890  if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)
891  return AVERROR(ENOMEM);
892 
893  registered_writers[next_registered_writer_idx++] = writer;
894  return 0;
895 }
896 
897 static const Writer *writer_get_by_name(const char *name)
898 {
899  int i;
900 
901  for (i = 0; registered_writers[i]; i++)
902  if (!strcmp(registered_writers[i]->name, name))
903  return registered_writers[i];
904 
905  return NULL;
906 }
907 
908 
909 /* WRITERS */
910 
911 #define DEFINE_WRITER_CLASS(name) \
912 static const char *name##_get_name(void *ctx) \
913 { \
914  return #name ; \
915 } \
916 static const AVClass name##_class = { \
917  .class_name = #name, \
918  .item_name = name##_get_name, \
919  .option = name##_options \
920 }
921 
922 /* Default output */
923 
924 typedef struct DefaultContext {
925  const AVClass *class;
926  int nokey;
930 
931 #undef OFFSET
932 #define OFFSET(x) offsetof(DefaultContext, x)
933 
934 static const AVOption default_options[] = {
935  { "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
936  { "nw", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
937  { "nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
938  { "nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
939  {NULL},
940 };
941 
942 DEFINE_WRITER_CLASS(default);
943 
944 /* lame uppercasing routine, assumes the string is lower case ASCII */
945 static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
946 {
947  int i;
948  for (i = 0; src[i] && i < dst_size-1; i++)
949  dst[i] = av_toupper(src[i]);
950  dst[i] = 0;
951  return dst;
952 }
953 
955 {
956  DefaultContext *def = wctx->priv;
957  char buf[32];
958  const struct section *section = wctx->section[wctx->level];
959  const struct section *parent_section = wctx->level ?
960  wctx->section[wctx->level-1] : NULL;
961 
962  av_bprint_clear(&wctx->section_pbuf[wctx->level]);
963  if (parent_section &&
964  !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
965  def->nested_section[wctx->level] = 1;
966  av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
967  wctx->section_pbuf[wctx->level-1].str,
968  upcase_string(buf, sizeof(buf),
970  }
971 
972  if (def->noprint_wrappers || def->nested_section[wctx->level])
973  return;
974 
976  printf("[%s]\n", upcase_string(buf, sizeof(buf), section->name));
977 }
978 
980 {
981  DefaultContext *def = wctx->priv;
982  const struct section *section = wctx->section[wctx->level];
983  char buf[32];
984 
985  if (def->noprint_wrappers || def->nested_section[wctx->level])
986  return;
987 
989  printf("[/%s]\n", upcase_string(buf, sizeof(buf), section->name));
990 }
991 
992 static void default_print_str(WriterContext *wctx, const char *key, const char *value)
993 {
994  DefaultContext *def = wctx->priv;
995 
996  if (!def->nokey)
997  printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
998  printf("%s\n", value);
999 }
1000 
1001 static void default_print_int(WriterContext *wctx, const char *key, long long int value)
1002 {
1003  DefaultContext *def = wctx->priv;
1004 
1005  if (!def->nokey)
1006  printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
1007  printf("%lld\n", value);
1008 }
1009 
1010 static const Writer default_writer = {
1011  .name = "default",
1012  .priv_size = sizeof(DefaultContext),
1015  .print_integer = default_print_int,
1016  .print_string = default_print_str,
1018  .priv_class = &default_class,
1019 };
1020 
1021 /* Compact output */
1022 
1023 /**
1024  * Apply C-language-like string escaping.
1025  */
1026 static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1027 {
1028  const char *p;
1029 
1030  for (p = src; *p; p++) {
1031  switch (*p) {
1032  case '\b': av_bprintf(dst, "%s", "\\b"); break;
1033  case '\f': av_bprintf(dst, "%s", "\\f"); break;
1034  case '\n': av_bprintf(dst, "%s", "\\n"); break;
1035  case '\r': av_bprintf(dst, "%s", "\\r"); break;
1036  case '\\': av_bprintf(dst, "%s", "\\\\"); break;
1037  default:
1038  if (*p == sep)
1039  av_bprint_chars(dst, '\\', 1);
1040  av_bprint_chars(dst, *p, 1);
1041  }
1042  }
1043  return dst->str;
1044 }
1045 
1046 /**
1047  * Quote fields containing special characters, check RFC4180.
1048  */
1049 static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1050 {
1051  char meta_chars[] = { sep, '"', '\n', '\r', '\0' };
1052  int needs_quoting = !!src[strcspn(src, meta_chars)];
1053 
1054  if (needs_quoting)
1055  av_bprint_chars(dst, '"', 1);
1056 
1057  for (; *src; src++) {
1058  if (*src == '"')
1059  av_bprint_chars(dst, '"', 1);
1060  av_bprint_chars(dst, *src, 1);
1061  }
1062  if (needs_quoting)
1063  av_bprint_chars(dst, '"', 1);
1064  return dst->str;
1065 }
1066 
1067 static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1068 {
1069  return src;
1070 }
1071 
1072 typedef struct CompactContext {
1073  const AVClass *class;
1075  char item_sep;
1076  int nokey;
1079  const char * (*escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx);
1083 } CompactContext;
1084 
1085 #undef OFFSET
1086 #define OFFSET(x) offsetof(CompactContext, x)
1087 
1088 static const AVOption compact_options[]= {
1089  {"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, 0, 0 },
1090  {"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, 0, 0 },
1091  {"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1092  {"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1093  {"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, 0, 0 },
1094  {"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, 0, 0 },
1095  {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1096  {"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1097  {NULL},
1098 };
1099 
1100 DEFINE_WRITER_CLASS(compact);
1101 
1103 {
1104  CompactContext *compact = wctx->priv;
1105 
1106  if (strlen(compact->item_sep_str) != 1) {
1107  av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
1108  compact->item_sep_str);
1109  return AVERROR(EINVAL);
1110  }
1111  compact->item_sep = compact->item_sep_str[0];
1112 
1113  if (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;
1114  else if (!strcmp(compact->escape_mode_str, "c" )) compact->escape_str = c_escape_str;
1115  else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;
1116  else {
1117  av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);
1118  return AVERROR(EINVAL);
1119  }
1120 
1121  return 0;
1122 }
1123 
1125 {
1126  CompactContext *compact = wctx->priv;
1127  const struct section *section = wctx->section[wctx->level];
1128  const struct section *parent_section = wctx->level ?
1129  wctx->section[wctx->level-1] : NULL;
1130  compact->terminate_line[wctx->level] = 1;
1131  compact->has_nested_elems[wctx->level] = 0;
1132 
1133  av_bprint_clear(&wctx->section_pbuf[wctx->level]);
1134  if (!(section->flags & SECTION_FLAG_IS_ARRAY) && parent_section &&
1135  !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
1136  compact->nested_section[wctx->level] = 1;
1137  compact->has_nested_elems[wctx->level-1] = 1;
1138  av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
1139  wctx->section_pbuf[wctx->level-1].str,
1141  wctx->nb_item[wctx->level] = wctx->nb_item[wctx->level-1];
1142  } else {
1143  if (parent_section && compact->has_nested_elems[wctx->level-1] &&
1145  compact->terminate_line[wctx->level-1] = 0;
1146  printf("\n");
1147  }
1148  if (compact->print_section &&
1150  printf("%s%c", section->name, compact->item_sep);
1151  }
1152 }
1153 
1155 {
1156  CompactContext *compact = wctx->priv;
1157 
1158  if (!compact->nested_section[wctx->level] &&
1159  compact->terminate_line[wctx->level] &&
1161  printf("\n");
1162 }
1163 
1164 static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
1165 {
1166  CompactContext *compact = wctx->priv;
1167  AVBPrint buf;
1168 
1169  if (wctx->nb_item[wctx->level]) printf("%c", compact->item_sep);
1170  if (!compact->nokey)
1171  printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
1173  printf("%s", compact->escape_str(&buf, value, compact->item_sep, wctx));
1174  av_bprint_finalize(&buf, NULL);
1175 }
1176 
1177 static void compact_print_int(WriterContext *wctx, const char *key, long long int value)
1178 {
1179  CompactContext *compact = wctx->priv;
1180 
1181  if (wctx->nb_item[wctx->level]) printf("%c", compact->item_sep);
1182  if (!compact->nokey)
1183  printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
1184  printf("%lld", value);
1185 }
1186 
1187 static const Writer compact_writer = {
1188  .name = "compact",
1189  .priv_size = sizeof(CompactContext),
1190  .init = compact_init,
1193  .print_integer = compact_print_int,
1194  .print_string = compact_print_str,
1196  .priv_class = &compact_class,
1197 };
1198 
1199 /* CSV output */
1200 
1201 #undef OFFSET
1202 #define OFFSET(x) offsetof(CompactContext, x)
1203 
1204 static const AVOption csv_options[] = {
1205  {"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, 0, 0 },
1206  {"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, 0, 0 },
1207  {"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1208  {"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1209  {"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, 0, 0 },
1210  {"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, 0, 0 },
1211  {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1212  {"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1213  {NULL},
1214 };
1215 
1216 DEFINE_WRITER_CLASS(csv);
1217 
1218 static const Writer csv_writer = {
1219  .name = "csv",
1220  .priv_size = sizeof(CompactContext),
1221  .init = compact_init,
1224  .print_integer = compact_print_int,
1225  .print_string = compact_print_str,
1227  .priv_class = &csv_class,
1228 };
1229 
1230 /* Flat output */
1231 
1232 typedef struct FlatContext {
1233  const AVClass *class;
1234  const char *sep_str;
1235  char sep;
1237 } FlatContext;
1238 
1239 #undef OFFSET
1240 #define OFFSET(x) offsetof(FlatContext, x)
1241 
1242 static const AVOption flat_options[]= {
1243  {"sep_char", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, 0, 0 },
1244  {"s", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, 0, 0 },
1245  {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1246  {"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1247  {NULL},
1248 };
1249 
1251 
1253 {
1254  FlatContext *flat = wctx->priv;
1255 
1256  if (strlen(flat->sep_str) != 1) {
1257  av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
1258  flat->sep_str);
1259  return AVERROR(EINVAL);
1260  }
1261  flat->sep = flat->sep_str[0];
1262 
1263  return 0;
1264 }
1265 
1266 static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
1267 {
1268  const char *p;
1269 
1270  for (p = src; *p; p++) {
1271  if (!((*p >= '0' && *p <= '9') ||
1272  (*p >= 'a' && *p <= 'z') ||
1273  (*p >= 'A' && *p <= 'Z')))
1274  av_bprint_chars(dst, '_', 1);
1275  else
1276  av_bprint_chars(dst, *p, 1);
1277  }
1278  return dst->str;
1279 }
1280 
1281 static const char *flat_escape_value_str(AVBPrint *dst, const char *src)
1282 {
1283  const char *p;
1284 
1285  for (p = src; *p; p++) {
1286  switch (*p) {
1287  case '\n': av_bprintf(dst, "%s", "\\n"); break;
1288  case '\r': av_bprintf(dst, "%s", "\\r"); break;
1289  case '\\': av_bprintf(dst, "%s", "\\\\"); break;
1290  case '"': av_bprintf(dst, "%s", "\\\""); break;
1291  case '`': av_bprintf(dst, "%s", "\\`"); break;
1292  case '$': av_bprintf(dst, "%s", "\\$"); break;
1293  default: av_bprint_chars(dst, *p, 1); break;
1294  }
1295  }
1296  return dst->str;
1297 }
1298 
1300 {
1301  FlatContext *flat = wctx->priv;
1302  AVBPrint *buf = &wctx->section_pbuf[wctx->level];
1303  const struct section *section = wctx->section[wctx->level];
1304  const struct section *parent_section = wctx->level ?
1305  wctx->section[wctx->level-1] : NULL;
1306 
1307  /* build section header */
1308  av_bprint_clear(buf);
1309  if (!parent_section)
1310  return;
1311  av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
1312 
1313  if (flat->hierarchical ||
1315  av_bprintf(buf, "%s%s", wctx->section[wctx->level]->name, flat->sep_str);
1316 
1317  if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
1318  int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
1319  wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
1320  av_bprintf(buf, "%d%s", n, flat->sep_str);
1321  }
1322  }
1323 }
1324 
1325 static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
1326 {
1327  printf("%s%s=%lld\n", wctx->section_pbuf[wctx->level].str, key, value);
1328 }
1329 
1330 static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
1331 {
1332  FlatContext *flat = wctx->priv;
1333  AVBPrint buf;
1334 
1335  printf("%s", wctx->section_pbuf[wctx->level].str);
1337  printf("%s=", flat_escape_key_str(&buf, key, flat->sep));
1338  av_bprint_clear(&buf);
1339  printf("\"%s\"\n", flat_escape_value_str(&buf, value));
1340  av_bprint_finalize(&buf, NULL);
1341 }
1342 
1343 static const Writer flat_writer = {
1344  .name = "flat",
1345  .priv_size = sizeof(FlatContext),
1346  .init = flat_init,
1348  .print_integer = flat_print_int,
1349  .print_string = flat_print_str,
1351  .priv_class = &flat_class,
1352 };
1353 
1354 /* INI format output */
1355 
1356 typedef struct INIContext {
1357  const AVClass *class;
1359 } INIContext;
1360 
1361 #undef OFFSET
1362 #define OFFSET(x) offsetof(INIContext, x)
1363 
1364 static const AVOption ini_options[] = {
1365  {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1366  {"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1367  {NULL},
1368 };
1369 
1370 DEFINE_WRITER_CLASS(ini);
1371 
1372 static char *ini_escape_str(AVBPrint *dst, const char *src)
1373 {
1374  int i = 0;
1375  char c = 0;
1376 
1377  while (c = src[i++]) {
1378  switch (c) {
1379  case '\b': av_bprintf(dst, "%s", "\\b"); break;
1380  case '\f': av_bprintf(dst, "%s", "\\f"); break;
1381  case '\n': av_bprintf(dst, "%s", "\\n"); break;
1382  case '\r': av_bprintf(dst, "%s", "\\r"); break;
1383  case '\t': av_bprintf(dst, "%s", "\\t"); break;
1384  case '\\':
1385  case '#' :
1386  case '=' :
1387  case ':' : av_bprint_chars(dst, '\\', 1);
1388  default:
1389  if ((unsigned char)c < 32)
1390  av_bprintf(dst, "\\x00%02x", c & 0xff);
1391  else
1392  av_bprint_chars(dst, c, 1);
1393  break;
1394  }
1395  }
1396  return dst->str;
1397 }
1398 
1400 {
1401  INIContext *ini = wctx->priv;
1402  AVBPrint *buf = &wctx->section_pbuf[wctx->level];
1403  const struct section *section = wctx->section[wctx->level];
1404  const struct section *parent_section = wctx->level ?
1405  wctx->section[wctx->level-1] : NULL;
1406 
1407  av_bprint_clear(buf);
1408  if (!parent_section) {
1409  printf("# ffprobe output\n\n");
1410  return;
1411  }
1412 
1413  if (wctx->nb_item[wctx->level-1])
1414  printf("\n");
1415 
1416  av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
1417  if (ini->hierarchical ||
1419  av_bprintf(buf, "%s%s", buf->str[0] ? "." : "", wctx->section[wctx->level]->name);
1420 
1421  if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
1422  int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
1423  wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
1424  av_bprintf(buf, ".%d", n);
1425  }
1426  }
1427 
1429  printf("[%s]\n", buf->str);
1430 }
1431 
1432 static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
1433 {
1434  AVBPrint buf;
1435 
1437  printf("%s=", ini_escape_str(&buf, key));
1438  av_bprint_clear(&buf);
1439  printf("%s\n", ini_escape_str(&buf, value));
1440  av_bprint_finalize(&buf, NULL);
1441 }
1442 
1443 static void ini_print_int(WriterContext *wctx, const char *key, long long int value)
1444 {
1445  printf("%s=%lld\n", key, value);
1446 }
1447 
1448 static const Writer ini_writer = {
1449  .name = "ini",
1450  .priv_size = sizeof(INIContext),
1452  .print_integer = ini_print_int,
1453  .print_string = ini_print_str,
1455  .priv_class = &ini_class,
1456 };
1457 
1458 /* JSON output */
1459 
1460 typedef struct JSONContext {
1461  const AVClass *class;
1463  int compact;
1464  const char *item_sep, *item_start_end;
1465 } JSONContext;
1466 
1467 #undef OFFSET
1468 #define OFFSET(x) offsetof(JSONContext, x)
1469 
1470 static const AVOption json_options[]= {
1471  { "compact", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1472  { "c", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1473  { NULL }
1474 };
1475 
1476 DEFINE_WRITER_CLASS(json);
1477 
1479 {
1480  JSONContext *json = wctx->priv;
1481 
1482  json->item_sep = json->compact ? ", " : ",\n";
1483  json->item_start_end = json->compact ? " " : "\n";
1484 
1485  return 0;
1486 }
1487 
1488 static const char *json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
1489 {
1490  static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
1491  static const char json_subst[] = {'"', '\\', 'b', 'f', 'n', 'r', 't', 0};
1492  const char *p;
1493 
1494  for (p = src; *p; p++) {
1495  char *s = strchr(json_escape, *p);
1496  if (s) {
1497  av_bprint_chars(dst, '\\', 1);
1498  av_bprint_chars(dst, json_subst[s - json_escape], 1);
1499  } else if ((unsigned char)*p < 32) {
1500  av_bprintf(dst, "\\u00%02x", *p & 0xff);
1501  } else {
1502  av_bprint_chars(dst, *p, 1);
1503  }
1504  }
1505  return dst->str;
1506 }
1507 
1508 #define JSON_INDENT() printf("%*c", json->indent_level * 4, ' ')
1509 
1511 {
1512  JSONContext *json = wctx->priv;
1513  AVBPrint buf;
1514  const struct section *section = wctx->section[wctx->level];
1515  const struct section *parent_section = wctx->level ?
1516  wctx->section[wctx->level-1] : NULL;
1517 
1518  if (wctx->level && wctx->nb_item[wctx->level-1])
1519  printf(",\n");
1520 
1522  printf("{\n");
1523  json->indent_level++;
1524  } else {
1526  json_escape_str(&buf, section->name, wctx);
1527  JSON_INDENT();
1528 
1529  json->indent_level++;
1531  printf("\"%s\": [\n", buf.str);
1532  } else if (parent_section && !(parent_section->flags & SECTION_FLAG_IS_ARRAY)) {
1533  printf("\"%s\": {%s", buf.str, json->item_start_end);
1534  } else {
1535  printf("{%s", json->item_start_end);
1536 
1537  /* this is required so the parser can distinguish between packets and frames */
1538  if (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES) {
1539  if (!json->compact)
1540  JSON_INDENT();
1541  printf("\"type\": \"%s\"", section->name);
1542  }
1543  }
1544  av_bprint_finalize(&buf, NULL);
1545  }
1546 }
1547 
1549 {
1550  JSONContext *json = wctx->priv;
1551  const struct section *section = wctx->section[wctx->level];
1552 
1553  if (wctx->level == 0) {
1554  json->indent_level--;
1555  printf("\n}\n");
1556  } else if (section->flags & SECTION_FLAG_IS_ARRAY) {
1557  printf("\n");
1558  json->indent_level--;
1559  JSON_INDENT();
1560  printf("]");
1561  } else {
1562  printf("%s", json->item_start_end);
1563  json->indent_level--;
1564  if (!json->compact)
1565  JSON_INDENT();
1566  printf("}");
1567  }
1568 }
1569 
1570 static inline void json_print_item_str(WriterContext *wctx,
1571  const char *key, const char *value)
1572 {
1573  AVBPrint buf;
1574 
1576  printf("\"%s\":", json_escape_str(&buf, key, wctx));
1577  av_bprint_clear(&buf);
1578  printf(" \"%s\"", json_escape_str(&buf, value, wctx));
1579  av_bprint_finalize(&buf, NULL);
1580 }
1581 
1582 static void json_print_str(WriterContext *wctx, const char *key, const char *value)
1583 {
1584  JSONContext *json = wctx->priv;
1585  const struct section *parent_section = wctx->level ?
1586  wctx->section[wctx->level-1] : NULL;
1587 
1588  if (wctx->nb_item[wctx->level] || (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES))
1589  printf("%s", json->item_sep);
1590  if (!json->compact)
1591  JSON_INDENT();
1592  json_print_item_str(wctx, key, value);
1593 }
1594 
1595 static void json_print_int(WriterContext *wctx, const char *key, long long int value)
1596 {
1597  JSONContext *json = wctx->priv;
1598  const struct section *parent_section = wctx->level ?
1599  wctx->section[wctx->level-1] : NULL;
1600  AVBPrint buf;
1601 
1602  if (wctx->nb_item[wctx->level] || (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES))
1603  printf("%s", json->item_sep);
1604  if (!json->compact)
1605  JSON_INDENT();
1606 
1608  printf("\"%s\": %lld", json_escape_str(&buf, key, wctx), value);
1609  av_bprint_finalize(&buf, NULL);
1610 }
1611 
1612 static const Writer json_writer = {
1613  .name = "json",
1614  .priv_size = sizeof(JSONContext),
1615  .init = json_init,
1618  .print_integer = json_print_int,
1619  .print_string = json_print_str,
1621  .priv_class = &json_class,
1622 };
1623 
1624 /* XML output */
1625 
1626 typedef struct XMLContext {
1627  const AVClass *class;
1632 } XMLContext;
1633 
1634 #undef OFFSET
1635 #define OFFSET(x) offsetof(XMLContext, x)
1636 
1637 static const AVOption xml_options[] = {
1638  {"fully_qualified", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1639  {"q", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1640  {"xsd_strict", "ensure that the output is XSD compliant", OFFSET(xsd_strict), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1641  {"x", "ensure that the output is XSD compliant", OFFSET(xsd_strict), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1642  {NULL},
1643 };
1644 
1645 DEFINE_WRITER_CLASS(xml);
1646 
1647 static av_cold int xml_init(WriterContext *wctx)
1648 {
1649  XMLContext *xml = wctx->priv;
1650 
1651  if (xml->xsd_strict) {
1652  xml->fully_qualified = 1;
1653 #define CHECK_COMPLIANCE(opt, opt_name) \
1654  if (opt) { \
1655  av_log(wctx, AV_LOG_ERROR, \
1656  "XSD-compliant output selected but option '%s' was selected, XML output may be non-compliant.\n" \
1657  "You need to disable such option with '-no%s'\n", opt_name, opt_name); \
1658  return AVERROR(EINVAL); \
1659  }
1660  CHECK_COMPLIANCE(show_private_data, "private");
1663 
1665  av_log(wctx, AV_LOG_ERROR,
1666  "Interleaved frames and packets are not allowed in XSD. "
1667  "Select only one between the -show_frames and the -show_packets options.\n");
1668  return AVERROR(EINVAL);
1669  }
1670  }
1671 
1672  return 0;
1673 }
1674 
1675 #define XML_INDENT() printf("%*c", xml->indent_level * 4, ' ')
1676 
1678 {
1679  XMLContext *xml = wctx->priv;
1680  const struct section *section = wctx->section[wctx->level];
1681  const struct section *parent_section = wctx->level ?
1682  wctx->section[wctx->level-1] : NULL;
1683 
1684  if (wctx->level == 0) {
1685  const char *qual = " xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
1686  "xmlns:ffprobe='http://www.ffmpeg.org/schema/ffprobe' "
1687  "xsi:schemaLocation='http://www.ffmpeg.org/schema/ffprobe ffprobe.xsd'";
1688 
1689  printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
1690  printf("<%sffprobe%s>\n",
1691  xml->fully_qualified ? "ffprobe:" : "",
1692  xml->fully_qualified ? qual : "");
1693  return;
1694  }
1695 
1696  if (xml->within_tag) {
1697  xml->within_tag = 0;
1698  printf(">\n");
1699  }
1701  xml->indent_level++;
1702  } else {
1703  if (parent_section && (parent_section->flags & SECTION_FLAG_IS_WRAPPER) &&
1704  wctx->level && wctx->nb_item[wctx->level-1])
1705  printf("\n");
1706  xml->indent_level++;
1707 
1709  XML_INDENT(); printf("<%s>\n", section->name);
1710  } else {
1711  XML_INDENT(); printf("<%s ", section->name);
1712  xml->within_tag = 1;
1713  }
1714  }
1715 }
1716 
1718 {
1719  XMLContext *xml = wctx->priv;
1720  const struct section *section = wctx->section[wctx->level];
1721 
1722  if (wctx->level == 0) {
1723  printf("</%sffprobe>\n", xml->fully_qualified ? "ffprobe:" : "");
1724  } else if (xml->within_tag) {
1725  xml->within_tag = 0;
1726  printf("/>\n");
1727  xml->indent_level--;
1729  xml->indent_level--;
1730  } else {
1731  XML_INDENT(); printf("</%s>\n", section->name);
1732  xml->indent_level--;
1733  }
1734 }
1735 
1736 static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
1737 {
1738  AVBPrint buf;
1739  XMLContext *xml = wctx->priv;
1740  const struct section *section = wctx->section[wctx->level];
1741 
1743 
1745  XML_INDENT();
1746  av_bprint_escape(&buf, key, NULL,
1748  printf("<%s key=\"%s\"",
1749  section->element_name, buf.str);
1750  av_bprint_clear(&buf);
1751 
1752  av_bprint_escape(&buf, value, NULL,
1754  printf(" value=\"%s\"/>\n", buf.str);
1755  } else {
1756  if (wctx->nb_item[wctx->level])
1757  printf(" ");
1758 
1759  av_bprint_escape(&buf, value, NULL,
1761  printf("%s=\"%s\"", key, buf.str);
1762  }
1763 
1764  av_bprint_finalize(&buf, NULL);
1765 }
1766 
1767 static void xml_print_int(WriterContext *wctx, const char *key, long long int value)
1768 {
1769  if (wctx->nb_item[wctx->level])
1770  printf(" ");
1771  printf("%s=\"%lld\"", key, value);
1772 }
1773 
1774 static Writer xml_writer = {
1775  .name = "xml",
1776  .priv_size = sizeof(XMLContext),
1777  .init = xml_init,
1780  .print_integer = xml_print_int,
1781  .print_string = xml_print_str,
1783  .priv_class = &xml_class,
1784 };
1785 
1786 static void writer_register_all(void)
1787 {
1788  static int initialized;
1789 
1790  if (initialized)
1791  return;
1792  initialized = 1;
1793 
1801 }
1802 
1803 #define print_fmt(k, f, ...) do { \
1804  av_bprint_clear(&pbuf); \
1805  av_bprintf(&pbuf, f, __VA_ARGS__); \
1806  writer_print_string(w, k, pbuf.str, 0); \
1807 } while (0)
1808 
1809 #define print_int(k, v) writer_print_integer(w, k, v)
1810 #define print_q(k, v, s) writer_print_rational(w, k, v, s)
1811 #define print_str(k, v) writer_print_string(w, k, v, 0)
1812 #define print_str_opt(k, v) writer_print_string(w, k, v, PRINT_STRING_OPT)
1813 #define print_str_validate(k, v) writer_print_string(w, k, v, PRINT_STRING_VALIDATE)
1814 #define print_time(k, v, tb) writer_print_time(w, k, v, tb, 0)
1815 #define print_ts(k, v) writer_print_ts(w, k, v, 0)
1816 #define print_duration_time(k, v, tb) writer_print_time(w, k, v, tb, 1)
1817 #define print_duration_ts(k, v) writer_print_ts(w, k, v, 1)
1818 #define print_val(k, v, u) do { \
1819  struct unit_value uv; \
1820  uv.val.i = v; \
1821  uv.unit = u; \
1822  writer_print_string(w, k, value_string(val_str, sizeof(val_str), uv), 0); \
1823 } while (0)
1824 
1825 #define print_section_header(s) writer_print_section_header(w, s)
1826 #define print_section_footer(s) writer_print_section_footer(w, s)
1827 
1828 #define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n) \
1829 { \
1830  ret = av_reallocp_array(&(ptr), (new_n), sizeof(*(ptr))); \
1831  if (ret < 0) \
1832  goto end; \
1833  memset( (ptr) + (cur_n), 0, ((new_n) - (cur_n)) * sizeof(*(ptr)) ); \
1834 }
1835 
1836 static inline int show_tags(WriterContext *w, AVDictionary *tags, int section_id)
1837 {
1839  int ret = 0;
1840 
1841  if (!tags)
1842  return 0;
1843  writer_print_section_header(w, section_id);
1844 
1845  while ((tag = av_dict_get(tags, "", tag, AV_DICT_IGNORE_SUFFIX))) {
1846  if ((ret = print_str_validate(tag->key, tag->value)) < 0)
1847  break;
1848  }
1850 
1851  return ret;
1852 }
1853 
1855 {
1856  if (!metadata)
1857  return;
1858  print_int("application version", metadata->application_version);
1859  print_int("num_windows", metadata->num_windows);
1860  for (int n = 1; n < metadata->num_windows; n++) {
1861  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
1862  print_q("window_upper_left_corner_x",
1863  params->window_upper_left_corner_x,'/');
1864  print_q("window_upper_left_corner_y",
1865  params->window_upper_left_corner_y,'/');
1866  print_q("window_lower_right_corner_x",
1867  params->window_lower_right_corner_x,'/');
1868  print_q("window_lower_right_corner_y",
1869  params->window_lower_right_corner_y,'/');
1870  print_q("window_upper_left_corner_x",
1871  params->window_upper_left_corner_x,'/');
1872  print_q("window_upper_left_corner_y",
1873  params->window_upper_left_corner_y,'/');
1874  print_int("center_of_ellipse_x",
1875  params->center_of_ellipse_x ) ;
1876  print_int("center_of_ellipse_y",
1877  params->center_of_ellipse_y );
1878  print_int("rotation_angle",
1879  params->rotation_angle);
1880  print_int("semimajor_axis_internal_ellipse",
1882  print_int("semimajor_axis_external_ellipse",
1884  print_int("semiminor_axis_external_ellipse",
1886  print_int("overlap_process_option",
1887  params->overlap_process_option);
1888  }
1889  print_q("targeted_system_display_maximum_luminance",
1892  print_int("num_rows_targeted_system_display_actual_peak_luminance",
1894  print_int("num_cols_targeted_system_display_actual_peak_luminance",
1896  for (int i = 0; i < metadata->num_rows_targeted_system_display_actual_peak_luminance; i++) {
1897  for (int j = 0; j < metadata->num_cols_targeted_system_display_actual_peak_luminance; j++) {
1898  print_q("targeted_system_display_actual_peak_luminance",
1900  }
1901  }
1902  }
1903  for (int n = 0; n < metadata->num_windows; n++) {
1904  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
1905  for (int i = 0; i < 3; i++) {
1906  print_q("maxscl",params->maxscl[i],'/');
1907  }
1908  print_q("average_maxrgb",
1909  params->average_maxrgb,'/');
1910  print_int("num_distribution_maxrgb_percentiles",
1912  for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
1913  print_int("distribution_maxrgb_percentage",
1914  params->distribution_maxrgb[i].percentage);
1915  print_q("distribution_maxrgb_percentile",
1916  params->distribution_maxrgb[i].percentile,'/');
1917  }
1918  print_q("fraction_bright_pixels",
1919  params->fraction_bright_pixels,'/');
1920  }
1922  print_int("num_rows_mastering_display_actual_peak_luminance",
1924  print_int("num_cols_mastering_display_actual_peak_luminance",
1926  for (int i = 0; i < metadata->num_rows_mastering_display_actual_peak_luminance; i++) {
1927  for (int j = 0; j < metadata->num_cols_mastering_display_actual_peak_luminance; j++) {
1928  print_q("mastering_display_actual_peak_luminance",
1929  metadata->mastering_display_actual_peak_luminance[i][j],'/');
1930  }
1931  }
1932  }
1933 
1934  for (int n = 0; n < metadata->num_windows; n++) {
1935  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
1936  if (params->tone_mapping_flag) {
1937  print_q("knee_point_x", params->knee_point_x,'/');
1938  print_q("knee_point_y", params->knee_point_y,'/');
1939  print_int("num_bezier_curve_anchors",
1940  params->num_bezier_curve_anchors );
1941  for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
1942  print_q("bezier_curve_anchors",
1943  params->bezier_curve_anchors[i],'/');
1944  }
1945  }
1946  if (params->color_saturation_mapping_flag) {
1947  print_q("color_saturation_weight",
1948  params->color_saturation_weight,'/');
1949  }
1950  }
1951 }
1952 
1954  AVCodecParameters *par,
1955  const AVPacketSideData *side_data,
1956  int nb_side_data,
1957  SectionID id_data_list,
1958  SectionID id_data)
1959 {
1960  int i;
1961 
1962  writer_print_section_header(w, id_data_list);
1963  for (i = 0; i < nb_side_data; i++) {
1964  const AVPacketSideData *sd = &side_data[i];
1965  const char *name = av_packet_side_data_name(sd->type);
1966 
1967  writer_print_section_header(w, id_data);
1968  print_str("side_data_type", name ? name : "unknown");
1969  if (sd->type == AV_PKT_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
1970  writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
1971  print_int("rotation", av_display_rotation_get((int32_t *)sd->data));
1972  } else if (sd->type == AV_PKT_DATA_STEREO3D) {
1973  const AVStereo3D *stereo = (AVStereo3D *)sd->data;
1974  print_str("type", av_stereo3d_type_name(stereo->type));
1975  print_int("inverted", !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
1976  } else if (sd->type == AV_PKT_DATA_SPHERICAL) {
1977  const AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
1978  print_str("projection", av_spherical_projection_name(spherical->projection));
1979  if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
1980  print_int("padding", spherical->padding);
1981  } else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
1982  size_t l, t, r, b;
1983  av_spherical_tile_bounds(spherical, par->width, par->height,
1984  &l, &t, &r, &b);
1985  print_int("bound_left", l);
1986  print_int("bound_top", t);
1987  print_int("bound_right", r);
1988  print_int("bound_bottom", b);
1989  }
1990 
1991  print_int("yaw", (double) spherical->yaw / (1 << 16));
1992  print_int("pitch", (double) spherical->pitch / (1 << 16));
1993  print_int("roll", (double) spherical->roll / (1 << 16));
1994  } else if (sd->type == AV_PKT_DATA_SKIP_SAMPLES && sd->size == 10) {
1995  print_int("skip_samples", AV_RL32(sd->data));
1996  print_int("discard_padding", AV_RL32(sd->data + 4));
1997  print_int("skip_reason", AV_RL8(sd->data + 8));
1998  print_int("discard_reason", AV_RL8(sd->data + 9));
1999  } else if (sd->type == AV_PKT_DATA_MASTERING_DISPLAY_METADATA) {
2001 
2002  if (metadata->has_primaries) {
2003  print_q("red_x", metadata->display_primaries[0][0], '/');
2004  print_q("red_y", metadata->display_primaries[0][1], '/');
2005  print_q("green_x", metadata->display_primaries[1][0], '/');
2006  print_q("green_y", metadata->display_primaries[1][1], '/');
2007  print_q("blue_x", metadata->display_primaries[2][0], '/');
2008  print_q("blue_y", metadata->display_primaries[2][1], '/');
2009 
2010  print_q("white_point_x", metadata->white_point[0], '/');
2011  print_q("white_point_y", metadata->white_point[1], '/');
2012  }
2013 
2014  if (metadata->has_luminance) {
2015  print_q("min_luminance", metadata->min_luminance, '/');
2016  print_q("max_luminance", metadata->max_luminance, '/');
2017  }
2018  } else if (sd->type == AV_PKT_DATA_CONTENT_LIGHT_LEVEL) {
2020  print_int("max_content", metadata->MaxCLL);
2021  print_int("max_average", metadata->MaxFALL);
2022  } else if (sd->type == AV_PKT_DATA_DOVI_CONF) {
2024  print_int("dv_version_major", dovi->dv_version_major);
2025  print_int("dv_version_minor", dovi->dv_version_minor);
2026  print_int("dv_profile", dovi->dv_profile);
2027  print_int("dv_level", dovi->dv_level);
2028  print_int("rpu_present_flag", dovi->rpu_present_flag);
2029  print_int("el_present_flag", dovi->el_present_flag);
2030  print_int("bl_present_flag", dovi->bl_present_flag);
2031  print_int("dv_bl_signal_compatibility_id", dovi->dv_bl_signal_compatibility_id);
2032  }
2034  }
2036 }
2037 
2039 {
2040  const char *val = av_color_range_name(color_range);
2042  print_str_opt("color_range", "unknown");
2043  } else {
2044  print_str("color_range", val);
2045  }
2046 }
2047 
2048 static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
2049 {
2050  const char *val = av_color_space_name(color_space);
2051  if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
2052  print_str_opt("color_space", "unknown");
2053  } else {
2054  print_str("color_space", val);
2055  }
2056 }
2057 
2059 {
2062  print_str_opt("color_primaries", "unknown");
2063  } else {
2064  print_str("color_primaries", val);
2065  }
2066 }
2067 
2069 {
2070  const char *val = av_color_transfer_name(color_trc);
2071  if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
2072  print_str_opt("color_transfer", "unknown");
2073  } else {
2074  print_str("color_transfer", val);
2075  }
2076 }
2077 
2078 static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
2079 {
2080  const char *val = av_chroma_location_name(chroma_location);
2081  if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
2082  print_str_opt("chroma_location", "unspecified");
2083  } else {
2084  print_str("chroma_location", val);
2085  }
2086 }
2087 
2088 
2089 static void clear_log(int need_lock)
2090 {
2091  int i;
2092 
2093  if (need_lock)
2094  pthread_mutex_lock(&log_mutex);
2095  for (i=0; i<log_buffer_size; i++) {
2096  av_freep(&log_buffer[i].context_name);
2097  av_freep(&log_buffer[i].parent_name);
2098  av_freep(&log_buffer[i].log_message);
2099  }
2100  log_buffer_size = 0;
2101  if(need_lock)
2102  pthread_mutex_unlock(&log_mutex);
2103 }
2104 
2105 static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
2106 {
2107  int i;
2108  pthread_mutex_lock(&log_mutex);
2109  if (!log_buffer_size) {
2110  pthread_mutex_unlock(&log_mutex);
2111  return 0;
2112  }
2113  writer_print_section_header(w, section_ids);
2114 
2115  for (i=0; i<log_buffer_size; i++) {
2116  if (log_buffer[i].log_level <= log_level) {
2117  writer_print_section_header(w, section_id);
2118  print_str("context", log_buffer[i].context_name);
2119  print_int("level", log_buffer[i].log_level);
2120  print_int("category", log_buffer[i].category);
2121  if (log_buffer[i].parent_name) {
2122  print_str("parent_context", log_buffer[i].parent_name);
2123  print_int("parent_category", log_buffer[i].parent_category);
2124  } else {
2125  print_str_opt("parent_context", "N/A");
2126  print_str_opt("parent_category", "N/A");
2127  }
2128  print_str("message", log_buffer[i].log_message);
2130  }
2131  }
2132  clear_log(0);
2133  pthread_mutex_unlock(&log_mutex);
2134 
2136 
2137  return 0;
2138 }
2139 
2140 static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
2141 {
2142  char val_str[128];
2143  AVStream *st = ifile->streams[pkt->stream_index].st;
2144  AVBPrint pbuf;
2145  const char *s;
2146 
2148 
2150 
2152  if (s) print_str ("codec_type", s);
2153  else print_str_opt("codec_type", "unknown");
2154  print_int("stream_index", pkt->stream_index);
2155  print_ts ("pts", pkt->pts);
2156  print_time("pts_time", pkt->pts, &st->time_base);
2157  print_ts ("dts", pkt->dts);
2158  print_time("dts_time", pkt->dts, &st->time_base);
2159  print_duration_ts("duration", pkt->duration);
2160  print_duration_time("duration_time", pkt->duration, &st->time_base);
2161  print_val("size", pkt->size, unit_byte_str);
2162  if (pkt->pos != -1) print_fmt ("pos", "%"PRId64, pkt->pos);
2163  else print_str_opt("pos", "N/A");
2164  print_fmt("flags", "%c%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_',
2165  pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_');
2166 
2167  if (pkt->side_data_elems) {
2168  int size;
2169  const uint8_t *side_metadata;
2170 
2172  if (side_metadata && size && do_show_packet_tags) {
2173  AVDictionary *dict = NULL;
2174  if (av_packet_unpack_dictionary(side_metadata, size, &dict) >= 0)
2176  av_dict_free(&dict);
2177  }
2178 
2182  }
2183 
2184  if (do_show_data)
2185  writer_print_data(w, "data", pkt->data, pkt->size);
2186  writer_print_data_hash(w, "data_hash", pkt->data, pkt->size);
2188 
2189  av_bprint_finalize(&pbuf, NULL);
2190  fflush(stdout);
2191 }
2192 
2195 {
2196  AVBPrint pbuf;
2197 
2199 
2201 
2202  print_str ("media_type", "subtitle");
2203  print_ts ("pts", sub->pts);
2204  print_time("pts_time", sub->pts, &AV_TIME_BASE_Q);
2205  print_int ("format", sub->format);
2206  print_int ("start_display_time", sub->start_display_time);
2207  print_int ("end_display_time", sub->end_display_time);
2208  print_int ("num_rects", sub->num_rects);
2209 
2211 
2212  av_bprint_finalize(&pbuf, NULL);
2213  fflush(stdout);
2214 }
2215 
2218 {
2219  AVBPrint pbuf;
2220  char val_str[128];
2221  const char *s;
2222  int i;
2223 
2225 
2227 
2229  if (s) print_str ("media_type", s);
2230  else print_str_opt("media_type", "unknown");
2231  print_int("stream_index", stream->index);
2232  print_int("key_frame", frame->key_frame);
2233  print_ts ("pkt_pts", frame->pts);
2234  print_time("pkt_pts_time", frame->pts, &stream->time_base);
2235  print_ts ("pkt_dts", frame->pkt_dts);
2236  print_time("pkt_dts_time", frame->pkt_dts, &stream->time_base);
2237  print_ts ("best_effort_timestamp", frame->best_effort_timestamp);
2238  print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
2239  print_duration_ts ("pkt_duration", frame->pkt_duration);
2240  print_duration_time("pkt_duration_time", frame->pkt_duration, &stream->time_base);
2241  if (frame->pkt_pos != -1) print_fmt ("pkt_pos", "%"PRId64, frame->pkt_pos);
2242  else print_str_opt("pkt_pos", "N/A");
2243  if (frame->pkt_size != -1) print_val ("pkt_size", frame->pkt_size, unit_byte_str);
2244  else print_str_opt("pkt_size", "N/A");
2245 
2246  switch (stream->codecpar->codec_type) {
2247  AVRational sar;
2248 
2249  case AVMEDIA_TYPE_VIDEO:
2250  print_int("width", frame->width);
2251  print_int("height", frame->height);
2252  s = av_get_pix_fmt_name(frame->format);
2253  if (s) print_str ("pix_fmt", s);
2254  else print_str_opt("pix_fmt", "unknown");
2255  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
2256  if (sar.num) {
2257  print_q("sample_aspect_ratio", sar, ':');
2258  } else {
2259  print_str_opt("sample_aspect_ratio", "N/A");
2260  }
2261  print_fmt("pict_type", "%c", av_get_picture_type_char(frame->pict_type));
2262  print_int("coded_picture_number", frame->coded_picture_number);
2263  print_int("display_picture_number", frame->display_picture_number);
2264  print_int("interlaced_frame", frame->interlaced_frame);
2265  print_int("top_field_first", frame->top_field_first);
2266  print_int("repeat_pict", frame->repeat_pict);
2267 
2268  print_color_range(w, frame->color_range);
2269  print_color_space(w, frame->colorspace);
2270  print_primaries(w, frame->color_primaries);
2271  print_color_trc(w, frame->color_trc);
2272  print_chroma_location(w, frame->chroma_location);
2273  break;
2274 
2275  case AVMEDIA_TYPE_AUDIO:
2276  s = av_get_sample_fmt_name(frame->format);
2277  if (s) print_str ("sample_fmt", s);
2278  else print_str_opt("sample_fmt", "unknown");
2279  print_int("nb_samples", frame->nb_samples);
2280  print_int("channels", frame->channels);
2281  if (frame->channel_layout) {
2282  av_bprint_clear(&pbuf);
2283  av_bprint_channel_layout(&pbuf, frame->channels,
2284  frame->channel_layout);
2285  print_str ("channel_layout", pbuf.str);
2286  } else
2287  print_str_opt("channel_layout", "unknown");
2288  break;
2289  }
2290  if (do_show_frame_tags)
2291  show_tags(w, frame->metadata, SECTION_ID_FRAME_TAGS);
2292  if (do_show_log)
2294  if (frame->nb_side_data) {
2296  for (i = 0; i < frame->nb_side_data; i++) {
2297  AVFrameSideData *sd = frame->side_data[i];
2298  const char *name;
2299 
2302  print_str("side_data_type", name ? name : "unknown");
2303  if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
2304  writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
2305  print_int("rotation", av_display_rotation_get((int32_t *)sd->data));
2306  } else if (sd->type == AV_FRAME_DATA_GOP_TIMECODE && sd->size >= 8) {
2307  char tcbuf[AV_TIMECODE_STR_SIZE];
2308  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
2309  print_str("timecode", tcbuf);
2310  } else if (sd->type == AV_FRAME_DATA_S12M_TIMECODE && sd->size == 16) {
2311  uint32_t *tc = (uint32_t*)sd->data;
2312  int m = FFMIN(tc[0],3);
2314  for (int j = 1; j <= m ; j++) {
2315  char tcbuf[AV_TIMECODE_STR_SIZE];
2316  av_timecode_make_smpte_tc_string2(tcbuf, stream->avg_frame_rate, tc[j], 0, 0);
2318  print_str("value", tcbuf);
2320  }
2322  } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
2324 
2325  if (metadata->has_primaries) {
2326  print_q("red_x", metadata->display_primaries[0][0], '/');
2327  print_q("red_y", metadata->display_primaries[0][1], '/');
2328  print_q("green_x", metadata->display_primaries[1][0], '/');
2329  print_q("green_y", metadata->display_primaries[1][1], '/');
2330  print_q("blue_x", metadata->display_primaries[2][0], '/');
2331  print_q("blue_y", metadata->display_primaries[2][1], '/');
2332 
2333  print_q("white_point_x", metadata->white_point[0], '/');
2334  print_q("white_point_y", metadata->white_point[1], '/');
2335  }
2336 
2337  if (metadata->has_luminance) {
2338  print_q("min_luminance", metadata->min_luminance, '/');
2339  print_q("max_luminance", metadata->max_luminance, '/');
2340  }
2341  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_PLUS) {
2342  AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
2343  print_dynamic_hdr10_plus(w, metadata);
2344  } else if (sd->type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL) {
2346  print_int("max_content", metadata->MaxCLL);
2347  print_int("max_average", metadata->MaxFALL);
2348  } else if (sd->type == AV_FRAME_DATA_ICC_PROFILE) {
2350  if (tag)
2351  print_str(tag->key, tag->value);
2352  print_int("size", sd->size);
2353  }
2355  }
2357  }
2358 
2360 
2361  av_bprint_finalize(&pbuf, NULL);
2362  fflush(stdout);
2363 }
2364 
2366  InputFile *ifile,
2368  int *packet_new)
2369 {
2370  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2371  AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
2372  AVCodecParameters *par = ifile->streams[pkt->stream_index].st->codecpar;
2373  AVSubtitle sub;
2374  int ret = 0, got_frame = 0;
2375 
2376  clear_log(1);
2377  if (dec_ctx && dec_ctx->codec) {
2378  switch (par->codec_type) {
2379  case AVMEDIA_TYPE_VIDEO:
2380  case AVMEDIA_TYPE_AUDIO:
2381  if (*packet_new) {
2383  if (ret == AVERROR(EAGAIN)) {
2384  ret = 0;
2385  } else if (ret >= 0 || ret == AVERROR_EOF) {
2386  ret = 0;
2387  *packet_new = 0;
2388  }
2389  }
2390  if (ret >= 0) {
2392  if (ret >= 0) {
2393  got_frame = 1;
2394  } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
2395  ret = 0;
2396  }
2397  }
2398  break;
2399 
2400  case AVMEDIA_TYPE_SUBTITLE:
2401  if (*packet_new)
2402  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
2403  *packet_new = 0;
2404  break;
2405  default:
2406  *packet_new = 0;
2407  }
2408  } else {
2409  *packet_new = 0;
2410  }
2411 
2412  if (ret < 0)
2413  return ret;
2414  if (got_frame) {
2415  int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
2417  if (do_show_frames)
2418  if (is_sub)
2419  show_subtitle(w, &sub, ifile->streams[pkt->stream_index].st, fmt_ctx);
2420  else
2421  show_frame(w, frame, ifile->streams[pkt->stream_index].st, fmt_ctx);
2422  if (is_sub)
2423  avsubtitle_free(&sub);
2424  }
2425  return got_frame || *packet_new;
2426 }
2427 
2428 static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
2429 {
2430  av_log(log_ctx, log_level, "id:%d", interval->id);
2431 
2432  if (interval->has_start) {
2433  av_log(log_ctx, log_level, " start:%s%s", interval->start_is_offset ? "+" : "",
2434  av_ts2timestr(interval->start, &AV_TIME_BASE_Q));
2435  } else {
2436  av_log(log_ctx, log_level, " start:N/A");
2437  }
2438 
2439  if (interval->has_end) {
2440  av_log(log_ctx, log_level, " end:%s", interval->end_is_offset ? "+" : "");
2441  if (interval->duration_frames)
2442  av_log(log_ctx, log_level, "#%"PRId64, interval->end);
2443  else
2444  av_log(log_ctx, log_level, "%s", av_ts2timestr(interval->end, &AV_TIME_BASE_Q));
2445  } else {
2446  av_log(log_ctx, log_level, " end:N/A");
2447  }
2448 
2449  av_log(log_ctx, log_level, "\n");
2450 }
2451 
2453  const ReadInterval *interval, int64_t *cur_ts)
2454 {
2455  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2456  AVPacket *pkt = NULL;
2457  AVFrame *frame = NULL;
2458  int ret = 0, i = 0, frame_count = 0;
2459  int64_t start = -INT64_MAX, end = interval->end;
2460  int has_start = 0, has_end = interval->has_end && !interval->end_is_offset;
2461 
2462  av_log(NULL, AV_LOG_VERBOSE, "Processing read interval ");
2464 
2465  if (interval->has_start) {
2466  int64_t target;
2467  if (interval->start_is_offset) {
2468  if (*cur_ts == AV_NOPTS_VALUE) {
2470  "Could not seek to relative position since current "
2471  "timestamp is not defined\n");
2472  ret = AVERROR(EINVAL);
2473  goto end;
2474  }
2475  target = *cur_ts + interval->start;
2476  } else {
2477  target = interval->start;
2478  }
2479 
2480  av_log(NULL, AV_LOG_VERBOSE, "Seeking to read interval start point %s\n",
2481  av_ts2timestr(target, &AV_TIME_BASE_Q));
2482  if ((ret = avformat_seek_file(fmt_ctx, -1, -INT64_MAX, target, INT64_MAX, 0)) < 0) {
2483  av_log(NULL, AV_LOG_ERROR, "Could not seek to position %"PRId64": %s\n",
2484  interval->start, av_err2str(ret));
2485  goto end;
2486  }
2487  }
2488 
2489  frame = av_frame_alloc();
2490  if (!frame) {
2491  ret = AVERROR(ENOMEM);
2492  goto end;
2493  }
2494  pkt = av_packet_alloc();
2495  if (!pkt) {
2496  ret = AVERROR(ENOMEM);
2497  goto end;
2498  }
2499  while (!av_read_frame(fmt_ctx, pkt)) {
2500  if (fmt_ctx->nb_streams > nb_streams) {
2505  }
2507  AVRational tb = ifile->streams[pkt->stream_index].st->time_base;
2508 
2509  if (pkt->pts != AV_NOPTS_VALUE)
2510  *cur_ts = av_rescale_q(pkt->pts, tb, AV_TIME_BASE_Q);
2511 
2512  if (!has_start && *cur_ts != AV_NOPTS_VALUE) {
2513  start = *cur_ts;
2514  has_start = 1;
2515  }
2516 
2517  if (has_start && !has_end && interval->end_is_offset) {
2518  end = start + interval->end;
2519  has_end = 1;
2520  }
2521 
2522  if (interval->end_is_offset && interval->duration_frames) {
2523  if (frame_count >= interval->end)
2524  break;
2525  } else if (has_end && *cur_ts != AV_NOPTS_VALUE && *cur_ts >= end) {
2526  break;
2527  }
2528 
2529  frame_count++;
2530  if (do_read_packets) {
2531  if (do_show_packets)
2532  show_packet(w, ifile, pkt, i++);
2534  }
2535  if (do_read_frames) {
2536  int packet_new = 1;
2537  while (process_frame(w, ifile, frame, pkt, &packet_new) > 0);
2538  }
2539  }
2541  }
2543  //Flush remaining frames that are cached in the decoder
2544  for (i = 0; i < fmt_ctx->nb_streams; i++) {
2545  pkt->stream_index = i;
2546  if (do_read_frames)
2547  while (process_frame(w, ifile, frame, pkt, &(int){1}) > 0);
2548  }
2549 
2550 end:
2551  av_frame_free(&frame);
2552  av_packet_free(&pkt);
2553  if (ret < 0) {
2554  av_log(NULL, AV_LOG_ERROR, "Could not read packets in interval ");
2555  log_read_interval(interval, NULL, AV_LOG_ERROR);
2556  }
2557  return ret;
2558 }
2559 
2561 {
2562  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2563  int i, ret = 0;
2564  int64_t cur_ts = fmt_ctx->start_time;
2565 
2566  if (read_intervals_nb == 0) {
2567  ReadInterval interval = (ReadInterval) { .has_start = 0, .has_end = 0 };
2568  ret = read_interval_packets(w, ifile, &interval, &cur_ts);
2569  } else {
2570  for (i = 0; i < read_intervals_nb; i++) {
2571  ret = read_interval_packets(w, ifile, &read_intervals[i], &cur_ts);
2572  if (ret < 0)
2573  break;
2574  }
2575  }
2576 
2577  return ret;
2578 }
2579 
2580 static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int in_program)
2581 {
2582  AVStream *stream = ist->st;
2583  AVCodecParameters *par;
2585  char val_str[128];
2586  const char *s;
2587  AVRational sar, dar;
2588  AVBPrint pbuf;
2589  const AVCodecDescriptor *cd;
2590  int ret = 0;
2591  const char *profile = NULL;
2592 
2594 
2596 
2597  print_int("index", stream->index);
2598 
2599  par = stream->codecpar;
2600  dec_ctx = ist->dec_ctx;
2601  if (cd = avcodec_descriptor_get(par->codec_id)) {
2602  print_str("codec_name", cd->name);
2603  if (!do_bitexact) {
2604  print_str("codec_long_name",
2605  cd->long_name ? cd->long_name : "unknown");
2606  }
2607  } else {
2608  print_str_opt("codec_name", "unknown");
2609  if (!do_bitexact) {
2610  print_str_opt("codec_long_name", "unknown");
2611  }
2612  }
2613 
2614  if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
2615  print_str("profile", profile);
2616  else {
2617  if (par->profile != FF_PROFILE_UNKNOWN) {
2618  char profile_num[12];
2619  snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
2620  print_str("profile", profile_num);
2621  } else
2622  print_str_opt("profile", "unknown");
2623  }
2624 
2626  if (s) print_str ("codec_type", s);
2627  else print_str_opt("codec_type", "unknown");
2628 
2629  /* print AVI/FourCC tag */
2630  print_str("codec_tag_string", av_fourcc2str(par->codec_tag));
2631  print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
2632 
2633  switch (par->codec_type) {
2634  case AVMEDIA_TYPE_VIDEO:
2635  print_int("width", par->width);
2636  print_int("height", par->height);
2637  if (dec_ctx) {
2638  print_int("coded_width", dec_ctx->coded_width);
2639  print_int("coded_height", dec_ctx->coded_height);
2641  }
2642  print_int("has_b_frames", par->video_delay);
2643  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
2644  if (sar.num) {
2645  print_q("sample_aspect_ratio", sar, ':');
2646  av_reduce(&dar.num, &dar.den,
2647  par->width * sar.num,
2648  par->height * sar.den,
2649  1024*1024);
2650  print_q("display_aspect_ratio", dar, ':');
2651  } else {
2652  print_str_opt("sample_aspect_ratio", "N/A");
2653  print_str_opt("display_aspect_ratio", "N/A");
2654  }
2655  s = av_get_pix_fmt_name(par->format);
2656  if (s) print_str ("pix_fmt", s);
2657  else print_str_opt("pix_fmt", "unknown");
2658  print_int("level", par->level);
2659 
2662  print_color_trc(w, par->color_trc);
2665 
2666  if (par->field_order == AV_FIELD_PROGRESSIVE)
2667  print_str("field_order", "progressive");
2668  else if (par->field_order == AV_FIELD_TT)
2669  print_str("field_order", "tt");
2670  else if (par->field_order == AV_FIELD_BB)
2671  print_str("field_order", "bb");
2672  else if (par->field_order == AV_FIELD_TB)
2673  print_str("field_order", "tb");
2674  else if (par->field_order == AV_FIELD_BT)
2675  print_str("field_order", "bt");
2676  else
2677  print_str_opt("field_order", "unknown");
2678 
2679  if (dec_ctx)
2680  print_int("refs", dec_ctx->refs);
2681  break;
2682 
2683  case AVMEDIA_TYPE_AUDIO:
2685  if (s) print_str ("sample_fmt", s);
2686  else print_str_opt("sample_fmt", "unknown");
2687  print_val("sample_rate", par->sample_rate, unit_hertz_str);
2688  print_int("channels", par->channels);
2689 
2690  if (par->channel_layout) {
2691  av_bprint_clear(&pbuf);
2693  print_str ("channel_layout", pbuf.str);
2694  } else {
2695  print_str_opt("channel_layout", "unknown");
2696  }
2697 
2698  print_int("bits_per_sample", av_get_bits_per_sample(par->codec_id));
2699  break;
2700 
2701  case AVMEDIA_TYPE_SUBTITLE:
2702  if (par->width)
2703  print_int("width", par->width);
2704  else
2705  print_str_opt("width", "N/A");
2706  if (par->height)
2707  print_int("height", par->height);
2708  else
2709  print_str_opt("height", "N/A");
2710  break;
2711  }
2712 
2714  const AVOption *opt = NULL;
2715  while (opt = av_opt_next(dec_ctx->priv_data,opt)) {
2716  uint8_t *str;
2717  if (opt->flags) continue;
2718  if (av_opt_get(dec_ctx->priv_data, opt->name, 0, &str) >= 0) {
2719  print_str(opt->name, str);
2720  av_free(str);
2721  }
2722  }
2723  }
2724 
2725  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%x", stream->id);
2726  else print_str_opt("id", "N/A");
2727  print_q("r_frame_rate", stream->r_frame_rate, '/');
2728  print_q("avg_frame_rate", stream->avg_frame_rate, '/');
2729  print_q("time_base", stream->time_base, '/');
2730  print_ts ("start_pts", stream->start_time);
2731  print_time("start_time", stream->start_time, &stream->time_base);
2732  print_ts ("duration_ts", stream->duration);
2733  print_time("duration", stream->duration, &stream->time_base);
2734  if (par->bit_rate > 0) print_val ("bit_rate", par->bit_rate, unit_bit_per_second_str);
2735  else print_str_opt("bit_rate", "N/A");
2736  if (dec_ctx && dec_ctx->rc_max_rate > 0)
2738  else
2739  print_str_opt("max_bit_rate", "N/A");
2740  if (dec_ctx && dec_ctx->bits_per_raw_sample > 0) print_fmt("bits_per_raw_sample", "%d", dec_ctx->bits_per_raw_sample);
2741  else print_str_opt("bits_per_raw_sample", "N/A");
2742  if (stream->nb_frames) print_fmt ("nb_frames", "%"PRId64, stream->nb_frames);
2743  else print_str_opt("nb_frames", "N/A");
2744  if (nb_streams_frames[stream_idx]) print_fmt ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
2745  else print_str_opt("nb_read_frames", "N/A");
2746  if (nb_streams_packets[stream_idx]) print_fmt ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
2747  else print_str_opt("nb_read_packets", "N/A");
2748  if (do_show_data)
2749  writer_print_data(w, "extradata", par->extradata,
2750  par->extradata_size);
2751  writer_print_data_hash(w, "extradata_hash", par->extradata,
2752  par->extradata_size);
2753 
2754  /* Print disposition information */
2755 #define PRINT_DISPOSITION(flagname, name) do { \
2756  print_int(name, !!(stream->disposition & AV_DISPOSITION_##flagname)); \
2757  } while (0)
2758 
2761  PRINT_DISPOSITION(DEFAULT, "default");
2762  PRINT_DISPOSITION(DUB, "dub");
2763  PRINT_DISPOSITION(ORIGINAL, "original");
2764  PRINT_DISPOSITION(COMMENT, "comment");
2765  PRINT_DISPOSITION(LYRICS, "lyrics");
2766  PRINT_DISPOSITION(KARAOKE, "karaoke");
2767  PRINT_DISPOSITION(FORCED, "forced");
2768  PRINT_DISPOSITION(HEARING_IMPAIRED, "hearing_impaired");
2769  PRINT_DISPOSITION(VISUAL_IMPAIRED, "visual_impaired");
2770  PRINT_DISPOSITION(CLEAN_EFFECTS, "clean_effects");
2771  PRINT_DISPOSITION(ATTACHED_PIC, "attached_pic");
2772  PRINT_DISPOSITION(TIMED_THUMBNAILS, "timed_thumbnails");
2774  }
2775 
2776  if (do_show_stream_tags)
2778 
2779  if (stream->nb_side_data) {
2780  print_pkt_side_data(w, stream->codecpar, stream->side_data, stream->nb_side_data,
2783  }
2784 
2786  av_bprint_finalize(&pbuf, NULL);
2787  fflush(stdout);
2788 
2789  return ret;
2790 }
2791 
2793 {
2794  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2795  int i, ret = 0;
2796 
2798  for (i = 0; i < ifile->nb_streams; i++)
2799  if (selected_streams[i]) {
2800  ret = show_stream(w, fmt_ctx, i, &ifile->streams[i], 0);
2801  if (ret < 0)
2802  break;
2803  }
2805 
2806  return ret;
2807 }
2808 
2810 {
2811  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2812  int i, ret = 0;
2813 
2815  print_int("program_id", program->id);
2816  print_int("program_num", program->program_num);
2817  print_int("nb_streams", program->nb_stream_indexes);
2818  print_int("pmt_pid", program->pmt_pid);
2819  print_int("pcr_pid", program->pcr_pid);
2820  print_ts("start_pts", program->start_time);
2821  print_time("start_time", program->start_time, &AV_TIME_BASE_Q);
2822  print_ts("end_pts", program->end_time);
2823  print_time("end_time", program->end_time, &AV_TIME_BASE_Q);
2826  if (ret < 0)
2827  goto end;
2828 
2830  for (i = 0; i < program->nb_stream_indexes; i++) {
2831  if (selected_streams[program->stream_index[i]]) {
2832  ret = show_stream(w, fmt_ctx, program->stream_index[i], &ifile->streams[program->stream_index[i]], 1);
2833  if (ret < 0)
2834  break;
2835  }
2836  }
2838 
2839 end:
2841  return ret;
2842 }
2843 
2845 {
2846  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2847  int i, ret = 0;
2848 
2850  for (i = 0; i < fmt_ctx->nb_programs; i++) {
2852  if (!program)
2853  continue;
2855  if (ret < 0)
2856  break;
2857  }
2859  return ret;
2860 }
2861 
2863 {
2864  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2865  int i, ret = 0;
2866 
2868  for (i = 0; i < fmt_ctx->nb_chapters; i++) {
2869  AVChapter *chapter = fmt_ctx->chapters[i];
2870 
2872  print_int("id", chapter->id);
2873  print_q ("time_base", chapter->time_base, '/');
2874  print_int("start", chapter->start);
2875  print_time("start_time", chapter->start, &chapter->time_base);
2876  print_int("end", chapter->end);
2877  print_time("end_time", chapter->end, &chapter->time_base);
2881  }
2883 
2884  return ret;
2885 }
2886 
2888 {
2889  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2890  char val_str[128];
2891  int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
2892  int ret = 0;
2893 
2895  print_str_validate("filename", fmt_ctx->url);
2896  print_int("nb_streams", fmt_ctx->nb_streams);
2897  print_int("nb_programs", fmt_ctx->nb_programs);
2898  print_str("format_name", fmt_ctx->iformat->name);
2899  if (!do_bitexact) {
2900  if (fmt_ctx->iformat->long_name) print_str ("format_long_name", fmt_ctx->iformat->long_name);
2901  else print_str_opt("format_long_name", "unknown");
2902  }
2903  print_time("start_time", fmt_ctx->start_time, &AV_TIME_BASE_Q);
2904  print_time("duration", fmt_ctx->duration, &AV_TIME_BASE_Q);
2905  if (size >= 0) print_val ("size", size, unit_byte_str);
2906  else print_str_opt("size", "N/A");
2908  else print_str_opt("bit_rate", "N/A");
2909  print_int("probe_score", fmt_ctx->probe_score);
2910  if (do_show_format_tags)
2912 
2914  fflush(stdout);
2915  return ret;
2916 }
2917 
2918 static void show_error(WriterContext *w, int err)
2919 {
2920  char errbuf[128];
2921  const char *errbuf_ptr = errbuf;
2922 
2923  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
2924  errbuf_ptr = strerror(AVUNERROR(err));
2925 
2927  print_int("code", err);
2928  print_str("string", errbuf_ptr);
2930 }
2931 
2932 static int open_input_file(InputFile *ifile, const char *filename,
2933  const char *print_filename)
2934 {
2935  int err, i;
2937  AVDictionaryEntry *t = NULL;
2938  int scan_all_pmts_set = 0;
2939 
2941  if (!fmt_ctx) {
2942  print_error(filename, AVERROR(ENOMEM));
2943  exit_program(1);
2944  }
2945 
2946  if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2947  av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2948  scan_all_pmts_set = 1;
2949  }
2950  if ((err = avformat_open_input(&fmt_ctx, filename,
2951  iformat, &format_opts)) < 0) {
2952  print_error(filename, err);
2953  return err;
2954  }
2955  if (print_filename) {
2956  av_freep(&fmt_ctx->url);
2957  fmt_ctx->url = av_strdup(print_filename);
2958  }
2959  ifile->fmt_ctx = fmt_ctx;
2960  if (scan_all_pmts_set)
2961  av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2962  while ((t = av_dict_get(format_opts, "", t, AV_DICT_IGNORE_SUFFIX)))
2963  av_log(NULL, AV_LOG_WARNING, "Option %s skipped - not known to demuxer.\n", t->key);
2964 
2965  if (find_stream_info) {
2967  int orig_nb_streams = fmt_ctx->nb_streams;
2968 
2970 
2971  for (i = 0; i < orig_nb_streams; i++)
2972  av_dict_free(&opts[i]);
2973  av_freep(&opts);
2974 
2975  if (err < 0) {
2976  print_error(filename, err);
2977  return err;
2978  }
2979  }
2980 
2981  av_dump_format(fmt_ctx, 0, filename, 0);
2982 
2984  sizeof(*ifile->streams));
2985  if (!ifile->streams)
2986  exit(1);
2987  ifile->nb_streams = fmt_ctx->nb_streams;
2988 
2989  /* bind a decoder to each input stream */
2990  for (i = 0; i < fmt_ctx->nb_streams; i++) {
2991  InputStream *ist = &ifile->streams[i];
2992  AVStream *stream = fmt_ctx->streams[i];
2993  const AVCodec *codec;
2994 
2995  ist->st = stream;
2996 
2997  if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
2999  "Failed to probe codec for input stream %d\n",
3000  stream->index);
3001  continue;
3002  }
3003 
3004  codec = avcodec_find_decoder(stream->codecpar->codec_id);
3005  if (!codec) {
3007  "Unsupported codec with id %d for input stream %d\n",
3008  stream->codecpar->codec_id, stream->index);
3009  continue;
3010  }
3011  {
3013  fmt_ctx, stream, codec);
3014 
3015  ist->dec_ctx = avcodec_alloc_context3(codec);
3016  if (!ist->dec_ctx)
3017  exit(1);
3018 
3019  err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
3020  if (err < 0)
3021  exit(1);
3022 
3023  if (do_show_log) {
3024  // For loging it is needed to disable at least frame threads as otherwise
3025  // the log information would need to be reordered and matches up to contexts and frames
3026  // That is in fact possible but not trivial
3027  av_dict_set(&codec_opts, "threads", "1", 0);
3028  }
3029 
3030  ist->dec_ctx->pkt_timebase = stream->time_base;
3031 
3032  if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
3033  av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
3034  stream->index);
3035  exit(1);
3036  }
3037 
3038  if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
3039  av_log(NULL, AV_LOG_ERROR, "Option %s for input stream %d not found\n",
3040  t->key, stream->index);
3041  return AVERROR_OPTION_NOT_FOUND;
3042  }
3043  }
3044  }
3045 
3046  ifile->fmt_ctx = fmt_ctx;
3047  return 0;
3048 }
3049 
3051 {
3052  int i;
3053 
3054  /* close decoder for each stream */
3055  for (i = 0; i < ifile->nb_streams; i++)
3056  if (ifile->streams[i].st->codecpar->codec_id != AV_CODEC_ID_NONE)
3057  avcodec_free_context(&ifile->streams[i].dec_ctx);
3058 
3059  av_freep(&ifile->streams);
3060  ifile->nb_streams = 0;
3061 
3062  avformat_close_input(&ifile->fmt_ctx);
3063 }
3064 
3065 static int probe_file(WriterContext *wctx, const char *filename,
3066  const char *print_filename)
3067 {
3068  InputFile ifile = { 0 };
3069  int ret, i;
3070  int section_id;
3071 
3074 
3075  ret = open_input_file(&ifile, filename, print_filename);
3076  if (ret < 0)
3077  goto end;
3078 
3079 #define CHECK_END if (ret < 0) goto end
3080 
3081  nb_streams = ifile.fmt_ctx->nb_streams;
3082  REALLOCZ_ARRAY_STREAM(nb_streams_frames,0,ifile.fmt_ctx->nb_streams);
3083  REALLOCZ_ARRAY_STREAM(nb_streams_packets,0,ifile.fmt_ctx->nb_streams);
3084  REALLOCZ_ARRAY_STREAM(selected_streams,0,ifile.fmt_ctx->nb_streams);
3085 
3086  for (i = 0; i < ifile.fmt_ctx->nb_streams; i++) {
3087  if (stream_specifier) {
3089  ifile.fmt_ctx->streams[i],
3091  CHECK_END;
3092  else
3093  selected_streams[i] = ret;
3094  ret = 0;
3095  } else {
3096  selected_streams[i] = 1;
3097  }
3098  if (!selected_streams[i])
3099  ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
3100  }
3101 
3105  section_id = SECTION_ID_PACKETS_AND_FRAMES;
3106  else if (do_show_packets && !do_show_frames)
3107  section_id = SECTION_ID_PACKETS;
3108  else // (!do_show_packets && do_show_frames)
3109  section_id = SECTION_ID_FRAMES;
3111  writer_print_section_header(wctx, section_id);
3112  ret = read_packets(wctx, &ifile);
3115  CHECK_END;
3116  }
3117 
3118  if (do_show_programs) {
3119  ret = show_programs(wctx, &ifile);
3120  CHECK_END;
3121  }
3122 
3123  if (do_show_streams) {
3124  ret = show_streams(wctx, &ifile);
3125  CHECK_END;
3126  }
3127  if (do_show_chapters) {
3128  ret = show_chapters(wctx, &ifile);
3129  CHECK_END;
3130  }
3131  if (do_show_format) {
3132  ret = show_format(wctx, &ifile);
3133  CHECK_END;
3134  }
3135 
3136 end:
3137  if (ifile.fmt_ctx)
3142 
3143  return ret;
3144 }
3145 
3146 static void show_usage(void)
3147 {
3148  av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
3149  av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] [INPUT_FILE]\n", program_name);
3150  av_log(NULL, AV_LOG_INFO, "\n");
3151 }
3152 
3154 {
3155  AVBPrint pbuf;
3157 
3159  print_str("version", FFMPEG_VERSION);
3160  print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
3161  program_birth_year, CONFIG_THIS_YEAR);
3162  print_str("compiler_ident", CC_IDENT);
3163  print_str("configuration", FFMPEG_CONFIGURATION);
3165 
3166  av_bprint_finalize(&pbuf, NULL);
3167 }
3168 
3169 #define SHOW_LIB_VERSION(libname, LIBNAME) \
3170  do { \
3171  if (CONFIG_##LIBNAME) { \
3172  unsigned int version = libname##_version(); \
3173  writer_print_section_header(w, SECTION_ID_LIBRARY_VERSION); \
3174  print_str("name", "lib" #libname); \
3175  print_int("major", LIB##LIBNAME##_VERSION_MAJOR); \
3176  print_int("minor", LIB##LIBNAME##_VERSION_MINOR); \
3177  print_int("micro", LIB##LIBNAME##_VERSION_MICRO); \
3178  print_int("version", version); \
3179  print_str("ident", LIB##LIBNAME##_IDENT); \
3180  writer_print_section_footer(w); \
3181  } \
3182  } while (0)
3183 
3185 {
3187  SHOW_LIB_VERSION(avutil, AVUTIL);
3188  SHOW_LIB_VERSION(avcodec, AVCODEC);
3189  SHOW_LIB_VERSION(avformat, AVFORMAT);
3190  SHOW_LIB_VERSION(avdevice, AVDEVICE);
3191  SHOW_LIB_VERSION(avfilter, AVFILTER);
3192  SHOW_LIB_VERSION(swscale, SWSCALE);
3193  SHOW_LIB_VERSION(swresample, SWRESAMPLE);
3194  SHOW_LIB_VERSION(postproc, POSTPROC);
3196 }
3197 
3198 #define PRINT_PIX_FMT_FLAG(flagname, name) \
3199  do { \
3200  print_int(name, !!(pixdesc->flags & AV_PIX_FMT_FLAG_##flagname)); \
3201  } while (0)
3202 
3204 {
3205  const AVPixFmtDescriptor *pixdesc = NULL;
3206  int i, n;
3207 
3209  while (pixdesc = av_pix_fmt_desc_next(pixdesc)) {
3211  print_str("name", pixdesc->name);
3212  print_int("nb_components", pixdesc->nb_components);
3213  if ((pixdesc->nb_components >= 3) && !(pixdesc->flags & AV_PIX_FMT_FLAG_RGB)) {
3214  print_int ("log2_chroma_w", pixdesc->log2_chroma_w);
3215  print_int ("log2_chroma_h", pixdesc->log2_chroma_h);
3216  } else {
3217  print_str_opt("log2_chroma_w", "N/A");
3218  print_str_opt("log2_chroma_h", "N/A");
3219  }
3220  n = av_get_bits_per_pixel(pixdesc);
3221  if (n) print_int ("bits_per_pixel", n);
3222  else print_str_opt("bits_per_pixel", "N/A");
3225  PRINT_PIX_FMT_FLAG(BE, "big_endian");
3226  PRINT_PIX_FMT_FLAG(PAL, "palette");
3227  PRINT_PIX_FMT_FLAG(BITSTREAM, "bitstream");
3228  PRINT_PIX_FMT_FLAG(HWACCEL, "hwaccel");
3229  PRINT_PIX_FMT_FLAG(PLANAR, "planar");
3230  PRINT_PIX_FMT_FLAG(RGB, "rgb");
3231  PRINT_PIX_FMT_FLAG(ALPHA, "alpha");
3233  }
3234  if (do_show_pixel_format_components && (pixdesc->nb_components > 0)) {
3236  for (i = 0; i < pixdesc->nb_components; i++) {
3238  print_int("index", i + 1);
3239  print_int("bit_depth", pixdesc->comp[i].depth);
3241  }
3243  }
3245  }
3247 }
3248 
3249 static int opt_format(void *optctx, const char *opt, const char *arg)
3250 {
3252  if (!iformat) {
3253  av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
3254  return AVERROR(EINVAL);
3255  }
3256  return 0;
3257 }
3258 
3259 static inline void mark_section_show_entries(SectionID section_id,
3260  int show_all_entries, AVDictionary *entries)
3261 {
3262  struct section *section = &sections[section_id];
3263 
3265  if (show_all_entries) {
3266  SectionID *id;
3267  for (id = section->children_ids; *id != -1; id++)
3269  } else {
3270  av_dict_copy(&section->entries_to_show, entries, 0);
3271  }
3272 }
3273 
3274 static int match_section(const char *section_name,
3275  int show_all_entries, AVDictionary *entries)
3276 {
3277  int i, ret = 0;
3278 
3279  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) {
3280  const struct section *section = &sections[i];
3281  if (!strcmp(section_name, section->name) ||
3282  (section->unique_name && !strcmp(section_name, section->unique_name))) {
3284  "'%s' matches section with unique name '%s'\n", section_name,
3286  ret++;
3288  }
3289  }
3290  return ret;
3291 }
3292 
3293 static int opt_show_entries(void *optctx, const char *opt, const char *arg)
3294 {
3295  const char *p = arg;
3296  int ret = 0;
3297 
3298  while (*p) {
3299  AVDictionary *entries = NULL;
3300  char *section_name = av_get_token(&p, "=:");
3301  int show_all_entries = 0;
3302 
3303  if (!section_name) {
3305  "Missing section name for option '%s'\n", opt);
3306  return AVERROR(EINVAL);
3307  }
3308 
3309  if (*p == '=') {
3310  p++;
3311  while (*p && *p != ':') {
3312  char *entry = av_get_token(&p, ",:");
3313  if (!entry)
3314  break;
3316  "Adding '%s' to the entries to show in section '%s'\n",
3317  entry, section_name);
3318  av_dict_set(&entries, entry, "", AV_DICT_DONT_STRDUP_KEY);
3319  if (*p == ',')
3320  p++;
3321  }
3322  } else {
3323  show_all_entries = 1;
3324  }
3325 
3326  ret = match_section(section_name, show_all_entries, entries);
3327  if (ret == 0) {
3328  av_log(NULL, AV_LOG_ERROR, "No match for section '%s'\n", section_name);
3329  ret = AVERROR(EINVAL);
3330  }
3331  av_dict_free(&entries);
3332  av_free(section_name);
3333 
3334  if (ret <= 0)
3335  break;
3336  if (*p)
3337  p++;
3338  }
3339 
3340  return ret;
3341 }
3342 
3343 static int opt_show_format_entry(void *optctx, const char *opt, const char *arg)
3344 {
3345  char *buf = av_asprintf("format=%s", arg);
3346  int ret;
3347 
3348  if (!buf)
3349  return AVERROR(ENOMEM);
3350 
3352  "Option '%s' is deprecated, use '-show_entries format=%s' instead\n",
3353  opt, arg);
3354  ret = opt_show_entries(optctx, opt, buf);
3355  av_free(buf);
3356  return ret;
3357 }
3358 
3359 static void opt_input_file(void *optctx, const char *arg)
3360 {
3361  if (input_filename) {
3363  "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3364  arg, input_filename);
3365  exit_program(1);
3366  }
3367  if (!strcmp(arg, "-"))
3368  arg = "pipe:";
3369  input_filename = arg;
3370 }
3371 
3372 static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
3373 {
3374  opt_input_file(optctx, arg);
3375  return 0;
3376 }
3377 
3378 static int opt_print_filename(void *optctx, const char *opt, const char *arg)
3379 {
3381  return 0;
3382 }
3383 
3384 void show_help_default(const char *opt, const char *arg)
3385 {
3387  show_usage();
3388  show_help_options(options, "Main options:", 0, 0, 0);
3389  printf("\n");
3390 
3393 }
3394 
3395 /**
3396  * Parse interval specification, according to the format:
3397  * INTERVAL ::= [START|+START_OFFSET][%[END|+END_OFFSET]]
3398  * INTERVALS ::= INTERVAL[,INTERVALS]
3399 */
3400 static int parse_read_interval(const char *interval_spec,
3401  ReadInterval *interval)
3402 {
3403  int ret = 0;
3404  char *next, *p, *spec = av_strdup(interval_spec);
3405  if (!spec)
3406  return AVERROR(ENOMEM);
3407 
3408  if (!*spec) {
3409  av_log(NULL, AV_LOG_ERROR, "Invalid empty interval specification\n");
3410  ret = AVERROR(EINVAL);
3411  goto end;
3412  }
3413 
3414  p = spec;
3415  next = strchr(spec, '%');
3416  if (next)
3417  *next++ = 0;
3418 
3419  /* parse first part */
3420  if (*p) {
3421  interval->has_start = 1;
3422 
3423  if (*p == '+') {
3424  interval->start_is_offset = 1;
3425  p++;
3426  } else {
3427  interval->start_is_offset = 0;
3428  }
3429 
3430  ret = av_parse_time(&interval->start, p, 1);
3431  if (ret < 0) {
3432  av_log(NULL, AV_LOG_ERROR, "Invalid interval start specification '%s'\n", p);
3433  goto end;
3434  }
3435  } else {
3436  interval->has_start = 0;
3437  }
3438 
3439  /* parse second part */
3440  p = next;
3441  if (p && *p) {
3442  int64_t us;
3443  interval->has_end = 1;
3444 
3445  if (*p == '+') {
3446  interval->end_is_offset = 1;
3447  p++;
3448  } else {
3449  interval->end_is_offset = 0;
3450  }
3451 
3452  if (interval->end_is_offset && *p == '#') {
3453  long long int lli;
3454  char *tail;
3455  interval->duration_frames = 1;
3456  p++;
3457  lli = strtoll(p, &tail, 10);
3458  if (*tail || lli < 0) {
3460  "Invalid or negative value '%s' for duration number of frames\n", p);
3461  goto end;
3462  }
3463  interval->end = lli;
3464  } else {
3465  interval->duration_frames = 0;
3466  ret = av_parse_time(&us, p, 1);
3467  if (ret < 0) {
3468  av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
3469  goto end;
3470  }
3471  interval->end = us;
3472  }
3473  } else {
3474  interval->has_end = 0;
3475  }
3476 
3477 end:
3478  av_free(spec);
3479  return ret;
3480 }
3481 
3482 static int parse_read_intervals(const char *intervals_spec)
3483 {
3484  int ret, n, i;
3485  char *p, *spec = av_strdup(intervals_spec);
3486  if (!spec)
3487  return AVERROR(ENOMEM);
3488 
3489  /* preparse specification, get number of intervals */
3490  for (n = 0, p = spec; *p; p++)
3491  if (*p == ',')
3492  n++;
3493  n++;
3494 
3496  if (!read_intervals) {
3497  ret = AVERROR(ENOMEM);
3498  goto end;
3499  }
3500  read_intervals_nb = n;
3501 
3502  /* parse intervals */
3503  p = spec;
3504  for (i = 0; p; i++) {
3505  char *next;
3506 
3508  next = strchr(p, ',');
3509  if (next)
3510  *next++ = 0;
3511 
3512  read_intervals[i].id = i;
3514  if (ret < 0) {
3515  av_log(NULL, AV_LOG_ERROR, "Error parsing read interval #%d '%s'\n",
3516  i, p);
3517  goto end;
3518  }
3519  av_log(NULL, AV_LOG_VERBOSE, "Parsed log interval ");
3521  p = next;
3522  }
3524 
3525 end:
3526  av_free(spec);
3527  return ret;
3528 }
3529 
3530 static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
3531 {
3532  return parse_read_intervals(arg);
3533 }
3534 
3535 static int opt_pretty(void *optctx, const char *opt, const char *arg)
3536 {
3537  show_value_unit = 1;
3538  use_value_prefix = 1;
3541  return 0;
3542 }
3543 
3544 static void print_section(SectionID id, int level)
3545 {
3546  const SectionID *pid;
3547  const struct section *section = &sections[id];
3548  printf("%c%c%c",
3549  section->flags & SECTION_FLAG_IS_WRAPPER ? 'W' : '.',
3550  section->flags & SECTION_FLAG_IS_ARRAY ? 'A' : '.',
3552  printf("%*c %s", level * 4, ' ', section->name);
3553  if (section->unique_name)
3554  printf("/%s", section->unique_name);
3555  printf("\n");
3556 
3557  for (pid = section->children_ids; *pid != -1; pid++)
3558  print_section(*pid, level+1);
3559 }
3560 
3561 static int opt_sections(void *optctx, const char *opt, const char *arg)
3562 {
3563  printf("Sections:\n"
3564  "W.. = Section is a wrapper (contains other sections, no local entries)\n"
3565  ".A. = Section contains an array of elements of the same type\n"
3566  "..V = Section may contain a variable number of fields with variable keys\n"
3567  "FLAGS NAME/UNIQUE_NAME\n"
3568  "---\n");
3570  return 0;
3571 }
3572 
3573 static int opt_show_versions(void *optctx, const char *opt, const char *arg)
3574 {
3577  return 0;
3578 }
3579 
3580 #define DEFINE_OPT_SHOW_SECTION(section, target_section_id) \
3581  static int opt_show_##section(void *optctx, const char *opt, const char *arg) \
3582  { \
3583  mark_section_show_entries(SECTION_ID_##target_section_id, 1, NULL); \
3584  return 0; \
3585  }
3586 
3587 DEFINE_OPT_SHOW_SECTION(chapters, CHAPTERS)
3591 DEFINE_OPT_SHOW_SECTION(library_versions, LIBRARY_VERSIONS)
3592 DEFINE_OPT_SHOW_SECTION(packets, PACKETS)
3593 DEFINE_OPT_SHOW_SECTION(pixel_formats, PIXEL_FORMATS)
3594 DEFINE_OPT_SHOW_SECTION(program_version, PROGRAM_VERSION)
3595 DEFINE_OPT_SHOW_SECTION(streams, STREAMS)
3596 DEFINE_OPT_SHOW_SECTION(programs, PROGRAMS)
3597 
3598 static const OptionDef real_options[] = {
3600  { "f", HAS_ARG, {.func_arg = opt_format}, "force format", "format" },
3601  { "unit", OPT_BOOL, {&show_value_unit}, "show unit of the displayed values" },
3602  { "prefix", OPT_BOOL, {&use_value_prefix}, "use SI prefixes for the displayed values" },
3603  { "byte_binary_prefix", OPT_BOOL, {&use_byte_value_binary_prefix},
3604  "use binary prefixes for byte units" },
3605  { "sexagesimal", OPT_BOOL, {&use_value_sexagesimal_format},
3606  "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
3607  { "pretty", 0, {.func_arg = opt_pretty},
3608  "prettify the format of displayed values, make it more human readable" },
3609  { "print_format", OPT_STRING | HAS_ARG, { &print_format },
3610  "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
3611  { "of", OPT_STRING | HAS_ARG, { &print_format }, "alias for -print_format", "format" },
3612  { "select_streams", OPT_STRING | HAS_ARG, { &stream_specifier }, "select the specified streams", "stream_specifier" },
3613  { "sections", OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
3614  { "show_data", OPT_BOOL, { &do_show_data }, "show packets data" },
3615  { "show_data_hash", OPT_STRING | HAS_ARG, { &show_data_hash }, "show packets data hash" },
3616  { "show_error", 0, { .func_arg = &opt_show_error }, "show probing error" },
3617  { "show_format", 0, { .func_arg = &opt_show_format }, "show format/container info" },
3618  { "show_frames", 0, { .func_arg = &opt_show_frames }, "show frames info" },
3619  { "show_format_entry", HAS_ARG, {.func_arg = opt_show_format_entry},
3620  "show a particular entry from the format/container info", "entry" },
3621  { "show_entries", HAS_ARG, {.func_arg = opt_show_entries},
3622  "show a set of specified entries", "entry_list" },
3623 #if HAVE_THREADS
3624  { "show_log", OPT_INT|HAS_ARG, { &do_show_log }, "show log" },
3625 #endif
3626  { "show_packets", 0, { .func_arg = &opt_show_packets }, "show packets info" },
3627  { "show_programs", 0, { .func_arg = &opt_show_programs }, "show programs info" },
3628  { "show_streams", 0, { .func_arg = &opt_show_streams }, "show streams info" },
3629  { "show_chapters", 0, { .func_arg = &opt_show_chapters }, "show chapters info" },
3630  { "count_frames", OPT_BOOL, { &do_count_frames }, "count the number of frames per stream" },
3631  { "count_packets", OPT_BOOL, { &do_count_packets }, "count the number of packets per stream" },
3632  { "show_program_version", 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" },
3633  { "show_library_versions", 0, { .func_arg = &opt_show_library_versions }, "show library versions" },
3634  { "show_versions", 0, { .func_arg = &opt_show_versions }, "show program and library versions" },
3635  { "show_pixel_formats", 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" },
3636  { "show_private_data", OPT_BOOL, { &show_private_data }, "show private data" },
3637  { "private", OPT_BOOL, { &show_private_data }, "same as show_private_data" },
3638  { "bitexact", OPT_BOOL, {&do_bitexact}, "force bitexact output" },
3639  { "read_intervals", HAS_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
3640  { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default}, "generic catch all option", "" },
3641  { "i", HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
3642  { "print_filename", HAS_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"},
3643  { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3644  "read and decode the streams to fill missing information with heuristics" },
3645  { NULL, },
3646 };
3647 
3648 static inline int check_section_show_entries(int section_id)
3649 {
3650  int *id;
3651  struct section *section = &sections[section_id];
3652  if (sections[section_id].show_all_entries || sections[section_id].entries_to_show)
3653  return 1;
3654  for (id = section->children_ids; *id != -1; id++)
3655  if (check_section_show_entries(*id))
3656  return 1;
3657  return 0;
3658 }
3659 
3660 #define SET_DO_SHOW(id, varname) do { \
3661  if (check_section_show_entries(SECTION_ID_##id)) \
3662  do_show_##varname = 1; \
3663  } while (0)
3664 
3665 int main(int argc, char **argv)
3666 {
3667  const Writer *w;
3668  WriterContext *wctx;
3669  char *buf;
3670  char *w_name = NULL, *w_args = NULL;
3671  int ret, i;
3672 
3673  init_dynload();
3674 
3675 #if HAVE_THREADS
3676  ret = pthread_mutex_init(&log_mutex, NULL);
3677  if (ret != 0) {
3678  goto end;
3679  }
3680 #endif
3683 
3685  parse_loglevel(argc, argv, options);
3687  init_opts();
3688 #if CONFIG_AVDEVICE
3690 #endif
3691 
3692  show_banner(argc, argv, options);
3693  parse_options(NULL, argc, argv, options, opt_input_file);
3694 
3695  if (do_show_log)
3697 
3698  /* mark things to show, based on -show_entries */
3699  SET_DO_SHOW(CHAPTERS, chapters);
3701  SET_DO_SHOW(FORMAT, format);
3702  SET_DO_SHOW(FRAMES, frames);
3703  SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
3704  SET_DO_SHOW(PACKETS, packets);
3705  SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
3706  SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
3707  SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
3708  SET_DO_SHOW(PROGRAM_VERSION, program_version);
3709  SET_DO_SHOW(PROGRAMS, programs);
3710  SET_DO_SHOW(STREAMS, streams);
3711  SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
3712  SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
3713 
3714  SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
3715  SET_DO_SHOW(FORMAT_TAGS, format_tags);
3716  SET_DO_SHOW(FRAME_TAGS, frame_tags);
3717  SET_DO_SHOW(PROGRAM_TAGS, program_tags);
3718  SET_DO_SHOW(STREAM_TAGS, stream_tags);
3719  SET_DO_SHOW(PROGRAM_STREAM_TAGS, stream_tags);
3720  SET_DO_SHOW(PACKET_TAGS, packet_tags);
3721 
3724  "-bitexact and -show_program_version or -show_library_versions "
3725  "options are incompatible\n");
3726  ret = AVERROR(EINVAL);
3727  goto end;
3728  }
3729 
3731 
3732  if (!print_format)
3733  print_format = av_strdup("default");
3734  if (!print_format) {
3735  ret = AVERROR(ENOMEM);
3736  goto end;
3737  }
3738  w_name = av_strtok(print_format, "=", &buf);
3739  if (!w_name) {
3741  "No name specified for the output format\n");
3742  ret = AVERROR(EINVAL);
3743  goto end;
3744  }
3745  w_args = buf;
3746 
3747  if (show_data_hash) {
3748  if ((ret = av_hash_alloc(&hash, show_data_hash)) < 0) {
3749  if (ret == AVERROR(EINVAL)) {
3750  const char *n;
3752  "Unknown hash algorithm '%s'\nKnown algorithms:",
3753  show_data_hash);
3754  for (i = 0; (n = av_hash_names(i)); i++)
3755  av_log(NULL, AV_LOG_ERROR, " %s", n);
3756  av_log(NULL, AV_LOG_ERROR, "\n");
3757  }
3758  goto end;
3759  }
3760  }
3761 
3762  w = writer_get_by_name(w_name);
3763  if (!w) {
3764  av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
3765  ret = AVERROR(EINVAL);
3766  goto end;
3767  }
3768 
3769  if ((ret = writer_open(&wctx, w, w_args,
3770  sections, FF_ARRAY_ELEMS(sections))) >= 0) {
3771  if (w == &xml_writer)
3773 
3775 
3782 
3783  if (!input_filename &&
3786  show_usage();
3787  av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
3788  av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
3789  ret = AVERROR(EINVAL);
3790  } else if (input_filename) {
3792  if (ret < 0 && do_show_error)
3793  show_error(wctx, ret);
3794  }
3795 
3797  writer_close(&wctx);
3798  }
3799 
3800 end:
3803  av_hash_freep(&hash);
3804 
3805  uninit_opts();
3806  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
3808 
3810 
3811  return ret < 0;
3812 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
flat_escape_key_str
static const char * flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
Definition: ffprobe.c:1266
main
int main(int argc, char **argv)
Definition: ffprobe.c:3665
AVSubtitle
Definition: avcodec.h:2722
SECTION_ID_STREAM_SIDE_DATA_LIST
@ SECTION_ID_STREAM_SIDE_DATA_LIST
Definition: ffprobe.c:200
opt_format
static int opt_format(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3249
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
clear_log
static void clear_log(int need_lock)
Definition: ffprobe.c:2089
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
AVHDRPlusColorTransformParams::average_maxrgb
AVRational average_maxrgb
The average of linearized maxRGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:164
mark_section_show_entries
static void mark_section_show_entries(SectionID section_id, int show_all_entries, AVDictionary *entries)
Definition: ffprobe.c:3259
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:171
AVCodec
AVCodec.
Definition: codec.h:197
writer_get_by_name
static const Writer * writer_get_by_name(const char *name)
Definition: ffprobe.c:897
av_utf8_decode
int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end, unsigned int flags)
Read and decode a single UTF-8 code point (character) from the buffer in *buf, and update *buf to poi...
Definition: avstring.c:376
AVDynamicHDRPlus::params
AVHDRPlusColorTransformParams params[3]
The color transform parameters for every processing window.
Definition: hdr_dynamic_metadata.h:264
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
flat_options
static const AVOption flat_options[]
Definition: ffprobe.c:1242
WriterContext::section_pbuf
AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]
generic print buffer dedicated to each section, used by various writers
Definition: ffprobe.c:469
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
use_byte_value_binary_prefix
static int use_byte_value_binary_prefix
Definition: ffprobe.c:116
WriterContext::level
int level
current level, starting from 0
Definition: ffprobe.c:462
WriterContext::string_validation
int string_validation
Definition: ffprobe.c:476
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
MAX_REGISTERED_WRITERS_NB
#define MAX_REGISTERED_WRITERS_NB
Definition: ffprobe.c:882
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:206
do_show_log
static int do_show_log
Definition: ffprobe.c:105
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
av_clip
#define av_clip
Definition: common.h:122
InputFile::fmt_ctx
AVFormatContext * fmt_ctx
Definition: ffprobe.c:77
SECTION_MAX_NB_LEVELS
#define SECTION_MAX_NB_LEVELS
Definition: ffprobe.c:451
writer_close
static void writer_close(WriterContext **wctx)
Definition: ffprobe.c:518
SECTION_ID_STREAM_SIDE_DATA
@ SECTION_ID_STREAM_SIDE_DATA
Definition: ffprobe.c:201
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
do_show_frame_tags
static int do_show_frame_tags
Definition: ffprobe.c:109
PLANAR
#define PLANAR
Definition: flacdsp.c:43
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1193
r
const char * r
Definition: vf_curves.c:116
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
SECTION_ID_NONE
@ SECTION_ID_NONE
Definition: ffprobe.c:158
opt.h
read_intervals_nb
static int read_intervals_nb
Definition: ffprobe.c:133
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:460
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
Definition: avpacket.c:368
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
ReadInterval::end_is_offset
int end_is_offset
Definition: ffprobe.c:128
LogBuffer::log_message
char * log_message
Definition: ffprobe.c:294
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:483
libm.h
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
show_streams
static int show_streams(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:2792
Writer::name
const char * name
Definition: ffprobe.c:438
print_str
#define print_str(k, v)
Definition: ffprobe.c:1811
LogBuffer::context_name
char * context_name
Definition: ffprobe.c:292
writer_print_section_header
static void writer_print_section_header(WriterContext *wctx, int section_id)
Definition: ffprobe.c:632
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:151
AV_HASH_MAX_SIZE
#define AV_HASH_MAX_SIZE
Maximum value that av_hash_get_size() will currently return.
Definition: hash.h:158
AVHDRPlusColorTransformParams::rotation_angle
uint8_t rotation_angle
The clockwise rotation angle in degree of arc with respect to the positive direction of the x-axis of...
Definition: hdr_dynamic_metadata.h:118
print_val
#define print_val(k, v, u)
Definition: ffprobe.c:1818
compact_print_section_footer
static void compact_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1154
SECTION_ID_PACKET_SIDE_DATA_LIST
@ SECTION_ID_PACKET_SIDE_DATA_LIST
Definition: ffprobe.c:180
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1463
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AVHDRPlusPercentile::percentile
AVRational percentile
The linearized maxRGB value at a specific percentile in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:52
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:223
show_stream
static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int in_program)
Definition: ffprobe.c:2580
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:32
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:149
Writer::init
int(* init)(WriterContext *wctx)
Definition: ffprobe.c:440
thread.h
value_string
static char * value_string(char *buf, int buf_size, struct unit_value uv)
Definition: ffprobe.c:368
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
read_packets
static int read_packets(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:2560
pthread_mutex_init
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
AVCodecDescriptor::long_name
const char * long_name
A more descriptive name for this codec.
Definition: codec_desc.h:50
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
show_packet
static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
Definition: ffprobe.c:2140
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:417
CompactContext::print_section
int print_section
Definition: ffprobe.c:1077
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
InputStream::dec_ctx
AVCodecContext * dec_ctx
Definition: ffmpeg.h:309
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
Writer::print_section_footer
void(* print_section_footer)(WriterContext *wctx)
Definition: ffprobe.c:444
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
writer_open
static int writer_open(WriterContext **wctx, const Writer *writer, const char *args, const struct section *sections, int nb_sections)
Definition: ffprobe.c:545
selected_streams
static int * selected_streams
Definition: ffprobe.c:286
SECTION_ID_PROGRAM_TAGS
@ SECTION_ID_PROGRAM_TAGS
Definition: ffprobe.c:192
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse
uint16_t semimajor_axis_external_ellipse
The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:134
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:246
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
DefaultContext
Definition: ffprobe.c:924
Writer::priv_class
const AVClass * priv_class
private class of the writer, if any
Definition: ffprobe.c:436
AVHDRPlusColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for SMPTE 2094-40.
Definition: hdr_dynamic_metadata.h:59
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:360
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
profile
mfxU16 profile
Definition: qsvenc.c:45
WriterContext::section
const struct section * section[SECTION_MAX_NB_LEVELS]
section per each level
Definition: ffprobe.c:468
json_escape_str
static const char * json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
Definition: ffprobe.c:1488
print_ts
#define print_ts(k, v)
Definition: ffprobe.c:1815
opt_input_file_i
static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3372
WriterContext::nb_section_packet_frame
unsigned int nb_section_packet_frame
nb_section_packet or nb_section_frame according if is_packets_and_frames
Definition: ffprobe.c:474
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1300
AVPacketSideData
Definition: packet.h:306
w
uint8_t w
Definition: llviddspenc.c:39
validate_string
static int validate_string(WriterContext *wctx, char **dstp, const char *src)
Definition: ffprobe.c:684
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:178
opt_show_format_entry
static int opt_show_format_entry(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3343
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1034
SECTION_ID_PIXEL_FORMAT_COMPONENTS
@ SECTION_ID_PIXEL_FORMAT_COMPONENTS
Definition: ffprobe.c:185
AVDynamicHDRPlus::num_cols_targeted_system_display_actual_peak_luminance
uint8_t num_cols_targeted_system_display_actual_peak_luminance
The number of columns in the targeted_system_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:290
AVPacket::data
uint8_t * data
Definition: packet.h:369
ReadInterval::duration_frames
int duration_frames
Definition: ffprobe.c:129
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:58
av_spherical_tile_bounds
void av_spherical_tile_bounds(const AVSphericalMapping *map, size_t width, size_t height, size_t *left, size_t *top, size_t *right, size_t *bottom)
Convert the bounding fields from an AVSphericalVideo from 0.32 fixed point to pixels.
Definition: spherical.c:37
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:82
AVOption
AVOption.
Definition: opt.h:248
HAS_ARG
#define HAS_ARG
Definition: cmdutils.h:161
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:486
SECTION_ID_STREAM
@ SECTION_ID_STREAM
Definition: ffprobe.c:196
section::element_name
const char * element_name
name of the contained element, if provided
Definition: ffprobe.c:151
SECTION_ID_PIXEL_FORMAT_FLAGS
@ SECTION_ID_PIXEL_FORMAT_FLAGS
Definition: ffprobe.c:183
LogBuffer
Definition: ffprobe.c:291
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:946
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1192
data
const char data[16]
Definition: mxf.c:142
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:2580
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:70
writer_print_integer
static void writer_print_integer(WriterContext *wctx, const char *key, long long int val)
Definition: ffprobe.c:673
PRINT_DISPOSITION
#define PRINT_DISPOSITION(flagname, name)
XMLContext::within_tag
int within_tag
Definition: ffprobe.c:1628
SECTION_MAX_NB_CHILDREN
#define SECTION_MAX_NB_CHILDREN
Definition: ffprobe.c:139
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:70
do_show_stream_tags
static int do_show_stream_tags
Definition: ffprobe.c:111
ini_escape_str
static char * ini_escape_str(AVBPrint *dst, const char *src)
Definition: ffprobe.c:1372
print_section_header
#define print_section_header(s)
Definition: ffprobe.c:1825
SECTION_ID_PIXEL_FORMAT
@ SECTION_ID_PIXEL_FORMAT
Definition: ffprobe.c:182
AVHDRPlusColorTransformParams::tone_mapping_flag
uint8_t tone_mapping_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_metadata.h:189
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
SECTION_ID_PROGRAM_STREAM
@ SECTION_ID_PROGRAM_STREAM
Definition: ffprobe.c:191
print_format
static char * print_format
Definition: ffprobe.c:120
category
category
Definition: openal-dec.c:248
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1414
OFFSET
#define OFFSET(x)
Definition: ffprobe.c:1635
SECTION_ID_FORMAT
@ SECTION_ID_FORMAT
Definition: ffprobe.c:163
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:203
avcodec_profile_name
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:526
AVOption::flags
int flags
Definition: opt.h:277
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:84
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:2525
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
AV_SPHERICAL_EQUIRECTANGULAR_TILE
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:72
check_section_show_entries
static int check_section_show_entries(int section_id)
Definition: ffprobe.c:3648
print_section
static void print_section(SectionID id, int level)
Definition: ffprobe.c:3544
section::id
int id
unique id identifying a section
Definition: ffprobe.c:142
AVHDRPlusColorTransformParams::distribution_maxrgb
AVHDRPlusPercentile distribution_maxrgb[15]
The linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:176
AVDictionary
Definition: dict.c:30
writer_options
static const AVOption writer_options[]
Definition: ffprobe.c:489
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:158
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:458
DefaultContext::nokey
int nokey
Definition: ffprobe.c:926
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1741
writer_register_all
static void writer_register_all(void)
Definition: ffprobe.c:1786
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
CompactContext
Definition: ffprobe.c:1072
AVHDRPlusColorTransformParams::knee_point_x
AVRational knee_point_x
The x coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:196
dec_val
double dec_val
Definition: ffprobe.c:266
show_tags
static int show_tags(WriterContext *w, AVDictionary *tags, int section_id)
Definition: ffprobe.c:1836
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:398
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
do_show_format_tags
static int do_show_format_tags
Definition: ffprobe.c:108
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:2982
section::unique_name
const char * unique_name
unique section name, in case the name is ambiguous
Definition: ffprobe.c:152
Writer::print_string
void(* print_string)(WriterContext *wctx, const char *, const char *)
Definition: ffprobe.c:447
do_show_frames
static int do_show_frames
Definition: ffprobe.c:94
json_print_int
static void json_print_int(WriterContext *wctx, const char *key, long long int value)
Definition: ffprobe.c:1595
OptionDef
Definition: cmdutils.h:158
AVUNERROR
#define AVUNERROR(e)
Definition: error.h:44
compact_init
static av_cold int compact_init(WriterContext *wctx)
Definition: ffprobe.c:1102
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:652
xml_print_section_footer
static void xml_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1717
SECTION_ID_FRAME_TAGS
@ SECTION_ID_FRAME_TAGS
Definition: ffprobe.c:167
ReadInterval::id
int id
identifier
Definition: ffprobe.c:125
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
do_show_library_versions
static int do_show_library_versions
Definition: ffprobe.c:101
exit_program
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:133
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
InputStream
Definition: ffmpeg.h:300
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4481
AVPacketSideData::size
size_t size
Definition: packet.h:311
match_section
static int match_section(const char *section_name, int show_all_entries, AVDictionary *entries)
Definition: ffprobe.c:3274
AVHDRPlusColorTransformParams::color_saturation_mapping_flag
uint8_t color_saturation_mapping_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:222
INIContext
Definition: ffprobe.c:1356
unit_hertz_str
static const char unit_hertz_str[]
Definition: ffprobe.c:279
AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES
#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES
exclude control codes not accepted by XML
Definition: avstring.h:383
SECTION_ID_STREAMS
@ SECTION_ID_STREAMS
Definition: ffprobe.c:198
print_error
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:1084
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:39
AVFormatContext::iformat
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1244
json_print_section_footer
static void json_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1548
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2961
unit_value::val
union unit_value::@5 val
AVHDRPlusColorTransformParams::center_of_ellipse_x
uint16_t center_of_ellipse_x
The x coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:102
opt_pretty
static int opt_pretty(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3535
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:545
U
#define U(x)
Definition: vp56_arith.h:37
json_options
static const AVOption json_options[]
Definition: ffprobe.c:1470
default_options
static const AVOption default_options[]
Definition: ffprobe.c:934
fail
#define fail()
Definition: checkasm.h:133
writer_get_name
static const char * writer_get_name(void *p)
Definition: ffprobe.c:481
av_hash_get_name
const char * av_hash_get_name(const AVHashContext *ctx)
Definition: hash.c:92
process_frame
static av_always_inline int process_frame(WriterContext *w, InputFile *ifile, AVFrame *frame, AVPacket *pkt, int *packet_new)
Definition: ffprobe.c:2365
LogBuffer::log_level
int log_level
Definition: ffprobe.c:293
print_chroma_location
static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
Definition: ffprobe.c:2078
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:105
Writer::uninit
void(* uninit)(WriterContext *wctx)
Definition: ffprobe.c:441
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
timecode.h
SECTION_FLAG_HAS_VARIABLE_FIELDS
#define SECTION_FLAG_HAS_VARIABLE_FIELDS
the section may contain a variable number of fields with variable keys.
Definition: ffprobe.c:147
json_writer
static const Writer json_writer
Definition: ffprobe.c:1612
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1124
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
AVChapter
Definition: avformat.h:1185
default_print_int
static void default_print_int(WriterContext *wctx, const char *key, long long int value)
Definition: ffprobe.c:1001
val
static double val(void *priv, double ch)
Definition: aeval.c:76
json_init
static av_cold int json_init(WriterContext *wctx)
Definition: ffprobe.c:1478
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffprobe.c:3384
c_escape_str
static const char * c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Apply C-language-like string escaping.
Definition: ffprobe.c:1026
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:724
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
ini_print_section_header
static void ini_print_section_header(WriterContext *wctx)
Definition: ffprobe.c:1399
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
show_log
static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
Definition: ffprobe.c:2105
OPT_STRING
#define OPT_STRING
Definition: cmdutils.h:164
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
AV_FIELD_TB
@ AV_FIELD_TB
Definition: codec_par.h:41
input_filename
static const char * input_filename
Definition: ffprobe.c:258
print_duration_ts
#define print_duration_ts(k, v)
Definition: ffprobe.c:1817
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
json_print_section_header
static void json_print_section_header(WriterContext *wctx)
Definition: ffprobe.c:1510
AVRational::num
int num
Numerator.
Definition: rational.h:59
avformat_network_init
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:5056
InputFile
Definition: ffmpeg.h:400
AVHDRPlusColorTransformParams::knee_point_y
AVRational knee_point_y
The y coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:203
do_read_packets
static int do_read_packets
Definition: ffprobe.c:90
AVHDRPlusColorTransformParams::num_bezier_curve_anchors
uint8_t num_bezier_curve_anchors
The number of the intermediate anchor parameters of the tone mapping function in the processing windo...
Definition: hdr_dynamic_metadata.h:209
opt_read_intervals
static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3530
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:551
close_input_file
static void close_input_file(InputFile *ifile)
Definition: ffprobe.c:3050
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:172
parse_read_intervals
static int parse_read_intervals(const char *intervals_spec)
Definition: ffprobe.c:3482
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1354
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
json_print_item_str
static void json_print_item_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1570
av_packet_side_data_name
const char * av_packet_side_data_name(enum AVPacketSideDataType type)
Definition: avpacket.c:385
default_writer
static const Writer default_writer
Definition: ffprobe.c:1010
avassert.h
writer_print_time
static void writer_print_time(WriterContext *wctx, const char *key, int64_t ts, const AVRational *time_base, int is_duration)
Definition: ffprobe.c:787
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2216
av_guess_sample_aspect_ratio
AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio.
Definition: utils.c:5119
do_show_error
static int do_show_error
Definition: ffprobe.c:92
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
CHECK_END
#define CHECK_END
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1474
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:640
av_cold
#define av_cold
Definition: attributes.h:90
av_dump_format
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate,...
Definition: dump.c:640
nb_streams_frames
static uint64_t * nb_streams_frames
Definition: ffprobe.c:285
AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES
#define AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES
Within AV_ESCAPE_MODE_XML, additionally escape double quotes for double quoted attributes.
Definition: avstring.h:357
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
postprocess.h
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:328
SECTION_ID_FORMAT_TAGS
@ SECTION_ID_FORMAT_TAGS
Definition: ffprobe.c:164
Writer::print_rational
void(* print_rational)(WriterContext *wctx, AVRational *q, char *sep)
Definition: ffprobe.c:446
OPT_INT
#define OPT_INT
Definition: cmdutils.h:167
writer_print_data_hash
static void writer_print_data_hash(WriterContext *wctx, const char *name, uint8_t *data, int size)
Definition: ffprobe.c:841
initialized
static int initialized
Definition: vaapi_transcode.c:46
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:173
do_count_frames
static int do_count_frames
Definition: ffprobe.c:87
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1192
writer_child_next
static void * writer_child_next(void *obj, void *prev)
Definition: ffprobe.c:502
print_section_footer
#define print_section_footer(s)
Definition: ffprobe.c:1826
ReadInterval::end
int64_t end
start, end in second/AV_TIME_BASE units
Definition: ffprobe.c:126
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
stereo3d.h
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
log_read_interval
static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
Definition: ffprobe.c:2428
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVHDRPlusColorTransformParams::semiminor_axis_external_ellipse
uint16_t semiminor_axis_external_ellipse
The semi-minor axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:141
AV_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:114
unit_bit_per_second_str
static const char unit_bit_per_second_str[]
Definition: ffprobe.c:281
show_program
static int show_program(WriterContext *w, InputFile *ifile, AVProgram *program)
Definition: ffprobe.c:2809
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
xml_options
static const AVOption xml_options[]
Definition: ffprobe.c:1637
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1413
AVHDRPlusColorTransformParams::window_upper_left_corner_y
AVRational window_upper_left_corner_y
The relative y coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:76
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1464
AVHDRPlusColorTransformParams::window_lower_right_corner_x
AVRational window_lower_right_corner_x
The relative x coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:85
SECTION_ID_SUBTITLE
@ SECTION_ID_SUBTITLE
Definition: ffprobe.c:202
AVDictionaryEntry::key
char * key
Definition: dict.h:82
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_hash_alloc
int av_hash_alloc(AVHashContext **ctx, const char *name)
Allocate a hash context for the algorithm specified by name.
Definition: hash.c:102
av_bprint_channel_layout
void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout)
Append a description of a channel layout to a bprint buffer.
Definition: channel_layout.c:183
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:186
AVDynamicHDRPlus::targeted_system_display_maximum_luminance
AVRational targeted_system_display_maximum_luminance
The nominal maximum display luminance of the targeted system display, in units of 0....
Definition: hdr_dynamic_metadata.h:271
CompactContext::item_sep
char item_sep
Definition: ffprobe.c:1075
print_fmt
#define print_fmt(k, f,...)
Definition: ffprobe.c:1803
FlatContext
Definition: ffprobe.c:1232
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:652
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
xml_print_str
static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1736
probe_file
static int probe_file(WriterContext *wctx, const char *filename, const char *print_filename)
Definition: ffprobe.c:3065
AVDynamicHDRPlus::mastering_display_actual_peak_luminance_flag
uint8_t mastering_display_actual_peak_luminance_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:303
JSON_INDENT
#define JSON_INDENT()
Definition: ffprobe.c:1508
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
AVPacketSideData::data
uint8_t * data
Definition: packet.h:307
section::show_all_entries
int show_all_entries
Definition: ffprobe.c:154
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:54
print_pkt_side_data
static void print_pkt_side_data(WriterContext *w, AVCodecParameters *par, const AVPacketSideData *side_data, int nb_side_data, SectionID id_data_list, SectionID id_data)
Definition: ffprobe.c:1953
ctx
AVFormatContext * ctx
Definition: movenc.c:48
flat_print_str
static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1330
SECTION_ID_ROOT
@ SECTION_ID_ROOT
Definition: ffprobe.c:195
nb_streams
static int nb_streams
Definition: ffprobe.c:283
ffprobe_show_program_version
static void ffprobe_show_program_version(WriterContext *w)
Definition: ffprobe.c:3153
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
do_show_chapter_tags
static int do_show_chapter_tags
Definition: ffprobe.c:107
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
do_show_pixel_format_components
static int do_show_pixel_format_components
Definition: ffprobe.c:104
parse_options
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:379
CompactContext::nested_section
int nested_section[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1080
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1416
flat_writer
static const Writer flat_writer
Definition: ffprobe.c:1343
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:49
key
const char * key
Definition: hwcontext_opencl.c:168
color_range
color_range
Definition: vf_selectivecolor.c:44
flat_escape_value_str
static const char * flat_escape_value_str(AVBPrint *dst, const char *src)
Definition: ffprobe.c:1281
do_show_chapters
static int do_show_chapters
Definition: ffprobe.c:91
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:461
AVFormatContext::probe_score
int probe_score
format probing score.
Definition: avformat.h:1670
AV_FIELD_BT
@ AV_FIELD_BT
Definition: codec_par.h:42
show_chapters
static int show_chapters(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:2862
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:52
find_stream_info
static int find_stream_info
Definition: ffprobe.c:135
SECTION_ID_FRAME_LOGS
@ SECTION_ID_FRAME_LOGS
Definition: ffprobe.c:173
int32_t
int32_t
Definition: audio_convert.c:194
arg
const char * arg
Definition: jacosubdec.c:66
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
do_show_pixel_format_flags
static int do_show_pixel_format_flags
Definition: ffprobe.c:103
AVHDRPlusPercentile::percentage
uint8_t percentage
The percentage value corresponding to a specific percentile linearized RGB value in the processing wi...
Definition: hdr_dynamic_metadata.h:45
if
if(ret)
Definition: filter_design.txt:179
compact_print_section_header
static void compact_print_section_header(WriterContext *wctx)
Definition: ffprobe.c:1124
SECTION_FLAG_IS_WRAPPER
#define SECTION_FLAG_IS_WRAPPER
the section only contains other sections, but has no data at its own level
Definition: ffprobe.c:145
section::name
const char * name
Definition: ffprobe.c:143
open_input_file
static int open_input_file(InputFile *ifile, const char *filename, const char *print_filename)
Definition: ffprobe.c:2932
writer_print_data
static void writer_print_data(WriterContext *wctx, const char *name, uint8_t *data, int size)
Definition: ffprobe.c:813
InputFile::streams
InputStream * streams
Definition: ffprobe.c:79
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2901
ReadInterval::start
int64_t start
Definition: ffprobe.c:126
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
AVFormatContext
Format I/O context.
Definition: avformat.h:1232
print_int
#define print_int(k, v)
Definition: ffprobe.c:1809
init_dynload
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:117
opts
AVDictionary * opts
Definition: movenc.c:50
read_intervals
static ReadInterval * read_intervals
Definition: ffprobe.c:132
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
opt_input_file
static void opt_input_file(void *optctx, const char *arg)
Definition: ffprobe.c:3359
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVDynamicHDRPlus::application_version
uint8_t application_version
Application version in the application defining document in ST-2094 suite.
Definition: hdr_dynamic_metadata.h:253
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ReadInterval::has_end
int has_end
Definition: ffprobe.c:127
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:311
SECTION_ID_FRAME_LOG
@ SECTION_ID_FRAME_LOG
Definition: ffprobe.c:172
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:902
NULL
#define NULL
Definition: coverity.c:32
section::children_ids
int children_ids[SECTION_MAX_NB_CHILDREN+1]
list of children section IDS, terminated by -1
Definition: ffprobe.c:150
compact_print_str
static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1164
av_hash_names
const char * av_hash_names(int i)
Get the names of available hash algorithms.
Definition: hash.c:86
SET_DO_SHOW
#define SET_DO_SHOW(id, varname)
Definition: ffprobe.c:3660
print_color_range
static void print_color_range(WriterContext *w, enum AVColorRange color_range)
Definition: ffprobe.c:2038
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:55
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffprobe.c:83
compact_writer
static const Writer compact_writer
Definition: ffprobe.c:1187
StringValidation
StringValidation
Definition: ffprobe.c:428
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:59
FlatContext::hierarchical
int hierarchical
Definition: ffprobe.c:1236
InputStream::st
AVStream * st
Definition: ffmpeg.h:302
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
av_hash_init
void av_hash_init(AVHashContext *ctx)
Initialize or reset a hash context.
Definition: hash.c:139
fmt_ctx
static AVFormatContext * fmt_ctx
Definition: demuxing_decoding.c:37
compact_print_int
static void compact_print_int(WriterContext *wctx, const char *key, long long int value)
Definition: ffprobe.c:1177
OPT_EXPERT
#define OPT_EXPERT
Definition: cmdutils.h:163
ERROR
static void ERROR(const char *str)
Definition: audio_fifo.c:57
do_read_frames
static int do_read_frames
Definition: ffprobe.c:89
SECTION_ID_LIBRARY_VERSION
@ SECTION_ID_LIBRARY_VERSION
Definition: ffprobe.c:174
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:188
hash
static struct AVHashContext * hash
Definition: ffprobe.c:262
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
SECTION_ID_STREAM_TAGS
@ SECTION_ID_STREAM_TAGS
Definition: ffprobe.c:199
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:313
print_q
#define print_q(k, v, s)
Definition: ffprobe.c:1810
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1274
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:445
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
src
#define src
Definition: vp8dsp.c:255
parseutils.h
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:143
init_opts
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
Definition: cmdutils.c:82
WriterContext::name
char * name
name of this writer instance
Definition: ffprobe.c:456
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:119
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:937
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2919
AVHDRPlusColorTransformParams::fraction_bright_pixels
AVRational fraction_bright_pixels
The fraction of selected pixels in the image that contains the brightest pixel in the scene.
Definition: hdr_dynamic_metadata.h:183
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:76
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:144
xml_init
static av_cold int xml_init(WriterContext *wctx)
Definition: ffprobe.c:1647
WriterContext::sections
const struct section * sections
array containing all sections
Definition: ffprobe.c:459
csv_writer
static const Writer csv_writer
Definition: ffprobe.c:1218
print_color_trc
static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
Definition: ffprobe.c:2068
Writer::print_integer
void(* print_integer)(WriterContext *wctx, const char *, long long int)
Definition: ffprobe.c:445
do_show_programs
static int do_show_programs
Definition: ffprobe.c:96
AVHDRPlusColorTransformParams::color_saturation_weight
AVRational color_saturation_weight
The color saturation gain in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:229
bin_str
const char * bin_str
Definition: ffprobe.c:267
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
read_interval_packets
static int read_interval_packets(WriterContext *w, InputFile *ifile, const ReadInterval *interval, int64_t *cur_ts)
Definition: ffprobe.c:2452
real_options
static const OptionDef real_options[]
Definition: ffprobe.c:3598
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:552
WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER
#define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER
Definition: ffprobe.c:426
AVCodecParameters::level
int level
Definition: codec_par.h:121
WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS
#define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS
Definition: ffprobe.c:425
swresample.h
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
unit_byte_str
static const char unit_byte_str[]
Definition: ffprobe.c:280
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffprobe.c:84
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:67
av_hash_freep
void av_hash_freep(AVHashContext **ctx)
Free hash context and set hash context pointer to NULL.
Definition: hash.c:240
show_format
static int show_format(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:2887
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:924
SECTION_ID_CHAPTER
@ SECTION_ID_CHAPTER
Definition: ffprobe.c:159
print_duration_time
#define print_duration_time(k, v, tb)
Definition: ffprobe.c:1816
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
show_value_unit
static int show_value_unit
Definition: ffprobe.c:114
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1288
print_input_filename
static const char * print_input_filename
Definition: ffprobe.c:259
SECTION_ID_FRAMES
@ SECTION_ID_FRAMES
Definition: ffprobe.c:166
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:70
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:630
csv_escape_str
static const char * csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Quote fields containing special characters, check RFC4180.
Definition: ffprobe.c:1049
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3602
ALPHA
@ ALPHA
Definition: drawutils.c:33
WRITER_STRING_VALIDATION_IGNORE
@ WRITER_STRING_VALIDATION_IGNORE
Definition: ffprobe.c:431
av_spherical_projection_name
const char * av_spherical_projection_name(enum AVSphericalProjection projection)
Provide a human-readable name of a given AVSphericalProjection.
Definition: spherical.c:61
AV_SPHERICAL_CUBEMAP
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
WriterContext::string_validation_utf8_flags
unsigned int string_validation_utf8_flags
Definition: ffprobe.c:478
DefaultContext::noprint_wrappers
int noprint_wrappers
Definition: ffprobe.c:927
av_log_set_callback
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:455
AVDynamicHDRPlus::num_rows_mastering_display_actual_peak_luminance
uint8_t num_rows_mastering_display_actual_peak_luminance
The number of rows in the mastering_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:309
AVPacket::size
int size
Definition: packet.h:370
ReadInterval::start_is_offset
int start_is_offset
Definition: ffprobe.c:128
do_show_packet_tags
static int do_show_packet_tags
Definition: ffprobe.c:112
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: utils.c:5326
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:325
SECTION_ID_STREAM_DISPOSITION
@ SECTION_ID_STREAM_DISPOSITION
Definition: ffprobe.c:197
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
PRINT_PIX_FMT_FLAG
#define PRINT_PIX_FMT_FLAG(flagname, name)
Definition: ffprobe.c:3198
OPT_AUDIO
#define OPT_AUDIO
Definition: cmdutils.h:166
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
AVClass::category
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:133
AVDynamicHDRPlus::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_metadata.h:259
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
XMLContext::fully_qualified
int fully_qualified
Definition: ffprobe.c:1630
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1328
si_prefixes
static const struct @4 si_prefixes[]
SECTION_FLAG_IS_ARRAY
#define SECTION_FLAG_IS_ARRAY
the section contains an array of elements of the same type
Definition: ffprobe.c:146
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2085
SectionID
SectionID
Definition: ffprobe.c:157
REALLOCZ_ARRAY_STREAM
#define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n)
Definition: ffprobe.c:1828
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:87
AVClass::get_category
AVClassCategory(* get_category)(void *ctx)
Callback to return the category.
Definition: log.h:139
size
int size
Definition: twinvq_data.h:10344
SECTION_ID_CHAPTER_TAGS
@ SECTION_ID_CHAPTER_TAGS
Definition: ffprobe.c:160
AV_ESCAPE_MODE_XML
@ AV_ESCAPE_MODE_XML
Use XML non-markup character data escaping.
Definition: avstring.h:327
show_private_data
static int show_private_data
Definition: ffprobe.c:118
avformat_seek_file
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:2512
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVDynamicHDRPlus::mastering_display_actual_peak_luminance
AVRational mastering_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the mastering display used for mastering the image essence.
Definition: hdr_dynamic_metadata.h:322
section
Definition: ffprobe.c:141
xml_print_int
static void xml_print_int(WriterContext *wctx, const char *key, long long int value)
Definition: ffprobe.c:1767
opt_show_versions
static int opt_show_versions(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3573
AVFrameSideData::data
uint8_t * data
Definition: frame.h:222
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:120
PAL
#define PAL
Definition: bktr.c:65
setup_find_stream_info_opts
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2161
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:606
swscale
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale.c:238
ffprobe_show_library_versions
static void ffprobe_show_library_versions(WriterContext *w)
Definition: ffprobe.c:3184
printf
printf("static const uint8_t my_array[100] = {\n")
SECTION_ID_PACKETS_AND_FRAMES
@ SECTION_ID_PACKETS_AND_FRAMES
Definition: ffprobe.c:179
AVOption::name
const char * name
Definition: opt.h:249
use_value_prefix
static int use_value_prefix
Definition: ffprobe.c:115
SECTION_ID_ERROR
@ SECTION_ID_ERROR
Definition: ffprobe.c:162
DefaultContext::nested_section
int nested_section[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:928
unit_value
Definition: ffprobe.c:363
flat_print_int
static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
Definition: ffprobe.c:1325
avdevice.h
show_error
static void show_error(WriterContext *w, int err)
Definition: ffprobe.c:2918
Writer::flags
int flags
a combination or WRITER_FLAG_*
Definition: ffprobe.c:448
av_packet_unpack_dictionary
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: avpacket.c:556
ini_print_str
static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1432
AVHDRPlusColorTransformParams::window_lower_right_corner_y
AVRational window_lower_right_corner_y
The relative y coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:94
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
WriterContext::nb_section_frame
unsigned int nb_section_frame
number of the frame section in case we are in "packets_and_frames" section
Definition: ffprobe.c:473
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
SECTION_ID_FRAME_SIDE_DATA_LIST
@ SECTION_ID_FRAME_SIDE_DATA_LIST
Definition: ffprobe.c:168
SECTION_ID_PACKET_TAGS
@ SECTION_ID_PACKET_TAGS
Definition: ffprobe.c:177
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVHashContext
Definition: hash.c:58
line
Definition: graph2dot.c:48
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:235
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
do_show_format
static int do_show_format
Definition: ffprobe.c:93
ReadInterval
Definition: ffprobe.c:124
va_copy
#define va_copy(dst, src)
Definition: va_copy.h:31
writer_print_string
static int writer_print_string(WriterContext *wctx, const char *key, const char *val, int flags)
Definition: ffprobe.c:742
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
Writer
Definition: ffprobe.c:435
section::entries_to_show
AVDictionary * entries_to_show
Definition: ffprobe.c:153
do_show_stream_disposition
static int do_show_stream_disposition
Definition: ffprobe.c:98
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
xml_print_section_header
static void xml_print_section_header(WriterContext *wctx)
Definition: ffprobe.c:1677
AVDynamicHDRPlus::num_rows_targeted_system_display_actual_peak_luminance
uint8_t num_rows_targeted_system_display_actual_peak_luminance
The number of rows in the targeted system_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:283
Writer::priv_size
int priv_size
private size for the writer context
Definition: ffprobe.c:437
AVStream::side_data
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:975
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:605
registered_writers
static const Writer * registered_writers[MAX_REGISTERED_WRITERS_NB+1]
Definition: ffprobe.c:884
AVHDRPlusColorTransformParams::window_upper_left_corner_x
AVRational window_upper_left_corner_x
The relative x coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:67
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1183
do_count_packets
static int do_count_packets
Definition: ffprobe.c:88
pthread_mutex_destroy
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
ReadInterval::has_start
int has_start
Definition: ffprobe.c:127
sections
static struct section sections[]
Definition: ffprobe.c:205
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:83
register_exit
void register_exit(void(*cb)(int ret))
Register a program-specific cleanup routine.
Definition: cmdutils.c:128
unit_value::unit
const char * unit
Definition: ffprobe.c:365
AV_FIELD_BB
@ AV_FIELD_BB
Definition: codec_par.h:40
SECTION_ID_PROGRAM_STREAM_TAGS
@ SECTION_ID_PROGRAM_STREAM_TAGS
Definition: ffprobe.c:188
JSONContext::indent_level
int indent_level
Definition: ffprobe.c:1462
section::flags
int flags
For these sections the element_name field is mandatory.
Definition: ffprobe.c:149
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:589
av_find_input_format
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
bprint.h
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:136
AVHDRPlusColorTransformParams::semimajor_axis_internal_ellipse
uint16_t semimajor_axis_internal_ellipse
The semi-major axis value of the internal ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:125
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
i
int i
Definition: input.c:407
AVClassCategory
AVClassCategory
Definition: log.h:29
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:136
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2183
SECTION_ID_PROGRAM
@ SECTION_ID_PROGRAM
Definition: ffprobe.c:189
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:512
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1189
print_color_space
static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
Definition: ffprobe.c:2048
ffprobe_show_pixel_formats
static void ffprobe_show_pixel_formats(WriterContext *w)
Definition: ffprobe.c:3203
WRITER_STRING_VALIDATION_NB
@ WRITER_STRING_VALIDATION_NB
Definition: ffprobe.c:432
show_usage
static void show_usage(void)
Definition: ffprobe.c:3146
WriterContext::nb_item
unsigned int nb_item[SECTION_MAX_NB_LEVELS]
number of the item printed in the given section, starting from 0
Definition: ffprobe.c:465
csv_options
static const AVOption csv_options[]
Definition: ffprobe.c:1204
show_subtitle
static void show_subtitle(WriterContext *w, AVSubtitle *sub, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2193
AVCodecParameters::height
int height
Definition: codec_par.h:127
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: codec_par.c:147
XMLContext::xsd_strict
int xsd_strict
Definition: ffprobe.c:1631
do_bitexact
static int do_bitexact
Definition: ffprobe.c:86
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:512
display.h
SECTION_ID_PACKETS
@ SECTION_ID_PACKETS
Definition: ffprobe.c:178
xml_writer
static Writer xml_writer
Definition: ffprobe.c:1774
LogBuffer::category
AVClassCategory category
Definition: ffprobe.c:295
writer_print_ts
static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
Definition: ffprobe.c:804
filter_codec_opts
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2103
opt_show_entries
static int opt_show_entries(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3293
av_always_inline
#define av_always_inline
Definition: attributes.h:49
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
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:279
SECTION_ID_FRAME_SIDE_DATA
@ SECTION_ID_FRAME_SIDE_DATA
Definition: ffprobe.c:169
opt_sections
static int opt_sections(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3561
CompactContext::escape_str
const char *(* escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Definition: ffprobe.c:1079
WriterContext::priv
void * priv
private data for use by the filter
Definition: ffprobe.c:457
uint8_t
uint8_t
Definition: audio_convert.c:194
AVHDRPlusColorTransformParams::overlap_process_option
enum AVHDRPlusOverlapProcessOption overlap_process_option
Overlap process option indicates one of the two methods of combining rendered pixels in the processin...
Definition: hdr_dynamic_metadata.h:149
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1150
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:156
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:146
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
upcase_string
static char * upcase_string(char *dst, size_t dst_size, const char *src)
Definition: ffprobe.c:945
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:515
dec_str
const char * dec_str
Definition: ffprobe.c:268
SECTION_ID_PACKET_SIDE_DATA
@ SECTION_ID_PACKET_SIDE_DATA
Definition: ffprobe.c:181
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
use_value_sexagesimal_format
static int use_value_sexagesimal_format
Definition: ffprobe.c:117
SECTION_ID_LIBRARY_VERSIONS
@ SECTION_ID_LIBRARY_VERSIONS
Definition: ffprobe.c:175
SECTION_ID_FRAME_SIDE_DATA_TIMECODE
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE
Definition: ffprobe.c:171
LogBuffer::parent_name
char * parent_name
Definition: ffprobe.c:296
log2
#define log2(x)
Definition: libm.h:404
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
SECTION_ID_PROGRAM_VERSION
@ SECTION_ID_PROGRAM_VERSION
Definition: ffprobe.c:193
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
none_escape_str
static const char * none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Definition: ffprobe.c:1067
ini_writer
static const Writer ini_writer
Definition: ffprobe.c:1448
avcodec.h
parse_loglevel
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the '-loglevel' option in the command line args and apply it.
Definition: cmdutils.c:502
PRINT_STRING_OPT
#define PRINT_STRING_OPT
Definition: ffprobe.c:739
SECTION_ID_PROGRAMS
@ SECTION_ID_PROGRAMS
Definition: ffprobe.c:194
json_print_str
static void json_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1582
ini_print_int
static void ini_print_int(WriterContext *wctx, const char *key, long long int value)
Definition: ffprobe.c:1443
WriterContext::string_validation_replacement
char * string_validation_replacement
Definition: ffprobe.c:477
tag
uint32_t tag
Definition: movenc.c:1611
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:880
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:873
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:283
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:124
log_buffer
static LogBuffer * log_buffer
Definition: ffprobe.c:300
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:72
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
normalize.ifile
ifile
Definition: normalize.py:6
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:96
AVStream::nb_side_data
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:979
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
parse_read_interval
static int parse_read_interval(const char *interval_spec, ReadInterval *interval)
Parse interval specification, according to the format: INTERVAL ::= [START|+START_OFFSET][%[END|+END_...
Definition: ffprobe.c:3400
avformat.h
dovi_meta.h
iformat
static AVInputFormat * iformat
Definition: ffprobe.c:260
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:380
av_bprint_escape
void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, enum AVEscapeMode mode, int flags)
Escape the content in src and append it to dstbuf.
Definition: bprint.c:265
flat_init
static av_cold int flat_init(WriterContext *wctx)
Definition: ffprobe.c:1252
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:384
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
log_buffer_size
static int log_buffer_size
Definition: ffprobe.c:301
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:5068
WriterContext::writer
const Writer * writer
the Writer of which this is an instance
Definition: ffprobe.c:455
SECTION_ID_FRAME
@ SECTION_ID_FRAME
Definition: ffprobe.c:165
XML_INDENT
#define XML_INDENT()
Definition: ffprobe.c:1675
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:71
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:175
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:874
CMDUTILS_COMMON_OPTIONS
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:212
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:165
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
hash.h
CompactContext::nokey
int nokey
Definition: ffprobe.c:1076
WriterContext
Definition: ffprobe.c:453
JSONContext::item_sep
const char * item_sep
Definition: ffprobe.c:1464
nb_streams_packets
static uint64_t * nb_streams_packets
Definition: ffprobe.c:284
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance_flag
uint8_t targeted_system_display_actual_peak_luminance_flag
This flag shall be equal to 0 in bit streams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:277
do_show_program_version
static int do_show_program_version
Definition: ffprobe.c:100
DEFINE_OPT_SHOW_SECTION
#define DEFINE_OPT_SHOW_SECTION(section, target_section_id)
Definition: ffprobe.c:3580
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:659
AVRational::den
int den
Denominator.
Definition: rational.h:60
PRINT_STRING_VALIDATE
#define PRINT_STRING_VALIDATE
Definition: ffprobe.c:740
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:58
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVHDRPlusColorTransformParams::num_distribution_maxrgb_percentiles
uint8_t num_distribution_maxrgb_percentiles
The number of linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:170
AVHDRPlusColorTransformParams::maxscl
AVRational maxscl[3]
The maximum of the color components of linearized RGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:157
SECTION_ID_PIXEL_FORMATS
@ SECTION_ID_PIXEL_FORMATS
Definition: ffprobe.c:186
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
print_str_validate
#define print_str_validate(k, v)
Definition: ffprobe.c:1813
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:221
hdr_dynamic_metadata.h
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
ini_options
static const AVOption ini_options[]
Definition: ffprobe.c:1364
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1015
print_dynamic_hdr10_plus
static void print_dynamic_hdr10_plus(WriterContext *w, const AVDynamicHDRPlus *metadata)
Definition: ffprobe.c:1854
CHECK_COMPLIANCE
#define CHECK_COMPLIANCE(opt, opt_name)
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:56
options
static const OptionDef * options
Definition: ffprobe.c:255
do_show_pixel_formats
static int do_show_pixel_formats
Definition: ffprobe.c:102
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:57
AV_CODEC_ID_PROBE
@ AV_CODEC_ID_PROBE
codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
Definition: codec_id.h:567
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2185
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1347
AVPacket::stream_index
int stream_index
Definition: packet.h:371
FlatContext::sep_str
const char * sep_str
Definition: ffprobe.c:1234
DEFINE_WRITER_CLASS
#define DEFINE_WRITER_CLASS(name)
Definition: ffprobe.c:911
av_hash_update
void av_hash_update(AVHashContext *ctx, const uint8_t *src, int len)
Update a hash context with additional data.
Definition: hash.c:161
opt_print_filename
static int opt_print_filename(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3378
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
tc
#define tc
Definition: regdef.h:69
opt_default
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions.
Definition: cmdutils.c:541
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
XMLContext
Definition: ffprobe.c:1626
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:53
do_show_program_tags
static int do_show_program_tags
Definition: ffprobe.c:110
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
WRITER_STRING_VALIDATION_REPLACE
@ WRITER_STRING_VALIDATION_REPLACE
Definition: ffprobe.c:430
AVHDRPlusColorTransformParams::center_of_ellipse_y
uint16_t center_of_ellipse_y
The y coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:110
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:346
unit_value::i
long long int i
Definition: ffprobe.c:364
CompactContext::item_sep_str
char * item_sep_str
Definition: ffprobe.c:1074
CompactContext::escape_mode_str
char * escape_mode_str
Definition: ffprobe.c:1078
mastering_display_metadata.h
av_hash_final_hex
void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size)
Finalize a hash context and store the hexadecimal representation of the actual hash value as a string...
Definition: hash.c:217
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:155
FlatContext::sep
char sep
Definition: ffprobe.c:1235
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
JSONContext::item_start_end
const char * item_start_end
Definition: ffprobe.c:1464
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:220
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
bin_val
double bin_val
Definition: ffprobe.c:265
ffprobe_cleanup
static void ffprobe_cleanup(int ret)
Definition: ffprobe.c:352
SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST
Definition: ffprobe.c:170
WRITER_STRING_VALIDATION_FAIL
@ WRITER_STRING_VALIDATION_FAIL
Definition: ffprobe.c:429
OPT_VIDEO
#define OPT_VIDEO
Definition: cmdutils.h:165
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
compact_options
static const AVOption compact_options[]
Definition: ffprobe.c:1088
CompactContext::has_nested_elems
int has_nested_elems[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1081
default_print_section_header
static void default_print_section_header(WriterContext *wctx)
Definition: ffprobe.c:954
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
DEFAULT
#define DEFAULT
Definition: avdct.c:28
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
AVFrameSideData::size
int size
Definition: frame.h:224
WriterContext::nb_sections
int nb_sections
number of sections
Definition: ffprobe.c:460
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
cmdutils.h
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance
AVRational targeted_system_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the targeted system display.
Definition: hdr_dynamic_metadata.h:297
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: frame.c:826
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
SHOW_LIB_VERSION
#define SHOW_LIB_VERSION(libname, LIBNAME)
Definition: ffprobe.c:3169
OPT_BOOL
#define OPT_BOOL
Definition: cmdutils.h:162
writer_print_rational
static void writer_print_rational(WriterContext *wctx, const char *key, AVRational q, char sep)
Definition: ffprobe.c:778
XMLContext::indent_level
int indent_level
Definition: ffprobe.c:1629
convert_header.str
string str
Definition: convert_header.py:20
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:228
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:779
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1337
writer_print_section_footer
static void writer_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:656
flat
static av_always_inline void flat(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1089
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
SECTION_ID_PROGRAM_STREAMS
@ SECTION_ID_PROGRAM_STREAMS
Definition: ffprobe.c:190
av_stereo3d_type_name
const char * av_stereo3d_type_name(unsigned int type)
Provide a human-readable name of a given stereo3d type.
Definition: stereo3d.c:57
do_show_data
static int do_show_data
Definition: ffprobe.c:99
flat_print_section_header
static void flat_print_section_header(WriterContext *wctx)
Definition: ffprobe.c:1299
AVClass::parent_log_context_offset
int parent_log_context_offset
Offset in the structure where a pointer to the parent context for logging is stored.
Definition: log.h:108
LogBuffer::parent_category
AVClassCategory parent_category
Definition: ffprobe.c:297
SECTION_ID_PROGRAM_STREAM_DISPOSITION
@ SECTION_ID_PROGRAM_STREAM_DISPOSITION
Definition: ffprobe.c:187
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:176
AVDictionaryEntry::value
char * value
Definition: dict.h:83
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:912
show_data_hash
static char * show_data_hash
Definition: ffprobe.c:122
avstring.h
AVClass::item_name
const char *(* item_name)(void *ctx)
A pointer to a function which returns the name of a context instance ctx associated with the class.
Definition: log.h:78
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
print_primaries
static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
Definition: ffprobe.c:2058
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:174
do_show_streams
static int do_show_streams
Definition: ffprobe.c:97
unit_value::d
double d
Definition: ffprobe.c:364
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:416
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:551
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1191
int
int
Definition: ffmpeg_filter.c:170
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
snprintf
#define snprintf
Definition: snprintf.h:34
stream_specifier
static char * stream_specifier
Definition: ffprobe.c:121
writer_print_integers
static void writer_print_integers(WriterContext *wctx, const char *name, uint8_t *data, int size, const char *format, int columns, int bytes, int offset_add)
Definition: ffprobe.c:856
log_callback
static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
Definition: ffprobe.c:303
SECTION_ID_CHAPTERS
@ SECTION_ID_CHAPTERS
Definition: ffprobe.c:161
color_primaries
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
Definition: vf_colorspace.c:211
print_time
#define print_time(k, v, tb)
Definition: ffprobe.c:1814
default_print_str
static void default_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:992
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:82
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2940
print_str_opt
#define print_str_opt(k, v)
Definition: ffprobe.c:1812
WriterContext::nb_section_packet
unsigned int nb_section_packet
number of the packet section in case we are in "packets_and_frames" section
Definition: ffprobe.c:472
CompactContext::terminate_line
int terminate_line[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1082
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140
default_print_section_footer
static void default_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:979
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
SECTION_ID_PIXEL_FORMAT_COMPONENT
@ SECTION_ID_PIXEL_FORMAT_COMPONENT
Definition: ffprobe.c:184
INIContext::hierarchical
int hierarchical
Definition: ffprobe.c:1358
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
SECTION_ID_PACKET
@ SECTION_ID_PACKET
Definition: ffprobe.c:176
swscale.h
AV_DICT_DONT_STRDUP_KEY
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
Definition: dict.h:72
JSONContext::compact
int compact
Definition: ffprobe.c:1463
unit_second_str
static const char unit_second_str[]
Definition: ffprobe.c:278
AVHDRPlusColorTransformParams::bezier_curve_anchors
AVRational bezier_curve_anchors[15]
The intermediate anchor parameters of the tone mapping function in the processing window in the scene...
Definition: hdr_dynamic_metadata.h:216
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
AVDynamicHDRPlus::num_cols_mastering_display_actual_peak_luminance
uint8_t num_cols_mastering_display_actual_peak_luminance
The number of columns in the mastering_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:315
dec_ctx
static AVCodecContext * dec_ctx
Definition: filtering_audio.c:43
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:381
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
writer_class
static const AVClass writer_class
Definition: ffprobe.c:510
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:2489
do_show_packets
static int do_show_packets
Definition: ffprobe.c:95
show_programs
static int show_programs(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:2844
JSONContext
Definition: ffprobe.c:1460
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:63
bprint_bytes
static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
Definition: ffprobe.c:536
avdevice_register_all
void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:66
Writer::print_section_header
void(* print_section_header)(WriterContext *wctx)
Definition: ffprobe.c:443
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:51
writer_register
static int writer_register(const Writer *writer)
Definition: ffprobe.c:886