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