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 #include <math.h>
31 
32 #include "libavformat/avformat.h"
33 #include "libavformat/version.h"
34 #include "libavcodec/avcodec.h"
35 #include "libavcodec/version.h"
36 #include "libavutil/ambient_viewing_environment.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/channel_layout.h"
41 #include "libavutil/display.h"
42 #include "libavutil/film_grain_params.h"
43 #include "libavutil/hash.h"
44 #include "libavutil/hdr_dynamic_metadata.h"
45 #include "libavutil/iamf.h"
46 #include "libavutil/mastering_display_metadata.h"
47 #include "libavutil/hdr_dynamic_vivid_metadata.h"
48 #include "libavutil/dovi_meta.h"
49 #include "libavutil/mem.h"
50 #include "libavutil/opt.h"
51 #include "libavutil/pixdesc.h"
52 #include "libavutil/spherical.h"
53 #include "libavutil/stereo3d.h"
54 #include "libavutil/dict.h"
55 #include "libavutil/intreadwrite.h"
56 #include "libavutil/libm.h"
57 #include "libavutil/parseutils.h"
58 #include "libavutil/timecode.h"
59 #include "libavutil/timestamp.h"
60 #include "libavdevice/avdevice.h"
61 #include "libavdevice/version.h"
62 #include "libswscale/swscale.h"
63 #include "libswscale/version.h"
64 #include "libswresample/swresample.h"
65 #include "libswresample/version.h"
66 #include "libpostproc/postprocess.h"
67 #include "libpostproc/version.h"
68 #include "libavfilter/version.h"
69 #include "cmdutils.h"
70 #include "opt_common.h"
71 
72 #include "libavutil/thread.h"
73 
74 #if !HAVE_THREADS
75 # ifdef pthread_mutex_lock
76 # undef pthread_mutex_lock
77 # endif
78 # define pthread_mutex_lock(a) do{}while(0)
79 # ifdef pthread_mutex_unlock
80 # undef pthread_mutex_unlock
81 # endif
82 # define pthread_mutex_unlock(a) do{}while(0)
83 #endif
84 
85 // attached as opaque_ref to packets/frames
86 typedef struct FrameData {
87  int64_t pkt_pos;
88  int pkt_size;
89 } FrameData;
90 
91 typedef struct InputStream {
92  AVStream *st;
93 
94  AVCodecContext *dec_ctx;
95 } InputStream;
96 
97 typedef struct InputFile {
98  AVFormatContext *fmt_ctx;
99 
100  InputStream *streams;
101  int nb_streams;
102 } InputFile;
103 
104 const char program_name[] = "ffprobe";
105 const int program_birth_year = 2007;
106 
107 static int do_analyze_frames = 0;
108 static int do_bitexact = 0;
109 static int do_count_frames = 0;
110 static int do_count_packets = 0;
111 static int do_read_frames = 0;
112 static int do_read_packets = 0;
113 static int do_show_chapters = 0;
114 static int do_show_error = 0;
115 static int do_show_format = 0;
116 static int do_show_frames = 0;
117 static int do_show_packets = 0;
118 static int do_show_programs = 0;
119 static int do_show_stream_groups = 0;
120 static int do_show_stream_group_components = 0;
121 static int do_show_streams = 0;
122 static int do_show_stream_disposition = 0;
123 static int do_show_stream_group_disposition = 0;
124 static int do_show_data = 0;
125 static int do_show_program_version = 0;
126 static int do_show_library_versions = 0;
127 static int do_show_pixel_formats = 0;
128 static int do_show_pixel_format_flags = 0;
129 static int do_show_pixel_format_components = 0;
130 static int do_show_log = 0;
131 
132 static int do_show_chapter_tags = 0;
133 static int do_show_format_tags = 0;
134 static int do_show_frame_tags = 0;
135 static int do_show_program_tags = 0;
136 static int do_show_stream_group_tags = 0;
137 static int do_show_stream_tags = 0;
138 static int do_show_packet_tags = 0;
139 
140 static int show_value_unit = 0;
141 static int use_value_prefix = 0;
142 static int use_byte_value_binary_prefix = 0;
143 static int use_value_sexagesimal_format = 0;
144 static int show_private_data = 1;
145 
146 #define SHOW_OPTIONAL_FIELDS_AUTO -1
147 #define SHOW_OPTIONAL_FIELDS_NEVER 0
148 #define SHOW_OPTIONAL_FIELDS_ALWAYS 1
149 static int show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
150 
151 static char *output_format;
152 static char *stream_specifier;
153 static char *show_data_hash;
154 
155 typedef struct ReadInterval {
156  int id; ///< identifier
157  int64_t start, end; ///< start, end in second/AV_TIME_BASE units
158  int has_start, has_end;
159  int start_is_offset, end_is_offset;
160  int duration_frames;
161 } ReadInterval;
162 
163 static ReadInterval *read_intervals;
164 static int read_intervals_nb = 0;
165 
166 static int find_stream_info = 1;
167 
168 /* section structure definition */
169 
170 #define SECTION_MAX_NB_CHILDREN 11
171 
172 typedef enum {
173  SECTION_ID_NONE = -1,
174  SECTION_ID_CHAPTER,
175  SECTION_ID_CHAPTER_TAGS,
176  SECTION_ID_CHAPTERS,
177  SECTION_ID_ERROR,
178  SECTION_ID_FORMAT,
179  SECTION_ID_FORMAT_TAGS,
180  SECTION_ID_FRAME,
181  SECTION_ID_FRAMES,
182  SECTION_ID_FRAME_TAGS,
183  SECTION_ID_FRAME_SIDE_DATA_LIST,
184  SECTION_ID_FRAME_SIDE_DATA,
185  SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST,
186  SECTION_ID_FRAME_SIDE_DATA_TIMECODE,
187  SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST,
188  SECTION_ID_FRAME_SIDE_DATA_COMPONENT,
189  SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST,
190  SECTION_ID_FRAME_SIDE_DATA_PIECE,
191  SECTION_ID_FRAME_LOG,
192  SECTION_ID_FRAME_LOGS,
193  SECTION_ID_LIBRARY_VERSION,
194  SECTION_ID_LIBRARY_VERSIONS,
195  SECTION_ID_PACKET,
196  SECTION_ID_PACKET_TAGS,
197  SECTION_ID_PACKETS,
198  SECTION_ID_PACKETS_AND_FRAMES,
199  SECTION_ID_PACKET_SIDE_DATA_LIST,
200  SECTION_ID_PACKET_SIDE_DATA,
201  SECTION_ID_PIXEL_FORMAT,
202  SECTION_ID_PIXEL_FORMAT_FLAGS,
203  SECTION_ID_PIXEL_FORMAT_COMPONENT,
204  SECTION_ID_PIXEL_FORMAT_COMPONENTS,
205  SECTION_ID_PIXEL_FORMATS,
206  SECTION_ID_PROGRAM_STREAM_DISPOSITION,
207  SECTION_ID_PROGRAM_STREAM_TAGS,
208  SECTION_ID_PROGRAM,
209  SECTION_ID_PROGRAM_STREAMS,
210  SECTION_ID_PROGRAM_STREAM,
211  SECTION_ID_PROGRAM_TAGS,
212  SECTION_ID_PROGRAM_VERSION,
213  SECTION_ID_PROGRAMS,
214  SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION,
215  SECTION_ID_STREAM_GROUP_STREAM_TAGS,
216  SECTION_ID_STREAM_GROUP,
217  SECTION_ID_STREAM_GROUP_COMPONENTS,
218  SECTION_ID_STREAM_GROUP_COMPONENT,
219  SECTION_ID_STREAM_GROUP_SUBCOMPONENTS,
220  SECTION_ID_STREAM_GROUP_SUBCOMPONENT,
221  SECTION_ID_STREAM_GROUP_PIECES,
222  SECTION_ID_STREAM_GROUP_PIECE,
223  SECTION_ID_STREAM_GROUP_SUBPIECES,
224  SECTION_ID_STREAM_GROUP_SUBPIECE,
225  SECTION_ID_STREAM_GROUP_BLOCKS,
226  SECTION_ID_STREAM_GROUP_BLOCK,
227  SECTION_ID_STREAM_GROUP_STREAMS,
228  SECTION_ID_STREAM_GROUP_STREAM,
229  SECTION_ID_STREAM_GROUP_DISPOSITION,
230  SECTION_ID_STREAM_GROUP_TAGS,
231  SECTION_ID_STREAM_GROUPS,
232  SECTION_ID_ROOT,
233  SECTION_ID_STREAM,
234  SECTION_ID_STREAM_DISPOSITION,
235  SECTION_ID_STREAMS,
236  SECTION_ID_STREAM_TAGS,
237  SECTION_ID_STREAM_SIDE_DATA_LIST,
238  SECTION_ID_STREAM_SIDE_DATA,
239  SECTION_ID_SUBTITLE,
240 } SectionID;
241 
242 struct section {
243  int id; ///< unique id identifying a section
244  const char *name;
245 
246 #define SECTION_FLAG_IS_WRAPPER 1 ///< the section only contains other sections, but has no data at its own level
247 #define SECTION_FLAG_IS_ARRAY 2 ///< the section contains an array of elements of the same type
248 #define SECTION_FLAG_HAS_VARIABLE_FIELDS 4 ///< the section may contain a variable number of fields with variable keys.
249  /// For these sections the element_name field is mandatory.
250 #define SECTION_FLAG_HAS_TYPE 8 ///< the section contains a type to distinguish multiple nested elements
251 
252  int flags;
253  const SectionID children_ids[SECTION_MAX_NB_CHILDREN+1]; ///< list of children section IDS, terminated by -1
254  const char *element_name; ///< name of the contained element, if provided
255  const char *unique_name; ///< unique section name, in case the name is ambiguous
256  AVDictionary *entries_to_show;
257  const char *(* get_type)(const void *data); ///< function returning a type if defined, must be defined when SECTION_FLAG_HAS_TYPE is defined
258  int show_all_entries;
259 };
260 
261 static const char *get_packet_side_data_type(const void *data)
262 {
263  const AVPacketSideData *sd = (const AVPacketSideData *)data;
264  return av_x_if_null(av_packet_side_data_name(sd->type), "unknown");
265 }
266 
267 static const char *get_frame_side_data_type(const void *data)
268 {
269  const AVFrameSideData *sd = (const AVFrameSideData *)data;
270  return av_x_if_null(av_frame_side_data_name(sd->type), "unknown");
271 }
272 
273 static const char *get_raw_string_type(const void *data)
274 {
275  return data;
276 }
277 
278 static const char *get_stream_group_type(const void *data)
279 {
280  const AVStreamGroup *stg = (const AVStreamGroup *)data;
281  return av_x_if_null(avformat_stream_group_name(stg->type), "unknown");
282 }
283 
284 static struct section sections[] = {
285  [SECTION_ID_CHAPTERS] = { SECTION_ID_CHAPTERS, "chapters", SECTION_FLAG_IS_ARRAY, { SECTION_ID_CHAPTER, -1 } },
286  [SECTION_ID_CHAPTER] = { SECTION_ID_CHAPTER, "chapter", 0, { SECTION_ID_CHAPTER_TAGS, -1 } },
287  [SECTION_ID_CHAPTER_TAGS] = { SECTION_ID_CHAPTER_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "chapter_tags" },
288  [SECTION_ID_ERROR] = { SECTION_ID_ERROR, "error", 0, { -1 } },
289  [SECTION_ID_FORMAT] = { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },
290  [SECTION_ID_FORMAT_TAGS] = { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },
291  [SECTION_ID_FRAMES] = { SECTION_ID_FRAMES, "frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, SECTION_ID_SUBTITLE, -1 } },
292  [SECTION_ID_FRAME] = { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_LOGS, -1 } },
293  [SECTION_ID_FRAME_TAGS] = { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },
294  [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" },
295  [SECTION_ID_FRAME_SIDE_DATA] = { SECTION_ID_FRAME_SIDE_DATA, "side_data", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST, -1 }, .unique_name = "frame_side_data", .element_name = "side_datum", .get_type = get_frame_side_data_type },
296  [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 } },
297  [SECTION_ID_FRAME_SIDE_DATA_TIMECODE] = { SECTION_ID_FRAME_SIDE_DATA_TIMECODE, "timecode", 0, { -1 } },
298  [SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST] = { SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST, "components", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_COMPONENT, -1 }, .element_name = "component", .unique_name = "frame_side_data_components" },
299  [SECTION_ID_FRAME_SIDE_DATA_COMPONENT] = { SECTION_ID_FRAME_SIDE_DATA_COMPONENT, "component", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST, -1 }, .unique_name = "frame_side_data_component", .element_name = "component_entry", .get_type = get_raw_string_type },
300  [SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST] = { SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST, "pieces", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_PIECE, -1 }, .element_name = "piece", .unique_name = "frame_side_data_pieces" },
301  [SECTION_ID_FRAME_SIDE_DATA_PIECE] = { SECTION_ID_FRAME_SIDE_DATA_PIECE, "piece", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { -1 }, .element_name = "piece_entry", .unique_name = "frame_side_data_piece", .get_type = get_raw_string_type },
302  [SECTION_ID_FRAME_LOGS] = { SECTION_ID_FRAME_LOGS, "logs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_LOG, -1 } },
303  [SECTION_ID_FRAME_LOG] = { SECTION_ID_FRAME_LOG, "log", 0, { -1 }, },
304  [SECTION_ID_LIBRARY_VERSIONS] = { SECTION_ID_LIBRARY_VERSIONS, "library_versions", SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } },
305  [SECTION_ID_LIBRARY_VERSION] = { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },
306  [SECTION_ID_PACKETS] = { SECTION_ID_PACKETS, "packets", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
307  [SECTION_ID_PACKETS_AND_FRAMES] = { SECTION_ID_PACKETS_AND_FRAMES, "packets_and_frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
308  [SECTION_ID_PACKET] = { SECTION_ID_PACKET, "packet", 0, { SECTION_ID_PACKET_TAGS, SECTION_ID_PACKET_SIDE_DATA_LIST, -1 } },
309  [SECTION_ID_PACKET_TAGS] = { SECTION_ID_PACKET_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "packet_tags" },
310  [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" },
311  [SECTION_ID_PACKET_SIDE_DATA] = { SECTION_ID_PACKET_SIDE_DATA, "side_data", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { -1 }, .unique_name = "packet_side_data", .element_name = "side_datum", .get_type = get_packet_side_data_type },
312  [SECTION_ID_PIXEL_FORMATS] = { SECTION_ID_PIXEL_FORMATS, "pixel_formats", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PIXEL_FORMAT, -1 } },
313  [SECTION_ID_PIXEL_FORMAT] = { SECTION_ID_PIXEL_FORMAT, "pixel_format", 0, { SECTION_ID_PIXEL_FORMAT_FLAGS, SECTION_ID_PIXEL_FORMAT_COMPONENTS, -1 } },
314  [SECTION_ID_PIXEL_FORMAT_FLAGS] = { SECTION_ID_PIXEL_FORMAT_FLAGS, "flags", 0, { -1 }, .unique_name = "pixel_format_flags" },
315  [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" },
316  [SECTION_ID_PIXEL_FORMAT_COMPONENT] = { SECTION_ID_PIXEL_FORMAT_COMPONENT, "component", 0, { -1 } },
317  [SECTION_ID_PROGRAM_STREAM_DISPOSITION] = { SECTION_ID_PROGRAM_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "program_stream_disposition" },
318  [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" },
319  [SECTION_ID_PROGRAM] = { SECTION_ID_PROGRAM, "program", 0, { SECTION_ID_PROGRAM_TAGS, SECTION_ID_PROGRAM_STREAMS, -1 } },
320  [SECTION_ID_PROGRAM_STREAMS] = { SECTION_ID_PROGRAM_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM_STREAM, -1 }, .unique_name = "program_streams" },
321  [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" },
322  [SECTION_ID_PROGRAM_TAGS] = { SECTION_ID_PROGRAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_tags" },
323  [SECTION_ID_PROGRAM_VERSION] = { SECTION_ID_PROGRAM_VERSION, "program_version", 0, { -1 } },
324  [SECTION_ID_PROGRAMS] = { SECTION_ID_PROGRAMS, "programs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM, -1 } },
325  [SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION] = { SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_group_stream_disposition" },
326  [SECTION_ID_STREAM_GROUP_STREAM_TAGS] = { SECTION_ID_STREAM_GROUP_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_group_stream_tags" },
327  [SECTION_ID_STREAM_GROUP] = { SECTION_ID_STREAM_GROUP, "stream_group", 0, { SECTION_ID_STREAM_GROUP_TAGS, SECTION_ID_STREAM_GROUP_DISPOSITION, SECTION_ID_STREAM_GROUP_COMPONENTS, SECTION_ID_STREAM_GROUP_STREAMS, -1 } },
328  [SECTION_ID_STREAM_GROUP_COMPONENTS] = { SECTION_ID_STREAM_GROUP_COMPONENTS, "components", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_COMPONENT, -1 }, .element_name = "component", .unique_name = "stream_group_components" },
329  [SECTION_ID_STREAM_GROUP_COMPONENT] = { SECTION_ID_STREAM_GROUP_COMPONENT, "component", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_SUBCOMPONENTS, -1 }, .unique_name = "stream_group_component", .element_name = "component_entry", .get_type = get_stream_group_type },
330  [SECTION_ID_STREAM_GROUP_SUBCOMPONENTS] = { SECTION_ID_STREAM_GROUP_SUBCOMPONENTS, "subcomponents", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_SUBCOMPONENT, -1 }, .element_name = "component" },
331  [SECTION_ID_STREAM_GROUP_SUBCOMPONENT] = { SECTION_ID_STREAM_GROUP_SUBCOMPONENT, "subcomponent", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_PIECES, -1 }, .element_name = "subcomponent_entry", .get_type = get_raw_string_type },
332  [SECTION_ID_STREAM_GROUP_PIECES] = { SECTION_ID_STREAM_GROUP_PIECES, "pieces", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_PIECE, -1 }, .element_name = "piece", .unique_name = "stream_group_pieces" },
333  [SECTION_ID_STREAM_GROUP_PIECE] = { SECTION_ID_STREAM_GROUP_PIECE, "piece", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_SUBPIECES, -1 }, .unique_name = "stream_group_piece", .element_name = "piece_entry", .get_type = get_raw_string_type },
334  [SECTION_ID_STREAM_GROUP_SUBPIECES] = { SECTION_ID_STREAM_GROUP_SUBPIECES, "subpieces", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_SUBPIECE, -1 }, .element_name = "subpiece" },
335  [SECTION_ID_STREAM_GROUP_SUBPIECE] = { SECTION_ID_STREAM_GROUP_SUBPIECE, "subpiece", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_BLOCKS, -1 }, .element_name = "subpiece_entry", .get_type = get_raw_string_type },
336  [SECTION_ID_STREAM_GROUP_BLOCKS] = { SECTION_ID_STREAM_GROUP_BLOCKS, "blocks", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_BLOCK, -1 }, .element_name = "block" },
337  [SECTION_ID_STREAM_GROUP_BLOCK] = { SECTION_ID_STREAM_GROUP_BLOCK, "block", SECTION_FLAG_HAS_VARIABLE_FIELDS|SECTION_FLAG_HAS_TYPE, { -1 }, .element_name = "block_entry", .get_type = get_raw_string_type },
338  [SECTION_ID_STREAM_GROUP_STREAMS] = { SECTION_ID_STREAM_GROUP_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_STREAM, -1 }, .unique_name = "stream_group_streams" },
339  [SECTION_ID_STREAM_GROUP_STREAM] = { SECTION_ID_STREAM_GROUP_STREAM, "stream", 0, { SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION, SECTION_ID_STREAM_GROUP_STREAM_TAGS, -1 }, .unique_name = "stream_group_stream" },
340  [SECTION_ID_STREAM_GROUP_DISPOSITION] = { SECTION_ID_STREAM_GROUP_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_group_disposition" },
341  [SECTION_ID_STREAM_GROUP_TAGS] = { SECTION_ID_STREAM_GROUP_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_group_tags" },
342  [SECTION_ID_STREAM_GROUPS] = { SECTION_ID_STREAM_GROUPS, "stream_groups", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP, -1 } },
343  [SECTION_ID_ROOT] = { SECTION_ID_ROOT, "root", SECTION_FLAG_IS_WRAPPER,
344  { SECTION_ID_CHAPTERS, SECTION_ID_FORMAT, SECTION_ID_FRAMES, SECTION_ID_PROGRAMS, SECTION_ID_STREAM_GROUPS, SECTION_ID_STREAMS,
345  SECTION_ID_PACKETS, SECTION_ID_ERROR, SECTION_ID_PROGRAM_VERSION, SECTION_ID_LIBRARY_VERSIONS,
346  SECTION_ID_PIXEL_FORMATS, -1} },
347  [SECTION_ID_STREAMS] = { SECTION_ID_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM, -1 } },
348  [SECTION_ID_STREAM] = { SECTION_ID_STREAM, "stream", 0, { SECTION_ID_STREAM_DISPOSITION, SECTION_ID_STREAM_TAGS, SECTION_ID_STREAM_SIDE_DATA_LIST, -1 } },
349  [SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },
350  [SECTION_ID_STREAM_TAGS] = { SECTION_ID_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },
351  [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" },
352  [SECTION_ID_STREAM_SIDE_DATA] = { SECTION_ID_STREAM_SIDE_DATA, "side_data", SECTION_FLAG_HAS_TYPE|SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .unique_name = "stream_side_data", .element_name = "side_datum", .get_type = get_packet_side_data_type },
353  [SECTION_ID_SUBTITLE] = { SECTION_ID_SUBTITLE, "subtitle", 0, { -1 } },
354 };
355 
356 static const OptionDef *options;
357 
358 /* FFprobe context */
359 static const char *input_filename;
360 static const char *print_input_filename;
361 static const AVInputFormat *iformat = NULL;
362 static const char *output_filename = NULL;
363 
364 static struct AVHashContext *hash;
365 
366 static const struct {
367  double bin_val;
368  double dec_val;
369  const char *bin_str;
370  const char *dec_str;
371 } si_prefixes[] = {
372  { 1.0, 1.0, "", "" },
373  { 1.024e3, 1e3, "Ki", "K" },
374  { 1.048576e6, 1e6, "Mi", "M" },
375  { 1.073741824e9, 1e9, "Gi", "G" },
376  { 1.099511627776e12, 1e12, "Ti", "T" },
377  { 1.125899906842624e15, 1e15, "Pi", "P" },
378 };
379 
380 static const char unit_second_str[] = "s" ;
381 static const char unit_hertz_str[] = "Hz" ;
382 static const char unit_byte_str[] = "byte" ;
383 static const char unit_bit_per_second_str[] = "bit/s";
384 
385 static int nb_streams;
386 static uint64_t *nb_streams_packets;
387 static uint64_t *nb_streams_frames;
388 static int *selected_streams;
389 static int *streams_with_closed_captions;
390 static int *streams_with_film_grain;
391 
392 #if HAVE_THREADS
393 pthread_mutex_t log_mutex;
394 #endif
395 typedef struct LogBuffer {
396  char *context_name;
397  int log_level;
398  char *log_message;
399  AVClassCategory category;
400  char *parent_name;
401  AVClassCategory parent_category;
402 }LogBuffer;
403 
404 static LogBuffer *log_buffer;
405 static int log_buffer_size;
406 
407 static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
408 {
409  AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
410  va_list vl2;
411  char line[1024];
412  static int print_prefix = 1;
413  void *new_log_buffer;
414 
415  va_copy(vl2, vl);
416  av_log_default_callback(ptr, level, fmt, vl);
417  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
418  va_end(vl2);
419 
420 #if HAVE_THREADS
421  pthread_mutex_lock(&log_mutex);
422 
423  new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer));
424  if (new_log_buffer) {
425  char *msg;
426  int i;
427 
428  log_buffer = new_log_buffer;
429  memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size]));
430  log_buffer[log_buffer_size].context_name= avc ? av_strdup(avc->item_name(ptr)) : NULL;
431  if (avc) {
432  if (avc->get_category) log_buffer[log_buffer_size].category = avc->get_category(ptr);
433  else log_buffer[log_buffer_size].category = avc->category;
434  }
435  log_buffer[log_buffer_size].log_level = level;
436  msg = log_buffer[log_buffer_size].log_message = av_strdup(line);
437  for (i=strlen(msg) - 1; i>=0 && msg[i] == '\n'; i--) {
438  msg[i] = 0;
439  }
440  if (avc && avc->parent_log_context_offset) {
441  AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
442  avc->parent_log_context_offset);
443  if (parent && *parent) {
444  log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent));
445  log_buffer[log_buffer_size].parent_category =
446  (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category;
447  }
448  }
449  log_buffer_size ++;
450  }
451 
452  pthread_mutex_unlock(&log_mutex);
453 #endif
454 }
455 
456 struct unit_value {
457  union { double d; int64_t i; } val;
458  const char *unit;
459 };
460 
461 static char *value_string(char *buf, int buf_size, struct unit_value uv)
462 {
463  double vald;
464  int64_t vali;
465  int show_float = 0;
466 
467  if (uv.unit == unit_second_str) {
468  vald = uv.val.d;
469  show_float = 1;
470  } else {
471  vald = vali = uv.val.i;
472  }
473 
474  if (uv.unit == unit_second_str && use_value_sexagesimal_format) {
475  double secs;
476  int hours, mins;
477  secs = vald;
478  mins = (int)secs / 60;
479  secs = secs - mins * 60;
480  hours = mins / 60;
481  mins %= 60;
482  snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
483  } else {
484  const char *prefix_string = "";
485 
486  if (use_value_prefix && vald > 1) {
487  int64_t index;
488 
489  if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
490  index = (int64_t) (log2(vald)) / 10;
491  index = av_clip(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
492  vald /= si_prefixes[index].bin_val;
493  prefix_string = si_prefixes[index].bin_str;
494  } else {
495  index = (int64_t) (log10(vald)) / 3;
496  index = av_clip(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
497  vald /= si_prefixes[index].dec_val;
498  prefix_string = si_prefixes[index].dec_str;
499  }
500  vali = vald;
501  }
502 
503  if (show_float || (use_value_prefix && vald != (int64_t)vald))
504  snprintf(buf, buf_size, "%f", vald);
505  else
506  snprintf(buf, buf_size, "%"PRId64, vali);
507  av_strlcatf(buf, buf_size, "%s%s%s", *prefix_string || show_value_unit ? " " : "",
508  prefix_string, show_value_unit ? uv.unit : "");
509  }
510 
511  return buf;
512 }
513 
514 /* WRITERS API */
515 
516 typedef struct WriterContext WriterContext;
517 
518 #define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1
519 #define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2
520 
521 typedef enum {
522  WRITER_STRING_VALIDATION_FAIL,
523  WRITER_STRING_VALIDATION_REPLACE,
524  WRITER_STRING_VALIDATION_IGNORE,
525  WRITER_STRING_VALIDATION_NB
526 } StringValidation;
527 
528 typedef struct Writer {
529  const AVClass *priv_class; ///< private class of the writer, if any
530  int priv_size; ///< private size for the writer context
531  const char *name;
532 
533  int (*init) (WriterContext *wctx);
534  void (*uninit)(WriterContext *wctx);
535 
536  void (*print_section_header)(WriterContext *wctx, const void *data);
537  void (*print_section_footer)(WriterContext *wctx);
538  void (*print_integer) (WriterContext *wctx, const char *, int64_t);
539  void (*print_rational) (WriterContext *wctx, AVRational *q, char *sep);
540  void (*print_string) (WriterContext *wctx, const char *, const char *);
541  int flags; ///< a combination or WRITER_FLAG_*
542 } Writer;
543 
544 #define SECTION_MAX_NB_LEVELS 12
545 
546 struct WriterContext {
547  const AVClass *class; ///< class of the writer
548  const Writer *writer; ///< the Writer of which this is an instance
549  AVIOContext *avio; ///< the I/O context used to write
550 
551  void (* writer_w8)(WriterContext *wctx, int b);
552  void (* writer_put_str)(WriterContext *wctx, const char *str);
553  void (* writer_printf)(WriterContext *wctx, const char *fmt, ...);
554 
555  char *name; ///< name of this writer instance
556  void *priv; ///< private data for use by the filter
557 
558  const struct section *sections; ///< array containing all sections
559  int nb_sections; ///< number of sections
560 
561  int level; ///< current level, starting from 0
562 
563  /** number of the item printed in the given section, starting from 0 */
564  unsigned int nb_item[SECTION_MAX_NB_LEVELS];
565 
566  /** section per each level */
567  const struct section *section[SECTION_MAX_NB_LEVELS];
568  AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]; ///< generic print buffer dedicated to each section,
569  /// used by various writers
570 
571  unsigned int nb_section_packet; ///< number of the packet section in case we are in "packets_and_frames" section
572  unsigned int nb_section_frame; ///< number of the frame section in case we are in "packets_and_frames" section
573  unsigned int nb_section_packet_frame; ///< nb_section_packet or nb_section_frame according if is_packets_and_frames
574 
575  int string_validation;
576  char *string_validation_replacement;
577  unsigned int string_validation_utf8_flags;
578 };
579 
580 static const char *writer_get_name(void *p)
581 {
582  WriterContext *wctx = p;
583  return wctx->writer->name;
584 }
585 
586 #define OFFSET(x) offsetof(WriterContext, x)
587 
588 static const AVOption writer_options[] = {
589  { "string_validation", "set string validation mode",
590  OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
591  { "sv", "set string validation mode",
592  OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
593  { "ignore", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_IGNORE}, .unit = "sv" },
594  { "replace", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_REPLACE}, .unit = "sv" },
595  { "fail", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_FAIL}, .unit = "sv" },
596  { "string_validation_replacement", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str=""}},
597  { "svr", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str="\xEF\xBF\xBD"}},
598  { NULL }
599 };
600 
601 static void *writer_child_next(void *obj, void *prev)
602 {
603  WriterContext *ctx = obj;
604  if (!prev && ctx->writer && ctx->writer->priv_class && ctx->priv)
605  return ctx->priv;
606  return NULL;
607 }
608 
609 static const AVClass writer_class = {
610  .class_name = "Writer",
611  .item_name = writer_get_name,
612  .option = writer_options,
613  .version = LIBAVUTIL_VERSION_INT,
614  .child_next = writer_child_next,
615 };
616 
617 static int writer_close(WriterContext **wctx)
618 {
619  int i;
620  int ret = 0;
621 
622  if (!*wctx)
623  return -1;
624 
625  if ((*wctx)->writer->uninit)
626  (*wctx)->writer->uninit(*wctx);
627  for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
628  av_bprint_finalize(&(*wctx)->section_pbuf[i], NULL);
629  if ((*wctx)->writer->priv_class)
630  av_opt_free((*wctx)->priv);
631  av_freep(&((*wctx)->priv));
632  av_opt_free(*wctx);
633  if ((*wctx)->avio) {
634  avio_flush((*wctx)->avio);
635  ret = avio_close((*wctx)->avio);
636  }
637  av_freep(wctx);
638  return ret;
639 }
640 
641 static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
642 {
643  int i;
644  av_bprintf(bp, "0X");
645  for (i = 0; i < ubuf_size; i++)
646  av_bprintf(bp, "%02X", ubuf[i]);
647 }
648 
649 static inline void writer_w8_avio(WriterContext *wctx, int b)
650 {
651  avio_w8(wctx->avio, b);
652 }
653 
654 static inline void writer_put_str_avio(WriterContext *wctx, const char *str)
655 {
656  avio_write(wctx->avio, str, strlen(str));
657 }
658 
659 static inline void writer_printf_avio(WriterContext *wctx, const char *fmt, ...)
660 {
661  va_list ap;
662 
663  va_start(ap, fmt);
664  avio_vprintf(wctx->avio, fmt, ap);
665  va_end(ap);
666 }
667 
668 static inline void writer_w8_printf(WriterContext *wctx, int b)
669 {
670  printf("%c", b);
671 }
672 
673 static inline void writer_put_str_printf(WriterContext *wctx, const char *str)
674 {
675  printf("%s", str);
676 }
677 
678 static inline void writer_printf_printf(WriterContext *wctx, const char *fmt, ...)
679 {
680  va_list ap;
681 
682  va_start(ap, fmt);
683  vprintf(fmt, ap);
684  va_end(ap);
685 }
686 
687 static int writer_open(WriterContext **wctx, const Writer *writer, const char *args,
688  const struct section *sections, int nb_sections, const char *output)
689 {
690  int i, ret = 0;
691 
692  if (!(*wctx = av_mallocz(sizeof(WriterContext)))) {
693  ret = AVERROR(ENOMEM);
694  goto fail;
695  }
696 
697  if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
698  ret = AVERROR(ENOMEM);
699  goto fail;
700  }
701 
702  (*wctx)->class = &writer_class;
703  (*wctx)->writer = writer;
704  (*wctx)->level = -1;
705  (*wctx)->sections = sections;
706  (*wctx)->nb_sections = nb_sections;
707 
708  av_opt_set_defaults(*wctx);
709 
710  if (writer->priv_class) {
711  void *priv_ctx = (*wctx)->priv;
712  *((const AVClass **)priv_ctx) = writer->priv_class;
713  av_opt_set_defaults(priv_ctx);
714  }
715 
716  /* convert options to dictionary */
717  if (args) {
718  AVDictionary *opts = NULL;
719  const AVDictionaryEntry *opt = NULL;
720 
721  if ((ret = av_dict_parse_string(&opts, args, "=", ":", 0)) < 0) {
722  av_log(*wctx, AV_LOG_ERROR, "Failed to parse option string '%s' provided to writer context\n", args);
723  av_dict_free(&opts);
724  goto fail;
725  }
726 
727  while ((opt = av_dict_iterate(opts, opt))) {
728  if ((ret = av_opt_set(*wctx, opt->key, opt->value, AV_OPT_SEARCH_CHILDREN)) < 0) {
729  av_log(*wctx, AV_LOG_ERROR, "Failed to set option '%s' with value '%s' provided to writer context\n",
730  opt->key, opt->value);
731  av_dict_free(&opts);
732  goto fail;
733  }
734  }
735 
736  av_dict_free(&opts);
737  }
738 
739  /* validate replace string */
740  {
741  const uint8_t *p = (*wctx)->string_validation_replacement;
742  const uint8_t *endp = p + strlen(p);
743  while (*p) {
744  const uint8_t *p0 = p;
745  int32_t code;
746  ret = av_utf8_decode(&code, &p, endp, (*wctx)->string_validation_utf8_flags);
747  if (ret < 0) {
748  AVBPrint bp;
749  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
750  bprint_bytes(&bp, p0, p-p0),
751  av_log(wctx, AV_LOG_ERROR,
752  "Invalid UTF8 sequence %s found in string validation replace '%s'\n",
753  bp.str, (*wctx)->string_validation_replacement);
754  return ret;
755  }
756  }
757  }
758 
759  if (!output_filename) {
760  (*wctx)->writer_w8 = writer_w8_printf;
761  (*wctx)->writer_put_str = writer_put_str_printf;
762  (*wctx)->writer_printf = writer_printf_printf;
763  } else {
764  if ((ret = avio_open(&(*wctx)->avio, output, AVIO_FLAG_WRITE)) < 0) {
765  av_log(*wctx, AV_LOG_ERROR,
766  "Failed to open output '%s' with error: %s\n", output, av_err2str(ret));
767  goto fail;
768  }
769  (*wctx)->writer_w8 = writer_w8_avio;
770  (*wctx)->writer_put_str = writer_put_str_avio;
771  (*wctx)->writer_printf = writer_printf_avio;
772  }
773 
774  for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
775  av_bprint_init(&(*wctx)->section_pbuf[i], 1, AV_BPRINT_SIZE_UNLIMITED);
776 
777  if ((*wctx)->writer->init)
778  ret = (*wctx)->writer->init(*wctx);
779  if (ret < 0)
780  goto fail;
781 
782  return 0;
783 
784 fail:
785  writer_close(wctx);
786  return ret;
787 }
788 
789 static inline void writer_print_section_header(WriterContext *wctx,
790  const void *data,
791  int section_id)
792 {
793  int parent_section_id;
794  wctx->level++;
795  av_assert0(wctx->level < SECTION_MAX_NB_LEVELS);
796  parent_section_id = wctx->level ?
797  (wctx->section[wctx->level-1])->id : SECTION_ID_NONE;
798 
799  wctx->nb_item[wctx->level] = 0;
800  wctx->section[wctx->level] = &wctx->sections[section_id];
801 
802  if (section_id == SECTION_ID_PACKETS_AND_FRAMES) {
803  wctx->nb_section_packet = wctx->nb_section_frame =
804  wctx->nb_section_packet_frame = 0;
805  } else if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
806  wctx->nb_section_packet_frame = section_id == SECTION_ID_PACKET ?
807  wctx->nb_section_packet : wctx->nb_section_frame;
808  }
809 
810  if (wctx->writer->print_section_header)
811  wctx->writer->print_section_header(wctx, data);
812 }
813 
814 static inline void writer_print_section_footer(WriterContext *wctx)
815 {
816  int section_id = wctx->section[wctx->level]->id;
817  int parent_section_id = wctx->level ?
818  wctx->section[wctx->level-1]->id : SECTION_ID_NONE;
819 
820  if (parent_section_id != SECTION_ID_NONE)
821  wctx->nb_item[wctx->level-1]++;
822  if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
823  if (section_id == SECTION_ID_PACKET) wctx->nb_section_packet++;
824  else wctx->nb_section_frame++;
825  }
826  if (wctx->writer->print_section_footer)
827  wctx->writer->print_section_footer(wctx);
828  wctx->level--;
829 }
830 
831 static inline void writer_print_integer(WriterContext *wctx,
832  const char *key, int64_t val)
833 {
834  const struct section *section = wctx->section[wctx->level];
835 
836  if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {
837  wctx->writer->print_integer(wctx, key, val);
838  wctx->nb_item[wctx->level]++;
839  }
840 }
841 
842 static inline int validate_string(WriterContext *wctx, char **dstp, const char *src)
843 {
844  const uint8_t *p, *endp;
845  AVBPrint dstbuf;
846  int invalid_chars_nb = 0, ret = 0;
847 
848  av_bprint_init(&dstbuf, 0, AV_BPRINT_SIZE_UNLIMITED);
849 
850  endp = src + strlen(src);
851  for (p = src; *p;) {
852  uint32_t code;
853  int invalid = 0;
854  const uint8_t *p0 = p;
855 
856  if (av_utf8_decode(&code, &p, endp, wctx->string_validation_utf8_flags) < 0) {
857  AVBPrint bp;
858  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
859  bprint_bytes(&bp, p0, p-p0);
860  av_log(wctx, AV_LOG_DEBUG,
861  "Invalid UTF-8 sequence %s found in string '%s'\n", bp.str, src);
862  invalid = 1;
863  }
864 
865  if (invalid) {
866  invalid_chars_nb++;
867 
868  switch (wctx->string_validation) {
869  case WRITER_STRING_VALIDATION_FAIL:
870  av_log(wctx, AV_LOG_ERROR,
871  "Invalid UTF-8 sequence found in string '%s'\n", src);
872  ret = AVERROR_INVALIDDATA;
873  goto end;
874  break;
875 
876  case WRITER_STRING_VALIDATION_REPLACE:
877  av_bprintf(&dstbuf, "%s", wctx->string_validation_replacement);
878  break;
879  }
880  }
881 
882  if (!invalid || wctx->string_validation == WRITER_STRING_VALIDATION_IGNORE)
883  av_bprint_append_data(&dstbuf, p0, p-p0);
884  }
885 
886  if (invalid_chars_nb && wctx->string_validation == WRITER_STRING_VALIDATION_REPLACE) {
887  av_log(wctx, AV_LOG_WARNING,
888  "%d invalid UTF-8 sequence(s) found in string '%s', replaced with '%s'\n",
889  invalid_chars_nb, src, wctx->string_validation_replacement);
890  }
891 
892 end:
893  av_bprint_finalize(&dstbuf, dstp);
894  return ret;
895 }
896 
897 #define PRINT_STRING_OPT 1
898 #define PRINT_STRING_VALIDATE 2
899 
900 static inline int writer_print_string(WriterContext *wctx,
901  const char *key, const char *val, int flags)
902 {
903  const struct section *section = wctx->section[wctx->level];
904  int ret = 0;
905 
906  if (show_optional_fields == SHOW_OPTIONAL_FIELDS_NEVER ||
907  (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO
908  && (flags & PRINT_STRING_OPT)
909  && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS)))
910  return 0;
911 
912  if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {
913  if (flags & PRINT_STRING_VALIDATE) {
914  char *key1 = NULL, *val1 = NULL;
915  ret = validate_string(wctx, &key1, key);
916  if (ret < 0) goto end;
917  ret = validate_string(wctx, &val1, val);
918  if (ret < 0) goto end;
919  wctx->writer->print_string(wctx, key1, val1);
920  end:
921  if (ret < 0) {
922  av_log(wctx, AV_LOG_ERROR,
923  "Invalid key=value string combination %s=%s in section %s\n",
924  key, val, section->unique_name);
925  }
926  av_free(key1);
927  av_free(val1);
928  } else {
929  wctx->writer->print_string(wctx, key, val);
930  }
931 
932  wctx->nb_item[wctx->level]++;
933  }
934 
935  return ret;
936 }
937 
938 static inline void writer_print_rational(WriterContext *wctx,
939  const char *key, AVRational q, char sep)
940 {
941  AVBPrint buf;
942  av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
943  av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);
944  writer_print_string(wctx, key, buf.str, 0);
945 }
946 
947 static void writer_print_time(WriterContext *wctx, const char *key,
948  int64_t ts, const AVRational *time_base, int is_duration)
949 {
950  char buf[128];
951 
952  if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
953  writer_print_string(wctx, key, "N/A", PRINT_STRING_OPT);
954  } else {
955  double d = ts * av_q2d(*time_base);
956  struct unit_value uv;
957  uv.val.d = d;
958  uv.unit = unit_second_str;
959  value_string(buf, sizeof(buf), uv);
960  writer_print_string(wctx, key, buf, 0);
961  }
962 }
963 
964 static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
965 {
966  if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
967  writer_print_string(wctx, key, "N/A", PRINT_STRING_OPT);
968  } else {
969  writer_print_integer(wctx, key, ts);
970  }
971 }
972 
973 static void writer_print_data(WriterContext *wctx, const char *name,
974  const uint8_t *data, int size)
975 {
976  AVBPrint bp;
977  int offset = 0, l, i;
978 
979  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
980  av_bprintf(&bp, "\n");
981  while (size) {
982  av_bprintf(&bp, "%08x: ", offset);
983  l = FFMIN(size, 16);
984  for (i = 0; i < l; i++) {
985  av_bprintf(&bp, "%02x", data[i]);
986  if (i & 1)
987  av_bprintf(&bp, " ");
988  }
989  av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);
990  for (i = 0; i < l; i++)
991  av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);
992  av_bprintf(&bp, "\n");
993  offset += l;
994  data += l;
995  size -= l;
996  }
997  writer_print_string(wctx, name, bp.str, 0);
998  av_bprint_finalize(&bp, NULL);
999 }
1000 
1001 static void writer_print_data_hash(WriterContext *wctx, const char *name,
1002  const uint8_t *data, int size)
1003 {
1004  char *p, buf[AV_HASH_MAX_SIZE * 2 + 64] = { 0 };
1005 
1006  if (!hash)
1007  return;
1008  av_hash_init(hash);
1009  av_hash_update(hash, data, size);
1010  snprintf(buf, sizeof(buf), "%s:", av_hash_get_name(hash));
1011  p = buf + strlen(buf);
1012  av_hash_final_hex(hash, p, buf + sizeof(buf) - p);
1013  writer_print_string(wctx, name, buf, 0);
1014 }
1015 
1016 static void writer_print_integers(WriterContext *wctx, const char *name,
1017  uint8_t *data, int size, const char *format,
1018  int columns, int bytes, int offset_add)
1019 {
1020  AVBPrint bp;
1021  int offset = 0, l, i;
1022 
1023  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
1024  av_bprintf(&bp, "\n");
1025  while (size) {
1026  av_bprintf(&bp, "%08x: ", offset);
1027  l = FFMIN(size, columns);
1028  for (i = 0; i < l; i++) {
1029  if (bytes == 1) av_bprintf(&bp, format, *data);
1030  else if (bytes == 2) av_bprintf(&bp, format, AV_RN16(data));
1031  else if (bytes == 4) av_bprintf(&bp, format, AV_RN32(data));
1032  data += bytes;
1033  size --;
1034  }
1035  av_bprintf(&bp, "\n");
1036  offset += offset_add;
1037  }
1038  writer_print_string(wctx, name, bp.str, 0);
1039  av_bprint_finalize(&bp, NULL);
1040 }
1041 
1042 #define writer_w8(wctx_, b_) (wctx_)->writer_w8(wctx_, b_)
1043 #define writer_put_str(wctx_, str_) (wctx_)->writer_put_str(wctx_, str_)
1044 #define writer_printf(wctx_, fmt_, ...) (wctx_)->writer_printf(wctx_, fmt_, __VA_ARGS__)
1045 
1046 #define MAX_REGISTERED_WRITERS_NB 64
1047 
1048 static const Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];
1049 
1050 static int writer_register(const Writer *writer)
1051 {
1052  static int next_registered_writer_idx = 0;
1053 
1054  if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)
1055  return AVERROR(ENOMEM);
1056 
1057  registered_writers[next_registered_writer_idx++] = writer;
1058  return 0;
1059 }
1060 
1061 static const Writer *writer_get_by_name(const char *name)
1062 {
1063  int i;
1064 
1065  for (i = 0; registered_writers[i]; i++)
1066  if (!strcmp(registered_writers[i]->name, name))
1067  return registered_writers[i];
1068 
1069  return NULL;
1070 }
1071 
1072 
1073 /* WRITERS */
1074 
1075 #define DEFINE_WRITER_CLASS(name) \
1076 static const char *name##_get_name(void *ctx) \
1077 { \
1078  return #name ; \
1079 } \
1080 static const AVClass name##_class = { \
1081  .class_name = #name, \
1082  .item_name = name##_get_name, \
1083  .option = name##_options \
1084 }
1085 
1086 /* Default output */
1087 
1088 typedef struct DefaultContext {
1089  const AVClass *class;
1090  int nokey;
1091  int noprint_wrappers;
1092  int nested_section[SECTION_MAX_NB_LEVELS];
1093 } DefaultContext;
1094 
1095 #undef OFFSET
1096 #define OFFSET(x) offsetof(DefaultContext, x)
1097 
1098 static const AVOption default_options[] = {
1099  { "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1100  { "nw", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1101  { "nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1102  { "nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1103  {NULL},
1104 };
1105 
1106 DEFINE_WRITER_CLASS(default);
1107 
1108 /* lame uppercasing routine, assumes the string is lower case ASCII */
1109 static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
1110 {
1111  int i;
1112  for (i = 0; src[i] && i < dst_size-1; i++)
1113  dst[i] = av_toupper(src[i]);
1114  dst[i] = 0;
1115  return dst;
1116 }
1117 
1118 static void default_print_section_header(WriterContext *wctx, const void *data)
1119 {
1120  DefaultContext *def = wctx->priv;
1121  char buf[32];
1122  const struct section *section = wctx->section[wctx->level];
1123  const struct section *parent_section = wctx->level ?
1124  wctx->section[wctx->level-1] : NULL;
1125 
1126  av_bprint_clear(&wctx->section_pbuf[wctx->level]);
1127  if (parent_section &&
1128  !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
1129  def->nested_section[wctx->level] = 1;
1130  av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
1131  wctx->section_pbuf[wctx->level-1].str,
1132  upcase_string(buf, sizeof(buf),
1133  av_x_if_null(section->element_name, section->name)));
1134  }
1135 
1136  if (def->noprint_wrappers || def->nested_section[wctx->level])
1137  return;
1138 
1139  if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
1140  writer_printf(wctx, "[%s]\n", upcase_string(buf, sizeof(buf), section->name));
1141 }
1142 
1143 static void default_print_section_footer(WriterContext *wctx)
1144 {
1145  DefaultContext *def = wctx->priv;
1146  const struct section *section = wctx->section[wctx->level];
1147  char buf[32];
1148 
1149  if (def->noprint_wrappers || def->nested_section[wctx->level])
1150  return;
1151 
1152  if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
1153  writer_printf(wctx, "[/%s]\n", upcase_string(buf, sizeof(buf), section->name));
1154 }
1155 
1156 static void default_print_str(WriterContext *wctx, const char *key, const char *value)
1157 {
1158  DefaultContext *def = wctx->priv;
1159 
1160  if (!def->nokey)
1161  writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
1162  writer_printf(wctx, "%s\n", value);
1163 }
1164 
1165 static void default_print_int(WriterContext *wctx, const char *key, int64_t value)
1166 {
1167  DefaultContext *def = wctx->priv;
1168 
1169  if (!def->nokey)
1170  writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
1171  writer_printf(wctx, "%"PRId64"\n", value);
1172 }
1173 
1174 static const Writer default_writer = {
1175  .name = "default",
1176  .priv_size = sizeof(DefaultContext),
1177  .print_section_header = default_print_section_header,
1178  .print_section_footer = default_print_section_footer,
1179  .print_integer = default_print_int,
1180  .print_string = default_print_str,
1181  .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
1182  .priv_class = &default_class,
1183 };
1184 
1185 /* Compact output */
1186 
1187 /**
1188  * Apply C-language-like string escaping.
1189  */
1190 static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1191 {
1192  const char *p;
1193 
1194  for (p = src; *p; p++) {
1195  switch (*p) {
1196  case '\b': av_bprintf(dst, "%s", "\\b"); break;
1197  case '\f': av_bprintf(dst, "%s", "\\f"); break;
1198  case '\n': av_bprintf(dst, "%s", "\\n"); break;
1199  case '\r': av_bprintf(dst, "%s", "\\r"); break;
1200  case '\\': av_bprintf(dst, "%s", "\\\\"); break;
1201  default:
1202  if (*p == sep)
1203  av_bprint_chars(dst, '\\', 1);
1204  av_bprint_chars(dst, *p, 1);
1205  }
1206  }
1207  return dst->str;
1208 }
1209 
1210 /**
1211  * Quote fields containing special characters, check RFC4180.
1212  */
1213 static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1214 {
1215  char meta_chars[] = { sep, '"', '\n', '\r', '\0' };
1216  int needs_quoting = !!src[strcspn(src, meta_chars)];
1217 
1218  if (needs_quoting)
1219  av_bprint_chars(dst, '"', 1);
1220 
1221  for (; *src; src++) {
1222  if (*src == '"')
1223  av_bprint_chars(dst, '"', 1);
1224  av_bprint_chars(dst, *src, 1);
1225  }
1226  if (needs_quoting)
1227  av_bprint_chars(dst, '"', 1);
1228  return dst->str;
1229 }
1230 
1231 static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1232 {
1233  return src;
1234 }
1235 
1236 typedef struct CompactContext {
1237  const AVClass *class;
1238  char *item_sep_str;
1239  char item_sep;
1240  int nokey;
1241  int print_section;
1242  char *escape_mode_str;
1243  const char * (*escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx);
1244  int nested_section[SECTION_MAX_NB_LEVELS];
1245  int has_nested_elems[SECTION_MAX_NB_LEVELS];
1246  int terminate_line[SECTION_MAX_NB_LEVELS];
1247 } CompactContext;
1248 
1249 #undef OFFSET
1250 #define OFFSET(x) offsetof(CompactContext, x)
1251 
1252 static const AVOption compact_options[]= {
1253  {"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, 0, 0 },
1254  {"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, 0, 0 },
1255  {"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1256  {"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1257  {"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, 0, 0 },
1258  {"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, 0, 0 },
1259  {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1260  {"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1261  {NULL},
1262 };
1263 
1264 DEFINE_WRITER_CLASS(compact);
1265 
1266 static av_cold int compact_init(WriterContext *wctx)
1267 {
1268  CompactContext *compact = wctx->priv;
1269 
1270  if (strlen(compact->item_sep_str) != 1) {
1271  av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
1272  compact->item_sep_str);
1273  return AVERROR(EINVAL);
1274  }
1275  compact->item_sep = compact->item_sep_str[0];
1276 
1277  if (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;
1278  else if (!strcmp(compact->escape_mode_str, "c" )) compact->escape_str = c_escape_str;
1279  else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;
1280  else {
1281  av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);
1282  return AVERROR(EINVAL);
1283  }
1284 
1285  return 0;
1286 }
1287 
1288 static void compact_print_section_header(WriterContext *wctx, const void *data)
1289 {
1290  CompactContext *compact = wctx->priv;
1291  const struct section *section = wctx->section[wctx->level];
1292  const struct section *parent_section = wctx->level ?
1293  wctx->section[wctx->level-1] : NULL;
1294  compact->terminate_line[wctx->level] = 1;
1295  compact->has_nested_elems[wctx->level] = 0;
1296 
1297  av_bprint_clear(&wctx->section_pbuf[wctx->level]);
1298  if (parent_section &&
1299  (section->flags & SECTION_FLAG_HAS_TYPE ||
1300  (!(section->flags & SECTION_FLAG_IS_ARRAY) &&
1301  !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))))) {
1302 
1303  /* define a prefix for elements not contained in an array or
1304  in a wrapper, or for array elements with a type */
1305  const char *element_name = (char *)av_x_if_null(section->element_name, section->name);
1306  AVBPrint *section_pbuf = &wctx->section_pbuf[wctx->level];
1307 
1308  compact->nested_section[wctx->level] = 1;
1309  compact->has_nested_elems[wctx->level-1] = 1;
1310 
1311  av_bprintf(section_pbuf, "%s%s",
1312  wctx->section_pbuf[wctx->level-1].str, element_name);
1313 
1314  if (section->flags & SECTION_FLAG_HAS_TYPE) {
1315  // add /TYPE to prefix
1316  av_bprint_chars(section_pbuf, '/', 1);
1317 
1318  // normalize section type, replace special characters and lower case
1319  for (const char *p = section->get_type(data); *p; p++) {
1320  char c =
1321  (*p >= '0' && *p <= '9') ||
1322  (*p >= 'a' && *p <= 'z') ||
1323  (*p >= 'A' && *p <= 'Z') ? av_tolower(*p) : '_';
1324  av_bprint_chars(section_pbuf, c, 1);
1325  }
1326  }
1327  av_bprint_chars(section_pbuf, ':', 1);
1328 
1329  wctx->nb_item[wctx->level] = wctx->nb_item[wctx->level-1];
1330  } else {
1331  if (parent_section && !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)) &&
1332  wctx->level && wctx->nb_item[wctx->level-1])
1333  writer_w8(wctx, compact->item_sep);
1334  if (compact->print_section &&
1335  !(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
1336  writer_printf(wctx, "%s%c", section->name, compact->item_sep);
1337  }
1338 }
1339 
1340 static void compact_print_section_footer(WriterContext *wctx)
1341 {
1342  CompactContext *compact = wctx->priv;
1343 
1344  if (!compact->nested_section[wctx->level] &&
1345  compact->terminate_line[wctx->level] &&
1346  !(wctx->section[wctx->level]->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
1347  writer_w8(wctx, '\n');
1348 }
1349 
1350 static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
1351 {
1352  CompactContext *compact = wctx->priv;
1353  AVBPrint buf;
1354 
1355  if (wctx->nb_item[wctx->level]) writer_w8(wctx, compact->item_sep);
1356  if (!compact->nokey)
1357  writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
1358  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1359  writer_put_str(wctx, compact->escape_str(&buf, value, compact->item_sep, wctx));
1360  av_bprint_finalize(&buf, NULL);
1361 }
1362 
1363 static void compact_print_int(WriterContext *wctx, const char *key, int64_t value)
1364 {
1365  CompactContext *compact = wctx->priv;
1366 
1367  if (wctx->nb_item[wctx->level]) writer_w8(wctx, compact->item_sep);
1368  if (!compact->nokey)
1369  writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
1370  writer_printf(wctx, "%"PRId64, value);
1371 }
1372 
1373 static const Writer compact_writer = {
1374  .name = "compact",
1375  .priv_size = sizeof(CompactContext),
1376  .init = compact_init,
1377  .print_section_header = compact_print_section_header,
1378  .print_section_footer = compact_print_section_footer,
1379  .print_integer = compact_print_int,
1380  .print_string = compact_print_str,
1381  .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
1382  .priv_class = &compact_class,
1383 };
1384 
1385 /* CSV output */
1386 
1387 #undef OFFSET
1388 #define OFFSET(x) offsetof(CompactContext, x)
1389 
1390 static const AVOption csv_options[] = {
1391  {"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, 0, 0 },
1392  {"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, 0, 0 },
1393  {"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1394  {"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1395  {"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, 0, 0 },
1396  {"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, 0, 0 },
1397  {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1398  {"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1399  {NULL},
1400 };
1401 
1402 DEFINE_WRITER_CLASS(csv);
1403 
1404 static const Writer csv_writer = {
1405  .name = "csv",
1406  .priv_size = sizeof(CompactContext),
1407  .init = compact_init,
1408  .print_section_header = compact_print_section_header,
1409  .print_section_footer = compact_print_section_footer,
1410  .print_integer = compact_print_int,
1411  .print_string = compact_print_str,
1412  .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
1413  .priv_class = &csv_class,
1414 };
1415 
1416 /* Flat output */
1417 
1418 typedef struct FlatContext {
1419  const AVClass *class;
1420  const char *sep_str;
1421  char sep;
1422  int hierarchical;
1423 } FlatContext;
1424 
1425 #undef OFFSET
1426 #define OFFSET(x) offsetof(FlatContext, x)
1427 
1428 static const AVOption flat_options[]= {
1429  {"sep_char", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, 0, 0 },
1430  {"s", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, 0, 0 },
1431  {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1432  {"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1433  {NULL},
1434 };
1435 
1436 DEFINE_WRITER_CLASS(flat);
1437 
1438 static av_cold int flat_init(WriterContext *wctx)
1439 {
1440  FlatContext *flat = wctx->priv;
1441 
1442  if (strlen(flat->sep_str) != 1) {
1443  av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
1444  flat->sep_str);
1445  return AVERROR(EINVAL);
1446  }
1447  flat->sep = flat->sep_str[0];
1448 
1449  return 0;
1450 }
1451 
1452 static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
1453 {
1454  const char *p;
1455 
1456  for (p = src; *p; p++) {
1457  if (!((*p >= '0' && *p <= '9') ||
1458  (*p >= 'a' && *p <= 'z') ||
1459  (*p >= 'A' && *p <= 'Z')))
1460  av_bprint_chars(dst, '_', 1);
1461  else
1462  av_bprint_chars(dst, *p, 1);
1463  }
1464  return dst->str;
1465 }
1466 
1467 static const char *flat_escape_value_str(AVBPrint *dst, const char *src)
1468 {
1469  const char *p;
1470 
1471  for (p = src; *p; p++) {
1472  switch (*p) {
1473  case '\n': av_bprintf(dst, "%s", "\\n"); break;
1474  case '\r': av_bprintf(dst, "%s", "\\r"); break;
1475  case '\\': av_bprintf(dst, "%s", "\\\\"); break;
1476  case '"': av_bprintf(dst, "%s", "\\\""); break;
1477  case '`': av_bprintf(dst, "%s", "\\`"); break;
1478  case '$': av_bprintf(dst, "%s", "\\$"); break;
1479  default: av_bprint_chars(dst, *p, 1); break;
1480  }
1481  }
1482  return dst->str;
1483 }
1484 
1485 static void flat_print_section_header(WriterContext *wctx, const void *data)
1486 {
1487  FlatContext *flat = wctx->priv;
1488  AVBPrint *buf = &wctx->section_pbuf[wctx->level];
1489  const struct section *section = wctx->section[wctx->level];
1490  const struct section *parent_section = wctx->level ?
1491  wctx->section[wctx->level-1] : NULL;
1492 
1493  /* build section header */
1494  av_bprint_clear(buf);
1495  if (!parent_section)
1496  return;
1497  av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
1498 
1499  if (flat->hierarchical ||
1500  !(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {
1501  av_bprintf(buf, "%s%s", wctx->section[wctx->level]->name, flat->sep_str);
1502 
1503  if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
1504  int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
1505  wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
1506  av_bprintf(buf, "%d%s", n, flat->sep_str);
1507  }
1508  }
1509 }
1510 
1511 static void flat_print_int(WriterContext *wctx, const char *key, int64_t value)
1512 {
1513  writer_printf(wctx, "%s%s=%"PRId64"\n", wctx->section_pbuf[wctx->level].str, key, value);
1514 }
1515 
1516 static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
1517 {
1518  FlatContext *flat = wctx->priv;
1519  AVBPrint buf;
1520 
1521  writer_put_str(wctx, wctx->section_pbuf[wctx->level].str);
1522  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1523  writer_printf(wctx, "%s=", flat_escape_key_str(&buf, key, flat->sep));
1524  av_bprint_clear(&buf);
1525  writer_printf(wctx, "\"%s\"\n", flat_escape_value_str(&buf, value));
1526  av_bprint_finalize(&buf, NULL);
1527 }
1528 
1529 static const Writer flat_writer = {
1530  .name = "flat",
1531  .priv_size = sizeof(FlatContext),
1532  .init = flat_init,
1533  .print_section_header = flat_print_section_header,
1534  .print_integer = flat_print_int,
1535  .print_string = flat_print_str,
1536  .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1537  .priv_class = &flat_class,
1538 };
1539 
1540 /* INI format output */
1541 
1542 typedef struct INIContext {
1543  const AVClass *class;
1544  int hierarchical;
1545 } INIContext;
1546 
1547 #undef OFFSET
1548 #define OFFSET(x) offsetof(INIContext, x)
1549 
1550 static const AVOption ini_options[] = {
1551  {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1552  {"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1553  {NULL},
1554 };
1555 
1556 DEFINE_WRITER_CLASS(ini);
1557 
1558 static char *ini_escape_str(AVBPrint *dst, const char *src)
1559 {
1560  int i = 0;
1561  char c = 0;
1562 
1563  while (c = src[i++]) {
1564  switch (c) {
1565  case '\b': av_bprintf(dst, "%s", "\\b"); break;
1566  case '\f': av_bprintf(dst, "%s", "\\f"); break;
1567  case '\n': av_bprintf(dst, "%s", "\\n"); break;
1568  case '\r': av_bprintf(dst, "%s", "\\r"); break;
1569  case '\t': av_bprintf(dst, "%s", "\\t"); break;
1570  case '\\':
1571  case '#' :
1572  case '=' :
1573  case ':' : av_bprint_chars(dst, '\\', 1);
1574  default:
1575  if ((unsigned char)c < 32)
1576  av_bprintf(dst, "\\x00%02x", c & 0xff);
1577  else
1578  av_bprint_chars(dst, c, 1);
1579  break;
1580  }
1581  }
1582  return dst->str;
1583 }
1584 
1585 static void ini_print_section_header(WriterContext *wctx, const void *data)
1586 {
1587  INIContext *ini = wctx->priv;
1588  AVBPrint *buf = &wctx->section_pbuf[wctx->level];
1589  const struct section *section = wctx->section[wctx->level];
1590  const struct section *parent_section = wctx->level ?
1591  wctx->section[wctx->level-1] : NULL;
1592 
1593  av_bprint_clear(buf);
1594  if (!parent_section) {
1595  writer_put_str(wctx, "# ffprobe output\n\n");
1596  return;
1597  }
1598 
1599  if (wctx->nb_item[wctx->level-1])
1600  writer_w8(wctx, '\n');
1601 
1602  av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
1603  if (ini->hierarchical ||
1604  !(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {
1605  av_bprintf(buf, "%s%s", buf->str[0] ? "." : "", wctx->section[wctx->level]->name);
1606 
1607  if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
1608  int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
1609  wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
1610  av_bprintf(buf, ".%d", n);
1611  }
1612  }
1613 
1614  if (!(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER)))
1615  writer_printf(wctx, "[%s]\n", buf->str);
1616 }
1617 
1618 static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
1619 {
1620  AVBPrint buf;
1621 
1622  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1623  writer_printf(wctx, "%s=", ini_escape_str(&buf, key));
1624  av_bprint_clear(&buf);
1625  writer_printf(wctx, "%s\n", ini_escape_str(&buf, value));
1626  av_bprint_finalize(&buf, NULL);
1627 }
1628 
1629 static void ini_print_int(WriterContext *wctx, const char *key, int64_t value)
1630 {
1631  writer_printf(wctx, "%s=%"PRId64"\n", key, value);
1632 }
1633 
1634 static const Writer ini_writer = {
1635  .name = "ini",
1636  .priv_size = sizeof(INIContext),
1637  .print_section_header = ini_print_section_header,
1638  .print_integer = ini_print_int,
1639  .print_string = ini_print_str,
1640  .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1641  .priv_class = &ini_class,
1642 };
1643 
1644 /* JSON output */
1645 
1646 typedef struct JSONContext {
1647  const AVClass *class;
1648  int indent_level;
1649  int compact;
1650  const char *item_sep, *item_start_end;
1651 } JSONContext;
1652 
1653 #undef OFFSET
1654 #define OFFSET(x) offsetof(JSONContext, x)
1655 
1656 static const AVOption json_options[]= {
1657  { "compact", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1658  { "c", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1659  { NULL }
1660 };
1661 
1662 DEFINE_WRITER_CLASS(json);
1663 
1664 static av_cold int json_init(WriterContext *wctx)
1665 {
1666  JSONContext *json = wctx->priv;
1667 
1668  json->item_sep = json->compact ? ", " : ",\n";
1669  json->item_start_end = json->compact ? " " : "\n";
1670 
1671  return 0;
1672 }
1673 
1674 static const char *json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
1675 {
1676  static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
1677  static const char json_subst[] = {'"', '\\', 'b', 'f', 'n', 'r', 't', 0};
1678  const char *p;
1679 
1680  for (p = src; *p; p++) {
1681  char *s = strchr(json_escape, *p);
1682  if (s) {
1683  av_bprint_chars(dst, '\\', 1);
1684  av_bprint_chars(dst, json_subst[s - json_escape], 1);
1685  } else if ((unsigned char)*p < 32) {
1686  av_bprintf(dst, "\\u00%02x", *p & 0xff);
1687  } else {
1688  av_bprint_chars(dst, *p, 1);
1689  }
1690  }
1691  return dst->str;
1692 }
1693 
1694 #define JSON_INDENT() writer_printf(wctx, "%*c", json->indent_level * 4, ' ')
1695 
1696 static void json_print_section_header(WriterContext *wctx, const void *data)
1697 {
1698  JSONContext *json = wctx->priv;
1699  AVBPrint buf;
1700  const struct section *section = wctx->section[wctx->level];
1701  const struct section *parent_section = wctx->level ?
1702  wctx->section[wctx->level-1] : NULL;
1703 
1704  if (wctx->level && wctx->nb_item[wctx->level-1])
1705  writer_put_str(wctx, ",\n");
1706 
1707  if (section->flags & SECTION_FLAG_IS_WRAPPER) {
1708  writer_put_str(wctx, "{\n");
1709  json->indent_level++;
1710  } else {
1711  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1712  json_escape_str(&buf, section->name, wctx);
1713  JSON_INDENT();
1714 
1715  json->indent_level++;
1716  if (section->flags & SECTION_FLAG_IS_ARRAY) {
1717  writer_printf(wctx, "\"%s\": [\n", buf.str);
1718  } else if (parent_section && !(parent_section->flags & SECTION_FLAG_IS_ARRAY)) {
1719  writer_printf(wctx, "\"%s\": {%s", buf.str, json->item_start_end);
1720  } else {
1721  writer_printf(wctx, "{%s", json->item_start_end);
1722 
1723  /* this is required so the parser can distinguish between packets and frames */
1724  if (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES) {
1725  if (!json->compact)
1726  JSON_INDENT();
1727  writer_printf(wctx, "\"type\": \"%s\"", section->name);
1728  wctx->nb_item[wctx->level]++;
1729  }
1730  }
1731  av_bprint_finalize(&buf, NULL);
1732  }
1733 }
1734 
1735 static void json_print_section_footer(WriterContext *wctx)
1736 {
1737  JSONContext *json = wctx->priv;
1738  const struct section *section = wctx->section[wctx->level];
1739 
1740  if (wctx->level == 0) {
1741  json->indent_level--;
1742  writer_put_str(wctx, "\n}\n");
1743  } else if (section->flags & SECTION_FLAG_IS_ARRAY) {
1744  writer_w8(wctx, '\n');
1745  json->indent_level--;
1746  JSON_INDENT();
1747  writer_w8(wctx, ']');
1748  } else {
1749  writer_put_str(wctx, json->item_start_end);
1750  json->indent_level--;
1751  if (!json->compact)
1752  JSON_INDENT();
1753  writer_w8(wctx, '}');
1754  }
1755 }
1756 
1757 static inline void json_print_item_str(WriterContext *wctx,
1758  const char *key, const char *value)
1759 {
1760  AVBPrint buf;
1761 
1762  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1763  writer_printf(wctx, "\"%s\":", json_escape_str(&buf, key, wctx));
1764  av_bprint_clear(&buf);
1765  writer_printf(wctx, " \"%s\"", json_escape_str(&buf, value, wctx));
1766  av_bprint_finalize(&buf, NULL);
1767 }
1768 
1769 static void json_print_str(WriterContext *wctx, const char *key, const char *value)
1770 {
1771  JSONContext *json = wctx->priv;
1772  const struct section *parent_section = wctx->level ?
1773  wctx->section[wctx->level-1] : NULL;
1774 
1775  if (wctx->nb_item[wctx->level] || (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES))
1776  writer_put_str(wctx, json->item_sep);
1777  if (!json->compact)
1778  JSON_INDENT();
1779  json_print_item_str(wctx, key, value);
1780 }
1781 
1782 static void json_print_int(WriterContext *wctx, const char *key, int64_t value)
1783 {
1784  JSONContext *json = wctx->priv;
1785  const struct section *parent_section = wctx->level ?
1786  wctx->section[wctx->level-1] : NULL;
1787  AVBPrint buf;
1788 
1789  if (wctx->nb_item[wctx->level] || (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES))
1790  writer_put_str(wctx, json->item_sep);
1791  if (!json->compact)
1792  JSON_INDENT();
1793 
1794  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1795  writer_printf(wctx, "\"%s\": %"PRId64, json_escape_str(&buf, key, wctx), value);
1796  av_bprint_finalize(&buf, NULL);
1797 }
1798 
1799 static const Writer json_writer = {
1800  .name = "json",
1801  .priv_size = sizeof(JSONContext),
1802  .init = json_init,
1803  .print_section_header = json_print_section_header,
1804  .print_section_footer = json_print_section_footer,
1805  .print_integer = json_print_int,
1806  .print_string = json_print_str,
1807  .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1808  .priv_class = &json_class,
1809 };
1810 
1811 /* XML output */
1812 
1813 typedef struct XMLContext {
1814  const AVClass *class;
1815  int within_tag;
1816  int indent_level;
1817  int fully_qualified;
1818  int xsd_strict;
1819 } XMLContext;
1820 
1821 #undef OFFSET
1822 #define OFFSET(x) offsetof(XMLContext, x)
1823 
1824 static const AVOption xml_options[] = {
1825  {"fully_qualified", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1826  {"q", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1827  {"xsd_strict", "ensure that the output is XSD compliant", OFFSET(xsd_strict), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1828  {"x", "ensure that the output is XSD compliant", OFFSET(xsd_strict), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1829  {NULL},
1830 };
1831 
1832 DEFINE_WRITER_CLASS(xml);
1833 
1834 static av_cold int xml_init(WriterContext *wctx)
1835 {
1836  XMLContext *xml = wctx->priv;
1837 
1838  if (xml->xsd_strict) {
1839  xml->fully_qualified = 1;
1840 #define CHECK_COMPLIANCE(opt, opt_name) \
1841  if (opt) { \
1842  av_log(wctx, AV_LOG_ERROR, \
1843  "XSD-compliant output selected but option '%s' was selected, XML output may be non-compliant.\n" \
1844  "You need to disable such option with '-no%s'\n", opt_name, opt_name); \
1845  return AVERROR(EINVAL); \
1846  }
1847  CHECK_COMPLIANCE(show_private_data, "private");
1848  CHECK_COMPLIANCE(show_value_unit, "unit");
1849  CHECK_COMPLIANCE(use_value_prefix, "prefix");
1850  }
1851 
1852  return 0;
1853 }
1854 
1855 #define XML_INDENT() writer_printf(wctx, "%*c", xml->indent_level * 4, ' ')
1856 
1857 static void xml_print_section_header(WriterContext *wctx, const void *data)
1858 {
1859  XMLContext *xml = wctx->priv;
1860  const struct section *section = wctx->section[wctx->level];
1861  const struct section *parent_section = wctx->level ?
1862  wctx->section[wctx->level-1] : NULL;
1863 
1864  if (wctx->level == 0) {
1865  const char *qual = " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
1866  "xmlns:ffprobe=\"http://www.ffmpeg.org/schema/ffprobe\" "
1867  "xsi:schemaLocation=\"http://www.ffmpeg.org/schema/ffprobe ffprobe.xsd\"";
1868 
1869  writer_put_str(wctx, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
1870  writer_printf(wctx, "<%sffprobe%s>\n",
1871  xml->fully_qualified ? "ffprobe:" : "",
1872  xml->fully_qualified ? qual : "");
1873  return;
1874  }
1875 
1876  if (xml->within_tag) {
1877  xml->within_tag = 0;
1878  writer_put_str(wctx, ">\n");
1879  }
1880 
1881  if (parent_section && (parent_section->flags & SECTION_FLAG_IS_WRAPPER) &&
1882  wctx->level && wctx->nb_item[wctx->level-1])
1883  writer_w8(wctx, '\n');
1884  xml->indent_level++;
1885 
1886  if (section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_HAS_VARIABLE_FIELDS)) {
1887  XML_INDENT(); writer_printf(wctx, "<%s", section->name);
1888 
1889  if (section->flags & SECTION_FLAG_HAS_TYPE) {
1890  AVBPrint buf;
1891  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1892  av_bprint_escape(&buf, section->get_type(data), NULL,
1893  AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
1894  writer_printf(wctx, " type=\"%s\"", buf.str);
1895  }
1896  writer_printf(wctx, ">\n", section->name);
1897  } else {
1898  XML_INDENT(); writer_printf(wctx, "<%s ", section->name);
1899  xml->within_tag = 1;
1900  }
1901 }
1902 
1903 static void xml_print_section_footer(WriterContext *wctx)
1904 {
1905  XMLContext *xml = wctx->priv;
1906  const struct section *section = wctx->section[wctx->level];
1907 
1908  if (wctx->level == 0) {
1909  writer_printf(wctx, "</%sffprobe>\n", xml->fully_qualified ? "ffprobe:" : "");
1910  } else if (xml->within_tag) {
1911  xml->within_tag = 0;
1912  writer_put_str(wctx, "/>\n");
1913  xml->indent_level--;
1914  } else {
1915  XML_INDENT(); writer_printf(wctx, "</%s>\n", section->name);
1916  xml->indent_level--;
1917  }
1918 }
1919 
1920 static void xml_print_value(WriterContext *wctx, const char *key,
1921  const char *str, int64_t num, const int is_int)
1922 {
1923  AVBPrint buf;
1924  XMLContext *xml = wctx->priv;
1925  const struct section *section = wctx->section[wctx->level];
1926 
1927  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1928 
1929  if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
1930  xml->indent_level++;
1931  XML_INDENT();
1932  av_bprint_escape(&buf, key, NULL,
1933  AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
1934  writer_printf(wctx, "<%s key=\"%s\"",
1935  section->element_name, buf.str);
1936  av_bprint_clear(&buf);
1937 
1938  if (is_int) {
1939  writer_printf(wctx, " value=\"%"PRId64"\"/>\n", num);
1940  } else {
1941  av_bprint_escape(&buf, str, NULL,
1942  AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
1943  writer_printf(wctx, " value=\"%s\"/>\n", buf.str);
1944  }
1945  xml->indent_level--;
1946  } else {
1947  if (wctx->nb_item[wctx->level])
1948  writer_w8(wctx, ' ');
1949 
1950  if (is_int) {
1951  writer_printf(wctx, "%s=\"%"PRId64"\"", key, num);
1952  } else {
1953  av_bprint_escape(&buf, str, NULL,
1954  AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
1955  writer_printf(wctx, "%s=\"%s\"", key, buf.str);
1956  }
1957  }
1958 
1959  av_bprint_finalize(&buf, NULL);
1960 }
1961 
1962 static inline void xml_print_str(WriterContext *wctx, const char *key, const char *value) {
1963  xml_print_value(wctx, key, value, 0, 0);
1964 }
1965 
1966 static void xml_print_int(WriterContext *wctx, const char *key, int64_t value)
1967 {
1968  xml_print_value(wctx, key, NULL, value, 1);
1969 }
1970 
1971 static Writer xml_writer = {
1972  .name = "xml",
1973  .priv_size = sizeof(XMLContext),
1974  .init = xml_init,
1975  .print_section_header = xml_print_section_header,
1976  .print_section_footer = xml_print_section_footer,
1977  .print_integer = xml_print_int,
1978  .print_string = xml_print_str,
1979  .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1980  .priv_class = &xml_class,
1981 };
1982 
1983 static void writer_register_all(void)
1984 {
1985  static int initialized;
1986 
1987  if (initialized)
1988  return;
1989  initialized = 1;
1990 
1991  writer_register(&default_writer);
1992  writer_register(&compact_writer);
1993  writer_register(&csv_writer);
1994  writer_register(&flat_writer);
1995  writer_register(&ini_writer);
1996  writer_register(&json_writer);
1997  writer_register(&xml_writer);
1998 }
1999 
2000 #define print_fmt(k, f, ...) do { \
2001  av_bprint_clear(&pbuf); \
2002  av_bprintf(&pbuf, f, __VA_ARGS__); \
2003  writer_print_string(w, k, pbuf.str, 0); \
2004 } while (0)
2005 
2006 #define print_list_fmt(k, f, n, m, ...) do { \
2007  av_bprint_clear(&pbuf); \
2008  for (int idx = 0; idx < n; idx++) { \
2009  for (int idx2 = 0; idx2 < m; idx2++) { \
2010  if (idx > 0 || idx2 > 0) \
2011  av_bprint_chars(&pbuf, ' ', 1); \
2012  av_bprintf(&pbuf, f, __VA_ARGS__); \
2013  } \
2014  } \
2015  writer_print_string(w, k, pbuf.str, 0); \
2016 } while (0)
2017 
2018 #define print_int(k, v) writer_print_integer(w, k, v)
2019 #define print_q(k, v, s) writer_print_rational(w, k, v, s)
2020 #define print_str(k, v) writer_print_string(w, k, v, 0)
2021 #define print_str_opt(k, v) writer_print_string(w, k, v, PRINT_STRING_OPT)
2022 #define print_str_validate(k, v) writer_print_string(w, k, v, PRINT_STRING_VALIDATE)
2023 #define print_time(k, v, tb) writer_print_time(w, k, v, tb, 0)
2024 #define print_ts(k, v) writer_print_ts(w, k, v, 0)
2025 #define print_duration_time(k, v, tb) writer_print_time(w, k, v, tb, 1)
2026 #define print_duration_ts(k, v) writer_print_ts(w, k, v, 1)
2027 #define print_val(k, v, u) do { \
2028  struct unit_value uv; \
2029  uv.val.i = v; \
2030  uv.unit = u; \
2031  writer_print_string(w, k, value_string(val_str, sizeof(val_str), uv), 0); \
2032 } while (0)
2033 
2034 #define print_section_header(s) writer_print_section_header(w, NULL, s)
2035 #define print_section_header_data(s, d) writer_print_section_header(w, d, s)
2036 #define print_section_footer(s) writer_print_section_footer(w, s)
2037 
2038 #define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n) \
2039 { \
2040  ret = av_reallocp_array(&(ptr), (new_n), sizeof(*(ptr))); \
2041  if (ret < 0) \
2042  goto end; \
2043  memset( (ptr) + (cur_n), 0, ((new_n) - (cur_n)) * sizeof(*(ptr)) ); \
2044 }
2045 
2046 static inline int show_tags(WriterContext *w, AVDictionary *tags, int section_id)
2047 {
2048  const AVDictionaryEntry *tag = NULL;
2049  int ret = 0;
2050 
2051  if (!tags)
2052  return 0;
2053  writer_print_section_header(w, NULL, section_id);
2054 
2055  while ((tag = av_dict_iterate(tags, tag))) {
2056  if ((ret = print_str_validate(tag->key, tag->value)) < 0)
2057  break;
2058  }
2059  writer_print_section_footer(w);
2060 
2061  return ret;
2062 }
2063 
2064 static void print_dovi_metadata(WriterContext *w, const AVDOVIMetadata *dovi)
2065 {
2066  if (!dovi)
2067  return;
2068 
2069  {
2070  const AVDOVIRpuDataHeader *hdr = av_dovi_get_header(dovi);
2071  const AVDOVIDataMapping *mapping = av_dovi_get_mapping(dovi);
2072  const AVDOVIColorMetadata *color = av_dovi_get_color(dovi);
2073  AVBPrint pbuf;
2074 
2075  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2076 
2077  // header
2078  print_int("rpu_type", hdr->rpu_type);
2079  print_int("rpu_format", hdr->rpu_format);
2080  print_int("vdr_rpu_profile", hdr->vdr_rpu_profile);
2081  print_int("vdr_rpu_level", hdr->vdr_rpu_level);
2082  print_int("chroma_resampling_explicit_filter_flag",
2083  hdr->chroma_resampling_explicit_filter_flag);
2084  print_int("coef_data_type", hdr->coef_data_type);
2085  print_int("coef_log2_denom", hdr->coef_log2_denom);
2086  print_int("vdr_rpu_normalized_idc", hdr->vdr_rpu_normalized_idc);
2087  print_int("bl_video_full_range_flag", hdr->bl_video_full_range_flag);
2088  print_int("bl_bit_depth", hdr->bl_bit_depth);
2089  print_int("el_bit_depth", hdr->el_bit_depth);
2090  print_int("vdr_bit_depth", hdr->vdr_bit_depth);
2091  print_int("spatial_resampling_filter_flag",
2092  hdr->spatial_resampling_filter_flag);
2093  print_int("el_spatial_resampling_filter_flag",
2094  hdr->el_spatial_resampling_filter_flag);
2095  print_int("disable_residual_flag", hdr->disable_residual_flag);
2096 
2097  // data mapping values
2098  print_int("vdr_rpu_id", mapping->vdr_rpu_id);
2099  print_int("mapping_color_space", mapping->mapping_color_space);
2100  print_int("mapping_chroma_format_idc",
2101  mapping->mapping_chroma_format_idc);
2102 
2103  print_int("nlq_method_idc", mapping->nlq_method_idc);
2104  switch (mapping->nlq_method_idc) {
2105  case AV_DOVI_NLQ_NONE:
2106  print_str("nlq_method_idc_name", "none");
2107  break;
2108  case AV_DOVI_NLQ_LINEAR_DZ:
2109  print_str("nlq_method_idc_name", "linear_dz");
2110  break;
2111  default:
2112  print_str("nlq_method_idc_name", "unknown");
2113  break;
2114  }
2115 
2116  print_int("num_x_partitions", mapping->num_x_partitions);
2117  print_int("num_y_partitions", mapping->num_y_partitions);
2118 
2119  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
2120 
2121  for (int c = 0; c < 3; c++) {
2122  const AVDOVIReshapingCurve *curve = &mapping->curves[c];
2123  writer_print_section_header(w, "Reshaping curve", SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
2124 
2125  print_list_fmt("pivots", "%"PRIu16, curve->num_pivots, 1, curve->pivots[idx]);
2126 
2127  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST);
2128  for (int i = 0; i < curve->num_pivots - 1; i++) {
2129  AVBPrint piece_buf;
2130 
2131  av_bprint_init(&piece_buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
2132  switch (curve->mapping_idc[i]) {
2133  case AV_DOVI_MAPPING_POLYNOMIAL:
2134  av_bprintf(&piece_buf, "Polynomial");
2135  break;
2136  case AV_DOVI_MAPPING_MMR:
2137  av_bprintf(&piece_buf, "MMR");
2138  break;
2139  default:
2140  av_bprintf(&piece_buf, "Unknown");
2141  break;
2142  }
2143  av_bprintf(&piece_buf, " mapping");
2144 
2145  writer_print_section_header(w, piece_buf.str, SECTION_ID_FRAME_SIDE_DATA_PIECE);
2146  print_int("mapping_idc", curve->mapping_idc[i]);
2147  switch (curve->mapping_idc[i]) {
2148  case AV_DOVI_MAPPING_POLYNOMIAL:
2149  print_str("mapping_idc_name", "polynomial");
2150  print_int("poly_order", curve->poly_order[i]);
2151  print_list_fmt("poly_coef", "%"PRIi64,
2152  curve->poly_order[i] + 1, 1,
2153  curve->poly_coef[i][idx]);
2154  break;
2155  case AV_DOVI_MAPPING_MMR:
2156  print_str("mapping_idc_name", "mmr");
2157  print_int("mmr_order", curve->mmr_order[i]);
2158  print_int("mmr_constant", curve->mmr_constant[i]);
2159  print_list_fmt("mmr_coef", "%"PRIi64,
2160  curve->mmr_order[i], 7,
2161  curve->mmr_coef[i][idx][idx2]);
2162  break;
2163  default:
2164  print_str("mapping_idc_name", "unknown");
2165  break;
2166  }
2167 
2168  // SECTION_ID_FRAME_SIDE_DATA_PIECE
2169  writer_print_section_footer(w);
2170  }
2171 
2172  // SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
2173  writer_print_section_footer(w);
2174 
2175  if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
2176  const AVDOVINLQParams *nlq = &mapping->nlq[c];
2177  print_int("nlq_offset", nlq->nlq_offset);
2178  print_int("vdr_in_max", nlq->vdr_in_max);
2179 
2180  switch (mapping->nlq_method_idc) {
2181  case AV_DOVI_NLQ_LINEAR_DZ:
2182  print_int("linear_deadzone_slope", nlq->linear_deadzone_slope);
2183  print_int("linear_deadzone_threshold", nlq->linear_deadzone_threshold);
2184  break;
2185  }
2186  }
2187 
2188  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
2189  writer_print_section_footer(w);
2190  }
2191 
2192  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
2193  writer_print_section_footer(w);
2194 
2195  // color metadata
2196  print_int("dm_metadata_id", color->dm_metadata_id);
2197  print_int("scene_refresh_flag", color->scene_refresh_flag);
2198  print_list_fmt("ycc_to_rgb_matrix", "%d/%d",
2199  FF_ARRAY_ELEMS(color->ycc_to_rgb_matrix), 1,
2200  color->ycc_to_rgb_matrix[idx].num,
2201  color->ycc_to_rgb_matrix[idx].den);
2202  print_list_fmt("ycc_to_rgb_offset", "%d/%d",
2203  FF_ARRAY_ELEMS(color->ycc_to_rgb_offset), 1,
2204  color->ycc_to_rgb_offset[idx].num,
2205  color->ycc_to_rgb_offset[idx].den);
2206  print_list_fmt("rgb_to_lms_matrix", "%d/%d",
2207  FF_ARRAY_ELEMS(color->rgb_to_lms_matrix), 1,
2208  color->rgb_to_lms_matrix[idx].num,
2209  color->rgb_to_lms_matrix[idx].den);
2210  print_int("signal_eotf", color->signal_eotf);
2211  print_int("signal_eotf_param0", color->signal_eotf_param0);
2212  print_int("signal_eotf_param1", color->signal_eotf_param1);
2213  print_int("signal_eotf_param2", color->signal_eotf_param2);
2214  print_int("signal_bit_depth", color->signal_bit_depth);
2215  print_int("signal_color_space", color->signal_color_space);
2216  print_int("signal_chroma_format", color->signal_chroma_format);
2217  print_int("signal_full_range_flag", color->signal_full_range_flag);
2218  print_int("source_min_pq", color->source_min_pq);
2219  print_int("source_max_pq", color->source_max_pq);
2220  print_int("source_diagonal", color->source_diagonal);
2221 
2222  av_bprint_finalize(&pbuf, NULL);
2223  }
2224 }
2225 
2226 static void print_dynamic_hdr10_plus(WriterContext *w, const AVDynamicHDRPlus *metadata)
2227 {
2228  if (!metadata)
2229  return;
2230  print_int("application version", metadata->application_version);
2231  print_int("num_windows", metadata->num_windows);
2232  for (int n = 1; n < metadata->num_windows; n++) {
2233  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
2234  print_q("window_upper_left_corner_x",
2235  params->window_upper_left_corner_x,'/');
2236  print_q("window_upper_left_corner_y",
2237  params->window_upper_left_corner_y,'/');
2238  print_q("window_lower_right_corner_x",
2239  params->window_lower_right_corner_x,'/');
2240  print_q("window_lower_right_corner_y",
2241  params->window_lower_right_corner_y,'/');
2242  print_q("window_upper_left_corner_x",
2243  params->window_upper_left_corner_x,'/');
2244  print_q("window_upper_left_corner_y",
2245  params->window_upper_left_corner_y,'/');
2246  print_int("center_of_ellipse_x",
2247  params->center_of_ellipse_x ) ;
2248  print_int("center_of_ellipse_y",
2249  params->center_of_ellipse_y );
2250  print_int("rotation_angle",
2251  params->rotation_angle);
2252  print_int("semimajor_axis_internal_ellipse",
2253  params->semimajor_axis_internal_ellipse);
2254  print_int("semimajor_axis_external_ellipse",
2255  params->semimajor_axis_external_ellipse);
2256  print_int("semiminor_axis_external_ellipse",
2257  params->semiminor_axis_external_ellipse);
2258  print_int("overlap_process_option",
2259  params->overlap_process_option);
2260  }
2261  print_q("targeted_system_display_maximum_luminance",
2262  metadata->targeted_system_display_maximum_luminance,'/');
2263  if (metadata->targeted_system_display_actual_peak_luminance_flag) {
2264  print_int("num_rows_targeted_system_display_actual_peak_luminance",
2265  metadata->num_rows_targeted_system_display_actual_peak_luminance);
2266  print_int("num_cols_targeted_system_display_actual_peak_luminance",
2267  metadata->num_cols_targeted_system_display_actual_peak_luminance);
2268  for (int i = 0; i < metadata->num_rows_targeted_system_display_actual_peak_luminance; i++) {
2269  for (int j = 0; j < metadata->num_cols_targeted_system_display_actual_peak_luminance; j++) {
2270  print_q("targeted_system_display_actual_peak_luminance",
2271  metadata->targeted_system_display_actual_peak_luminance[i][j],'/');
2272  }
2273  }
2274  }
2275  for (int n = 0; n < metadata->num_windows; n++) {
2276  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
2277  for (int i = 0; i < 3; i++) {
2278  print_q("maxscl",params->maxscl[i],'/');
2279  }
2280  print_q("average_maxrgb",
2281  params->average_maxrgb,'/');
2282  print_int("num_distribution_maxrgb_percentiles",
2283  params->num_distribution_maxrgb_percentiles);
2284  for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
2285  print_int("distribution_maxrgb_percentage",
2286  params->distribution_maxrgb[i].percentage);
2287  print_q("distribution_maxrgb_percentile",
2288  params->distribution_maxrgb[i].percentile,'/');
2289  }
2290  print_q("fraction_bright_pixels",
2291  params->fraction_bright_pixels,'/');
2292  }
2293  if (metadata->mastering_display_actual_peak_luminance_flag) {
2294  print_int("num_rows_mastering_display_actual_peak_luminance",
2295  metadata->num_rows_mastering_display_actual_peak_luminance);
2296  print_int("num_cols_mastering_display_actual_peak_luminance",
2297  metadata->num_cols_mastering_display_actual_peak_luminance);
2298  for (int i = 0; i < metadata->num_rows_mastering_display_actual_peak_luminance; i++) {
2299  for (int j = 0; j < metadata->num_cols_mastering_display_actual_peak_luminance; j++) {
2300  print_q("mastering_display_actual_peak_luminance",
2301  metadata->mastering_display_actual_peak_luminance[i][j],'/');
2302  }
2303  }
2304  }
2305 
2306  for (int n = 0; n < metadata->num_windows; n++) {
2307  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
2308  if (params->tone_mapping_flag) {
2309  print_q("knee_point_x", params->knee_point_x,'/');
2310  print_q("knee_point_y", params->knee_point_y,'/');
2311  print_int("num_bezier_curve_anchors",
2312  params->num_bezier_curve_anchors );
2313  for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
2314  print_q("bezier_curve_anchors",
2315  params->bezier_curve_anchors[i],'/');
2316  }
2317  }
2318  if (params->color_saturation_mapping_flag) {
2319  print_q("color_saturation_weight",
2320  params->color_saturation_weight,'/');
2321  }
2322  }
2323 }
2324 
2325 static void print_dynamic_hdr_vivid(WriterContext *w, const AVDynamicHDRVivid *metadata)
2326 {
2327  if (!metadata)
2328  return;
2329  print_int("system_start_code", metadata->system_start_code);
2330  print_int("num_windows", metadata->num_windows);
2331 
2332  for (int n = 0; n < metadata->num_windows; n++) {
2333  const AVHDRVividColorTransformParams *params = &metadata->params[n];
2334 
2335  print_q("minimum_maxrgb", params->minimum_maxrgb, '/');
2336  print_q("average_maxrgb", params->average_maxrgb, '/');
2337  print_q("variance_maxrgb", params->variance_maxrgb, '/');
2338  print_q("maximum_maxrgb", params->maximum_maxrgb, '/');
2339  }
2340 
2341  for (int n = 0; n < metadata->num_windows; n++) {
2342  const AVHDRVividColorTransformParams *params = &metadata->params[n];
2343 
2344  print_int("tone_mapping_mode_flag", params->tone_mapping_mode_flag);
2345  if (params->tone_mapping_mode_flag) {
2346  print_int("tone_mapping_param_num", params->tone_mapping_param_num);
2347  for (int i = 0; i < params->tone_mapping_param_num; i++) {
2348  const AVHDRVividColorToneMappingParams *tm_params = &params->tm_params[i];
2349 
2350  print_q("targeted_system_display_maximum_luminance",
2351  tm_params->targeted_system_display_maximum_luminance, '/');
2352  print_int("base_enable_flag", tm_params->base_enable_flag);
2353  if (tm_params->base_enable_flag) {
2354  print_q("base_param_m_p", tm_params->base_param_m_p, '/');
2355  print_q("base_param_m_m", tm_params->base_param_m_m, '/');
2356  print_q("base_param_m_a", tm_params->base_param_m_a, '/');
2357  print_q("base_param_m_b", tm_params->base_param_m_b, '/');
2358  print_q("base_param_m_n", tm_params->base_param_m_n, '/');
2359 
2360  print_int("base_param_k1", tm_params->base_param_k1);
2361  print_int("base_param_k2", tm_params->base_param_k2);
2362  print_int("base_param_k3", tm_params->base_param_k3);
2363  print_int("base_param_Delta_enable_mode",
2364  tm_params->base_param_Delta_enable_mode);
2365  print_q("base_param_Delta", tm_params->base_param_Delta, '/');
2366  }
2367  print_int("3Spline_enable_flag", tm_params->three_Spline_enable_flag);
2368  if (tm_params->three_Spline_enable_flag) {
2369  print_int("3Spline_num", tm_params->three_Spline_num);
2370 
2371  for (int j = 0; j < tm_params->three_Spline_num; j++) {
2372  const AVHDRVivid3SplineParams *three_spline = &tm_params->three_spline[j];
2373  print_int("3Spline_TH_mode", three_spline->th_mode);
2374  if (three_spline->th_mode == 0 || three_spline->th_mode == 2)
2375  print_q("3Spline_TH_enable_MB", three_spline->th_enable_mb, '/');
2376  print_q("3Spline_TH_enable", three_spline->th_enable, '/');
2377  print_q("3Spline_TH_Delta1", three_spline->th_delta1, '/');
2378  print_q("3Spline_TH_Delta2", three_spline->th_delta2, '/');
2379  print_q("3Spline_enable_Strength", three_spline->enable_strength, '/');
2380  }
2381  }
2382  }
2383  }
2384 
2385  print_int("color_saturation_mapping_flag", params->color_saturation_mapping_flag);
2386  if (params->color_saturation_mapping_flag) {
2387  print_int("color_saturation_num", params->color_saturation_num);
2388  for (int i = 0; i < params->color_saturation_num; i++) {
2389  print_q("color_saturation_gain", params->color_saturation_gain[i], '/');
2390  }
2391  }
2392  }
2393 }
2394 
2395 static void print_ambient_viewing_environment(WriterContext *w,
2396  const AVAmbientViewingEnvironment *env)
2397 {
2398  if (!env)
2399  return;
2400 
2401  print_q("ambient_illuminance", env->ambient_illuminance, '/');
2402  print_q("ambient_light_x", env->ambient_light_x, '/');
2403  print_q("ambient_light_y", env->ambient_light_y, '/');
2404 }
2405 
2406 static void print_film_grain_params(WriterContext *w,
2407  const AVFilmGrainParams *fgp)
2408 {
2409  const char *color_range, *color_primaries, *color_trc, *color_space;
2410  const char *const film_grain_type_names[] = {
2411  [AV_FILM_GRAIN_PARAMS_NONE] = "none",
2412  [AV_FILM_GRAIN_PARAMS_AV1] = "av1",
2413  [AV_FILM_GRAIN_PARAMS_H274] = "h274",
2414  };
2415 
2416  AVBPrint pbuf;
2417  if (!fgp || fgp->type >= FF_ARRAY_ELEMS(film_grain_type_names))
2418  return;
2419 
2420  color_range = av_color_range_name(fgp->color_range);
2421  color_primaries = av_color_primaries_name(fgp->color_primaries);
2422  color_trc = av_color_transfer_name(fgp->color_trc);
2423  color_space = av_color_space_name(fgp->color_space);
2424 
2425  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2426  print_str("type", film_grain_type_names[fgp->type]);
2427  print_fmt("seed", "%"PRIu64, fgp->seed);
2428  print_int("width", fgp->width);
2429  print_int("height", fgp->height);
2430  print_int("subsampling_x", fgp->subsampling_x);
2431  print_int("subsampling_y", fgp->subsampling_y);
2432  print_str("color_range", color_range ? color_range : "unknown");
2433  print_str("color_primaries", color_primaries ? color_primaries : "unknown");
2434  print_str("color_trc", color_trc ? color_trc : "unknown");
2435  print_str("color_space", color_space ? color_space : "unknown");
2436 
2437  switch (fgp->type) {
2438  case AV_FILM_GRAIN_PARAMS_NONE:
2439  break;
2440  case AV_FILM_GRAIN_PARAMS_AV1: {
2441  const AVFilmGrainAOMParams *aom = &fgp->codec.aom;
2442  const int num_ar_coeffs_y = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
2443  const int num_ar_coeffs_uv = num_ar_coeffs_y + !!aom->num_y_points;
2444  print_int("chroma_scaling_from_luma", aom->chroma_scaling_from_luma);
2445  print_int("scaling_shift", aom->scaling_shift);
2446  print_int("ar_coeff_lag", aom->ar_coeff_lag);
2447  print_int("ar_coeff_shift", aom->ar_coeff_shift);
2448  print_int("grain_scale_shift", aom->grain_scale_shift);
2449  print_int("overlap_flag", aom->overlap_flag);
2450  print_int("limit_output_range", aom->limit_output_range);
2451 
2452  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
2453 
2454  if (aom->num_y_points) {
2455  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
2456 
2457  print_int("bit_depth_luma", fgp->bit_depth_luma);
2458  print_list_fmt("y_points_value", "%"PRIu8, aom->num_y_points, 1, aom->y_points[idx][0]);
2459  print_list_fmt("y_points_scaling", "%"PRIu8, aom->num_y_points, 1, aom->y_points[idx][1]);
2460  print_list_fmt("ar_coeffs_y", "%"PRId8, num_ar_coeffs_y, 1, aom->ar_coeffs_y[idx]);
2461 
2462  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
2463  writer_print_section_footer(w);
2464  }
2465 
2466  for (int uv = 0; uv < 2; uv++) {
2467  if (!aom->num_uv_points[uv] && !aom->chroma_scaling_from_luma)
2468  continue;
2469 
2470  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
2471 
2472  print_int("bit_depth_chroma", fgp->bit_depth_chroma);
2473  print_list_fmt("uv_points_value", "%"PRIu8, aom->num_uv_points[uv], 1, aom->uv_points[uv][idx][0]);
2474  print_list_fmt("uv_points_scaling", "%"PRIu8, aom->num_uv_points[uv], 1, aom->uv_points[uv][idx][1]);
2475  print_list_fmt("ar_coeffs_uv", "%"PRId8, num_ar_coeffs_uv, 1, aom->ar_coeffs_uv[uv][idx]);
2476  print_int("uv_mult", aom->uv_mult[uv]);
2477  print_int("uv_mult_luma", aom->uv_mult_luma[uv]);
2478  print_int("uv_offset", aom->uv_offset[uv]);
2479 
2480  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
2481  writer_print_section_footer(w);
2482  }
2483 
2484  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
2485  writer_print_section_footer(w);
2486  break;
2487  }
2488  case AV_FILM_GRAIN_PARAMS_H274: {
2489  const AVFilmGrainH274Params *h274 = &fgp->codec.h274;
2490  print_int("model_id", h274->model_id);
2491  print_int("blending_mode_id", h274->blending_mode_id);
2492  print_int("log2_scale_factor", h274->log2_scale_factor);
2493 
2494  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
2495 
2496  for (int c = 0; c < 3; c++) {
2497  if (!h274->component_model_present[c])
2498  continue;
2499 
2500  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
2501  print_int(c ? "bit_depth_chroma" : "bit_depth_luma", c ? fgp->bit_depth_chroma : fgp->bit_depth_luma);
2502 
2503  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST);
2504  for (int i = 0; i < h274->num_intensity_intervals[c]; i++) {
2505 
2506  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_PIECE);
2507  print_int("intensity_interval_lower_bound", h274->intensity_interval_lower_bound[c][i]);
2508  print_int("intensity_interval_upper_bound", h274->intensity_interval_upper_bound[c][i]);
2509  print_list_fmt("comp_model_value", "%"PRId16, h274->num_model_values[c], 1, h274->comp_model_value[c][i][idx]);
2510 
2511  // SECTION_ID_FRAME_SIDE_DATA_PIECE
2512  writer_print_section_footer(w);
2513  }
2514 
2515  // SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
2516  writer_print_section_footer(w);
2517 
2518  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
2519  writer_print_section_footer(w);
2520  }
2521 
2522  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
2523  writer_print_section_footer(w);
2524  break;
2525  }
2526  }
2527 
2528  av_bprint_finalize(&pbuf, NULL);
2529 }
2530 
2531 static void print_pkt_side_data(WriterContext *w,
2532  AVCodecParameters *par,
2533  const AVPacketSideData *sd,
2534  SectionID id_data)
2535 {
2536  const char *name = av_packet_side_data_name(sd->type);
2537 
2538  writer_print_section_header(w, sd, id_data);
2539  print_str("side_data_type", name ? name : "unknown");
2540  if (sd->type == AV_PKT_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
2541  double rotation = av_display_rotation_get((int32_t *)sd->data);
2542  if (isnan(rotation))
2543  rotation = 0;
2544  writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
2545  print_int("rotation", rotation);
2546  } else if (sd->type == AV_PKT_DATA_STEREO3D) {
2547  const AVStereo3D *stereo = (AVStereo3D *)sd->data;
2548  print_str("type", av_stereo3d_type_name(stereo->type));
2549  print_int("inverted", !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
2550  print_str("view", av_stereo3d_view_name(stereo->view));
2551  print_str("primary_eye", av_stereo3d_primary_eye_name(stereo->primary_eye));
2552  print_int("baseline", stereo->baseline);
2553  print_q("horizontal_disparity_adjustment", stereo->horizontal_disparity_adjustment, '/');
2554  print_q("horizontal_field_of_view", stereo->horizontal_field_of_view, '/');
2555  } else if (sd->type == AV_PKT_DATA_SPHERICAL) {
2556  const AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
2557  print_str("projection", av_spherical_projection_name(spherical->projection));
2558  if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
2559  print_int("padding", spherical->padding);
2560  } else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
2561  size_t l, t, r, b;
2562  av_spherical_tile_bounds(spherical, par->width, par->height,
2563  &l, &t, &r, &b);
2564  print_int("bound_left", l);
2565  print_int("bound_top", t);
2566  print_int("bound_right", r);
2567  print_int("bound_bottom", b);
2568  }
2569 
2570  print_int("yaw", (double) spherical->yaw / (1 << 16));
2571  print_int("pitch", (double) spherical->pitch / (1 << 16));
2572  print_int("roll", (double) spherical->roll / (1 << 16));
2573  } else if (sd->type == AV_PKT_DATA_SKIP_SAMPLES && sd->size == 10) {
2574  print_int("skip_samples", AV_RL32(sd->data));
2575  print_int("discard_padding", AV_RL32(sd->data + 4));
2576  print_int("skip_reason", AV_RL8(sd->data + 8));
2577  print_int("discard_reason", AV_RL8(sd->data + 9));
2578  } else if (sd->type == AV_PKT_DATA_MASTERING_DISPLAY_METADATA) {
2579  AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
2580 
2581  if (metadata->has_primaries) {
2582  print_q("red_x", metadata->display_primaries[0][0], '/');
2583  print_q("red_y", metadata->display_primaries[0][1], '/');
2584  print_q("green_x", metadata->display_primaries[1][0], '/');
2585  print_q("green_y", metadata->display_primaries[1][1], '/');
2586  print_q("blue_x", metadata->display_primaries[2][0], '/');
2587  print_q("blue_y", metadata->display_primaries[2][1], '/');
2588 
2589  print_q("white_point_x", metadata->white_point[0], '/');
2590  print_q("white_point_y", metadata->white_point[1], '/');
2591  }
2592 
2593  if (metadata->has_luminance) {
2594  print_q("min_luminance", metadata->min_luminance, '/');
2595  print_q("max_luminance", metadata->max_luminance, '/');
2596  }
2597  } else if (sd->type == AV_PKT_DATA_CONTENT_LIGHT_LEVEL) {
2598  AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
2599  print_int("max_content", metadata->MaxCLL);
2600  print_int("max_average", metadata->MaxFALL);
2601  } else if (sd->type == AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT) {
2602  print_ambient_viewing_environment(
2603  w, (const AVAmbientViewingEnvironment *)sd->data);
2604  } else if (sd->type == AV_PKT_DATA_DYNAMIC_HDR10_PLUS) {
2605  AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
2606  print_dynamic_hdr10_plus(w, metadata);
2607  } else if (sd->type == AV_PKT_DATA_DOVI_CONF) {
2608  AVDOVIDecoderConfigurationRecord *dovi = (AVDOVIDecoderConfigurationRecord *)sd->data;
2609  const char *comp = "unknown";
2610  print_int("dv_version_major", dovi->dv_version_major);
2611  print_int("dv_version_minor", dovi->dv_version_minor);
2612  print_int("dv_profile", dovi->dv_profile);
2613  print_int("dv_level", dovi->dv_level);
2614  print_int("rpu_present_flag", dovi->rpu_present_flag);
2615  print_int("el_present_flag", dovi->el_present_flag);
2616  print_int("bl_present_flag", dovi->bl_present_flag);
2617  print_int("dv_bl_signal_compatibility_id", dovi->dv_bl_signal_compatibility_id);
2618  switch (dovi->dv_md_compression)
2619  {
2620  case AV_DOVI_COMPRESSION_NONE: comp = "none"; break;
2621  case AV_DOVI_COMPRESSION_LIMITED: comp = "limited"; break;
2622  case AV_DOVI_COMPRESSION_RESERVED: comp = "reserved"; break;
2623  case AV_DOVI_COMPRESSION_EXTENDED: comp = "extended"; break;
2624  }
2625  print_str("dv_md_compression", comp);
2626  } else if (sd->type == AV_PKT_DATA_AUDIO_SERVICE_TYPE) {
2627  enum AVAudioServiceType *t = (enum AVAudioServiceType *)sd->data;
2628  print_int("service_type", *t);
2629  } else if (sd->type == AV_PKT_DATA_MPEGTS_STREAM_ID) {
2630  print_int("id", *sd->data);
2631  } else if (sd->type == AV_PKT_DATA_CPB_PROPERTIES) {
2632  const AVCPBProperties *prop = (AVCPBProperties *)sd->data;
2633  print_int("max_bitrate", prop->max_bitrate);
2634  print_int("min_bitrate", prop->min_bitrate);
2635  print_int("avg_bitrate", prop->avg_bitrate);
2636  print_int("buffer_size", prop->buffer_size);
2637  print_int("vbv_delay", prop->vbv_delay);
2638  } else if (sd->type == AV_PKT_DATA_WEBVTT_IDENTIFIER ||
2639  sd->type == AV_PKT_DATA_WEBVTT_SETTINGS) {
2640  if (do_show_data)
2641  writer_print_data(w, "data", sd->data, sd->size);
2642  writer_print_data_hash(w, "data_hash", sd->data, sd->size);
2643  } else if (sd->type == AV_PKT_DATA_FRAME_CROPPING && sd->size >= sizeof(uint32_t) * 4) {
2644  print_int("crop_top", AV_RL32(sd->data));
2645  print_int("crop_bottom", AV_RL32(sd->data + 4));
2646  print_int("crop_left", AV_RL32(sd->data + 8));
2647  print_int("crop_right", AV_RL32(sd->data + 12));
2648  } else if (sd->type == AV_PKT_DATA_AFD && sd->size > 0) {
2649  print_int("active_format", *sd->data);
2650  }
2651 }
2652 
2653 static void print_private_data(WriterContext *w, void *priv_data)
2654 {
2655  const AVOption *opt = NULL;
2656  while (opt = av_opt_next(priv_data, opt)) {
2657  uint8_t *str;
2658  if (!(opt->flags & AV_OPT_FLAG_EXPORT)) continue;
2659  if (av_opt_get(priv_data, opt->name, 0, &str) >= 0) {
2660  print_str(opt->name, str);
2661  av_free(str);
2662  }
2663  }
2664 }
2665 
2666 static void print_color_range(WriterContext *w, enum AVColorRange color_range)
2667 {
2668  const char *val = av_color_range_name(color_range);
2669  if (!val || color_range == AVCOL_RANGE_UNSPECIFIED) {
2670  print_str_opt("color_range", "unknown");
2671  } else {
2672  print_str("color_range", val);
2673  }
2674 }
2675 
2676 static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
2677 {
2678  const char *val = av_color_space_name(color_space);
2679  if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
2680  print_str_opt("color_space", "unknown");
2681  } else {
2682  print_str("color_space", val);
2683  }
2684 }
2685 
2686 static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
2687 {
2688  const char *val = av_color_primaries_name(color_primaries);
2689  if (!val || color_primaries == AVCOL_PRI_UNSPECIFIED) {
2690  print_str_opt("color_primaries", "unknown");
2691  } else {
2692  print_str("color_primaries", val);
2693  }
2694 }
2695 
2696 static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
2697 {
2698  const char *val = av_color_transfer_name(color_trc);
2699  if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
2700  print_str_opt("color_transfer", "unknown");
2701  } else {
2702  print_str("color_transfer", val);
2703  }
2704 }
2705 
2706 static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
2707 {
2708  const char *val = av_chroma_location_name(chroma_location);
2709  if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
2710  print_str_opt("chroma_location", "unspecified");
2711  } else {
2712  print_str("chroma_location", val);
2713  }
2714 }
2715 
2716 static void clear_log(int need_lock)
2717 {
2718  int i;
2719 
2720  if (need_lock)
2721  pthread_mutex_lock(&log_mutex);
2722  for (i=0; i<log_buffer_size; i++) {
2723  av_freep(&log_buffer[i].context_name);
2724  av_freep(&log_buffer[i].parent_name);
2725  av_freep(&log_buffer[i].log_message);
2726  }
2727  log_buffer_size = 0;
2728  if(need_lock)
2729  pthread_mutex_unlock(&log_mutex);
2730 }
2731 
2732 static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
2733 {
2734  int i;
2735  pthread_mutex_lock(&log_mutex);
2736  if (!log_buffer_size) {
2737  pthread_mutex_unlock(&log_mutex);
2738  return 0;
2739  }
2740  writer_print_section_header(w, NULL, section_ids);
2741 
2742  for (i=0; i<log_buffer_size; i++) {
2743  if (log_buffer[i].log_level <= log_level) {
2744  writer_print_section_header(w, NULL, section_id);
2745  print_str("context", log_buffer[i].context_name);
2746  print_int("level", log_buffer[i].log_level);
2747  print_int("category", log_buffer[i].category);
2748  if (log_buffer[i].parent_name) {
2749  print_str("parent_context", log_buffer[i].parent_name);
2750  print_int("parent_category", log_buffer[i].parent_category);
2751  } else {
2752  print_str_opt("parent_context", "N/A");
2753  print_str_opt("parent_category", "N/A");
2754  }
2755  print_str("message", log_buffer[i].log_message);
2756  writer_print_section_footer(w);
2757  }
2758  }
2759  clear_log(0);
2760  pthread_mutex_unlock(&log_mutex);
2761 
2762  writer_print_section_footer(w);
2763 
2764  return 0;
2765 }
2766 
2767 static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
2768 {
2769  char val_str[128];
2770  AVStream *st = ifile->streams[pkt->stream_index].st;
2771  AVBPrint pbuf;
2772  const char *s;
2773 
2774  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2775 
2776  writer_print_section_header(w, NULL, SECTION_ID_PACKET);
2777 
2778  s = av_get_media_type_string(st->codecpar->codec_type);
2779  if (s) print_str ("codec_type", s);
2780  else print_str_opt("codec_type", "unknown");
2781  print_int("stream_index", pkt->stream_index);
2782  print_ts ("pts", pkt->pts);
2783  print_time("pts_time", pkt->pts, &st->time_base);
2784  print_ts ("dts", pkt->dts);
2785  print_time("dts_time", pkt->dts, &st->time_base);
2786  print_duration_ts("duration", pkt->duration);
2787  print_duration_time("duration_time", pkt->duration, &st->time_base);
2788  print_val("size", pkt->size, unit_byte_str);
2789  if (pkt->pos != -1) print_fmt ("pos", "%"PRId64, pkt->pos);
2790  else print_str_opt("pos", "N/A");
2791  print_fmt("flags", "%c%c%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_',
2792  pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_',
2793  pkt->flags & AV_PKT_FLAG_CORRUPT ? 'C' : '_');
2794  if (do_show_data)
2795  writer_print_data(w, "data", pkt->data, pkt->size);
2796  writer_print_data_hash(w, "data_hash", pkt->data, pkt->size);
2797 
2798  if (pkt->side_data_elems) {
2799  size_t size;
2800  const uint8_t *side_metadata;
2801 
2802  side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);
2803  if (side_metadata && size && do_show_packet_tags) {
2804  AVDictionary *dict = NULL;
2805  if (av_packet_unpack_dictionary(side_metadata, size, &dict) >= 0)
2806  show_tags(w, dict, SECTION_ID_PACKET_TAGS);
2807  av_dict_free(&dict);
2808  }
2809 
2810  writer_print_section_header(w, NULL, SECTION_ID_PACKET_SIDE_DATA_LIST);
2811  for (int i = 0; i < pkt->side_data_elems; i++) {
2812  print_pkt_side_data(w, st->codecpar, &pkt->side_data[i],
2813  SECTION_ID_PACKET_SIDE_DATA);
2814  writer_print_section_footer(w);
2815  }
2816  writer_print_section_footer(w);
2817  }
2818 
2819  writer_print_section_footer(w);
2820 
2821  av_bprint_finalize(&pbuf, NULL);
2822  fflush(stdout);
2823 }
2824 
2825 static void show_subtitle(WriterContext *w, AVSubtitle *sub, AVStream *stream,
2826  AVFormatContext *fmt_ctx)
2827 {
2828  AVBPrint pbuf;
2829 
2830  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2831 
2832  writer_print_section_header(w, NULL, SECTION_ID_SUBTITLE);
2833 
2834  print_str ("media_type", "subtitle");
2835  print_ts ("pts", sub->pts);
2836  print_time("pts_time", sub->pts, &AV_TIME_BASE_Q);
2837  print_int ("format", sub->format);
2838  print_int ("start_display_time", sub->start_display_time);
2839  print_int ("end_display_time", sub->end_display_time);
2840  print_int ("num_rects", sub->num_rects);
2841 
2842  writer_print_section_footer(w);
2843 
2844  av_bprint_finalize(&pbuf, NULL);
2845  fflush(stdout);
2846 }
2847 
2848 static void print_frame_side_data(WriterContext *w,
2849  const AVFrame *frame,
2850  const AVStream *stream)
2851 {
2852  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_LIST);
2853 
2854  for (int i = 0; i < frame->nb_side_data; i++) {
2855  const AVFrameSideData *sd = frame->side_data[i];
2856  const char *name;
2857 
2858  writer_print_section_header(w, sd, SECTION_ID_FRAME_SIDE_DATA);
2859  name = av_frame_side_data_name(sd->type);
2860  print_str("side_data_type", name ? name : "unknown");
2861  if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
2862  double rotation = av_display_rotation_get((int32_t *)sd->data);
2863  if (isnan(rotation))
2864  rotation = 0;
2865  writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
2866  print_int("rotation", rotation);
2867  } else if (sd->type == AV_FRAME_DATA_AFD && sd->size > 0) {
2868  print_int("active_format", *sd->data);
2869  } else if (sd->type == AV_FRAME_DATA_GOP_TIMECODE && sd->size >= 8) {
2870  char tcbuf[AV_TIMECODE_STR_SIZE];
2871  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
2872  print_str("timecode", tcbuf);
2873  } else if (sd->type == AV_FRAME_DATA_S12M_TIMECODE && sd->size == 16) {
2874  uint32_t *tc = (uint32_t*)sd->data;
2875  int m = FFMIN(tc[0],3);
2876  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST);
2877  for (int j = 1; j <= m ; j++) {
2878  char tcbuf[AV_TIMECODE_STR_SIZE];
2879  av_timecode_make_smpte_tc_string2(tcbuf, stream->avg_frame_rate, tc[j], 0, 0);
2880  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_TIMECODE);
2881  print_str("value", tcbuf);
2882  writer_print_section_footer(w);
2883  }
2884  writer_print_section_footer(w);
2885  } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
2886  AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
2887 
2888  if (metadata->has_primaries) {
2889  print_q("red_x", metadata->display_primaries[0][0], '/');
2890  print_q("red_y", metadata->display_primaries[0][1], '/');
2891  print_q("green_x", metadata->display_primaries[1][0], '/');
2892  print_q("green_y", metadata->display_primaries[1][1], '/');
2893  print_q("blue_x", metadata->display_primaries[2][0], '/');
2894  print_q("blue_y", metadata->display_primaries[2][1], '/');
2895 
2896  print_q("white_point_x", metadata->white_point[0], '/');
2897  print_q("white_point_y", metadata->white_point[1], '/');
2898  }
2899 
2900  if (metadata->has_luminance) {
2901  print_q("min_luminance", metadata->min_luminance, '/');
2902  print_q("max_luminance", metadata->max_luminance, '/');
2903  }
2904  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_PLUS) {
2905  AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
2906  print_dynamic_hdr10_plus(w, metadata);
2907  } else if (sd->type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL) {
2908  AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
2909  print_int("max_content", metadata->MaxCLL);
2910  print_int("max_average", metadata->MaxFALL);
2911  } else if (sd->type == AV_FRAME_DATA_ICC_PROFILE) {
2912  const AVDictionaryEntry *tag = av_dict_get(sd->metadata, "name", NULL, AV_DICT_MATCH_CASE);
2913  if (tag)
2914  print_str(tag->key, tag->value);
2915  print_int("size", sd->size);
2916  } else if (sd->type == AV_FRAME_DATA_DOVI_METADATA) {
2917  print_dovi_metadata(w, (const AVDOVIMetadata *)sd->data);
2918  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_VIVID) {
2919  AVDynamicHDRVivid *metadata = (AVDynamicHDRVivid *)sd->data;
2920  print_dynamic_hdr_vivid(w, metadata);
2921  } else if (sd->type == AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT) {
2922  print_ambient_viewing_environment(w, (const AVAmbientViewingEnvironment *)sd->data);
2923  } else if (sd->type == AV_FRAME_DATA_FILM_GRAIN_PARAMS) {
2924  AVFilmGrainParams *fgp = (AVFilmGrainParams *)sd->data;
2925  print_film_grain_params(w, fgp);
2926  } else if (sd->type == AV_FRAME_DATA_VIEW_ID) {
2927  print_int("view_id", *(int*)sd->data);
2928  }
2929  writer_print_section_footer(w);
2930  }
2931  writer_print_section_footer(w);
2932 }
2933 
2934 static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
2935  AVFormatContext *fmt_ctx)
2936 {
2937  FrameData *fd = frame->opaque_ref ? (FrameData*)frame->opaque_ref->data : NULL;
2938  AVBPrint pbuf;
2939  char val_str[128];
2940  const char *s;
2941 
2942  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2943 
2944  writer_print_section_header(w, NULL, SECTION_ID_FRAME);
2945 
2946  s = av_get_media_type_string(stream->codecpar->codec_type);
2947  if (s) print_str ("media_type", s);
2948  else print_str_opt("media_type", "unknown");
2949  print_int("stream_index", stream->index);
2950  print_int("key_frame", !!(frame->flags & AV_FRAME_FLAG_KEY));
2951  print_ts ("pts", frame->pts);
2952  print_time("pts_time", frame->pts, &stream->time_base);
2953  print_ts ("pkt_dts", frame->pkt_dts);
2954  print_time("pkt_dts_time", frame->pkt_dts, &stream->time_base);
2955  print_ts ("best_effort_timestamp", frame->best_effort_timestamp);
2956  print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
2957  print_duration_ts ("duration", frame->duration);
2958  print_duration_time("duration_time", frame->duration, &stream->time_base);
2959  if (fd && fd->pkt_pos != -1) print_fmt ("pkt_pos", "%"PRId64, fd->pkt_pos);
2960  else print_str_opt("pkt_pos", "N/A");
2961  if (fd && fd->pkt_size != -1) print_val ("pkt_size", fd->pkt_size, unit_byte_str);
2962  else print_str_opt("pkt_size", "N/A");
2963 
2964  switch (stream->codecpar->codec_type) {
2965  AVRational sar;
2966 
2967  case AVMEDIA_TYPE_VIDEO:
2968  print_int("width", frame->width);
2969  print_int("height", frame->height);
2970  print_int("crop_top", frame->crop_top);
2971  print_int("crop_bottom", frame->crop_bottom);
2972  print_int("crop_left", frame->crop_left);
2973  print_int("crop_right", frame->crop_right);
2974  s = av_get_pix_fmt_name(frame->format);
2975  if (s) print_str ("pix_fmt", s);
2976  else print_str_opt("pix_fmt", "unknown");
2977  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
2978  if (sar.num) {
2979  print_q("sample_aspect_ratio", sar, ':');
2980  } else {
2981  print_str_opt("sample_aspect_ratio", "N/A");
2982  }
2983  print_fmt("pict_type", "%c", av_get_picture_type_char(frame->pict_type));
2984  print_int("interlaced_frame", !!(frame->flags & AV_FRAME_FLAG_INTERLACED));
2985  print_int("top_field_first", !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
2986  print_int("lossless", !!(frame->flags & AV_FRAME_FLAG_LOSSLESS));
2987  print_int("repeat_pict", frame->repeat_pict);
2988 
2989  print_color_range(w, frame->color_range);
2990  print_color_space(w, frame->colorspace);
2991  print_primaries(w, frame->color_primaries);
2992  print_color_trc(w, frame->color_trc);
2993  print_chroma_location(w, frame->chroma_location);
2994  break;
2995 
2996  case AVMEDIA_TYPE_AUDIO:
2997  s = av_get_sample_fmt_name(frame->format);
2998  if (s) print_str ("sample_fmt", s);
2999  else print_str_opt("sample_fmt", "unknown");
3000  print_int("nb_samples", frame->nb_samples);
3001  print_int("channels", frame->ch_layout.nb_channels);
3002  if (frame->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
3003  av_channel_layout_describe(&frame->ch_layout, val_str, sizeof(val_str));
3004  print_str ("channel_layout", val_str);
3005  } else
3006  print_str_opt("channel_layout", "unknown");
3007  break;
3008  }
3009  if (do_show_frame_tags)
3010  show_tags(w, frame->metadata, SECTION_ID_FRAME_TAGS);
3011  if (do_show_log)
3012  show_log(w, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log);
3013  if (frame->nb_side_data)
3014  print_frame_side_data(w, frame, stream);
3015 
3016  writer_print_section_footer(w);
3017 
3018  av_bprint_finalize(&pbuf, NULL);
3019  fflush(stdout);
3020 }
3021 
3022 static av_always_inline int process_frame(WriterContext *w,
3023  InputFile *ifile,
3024  AVFrame *frame, const AVPacket *pkt,
3025  int *packet_new)
3026 {
3027  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3028  AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
3029  AVCodecParameters *par = ifile->streams[pkt->stream_index].st->codecpar;
3030  AVSubtitle sub;
3031  int ret = 0, got_frame = 0;
3032 
3033  clear_log(1);
3034  if (dec_ctx) {
3035  switch (par->codec_type) {
3036  case AVMEDIA_TYPE_VIDEO:
3037  case AVMEDIA_TYPE_AUDIO:
3038  if (*packet_new) {
3039  ret = avcodec_send_packet(dec_ctx, pkt);
3040  if (ret == AVERROR(EAGAIN)) {
3041  ret = 0;
3042  } else if (ret >= 0 || ret == AVERROR_EOF) {
3043  ret = 0;
3044  *packet_new = 0;
3045  }
3046  }
3047  if (ret >= 0) {
3048  ret = avcodec_receive_frame(dec_ctx, frame);
3049  if (ret >= 0) {
3050  got_frame = 1;
3051  } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
3052  ret = 0;
3053  }
3054  }
3055  break;
3056 
3057  case AVMEDIA_TYPE_SUBTITLE:
3058  if (*packet_new)
3059  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
3060  *packet_new = 0;
3061  break;
3062  default:
3063  *packet_new = 0;
3064  }
3065  } else {
3066  *packet_new = 0;
3067  }
3068 
3069  if (ret < 0)
3070  return ret;
3071  if (got_frame) {
3072  int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
3073  nb_streams_frames[pkt->stream_index]++;
3074  if (do_show_frames)
3075  if (is_sub)
3076  show_subtitle(w, &sub, ifile->streams[pkt->stream_index].st, fmt_ctx);
3077  else
3078  show_frame(w, frame, ifile->streams[pkt->stream_index].st, fmt_ctx);
3079 
3080  if (!is_sub && do_analyze_frames) {
3081  for (int i = 0; i < frame->nb_side_data; i++) {
3082  if (frame->side_data[i]->type == AV_FRAME_DATA_A53_CC)
3083  streams_with_closed_captions[pkt->stream_index] = 1;
3084  else if (frame->side_data[i]->type == AV_FRAME_DATA_FILM_GRAIN_PARAMS)
3085  streams_with_film_grain[pkt->stream_index] = 1;
3086  }
3087  }
3088 
3089  if (is_sub)
3090  avsubtitle_free(&sub);
3091  }
3092  return got_frame || *packet_new;
3093 }
3094 
3095 static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
3096 {
3097  av_log(log_ctx, log_level, "id:%d", interval->id);
3098 
3099  if (interval->has_start) {
3100  av_log(log_ctx, log_level, " start:%s%s", interval->start_is_offset ? "+" : "",
3101  av_ts2timestr(interval->start, &AV_TIME_BASE_Q));
3102  } else {
3103  av_log(log_ctx, log_level, " start:N/A");
3104  }
3105 
3106  if (interval->has_end) {
3107  av_log(log_ctx, log_level, " end:%s", interval->end_is_offset ? "+" : "");
3108  if (interval->duration_frames)
3109  av_log(log_ctx, log_level, "#%"PRId64, interval->end);
3110  else
3111  av_log(log_ctx, log_level, "%s", av_ts2timestr(interval->end, &AV_TIME_BASE_Q));
3112  } else {
3113  av_log(log_ctx, log_level, " end:N/A");
3114  }
3115 
3116  av_log(log_ctx, log_level, "\n");
3117 }
3118 
3119 static int read_interval_packets(WriterContext *w, InputFile *ifile,
3120  const ReadInterval *interval, int64_t *cur_ts)
3121 {
3122  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3123  AVPacket *pkt = NULL;
3124  AVFrame *frame = NULL;
3125  int ret = 0, i = 0, frame_count = 0;
3126  int64_t start = -INT64_MAX, end = interval->end;
3127  int has_start = 0, has_end = interval->has_end && !interval->end_is_offset;
3128 
3129  av_log(NULL, AV_LOG_VERBOSE, "Processing read interval ");
3130  log_read_interval(interval, NULL, AV_LOG_VERBOSE);
3131 
3132  if (interval->has_start) {
3133  int64_t target;
3134  if (interval->start_is_offset) {
3135  if (*cur_ts == AV_NOPTS_VALUE) {
3136  av_log(NULL, AV_LOG_ERROR,
3137  "Could not seek to relative position since current "
3138  "timestamp is not defined\n");
3139  ret = AVERROR(EINVAL);
3140  goto end;
3141  }
3142  target = *cur_ts + interval->start;
3143  } else {
3144  target = interval->start;
3145  }
3146 
3147  av_log(NULL, AV_LOG_VERBOSE, "Seeking to read interval start point %s\n",
3148  av_ts2timestr(target, &AV_TIME_BASE_Q));
3149  if ((ret = avformat_seek_file(fmt_ctx, -1, -INT64_MAX, target, INT64_MAX, 0)) < 0) {
3150  av_log(NULL, AV_LOG_ERROR, "Could not seek to position %"PRId64": %s\n",
3151  interval->start, av_err2str(ret));
3152  goto end;
3153  }
3154  }
3155 
3156  frame = av_frame_alloc();
3157  if (!frame) {
3158  ret = AVERROR(ENOMEM);
3159  goto end;
3160  }
3161  pkt = av_packet_alloc();
3162  if (!pkt) {
3163  ret = AVERROR(ENOMEM);
3164  goto end;
3165  }
3166  while (!av_read_frame(fmt_ctx, pkt)) {
3167  if (fmt_ctx->nb_streams > nb_streams) {
3168  REALLOCZ_ARRAY_STREAM(nb_streams_frames, nb_streams, fmt_ctx->nb_streams);
3169  REALLOCZ_ARRAY_STREAM(nb_streams_packets, nb_streams, fmt_ctx->nb_streams);
3170  REALLOCZ_ARRAY_STREAM(selected_streams, nb_streams, fmt_ctx->nb_streams);
3171  REALLOCZ_ARRAY_STREAM(streams_with_closed_captions, nb_streams, fmt_ctx->nb_streams);
3172  REALLOCZ_ARRAY_STREAM(streams_with_film_grain, nb_streams, fmt_ctx->nb_streams);
3173  nb_streams = fmt_ctx->nb_streams;
3174  }
3175  if (selected_streams[pkt->stream_index]) {
3176  AVRational tb = ifile->streams[pkt->stream_index].st->time_base;
3177  int64_t pts = pkt->pts != AV_NOPTS_VALUE ? pkt->pts : pkt->dts;
3178 
3179  if (pts != AV_NOPTS_VALUE)
3180  *cur_ts = av_rescale_q(pts, tb, AV_TIME_BASE_Q);
3181 
3182  if (!has_start && *cur_ts != AV_NOPTS_VALUE) {
3183  start = *cur_ts;
3184  has_start = 1;
3185  }
3186 
3187  if (has_start && !has_end && interval->end_is_offset) {
3188  end = start + interval->end;
3189  has_end = 1;
3190  }
3191 
3192  if (interval->end_is_offset && interval->duration_frames) {
3193  if (frame_count >= interval->end)
3194  break;
3195  } else if (has_end && *cur_ts != AV_NOPTS_VALUE && *cur_ts >= end) {
3196  break;
3197  }
3198 
3199  frame_count++;
3200  if (do_read_packets) {
3201  if (do_show_packets)
3202  show_packet(w, ifile, pkt, i++);
3203  nb_streams_packets[pkt->stream_index]++;
3204  }
3205  if (do_read_frames) {
3206  int packet_new = 1;
3207  FrameData *fd;
3208 
3209  pkt->opaque_ref = av_buffer_allocz(sizeof(*fd));
3210  if (!pkt->opaque_ref) {
3211  ret = AVERROR(ENOMEM);
3212  goto end;
3213  }
3214  fd = (FrameData*)pkt->opaque_ref->data;
3215  fd->pkt_pos = pkt->pos;
3216  fd->pkt_size = pkt->size;
3217 
3218  while (process_frame(w, ifile, frame, pkt, &packet_new) > 0);
3219  }
3220  }
3221  av_packet_unref(pkt);
3222  }
3223  av_packet_unref(pkt);
3224  //Flush remaining frames that are cached in the decoder
3225  for (i = 0; i < ifile->nb_streams; i++) {
3226  pkt->stream_index = i;
3227  if (do_read_frames) {
3228  while (process_frame(w, ifile, frame, pkt, &(int){1}) > 0);
3229  if (ifile->streams[i].dec_ctx)
3230  avcodec_flush_buffers(ifile->streams[i].dec_ctx);
3231  }
3232  }
3233 
3234 end:
3235  av_frame_free(&frame);
3236  av_packet_free(&pkt);
3237  if (ret < 0) {
3238  av_log(NULL, AV_LOG_ERROR, "Could not read packets in interval ");
3239  log_read_interval(interval, NULL, AV_LOG_ERROR);
3240  }
3241  return ret;
3242 }
3243 
3244 static int read_packets(WriterContext *w, InputFile *ifile)
3245 {
3246  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3247  int i, ret = 0;
3248  int64_t cur_ts = fmt_ctx->start_time;
3249 
3250  if (read_intervals_nb == 0) {
3251  ReadInterval interval = (ReadInterval) { .has_start = 0, .has_end = 0 };
3252  ret = read_interval_packets(w, ifile, &interval, &cur_ts);
3253  } else {
3254  for (i = 0; i < read_intervals_nb; i++) {
3255  ret = read_interval_packets(w, ifile, &read_intervals[i], &cur_ts);
3256  if (ret < 0)
3257  break;
3258  }
3259  }
3260 
3261  return ret;
3262 }
3263 
3264 static void print_dispositions(WriterContext *w, uint32_t disposition, SectionID section_id)
3265 {
3266  writer_print_section_header(w, NULL, section_id);
3267  for (int i = 0; i < sizeof(disposition) * CHAR_BIT; i++) {
3268  const char *disposition_str = av_disposition_to_string(1U << i);
3269 
3270  if (disposition_str)
3271  print_int(disposition_str, !!(disposition & (1U << i)));
3272  }
3273  writer_print_section_footer(w);
3274 }
3275 
3276 #define IN_PROGRAM 1
3277 #define IN_STREAM_GROUP 2
3278 
3279 static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int container)
3280 {
3281  AVStream *stream = ist->st;
3282  AVCodecParameters *par;
3283  AVCodecContext *dec_ctx;
3284  char val_str[128];
3285  const char *s;
3286  AVRational sar, dar;
3287  AVBPrint pbuf;
3288  const AVCodecDescriptor *cd;
3289  const SectionID section_header[] = {
3290  SECTION_ID_STREAM,
3291  SECTION_ID_PROGRAM_STREAM,
3292  SECTION_ID_STREAM_GROUP_STREAM,
3293  };
3294  const SectionID section_disposition[] = {
3295  SECTION_ID_STREAM_DISPOSITION,
3296  SECTION_ID_PROGRAM_STREAM_DISPOSITION,
3297  SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION,
3298  };
3299  const SectionID section_tags[] = {
3300  SECTION_ID_STREAM_TAGS,
3301  SECTION_ID_PROGRAM_STREAM_TAGS,
3302  SECTION_ID_STREAM_GROUP_STREAM_TAGS,
3303  };
3304  int ret = 0;
3305  const char *profile = NULL;
3306 
3307  av_assert0(container < FF_ARRAY_ELEMS(section_header));
3308 
3309  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
3310 
3311  writer_print_section_header(w, NULL, section_header[container]);
3312 
3313  print_int("index", stream->index);
3314 
3315  par = stream->codecpar;
3316  dec_ctx = ist->dec_ctx;
3317  if (cd = avcodec_descriptor_get(par->codec_id)) {
3318  print_str("codec_name", cd->name);
3319  if (!do_bitexact) {
3320  print_str("codec_long_name",
3321  cd->long_name ? cd->long_name : "unknown");
3322  }
3323  } else {
3324  print_str_opt("codec_name", "unknown");
3325  if (!do_bitexact) {
3326  print_str_opt("codec_long_name", "unknown");
3327  }
3328  }
3329 
3330  if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
3331  print_str("profile", profile);
3332  else {
3333  if (par->profile != AV_PROFILE_UNKNOWN) {
3334  char profile_num[12];
3335  snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
3336  print_str("profile", profile_num);
3337  } else
3338  print_str_opt("profile", "unknown");
3339  }
3340 
3341  s = av_get_media_type_string(par->codec_type);
3342  if (s) print_str ("codec_type", s);
3343  else print_str_opt("codec_type", "unknown");
3344 
3345  /* print AVI/FourCC tag */
3346  print_str("codec_tag_string", av_fourcc2str(par->codec_tag));
3347  print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
3348 
3349  switch (par->codec_type) {
3350  case AVMEDIA_TYPE_VIDEO:
3351  print_int("width", par->width);
3352  print_int("height", par->height);
3353  if (dec_ctx) {
3354  print_int("coded_width", dec_ctx->coded_width);
3355  print_int("coded_height", dec_ctx->coded_height);
3356 
3357  if (do_analyze_frames) {
3358  print_int("closed_captions", streams_with_closed_captions[stream->index]);
3359  print_int("film_grain", streams_with_film_grain[stream->index]);
3360  }
3361  }
3362  print_int("has_b_frames", par->video_delay);
3363  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
3364  if (sar.num) {
3365  print_q("sample_aspect_ratio", sar, ':');
3366  av_reduce(&dar.num, &dar.den,
3367  (int64_t) par->width * sar.num,
3368  (int64_t) par->height * sar.den,
3369  1024*1024);
3370  print_q("display_aspect_ratio", dar, ':');
3371  } else {
3372  print_str_opt("sample_aspect_ratio", "N/A");
3373  print_str_opt("display_aspect_ratio", "N/A");
3374  }
3375  s = av_get_pix_fmt_name(par->format);
3376  if (s) print_str ("pix_fmt", s);
3377  else print_str_opt("pix_fmt", "unknown");
3378  print_int("level", par->level);
3379 
3380  print_color_range(w, par->color_range);
3381  print_color_space(w, par->color_space);
3382  print_color_trc(w, par->color_trc);
3383  print_primaries(w, par->color_primaries);
3384  print_chroma_location(w, par->chroma_location);
3385 
3386  if (par->field_order == AV_FIELD_PROGRESSIVE)
3387  print_str("field_order", "progressive");
3388  else if (par->field_order == AV_FIELD_TT)
3389  print_str("field_order", "tt");
3390  else if (par->field_order == AV_FIELD_BB)
3391  print_str("field_order", "bb");
3392  else if (par->field_order == AV_FIELD_TB)
3393  print_str("field_order", "tb");
3394  else if (par->field_order == AV_FIELD_BT)
3395  print_str("field_order", "bt");
3396  else
3397  print_str_opt("field_order", "unknown");
3398 
3399  if (dec_ctx)
3400  print_int("refs", dec_ctx->refs);
3401  break;
3402 
3403  case AVMEDIA_TYPE_AUDIO:
3404  s = av_get_sample_fmt_name(par->format);
3405  if (s) print_str ("sample_fmt", s);
3406  else print_str_opt("sample_fmt", "unknown");
3407  print_val("sample_rate", par->sample_rate, unit_hertz_str);
3408  print_int("channels", par->ch_layout.nb_channels);
3409 
3410  if (par->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
3411  av_channel_layout_describe(&par->ch_layout, val_str, sizeof(val_str));
3412  print_str ("channel_layout", val_str);
3413  } else {
3414  print_str_opt("channel_layout", "unknown");
3415  }
3416 
3417  print_int("bits_per_sample", av_get_bits_per_sample(par->codec_id));
3418 
3419  print_int("initial_padding", par->initial_padding);
3420  break;
3421 
3422  case AVMEDIA_TYPE_SUBTITLE:
3423  if (par->width)
3424  print_int("width", par->width);
3425  else
3426  print_str_opt("width", "N/A");
3427  if (par->height)
3428  print_int("height", par->height);
3429  else
3430  print_str_opt("height", "N/A");
3431  break;
3432  }
3433 
3434  if (show_private_data) {
3435  if (dec_ctx && dec_ctx->codec->priv_class)
3436  print_private_data(w, dec_ctx->priv_data);
3437  if (fmt_ctx->iformat->priv_class)
3438  print_private_data(w, fmt_ctx->priv_data);
3439  }
3440 
3441  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%x", stream->id);
3442  else print_str_opt("id", "N/A");
3443  print_q("r_frame_rate", stream->r_frame_rate, '/');
3444  print_q("avg_frame_rate", stream->avg_frame_rate, '/');
3445  print_q("time_base", stream->time_base, '/');
3446  print_ts ("start_pts", stream->start_time);
3447  print_time("start_time", stream->start_time, &stream->time_base);
3448  print_ts ("duration_ts", stream->duration);
3449  print_time("duration", stream->duration, &stream->time_base);
3450  if (par->bit_rate > 0) print_val ("bit_rate", par->bit_rate, unit_bit_per_second_str);
3451  else print_str_opt("bit_rate", "N/A");
3452  if (dec_ctx && dec_ctx->rc_max_rate > 0)
3453  print_val ("max_bit_rate", dec_ctx->rc_max_rate, unit_bit_per_second_str);
3454  else
3455  print_str_opt("max_bit_rate", "N/A");
3456  if (dec_ctx && dec_ctx->bits_per_raw_sample > 0) print_fmt("bits_per_raw_sample", "%d", dec_ctx->bits_per_raw_sample);
3457  else print_str_opt("bits_per_raw_sample", "N/A");
3458  if (stream->nb_frames) print_fmt ("nb_frames", "%"PRId64, stream->nb_frames);
3459  else print_str_opt("nb_frames", "N/A");
3460  if (nb_streams_frames[stream_idx]) print_fmt ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
3461  else print_str_opt("nb_read_frames", "N/A");
3462  if (nb_streams_packets[stream_idx]) print_fmt ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
3463  else print_str_opt("nb_read_packets", "N/A");
3464  if (do_show_data)
3465  writer_print_data(w, "extradata", par->extradata,
3466  par->extradata_size);
3467 
3468  if (par->extradata_size > 0) {
3469  print_int("extradata_size", par->extradata_size);
3470  writer_print_data_hash(w, "extradata_hash", par->extradata,
3471  par->extradata_size);
3472  }
3473 
3474  /* Print disposition information */
3475  if (do_show_stream_disposition) {
3476  av_assert0(container < FF_ARRAY_ELEMS(section_disposition));
3477  print_dispositions(w, stream->disposition, section_disposition[container]);
3478  }
3479 
3480  if (do_show_stream_tags) {
3481  av_assert0(container < FF_ARRAY_ELEMS(section_tags));
3482  ret = show_tags(w, stream->metadata, section_tags[container]);
3483  }
3484 
3485  if (stream->codecpar->nb_coded_side_data) {
3486  writer_print_section_header(w, NULL, SECTION_ID_STREAM_SIDE_DATA_LIST);
3487  for (int i = 0; i < stream->codecpar->nb_coded_side_data; i++) {
3488  print_pkt_side_data(w, stream->codecpar, &stream->codecpar->coded_side_data[i],
3489  SECTION_ID_STREAM_SIDE_DATA);
3490  writer_print_section_footer(w);
3491  }
3492  writer_print_section_footer(w);
3493  }
3494 
3495  writer_print_section_footer(w);
3496  av_bprint_finalize(&pbuf, NULL);
3497  fflush(stdout);
3498 
3499  return ret;
3500 }
3501 
3502 static int show_streams(WriterContext *w, InputFile *ifile)
3503 {
3504  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3505  int i, ret = 0;
3506 
3507  writer_print_section_header(w, NULL, SECTION_ID_STREAMS);
3508  for (i = 0; i < ifile->nb_streams; i++)
3509  if (selected_streams[i]) {
3510  ret = show_stream(w, fmt_ctx, i, &ifile->streams[i], 0);
3511  if (ret < 0)
3512  break;
3513  }
3514  writer_print_section_footer(w);
3515 
3516  return ret;
3517 }
3518 
3519 static int show_program(WriterContext *w, InputFile *ifile, AVProgram *program)
3520 {
3521  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3522  int i, ret = 0;
3523 
3524  writer_print_section_header(w, NULL, SECTION_ID_PROGRAM);
3525  print_int("program_id", program->id);
3526  print_int("program_num", program->program_num);
3527  print_int("nb_streams", program->nb_stream_indexes);
3528  print_int("pmt_pid", program->pmt_pid);
3529  print_int("pcr_pid", program->pcr_pid);
3530  if (do_show_program_tags)
3531  ret = show_tags(w, program->metadata, SECTION_ID_PROGRAM_TAGS);
3532  if (ret < 0)
3533  goto end;
3534 
3535  writer_print_section_header(w, NULL, SECTION_ID_PROGRAM_STREAMS);
3536  for (i = 0; i < program->nb_stream_indexes; i++) {
3537  if (selected_streams[program->stream_index[i]]) {
3538  ret = show_stream(w, fmt_ctx, program->stream_index[i], &ifile->streams[program->stream_index[i]], IN_PROGRAM);
3539  if (ret < 0)
3540  break;
3541  }
3542  }
3543  writer_print_section_footer(w);
3544 
3545 end:
3546  writer_print_section_footer(w);
3547  return ret;
3548 }
3549 
3550 static int show_programs(WriterContext *w, InputFile *ifile)
3551 {
3552  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3553  int i, ret = 0;
3554 
3555  writer_print_section_header(w, NULL, SECTION_ID_PROGRAMS);
3556  for (i = 0; i < fmt_ctx->nb_programs; i++) {
3557  AVProgram *program = fmt_ctx->programs[i];
3558  if (!program)
3559  continue;
3560  ret = show_program(w, ifile, program);
3561  if (ret < 0)
3562  break;
3563  }
3564  writer_print_section_footer(w);
3565  return ret;
3566 }
3567 
3568 static void print_tile_grid_params(WriterContext *w, const AVStreamGroup *stg,
3569  const AVStreamGroupTileGrid *tile_grid)
3570 {
3571  writer_print_section_header(w, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
3572  print_int("nb_tiles", tile_grid->nb_tiles);
3573  print_int("coded_width", tile_grid->coded_width);
3574  print_int("coded_height", tile_grid->coded_height);
3575  print_int("horizontal_offset", tile_grid->horizontal_offset);
3576  print_int("vertical_offset", tile_grid->vertical_offset);
3577  print_int("width", tile_grid->width);
3578  print_int("height", tile_grid->height);
3579  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
3580  for (int i = 0; i < tile_grid->nb_tiles; i++) {
3581  writer_print_section_header(w, "tile_offset", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3582  print_int("stream_index", tile_grid->offsets[i].idx);
3583  print_int("tile_horizontal_offset", tile_grid->offsets[i].horizontal);
3584  print_int("tile_vertical_offset", tile_grid->offsets[i].vertical);
3585  writer_print_section_footer(w);
3586  }
3587  writer_print_section_footer(w);
3588  writer_print_section_footer(w);
3589 }
3590 
3591 static void print_iamf_param_definition(WriterContext *w, const char *name,
3592  const AVIAMFParamDefinition *param, SectionID section_id)
3593 {
3594  SectionID subsection_id, parameter_section_id;
3595  subsection_id = sections[section_id].children_ids[0];
3596  av_assert0(subsection_id != -1);
3597  parameter_section_id = sections[subsection_id].children_ids[0];
3598  av_assert0(parameter_section_id != -1);
3599  writer_print_section_header(w, "IAMF Param Definition", section_id);
3600  print_str("name", name);
3601  print_int("nb_subblocks", param->nb_subblocks);
3602  print_int("type", param->type);
3603  print_int("parameter_id", param->parameter_id);
3604  print_int("parameter_rate", param->parameter_rate);
3605  print_int("duration", param->duration);
3606  print_int("constant_subblock_duration", param->constant_subblock_duration);
3607  if (param->nb_subblocks > 0)
3608  writer_print_section_header(w, NULL, subsection_id);
3609  for (int i = 0; i < param->nb_subblocks; i++) {
3610  const void *subblock = av_iamf_param_definition_get_subblock(param, i);
3611  switch(param->type) {
3612  case AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN: {
3613  const AVIAMFMixGain *mix = subblock;
3614  writer_print_section_header(w, "IAMF Mix Gain Parameters", parameter_section_id);
3615  print_int("subblock_duration", mix->subblock_duration);
3616  print_int("animation_type", mix->animation_type);
3617  print_q("start_point_value", mix->start_point_value, '/');
3618  print_q("end_point_value", mix->end_point_value, '/');
3619  print_q("control_point_value", mix->control_point_value, '/');
3620  print_q("control_point_relative_time", mix->control_point_relative_time, '/');
3621  writer_print_section_footer(w); // parameter_section_id
3622  break;
3623  }
3624  case AV_IAMF_PARAMETER_DEFINITION_DEMIXING: {
3625  const AVIAMFDemixingInfo *demix = subblock;
3626  writer_print_section_header(w, "IAMF Demixing Info", parameter_section_id);
3627  print_int("subblock_duration", demix->subblock_duration);
3628  print_int("dmixp_mode", demix->dmixp_mode);
3629  writer_print_section_footer(w); // parameter_section_id
3630  break;
3631  }
3632  case AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN: {
3633  const AVIAMFReconGain *recon = subblock;
3634  writer_print_section_header(w, "IAMF Recon Gain", parameter_section_id);
3635  print_int("subblock_duration", recon->subblock_duration);
3636  writer_print_section_footer(w); // parameter_section_id
3637  break;
3638  }
3639  }
3640  }
3641  if (param->nb_subblocks > 0)
3642  writer_print_section_footer(w); // subsection_id
3643  writer_print_section_footer(w); // section_id
3644 }
3645 
3646 static void print_iamf_audio_element_params(WriterContext *w, const AVStreamGroup *stg,
3647  const AVIAMFAudioElement *audio_element)
3648 {
3649  writer_print_section_header(w, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
3650  print_int("nb_layers", audio_element->nb_layers);
3651  print_int("audio_element_type", audio_element->audio_element_type);
3652  print_int("default_w", audio_element->default_w);
3653  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
3654  for (int i = 0; i < audio_element->nb_layers; i++) {
3655  const AVIAMFLayer *layer = audio_element->layers[i];
3656  char val_str[128];
3657  writer_print_section_header(w, "IAMF Audio Layer", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3658  av_channel_layout_describe(&layer->ch_layout, val_str, sizeof(val_str));
3659  print_str("channel_layout", val_str);
3660  if (audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL) {
3661  print_int("output_gain_flags", layer->output_gain_flags);
3662  print_q("output_gain", layer->output_gain, '/');
3663  } else if (audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE)
3664  print_int("ambisonics_mode", layer->ambisonics_mode);
3665  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
3666  }
3667  if (audio_element->demixing_info)
3668  print_iamf_param_definition(w, "demixing_info", audio_element->demixing_info,
3669  SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3670  if (audio_element->recon_gain_info)
3671  print_iamf_param_definition(w, "recon_gain_info", audio_element->recon_gain_info,
3672  SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3673  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
3674  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_COMPONENT
3675 }
3676 
3677 static void print_iamf_submix_params(WriterContext *w, const AVIAMFSubmix *submix)
3678 {
3679  writer_print_section_header(w, "IAMF Submix", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3680  print_int("nb_elements", submix->nb_elements);
3681  print_int("nb_layouts", submix->nb_layouts);
3682  print_q("default_mix_gain", submix->default_mix_gain, '/');
3683  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_PIECES);
3684  for (int i = 0; i < submix->nb_elements; i++) {
3685  const AVIAMFSubmixElement *element = submix->elements[i];
3686  writer_print_section_header(w, "IAMF Submix Element", SECTION_ID_STREAM_GROUP_PIECE);
3687  print_int("stream_id", element->audio_element_id);
3688  print_q("default_mix_gain", element->default_mix_gain, '/');
3689  print_int("headphones_rendering_mode", element->headphones_rendering_mode);
3690  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBPIECES);
3691  if (element->annotations) {
3692  const AVDictionaryEntry *annotation = NULL;
3693  writer_print_section_header(w, "IAMF Annotations", SECTION_ID_STREAM_GROUP_SUBPIECE);
3694  while (annotation = av_dict_iterate(element->annotations, annotation))
3695  print_str(annotation->key, annotation->value);
3696  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBPIECE
3697  }
3698  if (element->element_mix_config)
3699  print_iamf_param_definition(w, "element_mix_config", element->element_mix_config,
3700  SECTION_ID_STREAM_GROUP_SUBPIECE);
3701  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBPIECES
3702  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_PIECE
3703  }
3704  if (submix->output_mix_config)
3705  print_iamf_param_definition(w, "output_mix_config", submix->output_mix_config,
3706  SECTION_ID_STREAM_GROUP_PIECE);
3707  for (int i = 0; i < submix->nb_layouts; i++) {
3708  const AVIAMFSubmixLayout *layout = submix->layouts[i];
3709  char val_str[128];
3710  writer_print_section_header(w, "IAMF Submix Layout", SECTION_ID_STREAM_GROUP_PIECE);
3711  av_channel_layout_describe(&layout->sound_system, val_str, sizeof(val_str));
3712  print_str("sound_system", val_str);
3713  print_q("integrated_loudness", layout->integrated_loudness, '/');
3714  print_q("digital_peak", layout->digital_peak, '/');
3715  print_q("true_peak", layout->true_peak, '/');
3716  print_q("dialogue_anchored_loudness", layout->dialogue_anchored_loudness, '/');
3717  print_q("album_anchored_loudness", layout->album_anchored_loudness, '/');
3718  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_PIECE
3719  }
3720  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_PIECES
3721  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
3722 }
3723 
3724 static void print_iamf_mix_presentation_params(WriterContext *w, const AVStreamGroup *stg,
3725  const AVIAMFMixPresentation *mix_presentation)
3726 {
3727  writer_print_section_header(w, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
3728  print_int("nb_submixes", mix_presentation->nb_submixes);
3729  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
3730  if (mix_presentation->annotations) {
3731  const AVDictionaryEntry *annotation = NULL;
3732  writer_print_section_header(w, "IAMF Annotations", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3733  while (annotation = av_dict_iterate(mix_presentation->annotations, annotation))
3734  print_str(annotation->key, annotation->value);
3735  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
3736  }
3737  for (int i = 0; i < mix_presentation->nb_submixes; i++)
3738  print_iamf_submix_params(w, mix_presentation->submixes[i]);
3739  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
3740  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_COMPONENT
3741 }
3742 
3743 static void print_stream_group_params(WriterContext *w, AVStreamGroup *stg)
3744 {
3745  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_COMPONENTS);
3746  if (stg->type == AV_STREAM_GROUP_PARAMS_TILE_GRID)
3747  print_tile_grid_params(w, stg, stg->params.tile_grid);
3748  else if (stg->type == AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT)
3749  print_iamf_audio_element_params(w, stg, stg->params.iamf_audio_element);
3750  else if (stg->type == AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION)
3751  print_iamf_mix_presentation_params(w, stg, stg->params.iamf_mix_presentation);
3752  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_COMPONENTS
3753 }
3754 
3755 static int show_stream_group(WriterContext *w, InputFile *ifile, AVStreamGroup *stg)
3756 {
3757  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3758  AVBPrint pbuf;
3759  int i, ret = 0;
3760 
3761  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
3762  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP);
3763  print_int("index", stg->index);
3764  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%"PRIx64, stg->id);
3765  else print_str_opt("id", "N/A");
3766  print_int("nb_streams", stg->nb_streams);
3767  if (stg->type != AV_STREAM_GROUP_PARAMS_NONE)
3768  print_str("type", av_x_if_null(avformat_stream_group_name(stg->type), "unknown"));
3769  else
3770  print_str_opt("type", "unknown");
3771  if (do_show_stream_group_components)
3772  print_stream_group_params(w, stg);
3773 
3774  /* Print disposition information */
3775  if (do_show_stream_group_disposition)
3776  print_dispositions(w, stg->disposition, SECTION_ID_STREAM_GROUP_DISPOSITION);
3777 
3778  if (do_show_stream_group_tags)
3779  ret = show_tags(w, stg->metadata, SECTION_ID_STREAM_GROUP_TAGS);
3780  if (ret < 0)
3781  goto end;
3782 
3783  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_STREAMS);
3784  for (i = 0; i < stg->nb_streams; i++) {
3785  if (selected_streams[stg->streams[i]->index]) {
3786  ret = show_stream(w, fmt_ctx, stg->streams[i]->index, &ifile->streams[stg->streams[i]->index], IN_STREAM_GROUP);
3787  if (ret < 0)
3788  break;
3789  }
3790  }
3791  writer_print_section_footer(w);
3792 
3793 end:
3794  av_bprint_finalize(&pbuf, NULL);
3795  writer_print_section_footer(w);
3796  return ret;
3797 }
3798 
3799 static int show_stream_groups(WriterContext *w, InputFile *ifile)
3800 {
3801  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3802  int i, ret = 0;
3803 
3804  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUPS);
3805  for (i = 0; i < fmt_ctx->nb_stream_groups; i++) {
3806  AVStreamGroup *stg = fmt_ctx->stream_groups[i];
3807 
3808  ret = show_stream_group(w, ifile, stg);
3809  if (ret < 0)
3810  break;
3811  }
3812  writer_print_section_footer(w);
3813  return ret;
3814 }
3815 
3816 static int show_chapters(WriterContext *w, InputFile *ifile)
3817 {
3818  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3819  int i, ret = 0;
3820 
3821  writer_print_section_header(w, NULL, SECTION_ID_CHAPTERS);
3822  for (i = 0; i < fmt_ctx->nb_chapters; i++) {
3823  AVChapter *chapter = fmt_ctx->chapters[i];
3824 
3825  writer_print_section_header(w, NULL, SECTION_ID_CHAPTER);
3826  print_int("id", chapter->id);
3827  print_q ("time_base", chapter->time_base, '/');
3828  print_int("start", chapter->start);
3829  print_time("start_time", chapter->start, &chapter->time_base);
3830  print_int("end", chapter->end);
3831  print_time("end_time", chapter->end, &chapter->time_base);
3832  if (do_show_chapter_tags)
3833  ret = show_tags(w, chapter->metadata, SECTION_ID_CHAPTER_TAGS);
3834  writer_print_section_footer(w);
3835  }
3836  writer_print_section_footer(w);
3837 
3838  return ret;
3839 }
3840 
3841 static int show_format(WriterContext *w, InputFile *ifile)
3842 {
3843  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3844  char val_str[128];
3845  int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
3846  int ret = 0;
3847 
3848  writer_print_section_header(w, NULL, SECTION_ID_FORMAT);
3849  print_str_validate("filename", fmt_ctx->url);
3850  print_int("nb_streams", fmt_ctx->nb_streams);
3851  print_int("nb_programs", fmt_ctx->nb_programs);
3852  print_int("nb_stream_groups", fmt_ctx->nb_stream_groups);
3853  print_str("format_name", fmt_ctx->iformat->name);
3854  if (!do_bitexact) {
3855  if (fmt_ctx->iformat->long_name) print_str ("format_long_name", fmt_ctx->iformat->long_name);
3856  else print_str_opt("format_long_name", "unknown");
3857  }
3858  print_time("start_time", fmt_ctx->start_time, &AV_TIME_BASE_Q);
3859  print_time("duration", fmt_ctx->duration, &AV_TIME_BASE_Q);
3860  if (size >= 0) print_val ("size", size, unit_byte_str);
3861  else print_str_opt("size", "N/A");
3862  if (fmt_ctx->bit_rate > 0) print_val ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
3863  else print_str_opt("bit_rate", "N/A");
3864  print_int("probe_score", fmt_ctx->probe_score);
3865  if (do_show_format_tags)
3866  ret = show_tags(w, fmt_ctx->metadata, SECTION_ID_FORMAT_TAGS);
3867 
3868  writer_print_section_footer(w);
3869  fflush(stdout);
3870  return ret;
3871 }
3872 
3873 static void show_error(WriterContext *w, int err)
3874 {
3875  writer_print_section_header(w, NULL, SECTION_ID_ERROR);
3876  print_int("code", err);
3877  print_str("string", av_err2str(err));
3878  writer_print_section_footer(w);
3879 }
3880 
3881 static int open_input_file(InputFile *ifile, const char *filename,
3882  const char *print_filename)
3883 {
3884  int err, i;
3885  AVFormatContext *fmt_ctx = NULL;
3886  const AVDictionaryEntry *t = NULL;
3887  int scan_all_pmts_set = 0;
3888 
3889  fmt_ctx = avformat_alloc_context();
3890  if (!fmt_ctx)
3891  return AVERROR(ENOMEM);
3892 
3893  if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
3894  av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
3895  scan_all_pmts_set = 1;
3896  }
3897  if ((err = avformat_open_input(&fmt_ctx, filename,
3898  iformat, &format_opts)) < 0) {
3899  print_error(filename, err);
3900  return err;
3901  }
3902  if (print_filename) {
3903  av_freep(&fmt_ctx->url);
3904  fmt_ctx->url = av_strdup(print_filename);
3905  }
3906  ifile->fmt_ctx = fmt_ctx;
3907  if (scan_all_pmts_set)
3908  av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
3909  while ((t = av_dict_iterate(format_opts, t)))
3910  av_log(NULL, AV_LOG_WARNING, "Option %s skipped - not known to demuxer.\n", t->key);
3911 
3912  if (find_stream_info) {
3913  AVDictionary **opts;
3914  int orig_nb_streams = fmt_ctx->nb_streams;
3915 
3916  err = setup_find_stream_info_opts(fmt_ctx, codec_opts, &opts);
3917  if (err < 0)
3918  return err;
3919 
3920  err = avformat_find_stream_info(fmt_ctx, opts);
3921 
3922  for (i = 0; i < orig_nb_streams; i++)
3923  av_dict_free(&opts[i]);
3924  av_freep(&opts);
3925 
3926  if (err < 0) {
3927  print_error(filename, err);
3928  return err;
3929  }
3930  }
3931 
3932  av_dump_format(fmt_ctx, 0, filename, 0);
3933 
3934  ifile->streams = av_calloc(fmt_ctx->nb_streams, sizeof(*ifile->streams));
3935  if (!ifile->streams)
3936  exit(1);
3937  ifile->nb_streams = fmt_ctx->nb_streams;
3938 
3939  /* bind a decoder to each input stream */
3940  for (i = 0; i < fmt_ctx->nb_streams; i++) {
3941  InputStream *ist = &ifile->streams[i];
3942  AVStream *stream = fmt_ctx->streams[i];
3943  const AVCodec *codec;
3944 
3945  ist->st = stream;
3946 
3947  if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
3948  av_log(NULL, AV_LOG_WARNING,
3949  "Failed to probe codec for input stream %d\n",
3950  stream->index);
3951  continue;
3952  }
3953 
3954  codec = avcodec_find_decoder(stream->codecpar->codec_id);
3955  if (!codec) {
3956  av_log(NULL, AV_LOG_WARNING,
3957  "Unsupported codec with id %d for input stream %d\n",
3958  stream->codecpar->codec_id, stream->index);
3959  continue;
3960  }
3961  {
3962  AVDictionary *opts;
3963 
3964  err = filter_codec_opts(codec_opts, stream->codecpar->codec_id,
3965  fmt_ctx, stream, codec, &opts, NULL);
3966  if (err < 0)
3967  exit(1);
3968 
3969  ist->dec_ctx = avcodec_alloc_context3(codec);
3970  if (!ist->dec_ctx)
3971  exit(1);
3972 
3973  err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
3974  if (err < 0)
3975  exit(1);
3976 
3977  if (do_show_log) {
3978  // For loging it is needed to disable at least frame threads as otherwise
3979  // the log information would need to be reordered and matches up to contexts and frames
3980  // That is in fact possible but not trivial
3981  av_dict_set(&codec_opts, "threads", "1", 0);
3982  }
3983 
3984  av_dict_set(&opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
3985 
3986  ist->dec_ctx->pkt_timebase = stream->time_base;
3987 
3988  if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
3989  av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
3990  stream->index);
3991  exit(1);
3992  }
3993 
3994  if ((t = av_dict_iterate(opts, NULL))) {
3995  av_log(NULL, AV_LOG_ERROR, "Option %s for input stream %d not found\n",
3996  t->key, stream->index);
3997  return AVERROR_OPTION_NOT_FOUND;
3998  }
3999  }
4000  }
4001 
4002  ifile->fmt_ctx = fmt_ctx;
4003  return 0;
4004 }
4005 
4006 static void close_input_file(InputFile *ifile)
4007 {
4008  int i;
4009 
4010  /* close decoder for each stream */
4011  for (i = 0; i < ifile->nb_streams; i++)
4012  avcodec_free_context(&ifile->streams[i].dec_ctx);
4013 
4014  av_freep(&ifile->streams);
4015  ifile->nb_streams = 0;
4016 
4017  avformat_close_input(&ifile->fmt_ctx);
4018 }
4019 
4020 static int probe_file(WriterContext *wctx, const char *filename,
4021  const char *print_filename)
4022 {
4023  InputFile ifile = { 0 };
4024  int ret, i;
4025  int section_id;
4026 
4027  do_analyze_frames = do_analyze_frames && do_show_streams;
4028  do_read_frames = do_show_frames || do_count_frames || do_analyze_frames;
4029  do_read_packets = do_show_packets || do_count_packets;
4030 
4031  ret = open_input_file(&ifile, filename, print_filename);
4032  if (ret < 0)
4033  goto end;
4034 
4035 #define CHECK_END if (ret < 0) goto end
4036 
4037  nb_streams = ifile.fmt_ctx->nb_streams;
4038  REALLOCZ_ARRAY_STREAM(nb_streams_frames,0,ifile.fmt_ctx->nb_streams);
4039  REALLOCZ_ARRAY_STREAM(nb_streams_packets,0,ifile.fmt_ctx->nb_streams);
4040  REALLOCZ_ARRAY_STREAM(selected_streams,0,ifile.fmt_ctx->nb_streams);
4041  REALLOCZ_ARRAY_STREAM(streams_with_closed_captions,0,ifile.fmt_ctx->nb_streams);
4042  REALLOCZ_ARRAY_STREAM(streams_with_film_grain,0,ifile.fmt_ctx->nb_streams);
4043 
4044  for (i = 0; i < ifile.fmt_ctx->nb_streams; i++) {
4045  if (stream_specifier) {
4046  ret = avformat_match_stream_specifier(ifile.fmt_ctx,
4047  ifile.fmt_ctx->streams[i],
4048  stream_specifier);
4049  CHECK_END;
4050  else
4051  selected_streams[i] = ret;
4052  ret = 0;
4053  } else {
4054  selected_streams[i] = 1;
4055  }
4056  if (!selected_streams[i])
4057  ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
4058  }
4059 
4060  if (do_read_frames || do_read_packets) {
4061  if (do_show_frames && do_show_packets &&
4062  wctx->writer->flags & WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER)
4063  section_id = SECTION_ID_PACKETS_AND_FRAMES;
4064  else if (do_show_packets && !do_show_frames)
4065  section_id = SECTION_ID_PACKETS;
4066  else // (!do_show_packets && do_show_frames)
4067  section_id = SECTION_ID_FRAMES;
4068  if (do_show_frames || do_show_packets)
4069  writer_print_section_header(wctx, NULL, section_id);
4070  ret = read_packets(wctx, &ifile);
4071  if (do_show_frames || do_show_packets)
4072  writer_print_section_footer(wctx);
4073  CHECK_END;
4074  }
4075 
4076  if (do_show_programs) {
4077  ret = show_programs(wctx, &ifile);
4078  CHECK_END;
4079  }
4080 
4081  if (do_show_stream_groups) {
4082  ret = show_stream_groups(wctx, &ifile);
4083  CHECK_END;
4084  }
4085 
4086  if (do_show_streams) {
4087  ret = show_streams(wctx, &ifile);
4088  CHECK_END;
4089  }
4090  if (do_show_chapters) {
4091  ret = show_chapters(wctx, &ifile);
4092  CHECK_END;
4093  }
4094  if (do_show_format) {
4095  ret = show_format(wctx, &ifile);
4096  CHECK_END;
4097  }
4098 
4099 end:
4100  if (ifile.fmt_ctx)
4101  close_input_file(&ifile);
4102  av_freep(&nb_streams_frames);
4103  av_freep(&nb_streams_packets);
4104  av_freep(&selected_streams);
4105  av_freep(&streams_with_closed_captions);
4106  av_freep(&streams_with_film_grain);
4107 
4108  return ret;
4109 }
4110 
4111 static void show_usage(void)
4112 {
4113  av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
4114  av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] INPUT_FILE\n", program_name);
4115  av_log(NULL, AV_LOG_INFO, "\n");
4116 }
4117 
4118 static void ffprobe_show_program_version(WriterContext *w)
4119 {
4120  AVBPrint pbuf;
4121  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
4122 
4123  writer_print_section_header(w, NULL, SECTION_ID_PROGRAM_VERSION);
4124  print_str("version", FFMPEG_VERSION);
4125  print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
4126  program_birth_year, CONFIG_THIS_YEAR);
4127  print_str("compiler_ident", CC_IDENT);
4128  print_str("configuration", FFMPEG_CONFIGURATION);
4129  writer_print_section_footer(w);
4130 
4131  av_bprint_finalize(&pbuf, NULL);
4132 }
4133 
4134 #define SHOW_LIB_VERSION(libname, LIBNAME) \
4135  do { \
4136  if (CONFIG_##LIBNAME) { \
4137  unsigned int version = libname##_version(); \
4138  writer_print_section_header(w, NULL, SECTION_ID_LIBRARY_VERSION); \
4139  print_str("name", "lib" #libname); \
4140  print_int("major", LIB##LIBNAME##_VERSION_MAJOR); \
4141  print_int("minor", LIB##LIBNAME##_VERSION_MINOR); \
4142  print_int("micro", LIB##LIBNAME##_VERSION_MICRO); \
4143  print_int("version", version); \
4144  print_str("ident", LIB##LIBNAME##_IDENT); \
4145  writer_print_section_footer(w); \
4146  } \
4147  } while (0)
4148 
4149 static void ffprobe_show_library_versions(WriterContext *w)
4150 {
4151  writer_print_section_header(w, NULL, SECTION_ID_LIBRARY_VERSIONS);
4152  SHOW_LIB_VERSION(avutil, AVUTIL);
4153  SHOW_LIB_VERSION(avcodec, AVCODEC);
4154  SHOW_LIB_VERSION(avformat, AVFORMAT);
4155  SHOW_LIB_VERSION(avdevice, AVDEVICE);
4156  SHOW_LIB_VERSION(avfilter, AVFILTER);
4157  SHOW_LIB_VERSION(swscale, SWSCALE);
4158  SHOW_LIB_VERSION(swresample, SWRESAMPLE);
4159  SHOW_LIB_VERSION(postproc, POSTPROC);
4160  writer_print_section_footer(w);
4161 }
4162 
4163 #define PRINT_PIX_FMT_FLAG(flagname, name) \
4164  do { \
4165  print_int(name, !!(pixdesc->flags & AV_PIX_FMT_FLAG_##flagname)); \
4166  } while (0)
4167 
4168 static void ffprobe_show_pixel_formats(WriterContext *w)
4169 {
4170  const AVPixFmtDescriptor *pixdesc = NULL;
4171  int i, n;
4172 
4173  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMATS);
4174  while (pixdesc = av_pix_fmt_desc_next(pixdesc)) {
4175  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT);
4176  print_str("name", pixdesc->name);
4177  print_int("nb_components", pixdesc->nb_components);
4178  if ((pixdesc->nb_components >= 3) && !(pixdesc->flags & AV_PIX_FMT_FLAG_RGB)) {
4179  print_int ("log2_chroma_w", pixdesc->log2_chroma_w);
4180  print_int ("log2_chroma_h", pixdesc->log2_chroma_h);
4181  } else {
4182  print_str_opt("log2_chroma_w", "N/A");
4183  print_str_opt("log2_chroma_h", "N/A");
4184  }
4185  n = av_get_bits_per_pixel(pixdesc);
4186  if (n) print_int ("bits_per_pixel", n);
4187  else print_str_opt("bits_per_pixel", "N/A");
4188  if (do_show_pixel_format_flags) {
4189  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT_FLAGS);
4190  PRINT_PIX_FMT_FLAG(BE, "big_endian");
4191  PRINT_PIX_FMT_FLAG(PAL, "palette");
4192  PRINT_PIX_FMT_FLAG(BITSTREAM, "bitstream");
4193  PRINT_PIX_FMT_FLAG(HWACCEL, "hwaccel");
4194  PRINT_PIX_FMT_FLAG(PLANAR, "planar");
4195  PRINT_PIX_FMT_FLAG(RGB, "rgb");
4196  PRINT_PIX_FMT_FLAG(ALPHA, "alpha");
4197  writer_print_section_footer(w);
4198  }
4199  if (do_show_pixel_format_components && (pixdesc->nb_components > 0)) {
4200  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT_COMPONENTS);
4201  for (i = 0; i < pixdesc->nb_components; i++) {
4202  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT_COMPONENT);
4203  print_int("index", i + 1);
4204  print_int("bit_depth", pixdesc->comp[i].depth);
4205  writer_print_section_footer(w);
4206  }
4207  writer_print_section_footer(w);
4208  }
4209  writer_print_section_footer(w);
4210  }
4211  writer_print_section_footer(w);
4212 }
4213 
4214 static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
4215 {
4216  if (!av_strcasecmp(arg, "always")) show_optional_fields = SHOW_OPTIONAL_FIELDS_ALWAYS;
4217  else if (!av_strcasecmp(arg, "never")) show_optional_fields = SHOW_OPTIONAL_FIELDS_NEVER;
4218  else if (!av_strcasecmp(arg, "auto")) show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
4219 
4220  if (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO && av_strcasecmp(arg, "auto")) {
4221  double num;
4222  int ret = parse_number("show_optional_fields", arg, OPT_TYPE_INT,
4223  SHOW_OPTIONAL_FIELDS_AUTO, SHOW_OPTIONAL_FIELDS_ALWAYS, &num);
4224  if (ret < 0)
4225  return ret;
4226  show_optional_fields = num;
4227  }
4228  return 0;
4229 }
4230 
4231 static int opt_format(void *optctx, const char *opt, const char *arg)
4232 {
4233  iformat = av_find_input_format(arg);
4234  if (!iformat) {
4235  av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
4236  return AVERROR(EINVAL);
4237  }
4238  return 0;
4239 }
4240 
4241 static inline void mark_section_show_entries(SectionID section_id,
4242  int show_all_entries, AVDictionary *entries)
4243 {
4244  struct section *section = &sections[section_id];
4245 
4246  section->show_all_entries = show_all_entries;
4247  if (show_all_entries) {
4248  for (const SectionID *id = section->children_ids; *id != -1; id++)
4249  mark_section_show_entries(*id, show_all_entries, entries);
4250  } else {
4251  av_dict_copy(&section->entries_to_show, entries, 0);
4252  }
4253 }
4254 
4255 static int match_section(const char *section_name,
4256  int show_all_entries, AVDictionary *entries)
4257 {
4258  int i, ret = 0;
4259 
4260  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) {
4261  const struct section *section = &sections[i];
4262  if (!strcmp(section_name, section->name) ||
4263  (section->unique_name && !strcmp(section_name, section->unique_name))) {
4264  av_log(NULL, AV_LOG_DEBUG,
4265  "'%s' matches section with unique name '%s'\n", section_name,
4266  (char *)av_x_if_null(section->unique_name, section->name));
4267  ret++;
4268  mark_section_show_entries(section->id, show_all_entries, entries);
4269  }
4270  }
4271  return ret;
4272 }
4273 
4274 static int opt_show_entries(void *optctx, const char *opt, const char *arg)
4275 {
4276  const char *p = arg;
4277  int ret = 0;
4278 
4279  while (*p) {
4280  AVDictionary *entries = NULL;
4281  char *section_name = av_get_token(&p, "=:");
4282  int show_all_entries = 0;
4283 
4284  if (!section_name) {
4285  av_log(NULL, AV_LOG_ERROR,
4286  "Missing section name for option '%s'\n", opt);
4287  return AVERROR(EINVAL);
4288  }
4289 
4290  if (*p == '=') {
4291  p++;
4292  while (*p && *p != ':') {
4293  char *entry = av_get_token(&p, ",:");
4294  if (!entry)
4295  break;
4296  av_log(NULL, AV_LOG_VERBOSE,
4297  "Adding '%s' to the entries to show in section '%s'\n",
4298  entry, section_name);
4299  av_dict_set(&entries, entry, "", AV_DICT_DONT_STRDUP_KEY);
4300  if (*p == ',')
4301  p++;
4302  }
4303  } else {
4304  show_all_entries = 1;
4305  }
4306 
4307  ret = match_section(section_name, show_all_entries, entries);
4308  if (ret == 0) {
4309  av_log(NULL, AV_LOG_ERROR, "No match for section '%s'\n", section_name);
4310  ret = AVERROR(EINVAL);
4311  }
4312  av_dict_free(&entries);
4313  av_free(section_name);
4314 
4315  if (ret <= 0)
4316  break;
4317  if (*p)
4318  p++;
4319  }
4320 
4321  return ret;
4322 }
4323 
4324 static int opt_input_file(void *optctx, const char *arg)
4325 {
4326  if (input_filename) {
4327  av_log(NULL, AV_LOG_ERROR,
4328  "Argument '%s' provided as input filename, but '%s' was already specified.\n",
4329  arg, input_filename);
4330  return AVERROR(EINVAL);
4331  }
4332  if (!strcmp(arg, "-"))
4333  arg = "fd:";
4334  input_filename = av_strdup(arg);
4335  if (!input_filename)
4336  return AVERROR(ENOMEM);
4337 
4338  return 0;
4339 }
4340 
4341 static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
4342 {
4343  opt_input_file(optctx, arg);
4344  return 0;
4345 }
4346 
4347 static int opt_output_file_o(void *optctx, const char *opt, const char *arg)
4348 {
4349  if (output_filename) {
4350  av_log(NULL, AV_LOG_ERROR,
4351  "Argument '%s' provided as output filename, but '%s' was already specified.\n",
4352  arg, output_filename);
4353  return AVERROR(EINVAL);
4354  }
4355  if (!strcmp(arg, "-"))
4356  arg = "fd:";
4357  output_filename = av_strdup(arg);
4358  if (!output_filename)
4359  return AVERROR(ENOMEM);
4360 
4361  return 0;
4362 }
4363 
4364 static int opt_print_filename(void *optctx, const char *opt, const char *arg)
4365 {
4366  av_freep(&print_input_filename);
4367  print_input_filename = av_strdup(arg);
4368  return print_input_filename ? 0 : AVERROR(ENOMEM);
4369 }
4370 
4371 void show_help_default(const char *opt, const char *arg)
4372 {
4373  av_log_set_callback(log_callback_help);
4374  show_usage();
4375  show_help_options(options, "Main options:", 0, 0);
4376  printf("\n");
4377 
4378  show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
4379  show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
4380 }
4381 
4382 /**
4383  * Parse interval specification, according to the format:
4384  * INTERVAL ::= [START|+START_OFFSET][%[END|+END_OFFSET]]
4385  * INTERVALS ::= INTERVAL[,INTERVALS]
4386 */
4387 static int parse_read_interval(const char *interval_spec,
4388  ReadInterval *interval)
4389 {
4390  int ret = 0;
4391  char *next, *p, *spec = av_strdup(interval_spec);
4392  if (!spec)
4393  return AVERROR(ENOMEM);
4394 
4395  if (!*spec) {
4396  av_log(NULL, AV_LOG_ERROR, "Invalid empty interval specification\n");
4397  ret = AVERROR(EINVAL);
4398  goto end;
4399  }
4400 
4401  p = spec;
4402  next = strchr(spec, '%');
4403  if (next)
4404  *next++ = 0;
4405 
4406  /* parse first part */
4407  if (*p) {
4408  interval->has_start = 1;
4409 
4410  if (*p == '+') {
4411  interval->start_is_offset = 1;
4412  p++;
4413  } else {
4414  interval->start_is_offset = 0;
4415  }
4416 
4417  ret = av_parse_time(&interval->start, p, 1);
4418  if (ret < 0) {
4419  av_log(NULL, AV_LOG_ERROR, "Invalid interval start specification '%s'\n", p);
4420  goto end;
4421  }
4422  } else {
4423  interval->has_start = 0;
4424  }
4425 
4426  /* parse second part */
4427  p = next;
4428  if (p && *p) {
4429  int64_t us;
4430  interval->has_end = 1;
4431 
4432  if (*p == '+') {
4433  interval->end_is_offset = 1;
4434  p++;
4435  } else {
4436  interval->end_is_offset = 0;
4437  }
4438 
4439  if (interval->end_is_offset && *p == '#') {
4440  long long int lli;
4441  char *tail;
4442  interval->duration_frames = 1;
4443  p++;
4444  lli = strtoll(p, &tail, 10);
4445  if (*tail || lli < 0) {
4446  av_log(NULL, AV_LOG_ERROR,
4447  "Invalid or negative value '%s' for duration number of frames\n", p);
4448  goto end;
4449  }
4450  interval->end = lli;
4451  } else {
4452  interval->duration_frames = 0;
4453  ret = av_parse_time(&us, p, 1);
4454  if (ret < 0) {
4455  av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
4456  goto end;
4457  }
4458  interval->end = us;
4459  }
4460  } else {
4461  interval->has_end = 0;
4462  }
4463 
4464 end:
4465  av_free(spec);
4466  return ret;
4467 }
4468 
4469 static int parse_read_intervals(const char *intervals_spec)
4470 {
4471  int ret, n, i;
4472  char *p, *spec = av_strdup(intervals_spec);
4473  if (!spec)
4474  return AVERROR(ENOMEM);
4475 
4476  /* preparse specification, get number of intervals */
4477  for (n = 0, p = spec; *p; p++)
4478  if (*p == ',')
4479  n++;
4480  n++;
4481 
4482  read_intervals = av_malloc_array(n, sizeof(*read_intervals));
4483  if (!read_intervals) {
4484  ret = AVERROR(ENOMEM);
4485  goto end;
4486  }
4487  read_intervals_nb = n;
4488 
4489  /* parse intervals */
4490  p = spec;
4491  for (i = 0; p; i++) {
4492  char *next;
4493 
4494  av_assert0(i < read_intervals_nb);
4495  next = strchr(p, ',');
4496  if (next)
4497  *next++ = 0;
4498 
4499  read_intervals[i].id = i;
4500  ret = parse_read_interval(p, &read_intervals[i]);
4501  if (ret < 0) {
4502  av_log(NULL, AV_LOG_ERROR, "Error parsing read interval #%d '%s'\n",
4503  i, p);
4504  goto end;
4505  }
4506  av_log(NULL, AV_LOG_VERBOSE, "Parsed log interval ");
4507  log_read_interval(&read_intervals[i], NULL, AV_LOG_VERBOSE);
4508  p = next;
4509  }
4510  av_assert0(i == read_intervals_nb);
4511 
4512 end:
4513  av_free(spec);
4514  return ret;
4515 }
4516 
4517 static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
4518 {
4519  return parse_read_intervals(arg);
4520 }
4521 
4522 static int opt_pretty(void *optctx, const char *opt, const char *arg)
4523 {
4524  show_value_unit = 1;
4525  use_value_prefix = 1;
4526  use_byte_value_binary_prefix = 1;
4527  use_value_sexagesimal_format = 1;
4528  return 0;
4529 }
4530 
4531 static void print_section(SectionID id, int level)
4532 {
4533  const SectionID *pid;
4534  const struct section *section = &sections[id];
4535  printf("%c%c%c%c",
4536  section->flags & SECTION_FLAG_IS_WRAPPER ? 'W' : '.',
4537  section->flags & SECTION_FLAG_IS_ARRAY ? 'A' : '.',
4538  section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS ? 'V' : '.',
4539  section->flags & SECTION_FLAG_HAS_TYPE ? 'T' : '.');
4540  printf("%*c %s", level * 4, ' ', section->name);
4541  if (section->unique_name)
4542  printf("/%s", section->unique_name);
4543  printf("\n");
4544 
4545  for (pid = section->children_ids; *pid != -1; pid++)
4546  print_section(*pid, level+1);
4547 }
4548 
4549 static int opt_sections(void *optctx, const char *opt, const char *arg)
4550 {
4551  printf("Sections:\n"
4552  "W... = Section is a wrapper (contains other sections, no local entries)\n"
4553  ".A.. = Section contains an array of elements of the same type\n"
4554  "..V. = Section may contain a variable number of fields with variable keys\n"
4555  "...T = Section contain a unique type\n"
4556  "FLAGS NAME/UNIQUE_NAME\n"
4557  "----\n");
4558  print_section(SECTION_ID_ROOT, 0);
4559  return 0;
4560 }
4561 
4562 static int opt_show_versions(void *optctx, const char *opt, const char *arg)
4563 {
4564  mark_section_show_entries(SECTION_ID_PROGRAM_VERSION, 1, NULL);
4565  mark_section_show_entries(SECTION_ID_LIBRARY_VERSION, 1, NULL);
4566  return 0;
4567 }
4568 
4569 #define DEFINE_OPT_SHOW_SECTION(section, target_section_id) \
4570  static int opt_show_##section(void *optctx, const char *opt, const char *arg) \
4571  { \
4572  mark_section_show_entries(SECTION_ID_##target_section_id, 1, NULL); \
4573  return 0; \
4574  }
4575 
4576 DEFINE_OPT_SHOW_SECTION(chapters, CHAPTERS)
4577 DEFINE_OPT_SHOW_SECTION(error, ERROR)
4578 DEFINE_OPT_SHOW_SECTION(format, FORMAT)
4579 DEFINE_OPT_SHOW_SECTION(frames, FRAMES)
4580 DEFINE_OPT_SHOW_SECTION(library_versions, LIBRARY_VERSIONS)
4581 DEFINE_OPT_SHOW_SECTION(packets, PACKETS)
4582 DEFINE_OPT_SHOW_SECTION(pixel_formats, PIXEL_FORMATS)
4583 DEFINE_OPT_SHOW_SECTION(program_version, PROGRAM_VERSION)
4584 DEFINE_OPT_SHOW_SECTION(streams, STREAMS)
4585 DEFINE_OPT_SHOW_SECTION(programs, PROGRAMS)
4586 DEFINE_OPT_SHOW_SECTION(stream_groups, STREAM_GROUPS)
4587 
4588 static const OptionDef real_options[] = {
4589  CMDUTILS_COMMON_OPTIONS
4590  { "f", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_format}, "force format", "format" },
4591  { "unit", OPT_TYPE_BOOL, 0, {&show_value_unit}, "show unit of the displayed values" },
4592  { "prefix", OPT_TYPE_BOOL, 0, {&use_value_prefix}, "use SI prefixes for the displayed values" },
4593  { "byte_binary_prefix", OPT_TYPE_BOOL, 0, {&use_byte_value_binary_prefix},
4594  "use binary prefixes for byte units" },
4595  { "sexagesimal", OPT_TYPE_BOOL, 0, {&use_value_sexagesimal_format},
4596  "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
4597  { "pretty", OPT_TYPE_FUNC, 0, {.func_arg = opt_pretty},
4598  "prettify the format of displayed values, make it more human readable" },
4599  { "output_format", OPT_TYPE_STRING, 0, { &output_format },
4600  "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
4601  { "print_format", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format (deprecated)" },
4602  { "of", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format", "format" },
4603  { "select_streams", OPT_TYPE_STRING, 0, { &stream_specifier }, "select the specified streams", "stream_specifier" },
4604  { "sections", OPT_TYPE_FUNC, OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
4605  { "show_data", OPT_TYPE_BOOL, 0, { &do_show_data }, "show packets data" },
4606  { "show_data_hash", OPT_TYPE_STRING, 0, { &show_data_hash }, "show packets data hash" },
4607  { "show_error", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_error }, "show probing error" },
4608  { "show_format", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_format }, "show format/container info" },
4609  { "show_frames", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_frames }, "show frames info" },
4610  { "show_entries", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_show_entries},
4611  "show a set of specified entries", "entry_list" },
4612 #if HAVE_THREADS
4613  { "show_log", OPT_TYPE_INT, 0, { &do_show_log }, "show log" },
4614 #endif
4615  { "show_packets", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_packets }, "show packets info" },
4616  { "show_programs", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_programs }, "show programs info" },
4617  { "show_stream_groups", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_stream_groups }, "show stream groups info" },
4618  { "show_streams", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_streams }, "show streams info" },
4619  { "show_chapters", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_chapters }, "show chapters info" },
4620  { "count_frames", OPT_TYPE_BOOL, 0, { &do_count_frames }, "count the number of frames per stream" },
4621  { "count_packets", OPT_TYPE_BOOL, 0, { &do_count_packets }, "count the number of packets per stream" },
4622  { "show_program_version", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" },
4623  { "show_library_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_library_versions }, "show library versions" },
4624  { "show_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_versions }, "show program and library versions" },
4625  { "show_pixel_formats", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" },
4626  { "show_optional_fields", OPT_TYPE_FUNC, OPT_FUNC_ARG, { .func_arg = &opt_show_optional_fields }, "show optional fields" },
4627  { "show_private_data", OPT_TYPE_BOOL, 0, { &show_private_data }, "show private data" },
4628  { "private", OPT_TYPE_BOOL, 0, { &show_private_data }, "same as show_private_data" },
4629  { "analyze_frames", OPT_TYPE_BOOL, 0, { &do_analyze_frames }, "analyze frames to provide additional stream-level information" },
4630  { "bitexact", OPT_TYPE_BOOL, 0, {&do_bitexact}, "force bitexact output" },
4631  { "read_intervals", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
4632  { "i", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
4633  { "o", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_output_file_o}, "write to specified output", "output_file"},
4634  { "print_filename", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"},
4635  { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT, { &find_stream_info },
4636  "read and decode the streams to fill missing information with heuristics" },
4637  { NULL, },
4638 };
4639 
4640 static inline int check_section_show_entries(int section_id)
4641 {
4642  struct section *section = &sections[section_id];
4643  if (sections[section_id].show_all_entries || sections[section_id].entries_to_show)
4644  return 1;
4645  for (const SectionID *id = section->children_ids; *id != -1; id++)
4646  if (check_section_show_entries(*id))
4647  return 1;
4648  return 0;
4649 }
4650 
4651 #define SET_DO_SHOW(id, varname) do { \
4652  if (check_section_show_entries(SECTION_ID_##id)) \
4653  do_show_##varname = 1; \
4654  } while (0)
4655 
4656 int main(int argc, char **argv)
4657 {
4658  const Writer *w;
4659  WriterContext *wctx;
4660  char *buf;
4661  char *w_name = NULL, *w_args = NULL;
4662  int ret, input_ret, i;
4663 
4664  init_dynload();
4665 
4666 #if HAVE_THREADS
4667  ret = pthread_mutex_init(&log_mutex, NULL);
4668  if (ret != 0) {
4669  goto end;
4670  }
4671 #endif
4672  av_log_set_flags(AV_LOG_SKIP_REPEATED);
4673 
4674  options = real_options;
4675  parse_loglevel(argc, argv, options);
4676  avformat_network_init();
4677 #if CONFIG_AVDEVICE
4678  avdevice_register_all();
4679 #endif
4680 
4681  show_banner(argc, argv, options);
4682  ret = parse_options(NULL, argc, argv, options, opt_input_file);
4683  if (ret < 0) {
4684  ret = (ret == AVERROR_EXIT) ? 0 : ret;
4685  goto end;
4686  }
4687 
4688  if (do_show_log)
4689  av_log_set_callback(log_callback);
4690 
4691  /* mark things to show, based on -show_entries */
4692  SET_DO_SHOW(CHAPTERS, chapters);
4693  SET_DO_SHOW(ERROR, error);
4694  SET_DO_SHOW(FORMAT, format);
4695  SET_DO_SHOW(FRAMES, frames);
4696  SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
4697  SET_DO_SHOW(PACKETS, packets);
4698  SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
4699  SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
4700  SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
4701  SET_DO_SHOW(PROGRAM_VERSION, program_version);
4702  SET_DO_SHOW(PROGRAMS, programs);
4703  SET_DO_SHOW(STREAM_GROUP_DISPOSITION, stream_group_disposition);
4704  SET_DO_SHOW(STREAM_GROUPS, stream_groups);
4705  SET_DO_SHOW(STREAM_GROUP_COMPONENTS, stream_group_components);
4706  SET_DO_SHOW(STREAMS, streams);
4707  SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
4708  SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
4709  SET_DO_SHOW(STREAM_GROUP_STREAM_DISPOSITION, stream_disposition);
4710 
4711  SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
4712  SET_DO_SHOW(FORMAT_TAGS, format_tags);
4713  SET_DO_SHOW(FRAME_TAGS, frame_tags);
4714  SET_DO_SHOW(PROGRAM_TAGS, program_tags);
4715  SET_DO_SHOW(STREAM_GROUP_TAGS, stream_group_tags);
4716  SET_DO_SHOW(STREAM_TAGS, stream_tags);
4717  SET_DO_SHOW(PROGRAM_STREAM_TAGS, stream_tags);
4718  SET_DO_SHOW(STREAM_GROUP_STREAM_TAGS, stream_tags);
4719  SET_DO_SHOW(PACKET_TAGS, packet_tags);
4720 
4721  if (do_bitexact && (do_show_program_version || do_show_library_versions)) {
4722  av_log(NULL, AV_LOG_ERROR,
4723  "-bitexact and -show_program_version or -show_library_versions "
4724  "options are incompatible\n");
4725  ret = AVERROR(EINVAL);
4726  goto end;
4727  }
4728 
4729  writer_register_all();
4730 
4731  if (!output_format)
4732  output_format = av_strdup("default");
4733  if (!output_format) {
4734  ret = AVERROR(ENOMEM);
4735  goto end;
4736  }
4737  w_name = av_strtok(output_format, "=", &buf);
4738  if (!w_name) {
4739  av_log(NULL, AV_LOG_ERROR,
4740  "No name specified for the output format\n");
4741  ret = AVERROR(EINVAL);
4742  goto end;
4743  }
4744  w_args = buf;
4745 
4746  if (show_data_hash) {
4747  if ((ret = av_hash_alloc(&hash, show_data_hash)) < 0) {
4748  if (ret == AVERROR(EINVAL)) {
4749  const char *n;
4750  av_log(NULL, AV_LOG_ERROR,
4751  "Unknown hash algorithm '%s'\nKnown algorithms:",
4752  show_data_hash);
4753  for (i = 0; (n = av_hash_names(i)); i++)
4754  av_log(NULL, AV_LOG_ERROR, " %s", n);
4755  av_log(NULL, AV_LOG_ERROR, "\n");
4756  }
4757  goto end;
4758  }
4759  }
4760 
4761  w = writer_get_by_name(w_name);
4762  if (!w) {
4763  av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
4764  ret = AVERROR(EINVAL);
4765  goto end;
4766  }
4767 
4768  if ((ret = writer_open(&wctx, w, w_args,
4769  sections, FF_ARRAY_ELEMS(sections), output_filename)) >= 0) {
4770  if (w == &xml_writer)
4771  wctx->string_validation_utf8_flags |= AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES;
4772 
4773  writer_print_section_header(wctx, NULL, SECTION_ID_ROOT);
4774 
4775  if (do_show_program_version)
4776  ffprobe_show_program_version(wctx);
4777  if (do_show_library_versions)
4778  ffprobe_show_library_versions(wctx);
4779  if (do_show_pixel_formats)
4780  ffprobe_show_pixel_formats(wctx);
4781 
4782  if (!input_filename &&
4783  ((do_show_format || do_show_programs || do_show_stream_groups || do_show_streams || do_show_chapters || do_show_packets || do_show_error) ||
4784  (!do_show_program_version && !do_show_library_versions && !do_show_pixel_formats))) {
4785  show_usage();
4786  av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
4787  av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
4788  ret = AVERROR(EINVAL);
4789  } else if (input_filename) {
4790  ret = probe_file(wctx, input_filename, print_input_filename);
4791  if (ret < 0 && do_show_error)
4792  show_error(wctx, ret);
4793  }
4794 
4795  input_ret = ret;
4796 
4797  writer_print_section_footer(wctx);
4798  ret = writer_close(&wctx);
4799  if (ret < 0)
4800  av_log(NULL, AV_LOG_ERROR, "Writing output failed: %s\n", av_err2str(ret));
4801 
4802  ret = FFMIN(ret, input_ret);
4803  }
4804 
4805 end:
4806  av_freep(&output_format);
4807  av_freep(&output_filename);
4808  av_freep(&input_filename);
4809  av_freep(&print_input_filename);
4810  av_freep(&read_intervals);
4811  av_hash_freep(&hash);
4812 
4813  uninit_opts();
4814  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
4815  av_dict_free(&(sections[i].entries_to_show));
4816 
4817  avformat_network_deinit();
4818 
4819 #if HAVE_THREADS
4820  pthread_mutex_destroy(&log_mutex);
4821 #endif
4822 
4823  return ret < 0;
4824 }
compact_print_section_header
static void compact_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c:1288
AVStreamGroup::params
union AVStreamGroup::@366 params
Group type-specific parameters.
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
flat_escape_key_str
static const char * flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
Definition: ffprobe.c:1452
main
int main(int argc, char **argv)
Definition: ffprobe.c:4656
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
AVSubtitle
Definition: avcodec.h:2257
SECTION_ID_STREAM_SIDE_DATA_LIST
@ SECTION_ID_STREAM_SIDE_DATA_LIST
Definition: ffprobe.c:237
opt_format
static int opt_format(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4231
AVHDRVividColorTransformParams::maximum_maxrgb
AVRational maximum_maxrgb
Indicates the maximum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:260
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
clear_log
static void clear_log(int need_lock)
Definition: ffprobe.c:2716
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
iamf.h
AVHDRPlusColorTransformParams::average_maxrgb
AVRational average_maxrgb
The average of linearized maxRGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:164
mark_section_show_entries
static void mark_section_show_entries(SectionID section_id, int show_all_entries, AVDictionary *entries)
Definition: ffprobe.c:4241
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:105
RGB
Definition: cms.c:66
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:203
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:107
AVCodec
AVCodec.
Definition: codec.h:187
writer_get_by_name
static const Writer * writer_get_by_name(const char *name)
Definition: ffprobe.c:1061
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:368
AVDynamicHDRPlus::params
AVHDRPlusColorTransformParams params[3]
The color transform parameters for every processing window.
Definition: hdr_dynamic_metadata.h:264
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVIAMFSubmix::elements
AVIAMFSubmixElement ** elements
Array of submix elements.
Definition: iamf.h:565
flat_options
static const AVOption flat_options[]
Definition: ffprobe.c:1428
WriterContext::section_pbuf
AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]
generic print buffer dedicated to each section, used by various writers
Definition: ffprobe.c:568
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVIAMFAudioElement::nb_layers
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
Definition: iamf.h:368
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AVDOVIDataMapping::nlq_method_idc
enum AVDOVINLQMethod nlq_method_idc
Definition: dovi_meta.h:159
use_byte_value_binary_prefix
static int use_byte_value_binary_prefix
Definition: ffprobe.c:142
WriterContext::level
int level
current level, starting from 0
Definition: ffprobe.c:561
WriterContext::string_validation
int string_validation
Definition: ffprobe.c:575
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:69
AVFormatContext::stream_groups
AVStreamGroup ** stream_groups
A list of all stream groups in the file.
Definition: avformat.h:1387
MAX_REGISTERED_WRITERS_NB
#define MAX_REGISTERED_WRITERS_NB
Definition: ffprobe.c:1046
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
entry
#define entry
Definition: aom_film_grain_template.c:66
AVHDRVividColorToneMappingParams::base_param_k2
int base_param_k2
indicates k2_0 in the base parameter, base_param_k2 <= 1: k2_0 = base_param_k2 base_param_k2 > 1: res...
Definition: hdr_dynamic_vivid_metadata.h:137
level
uint8_t level
Definition: svq3.c:205
do_show_log
static int do_show_log
Definition: ffprobe.c:130
AVStreamGroup::id
int64_t id
Group type-specific group ID.
Definition: avformat.h:1153
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
av_clip
#define av_clip
Definition: common.h:100
InputFile::fmt_ctx
AVFormatContext * fmt_ctx
Definition: ffprobe.c:98
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:1678
writer_print_integer
static void writer_print_integer(WriterContext *wctx, const char *key, int64_t val)
Definition: ffprobe.c:831
dec_ctx
static AVCodecContext * dec_ctx
Definition: decode_filter_audio.c:47
SECTION_MAX_NB_LEVELS
#define SECTION_MAX_NB_LEVELS
Definition: ffprobe.c:544
SECTION_ID_STREAM_SIDE_DATA
@ SECTION_ID_STREAM_SIDE_DATA
Definition: ffprobe.c:238
AVIAMFSubmix::layouts
AVIAMFSubmixLayout ** layouts
Array of submix layouts.
Definition: iamf.h:580
do_show_frame_tags
static int do_show_frame_tags
Definition: ffprobe.c:134
AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: packet.h:327
mix
static int mix(int c0, int c1)
Definition: 4xm.c:716
PLANAR
#define PLANAR
Definition: flacdsp.c:42
show_stream_groups
static int show_stream_groups(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3799
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1263
r
const char * r
Definition: vf_curves.c:127
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
unit_value::i
int64_t i
Definition: ffprobe.c:457
opt_show_optional_fields
static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4214
SECTION_ID_NONE
@ SECTION_ID_NONE
Definition: ffprobe.c:173
opt.h
FrameData::pkt_pos
int64_t pkt_pos
Definition: ffplay.c:148
read_intervals_nb
static int read_intervals_nb
Definition: ffprobe.c:164
opt_output_file_o
static int opt_output_file_o(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4347
show_stream_group
static int show_stream_group(WriterContext *w, InputFile *ifile, AVStreamGroup *stg)
Definition: ffprobe.c:3755
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVStreamGroup::tile_grid
struct AVStreamGroupTileGrid * tile_grid
Definition: avformat.h:1169
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:477
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:98
ReadInterval::end_is_offset
int end_is_offset
Definition: ffprobe.c:159
LogBuffer::log_message
char * log_message
Definition: ffprobe.c:398
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:611
libm.h
FrameData
Definition: ffmpeg.h:655
AVHDRVividColorToneMappingParams::base_param_Delta
AVRational base_param_Delta
base_param_Delta in the base parameter, in multiples of 1.0/127.
Definition: hdr_dynamic_vivid_metadata.h:157
show_streams
static int show_streams(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3502
AVFilmGrainParams::bit_depth_luma
int bit_depth_luma
Intended bit depth, or 0 for unknown/unspecified.
Definition: film_grain_params.h:287
Writer::name
const char * name
Definition: ffprobe.c:531
writer_put_str_printf
static void writer_put_str_printf(WriterContext *wctx, const char *str)
Definition: ffprobe.c:673
AVHDRVividColorToneMappingParams::base_enable_flag
int base_enable_flag
This flag indicates that transfer the base paramter(for value of 1)
Definition: hdr_dynamic_vivid_metadata.h:88
print_str
#define print_str(k, v)
Definition: ffprobe.c:2020
LogBuffer::context_name
char * context_name
Definition: ffprobe.c:396
color
Definition: vf_paletteuse.c:513
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
default_print_int
static void default_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1165
AV_HASH_MAX_SIZE
#define AV_HASH_MAX_SIZE
Maximum value that av_hash_get_size() will currently return.
Definition: hash.h:156
AVHDRPlusColorTransformParams::rotation_angle
uint8_t rotation_angle
The clockwise rotation angle in degree of arc with respect to the positive direction of the x-axis of...
Definition: hdr_dynamic_metadata.h:118
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
print_val
#define print_val(k, v, u)
Definition: ffprobe.c:2027
AV_PKT_DATA_FRAME_CROPPING
@ AV_PKT_DATA_FRAME_CROPPING
The number of pixels to discard from the top/bottom/left/right border of the decoded frame to obtain ...
Definition: packet.h:340
compact_print_section_footer
static void compact_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1340
SECTION_ID_PACKET_SIDE_DATA_LIST
@ SECTION_ID_PACKET_SIDE_DATA_LIST
Definition: ffprobe.c:199
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1400
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVHDRPlusPercentile::percentile
AVRational percentile
The linearized maxRGB value at a specific percentile in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:52
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:221
AVAmbientViewingEnvironment
Ambient viewing environment metadata as defined by H.274.
Definition: ambient_viewing_environment.h:36
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
AVIAMFAudioElement::default_w
unsigned int default_w
Default weight value as defined in section 3.6 of IAMF.
Definition: iamf.h:393
Writer::init
int(* init)(WriterContext *wctx)
Definition: ffprobe.c:533
thread.h
value_string
static char * value_string(char *buf, int buf_size, struct unit_value uv)
Definition: ffprobe.c:461
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
read_packets
static int read_packets(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3244
AVStreamGroupTileGrid::horizontal_offset
int horizontal_offset
Offset in pixels from the left edge of the canvas where the actual image meant for presentation start...
Definition: avformat.h:1054
AVIAMFAudioElement::layers
AVIAMFLayer ** layers
Definition: iamf.h:359
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:202
pthread_mutex_init
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:219
AVCodecDescriptor::long_name
const char * long_name
A more descriptive name for this codec.
Definition: codec_desc.h:50
AV_DOVI_COMPRESSION_LIMITED
@ AV_DOVI_COMPRESSION_LIMITED
Definition: dovi_meta.h:69
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
json_print_section_header
static void json_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c:1696
show_packet
static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
Definition: ffprobe.c:2767
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:601
CompactContext::print_section
int print_section
Definition: ffprobe.c:1241
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
version.h
AVHDRVividColorToneMappingParams::three_Spline_num
int three_Spline_num
The number of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:169
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
Writer::print_section_footer
void(* print_section_footer)(WriterContext *wctx)
Definition: ffprobe.c:537
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
int64_t
long long int64_t
Definition: coverity.c:34
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
selected_streams
static int * selected_streams
Definition: ffprobe.c:388
SECTION_ID_PROGRAM_TAGS
@ SECTION_ID_PROGRAM_TAGS
Definition: ffprobe.c:211
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2261
AVFilmGrainAOMParams::uv_points
uint8_t uv_points[2][10][2]
Definition: film_grain_params.h:63
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse
uint16_t semimajor_axis_external_ellipse
The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:134
AVFilmGrainH274Params::blending_mode_id
int blending_mode_id
Specifies the blending mode used to blend the simulated film grain with the decoded images.
Definition: film_grain_params.h:182
AVIAMFMixPresentation::nb_submixes
unsigned int nb_submixes
Number of submixes in the presentation.
Definition: iamf.h:629
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:201
AVStreamGroup::disposition
int disposition
Stream group disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1211
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
DefaultContext
Definition: ffprobe.c:1088
AVHDRVividColorTransformParams::tone_mapping_param_num
int tone_mapping_param_num
The number of tone mapping param.
Definition: hdr_dynamic_vivid_metadata.h:272
Writer::priv_class
const AVClass * priv_class
private class of the writer, if any
Definition: ffprobe.c:529
AVHDRPlusColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for SMPTE 2094-40.
Definition: hdr_dynamic_metadata.h:59
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:356
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
WriterContext::section
const struct section * section[SECTION_MAX_NB_LEVELS]
section per each level
Definition: ffprobe.c:567
json_escape_str
static const char * json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
Definition: ffprobe.c:1674
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:260
print_ts
#define print_ts(k, v)
Definition: ffprobe.c:2024
opt_input_file_i
static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4341
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:573
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:403
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1368
writer_put_str
#define writer_put_str(wctx_, str_)
Definition: ffprobe.c:1043
Writer::print_integer
void(* print_integer)(WriterContext *wctx, const char *, int64_t)
Definition: ffprobe.c:538
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
w
uint8_t w
Definition: llviddspenc.c:38
validate_string
static int validate_string(WriterContext *wctx, char **dstp, const char *src)
Definition: ffprobe.c:842
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:233
AVHDRVividColorTransformParams::variance_maxrgb
AVRational variance_maxrgb
Indicates the variance brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:253
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:558
flat_print_section_header
static void flat_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c:1485
SECTION_ID_STREAM_GROUP_COMPONENTS
@ SECTION_ID_STREAM_GROUP_COMPONENTS
Definition: ffprobe.c:217
AVDOVIReshapingCurve::mmr_coef
int64_t mmr_coef[AV_DOVI_MAX_PIECES][3][7]
Definition: dovi_meta.h:127
SECTION_ID_FRAME_SIDE_DATA_COMPONENT
@ SECTION_ID_FRAME_SIDE_DATA_COMPONENT
Definition: ffprobe.c:188
AVIAMFParamDefinition::type
enum AVIAMFParamDefinitionType type
Parameters type.
Definition: iamf.h:213
parse_number
int parse_number(const char *context, const char *numstr, enum OptionType type, double min, double max, double *dst)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:84
SECTION_ID_PIXEL_FORMAT_COMPONENTS
@ SECTION_ID_PIXEL_FORMAT_COMPONENTS
Definition: ffprobe.c:204
AVDynamicHDRPlus::num_cols_targeted_system_display_actual_peak_luminance
uint8_t num_cols_targeted_system_display_actual_peak_luminance
The number of columns in the targeted_system_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:290
AVPacket::data
uint8_t * data
Definition: packet.h:539
ReadInterval::duration_frames
int duration_frames
Definition: ffprobe.c:160
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
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:40
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:70
AVAmbientViewingEnvironment::ambient_light_x
AVRational ambient_light_x
Normalized x chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:47
AVHDRVivid3SplineParams::enable_strength
AVRational enable_strength
3Spline_enable_Strength of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:70
json_print_int
static void json_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1782
AVOption
AVOption.
Definition: opt.h:429
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
SECTION_ID_STREAM
@ SECTION_ID_STREAM
Definition: ffprobe.c:233
section::element_name
const char * element_name
name of the contained element, if provided
Definition: ffprobe.c:254
SECTION_ID_PIXEL_FORMAT_FLAGS
@ SECTION_ID_PIXEL_FORMAT_FLAGS
Definition: ffprobe.c:202
LogBuffer
Definition: ffprobe.c:395
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
AVStreamGroupTileGrid::vertical_offset
int vertical_offset
Offset in pixels from the top edge of the canvas where the actual image meant for presentation starts...
Definition: avformat.h:1061
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1262
data
const char data[16]
Definition: mxf.c:149
avio_open
int avio_open(AVIOContext **s, const char *filename, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: avio.c:497
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:3177
print_dovi_metadata
static void print_dovi_metadata(WriterContext *w, const AVDOVIMetadata *dovi)
Definition: ffprobe.c:2064
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
AV_DOVI_NLQ_NONE
@ AV_DOVI_NLQ_NONE
Definition: dovi_meta.h:131
print_iamf_submix_params
static void print_iamf_submix_params(WriterContext *w, const AVIAMFSubmix *submix)
Definition: ffprobe.c:3677
XMLContext::within_tag
int within_tag
Definition: ffprobe.c:1815
SECTION_MAX_NB_CHILDREN
#define SECTION_MAX_NB_CHILDREN
Definition: ffprobe.c:170
AVFilmGrainParams::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:282
do_show_stream_tags
static int do_show_stream_tags
Definition: ffprobe.c:137
ini_escape_str
static char * ini_escape_str(AVBPrint *dst, const char *src)
Definition: ffprobe.c:1558
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:120
print_section_header
#define print_section_header(s)
Definition: ffprobe.c:2034
SECTION_ID_PIXEL_FORMAT
@ SECTION_ID_PIXEL_FORMAT
Definition: ffprobe.c:201
writer_printf_printf
static void writer_printf_printf(WriterContext *wctx, const char *fmt,...)
Definition: ffprobe.c:678
version.h
AVHDRPlusColorTransformParams::tone_mapping_flag
uint8_t tone_mapping_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_metadata.h:189
streams_with_closed_captions
static int * streams_with_closed_captions
Definition: ffprobe.c:389
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
SECTION_ID_PROGRAM_STREAM
@ SECTION_ID_PROGRAM_STREAM
Definition: ffprobe.c:210
category
category
Definition: openal-dec.c:249
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1501
OFFSET
#define OFFSET(x)
Definition: ffprobe.c:1822
SECTION_ID_FORMAT
@ SECTION_ID_FORMAT
Definition: ffprobe.c:178
show_help_children
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:140
AVIAMFParamDefinition
Parameters as defined in section 3.6.1 of IAMF.
Definition: iamf.h:193
AVOption::flags
int flags
A combination of AV_OPT_FLAG_*.
Definition: opt.h:472
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:85
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:3122
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
SECTION_ID_STREAM_GROUP_SUBCOMPONENT
@ SECTION_ID_STREAM_GROUP_SUBCOMPONENT
Definition: ffprobe.c:220
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
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:68
check_section_show_entries
static int check_section_show_entries(int section_id)
Definition: ffprobe.c:4640
AVStereo3D::baseline
uint32_t baseline
The distance between the centres of the lenses of the camera system, in micrometers.
Definition: stereo3d.h:228
print_section
static void print_section(SectionID id, int level)
Definition: ffprobe.c:4531
AVIAMFSubmixElement::default_mix_gain
AVRational default_mix_gain
Default mix gain value to apply when there are no AVIAMFParamDefinition with element_mix_config's par...
Definition: iamf.h:469
AVHDRVivid3SplineParams::th_mode
int th_mode
The mode of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:35
section::id
int id
unique id identifying a section
Definition: ffprobe.c:243
AVHDRPlusColorTransformParams::distribution_maxrgb
AVHDRPlusPercentile distribution_maxrgb[15]
The linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:176
AVDictionary
Definition: dict.c:34
writer_options
static const AVOption writer_options[]
Definition: ffprobe.c:588
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:586
AVStreamGroupTileGrid::vertical
int vertical
Offset in pixels from the top edge of the canvas where the tile should be placed.
Definition: avformat.h:1036
SECTION_ID_STREAM_GROUP_BLOCKS
@ SECTION_ID_STREAM_GROUP_BLOCKS
Definition: ffprobe.c:225
AVDOVIRpuDataHeader::rpu_format
uint16_t rpu_format
Definition: dovi_meta.h:89
DefaultContext::nokey
int nokey
Definition: ffprobe.c:1090
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:442
do_show_stream_group_components
static int do_show_stream_group_components
Definition: ffprobe.c:120
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1547
writer_register_all
static void writer_register_all(void)
Definition: ffprobe.c:1983
AVDOVIDataMapping::mapping_color_space
uint8_t mapping_color_space
Definition: dovi_meta.h:154
CompactContext
Definition: ffprobe.c:1236
AVDOVIRpuDataHeader
Dolby Vision RPU data header.
Definition: dovi_meta.h:87
AVHDRPlusColorTransformParams::knee_point_x
AVRational knee_point_x
The x coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:196
output_filename
static const char * output_filename
Definition: ffprobe.c:362
AVHDRVividColorTransformParams::color_saturation_num
int color_saturation_num
The number of color saturation param.
Definition: hdr_dynamic_vivid_metadata.h:289
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
dec_val
double dec_val
Definition: ffprobe.c:368
show_tags
static int show_tags(WriterContext *w, AVDictionary *tags, int section_id)
Definition: ffprobe.c:2046
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:394
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
AVFilmGrainParams::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:281
do_show_format_tags
static int do_show_format_tags
Definition: ffprobe.c:133
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:75
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:250
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3567
ini_print_section_header
static void ini_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c:1585
hdr_dynamic_vivid_metadata.h
print_film_grain_params
static void print_film_grain_params(WriterContext *w, const AVFilmGrainParams *fgp)
Definition: ffprobe.c:2406
section::unique_name
const char * unique_name
unique section name, in case the name is ambiguous
Definition: ffprobe.c:255
Writer::print_string
void(* print_string)(WriterContext *wctx, const char *, const char *)
Definition: ffprobe.c:540
do_show_frames
static int do_show_frames
Definition: ffprobe.c:116
xml_print_section_header
static void xml_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c:1857
OptionDef
Definition: cmdutils.h:191
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:206
compact_init
static av_cold int compact_init(WriterContext *wctx)
Definition: ffprobe.c:1266
print_dispositions
static void print_dispositions(WriterContext *w, uint32_t disposition, SectionID section_id)
Definition: ffprobe.c:3264
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:560
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:667
xml_print_section_footer
static void xml_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1903
SECTION_ID_FRAME_TAGS
@ SECTION_ID_FRAME_TAGS
Definition: ffprobe.c:182
ReadInterval::id
int id
identifier
Definition: ffprobe.c:156
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
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:280
AVDOVIRpuDataHeader::coef_data_type
uint8_t coef_data_type
Definition: dovi_meta.h:93
do_show_library_versions
static int do_show_library_versions
Definition: ffprobe.c:126
AVStereo3D::horizontal_field_of_view
AVRational horizontal_field_of_view
Horizontal field of view, in degrees.
Definition: stereo3d.h:239
process_frame
static av_always_inline int process_frame(WriterContext *w, InputFile *ifile, AVFrame *frame, const AVPacket *pkt, int *packet_new)
Definition: ffprobe.c:3022
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
InputStream
Definition: ffmpeg.h:434
writer_print_data
static void writer_print_data(WriterContext *wctx, const char *name, const uint8_t *data, int size)
Definition: ffprobe.c:973
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:366
AVPacketSideData::size
size_t size
Definition: packet.h:392
match_section
static int match_section(const char *section_name, int show_all_entries, AVDictionary *entries)
Definition: ffprobe.c:4255
print_iamf_param_definition
static void print_iamf_param_definition(WriterContext *w, const char *name, const AVIAMFParamDefinition *param, SectionID section_id)
Definition: ffprobe.c:3591
SECTION_FLAG_HAS_TYPE
#define SECTION_FLAG_HAS_TYPE
For these sections the element_name field is mandatory.
Definition: ffprobe.c:250
AVHDRPlusColorTransformParams::color_saturation_mapping_flag
uint8_t color_saturation_mapping_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:222
INIContext
Definition: ffprobe.c:1542
unit_hertz_str
static const char unit_hertz_str[]
Definition: ffprobe.c:381
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:374
xml_print_value
static void xml_print_value(WriterContext *wctx, const char *key, const char *str, int64_t num, const int is_int)
Definition: ffprobe.c:1920
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:203
writer_close
static int writer_close(WriterContext **wctx)
Definition: ffprobe.c:617
SHOW_OPTIONAL_FIELDS_NEVER
#define SHOW_OPTIONAL_FIELDS_NEVER
Definition: ffprobe.c:147
SECTION_ID_STREAMS
@ SECTION_ID_STREAMS
Definition: ffprobe.c:235
AVHDRVividColorToneMappingParams::three_Spline_enable_flag
int three_Spline_enable_flag
indicates 3Spline_enable_flag in the base parameter, This flag indicates that transfer three Spline o...
Definition: hdr_dynamic_vivid_metadata.h:163
writer_print_data_hash
static void writer_print_data_hash(WriterContext *wctx, const char *name, const uint8_t *data, int size)
Definition: ffprobe.c:1001
show_optional_fields
static int show_optional_fields
Definition: ffprobe.c:149
json_print_section_footer
static void json_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1735
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3546
SECTION_ID_STREAM_GROUP
@ SECTION_ID_STREAM_GROUP
Definition: ffprobe.c:216
AVHDRPlusColorTransformParams::center_of_ellipse_x
uint16_t center_of_ellipse_x
The x coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:102
opt_pretty
static int opt_pretty(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4522
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
json_options
static const AVOption json_options[]
Definition: ffprobe.c:1656
default_options
static const AVOption default_options[]
Definition: ffprobe.c:1098
fail
#define fail()
Definition: checkasm.h:193
writer_get_name
static const char * writer_get_name(void *p)
Definition: ffprobe.c:580
AVHDRVividColorTransformParams::tm_params
AVHDRVividColorToneMappingParams tm_params[2]
The color tone mapping parameters.
Definition: hdr_dynamic_vivid_metadata.h:277
av_hash_get_name
const char * av_hash_get_name(const AVHashContext *ctx)
Definition: hash.c:104
AV_DOVI_COMPRESSION_EXTENDED
@ AV_DOVI_COMPRESSION_EXTENDED
Definition: dovi_meta.h:71
LogBuffer::log_level
int log_level
Definition: ffprobe.c:397
AVStreamGroupTileGrid
AVStreamGroupTileGrid holds information on how to combine several independent images on a single canv...
Definition: avformat.h:987
AVFilmGrainAOMParams::grain_scale_shift
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
Definition: film_grain_params.h:99
print_chroma_location
static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
Definition: ffprobe.c:2706
AVDOVIRpuDataHeader::el_bit_depth
uint8_t el_bit_depth
Definition: dovi_meta.h:98
AVHDRVivid3SplineParams::th_delta1
AVRational th_delta1
3Spline_TH_Delta1 of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:56
Writer::uninit
void(* uninit)(WriterContext *wctx)
Definition: ffprobe.c:534
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:248
AVIAMFSubmixLayout
Submix layout as defined in section 3.7.6 of IAMF.
Definition: iamf.h:514
avformat_stream_group_name
const char * avformat_stream_group_name(enum AVStreamGroupParamsType type)
Definition: avformat.c:335
AVDOVIDecoderConfigurationRecord::dv_md_compression
uint8_t dv_md_compression
Definition: dovi_meta.h:64
json_writer
static const Writer json_writer
Definition: ffprobe.c:1799
ALPHA
@ ALPHA
Definition: drawutils.c:33
AVStreamGroupTileGrid::coded_width
int coded_width
Width of the canvas.
Definition: avformat.h:1002
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:729
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
AVDynamicHDRVivid::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_vivid_metadata.h:320
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
AVChapter
Definition: avformat.h:1259
print_tile_grid_params
static void print_tile_grid_params(WriterContext *w, const AVStreamGroup *stg, const AVStreamGroupTileGrid *tile_grid)
Definition: ffprobe.c:3568
val
static double val(void *priv, double ch)
Definition: aeval.c:77
json_init
static av_cold int json_init(WriterContext *wctx)
Definition: ffprobe.c:1664
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffprobe.c:4371
AVStreamGroupTileGrid::coded_height
int coded_height
Width of the canvas.
Definition: avformat.h:1008
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:1190
pts
static int64_t pts
Definition: transcode_aac.c:644
SECTION_ID_FRAME_SIDE_DATA_PIECE
@ SECTION_ID_FRAME_SIDE_DATA_PIECE
Definition: ffprobe.c:190
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:647
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
show_log
static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
Definition: ffprobe.c:2732
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:807
AVAmbientViewingEnvironment::ambient_illuminance
AVRational ambient_illuminance
Environmental illuminance of the ambient viewing environment in lux.
Definition: ambient_viewing_environment.h:40
input_filename
static const char * input_filename
Definition: ffprobe.c:359
print_duration_ts
#define print_duration_ts(k, v)
Definition: ffprobe.c:2026
AVFilmGrainAOMParams::num_y_points
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
Definition: film_grain_params.h:49
AVIAMFAudioElement::audio_element_type
enum AVIAMFAudioElementType audio_element_type
Audio element type as defined in section 3.6 of IAMF.
Definition: iamf.h:388
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
streams_with_film_grain
static int * streams_with_film_grain
Definition: ffprobe.c:390
AVIAMFReconGain
Recon Gain Info Parameter Data as defined in section 3.8.3 of IAMF.
Definition: iamf.h:148
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:551
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:205
InputFile
Definition: ffmpeg.h:468
AVHDRPlusColorTransformParams::knee_point_y
AVRational knee_point_y
The y coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:203
AVDOVIRpuDataHeader::vdr_rpu_normalized_idc
uint8_t vdr_rpu_normalized_idc
Definition: dovi_meta.h:95
AVDOVIRpuDataHeader::el_spatial_resampling_filter_flag
uint8_t el_spatial_resampling_filter_flag
Definition: dovi_meta.h:101
do_read_packets
static int do_read_packets
Definition: ffprobe.c:112
AVFilmGrainAOMParams
This structure describes how to handle film grain synthesis for AOM codecs.
Definition: film_grain_params.h:44
AVHDRPlusColorTransformParams::num_bezier_curve_anchors
uint8_t num_bezier_curve_anchors
The number of the intermediate anchor parameters of the tone mapping function in the processing windo...
Definition: hdr_dynamic_metadata.h:209
av_stereo3d_view_name
const char * av_stereo3d_view_name(unsigned int view)
Provide a human-readable name of a given stereo3d view.
Definition: stereo3d.c:113
opt_read_intervals
static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4517
AVFilmGrainH274Params::intensity_interval_upper_bound
uint8_t intensity_interval_upper_bound[3][256]
Specifies the upper bound of each intensity interval for which the set of model values applies for th...
Definition: film_grain_params.h:216
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
AV_PKT_DATA_WEBVTT_SETTINGS
@ AV_PKT_DATA_WEBVTT_SETTINGS
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:199
AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
Subblocks are of struct type AVIAMFReconGain.
Definition: iamf.h:181
close_input_file
static void close_input_file(InputFile *ifile)
Definition: ffprobe.c:4006
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:151
parse_read_intervals
static int parse_read_intervals(const char *intervals_spec)
Definition: ffprobe.c:4469
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1442
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, const AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:983
json_print_item_str
static void json_print_item_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1757
default_writer
static const Writer default_writer
Definition: ffprobe.c:1174
AVIAMFSubmixElement::annotations
AVDictionary * annotations
A dictionary of strings describing the submix in different languages.
Definition: iamf.h:490
AVFilmGrainParams::bit_depth_chroma
int bit_depth_chroma
Definition: film_grain_params.h:288
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:947
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2934
do_show_error
static int do_show_error
Definition: ffprobe.c:114
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
CHECK_END
#define CHECK_END
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1535
film_grain_params.h
AVFrameSideData::size
size_t size
Definition: frame.h:268
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:548
av_cold
#define av_cold
Definition: attributes.h:90
AVDOVIRpuDataHeader::chroma_resampling_explicit_filter_flag
uint8_t chroma_resampling_explicit_filter_flag
Definition: dovi_meta.h:92
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:595
print_iamf_audio_element_params
static void print_iamf_audio_element_params(WriterContext *w, const AVStreamGroup *stg, const AVIAMFAudioElement *audio_element)
Definition: ffprobe.c:3646
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:845
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
nb_streams_frames
static uint64_t * nb_streams_frames
Definition: ffprobe.c:387
AVFilmGrainParams::width
int width
Intended display resolution.
Definition: film_grain_params.h:269
AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES
#define AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES
Within AV_ESCAPE_MODE_XML, additionally escape double quotes for double quoted attributes.
Definition: avstring.h:348
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:654
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:216
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:62
postprocess.h
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:653
SECTION_ID_STREAM_GROUP_STREAMS
@ SECTION_ID_STREAM_GROUP_STREAMS
Definition: ffprobe.c:227
av_log_format_line
void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix)
Format a line of log the same way as the default callback.
Definition: log.c:335
SECTION_ID_FORMAT_TAGS
@ SECTION_ID_FORMAT_TAGS
Definition: ffprobe.c:179
AVDOVIRpuDataHeader::vdr_bit_depth
uint8_t vdr_bit_depth
Definition: dovi_meta.h:99
Writer::print_rational
void(* print_rational)(WriterContext *wctx, AVRational *q, char *sep)
Definition: ffprobe.c:539
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1126
AVDOVIRpuDataHeader::rpu_type
uint8_t rpu_type
Definition: dovi_meta.h:88
initialized
static int initialized
Definition: vaapi_transcode.c:43
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
av_packet_side_data_name
const char * av_packet_side_data_name(enum AVPacketSideDataType type)
Definition: packet.c:270
do_count_frames
static int do_count_frames
Definition: ffprobe.c:109
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1262
writer_child_next
static void * writer_child_next(void *obj, void *prev)
Definition: ffprobe.c:601
print_section_footer
#define print_section_footer(s)
Definition: ffprobe.c:2036
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:337
ReadInterval::end
int64_t end
start, end in second/AV_TIME_BASE units
Definition: ffprobe.c:157
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:3095
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVDOVIReshapingCurve::mmr_order
uint8_t mmr_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:125
AVHDRPlusColorTransformParams::semiminor_axis_external_ellipse
uint16_t semiminor_axis_external_ellipse
The semi-minor axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:141
unit_bit_per_second_str
static const char unit_bit_per_second_str[]
Definition: ffprobe.c:383
show_program
static int show_program(WriterContext *w, InputFile *ifile, AVProgram *program)
Definition: ffprobe.c:3519
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
xml_options
static const AVOption xml_options[]
Definition: ffprobe.c:1824
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:1500
AVHDRPlusColorTransformParams::window_upper_left_corner_y
AVRational window_upper_left_corner_y
The relative y coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:76
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1312
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1401
AVHDRPlusColorTransformParams::window_lower_right_corner_x
AVRational window_lower_right_corner_x
The relative x coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:85
SECTION_ID_SUBTITLE
@ SECTION_ID_SUBTITLE
Definition: ffprobe.c:239
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVDOVIRpuDataHeader::spatial_resampling_filter_flag
uint8_t spatial_resampling_filter_flag
Definition: dovi_meta.h:100
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_iamf_param_definition_get_subblock
static av_always_inline void * av_iamf_param_definition_get_subblock(const AVIAMFParamDefinition *par, unsigned int idx)
Get the subblock at the specified.
Definition: iamf.h:260
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:119
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:114
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:178
AVDynamicHDRPlus::targeted_system_display_maximum_luminance
AVRational targeted_system_display_maximum_luminance
The nominal maximum display luminance of the targeted system display, in units of 0....
Definition: hdr_dynamic_metadata.h:271
get_frame_side_data_type
static const char * get_frame_side_data_type(const void *data)
Definition: ffprobe.c:267
CompactContext::item_sep
char item_sep
Definition: ffprobe.c:1239
print_fmt
#define print_fmt(k, f,...)
Definition: ffprobe.c:2000
FlatContext
Definition: ffprobe.c:1418
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
Definition: avcodec.c:717
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVIAMFSubmixElement::headphones_rendering_mode
enum AVIAMFHeadphonesMode headphones_rendering_mode
A value that indicates whether the referenced channel-based Audio Element shall be rendered to stereo...
Definition: iamf.h:478
xml_print_str
static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1962
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
do_show_stream_group_tags
static int do_show_stream_group_tags
Definition: ffprobe.c:136
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1145
probe_file
static int probe_file(WriterContext *wctx, const char *filename, const char *print_filename)
Definition: ffprobe.c:4020
AVDynamicHDRPlus::mastering_display_actual_peak_luminance_flag
uint8_t mastering_display_actual_peak_luminance_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:303
JSON_INDENT
#define JSON_INDENT()
Definition: ffprobe.c:1694
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1593
WriterContext::writer_w8
void(* writer_w8)(WriterContext *wctx, int b)
Definition: ffprobe.c:551
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
section::show_all_entries
int show_all_entries
Definition: ffprobe.c:258
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:58
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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: avformat.c:739
flat_print_str
static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1516
get_raw_string_type
static const char * get_raw_string_type(const void *data)
Definition: ffprobe.c:273
SECTION_ID_ROOT
@ SECTION_ID_ROOT
Definition: ffprobe.c:232
AVIAMFLayer::ch_layout
AVChannelLayout ch_layout
Definition: iamf.h:297
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:111
nb_streams
static int nb_streams
Definition: ffprobe.c:385
ffprobe_show_program_version
static void ffprobe_show_program_version(WriterContext *w)
Definition: ffprobe.c:4118
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
IN_STREAM_GROUP
#define IN_STREAM_GROUP
Definition: ffprobe.c:3277
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2263
pixel_formats
static enum AVPixelFormat pixel_formats[]
Definition: vf_sr.c:64
do_show_chapter_tags
static int do_show_chapter_tags
Definition: ffprobe.c:132
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
do_show_pixel_format_components
static int do_show_pixel_format_components
Definition: ffprobe.c:129
AV_DOVI_MAPPING_POLYNOMIAL
@ AV_DOVI_MAPPING_POLYNOMIAL
Definition: dovi_meta.h:108
CompactContext::nested_section
int nested_section[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1244
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1310
SECTION_ID_STREAM_GROUP_SUBPIECE
@ SECTION_ID_STREAM_GROUP_SUBPIECE
Definition: ffprobe.c:224
flat_writer
static const Writer flat_writer
Definition: ffprobe.c:1529
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
AVFilmGrainH274Params::comp_model_value
int16_t comp_model_value[3][256][6]
Specifies the model values for the component for each intensity interval.
Definition: film_grain_params.h:227
key
const char * key
Definition: hwcontext_opencl.c:189
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
color_range
color_range
Definition: vf_selectivecolor.c:43
flat_escape_value_str
static const char * flat_escape_value_str(AVBPrint *dst, const char *src)
Definition: ffprobe.c:1467
InputStream::dec_ctx
AVCodecContext * dec_ctx
Definition: ffprobe.c:94
do_show_chapters
static int do_show_chapters
Definition: ffprobe.c:113
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
AV_FILM_GRAIN_PARAMS_NONE
@ AV_FILM_GRAIN_PARAMS_NONE
Definition: film_grain_params.h:25
AVFormatContext::probe_score
int probe_score
format probing score.
Definition: avformat.h:1768
show_chapters
static int show_chapters(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3816
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:56
av_dovi_get_header
static av_always_inline AVDOVIRpuDataHeader * av_dovi_get_header(const AVDOVIMetadata *data)
Definition: dovi_meta.h:355
AVDOVIReshapingCurve::poly_order
uint8_t poly_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:122
AV_FRAME_DATA_DYNAMIC_HDR_VIVID
@ AV_FRAME_DATA_DYNAMIC_HDR_VIVID
HDR Vivid dynamic metadata associated with a video frame.
Definition: frame.h:215
find_stream_info
static int find_stream_info
Definition: ffprobe.c:166
SECTION_ID_FRAME_LOGS
@ SECTION_ID_FRAME_LOGS
Definition: ffprobe.c:192
arg
const char * arg
Definition: jacosubdec.c:67
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:212
do_show_pixel_format_flags
static int do_show_pixel_format_flags
Definition: ffprobe.c:128
AVHDRPlusPercentile::percentage
uint8_t percentage
The percentage value corresponding to a specific percentile linearized RGB value in the processing wi...
Definition: hdr_dynamic_metadata.h:45
if
if(ret)
Definition: filter_design.txt:179
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:246
section::name
const char * name
Definition: ffprobe.c:244
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:223
AVFilmGrainH274Params::model_id
int model_id
Specifies the film grain simulation mode.
Definition: film_grain_params.h:137
open_input_file
static int open_input_file(InputFile *ifile, const char *filename, const char *print_filename)
Definition: ffprobe.c:3881
AVDOVINLQParams::linear_deadzone_threshold
uint64_t linear_deadzone_threshold
Definition: dovi_meta.h:144
InputFile::streams
InputStream * streams
Definition: ffprobe.c:100
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:3486
ReadInterval::start
int64_t start
Definition: ffprobe.c:157
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
print_int
#define print_int(k, v)
Definition: ffprobe.c:2018
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
init_dynload
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:75
opts
AVDictionary * opts
Definition: movenc.c:51
read_intervals
static ReadInterval * read_intervals
Definition: ffprobe.c:163
AVIAMFDemixingInfo
Demixing Info Parameter Data as defined in section 3.8.2 of IAMF.
Definition: iamf.h:128
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
SECTION_ID_STREAM_GROUPS
@ SECTION_ID_STREAM_GROUPS
Definition: ffprobe.c:231
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
WriterContext::avio
AVIOContext * avio
the I/O context used to write
Definition: ffprobe.c:549
AVDynamicHDRPlus::application_version
uint8_t application_version
Application version in the application defining document in ST-2094 suite.
Definition: hdr_dynamic_metadata.h:253
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
ReadInterval::has_end
int has_end
Definition: ffprobe.c:158
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:184
SECTION_ID_FRAME_LOG
@ SECTION_ID_FRAME_LOG
Definition: ffprobe.c:191
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:787
NULL
#define NULL
Definition: coverity.c:32
compact_print_str
static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1350
av_hash_names
const char * av_hash_names(int i)
Get the names of available hash algorithms.
Definition: hash.c:98
print_ambient_viewing_environment
static void print_ambient_viewing_environment(WriterContext *w, const AVAmbientViewingEnvironment *env)
Definition: ffprobe.c:2395
SET_DO_SHOW
#define SET_DO_SHOW(id, varname)
Definition: ffprobe.c:4651
writer_print_section_header
static void writer_print_section_header(WriterContext *wctx, const void *data, int section_id)
Definition: ffprobe.c:789
print_color_range
static void print_color_range(WriterContext *w, enum AVColorRange color_range)
Definition: ffprobe.c:2666
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:59
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffprobe.c:104
compact_writer
static const Writer compact_writer
Definition: ffprobe.c:1373
StringValidation
StringValidation
Definition: ffprobe.c:521
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:63
FlatContext::hierarchical
int hierarchical
Definition: ffprobe.c:1422
InputStream::st
AVStream * st
Definition: ffmpeg.h:442
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
AVHDRVividColorTransformParams::color_saturation_gain
AVRational color_saturation_gain[8]
Indicates the color correction strength parameter.
Definition: hdr_dynamic_vivid_metadata.h:296
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
av_hash_init
void av_hash_init(AVHashContext *ctx)
Initialize or reset a hash context.
Definition: hash.c:151
AV_DOVI_MAPPING_MMR
@ AV_DOVI_MAPPING_MMR
Definition: dovi_meta.h:109
OPT_EXPERT
#define OPT_EXPERT
Definition: cmdutils.h:207
ERROR
static void ERROR(const char *str)
Definition: audio_fifo.c:58
do_read_frames
static int do_read_frames
Definition: ffprobe.c:111
av_bprint_escape
void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, enum AVEscapeMode mode, int flags)
Escape the content in src and append it to dstbuf.
Definition: bprint.c:268
SECTION_ID_LIBRARY_VERSION
@ SECTION_ID_LIBRARY_VERSION
Definition: ffprobe.c:193
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:164
si_prefixes
static const struct @11 si_prefixes[]
hash
static struct AVHashContext * hash
Definition: ffprobe.c:364
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVIAMFParamDefinition::duration
unsigned int duration
The accumulated duration of all blocks in this parameter definition, in units of 1 / parameter_rate.
Definition: iamf.h:231
version.h
SECTION_ID_STREAM_TAGS
@ SECTION_ID_STREAM_TAGS
Definition: ffprobe.c:236
isnan
#define isnan(x)
Definition: libm.h:340
writer_printf
#define writer_printf(wctx_, fmt_,...)
Definition: ffprobe.c:1044
SHOW_OPTIONAL_FIELDS_ALWAYS
#define SHOW_OPTIONAL_FIELDS_ALWAYS
Definition: ffprobe.c:148
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:393
filter_codec_opts
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst, AVDictionary **opts_used)
Filter out options for given codec.
Definition: cmdutils.c:1350
print_q
#define print_q(k, v, s)
Definition: ffprobe.c:2019
AVStereo3D::horizontal_disparity_adjustment
AVRational horizontal_disparity_adjustment
Relative shift of the left and right images, which changes the zero parallax plane.
Definition: stereo3d.h:234
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1342
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:452
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:360
parseutils.h
AVIAMFLayer
A layer defining a Channel Layout in the Audio Element.
Definition: iamf.h:294
SECTION_ID_STREAM_GROUP_PIECE
@ SECTION_ID_STREAM_GROUP_PIECE
Definition: ffprobe.c:222
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:144
AVDynamicHDRVivid
This struct represents dynamic metadata for color volume transform - CUVA 005.1:2021 standard.
Definition: hdr_dynamic_vivid_metadata.h:310
WriterContext::name
char * name
name of this writer instance
Definition: ffprobe.c:555
options
Definition: swscale.c:42
AVHDRVividColorTransformParams::color_saturation_mapping_flag
int color_saturation_mapping_flag
This flag indicates that the metadata for the color saturation mapping in the processing window is pr...
Definition: hdr_dynamic_vivid_metadata.h:283
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3504
AVHDRPlusColorTransformParams::fraction_bright_pixels
AVRational fraction_bright_pixels
The fraction of selected pixels in the image that contains the brightest pixel in the scene.
Definition: hdr_dynamic_metadata.h:183
av_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:592
print_pkt_side_data
static void print_pkt_side_data(WriterContext *w, AVCodecParameters *par, const AVPacketSideData *sd, SectionID id_data)
Definition: ffprobe.c:2531
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:143
xml_init
static av_cold int xml_init(WriterContext *wctx)
Definition: ffprobe.c:1834
WriterContext::sections
const struct section * sections
array containing all sections
Definition: ffprobe.c:558
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
av_hash_update
void av_hash_update(AVHashContext *ctx, const uint8_t *src, size_t len)
Update a hash context with additional data.
Definition: hash.c:172
csv_writer
static const Writer csv_writer
Definition: ffprobe.c:1404
print_color_trc
static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
Definition: ffprobe.c:2696
print_stream_group_params
static void print_stream_group_params(WriterContext *w, AVStreamGroup *stg)
Definition: ffprobe.c:3743
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVFilmGrainParams::subsampling_x
int subsampling_x
Intended subsampling ratio, or 0 for luma-only streams.
Definition: film_grain_params.h:274
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:126
do_show_programs
static int do_show_programs
Definition: ffprobe.c:118
AVHDRPlusColorTransformParams::color_saturation_weight
AVRational color_saturation_weight
The color saturation gain in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:229
AVHDRVividColorTransformParams::tone_mapping_mode_flag
int tone_mapping_mode_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_vivid_metadata.h:266
bin_str
const char * bin_str
Definition: ffprobe.c:369
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:90
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
read_interval_packets
static int read_interval_packets(WriterContext *w, InputFile *ifile, const ReadInterval *interval, int64_t *cur_ts)
Definition: ffprobe.c:3119
real_options
static const OptionDef real_options[]
Definition: ffprobe.c:4588
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:232
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:683
WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER
#define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER
Definition: ffprobe.c:519
AVCodecParameters::level
int level
Definition: codec_par.h:129
WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS
#define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS
Definition: ffprobe.c:518
swresample.h
index
int index
Definition: gxfenc.c:90
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:382
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffprobe.c:105
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVIAMFLayer::output_gain_flags
unsigned int output_gain_flags
Output gain channel flags as defined in section 3.6.2 of IAMF.
Definition: iamf.h:310
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:82
AVAudioServiceType
AVAudioServiceType
Definition: defs.h:224
av_hash_freep
void av_hash_freep(AVHashContext **ctx)
Free hash context and set hash context pointer to NULL.
Definition: hash.c:248
show_format
static int show_format(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3841
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:809
SECTION_ID_CHAPTER
@ SECTION_ID_CHAPTER
Definition: ffprobe.c:174
AVIAMFSubmixElement::audio_element_id
unsigned int audio_element_id
The id of the Audio Element this submix element references.
Definition: iamf.h:452
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1015
xml_print_int
static void xml_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1966
print_duration_time
#define print_duration_time(k, v, tb)
Definition: ffprobe.c:2025
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:225
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVIAMFSubmix
Submix layout as defined in section 3.7 of IAMF.
Definition: iamf.h:556
show_value_unit
static int show_value_unit
Definition: ffprobe.c:140
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1356
AVStereo3D::primary_eye
enum AVStereo3DPrimaryEye primary_eye
Which eye is the primary eye when rendering in 2D.
Definition: stereo3d.h:222
color_primaries
static const AVColorPrimariesDesc color_primaries[AVCOL_PRI_NB]
Definition: csp.c:76
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1127
print_input_filename
static const char * print_input_filename
Definition: ffprobe.c:360
AVFilmGrainAOMParams::num_uv_points
int num_uv_points[2]
If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.
Definition: film_grain_params.h:62
AVIAMFReconGain::subblock_duration
unsigned int subblock_duration
Duration for the given subblock, in units of 1 / parameter_rate.
Definition: iamf.h:156
SECTION_ID_FRAMES
@ SECTION_ID_FRAMES
Definition: ffprobe.c:181
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:58
FrameData::pkt_size
int pkt_size
Definition: ffprobe.c:88
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:1213
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: demux.c:2525
writer_open
static int writer_open(WriterContext **wctx, const Writer *writer, const char *args, const struct section *sections, int nb_sections, const char *output)
Definition: ffprobe.c:687
fmt_ctx
static AVFormatContext * fmt_ctx
Definition: decode_filter_audio.c:46
WRITER_STRING_VALIDATION_IGNORE
@ WRITER_STRING_VALIDATION_IGNORE
Definition: ffprobe.c:524
writer_w8
#define writer_w8(wctx_, b_)
Definition: ffprobe.c:1042
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:67
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
SECTION_ID_STREAM_GROUP_PIECES
@ SECTION_ID_STREAM_GROUP_PIECES
Definition: ffprobe.c:221
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:61
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:83
WriterContext::string_validation_utf8_flags
unsigned int string_validation_utf8_flags
Definition: ffprobe.c:577
DefaultContext::noprint_wrappers
int noprint_wrappers
Definition: ffprobe.c:1091
OPT_TYPE_INT
@ OPT_TYPE_INT
Definition: cmdutils.h:84
AVIAMFDemixingInfo::subblock_duration
unsigned int subblock_duration
Duration for the given subblock, in units of 1 / parameter_rate.
Definition: iamf.h:136
av_log_set_callback
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:462
AVDynamicHDRPlus::num_rows_mastering_display_actual_peak_luminance
uint8_t num_rows_mastering_display_actual_peak_luminance
The number of rows in the mastering_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:309
AVPacket::size
int size
Definition: packet.h:540
ReadInterval::start_is_offset
int start_is_offset
Definition: ffprobe.c:159
do_show_packet_tags
static int do_show_packet_tags
Definition: ffprobe.c:138
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: avformat.c:693
SECTION_ID_STREAM_DISPOSITION
@ SECTION_ID_STREAM_DISPOSITION
Definition: ffprobe.c:234
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:162
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: frame.h:220
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
PRINT_PIX_FMT_FLAG
#define PRINT_PIX_FMT_FLAG(flagname, name)
Definition: ffprobe.c:4163
csv
int csv
Definition: checkasm.c:407
writer_w8_avio
static void writer_w8_avio(WriterContext *wctx, int b)
Definition: ffprobe.c:649
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:136
AVClass::category
AVClassCategory category
Category used for visualization (like color).
Definition: log.h:132
AVFilmGrainH274Params::component_model_present
int component_model_present[3]
Indicates if the modelling of film grain for a given component is present.
Definition: film_grain_params.h:192
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:132
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:296
AVDOVIRpuDataHeader::vdr_rpu_profile
uint8_t vdr_rpu_profile
Definition: dovi_meta.h:90
AVDynamicHDRPlus::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_metadata.h:259
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
av_stereo3d_primary_eye_name
const char * av_stereo3d_primary_eye_name(unsigned int eye)
Provide a human-readable name of a given stereo3d primary eye.
Definition: stereo3d.c:133
XMLContext::fully_qualified
int fully_qualified
Definition: ffprobe.c:1817
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1416
SECTION_FLAG_IS_ARRAY
#define SECTION_FLAG_IS_ARRAY
the section contains an array of elements of the same type
Definition: ffprobe.c:247
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:565
SectionID
SectionID
Definition: ffprobe.c:172
REALLOCZ_ARRAY_STREAM
#define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n)
Definition: ffprobe.c:2038
SECTION_ID_STREAM_GROUP_COMPONENT
@ SECTION_ID_STREAM_GROUP_COMPONENT
Definition: ffprobe.c:218
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:62
AVClass::get_category
AVClassCategory(* get_category)(void *ctx)
Callback to return the instance category.
Definition: log.h:139
size
int size
Definition: twinvq_data.h:10344
SECTION_ID_CHAPTER_TAGS
@ SECTION_ID_CHAPTER_TAGS
Definition: ffprobe.c:175
AV_ESCAPE_MODE_XML
@ AV_ESCAPE_MODE_XML
Use XML non-markup character data escaping.
Definition: avstring.h:318
AVHDRVividColorTransformParams::average_maxrgb
AVRational average_maxrgb
Indicates the average brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:246
show_private_data
static int show_private_data
Definition: ffprobe.c:144
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: seek.c:664
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVDynamicHDRPlus::mastering_display_actual_peak_luminance
AVRational mastering_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the mastering display used for mastering the image essence.
Definition: hdr_dynamic_metadata.h:322
section
Definition: ffprobe.c:242
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1167
opt_show_versions
static int opt_show_versions(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4562
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:238
opt_input_file
static int opt_input_file(void *optctx, const char *arg)
Definition: ffprobe.c:4324
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
PAL
#define PAL
Definition: bktr.c:68
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:737
ffprobe_show_library_versions
static void ffprobe_show_library_versions(WriterContext *w)
Definition: ffprobe.c:4149
printf
printf("static const uint8_t my_array[100] = {\n")
SECTION_ID_PACKETS_AND_FRAMES
@ SECTION_ID_PACKETS_AND_FRAMES
Definition: ffprobe.c:198
AVOption::name
const char * name
Definition: opt.h:430
use_value_prefix
static int use_value_prefix
Definition: ffprobe.c:141
SECTION_ID_ERROR
@ SECTION_ID_ERROR
Definition: ffprobe.c:177
DefaultContext::nested_section
int nested_section[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1092
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:281
unit_value
Definition: ffprobe.c:456
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2260
avdevice.h
show_error
static void show_error(WriterContext *w, int err)
Definition: ffprobe.c:3873
Writer::flags
int flags
a combination or WRITER_FLAG_*
Definition: ffprobe.c:541
av_packet_unpack_dictionary
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: packet.c:350
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: opt_common.c:237
ini_print_str
static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1618
AVHDRPlusColorTransformParams::window_lower_right_corner_y
AVRational window_lower_right_corner_y
The relative y coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:94
writer_put_str_avio
static void writer_put_str_avio(WriterContext *wctx, const char *str)
Definition: ffprobe.c:654
AVDOVIRpuDataHeader::coef_log2_denom
uint8_t coef_log2_denom
Definition: dovi_meta.h:94
AVDOVIRpuDataHeader::bl_video_full_range_flag
uint8_t bl_video_full_range_flag
Definition: dovi_meta.h:96
print_frame_side_data
static void print_frame_side_data(WriterContext *w, const AVFrame *frame, const AVStream *stream)
Definition: ffprobe.c:2848
AVHDRVividColorToneMappingParams::base_param_k1
int base_param_k1
indicates k1_0 in the base parameter, base_param_k1 <= 1: k1_0 = base_param_k1 base_param_k1 > 1: res...
Definition: hdr_dynamic_vivid_metadata.h:130
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:194
AVIAMFParamDefinition::constant_subblock_duration
unsigned int constant_subblock_duration
The duration of every subblock in the case where all subblocks, with the optional exception of the la...
Definition: iamf.h:238
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:572
AVIAMFAudioElement
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
Definition: iamf.h:356
section::children_ids
const SectionID children_ids[SECTION_MAX_NB_CHILDREN+1]
list of children section IDS, terminated by -1
Definition: ffprobe.c:253
AVDOVIReshapingCurve::poly_coef
int64_t poly_coef[AV_DOVI_MAX_PIECES][3]
Definition: dovi_meta.h:123
SECTION_ID_FRAME_SIDE_DATA_LIST
@ SECTION_ID_FRAME_SIDE_DATA_LIST
Definition: ffprobe.c:183
SECTION_ID_PACKET_TAGS
@ SECTION_ID_PACKET_TAGS
Definition: ffprobe.c:196
AVStreamGroupTileGrid::nb_tiles
unsigned int nb_tiles
Amount of tiles in the grid.
Definition: avformat.h:995
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:66
line
Definition: graph2dot.c:48
SECTION_ID_STREAM_GROUP_STREAM_TAGS
@ SECTION_ID_STREAM_GROUP_STREAM_TAGS
Definition: ffprobe.c:215
AVIAMFMixGain
Mix Gain Parameter Data as defined in section 3.8.1 of IAMF.
Definition: iamf.h:77
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:64
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
do_show_format
static int do_show_format
Definition: ffprobe.c:115
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:286
AVFilmGrainParams::h274
AVFilmGrainH274Params h274
Definition: film_grain_params.h:261
ReadInterval
Definition: ffprobe.c:155
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:900
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1125
ini_print_int
static void ini_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1629
compact_print_int
static void compact_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1363
OPT_TYPE_FUNC
@ OPT_TYPE_FUNC
Definition: cmdutils.h:81
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:194
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1201
AVFilmGrainAOMParams::ar_coeffs_y
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
Definition: film_grain_params.h:80
AVStreamGroupTileGrid::offsets
struct AVStreamGroupTileGrid::@365 * offsets
An nb_tiles sized array of offsets in pixels from the topleft edge of the canvas, indicating where ea...
Writer
Definition: ffprobe.c:528
section::entries_to_show
AVDictionary * entries_to_show
Definition: ffprobe.c:256
OPT_TYPE_BOOL
@ OPT_TYPE_BOOL
Definition: cmdutils.h:82
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1168
do_show_stream_disposition
static int do_show_stream_disposition
Definition: ffprobe.c:122
do_show_stream_groups
static int do_show_stream_groups
Definition: ffprobe.c:119
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
AVDynamicHDRPlus::num_rows_targeted_system_display_actual_peak_luminance
uint8_t num_rows_targeted_system_display_actual_peak_luminance
The number of rows in the targeted system_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:283
Writer::priv_size
int priv_size
private size for the writer context
Definition: ffprobe.c:530
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:736
registered_writers
static const Writer * registered_writers[MAX_REGISTERED_WRITERS_NB+1]
Definition: ffprobe.c:1048
AVHDRPlusColorTransformParams::window_upper_left_corner_x
AVRational window_upper_left_corner_x
The relative x coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:67
WriterContext::writer_printf
void(* writer_printf)(WriterContext *wctx, const char *fmt,...)
Definition: ffprobe.c:553
do_count_packets
static int do_count_packets
Definition: ffprobe.c:110
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:361
SHOW_OPTIONAL_FIELDS_AUTO
#define SHOW_OPTIONAL_FIELDS_AUTO
Definition: ffprobe.c:146
pthread_mutex_destroy
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:169
ReadInterval::has_start
int has_start
Definition: ffprobe.c:158
sections
static struct section sections[]
Definition: ffprobe.c:284
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:40
AVCPBProperties::vbv_delay
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
Definition: defs.h:301
unit_value::unit
const char * unit
Definition: ffprobe.c:458
WriterContext::writer_put_str
void(* writer_put_str)(WriterContext *wctx, const char *str)
Definition: ffprobe.c:552
SECTION_ID_PROGRAM_STREAM_TAGS
@ SECTION_ID_PROGRAM_STREAM_TAGS
Definition: ffprobe.c:207
JSONContext::indent_level
int indent_level
Definition: ffprobe.c:1648
section::flags
int flags
Definition: ffprobe.c:252
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:728
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:48
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:142
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:137
AVHDRPlusColorTransformParams::semimajor_axis_internal_ellipse
uint16_t semimajor_axis_internal_ellipse
The semi-major axis value of the internal ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:125
AVStreamGroupTileGrid::width
int width
Width of the final image for presentation.
Definition: avformat.h:1072
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:140
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2258
AVClassCategory
AVClassCategory
Definition: log.h:28
AVFilmGrainParams::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:280
AV_STREAM_GROUP_PARAMS_NONE
@ AV_STREAM_GROUP_PARAMS_NONE
Definition: avformat.h:1124
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:139
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
AVIAMFParamDefinition::parameter_id
unsigned int parameter_id
Identifier for the paremeter substream.
Definition: iamf.h:218
SECTION_ID_PROGRAM
@ SECTION_ID_PROGRAM
Definition: ffprobe.c:208
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1260
print_color_space
static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
Definition: ffprobe.c:2676
ffprobe_show_pixel_formats
static void ffprobe_show_pixel_formats(WriterContext *w)
Definition: ffprobe.c:4168
WRITER_STRING_VALIDATION_NB
@ WRITER_STRING_VALIDATION_NB
Definition: ffprobe.c:525
setup_find_stream_info_opts
int setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *local_codec_opts, AVDictionary ***dst)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1418
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:253
show_usage
static void show_usage(void)
Definition: ffprobe.c:4111
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:564
AVFilmGrainH274Params
This structure describes how to handle film grain synthesis for codecs using the ITU-T H....
Definition: film_grain_params.h:132
csv_options
static const AVOption csv_options[]
Definition: ffprobe.c:1390
SECTION_ID_STREAM_GROUP_STREAM
@ SECTION_ID_STREAM_GROUP_STREAM
Definition: ffprobe.c:228
AVHDRVividColorToneMappingParams::targeted_system_display_maximum_luminance
AVRational targeted_system_display_maximum_luminance
The nominal maximum display luminance of the targeted system display, in multiples of 1....
Definition: hdr_dynamic_vivid_metadata.h:83
show_subtitle
static void show_subtitle(WriterContext *w, AVSubtitle *sub, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2825
AVCodecParameters::height
int height
Definition: codec_par.h:135
print_private_data
static void print_private_data(WriterContext *w, void *priv_data)
Definition: ffprobe.c:2653
XMLContext::xsd_strict
int xsd_strict
Definition: ffprobe.c:1818
AVFilmGrainH274Params::num_intensity_intervals
uint16_t num_intensity_intervals[3]
Specifies the number of intensity intervals for which a specific set of model values has been estimat...
Definition: film_grain_params.h:198
do_bitexact
static int do_bitexact
Definition: ffprobe.c:108
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:640
display.h
SECTION_ID_PACKETS
@ SECTION_ID_PACKETS
Definition: ffprobe.c:197
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:204
AVIAMFMixPresentation
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
Definition: iamf.h:613
AVFilmGrainParams::subsampling_y
int subsampling_y
Definition: film_grain_params.h:274
xml_writer
static Writer xml_writer
Definition: ffprobe.c:1971
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:276
AVDOVIDataMapping::num_y_partitions
uint32_t num_y_partitions
Definition: dovi_meta.h:161
LogBuffer::category
AVClassCategory category
Definition: ffprobe.c:399
writer_print_ts
static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
Definition: ffprobe.c:964
unit_value::val
union unit_value::@12 val
parse_options
int parse_options(void *optctx, int argc, char **argv, const OptionDef *options, int(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:417
opt_show_entries
static int opt_show_entries(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4274
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:227
SECTION_ID_FRAME_SIDE_DATA
@ SECTION_ID_FRAME_SIDE_DATA
Definition: ffprobe.c:184
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
@ SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
Definition: ffprobe.c:187
opt_sections
static int opt_sections(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4549
CompactContext::escape_str
const char *(* escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Definition: ffprobe.c:1243
WriterContext::priv
void * priv
private data for use by the filter
Definition: ffprobe.c:556
OPT_FUNC_ARG
#define OPT_FUNC_ARG
Definition: cmdutils.h:201
AVHDRPlusColorTransformParams::overlap_process_option
enum AVHDRPlusOverlapProcessOption overlap_process_option
Overlap process option indicates one of the two methods of combining rendered pixels in the processin...
Definition: hdr_dynamic_metadata.h:149
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:256
AVHDRVividColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for CUVA 005....
Definition: hdr_dynamic_vivid_metadata.h:233
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
AV_PKT_DATA_MPEGTS_STREAM_ID
@ AV_PKT_DATA_MPEGTS_STREAM_ID
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:212
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1224
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:166
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:1109
profile
int profile
Definition: mxfenc.c:2233
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
do_show_stream_group_disposition
static int do_show_stream_group_disposition
Definition: ffprobe.c:123
AVDOVINLQParams
Coefficients of the non-linear inverse quantization.
Definition: dovi_meta.h:139
dec_str
const char * dec_str
Definition: ffprobe.c:370
AVHDRVividColorToneMappingParams::base_param_Delta_enable_mode
int base_param_Delta_enable_mode
This flag indicates that delta mode of base paramter(for value of 1)
Definition: hdr_dynamic_vivid_metadata.h:150
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
SECTION_ID_PACKET_SIDE_DATA
@ SECTION_ID_PACKET_SIDE_DATA
Definition: ffprobe.c:200
ambient_viewing_environment.h
use_value_sexagesimal_format
static int use_value_sexagesimal_format
Definition: ffprobe.c:143
SECTION_ID_LIBRARY_VERSIONS
@ SECTION_ID_LIBRARY_VERSIONS
Definition: ffprobe.c:194
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:662
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilmGrainH274Params::intensity_interval_lower_bound
uint8_t intensity_interval_lower_bound[3][256]
Specifies the lower ounds of each intensity interval for whichthe set of model values applies for the...
Definition: film_grain_params.h:210
SECTION_ID_FRAME_SIDE_DATA_TIMECODE
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE
Definition: ffprobe.c:186
AVIAMFParamDefinition::nb_subblocks
unsigned int nb_subblocks
Number of subblocks in the array.
Definition: iamf.h:208
LogBuffer::parent_name
char * parent_name
Definition: ffprobe.c:400
AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
@ AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
Definition: iamf.h:346
log2
#define log2(x)
Definition: libm.h:404
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
SECTION_ID_PROGRAM_VERSION
@ SECTION_ID_PROGRAM_VERSION
Definition: ffprobe.c:212
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
none_escape_str
static const char * none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Definition: ffprobe.c:1231
AVDOVIDataMapping::curves
AVDOVIReshapingCurve curves[3]
Definition: dovi_meta.h:156
AVStreamGroupTileGrid::horizontal
int horizontal
Offset in pixels from the left edge of the canvas where the tile should be placed.
Definition: avformat.h:1031
ini_writer
static const Writer ini_writer
Definition: ffprobe.c:1634
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:553
PRINT_STRING_OPT
#define PRINT_STRING_OPT
Definition: ffprobe.c:897
AVDOVINLQParams::linear_deadzone_slope
uint64_t linear_deadzone_slope
Definition: dovi_meta.h:143
SECTION_ID_PROGRAMS
@ SECTION_ID_PROGRAMS
Definition: ffprobe.c:213
version.h
json_print_str
static void json_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1769
AVIAMFSubmix::nb_layouts
unsigned int nb_layouts
Number of layouts in the submix.
Definition: iamf.h:587
WriterContext::string_validation_replacement
char * string_validation_replacement
Definition: ffprobe.c:576
AVFilmGrainParams::height
int height
Definition: film_grain_params.h:269
AVDOVIReshapingCurve
Definition: dovi_meta.h:117
version.h
section::get_type
const char *(* get_type)(const void *data)
function returning a type if defined, must be defined when SECTION_FLAG_HAS_TYPE is defined
Definition: ffprobe.c:257
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:817
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
tag
uint32_t tag
Definition: movenc.c:1879
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
log_buffer
static LogBuffer * log_buffer
Definition: ffprobe.c:404
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:374
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:80
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
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:292
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:139
AVStreamGroup::metadata
AVDictionary * metadata
Metadata that applies to the whole group.
Definition: avformat.h:1181
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:141
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:70
flat_print_int
static void flat_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1511
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
InputFile::streams
InputStream ** streams
Definition: ffmpeg.h:487
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:4387
AVHDRVivid3SplineParams
HDR Vivid three spline params.
Definition: hdr_dynamic_vivid_metadata.h:30
avformat.h
dovi_meta.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
AVHDRVividColorTransformParams::minimum_maxrgb
AVRational minimum_maxrgb
Indicates the minimum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:239
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:550
flat_init
static av_cold int flat_init(WriterContext *wctx)
Definition: ffprobe.c:1438
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:399
id
enum AVCodecID id
Definition: dts2pts.c:367
CMDUTILS_COMMON_OPTIONS
#define CMDUTILS_COMMON_OPTIONS
Definition: opt_common.h:199
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
avio_vprintf
int avio_vprintf(AVIOContext *s, const char *fmt, va_list ap)
Writes a formatted string to the context taking a va_list.
Definition: aviobuf.c:1191
log_buffer_size
static int log_buffer_size
Definition: ffprobe.c:405
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:170
AVDOVIReshapingCurve::num_pivots
uint8_t num_pivots
Definition: dovi_meta.h:118
AV_PKT_DATA_WEBVTT_IDENTIFIER
@ AV_PKT_DATA_WEBVTT_IDENTIFIER
The optional first identifier line of a WebVTT cue.
Definition: packet.h:193
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:563
AVDOVIRpuDataHeader::vdr_rpu_level
uint8_t vdr_rpu_level
Definition: dovi_meta.h:91
WriterContext::writer
const Writer * writer
the Writer of which this is an instance
Definition: ffprobe.c:548
SECTION_ID_FRAME
@ SECTION_ID_FRAME
Definition: ffprobe.c:180
av_dovi_get_color
static av_always_inline AVDOVIColorMetadata * av_dovi_get_color(const AVDOVIMetadata *data)
Definition: dovi_meta.h:367
AVStreamGroup
Definition: avformat.h:1134
AVHDRVividColorToneMappingParams::base_param_m_n
AVRational base_param_m_n
base_param_m_n in the base parameter, in multiples of 1.0/10.
Definition: hdr_dynamic_vivid_metadata.h:123
XML_INDENT
#define XML_INDENT()
Definition: ffprobe.c:1855
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AVHDRVividColorToneMappingParams::base_param_m_a
AVRational base_param_m_a
base_param_m_a in the base parameter, in multiples of 1.0/1023.
Definition: hdr_dynamic_vivid_metadata.h:109
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
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:168
hash.h
CompactContext::nokey
int nokey
Definition: ffprobe.c:1240
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
WriterContext
Definition: ffprobe.c:546
AVDOVIDataMapping::mapping_chroma_format_idc
uint8_t mapping_chroma_format_idc
Definition: dovi_meta.h:155
AVStreamGroup::nb_streams
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
Definition: avformat.h:1188
get_packet_side_data_type
static const char * get_packet_side_data_type(const void *data)
Definition: ffprobe.c:261
AV_FILM_GRAIN_PARAMS_H274
@ AV_FILM_GRAIN_PARAMS_H274
The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
Definition: film_grain_params.h:35
channel_layout.h
AVIAMFSubmix::default_mix_gain
AVRational default_mix_gain
Default mix gain value to apply when there are no AVIAMFParamDefinition with output_mix_config's para...
Definition: iamf.h:603
JSONContext::item_sep
const char * item_sep
Definition: ffprobe.c:1650
nb_streams_packets
static uint64_t * nb_streams_packets
Definition: ffprobe.c:386
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance_flag
uint8_t targeted_system_display_actual_peak_luminance_flag
This flag shall be equal to 0 in bit streams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:277
do_show_program_version
static int do_show_program_version
Definition: ffprobe.c:125
AVFilmGrainAOMParams::y_points
uint8_t y_points[14][2]
Definition: film_grain_params.h:50
AVFilmGrainAOMParams::uv_offset
int uv_offset[2]
Offset used for component scaling function.
Definition: film_grain_params.h:112
opt_common.h
DEFINE_OPT_SHOW_SECTION
#define DEFINE_OPT_SHOW_SECTION(section, target_section_id)
Definition: ffprobe.c:4569
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
PRINT_STRING_VALIDATE
#define PRINT_STRING_VALIDATE
Definition: ffprobe.c:898
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:62
AVDOVIRpuDataHeader::bl_bit_depth
uint8_t bl_bit_depth
Definition: dovi_meta.h:97
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVFilmGrainParams::codec
union AVFilmGrainParams::@438 codec
Additional fields may be added both here and in any structure included.
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:143
AVHDRVivid3SplineParams::th_enable
AVRational th_enable
3Spline_TH_enable of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:49
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:232
version.h
AVHDRPlusColorTransformParams::num_distribution_maxrgb_percentiles
uint8_t num_distribution_maxrgb_percentiles
The number of linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:170
AVHDRPlusColorTransformParams::maxscl
AVRational maxscl[3]
The maximum of the color components of linearized RGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:157
SECTION_ID_PIXEL_FORMATS
@ SECTION_ID_PIXEL_FORMATS
Definition: ffprobe.c:205
SECTION_ID_STREAM_GROUP_BLOCK
@ SECTION_ID_STREAM_GROUP_BLOCK
Definition: ffprobe.c:226
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:200
print_str_validate
#define print_str_validate(k, v)
Definition: ffprobe.c:2022
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:266
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:171
output_format
static char * output_format
Definition: ffprobe.c:151
AVFilmGrainH274Params::log2_scale_factor
int log2_scale_factor
Specifies a scale factor used in the film grain characterization equations.
Definition: film_grain_params.h:187
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
hdr_dynamic_metadata.h
AV_PKT_DATA_AFD
@ AV_PKT_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:258
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
ini_options
static const AVOption ini_options[]
Definition: ffprobe.c:1550
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:914
print_dynamic_hdr10_plus
static void print_dynamic_hdr10_plus(WriterContext *w, const AVDynamicHDRPlus *metadata)
Definition: ffprobe.c:2226
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:153
CHECK_COMPLIANCE
#define CHECK_COMPLIANCE(opt, opt_name)
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:60
options
static const OptionDef * options
Definition: ffprobe.c:356
do_show_pixel_formats
static int do_show_pixel_formats
Definition: ffprobe.c:127
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:61
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:603
AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
Subblocks are of struct type AVIAMFMixGain.
Definition: iamf.h:173
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:144
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1435
AVHDRVividColorToneMappingParams
Color tone mapping parameters at a processing window in a dynamic metadata for CUVA 005....
Definition: hdr_dynamic_vivid_metadata.h:77
AVPacket::stream_index
int stream_index
Definition: packet.h:541
AVFilmGrainH274Params::num_model_values
uint8_t num_model_values[3]
Specifies the number of model values present for each intensity interval in which the film grain has ...
Definition: film_grain_params.h:204
AVFilmGrainParams::color_range
enum AVColorRange color_range
Intended video signal characteristics.
Definition: film_grain_params.h:279
FlatContext::sep_str
const char * sep_str
Definition: ffprobe.c:1420
DEFINE_WRITER_CLASS
#define DEFINE_WRITER_CLASS(name)
Definition: ffprobe.c:1075
opt_print_filename
static int opt_print_filename(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4364
AVIAMFSubmix::nb_elements
unsigned int nb_elements
Number of elements in the submix.
Definition: iamf.h:572
get_stream_group_type
static const char * get_stream_group_type(const void *data)
Definition: ffprobe.c:278
AVFilmGrainAOMParams::overlap_flag
int overlap_flag
Signals whether to overlap film grain blocks.
Definition: film_grain_params.h:117
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:647
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:117
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
XMLContext
Definition: ffprobe.c:1813
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:57
Writer::print_section_header
void(* print_section_header)(WriterContext *wctx, const void *data)
Definition: ffprobe.c:536
do_show_program_tags
static int do_show_program_tags
Definition: ffprobe.c:135
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
WRITER_STRING_VALIDATION_REPLACE
@ WRITER_STRING_VALIDATION_REPLACE
Definition: ffprobe.c:523
AVHDRPlusColorTransformParams::center_of_ellipse_y
uint16_t center_of_ellipse_y
The y coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:110
av_log_default_callback
void av_log_default_callback(void *ptr, int level, const char *fmt, va_list vl)
Default logging callback.
Definition: log.c:353
AVIAMFAudioElement::demixing_info
AVIAMFParamDefinition * demixing_info
Demixing information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:376
writer_printf_avio
static void writer_printf_avio(WriterContext *wctx, const char *fmt,...)
Definition: ffprobe.c:659
AVIAMFDemixingInfo::dmixp_mode
unsigned int dmixp_mode
Pre-defined combination of demixing parameters.
Definition: iamf.h:140
mem.h
AVIAMFSubmix::output_mix_config
AVIAMFParamDefinition * output_mix_config
Information required for post-processing the mixed audio signal to generate the audio signal for play...
Definition: iamf.h:595
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1161
AVIAMFLayer::ambisonics_mode
enum AVIAMFAmbisonicsMode ambisonics_mode
Ambisonics mode as defined in section 3.6.3 of IAMF.
Definition: iamf.h:328
CompactContext::item_sep_str
char * item_sep_str
Definition: ffprobe.c:1238
CompactContext::escape_mode_str
char * escape_mode_str
Definition: ffprobe.c:1242
mastering_display_metadata.h
av_dovi_get_mapping
static av_always_inline AVDOVIDataMapping * av_dovi_get_mapping(const AVDOVIMetadata *data)
Definition: dovi_meta.h:361
AV_DOVI_COMPRESSION_NONE
@ AV_DOVI_COMPRESSION_NONE
Definition: dovi_meta.h:68
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:225
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:175
FlatContext::sep
char sep
Definition: ffprobe.c:1421
JSONContext::item_start_end
const char * item_start_end
Definition: ffprobe.c:1650
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVCodecParameters::format
int format
Definition: codec_par.h:92
AVDynamicHDRVivid::params
AVHDRVividColorTransformParams params[3]
The color transform parameters for every processing window.
Definition: hdr_dynamic_vivid_metadata.h:325
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
default_print_section_header
static void default_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c:1118
bin_val
double bin_val
Definition: ffprobe.c:367
SECTION_ID_STREAM_GROUP_TAGS
@ SECTION_ID_STREAM_GROUP_TAGS
Definition: ffprobe.c:230
AVIAMFMixPresentation::annotations
AVDictionary * annotations
A dictionary of strings describing the mix in different languages.
Definition: iamf.h:641
SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST
Definition: ffprobe.c:185
WRITER_STRING_VALIDATION_FAIL
@ WRITER_STRING_VALIDATION_FAIL
Definition: ffprobe.c:522
AVFormatContext::nb_stream_groups
unsigned int nb_stream_groups
Number of elements in AVFormatContext.stream_groups.
Definition: avformat.h:1375
AVStreamGroupTileGrid::height
int height
Height of the final image for presentation.
Definition: avformat.h:1082
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:217
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVIAMFLayer::output_gain
AVRational output_gain
Output gain as defined in section 3.6.2 of IAMF.
Definition: iamf.h:316
compact_options
static const AVOption compact_options[]
Definition: ffprobe.c:1252
CompactContext::has_nested_elems
int has_nested_elems[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1245
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AV_OPT_FLAG_EXPORT
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:363
OPT_TYPE_STRING
@ OPT_TYPE_STRING
Definition: cmdutils.h:83
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:119
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
WriterContext::nb_sections
int nb_sections
number of sections
Definition: ffprobe.c:559
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:88
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:237
cmdutils.h
show_stream
static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int container)
Definition: ffprobe.c:3279
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance
AVRational targeted_system_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the targeted system display.
Definition: hdr_dynamic_metadata.h:297
print_dynamic_hdr_vivid
static void print_dynamic_hdr_vivid(WriterContext *w, const AVDynamicHDRVivid *metadata)
Definition: ffprobe.c:2325
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: frame.c:1059
SHOW_LIB_VERSION
#define SHOW_LIB_VERSION(libname, LIBNAME)
Definition: ffprobe.c:4134
IN_PROGRAM
#define IN_PROGRAM
Definition: ffprobe.c:3276
writer_print_rational
static void writer_print_rational(WriterContext *wctx, const char *key, AVRational q, char sep)
Definition: ffprobe.c:938
AVIAMFSubmixElement::element_mix_config
AVIAMFParamDefinition * element_mix_config
Information required required for applying any processing to the referenced and rendered Audio Elemen...
Definition: iamf.h:461
AVIAMFParamDefinition::parameter_rate
unsigned int parameter_rate
Sample rate for the paremeter substream.
Definition: iamf.h:222
XMLContext::indent_level
int indent_level
Definition: ffprobe.c:1816
int32_t
int32_t
Definition: audioconvert.c:56
AVIAMFSubmixElement
Submix element as defined in section 3.7 of IAMF.
Definition: iamf.h:446
AVDOVINLQParams::nlq_offset
uint16_t nlq_offset
Definition: dovi_meta.h:140
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:616
AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
@ AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
Definition: iamf.h:345
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:269
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1215
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:153
AVDynamicHDRVivid::system_start_code
uint8_t system_start_code
The system start code.
Definition: hdr_dynamic_vivid_metadata.h:314
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1425
writer_print_section_footer
static void writer_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:814
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:1104
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
@ SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
Definition: ffprobe.c:189
AVHDRVividColorToneMappingParams::base_param_k3
int base_param_k3
indicates k3_0 in the base parameter, base_param_k3 == 1: k3_0 = base_param_k3 base_param_k3 == 2: k3...
Definition: hdr_dynamic_vivid_metadata.h:145
SECTION_ID_PROGRAM_STREAMS
@ SECTION_ID_PROGRAM_STREAMS
Definition: ffprobe.c:209
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:93
do_show_data
static int do_show_data
Definition: ffprobe.c:124
AVDOVIRpuDataHeader::disable_residual_flag
uint8_t disable_residual_flag
Definition: dovi_meta.h:102
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:123
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
SECTION_ID_STREAM_GROUP_DISPOSITION
@ SECTION_ID_STREAM_GROUP_DISPOSITION
Definition: ffprobe.c:229
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:145
LogBuffer::parent_category
AVClassCategory parent_category
Definition: ffprobe.c:401
SECTION_ID_PROGRAM_STREAM_DISPOSITION
@ SECTION_ID_PROGRAM_STREAM_DISPOSITION
Definition: ffprobe.c:206
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3774
AVHDRVivid3SplineParams::th_delta2
AVRational th_delta2
3Spline_TH_Delta2 of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:63
AVIAMFAudioElement::recon_gain_info
AVIAMFParamDefinition * recon_gain_info
Recon gain information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:383
AV_DOVI_COMPRESSION_RESERVED
@ AV_DOVI_COMPRESSION_RESERVED
Definition: dovi_meta.h:70
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
AVDictionaryEntry::value
char * value
Definition: dict.h:91
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:797
SECTION_ID_STREAM_GROUP_SUBPIECES
@ SECTION_ID_STREAM_GROUP_SUBPIECES
Definition: ffprobe.c:223
show_data_hash
static char * show_data_hash
Definition: ffprobe.c:153
SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION
@ SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION
Definition: ffprobe.c:214
avstring.h
AVHDRVivid3SplineParams::th_enable_mb
AVRational th_enable_mb
three_Spline_TH_enable_MB is in the range of 0.0 to 1.0, inclusive and in multiples of 1....
Definition: hdr_dynamic_vivid_metadata.h:42
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:86
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
print_primaries
static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
Definition: ffprobe.c:2686
AVAmbientViewingEnvironment::ambient_light_y
AVRational ambient_light_y
Normalized y chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:54
do_show_streams
static int do_show_streams
Definition: ffprobe.c:121
AVFilmGrainAOMParams::chroma_scaling_from_luma
int chroma_scaling_from_luma
Signals whether to derive the chroma scaling function from the luma.
Definition: film_grain_params.h:56
AVStreamGroupTileGrid::idx
unsigned int idx
Index of the stream in the group this tile references.
Definition: avformat.h:1026
unit_value::d
double d
Definition: ffprobe.c:457
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:488
print_iamf_mix_presentation_params
static void print_iamf_mix_presentation_params(WriterContext *w, const AVStreamGroup *stg, const AVIAMFMixPresentation *mix_presentation)
Definition: ffprobe.c:3724
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:682
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1261
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
do_analyze_frames
static int do_analyze_frames
Definition: ffprobe.c:107
AVHDRVividColorToneMappingParams::three_spline
AVHDRVivid3SplineParams three_spline[2]
Definition: hdr_dynamic_vivid_metadata.h:225
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:163
AVHDRVividColorToneMappingParams::base_param_m_p
AVRational base_param_m_p
base_param_m_p in the base parameter, in multiples of 1.0/16383.
Definition: hdr_dynamic_vivid_metadata.h:95
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:242
AVIAMFMixPresentation::submixes
AVIAMFSubmix ** submixes
Array of submixes.
Definition: iamf.h:622
print_error
static 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.h:468
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:162
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
stream_specifier
static char * stream_specifier
Definition: ffprobe.c:152
AV_FRAME_FLAG_LOSSLESS
#define AV_FRAME_FLAG_LOSSLESS
A flag to mark frames which were encoded losslessly from the input.
Definition: frame.h:671
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:1016
log_callback
static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
Definition: ffprobe.c:407
AVCodecParameters::initial_padding
int initial_padding
Audio only.
Definition: codec_par.h:203
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1328
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:152
SECTION_ID_CHAPTERS
@ SECTION_ID_CHAPTERS
Definition: ffprobe.c:176
print_time
#define print_time(k, v, tb)
Definition: ffprobe.c:2023
default_print_str
static void default_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c:1156
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:94
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3525
print_str_opt
#define print_str_opt(k, v)
Definition: ffprobe.c:2021
av_tolower
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:237
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:571
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2259
CompactContext::terminate_line
int terminate_line[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c:1246
default_print_section_footer
static void default_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c:1143
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
SECTION_ID_PIXEL_FORMAT_COMPONENT
@ SECTION_ID_PIXEL_FORMAT_COMPONENT
Definition: ffprobe.c:203
INIContext::hierarchical
int hierarchical
Definition: ffprobe.c:1544
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:138
AVHDRVividColorToneMappingParams::base_param_m_b
AVRational base_param_m_b
base_param_m_b in the base parameter, in multiples of 1/1023.
Definition: hdr_dynamic_vivid_metadata.h:116
src
#define src
Definition: vp8dsp.c:248
SECTION_ID_PACKET
@ SECTION_ID_PACKET
Definition: ffprobe.c:195
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:77
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:578
JSONContext::compact
int compact
Definition: ffprobe.c:1649
AVHDRVividColorToneMappingParams::base_param_m_m
AVRational base_param_m_m
base_param_m_m in the base parameter, in multiples of 1.0/10.
Definition: hdr_dynamic_vivid_metadata.h:102
unit_second_str
static const char unit_second_str[]
Definition: ffprobe.c:380
AVHDRPlusColorTransformParams::bezier_curve_anchors
AVRational bezier_curve_anchors[15]
The intermediate anchor parameters of the tone mapping function in the processing window in the scene...
Definition: hdr_dynamic_metadata.h:216
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:312
AVDynamicHDRPlus::num_cols_mastering_display_actual_peak_luminance
uint8_t num_cols_mastering_display_actual_peak_luminance
The number of columns in the mastering_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:315
AVDOVIDataMapping::num_x_partitions
uint32_t num_x_partitions
Definition: dovi_meta.h:160
AVFilmGrainAOMParams::ar_coeff_shift
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
Definition: film_grain_params.h:93
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:551
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:35
version.h
writer_class
static const AVClass writer_class
Definition: ffprobe.c:609
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:3090
do_show_packets
static int do_show_packets
Definition: ffprobe.c:117
AV_IAMF_PARAMETER_DEFINITION_DEMIXING
@ AV_IAMF_PARAMETER_DEFINITION_DEMIXING
Subblocks are of struct type AVIAMFDemixingInfo.
Definition: iamf.h:177
show_programs
static int show_programs(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3550
JSONContext
Definition: ffprobe.c:1646
SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
@ SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
Definition: ffprobe.c:219
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:78
print_list_fmt
#define print_list_fmt(k, f, n, m,...)
Definition: ffprobe.c:2006
writer_w8_printf
static void writer_w8_printf(WriterContext *wctx, int b)
Definition: ffprobe.c:668
bprint_bytes
static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
Definition: ffprobe.c:641
avdevice_register_all
FF_VISIBILITY_POP_HIDDEN av_cold void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:70
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86
writer_register
static int writer_register(const Writer *writer)
Definition: ffprobe.c:1050
Generated on Mon Jan 6 2025 19:21:20 for FFmpeg by   doxygen 1.8.17