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