FFmpeg
ffprobe.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2007-2010 Stefano Sabatini
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * simple media prober based on the FFmpeg libraries
24  */
25 
26 #include "config.h"
27 #include "libavutil/ffversion.h"
28 
29 #include <string.h>
30 #include <math.h>
31 
32 #include "libavformat/avformat.h"
33 #include "libavformat/version.h"
34 #include "libavcodec/avcodec.h"
35 #include "libavcodec/version.h"
36 #include "libavutil/ambient_viewing_environment.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/channel_layout.h"
41 #include "libavutil/display.h"
42 #include "libavutil/film_grain_params.h"
43 #include "libavutil/hash.h"
44 #include "libavutil/hdr_dynamic_metadata.h"
45 #include "libavutil/iamf.h"
46 #include "libavutil/mastering_display_metadata.h"
47 #include "libavutil/hdr_dynamic_vivid_metadata.h"
48 #include "libavutil/dovi_meta.h"
49 #include "libavutil/mem.h"
50 #include "libavutil/opt.h"
51 #include "libavutil/pixdesc.h"
52 #include "libavutil/spherical.h"
53 #include "libavutil/stereo3d.h"
54 #include "libavutil/dict.h"
55 #include "libavutil/intreadwrite.h"
56 #include "libavutil/libm.h"
57 #include "libavutil/parseutils.h"
58 #include "libavutil/timecode.h"
59 #include "libavutil/timestamp.h"
60 #include "libavdevice/avdevice.h"
61 #include "libavdevice/version.h"
62 #include "libswscale/swscale.h"
63 #include "libswscale/version.h"
64 #include "libswresample/swresample.h"
65 #include "libswresample/version.h"
66 #include "libpostproc/postprocess.h"
67 #include "libpostproc/version.h"
68 #include "libavfilter/version.h"
69 #include "cmdutils.h"
70 #include "opt_common.h"
71 
72 #include "libavutil/thread.h"
73 
74 // 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_color_range(WriterContext *w, enum AVColorRange color_range)
2655 {
2656  const char *val = av_color_range_name(color_range);
2657  if (!val || color_range == AVCOL_RANGE_UNSPECIFIED) {
2658  print_str_opt("color_range", "unknown");
2659  } else {
2660  print_str("color_range", val);
2661  }
2662 }
2663 
2664 static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
2665 {
2666  const char *val = av_color_space_name(color_space);
2667  if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
2668  print_str_opt("color_space", "unknown");
2669  } else {
2670  print_str("color_space", val);
2671  }
2672 }
2673 
2674 static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
2675 {
2676  const char *val = av_color_primaries_name(color_primaries);
2677  if (!val || color_primaries == AVCOL_PRI_UNSPECIFIED) {
2678  print_str_opt("color_primaries", "unknown");
2679  } else {
2680  print_str("color_primaries", val);
2681  }
2682 }
2683 
2684 static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
2685 {
2686  const char *val = av_color_transfer_name(color_trc);
2687  if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
2688  print_str_opt("color_transfer", "unknown");
2689  } else {
2690  print_str("color_transfer", val);
2691  }
2692 }
2693 
2694 static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
2695 {
2696  const char *val = av_chroma_location_name(chroma_location);
2697  if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
2698  print_str_opt("chroma_location", "unspecified");
2699  } else {
2700  print_str("chroma_location", val);
2701  }
2702 }
2703 
2704 static void clear_log(int need_lock)
2705 {
2706  int i;
2707 
2708  if (need_lock)
2709  ff_mutex_lock(&log_mutex);
2710  for (i=0; i<log_buffer_size; i++) {
2711  av_freep(&log_buffer[i].context_name);
2712  av_freep(&log_buffer[i].parent_name);
2713  av_freep(&log_buffer[i].log_message);
2714  }
2715  log_buffer_size = 0;
2716  if(need_lock)
2717  ff_mutex_unlock(&log_mutex);
2718 }
2719 
2720 static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
2721 {
2722  int i;
2723  ff_mutex_lock(&log_mutex);
2724  if (!log_buffer_size) {
2725  ff_mutex_unlock(&log_mutex);
2726  return 0;
2727  }
2728  writer_print_section_header(w, NULL, section_ids);
2729 
2730  for (i=0; i<log_buffer_size; i++) {
2731  if (log_buffer[i].log_level <= log_level) {
2732  writer_print_section_header(w, NULL, section_id);
2733  print_str("context", log_buffer[i].context_name);
2734  print_int("level", log_buffer[i].log_level);
2735  print_int("category", log_buffer[i].category);
2736  if (log_buffer[i].parent_name) {
2737  print_str("parent_context", log_buffer[i].parent_name);
2738  print_int("parent_category", log_buffer[i].parent_category);
2739  } else {
2740  print_str_opt("parent_context", "N/A");
2741  print_str_opt("parent_category", "N/A");
2742  }
2743  print_str("message", log_buffer[i].log_message);
2744  writer_print_section_footer(w);
2745  }
2746  }
2747  clear_log(0);
2748  ff_mutex_unlock(&log_mutex);
2749 
2750  writer_print_section_footer(w);
2751 
2752  return 0;
2753 }
2754 
2755 static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
2756 {
2757  char val_str[128];
2758  AVStream *st = ifile->streams[pkt->stream_index].st;
2759  AVBPrint pbuf;
2760  const char *s;
2761 
2762  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2763 
2764  writer_print_section_header(w, NULL, SECTION_ID_PACKET);
2765 
2766  s = av_get_media_type_string(st->codecpar->codec_type);
2767  if (s) print_str ("codec_type", s);
2768  else print_str_opt("codec_type", "unknown");
2769  print_int("stream_index", pkt->stream_index);
2770  print_ts ("pts", pkt->pts);
2771  print_time("pts_time", pkt->pts, &st->time_base);
2772  print_ts ("dts", pkt->dts);
2773  print_time("dts_time", pkt->dts, &st->time_base);
2774  print_duration_ts("duration", pkt->duration);
2775  print_duration_time("duration_time", pkt->duration, &st->time_base);
2776  print_val("size", pkt->size, unit_byte_str);
2777  if (pkt->pos != -1) print_fmt ("pos", "%"PRId64, pkt->pos);
2778  else print_str_opt("pos", "N/A");
2779  print_fmt("flags", "%c%c%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_',
2780  pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_',
2781  pkt->flags & AV_PKT_FLAG_CORRUPT ? 'C' : '_');
2782  if (do_show_data)
2783  writer_print_data(w, "data", pkt->data, pkt->size);
2784  writer_print_data_hash(w, "data_hash", pkt->data, pkt->size);
2785 
2786  if (pkt->side_data_elems) {
2787  size_t size;
2788  const uint8_t *side_metadata;
2789 
2790  side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);
2791  if (side_metadata && size && do_show_packet_tags) {
2792  AVDictionary *dict = NULL;
2793  if (av_packet_unpack_dictionary(side_metadata, size, &dict) >= 0)
2794  show_tags(w, dict, SECTION_ID_PACKET_TAGS);
2795  av_dict_free(&dict);
2796  }
2797 
2798  writer_print_section_header(w, NULL, SECTION_ID_PACKET_SIDE_DATA_LIST);
2799  for (int i = 0; i < pkt->side_data_elems; i++) {
2800  print_pkt_side_data(w, st->codecpar, &pkt->side_data[i],
2801  SECTION_ID_PACKET_SIDE_DATA);
2802  writer_print_section_footer(w);
2803  }
2804  writer_print_section_footer(w);
2805  }
2806 
2807  writer_print_section_footer(w);
2808 
2809  av_bprint_finalize(&pbuf, NULL);
2810  fflush(stdout);
2811 }
2812 
2813 static void show_subtitle(WriterContext *w, AVSubtitle *sub, AVStream *stream,
2814  AVFormatContext *fmt_ctx)
2815 {
2816  AVBPrint pbuf;
2817 
2818  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2819 
2820  writer_print_section_header(w, NULL, SECTION_ID_SUBTITLE);
2821 
2822  print_str ("media_type", "subtitle");
2823  print_ts ("pts", sub->pts);
2824  print_time("pts_time", sub->pts, &AV_TIME_BASE_Q);
2825  print_int ("format", sub->format);
2826  print_int ("start_display_time", sub->start_display_time);
2827  print_int ("end_display_time", sub->end_display_time);
2828  print_int ("num_rects", sub->num_rects);
2829 
2830  writer_print_section_footer(w);
2831 
2832  av_bprint_finalize(&pbuf, NULL);
2833  fflush(stdout);
2834 }
2835 
2836 static void print_frame_side_data(WriterContext *w,
2837  const AVFrame *frame,
2838  const AVStream *stream)
2839 {
2840  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_LIST);
2841 
2842  for (int i = 0; i < frame->nb_side_data; i++) {
2843  const AVFrameSideData *sd = frame->side_data[i];
2844  const char *name;
2845 
2846  writer_print_section_header(w, sd, SECTION_ID_FRAME_SIDE_DATA);
2847  name = av_frame_side_data_name(sd->type);
2848  print_str("side_data_type", name ? name : "unknown");
2849  if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
2850  double rotation = av_display_rotation_get((int32_t *)sd->data);
2851  if (isnan(rotation))
2852  rotation = 0;
2853  writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
2854  print_int("rotation", rotation);
2855  } else if (sd->type == AV_FRAME_DATA_AFD && sd->size > 0) {
2856  print_int("active_format", *sd->data);
2857  } else if (sd->type == AV_FRAME_DATA_GOP_TIMECODE && sd->size >= 8) {
2858  char tcbuf[AV_TIMECODE_STR_SIZE];
2859  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
2860  print_str("timecode", tcbuf);
2861  } else if (sd->type == AV_FRAME_DATA_S12M_TIMECODE && sd->size == 16) {
2862  uint32_t *tc = (uint32_t*)sd->data;
2863  int m = FFMIN(tc[0],3);
2864  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST);
2865  for (int j = 1; j <= m ; j++) {
2866  char tcbuf[AV_TIMECODE_STR_SIZE];
2867  av_timecode_make_smpte_tc_string2(tcbuf, stream->avg_frame_rate, tc[j], 0, 0);
2868  writer_print_section_header(w, NULL, SECTION_ID_FRAME_SIDE_DATA_TIMECODE);
2869  print_str("value", tcbuf);
2870  writer_print_section_footer(w);
2871  }
2872  writer_print_section_footer(w);
2873  } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
2874  AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
2875 
2876  if (metadata->has_primaries) {
2877  print_q("red_x", metadata->display_primaries[0][0], '/');
2878  print_q("red_y", metadata->display_primaries[0][1], '/');
2879  print_q("green_x", metadata->display_primaries[1][0], '/');
2880  print_q("green_y", metadata->display_primaries[1][1], '/');
2881  print_q("blue_x", metadata->display_primaries[2][0], '/');
2882  print_q("blue_y", metadata->display_primaries[2][1], '/');
2883 
2884  print_q("white_point_x", metadata->white_point[0], '/');
2885  print_q("white_point_y", metadata->white_point[1], '/');
2886  }
2887 
2888  if (metadata->has_luminance) {
2889  print_q("min_luminance", metadata->min_luminance, '/');
2890  print_q("max_luminance", metadata->max_luminance, '/');
2891  }
2892  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_PLUS) {
2893  AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
2894  print_dynamic_hdr10_plus(w, metadata);
2895  } else if (sd->type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL) {
2896  AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
2897  print_int("max_content", metadata->MaxCLL);
2898  print_int("max_average", metadata->MaxFALL);
2899  } else if (sd->type == AV_FRAME_DATA_ICC_PROFILE) {
2900  const AVDictionaryEntry *tag = av_dict_get(sd->metadata, "name", NULL, AV_DICT_MATCH_CASE);
2901  if (tag)
2902  print_str(tag->key, tag->value);
2903  print_int("size", sd->size);
2904  } else if (sd->type == AV_FRAME_DATA_DOVI_METADATA) {
2905  print_dovi_metadata(w, (const AVDOVIMetadata *)sd->data);
2906  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_VIVID) {
2907  AVDynamicHDRVivid *metadata = (AVDynamicHDRVivid *)sd->data;
2908  print_dynamic_hdr_vivid(w, metadata);
2909  } else if (sd->type == AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT) {
2910  print_ambient_viewing_environment(w, (const AVAmbientViewingEnvironment *)sd->data);
2911  } else if (sd->type == AV_FRAME_DATA_FILM_GRAIN_PARAMS) {
2912  AVFilmGrainParams *fgp = (AVFilmGrainParams *)sd->data;
2913  print_film_grain_params(w, fgp);
2914  } else if (sd->type == AV_FRAME_DATA_VIEW_ID) {
2915  print_int("view_id", *(int*)sd->data);
2916  }
2917  writer_print_section_footer(w);
2918  }
2919  writer_print_section_footer(w);
2920 }
2921 
2922 static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
2923  AVFormatContext *fmt_ctx)
2924 {
2925  FrameData *fd = frame->opaque_ref ? (FrameData*)frame->opaque_ref->data : NULL;
2926  AVBPrint pbuf;
2927  char val_str[128];
2928  const char *s;
2929 
2930  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2931 
2932  writer_print_section_header(w, NULL, SECTION_ID_FRAME);
2933 
2934  s = av_get_media_type_string(stream->codecpar->codec_type);
2935  if (s) print_str ("media_type", s);
2936  else print_str_opt("media_type", "unknown");
2937  print_int("stream_index", stream->index);
2938  print_int("key_frame", !!(frame->flags & AV_FRAME_FLAG_KEY));
2939  print_ts ("pts", frame->pts);
2940  print_time("pts_time", frame->pts, &stream->time_base);
2941  print_ts ("pkt_dts", frame->pkt_dts);
2942  print_time("pkt_dts_time", frame->pkt_dts, &stream->time_base);
2943  print_ts ("best_effort_timestamp", frame->best_effort_timestamp);
2944  print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
2945  print_duration_ts ("duration", frame->duration);
2946  print_duration_time("duration_time", frame->duration, &stream->time_base);
2947  if (fd && fd->pkt_pos != -1) print_fmt ("pkt_pos", "%"PRId64, fd->pkt_pos);
2948  else print_str_opt("pkt_pos", "N/A");
2949  if (fd && fd->pkt_size != -1) print_val ("pkt_size", fd->pkt_size, unit_byte_str);
2950  else print_str_opt("pkt_size", "N/A");
2951 
2952  switch (stream->codecpar->codec_type) {
2953  AVRational sar;
2954 
2955  case AVMEDIA_TYPE_VIDEO:
2956  print_int("width", frame->width);
2957  print_int("height", frame->height);
2958  print_int("crop_top", frame->crop_top);
2959  print_int("crop_bottom", frame->crop_bottom);
2960  print_int("crop_left", frame->crop_left);
2961  print_int("crop_right", frame->crop_right);
2962  s = av_get_pix_fmt_name(frame->format);
2963  if (s) print_str ("pix_fmt", s);
2964  else print_str_opt("pix_fmt", "unknown");
2965  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
2966  if (sar.num) {
2967  print_q("sample_aspect_ratio", sar, ':');
2968  } else {
2969  print_str_opt("sample_aspect_ratio", "N/A");
2970  }
2971  print_fmt("pict_type", "%c", av_get_picture_type_char(frame->pict_type));
2972  print_int("interlaced_frame", !!(frame->flags & AV_FRAME_FLAG_INTERLACED));
2973  print_int("top_field_first", !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
2974  print_int("lossless", !!(frame->flags & AV_FRAME_FLAG_LOSSLESS));
2975  print_int("repeat_pict", frame->repeat_pict);
2976 
2977  print_color_range(w, frame->color_range);
2978  print_color_space(w, frame->colorspace);
2979  print_primaries(w, frame->color_primaries);
2980  print_color_trc(w, frame->color_trc);
2981  print_chroma_location(w, frame->chroma_location);
2982  break;
2983 
2984  case AVMEDIA_TYPE_AUDIO:
2985  s = av_get_sample_fmt_name(frame->format);
2986  if (s) print_str ("sample_fmt", s);
2987  else print_str_opt("sample_fmt", "unknown");
2988  print_int("nb_samples", frame->nb_samples);
2989  print_int("channels", frame->ch_layout.nb_channels);
2990  if (frame->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
2991  av_channel_layout_describe(&frame->ch_layout, val_str, sizeof(val_str));
2992  print_str ("channel_layout", val_str);
2993  } else
2994  print_str_opt("channel_layout", "unknown");
2995  break;
2996  }
2997  if (do_show_frame_tags)
2998  show_tags(w, frame->metadata, SECTION_ID_FRAME_TAGS);
2999  if (do_show_log)
3000  show_log(w, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log);
3001  if (frame->nb_side_data)
3002  print_frame_side_data(w, frame, stream);
3003 
3004  writer_print_section_footer(w);
3005 
3006  av_bprint_finalize(&pbuf, NULL);
3007  fflush(stdout);
3008 }
3009 
3010 static av_always_inline int process_frame(WriterContext *w,
3011  InputFile *ifile,
3012  AVFrame *frame, const AVPacket *pkt,
3013  int *packet_new)
3014 {
3015  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3016  AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
3017  AVCodecParameters *par = ifile->streams[pkt->stream_index].st->codecpar;
3018  AVSubtitle sub;
3019  int ret = 0, got_frame = 0;
3020 
3021  clear_log(1);
3022  if (dec_ctx) {
3023  switch (par->codec_type) {
3024  case AVMEDIA_TYPE_VIDEO:
3025  case AVMEDIA_TYPE_AUDIO:
3026  if (*packet_new) {
3027  ret = avcodec_send_packet(dec_ctx, pkt);
3028  if (ret == AVERROR(EAGAIN)) {
3029  ret = 0;
3030  } else if (ret >= 0 || ret == AVERROR_EOF) {
3031  ret = 0;
3032  *packet_new = 0;
3033  }
3034  }
3035  if (ret >= 0) {
3036  ret = avcodec_receive_frame(dec_ctx, frame);
3037  if (ret >= 0) {
3038  got_frame = 1;
3039  } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
3040  ret = 0;
3041  }
3042  }
3043  break;
3044 
3045  case AVMEDIA_TYPE_SUBTITLE:
3046  if (*packet_new)
3047  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
3048  *packet_new = 0;
3049  break;
3050  default:
3051  *packet_new = 0;
3052  }
3053  } else {
3054  *packet_new = 0;
3055  }
3056 
3057  if (ret < 0)
3058  return ret;
3059  if (got_frame) {
3060  int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
3061  nb_streams_frames[pkt->stream_index]++;
3062  if (do_show_frames)
3063  if (is_sub)
3064  show_subtitle(w, &sub, ifile->streams[pkt->stream_index].st, fmt_ctx);
3065  else
3066  show_frame(w, frame, ifile->streams[pkt->stream_index].st, fmt_ctx);
3067 
3068  if (!is_sub && do_analyze_frames) {
3069  for (int i = 0; i < frame->nb_side_data; i++) {
3070  if (frame->side_data[i]->type == AV_FRAME_DATA_A53_CC)
3071  streams_with_closed_captions[pkt->stream_index] = 1;
3072  else if (frame->side_data[i]->type == AV_FRAME_DATA_FILM_GRAIN_PARAMS)
3073  streams_with_film_grain[pkt->stream_index] = 1;
3074  }
3075  }
3076 
3077  if (is_sub)
3078  avsubtitle_free(&sub);
3079  }
3080  return got_frame || *packet_new;
3081 }
3082 
3083 static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
3084 {
3085  av_log(log_ctx, log_level, "id:%d", interval->id);
3086 
3087  if (interval->has_start) {
3088  av_log(log_ctx, log_level, " start:%s%s", interval->start_is_offset ? "+" : "",
3089  av_ts2timestr(interval->start, &AV_TIME_BASE_Q));
3090  } else {
3091  av_log(log_ctx, log_level, " start:N/A");
3092  }
3093 
3094  if (interval->has_end) {
3095  av_log(log_ctx, log_level, " end:%s", interval->end_is_offset ? "+" : "");
3096  if (interval->duration_frames)
3097  av_log(log_ctx, log_level, "#%"PRId64, interval->end);
3098  else
3099  av_log(log_ctx, log_level, "%s", av_ts2timestr(interval->end, &AV_TIME_BASE_Q));
3100  } else {
3101  av_log(log_ctx, log_level, " end:N/A");
3102  }
3103 
3104  av_log(log_ctx, log_level, "\n");
3105 }
3106 
3107 static int read_interval_packets(WriterContext *w, InputFile *ifile,
3108  const ReadInterval *interval, int64_t *cur_ts)
3109 {
3110  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3111  AVPacket *pkt = NULL;
3112  AVFrame *frame = NULL;
3113  int ret = 0, i = 0, frame_count = 0;
3114  int64_t start = -INT64_MAX, end = interval->end;
3115  int has_start = 0, has_end = interval->has_end && !interval->end_is_offset;
3116 
3117  av_log(NULL, AV_LOG_VERBOSE, "Processing read interval ");
3118  log_read_interval(interval, NULL, AV_LOG_VERBOSE);
3119 
3120  if (interval->has_start) {
3121  int64_t target;
3122  if (interval->start_is_offset) {
3123  if (*cur_ts == AV_NOPTS_VALUE) {
3124  av_log(NULL, AV_LOG_ERROR,
3125  "Could not seek to relative position since current "
3126  "timestamp is not defined\n");
3127  ret = AVERROR(EINVAL);
3128  goto end;
3129  }
3130  target = *cur_ts + interval->start;
3131  } else {
3132  target = interval->start;
3133  }
3134 
3135  av_log(NULL, AV_LOG_VERBOSE, "Seeking to read interval start point %s\n",
3136  av_ts2timestr(target, &AV_TIME_BASE_Q));
3137  if ((ret = avformat_seek_file(fmt_ctx, -1, -INT64_MAX, target, INT64_MAX, 0)) < 0) {
3138  av_log(NULL, AV_LOG_ERROR, "Could not seek to position %"PRId64": %s\n",
3139  interval->start, av_err2str(ret));
3140  goto end;
3141  }
3142  }
3143 
3144  frame = av_frame_alloc();
3145  if (!frame) {
3146  ret = AVERROR(ENOMEM);
3147  goto end;
3148  }
3149  pkt = av_packet_alloc();
3150  if (!pkt) {
3151  ret = AVERROR(ENOMEM);
3152  goto end;
3153  }
3154  while (!av_read_frame(fmt_ctx, pkt)) {
3155  if (fmt_ctx->nb_streams > nb_streams) {
3156  REALLOCZ_ARRAY_STREAM(nb_streams_frames, nb_streams, fmt_ctx->nb_streams);
3157  REALLOCZ_ARRAY_STREAM(nb_streams_packets, nb_streams, fmt_ctx->nb_streams);
3158  REALLOCZ_ARRAY_STREAM(selected_streams, nb_streams, fmt_ctx->nb_streams);
3159  REALLOCZ_ARRAY_STREAM(streams_with_closed_captions, nb_streams, fmt_ctx->nb_streams);
3160  REALLOCZ_ARRAY_STREAM(streams_with_film_grain, nb_streams, fmt_ctx->nb_streams);
3161  nb_streams = fmt_ctx->nb_streams;
3162  }
3163  if (selected_streams[pkt->stream_index]) {
3164  AVRational tb = ifile->streams[pkt->stream_index].st->time_base;
3165  int64_t pts = pkt->pts != AV_NOPTS_VALUE ? pkt->pts : pkt->dts;
3166 
3167  if (pts != AV_NOPTS_VALUE)
3168  *cur_ts = av_rescale_q(pts, tb, AV_TIME_BASE_Q);
3169 
3170  if (!has_start && *cur_ts != AV_NOPTS_VALUE) {
3171  start = *cur_ts;
3172  has_start = 1;
3173  }
3174 
3175  if (has_start && !has_end && interval->end_is_offset) {
3176  end = start + interval->end;
3177  has_end = 1;
3178  }
3179 
3180  if (interval->end_is_offset && interval->duration_frames) {
3181  if (frame_count >= interval->end)
3182  break;
3183  } else if (has_end && *cur_ts != AV_NOPTS_VALUE && *cur_ts >= end) {
3184  break;
3185  }
3186 
3187  frame_count++;
3188  if (do_read_packets) {
3189  if (do_show_packets)
3190  show_packet(w, ifile, pkt, i++);
3191  nb_streams_packets[pkt->stream_index]++;
3192  }
3193  if (do_read_frames) {
3194  int packet_new = 1;
3195  FrameData *fd;
3196 
3197  pkt->opaque_ref = av_buffer_allocz(sizeof(*fd));
3198  if (!pkt->opaque_ref) {
3199  ret = AVERROR(ENOMEM);
3200  goto end;
3201  }
3202  fd = (FrameData*)pkt->opaque_ref->data;
3203  fd->pkt_pos = pkt->pos;
3204  fd->pkt_size = pkt->size;
3205 
3206  while (process_frame(w, ifile, frame, pkt, &packet_new) > 0);
3207  }
3208  }
3209  av_packet_unref(pkt);
3210  }
3211  av_packet_unref(pkt);
3212  //Flush remaining frames that are cached in the decoder
3213  for (i = 0; i < ifile->nb_streams; i++) {
3214  pkt->stream_index = i;
3215  if (do_read_frames) {
3216  while (process_frame(w, ifile, frame, pkt, &(int){1}) > 0);
3217  if (ifile->streams[i].dec_ctx)
3218  avcodec_flush_buffers(ifile->streams[i].dec_ctx);
3219  }
3220  }
3221 
3222 end:
3223  av_frame_free(&frame);
3224  av_packet_free(&pkt);
3225  if (ret < 0) {
3226  av_log(NULL, AV_LOG_ERROR, "Could not read packets in interval ");
3227  log_read_interval(interval, NULL, AV_LOG_ERROR);
3228  }
3229  return ret;
3230 }
3231 
3232 static int read_packets(WriterContext *w, InputFile *ifile)
3233 {
3234  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3235  int i, ret = 0;
3236  int64_t cur_ts = fmt_ctx->start_time;
3237 
3238  if (read_intervals_nb == 0) {
3239  ReadInterval interval = (ReadInterval) { .has_start = 0, .has_end = 0 };
3240  ret = read_interval_packets(w, ifile, &interval, &cur_ts);
3241  } else {
3242  for (i = 0; i < read_intervals_nb; i++) {
3243  ret = read_interval_packets(w, ifile, &read_intervals[i], &cur_ts);
3244  if (ret < 0)
3245  break;
3246  }
3247  }
3248 
3249  return ret;
3250 }
3251 
3252 static void print_dispositions(WriterContext *w, uint32_t disposition, SectionID section_id)
3253 {
3254  writer_print_section_header(w, NULL, section_id);
3255  for (int i = 0; i < sizeof(disposition) * CHAR_BIT; i++) {
3256  const char *disposition_str = av_disposition_to_string(1U << i);
3257 
3258  if (disposition_str)
3259  print_int(disposition_str, !!(disposition & (1U << i)));
3260  }
3261  writer_print_section_footer(w);
3262 }
3263 
3264 #define IN_PROGRAM 1
3265 #define IN_STREAM_GROUP 2
3266 
3267 static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int container)
3268 {
3269  AVStream *stream = ist->st;
3270  AVCodecParameters *par;
3271  AVCodecContext *dec_ctx;
3272  char val_str[128];
3273  const char *s;
3274  AVRational sar, dar;
3275  AVBPrint pbuf;
3276  const AVCodecDescriptor *cd;
3277  const SectionID section_header[] = {
3278  SECTION_ID_STREAM,
3279  SECTION_ID_PROGRAM_STREAM,
3280  SECTION_ID_STREAM_GROUP_STREAM,
3281  };
3282  const SectionID section_disposition[] = {
3283  SECTION_ID_STREAM_DISPOSITION,
3284  SECTION_ID_PROGRAM_STREAM_DISPOSITION,
3285  SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION,
3286  };
3287  const SectionID section_tags[] = {
3288  SECTION_ID_STREAM_TAGS,
3289  SECTION_ID_PROGRAM_STREAM_TAGS,
3290  SECTION_ID_STREAM_GROUP_STREAM_TAGS,
3291  };
3292  int ret = 0;
3293  const char *profile = NULL;
3294 
3295  av_assert0(container < FF_ARRAY_ELEMS(section_header));
3296 
3297  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
3298 
3299  writer_print_section_header(w, NULL, section_header[container]);
3300 
3301  print_int("index", stream->index);
3302 
3303  par = stream->codecpar;
3304  dec_ctx = ist->dec_ctx;
3305  if (cd = avcodec_descriptor_get(par->codec_id)) {
3306  print_str("codec_name", cd->name);
3307  if (!do_bitexact) {
3308  print_str("codec_long_name",
3309  cd->long_name ? cd->long_name : "unknown");
3310  }
3311  } else {
3312  print_str_opt("codec_name", "unknown");
3313  if (!do_bitexact) {
3314  print_str_opt("codec_long_name", "unknown");
3315  }
3316  }
3317 
3318  if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
3319  print_str("profile", profile);
3320  else {
3321  if (par->profile != AV_PROFILE_UNKNOWN) {
3322  char profile_num[12];
3323  snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
3324  print_str("profile", profile_num);
3325  } else
3326  print_str_opt("profile", "unknown");
3327  }
3328 
3329  s = av_get_media_type_string(par->codec_type);
3330  if (s) print_str ("codec_type", s);
3331  else print_str_opt("codec_type", "unknown");
3332 
3333  /* print AVI/FourCC tag */
3334  print_str("codec_tag_string", av_fourcc2str(par->codec_tag));
3335  print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
3336 
3337  switch (par->codec_type) {
3338  case AVMEDIA_TYPE_VIDEO:
3339  print_int("width", par->width);
3340  print_int("height", par->height);
3341  if (dec_ctx) {
3342  print_int("coded_width", dec_ctx->coded_width);
3343  print_int("coded_height", dec_ctx->coded_height);
3344 
3345  if (do_analyze_frames) {
3346  print_int("closed_captions", streams_with_closed_captions[stream->index]);
3347  print_int("film_grain", streams_with_film_grain[stream->index]);
3348  }
3349  }
3350  print_int("has_b_frames", par->video_delay);
3351  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
3352  if (sar.num) {
3353  print_q("sample_aspect_ratio", sar, ':');
3354  av_reduce(&dar.num, &dar.den,
3355  (int64_t) par->width * sar.num,
3356  (int64_t) par->height * sar.den,
3357  1024*1024);
3358  print_q("display_aspect_ratio", dar, ':');
3359  } else {
3360  print_str_opt("sample_aspect_ratio", "N/A");
3361  print_str_opt("display_aspect_ratio", "N/A");
3362  }
3363  s = av_get_pix_fmt_name(par->format);
3364  if (s) print_str ("pix_fmt", s);
3365  else print_str_opt("pix_fmt", "unknown");
3366  print_int("level", par->level);
3367 
3368  print_color_range(w, par->color_range);
3369  print_color_space(w, par->color_space);
3370  print_color_trc(w, par->color_trc);
3371  print_primaries(w, par->color_primaries);
3372  print_chroma_location(w, par->chroma_location);
3373 
3374  if (par->field_order == AV_FIELD_PROGRESSIVE)
3375  print_str("field_order", "progressive");
3376  else if (par->field_order == AV_FIELD_TT)
3377  print_str("field_order", "tt");
3378  else if (par->field_order == AV_FIELD_BB)
3379  print_str("field_order", "bb");
3380  else if (par->field_order == AV_FIELD_TB)
3381  print_str("field_order", "tb");
3382  else if (par->field_order == AV_FIELD_BT)
3383  print_str("field_order", "bt");
3384  else
3385  print_str_opt("field_order", "unknown");
3386 
3387  if (dec_ctx)
3388  print_int("refs", dec_ctx->refs);
3389  break;
3390 
3391  case AVMEDIA_TYPE_AUDIO:
3392  s = av_get_sample_fmt_name(par->format);
3393  if (s) print_str ("sample_fmt", s);
3394  else print_str_opt("sample_fmt", "unknown");
3395  print_val("sample_rate", par->sample_rate, unit_hertz_str);
3396  print_int("channels", par->ch_layout.nb_channels);
3397 
3398  if (par->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
3399  av_channel_layout_describe(&par->ch_layout, val_str, sizeof(val_str));
3400  print_str ("channel_layout", val_str);
3401  } else {
3402  print_str_opt("channel_layout", "unknown");
3403  }
3404 
3405  print_int("bits_per_sample", av_get_bits_per_sample(par->codec_id));
3406 
3407  print_int("initial_padding", par->initial_padding);
3408  break;
3409 
3410  case AVMEDIA_TYPE_SUBTITLE:
3411  if (par->width)
3412  print_int("width", par->width);
3413  else
3414  print_str_opt("width", "N/A");
3415  if (par->height)
3416  print_int("height", par->height);
3417  else
3418  print_str_opt("height", "N/A");
3419  break;
3420  }
3421 
3422  if (show_private_data) {
3423  if (dec_ctx && dec_ctx->codec->priv_class)
3424  print_private_data(w, dec_ctx->priv_data);
3425  if (fmt_ctx->iformat->priv_class)
3426  print_private_data(w, fmt_ctx->priv_data);
3427  }
3428 
3429  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%x", stream->id);
3430  else print_str_opt("id", "N/A");
3431  print_q("r_frame_rate", stream->r_frame_rate, '/');
3432  print_q("avg_frame_rate", stream->avg_frame_rate, '/');
3433  print_q("time_base", stream->time_base, '/');
3434  print_ts ("start_pts", stream->start_time);
3435  print_time("start_time", stream->start_time, &stream->time_base);
3436  print_ts ("duration_ts", stream->duration);
3437  print_time("duration", stream->duration, &stream->time_base);
3438  if (par->bit_rate > 0) print_val ("bit_rate", par->bit_rate, unit_bit_per_second_str);
3439  else print_str_opt("bit_rate", "N/A");
3440  if (dec_ctx && dec_ctx->rc_max_rate > 0)
3441  print_val ("max_bit_rate", dec_ctx->rc_max_rate, unit_bit_per_second_str);
3442  else
3443  print_str_opt("max_bit_rate", "N/A");
3444  if (dec_ctx && dec_ctx->bits_per_raw_sample > 0) print_fmt("bits_per_raw_sample", "%d", dec_ctx->bits_per_raw_sample);
3445  else print_str_opt("bits_per_raw_sample", "N/A");
3446  if (stream->nb_frames) print_fmt ("nb_frames", "%"PRId64, stream->nb_frames);
3447  else print_str_opt("nb_frames", "N/A");
3448  if (nb_streams_frames[stream_idx]) print_fmt ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
3449  else print_str_opt("nb_read_frames", "N/A");
3450  if (nb_streams_packets[stream_idx]) print_fmt ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
3451  else print_str_opt("nb_read_packets", "N/A");
3452  if (do_show_data)
3453  writer_print_data(w, "extradata", par->extradata,
3454  par->extradata_size);
3455 
3456  if (par->extradata_size > 0) {
3457  print_int("extradata_size", par->extradata_size);
3458  writer_print_data_hash(w, "extradata_hash", par->extradata,
3459  par->extradata_size);
3460  }
3461 
3462  /* Print disposition information */
3463  if (do_show_stream_disposition) {
3464  av_assert0(container < FF_ARRAY_ELEMS(section_disposition));
3465  print_dispositions(w, stream->disposition, section_disposition[container]);
3466  }
3467 
3468  if (do_show_stream_tags) {
3469  av_assert0(container < FF_ARRAY_ELEMS(section_tags));
3470  ret = show_tags(w, stream->metadata, section_tags[container]);
3471  }
3472 
3473  if (stream->codecpar->nb_coded_side_data) {
3474  writer_print_section_header(w, NULL, SECTION_ID_STREAM_SIDE_DATA_LIST);
3475  for (int i = 0; i < stream->codecpar->nb_coded_side_data; i++) {
3476  print_pkt_side_data(w, stream->codecpar, &stream->codecpar->coded_side_data[i],
3477  SECTION_ID_STREAM_SIDE_DATA);
3478  writer_print_section_footer(w);
3479  }
3480  writer_print_section_footer(w);
3481  }
3482 
3483  writer_print_section_footer(w);
3484  av_bprint_finalize(&pbuf, NULL);
3485  fflush(stdout);
3486 
3487  return ret;
3488 }
3489 
3490 static int show_streams(WriterContext *w, InputFile *ifile)
3491 {
3492  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3493  int i, ret = 0;
3494 
3495  writer_print_section_header(w, NULL, SECTION_ID_STREAMS);
3496  for (i = 0; i < ifile->nb_streams; i++)
3497  if (selected_streams[i]) {
3498  ret = show_stream(w, fmt_ctx, i, &ifile->streams[i], 0);
3499  if (ret < 0)
3500  break;
3501  }
3502  writer_print_section_footer(w);
3503 
3504  return ret;
3505 }
3506 
3507 static int show_program(WriterContext *w, InputFile *ifile, AVProgram *program)
3508 {
3509  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3510  int i, ret = 0;
3511 
3512  writer_print_section_header(w, NULL, SECTION_ID_PROGRAM);
3513  print_int("program_id", program->id);
3514  print_int("program_num", program->program_num);
3515  print_int("nb_streams", program->nb_stream_indexes);
3516  print_int("pmt_pid", program->pmt_pid);
3517  print_int("pcr_pid", program->pcr_pid);
3518  if (do_show_program_tags)
3519  ret = show_tags(w, program->metadata, SECTION_ID_PROGRAM_TAGS);
3520  if (ret < 0)
3521  goto end;
3522 
3523  writer_print_section_header(w, NULL, SECTION_ID_PROGRAM_STREAMS);
3524  for (i = 0; i < program->nb_stream_indexes; i++) {
3525  if (selected_streams[program->stream_index[i]]) {
3526  ret = show_stream(w, fmt_ctx, program->stream_index[i], &ifile->streams[program->stream_index[i]], IN_PROGRAM);
3527  if (ret < 0)
3528  break;
3529  }
3530  }
3531  writer_print_section_footer(w);
3532 
3533 end:
3534  writer_print_section_footer(w);
3535  return ret;
3536 }
3537 
3538 static int show_programs(WriterContext *w, InputFile *ifile)
3539 {
3540  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3541  int i, ret = 0;
3542 
3543  writer_print_section_header(w, NULL, SECTION_ID_PROGRAMS);
3544  for (i = 0; i < fmt_ctx->nb_programs; i++) {
3545  AVProgram *program = fmt_ctx->programs[i];
3546  if (!program)
3547  continue;
3548  ret = show_program(w, ifile, program);
3549  if (ret < 0)
3550  break;
3551  }
3552  writer_print_section_footer(w);
3553  return ret;
3554 }
3555 
3556 static void print_tile_grid_params(WriterContext *w, const AVStreamGroup *stg,
3557  const AVStreamGroupTileGrid *tile_grid)
3558 {
3559  writer_print_section_header(w, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
3560  print_int("nb_tiles", tile_grid->nb_tiles);
3561  print_int("coded_width", tile_grid->coded_width);
3562  print_int("coded_height", tile_grid->coded_height);
3563  print_int("horizontal_offset", tile_grid->horizontal_offset);
3564  print_int("vertical_offset", tile_grid->vertical_offset);
3565  print_int("width", tile_grid->width);
3566  print_int("height", tile_grid->height);
3567  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
3568  for (int i = 0; i < tile_grid->nb_tiles; i++) {
3569  writer_print_section_header(w, "tile_offset", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3570  print_int("stream_index", tile_grid->offsets[i].idx);
3571  print_int("tile_horizontal_offset", tile_grid->offsets[i].horizontal);
3572  print_int("tile_vertical_offset", tile_grid->offsets[i].vertical);
3573  writer_print_section_footer(w);
3574  }
3575  writer_print_section_footer(w);
3576  writer_print_section_footer(w);
3577 }
3578 
3579 static void print_iamf_param_definition(WriterContext *w, const char *name,
3580  const AVIAMFParamDefinition *param, SectionID section_id)
3581 {
3582  SectionID subsection_id, parameter_section_id;
3583  subsection_id = sections[section_id].children_ids[0];
3584  av_assert0(subsection_id != -1);
3585  parameter_section_id = sections[subsection_id].children_ids[0];
3586  av_assert0(parameter_section_id != -1);
3587  writer_print_section_header(w, "IAMF Param Definition", section_id);
3588  print_str("name", name);
3589  print_int("nb_subblocks", param->nb_subblocks);
3590  print_int("type", param->type);
3591  print_int("parameter_id", param->parameter_id);
3592  print_int("parameter_rate", param->parameter_rate);
3593  print_int("duration", param->duration);
3594  print_int("constant_subblock_duration", param->constant_subblock_duration);
3595  if (param->nb_subblocks > 0)
3596  writer_print_section_header(w, NULL, subsection_id);
3597  for (int i = 0; i < param->nb_subblocks; i++) {
3598  const void *subblock = av_iamf_param_definition_get_subblock(param, i);
3599  switch(param->type) {
3600  case AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN: {
3601  const AVIAMFMixGain *mix = subblock;
3602  writer_print_section_header(w, "IAMF Mix Gain Parameters", parameter_section_id);
3603  print_int("subblock_duration", mix->subblock_duration);
3604  print_int("animation_type", mix->animation_type);
3605  print_q("start_point_value", mix->start_point_value, '/');
3606  print_q("end_point_value", mix->end_point_value, '/');
3607  print_q("control_point_value", mix->control_point_value, '/');
3608  print_q("control_point_relative_time", mix->control_point_relative_time, '/');
3609  writer_print_section_footer(w); // parameter_section_id
3610  break;
3611  }
3612  case AV_IAMF_PARAMETER_DEFINITION_DEMIXING: {
3613  const AVIAMFDemixingInfo *demix = subblock;
3614  writer_print_section_header(w, "IAMF Demixing Info", parameter_section_id);
3615  print_int("subblock_duration", demix->subblock_duration);
3616  print_int("dmixp_mode", demix->dmixp_mode);
3617  writer_print_section_footer(w); // parameter_section_id
3618  break;
3619  }
3620  case AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN: {
3621  const AVIAMFReconGain *recon = subblock;
3622  writer_print_section_header(w, "IAMF Recon Gain", parameter_section_id);
3623  print_int("subblock_duration", recon->subblock_duration);
3624  writer_print_section_footer(w); // parameter_section_id
3625  break;
3626  }
3627  }
3628  }
3629  if (param->nb_subblocks > 0)
3630  writer_print_section_footer(w); // subsection_id
3631  writer_print_section_footer(w); // section_id
3632 }
3633 
3634 static void print_iamf_audio_element_params(WriterContext *w, const AVStreamGroup *stg,
3635  const AVIAMFAudioElement *audio_element)
3636 {
3637  writer_print_section_header(w, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
3638  print_int("nb_layers", audio_element->nb_layers);
3639  print_int("audio_element_type", audio_element->audio_element_type);
3640  print_int("default_w", audio_element->default_w);
3641  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
3642  for (int i = 0; i < audio_element->nb_layers; i++) {
3643  const AVIAMFLayer *layer = audio_element->layers[i];
3644  char val_str[128];
3645  writer_print_section_header(w, "IAMF Audio Layer", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3646  av_channel_layout_describe(&layer->ch_layout, val_str, sizeof(val_str));
3647  print_str("channel_layout", val_str);
3648  if (audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL) {
3649  print_int("output_gain_flags", layer->output_gain_flags);
3650  print_q("output_gain", layer->output_gain, '/');
3651  } else if (audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE)
3652  print_int("ambisonics_mode", layer->ambisonics_mode);
3653  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
3654  }
3655  if (audio_element->demixing_info)
3656  print_iamf_param_definition(w, "demixing_info", audio_element->demixing_info,
3657  SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3658  if (audio_element->recon_gain_info)
3659  print_iamf_param_definition(w, "recon_gain_info", audio_element->recon_gain_info,
3660  SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3661  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
3662  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_COMPONENT
3663 }
3664 
3665 static void print_iamf_submix_params(WriterContext *w, const AVIAMFSubmix *submix)
3666 {
3667  writer_print_section_header(w, "IAMF Submix", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3668  print_int("nb_elements", submix->nb_elements);
3669  print_int("nb_layouts", submix->nb_layouts);
3670  print_q("default_mix_gain", submix->default_mix_gain, '/');
3671  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_PIECES);
3672  for (int i = 0; i < submix->nb_elements; i++) {
3673  const AVIAMFSubmixElement *element = submix->elements[i];
3674  writer_print_section_header(w, "IAMF Submix Element", SECTION_ID_STREAM_GROUP_PIECE);
3675  print_int("stream_id", element->audio_element_id);
3676  print_q("default_mix_gain", element->default_mix_gain, '/');
3677  print_int("headphones_rendering_mode", element->headphones_rendering_mode);
3678  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBPIECES);
3679  if (element->annotations) {
3680  const AVDictionaryEntry *annotation = NULL;
3681  writer_print_section_header(w, "IAMF Annotations", SECTION_ID_STREAM_GROUP_SUBPIECE);
3682  while (annotation = av_dict_iterate(element->annotations, annotation))
3683  print_str(annotation->key, annotation->value);
3684  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBPIECE
3685  }
3686  if (element->element_mix_config)
3687  print_iamf_param_definition(w, "element_mix_config", element->element_mix_config,
3688  SECTION_ID_STREAM_GROUP_SUBPIECE);
3689  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBPIECES
3690  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_PIECE
3691  }
3692  if (submix->output_mix_config)
3693  print_iamf_param_definition(w, "output_mix_config", submix->output_mix_config,
3694  SECTION_ID_STREAM_GROUP_PIECE);
3695  for (int i = 0; i < submix->nb_layouts; i++) {
3696  const AVIAMFSubmixLayout *layout = submix->layouts[i];
3697  char val_str[128];
3698  writer_print_section_header(w, "IAMF Submix Layout", SECTION_ID_STREAM_GROUP_PIECE);
3699  av_channel_layout_describe(&layout->sound_system, val_str, sizeof(val_str));
3700  print_str("sound_system", val_str);
3701  print_q("integrated_loudness", layout->integrated_loudness, '/');
3702  print_q("digital_peak", layout->digital_peak, '/');
3703  print_q("true_peak", layout->true_peak, '/');
3704  print_q("dialogue_anchored_loudness", layout->dialogue_anchored_loudness, '/');
3705  print_q("album_anchored_loudness", layout->album_anchored_loudness, '/');
3706  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_PIECE
3707  }
3708  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_PIECES
3709  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
3710 }
3711 
3712 static void print_iamf_mix_presentation_params(WriterContext *w, const AVStreamGroup *stg,
3713  const AVIAMFMixPresentation *mix_presentation)
3714 {
3715  writer_print_section_header(w, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
3716  print_int("nb_submixes", mix_presentation->nb_submixes);
3717  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
3718  if (mix_presentation->annotations) {
3719  const AVDictionaryEntry *annotation = NULL;
3720  writer_print_section_header(w, "IAMF Annotations", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
3721  while (annotation = av_dict_iterate(mix_presentation->annotations, annotation))
3722  print_str(annotation->key, annotation->value);
3723  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
3724  }
3725  for (int i = 0; i < mix_presentation->nb_submixes; i++)
3726  print_iamf_submix_params(w, mix_presentation->submixes[i]);
3727  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
3728  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_COMPONENT
3729 }
3730 
3731 static void print_stream_group_params(WriterContext *w, AVStreamGroup *stg)
3732 {
3733  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_COMPONENTS);
3734  if (stg->type == AV_STREAM_GROUP_PARAMS_TILE_GRID)
3735  print_tile_grid_params(w, stg, stg->params.tile_grid);
3736  else if (stg->type == AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT)
3737  print_iamf_audio_element_params(w, stg, stg->params.iamf_audio_element);
3738  else if (stg->type == AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION)
3739  print_iamf_mix_presentation_params(w, stg, stg->params.iamf_mix_presentation);
3740  writer_print_section_footer(w); // SECTION_ID_STREAM_GROUP_COMPONENTS
3741 }
3742 
3743 static int show_stream_group(WriterContext *w, InputFile *ifile, AVStreamGroup *stg)
3744 {
3745  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3746  AVBPrint pbuf;
3747  int i, ret = 0;
3748 
3749  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
3750  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP);
3751  print_int("index", stg->index);
3752  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%"PRIx64, stg->id);
3753  else print_str_opt("id", "N/A");
3754  print_int("nb_streams", stg->nb_streams);
3755  if (stg->type != AV_STREAM_GROUP_PARAMS_NONE)
3756  print_str("type", av_x_if_null(avformat_stream_group_name(stg->type), "unknown"));
3757  else
3758  print_str_opt("type", "unknown");
3759  if (do_show_stream_group_components)
3760  print_stream_group_params(w, stg);
3761 
3762  /* Print disposition information */
3763  if (do_show_stream_group_disposition)
3764  print_dispositions(w, stg->disposition, SECTION_ID_STREAM_GROUP_DISPOSITION);
3765 
3766  if (do_show_stream_group_tags)
3767  ret = show_tags(w, stg->metadata, SECTION_ID_STREAM_GROUP_TAGS);
3768  if (ret < 0)
3769  goto end;
3770 
3771  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUP_STREAMS);
3772  for (i = 0; i < stg->nb_streams; i++) {
3773  if (selected_streams[stg->streams[i]->index]) {
3774  ret = show_stream(w, fmt_ctx, stg->streams[i]->index, &ifile->streams[stg->streams[i]->index], IN_STREAM_GROUP);
3775  if (ret < 0)
3776  break;
3777  }
3778  }
3779  writer_print_section_footer(w);
3780 
3781 end:
3782  av_bprint_finalize(&pbuf, NULL);
3783  writer_print_section_footer(w);
3784  return ret;
3785 }
3786 
3787 static int show_stream_groups(WriterContext *w, InputFile *ifile)
3788 {
3789  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3790  int i, ret = 0;
3791 
3792  writer_print_section_header(w, NULL, SECTION_ID_STREAM_GROUPS);
3793  for (i = 0; i < fmt_ctx->nb_stream_groups; i++) {
3794  AVStreamGroup *stg = fmt_ctx->stream_groups[i];
3795 
3796  ret = show_stream_group(w, ifile, stg);
3797  if (ret < 0)
3798  break;
3799  }
3800  writer_print_section_footer(w);
3801  return ret;
3802 }
3803 
3804 static int show_chapters(WriterContext *w, InputFile *ifile)
3805 {
3806  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3807  int i, ret = 0;
3808 
3809  writer_print_section_header(w, NULL, SECTION_ID_CHAPTERS);
3810  for (i = 0; i < fmt_ctx->nb_chapters; i++) {
3811  AVChapter *chapter = fmt_ctx->chapters[i];
3812 
3813  writer_print_section_header(w, NULL, SECTION_ID_CHAPTER);
3814  print_int("id", chapter->id);
3815  print_q ("time_base", chapter->time_base, '/');
3816  print_int("start", chapter->start);
3817  print_time("start_time", chapter->start, &chapter->time_base);
3818  print_int("end", chapter->end);
3819  print_time("end_time", chapter->end, &chapter->time_base);
3820  if (do_show_chapter_tags)
3821  ret = show_tags(w, chapter->metadata, SECTION_ID_CHAPTER_TAGS);
3822  writer_print_section_footer(w);
3823  }
3824  writer_print_section_footer(w);
3825 
3826  return ret;
3827 }
3828 
3829 static int show_format(WriterContext *w, InputFile *ifile)
3830 {
3831  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
3832  char val_str[128];
3833  int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
3834  int ret = 0;
3835 
3836  writer_print_section_header(w, NULL, SECTION_ID_FORMAT);
3837  print_str_validate("filename", fmt_ctx->url);
3838  print_int("nb_streams", fmt_ctx->nb_streams);
3839  print_int("nb_programs", fmt_ctx->nb_programs);
3840  print_int("nb_stream_groups", fmt_ctx->nb_stream_groups);
3841  print_str("format_name", fmt_ctx->iformat->name);
3842  if (!do_bitexact) {
3843  if (fmt_ctx->iformat->long_name) print_str ("format_long_name", fmt_ctx->iformat->long_name);
3844  else print_str_opt("format_long_name", "unknown");
3845  }
3846  print_time("start_time", fmt_ctx->start_time, &AV_TIME_BASE_Q);
3847  print_time("duration", fmt_ctx->duration, &AV_TIME_BASE_Q);
3848  if (size >= 0) print_val ("size", size, unit_byte_str);
3849  else print_str_opt("size", "N/A");
3850  if (fmt_ctx->bit_rate > 0) print_val ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
3851  else print_str_opt("bit_rate", "N/A");
3852  print_int("probe_score", fmt_ctx->probe_score);
3853  if (do_show_format_tags)
3854  ret = show_tags(w, fmt_ctx->metadata, SECTION_ID_FORMAT_TAGS);
3855 
3856  writer_print_section_footer(w);
3857  fflush(stdout);
3858  return ret;
3859 }
3860 
3861 static void show_error(WriterContext *w, int err)
3862 {
3863  writer_print_section_header(w, NULL, SECTION_ID_ERROR);
3864  print_int("code", err);
3865  print_str("string", av_err2str(err));
3866  writer_print_section_footer(w);
3867 }
3868 
3869 static int open_input_file(InputFile *ifile, const char *filename,
3870  const char *print_filename)
3871 {
3872  int err, i;
3873  AVFormatContext *fmt_ctx = NULL;
3874  const AVDictionaryEntry *t = NULL;
3875  int scan_all_pmts_set = 0;
3876 
3877  fmt_ctx = avformat_alloc_context();
3878  if (!fmt_ctx)
3879  return AVERROR(ENOMEM);
3880 
3881  if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
3882  av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
3883  scan_all_pmts_set = 1;
3884  }
3885  if ((err = avformat_open_input(&fmt_ctx, filename,
3886  iformat, &format_opts)) < 0) {
3887  print_error(filename, err);
3888  return err;
3889  }
3890  if (print_filename) {
3891  av_freep(&fmt_ctx->url);
3892  fmt_ctx->url = av_strdup(print_filename);
3893  }
3894  ifile->fmt_ctx = fmt_ctx;
3895  if (scan_all_pmts_set)
3896  av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
3897  while ((t = av_dict_iterate(format_opts, t)))
3898  av_log(NULL, AV_LOG_WARNING, "Option %s skipped - not known to demuxer.\n", t->key);
3899 
3900  if (find_stream_info) {
3901  AVDictionary **opts;
3902  int orig_nb_streams = fmt_ctx->nb_streams;
3903 
3904  err = setup_find_stream_info_opts(fmt_ctx, codec_opts, &opts);
3905  if (err < 0)
3906  return err;
3907 
3908  err = avformat_find_stream_info(fmt_ctx, opts);
3909 
3910  for (i = 0; i < orig_nb_streams; i++)
3911  av_dict_free(&opts[i]);
3912  av_freep(&opts);
3913 
3914  if (err < 0) {
3915  print_error(filename, err);
3916  return err;
3917  }
3918  }
3919 
3920  av_dump_format(fmt_ctx, 0, filename, 0);
3921 
3922  ifile->streams = av_calloc(fmt_ctx->nb_streams, sizeof(*ifile->streams));
3923  if (!ifile->streams)
3924  exit(1);
3925  ifile->nb_streams = fmt_ctx->nb_streams;
3926 
3927  /* bind a decoder to each input stream */
3928  for (i = 0; i < fmt_ctx->nb_streams; i++) {
3929  InputStream *ist = &ifile->streams[i];
3930  AVStream *stream = fmt_ctx->streams[i];
3931  const AVCodec *codec;
3932 
3933  ist->st = stream;
3934 
3935  if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
3936  av_log(NULL, AV_LOG_WARNING,
3937  "Failed to probe codec for input stream %d\n",
3938  stream->index);
3939  continue;
3940  }
3941 
3942  codec = avcodec_find_decoder(stream->codecpar->codec_id);
3943  if (!codec) {
3944  av_log(NULL, AV_LOG_WARNING,
3945  "Unsupported codec with id %d for input stream %d\n",
3946  stream->codecpar->codec_id, stream->index);
3947  continue;
3948  }
3949  {
3950  AVDictionary *opts;
3951 
3952  err = filter_codec_opts(codec_opts, stream->codecpar->codec_id,
3953  fmt_ctx, stream, codec, &opts, NULL);
3954  if (err < 0)
3955  exit(1);
3956 
3957  ist->dec_ctx = avcodec_alloc_context3(codec);
3958  if (!ist->dec_ctx)
3959  exit(1);
3960 
3961  err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
3962  if (err < 0)
3963  exit(1);
3964 
3965  if (do_show_log) {
3966  // For loging it is needed to disable at least frame threads as otherwise
3967  // the log information would need to be reordered and matches up to contexts and frames
3968  // That is in fact possible but not trivial
3969  av_dict_set(&codec_opts, "threads", "1", 0);
3970  }
3971 
3972  av_dict_set(&opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
3973 
3974  ist->dec_ctx->pkt_timebase = stream->time_base;
3975 
3976  if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
3977  av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
3978  stream->index);
3979  exit(1);
3980  }
3981 
3982  if ((t = av_dict_iterate(opts, NULL))) {
3983  av_log(NULL, AV_LOG_ERROR, "Option %s for input stream %d not found\n",
3984  t->key, stream->index);
3985  return AVERROR_OPTION_NOT_FOUND;
3986  }
3987  }
3988  }
3989 
3990  ifile->fmt_ctx = fmt_ctx;
3991  return 0;
3992 }
3993 
3994 static void close_input_file(InputFile *ifile)
3995 {
3996  int i;
3997 
3998  /* close decoder for each stream */
3999  for (i = 0; i < ifile->nb_streams; i++)
4000  avcodec_free_context(&ifile->streams[i].dec_ctx);
4001 
4002  av_freep(&ifile->streams);
4003  ifile->nb_streams = 0;
4004 
4005  avformat_close_input(&ifile->fmt_ctx);
4006 }
4007 
4008 static int probe_file(WriterContext *wctx, const char *filename,
4009  const char *print_filename)
4010 {
4011  InputFile ifile = { 0 };
4012  int ret, i;
4013  int section_id;
4014 
4015  do_analyze_frames = do_analyze_frames && do_show_streams;
4016  do_read_frames = do_show_frames || do_count_frames || do_analyze_frames;
4017  do_read_packets = do_show_packets || do_count_packets;
4018 
4019  ret = open_input_file(&ifile, filename, print_filename);
4020  if (ret < 0)
4021  goto end;
4022 
4023 #define CHECK_END if (ret < 0) goto end
4024 
4025  nb_streams = ifile.fmt_ctx->nb_streams;
4026  REALLOCZ_ARRAY_STREAM(nb_streams_frames,0,ifile.fmt_ctx->nb_streams);
4027  REALLOCZ_ARRAY_STREAM(nb_streams_packets,0,ifile.fmt_ctx->nb_streams);
4028  REALLOCZ_ARRAY_STREAM(selected_streams,0,ifile.fmt_ctx->nb_streams);
4029  REALLOCZ_ARRAY_STREAM(streams_with_closed_captions,0,ifile.fmt_ctx->nb_streams);
4030  REALLOCZ_ARRAY_STREAM(streams_with_film_grain,0,ifile.fmt_ctx->nb_streams);
4031 
4032  for (i = 0; i < ifile.fmt_ctx->nb_streams; i++) {
4033  if (stream_specifier) {
4034  ret = avformat_match_stream_specifier(ifile.fmt_ctx,
4035  ifile.fmt_ctx->streams[i],
4036  stream_specifier);
4037  CHECK_END;
4038  else
4039  selected_streams[i] = ret;
4040  ret = 0;
4041  } else {
4042  selected_streams[i] = 1;
4043  }
4044  if (!selected_streams[i])
4045  ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
4046  }
4047 
4048  if (do_read_frames || do_read_packets) {
4049  if (do_show_frames && do_show_packets &&
4050  wctx->writer->flags & WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER)
4051  section_id = SECTION_ID_PACKETS_AND_FRAMES;
4052  else if (do_show_packets && !do_show_frames)
4053  section_id = SECTION_ID_PACKETS;
4054  else // (!do_show_packets && do_show_frames)
4055  section_id = SECTION_ID_FRAMES;
4056  if (do_show_frames || do_show_packets)
4057  writer_print_section_header(wctx, NULL, section_id);
4058  ret = read_packets(wctx, &ifile);
4059  if (do_show_frames || do_show_packets)
4060  writer_print_section_footer(wctx);
4061  CHECK_END;
4062  }
4063 
4064  if (do_show_programs) {
4065  ret = show_programs(wctx, &ifile);
4066  CHECK_END;
4067  }
4068 
4069  if (do_show_stream_groups) {
4070  ret = show_stream_groups(wctx, &ifile);
4071  CHECK_END;
4072  }
4073 
4074  if (do_show_streams) {
4075  ret = show_streams(wctx, &ifile);
4076  CHECK_END;
4077  }
4078  if (do_show_chapters) {
4079  ret = show_chapters(wctx, &ifile);
4080  CHECK_END;
4081  }
4082  if (do_show_format) {
4083  ret = show_format(wctx, &ifile);
4084  CHECK_END;
4085  }
4086 
4087 end:
4088  if (ifile.fmt_ctx)
4089  close_input_file(&ifile);
4090  av_freep(&nb_streams_frames);
4091  av_freep(&nb_streams_packets);
4092  av_freep(&selected_streams);
4093  av_freep(&streams_with_closed_captions);
4094  av_freep(&streams_with_film_grain);
4095 
4096  return ret;
4097 }
4098 
4099 static void show_usage(void)
4100 {
4101  av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
4102  av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] INPUT_FILE\n", program_name);
4103  av_log(NULL, AV_LOG_INFO, "\n");
4104 }
4105 
4106 static void ffprobe_show_program_version(WriterContext *w)
4107 {
4108  AVBPrint pbuf;
4109  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
4110 
4111  writer_print_section_header(w, NULL, SECTION_ID_PROGRAM_VERSION);
4112  print_str("version", FFMPEG_VERSION);
4113  print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
4114  program_birth_year, CONFIG_THIS_YEAR);
4115  print_str("compiler_ident", CC_IDENT);
4116  print_str("configuration", FFMPEG_CONFIGURATION);
4117  writer_print_section_footer(w);
4118 
4119  av_bprint_finalize(&pbuf, NULL);
4120 }
4121 
4122 #define SHOW_LIB_VERSION(libname, LIBNAME) \
4123  do { \
4124  if (CONFIG_##LIBNAME) { \
4125  unsigned int version = libname##_version(); \
4126  writer_print_section_header(w, NULL, SECTION_ID_LIBRARY_VERSION); \
4127  print_str("name", "lib" #libname); \
4128  print_int("major", LIB##LIBNAME##_VERSION_MAJOR); \
4129  print_int("minor", LIB##LIBNAME##_VERSION_MINOR); \
4130  print_int("micro", LIB##LIBNAME##_VERSION_MICRO); \
4131  print_int("version", version); \
4132  print_str("ident", LIB##LIBNAME##_IDENT); \
4133  writer_print_section_footer(w); \
4134  } \
4135  } while (0)
4136 
4137 static void ffprobe_show_library_versions(WriterContext *w)
4138 {
4139  writer_print_section_header(w, NULL, SECTION_ID_LIBRARY_VERSIONS);
4140  SHOW_LIB_VERSION(avutil, AVUTIL);
4141  SHOW_LIB_VERSION(avcodec, AVCODEC);
4142  SHOW_LIB_VERSION(avformat, AVFORMAT);
4143  SHOW_LIB_VERSION(avdevice, AVDEVICE);
4144  SHOW_LIB_VERSION(avfilter, AVFILTER);
4145  SHOW_LIB_VERSION(swscale, SWSCALE);
4146  SHOW_LIB_VERSION(swresample, SWRESAMPLE);
4147  SHOW_LIB_VERSION(postproc, POSTPROC);
4148  writer_print_section_footer(w);
4149 }
4150 
4151 #define PRINT_PIX_FMT_FLAG(flagname, name) \
4152  do { \
4153  print_int(name, !!(pixdesc->flags & AV_PIX_FMT_FLAG_##flagname)); \
4154  } while (0)
4155 
4156 static void ffprobe_show_pixel_formats(WriterContext *w)
4157 {
4158  const AVPixFmtDescriptor *pixdesc = NULL;
4159  int i, n;
4160 
4161  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMATS);
4162  while (pixdesc = av_pix_fmt_desc_next(pixdesc)) {
4163  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT);
4164  print_str("name", pixdesc->name);
4165  print_int("nb_components", pixdesc->nb_components);
4166  if ((pixdesc->nb_components >= 3) && !(pixdesc->flags & AV_PIX_FMT_FLAG_RGB)) {
4167  print_int ("log2_chroma_w", pixdesc->log2_chroma_w);
4168  print_int ("log2_chroma_h", pixdesc->log2_chroma_h);
4169  } else {
4170  print_str_opt("log2_chroma_w", "N/A");
4171  print_str_opt("log2_chroma_h", "N/A");
4172  }
4173  n = av_get_bits_per_pixel(pixdesc);
4174  if (n) print_int ("bits_per_pixel", n);
4175  else print_str_opt("bits_per_pixel", "N/A");
4176  if (do_show_pixel_format_flags) {
4177  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT_FLAGS);
4178  PRINT_PIX_FMT_FLAG(BE, "big_endian");
4179  PRINT_PIX_FMT_FLAG(PAL, "palette");
4180  PRINT_PIX_FMT_FLAG(BITSTREAM, "bitstream");
4181  PRINT_PIX_FMT_FLAG(HWACCEL, "hwaccel");
4182  PRINT_PIX_FMT_FLAG(PLANAR, "planar");
4183  PRINT_PIX_FMT_FLAG(RGB, "rgb");
4184  PRINT_PIX_FMT_FLAG(ALPHA, "alpha");
4185  writer_print_section_footer(w);
4186  }
4187  if (do_show_pixel_format_components && (pixdesc->nb_components > 0)) {
4188  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT_COMPONENTS);
4189  for (i = 0; i < pixdesc->nb_components; i++) {
4190  writer_print_section_header(w, NULL, SECTION_ID_PIXEL_FORMAT_COMPONENT);
4191  print_int("index", i + 1);
4192  print_int("bit_depth", pixdesc->comp[i].depth);
4193  writer_print_section_footer(w);
4194  }
4195  writer_print_section_footer(w);
4196  }
4197  writer_print_section_footer(w);
4198  }
4199  writer_print_section_footer(w);
4200 }
4201 
4202 static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
4203 {
4204  if (!av_strcasecmp(arg, "always")) show_optional_fields = SHOW_OPTIONAL_FIELDS_ALWAYS;
4205  else if (!av_strcasecmp(arg, "never")) show_optional_fields = SHOW_OPTIONAL_FIELDS_NEVER;
4206  else if (!av_strcasecmp(arg, "auto")) show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
4207 
4208  if (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO && av_strcasecmp(arg, "auto")) {
4209  double num;
4210  int ret = parse_number("show_optional_fields", arg, OPT_TYPE_INT,
4211  SHOW_OPTIONAL_FIELDS_AUTO, SHOW_OPTIONAL_FIELDS_ALWAYS, &num);
4212  if (ret < 0)
4213  return ret;
4214  show_optional_fields = num;
4215  }
4216  return 0;
4217 }
4218 
4219 static int opt_format(void *optctx, const char *opt, const char *arg)
4220 {
4221  iformat = av_find_input_format(arg);
4222  if (!iformat) {
4223  av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
4224  return AVERROR(EINVAL);
4225  }
4226  return 0;
4227 }
4228 
4229 static inline void mark_section_show_entries(SectionID section_id,
4230  int show_all_entries, AVDictionary *entries)
4231 {
4232  struct section *section = &sections[section_id];
4233 
4234  section->show_all_entries = show_all_entries;
4235  if (show_all_entries) {
4236  for (const SectionID *id = section->children_ids; *id != -1; id++)
4237  mark_section_show_entries(*id, show_all_entries, entries);
4238  } else {
4239  av_dict_copy(&section->entries_to_show, entries, 0);
4240  }
4241 }
4242 
4243 static int match_section(const char *section_name,
4244  int show_all_entries, AVDictionary *entries)
4245 {
4246  int i, ret = 0;
4247 
4248  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) {
4249  const struct section *section = &sections[i];
4250  if (!strcmp(section_name, section->name) ||
4251  (section->unique_name && !strcmp(section_name, section->unique_name))) {
4252  av_log(NULL, AV_LOG_DEBUG,
4253  "'%s' matches section with unique name '%s'\n", section_name,
4254  (char *)av_x_if_null(section->unique_name, section->name));
4255  ret++;
4256  mark_section_show_entries(section->id, show_all_entries, entries);
4257  }
4258  }
4259  return ret;
4260 }
4261 
4262 static int opt_show_entries(void *optctx, const char *opt, const char *arg)
4263 {
4264  const char *p = arg;
4265  int ret = 0;
4266 
4267  while (*p) {
4268  AVDictionary *entries = NULL;
4269  char *section_name = av_get_token(&p, "=:");
4270  int show_all_entries = 0;
4271 
4272  if (!section_name) {
4273  av_log(NULL, AV_LOG_ERROR,
4274  "Missing section name for option '%s'\n", opt);
4275  return AVERROR(EINVAL);
4276  }
4277 
4278  if (*p == '=') {
4279  p++;
4280  while (*p && *p != ':') {
4281  char *entry = av_get_token(&p, ",:");
4282  if (!entry)
4283  break;
4284  av_log(NULL, AV_LOG_VERBOSE,
4285  "Adding '%s' to the entries to show in section '%s'\n",
4286  entry, section_name);
4287  av_dict_set(&entries, entry, "", AV_DICT_DONT_STRDUP_KEY);
4288  if (*p == ',')
4289  p++;
4290  }
4291  } else {
4292  show_all_entries = 1;
4293  }
4294 
4295  ret = match_section(section_name, show_all_entries, entries);
4296  if (ret == 0) {
4297  av_log(NULL, AV_LOG_ERROR, "No match for section '%s'\n", section_name);
4298  ret = AVERROR(EINVAL);
4299  }
4300  av_dict_free(&entries);
4301  av_free(section_name);
4302 
4303  if (ret <= 0)
4304  break;
4305  if (*p)
4306  p++;
4307  }
4308 
4309  return ret;
4310 }
4311 
4312 static int opt_input_file(void *optctx, const char *arg)
4313 {
4314  if (input_filename) {
4315  av_log(NULL, AV_LOG_ERROR,
4316  "Argument '%s' provided as input filename, but '%s' was already specified.\n",
4317  arg, input_filename);
4318  return AVERROR(EINVAL);
4319  }
4320  if (!strcmp(arg, "-"))
4321  arg = "fd:";
4322  input_filename = av_strdup(arg);
4323  if (!input_filename)
4324  return AVERROR(ENOMEM);
4325 
4326  return 0;
4327 }
4328 
4329 static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
4330 {
4331  opt_input_file(optctx, arg);
4332  return 0;
4333 }
4334 
4335 static int opt_output_file_o(void *optctx, const char *opt, const char *arg)
4336 {
4337  if (output_filename) {
4338  av_log(NULL, AV_LOG_ERROR,
4339  "Argument '%s' provided as output filename, but '%s' was already specified.\n",
4340  arg, output_filename);
4341  return AVERROR(EINVAL);
4342  }
4343  if (!strcmp(arg, "-"))
4344  arg = "fd:";
4345  output_filename = av_strdup(arg);
4346  if (!output_filename)
4347  return AVERROR(ENOMEM);
4348 
4349  return 0;
4350 }
4351 
4352 static int opt_print_filename(void *optctx, const char *opt, const char *arg)
4353 {
4354  av_freep(&print_input_filename);
4355  print_input_filename = av_strdup(arg);
4356  return print_input_filename ? 0 : AVERROR(ENOMEM);
4357 }
4358 
4359 void show_help_default(const char *opt, const char *arg)
4360 {
4361  av_log_set_callback(log_callback_help);
4362  show_usage();
4363  show_help_options(options, "Main options:", 0, 0);
4364  printf("\n");
4365 
4366  show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
4367  show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
4368 }
4369 
4370 /**
4371  * Parse interval specification, according to the format:
4372  * INTERVAL ::= [START|+START_OFFSET][%[END|+END_OFFSET]]
4373  * INTERVALS ::= INTERVAL[,INTERVALS]
4374 */
4375 static int parse_read_interval(const char *interval_spec,
4376  ReadInterval *interval)
4377 {
4378  int ret = 0;
4379  char *next, *p, *spec = av_strdup(interval_spec);
4380  if (!spec)
4381  return AVERROR(ENOMEM);
4382 
4383  if (!*spec) {
4384  av_log(NULL, AV_LOG_ERROR, "Invalid empty interval specification\n");
4385  ret = AVERROR(EINVAL);
4386  goto end;
4387  }
4388 
4389  p = spec;
4390  next = strchr(spec, '%');
4391  if (next)
4392  *next++ = 0;
4393 
4394  /* parse first part */
4395  if (*p) {
4396  interval->has_start = 1;
4397 
4398  if (*p == '+') {
4399  interval->start_is_offset = 1;
4400  p++;
4401  } else {
4402  interval->start_is_offset = 0;
4403  }
4404 
4405  ret = av_parse_time(&interval->start, p, 1);
4406  if (ret < 0) {
4407  av_log(NULL, AV_LOG_ERROR, "Invalid interval start specification '%s'\n", p);
4408  goto end;
4409  }
4410  } else {
4411  interval->has_start = 0;
4412  }
4413 
4414  /* parse second part */
4415  p = next;
4416  if (p && *p) {
4417  int64_t us;
4418  interval->has_end = 1;
4419 
4420  if (*p == '+') {
4421  interval->end_is_offset = 1;
4422  p++;
4423  } else {
4424  interval->end_is_offset = 0;
4425  }
4426 
4427  if (interval->end_is_offset && *p == '#') {
4428  long long int lli;
4429  char *tail;
4430  interval->duration_frames = 1;
4431  p++;
4432  lli = strtoll(p, &tail, 10);
4433  if (*tail || lli < 0) {
4434  av_log(NULL, AV_LOG_ERROR,
4435  "Invalid or negative value '%s' for duration number of frames\n", p);
4436  goto end;
4437  }
4438  interval->end = lli;
4439  } else {
4440  interval->duration_frames = 0;
4441  ret = av_parse_time(&us, p, 1);
4442  if (ret < 0) {
4443  av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
4444  goto end;
4445  }
4446  interval->end = us;
4447  }
4448  } else {
4449  interval->has_end = 0;
4450  }
4451 
4452 end:
4453  av_free(spec);
4454  return ret;
4455 }
4456 
4457 static int parse_read_intervals(const char *intervals_spec)
4458 {
4459  int ret, n, i;
4460  char *p, *spec = av_strdup(intervals_spec);
4461  if (!spec)
4462  return AVERROR(ENOMEM);
4463 
4464  /* preparse specification, get number of intervals */
4465  for (n = 0, p = spec; *p; p++)
4466  if (*p == ',')
4467  n++;
4468  n++;
4469 
4470  read_intervals = av_malloc_array(n, sizeof(*read_intervals));
4471  if (!read_intervals) {
4472  ret = AVERROR(ENOMEM);
4473  goto end;
4474  }
4475  read_intervals_nb = n;
4476 
4477  /* parse intervals */
4478  p = spec;
4479  for (i = 0; p; i++) {
4480  char *next;
4481 
4482  av_assert0(i < read_intervals_nb);
4483  next = strchr(p, ',');
4484  if (next)
4485  *next++ = 0;
4486 
4487  read_intervals[i].id = i;
4488  ret = parse_read_interval(p, &read_intervals[i]);
4489  if (ret < 0) {
4490  av_log(NULL, AV_LOG_ERROR, "Error parsing read interval #%d '%s'\n",
4491  i, p);
4492  goto end;
4493  }
4494  av_log(NULL, AV_LOG_VERBOSE, "Parsed log interval ");
4495  log_read_interval(&read_intervals[i], NULL, AV_LOG_VERBOSE);
4496  p = next;
4497  }
4498  av_assert0(i == read_intervals_nb);
4499 
4500 end:
4501  av_free(spec);
4502  return ret;
4503 }
4504 
4505 static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
4506 {
4507  return parse_read_intervals(arg);
4508 }
4509 
4510 static int opt_pretty(void *optctx, const char *opt, const char *arg)
4511 {
4512  show_value_unit = 1;
4513  use_value_prefix = 1;
4514  use_byte_value_binary_prefix = 1;
4515  use_value_sexagesimal_format = 1;
4516  return 0;
4517 }
4518 
4519 static void print_section(SectionID id, int level)
4520 {
4521  const SectionID *pid;
4522  const struct section *section = &sections[id];
4523  printf("%c%c%c%c",
4524  section->flags & SECTION_FLAG_IS_WRAPPER ? 'W' : '.',
4525  section->flags & SECTION_FLAG_IS_ARRAY ? 'A' : '.',
4526  section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS ? 'V' : '.',
4527  section->flags & SECTION_FLAG_HAS_TYPE ? 'T' : '.');
4528  printf("%*c %s", level * 4, ' ', section->name);
4529  if (section->unique_name)
4530  printf("/%s", section->unique_name);
4531  printf("\n");
4532 
4533  for (pid = section->children_ids; *pid != -1; pid++)
4534  print_section(*pid, level+1);
4535 }
4536 
4537 static int opt_sections(void *optctx, const char *opt, const char *arg)
4538 {
4539  printf("Sections:\n"
4540  "W... = Section is a wrapper (contains other sections, no local entries)\n"
4541  ".A.. = Section contains an array of elements of the same type\n"
4542  "..V. = Section may contain a variable number of fields with variable keys\n"
4543  "...T = Section contain a unique type\n"
4544  "FLAGS NAME/UNIQUE_NAME\n"
4545  "----\n");
4546  print_section(SECTION_ID_ROOT, 0);
4547  return 0;
4548 }
4549 
4550 static int opt_show_versions(void *optctx, const char *opt, const char *arg)
4551 {
4552  mark_section_show_entries(SECTION_ID_PROGRAM_VERSION, 1, NULL);
4553  mark_section_show_entries(SECTION_ID_LIBRARY_VERSION, 1, NULL);
4554  return 0;
4555 }
4556 
4557 #define DEFINE_OPT_SHOW_SECTION(section, target_section_id) \
4558  static int opt_show_##section(void *optctx, const char *opt, const char *arg) \
4559  { \
4560  mark_section_show_entries(SECTION_ID_##target_section_id, 1, NULL); \
4561  return 0; \
4562  }
4563 
4564 DEFINE_OPT_SHOW_SECTION(chapters, CHAPTERS)
4565 DEFINE_OPT_SHOW_SECTION(error, ERROR)
4566 DEFINE_OPT_SHOW_SECTION(format, FORMAT)
4567 DEFINE_OPT_SHOW_SECTION(frames, FRAMES)
4568 DEFINE_OPT_SHOW_SECTION(library_versions, LIBRARY_VERSIONS)
4569 DEFINE_OPT_SHOW_SECTION(packets, PACKETS)
4570 DEFINE_OPT_SHOW_SECTION(pixel_formats, PIXEL_FORMATS)
4571 DEFINE_OPT_SHOW_SECTION(program_version, PROGRAM_VERSION)
4572 DEFINE_OPT_SHOW_SECTION(streams, STREAMS)
4573 DEFINE_OPT_SHOW_SECTION(programs, PROGRAMS)
4574 DEFINE_OPT_SHOW_SECTION(stream_groups, STREAM_GROUPS)
4575 
4576 static const OptionDef real_options[] = {
4577  CMDUTILS_COMMON_OPTIONS
4578  { "f", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_format}, "force format", "format" },
4579  { "unit", OPT_TYPE_BOOL, 0, {&show_value_unit}, "show unit of the displayed values" },
4580  { "prefix", OPT_TYPE_BOOL, 0, {&use_value_prefix}, "use SI prefixes for the displayed values" },
4581  { "byte_binary_prefix", OPT_TYPE_BOOL, 0, {&use_byte_value_binary_prefix},
4582  "use binary prefixes for byte units" },
4583  { "sexagesimal", OPT_TYPE_BOOL, 0, {&use_value_sexagesimal_format},
4584  "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
4585  { "pretty", OPT_TYPE_FUNC, 0, {.func_arg = opt_pretty},
4586  "prettify the format of displayed values, make it more human readable" },
4587  { "output_format", OPT_TYPE_STRING, 0, { &output_format },
4588  "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
4589  { "print_format", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format (deprecated)" },
4590  { "of", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format", "format" },
4591  { "select_streams", OPT_TYPE_STRING, 0, { &stream_specifier }, "select the specified streams", "stream_specifier" },
4592  { "sections", OPT_TYPE_FUNC, OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
4593  { "show_data", OPT_TYPE_BOOL, 0, { &do_show_data }, "show packets data" },
4594  { "show_data_hash", OPT_TYPE_STRING, 0, { &show_data_hash }, "show packets data hash" },
4595  { "show_error", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_error }, "show probing error" },
4596  { "show_format", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_format }, "show format/container info" },
4597  { "show_frames", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_frames }, "show frames info" },
4598  { "show_entries", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_show_entries},
4599  "show a set of specified entries", "entry_list" },
4600 #if HAVE_THREADS
4601  { "show_log", OPT_TYPE_INT, 0, { &do_show_log }, "show log" },
4602 #endif
4603  { "show_packets", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_packets }, "show packets info" },
4604  { "show_programs", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_programs }, "show programs info" },
4605  { "show_stream_groups", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_stream_groups }, "show stream groups info" },
4606  { "show_streams", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_streams }, "show streams info" },
4607  { "show_chapters", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_chapters }, "show chapters info" },
4608  { "count_frames", OPT_TYPE_BOOL, 0, { &do_count_frames }, "count the number of frames per stream" },
4609  { "count_packets", OPT_TYPE_BOOL, 0, { &do_count_packets }, "count the number of packets per stream" },
4610  { "show_program_version", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" },
4611  { "show_library_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_library_versions }, "show library versions" },
4612  { "show_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_versions }, "show program and library versions" },
4613  { "show_pixel_formats", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" },
4614  { "show_optional_fields", OPT_TYPE_FUNC, OPT_FUNC_ARG, { .func_arg = &opt_show_optional_fields }, "show optional fields" },
4615  { "show_private_data", OPT_TYPE_BOOL, 0, { &show_private_data }, "show private data" },
4616  { "private", OPT_TYPE_BOOL, 0, { &show_private_data }, "same as show_private_data" },
4617  { "analyze_frames", OPT_TYPE_BOOL, 0, { &do_analyze_frames }, "analyze frames to provide additional stream-level information" },
4618  { "bitexact", OPT_TYPE_BOOL, 0, {&do_bitexact}, "force bitexact output" },
4619  { "read_intervals", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
4620  { "i", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
4621  { "o", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_output_file_o}, "write to specified output", "output_file"},
4622  { "print_filename", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"},
4623  { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT, { &find_stream_info },
4624  "read and decode the streams to fill missing information with heuristics" },
4625  { NULL, },
4626 };
4627 
4628 static inline int check_section_show_entries(int section_id)
4629 {
4630  struct section *section = &sections[section_id];
4631  if (sections[section_id].show_all_entries || sections[section_id].entries_to_show)
4632  return 1;
4633  for (const SectionID *id = section->children_ids; *id != -1; id++)
4634  if (check_section_show_entries(*id))
4635  return 1;
4636  return 0;
4637 }
4638 
4639 #define SET_DO_SHOW(id, varname) do { \
4640  if (check_section_show_entries(SECTION_ID_##id)) \
4641  do_show_##varname = 1; \
4642  } while (0)
4643 
4644 int main(int argc, char **argv)
4645 {
4646  const Writer *w;
4647  WriterContext *wctx;
4648  char *buf;
4649  char *w_name = NULL, *w_args = NULL;
4650  int ret, input_ret, i;
4651 
4652  init_dynload();
4653 
4654  av_log_set_flags(AV_LOG_SKIP_REPEATED);
4655 
4656  options = real_options;
4657  parse_loglevel(argc, argv, options);
4658  avformat_network_init();
4659 #if CONFIG_AVDEVICE
4660  avdevice_register_all();
4661 #endif
4662 
4663  show_banner(argc, argv, options);
4664  ret = parse_options(NULL, argc, argv, options, opt_input_file);
4665  if (ret < 0) {
4666  ret = (ret == AVERROR_EXIT) ? 0 : ret;
4667  goto end;
4668  }
4669 
4670  if (do_show_log)
4671  av_log_set_callback(log_callback);
4672 
4673  /* mark things to show, based on -show_entries */
4674  SET_DO_SHOW(CHAPTERS, chapters);
4675  SET_DO_SHOW(ERROR, error);
4676  SET_DO_SHOW(FORMAT, format);
4677  SET_DO_SHOW(FRAMES, frames);
4678  SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
4679  SET_DO_SHOW(PACKETS, packets);
4680  SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
4681  SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
4682  SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
4683  SET_DO_SHOW(PROGRAM_VERSION, program_version);
4684  SET_DO_SHOW(PROGRAMS, programs);
4685  SET_DO_SHOW(STREAM_GROUP_DISPOSITION, stream_group_disposition);
4686  SET_DO_SHOW(STREAM_GROUPS, stream_groups);
4687  SET_DO_SHOW(STREAM_GROUP_COMPONENTS, stream_group_components);
4688  SET_DO_SHOW(STREAMS, streams);
4689  SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
4690  SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
4691  SET_DO_SHOW(STREAM_GROUP_STREAM_DISPOSITION, stream_disposition);
4692 
4693  SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
4694  SET_DO_SHOW(FORMAT_TAGS, format_tags);
4695  SET_DO_SHOW(FRAME_TAGS, frame_tags);
4696  SET_DO_SHOW(PROGRAM_TAGS, program_tags);
4697  SET_DO_SHOW(STREAM_GROUP_TAGS, stream_group_tags);
4698  SET_DO_SHOW(STREAM_TAGS, stream_tags);
4699  SET_DO_SHOW(PROGRAM_STREAM_TAGS, stream_tags);
4700  SET_DO_SHOW(STREAM_GROUP_STREAM_TAGS, stream_tags);
4701  SET_DO_SHOW(PACKET_TAGS, packet_tags);
4702 
4703  if (do_bitexact && (do_show_program_version || do_show_library_versions)) {
4704  av_log(NULL, AV_LOG_ERROR,
4705  "-bitexact and -show_program_version or -show_library_versions "
4706  "options are incompatible\n");
4707  ret = AVERROR(EINVAL);
4708  goto end;
4709  }
4710 
4711  writer_register_all();
4712 
4713  if (!output_format)
4714  output_format = av_strdup("default");
4715  if (!output_format) {
4716  ret = AVERROR(ENOMEM);
4717  goto end;
4718  }
4719  w_name = av_strtok(output_format, "=", &buf);
4720  if (!w_name) {
4721  av_log(NULL, AV_LOG_ERROR,
4722  "No name specified for the output format\n");
4723  ret = AVERROR(EINVAL);
4724  goto end;
4725  }
4726  w_args = buf;
4727 
4728  if (show_data_hash) {
4729  if ((ret = av_hash_alloc(&hash, show_data_hash)) < 0) {
4730  if (ret == AVERROR(EINVAL)) {
4731  const char *n;
4732  av_log(NULL, AV_LOG_ERROR,
4733  "Unknown hash algorithm '%s'\nKnown algorithms:",
4734  show_data_hash);
4735  for (i = 0; (n = av_hash_names(i)); i++)
4736  av_log(NULL, AV_LOG_ERROR, " %s", n);
4737  av_log(NULL, AV_LOG_ERROR, "\n");
4738  }
4739  goto end;
4740  }
4741  }
4742 
4743  w = writer_get_by_name(w_name);
4744  if (!w) {
4745  av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
4746  ret = AVERROR(EINVAL);
4747  goto end;
4748  }
4749 
4750  if ((ret = writer_open(&wctx, w, w_args,
4751  sections, FF_ARRAY_ELEMS(sections), output_filename)) >= 0) {
4752  if (w == &xml_writer)
4753  wctx->string_validation_utf8_flags |= AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES;
4754 
4755  writer_print_section_header(wctx, NULL, SECTION_ID_ROOT);
4756 
4757  if (do_show_program_version)
4758  ffprobe_show_program_version(wctx);
4759  if (do_show_library_versions)
4760  ffprobe_show_library_versions(wctx);
4761  if (do_show_pixel_formats)
4762  ffprobe_show_pixel_formats(wctx);
4763 
4764  if (!input_filename &&
4765  ((do_show_format || do_show_programs || do_show_stream_groups || do_show_streams || do_show_chapters || do_show_packets || do_show_error) ||
4766  (!do_show_program_version && !do_show_library_versions && !do_show_pixel_formats))) {
4767  show_usage();
4768  av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
4769  av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
4770  ret = AVERROR(EINVAL);
4771  } else if (input_filename) {
4772  ret = probe_file(wctx, input_filename, print_input_filename);
4773  if (ret < 0 && do_show_error)
4774  show_error(wctx, ret);
4775  }
4776 
4777  input_ret = ret;
4778 
4779  writer_print_section_footer(wctx);
4780  ret = writer_close(&wctx);
4781  if (ret < 0)
4782  av_log(NULL, AV_LOG_ERROR, "Writing output failed: %s\n", av_err2str(ret));
4783 
4784  ret = FFMIN(ret, input_ret);
4785  }
4786 
4787 end:
4788  av_freep(&output_format);
4789  av_freep(&output_filename);
4790  av_freep(&input_filename);
4791  av_freep(&print_input_filename);
4792  av_freep(&read_intervals);
4793  av_hash_freep(&hash);
4794 
4795  uninit_opts();
4796  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
4797  av_dict_free(&(sections[i].entries_to_show));
4798 
4799  avformat_network_deinit();
4800 
4801  return ret < 0;
4802 }
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:4644
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
AVSubtitle
Definition: avcodec.h:2257
SECTION_ID_STREAM_SIDE_DATA_LIST
@ SECTION_ID_STREAM_SIDE_DATA_LIST
Definition: ffprobe.c:226
opt_format
static int opt_format(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4219
AVHDRVividColorTransformParams::maximum_maxrgb
AVRational maximum_maxrgb
Indicates the maximum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:260
clear_log
static void clear_log(int need_lock)
Definition: ffprobe.c:2704
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:4229
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:105
RGB
Definition: cms.c:66
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:203
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:107
AVCodec
AVCodec.
Definition: codec.h:187
writer_get_by_name
static const Writer * writer_get_by_name(const char *name)
Definition: ffprobe.c:1049
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
AVFormatContext::stream_groups
AVStreamGroup ** stream_groups
A list of all stream groups in the file.
Definition: avformat.h:1387
MAX_REGISTERED_WRITERS_NB
#define MAX_REGISTERED_WRITERS_NB
Definition: ffprobe.c: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:1153
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
av_clip
#define av_clip
Definition: common.h:100
InputFile::fmt_ctx
AVFormatContext * fmt_ctx
Definition: ffprobe.c: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:3787
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1263
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
unit_value::i
int64_t i
Definition: ffprobe.c:445
opt_show_optional_fields
static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4202
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:4335
show_stream_group
static int show_stream_group(WriterContext *w, InputFile *ifile, AVStreamGroup *stg)
Definition: ffprobe.c:3743
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVStreamGroup::tile_grid
struct AVStreamGroupTileGrid * tile_grid
Definition: avformat.h:1169
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:477
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:98
ReadInterval::end_is_offset
int end_is_offset
Definition: ffprobe.c:148
LogBuffer::log_message
char * log_message
Definition: ffprobe.c:386
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:627
libm.h
FrameData
Definition: ffmpeg.h:656
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:3490
AVFilmGrainParams::bit_depth_luma
int bit_depth_luma
Intended bit depth, or 0 for unknown/unspecified.
Definition: film_grain_params.h:287
Writer::name
const char * name
Definition: ffprobe.c: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:81
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:1400
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVHDRPlusPercentile::percentile
AVRational percentile
The linearized maxRGB value at a specific percentile in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:52
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:221
AVAmbientViewingEnvironment
Ambient viewing environment metadata as defined by H.274.
Definition: ambient_viewing_environment.h:36
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
AVIAMFAudioElement::default_w
unsigned int default_w
Default weight value as defined in section 3.6 of IAMF.
Definition: iamf.h:393
Writer::init
int(* init)(WriterContext *wctx)
Definition: ffprobe.c: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:3232
AVStreamGroupTileGrid::horizontal_offset
int horizontal_offset
Offset in pixels from the left edge of the canvas where the actual image meant for presentation start...
Definition: avformat.h:1054
AVIAMFAudioElement::layers
AVIAMFLayer ** layers
Definition: iamf.h:359
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:202
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:2755
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:601
CompactContext::print_section
int print_section
Definition: ffprobe.c: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
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:2261
AVFilmGrainAOMParams::uv_points
uint8_t uv_points[2][10][2]
Definition: film_grain_params.h:63
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse
uint16_t semimajor_axis_external_ellipse
The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:134
AVFilmGrainH274Params::blending_mode_id
int blending_mode_id
Specifies the blending mode used to blend the simulated film grain with the decoded images.
Definition: film_grain_params.h:182
AVIAMFMixPresentation::nb_submixes
unsigned int nb_submixes
Number of submixes in the presentation.
Definition: iamf.h:629
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:201
AVStreamGroup::disposition
int disposition
Stream group disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1211
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
DefaultContext
Definition: ffprobe.c:1076
AVHDRVividColorTransformParams::tone_mapping_param_num
int tone_mapping_param_num
The number of tone mapping param.
Definition: hdr_dynamic_vivid_metadata.h:272
Writer::priv_class
const AVClass * priv_class
private class of the writer, if any
Definition: ffprobe.c: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:163
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
WriterContext::section
const struct section * section[SECTION_MAX_NB_LEVELS]
section per each level
Definition: ffprobe.c: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:260
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:4329
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:1368
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:390
w
uint8_t w
Definition: llviddspenc.c:38
validate_string
static int validate_string(WriterContext *wctx, char **dstp, const char *src)
Definition: ffprobe.c: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:253
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:558
flat_print_section_header
static void flat_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c: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:539
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:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:630
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:837
AVStreamGroupTileGrid::vertical_offset
int vertical_offset
Offset in pixels from the top edge of the canvas where the actual image meant for presentation starts...
Definition: avformat.h:1061
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1262
data
const char data[16]
Definition: mxf.c:149
avio_open
int avio_open(AVIOContext **s, const char *filename, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: avio.c:497
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:3255
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:3665
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:282
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:1501
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:3200
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
SECTION_ID_STREAM_GROUP_SUBCOMPONENT
@ SECTION_ID_STREAM_GROUP_SUBCOMPONENT
Definition: ffprobe.c: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:4628
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:4519
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:34
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:602
AVStreamGroupTileGrid::vertical
int vertical
Offset in pixels from the top edge of the canvas where the tile should be placed.
Definition: avformat.h:1036
SECTION_ID_STREAM_GROUP_BLOCKS
@ SECTION_ID_STREAM_GROUP_BLOCKS
Definition: ffprobe.c: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:442
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:1556
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
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:289
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
dec_val
double dec_val
Definition: ffprobe.c: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
AVStreamGroup::params
union AVStreamGroup::@368 params
Group type-specific parameters.
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
AVFilmGrainParams::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:281
do_show_format_tags
static int do_show_format_tags
Definition: ffprobe.c: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:250
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3645
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:3252
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:560
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:674
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:3010
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
InputStream
Definition: ffmpeg.h:435
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:392
match_section
static int match_section(const char *section_name, int show_all_entries, AVDictionary *entries)
Definition: ffprobe.c:4243
print_iamf_param_definition
static void print_iamf_param_definition(WriterContext *w, const char *name, const AVIAMFParamDefinition *param, SectionID section_id)
Definition: ffprobe.c:3579
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:3624
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:4510
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
json_options
static const AVOption json_options[]
Definition: ffprobe.c: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:277
av_hash_get_name
const char * av_hash_get_name(const AVHashContext *ctx)
Definition: hash.c:104
AV_DOVI_COMPRESSION_EXTENDED
@ AV_DOVI_COMPRESSION_EXTENDED
Definition: dovi_meta.h:71
LogBuffer::log_level
int log_level
Definition: ffprobe.c:385
AVStreamGroupTileGrid
AVStreamGroupTileGrid holds information on how to combine several independent images on a single canv...
Definition: avformat.h:987
AVFilmGrainAOMParams::grain_scale_shift
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
Definition: film_grain_params.h:99
print_chroma_location
static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
Definition: ffprobe.c:2694
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:336
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:1002
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:729
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
AVDynamicHDRVivid::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_vivid_metadata.h:320
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
AVChapter
Definition: avformat.h:1259
print_tile_grid_params
static void print_tile_grid_params(WriterContext *w, const AVStreamGroup *stg, const AVStreamGroupTileGrid *tile_grid)
Definition: ffprobe.c:3556
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:4359
AVStreamGroupTileGrid::coded_height
int coded_height
Width of the canvas.
Definition: avformat.h:1008
c_escape_str
static const char * c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
Apply C-language-like string escaping.
Definition: ffprobe.c: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:647
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
show_log
static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
Definition: ffprobe.c:2720
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:807
AVAmbientViewingEnvironment::ambient_illuminance
AVRational ambient_illuminance
Environmental illuminance of the ambient viewing environment in lux.
Definition: ambient_viewing_environment.h:40
input_filename
static const char * input_filename
Definition: ffprobe.c: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:551
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:205
InputFile
Definition: ffmpeg.h:469
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:4505
AVFilmGrainH274Params::intensity_interval_upper_bound
uint8_t intensity_interval_upper_bound[3][256]
Specifies the upper bound of each intensity interval for which the set of model values applies for th...
Definition: film_grain_params.h:216
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
AV_PKT_DATA_WEBVTT_SETTINGS
@ AV_PKT_DATA_WEBVTT_SETTINGS
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:199
AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
Subblocks are of struct type AVIAMFReconGain.
Definition: iamf.h:181
close_input_file
static void close_input_file(InputFile *ifile)
Definition: ffprobe.c:3994
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:151
parse_read_intervals
static int parse_read_intervals(const char *intervals_spec)
Definition: ffprobe.c:4457
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1442
AVStreamGroupTileGrid::offsets
struct AVStreamGroupTileGrid::@367 * offsets
An nb_tiles sized array of offsets in pixels from the topleft edge of the canvas, indicating where ea...
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, const AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:983
json_print_item_str
static void json_print_item_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c: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::codec
union AVFilmGrainParams::@441 codec
Additional fields may be added both here and in any structure included.
AVFilmGrainParams::bit_depth_chroma
int bit_depth_chroma
Definition: film_grain_params.h:288
avassert.h
writer_print_time
static void writer_print_time(WriterContext *wctx, const char *key, int64_t ts, const AVRational *time_base, int is_duration)
Definition: ffprobe.c:935
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2922
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:1535
film_grain_params.h
AVFrameSideData::size
size_t size
Definition: frame.h:268
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:548
av_cold
#define av_cold
Definition: attributes.h:90
AVDOVIRpuDataHeader::chroma_resampling_explicit_filter_flag
uint8_t chroma_resampling_explicit_filter_flag
Definition: dovi_meta.h:92
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:595
print_iamf_audio_element_params
static void print_iamf_audio_element_params(WriterContext *w, const AVStreamGroup *stg, const AVIAMFAudioElement *audio_element)
Definition: ffprobe.c:3634
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:269
AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES
#define AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES
Within AV_ESCAPE_MODE_XML, additionally escape double quotes for double quoted attributes.
Definition: avstring.h:348
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:661
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:62
postprocess.h
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:653
SECTION_ID_STREAM_GROUP_STREAMS
@ SECTION_ID_STREAM_GROUP_STREAMS
Definition: ffprobe.c: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:1126
AVDOVIRpuDataHeader::rpu_type
uint8_t rpu_type
Definition: dovi_meta.h:88
initialized
static int initialized
Definition: vaapi_transcode.c:43
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
av_packet_side_data_name
const char * av_packet_side_data_name(enum AVPacketSideDataType type)
Definition: packet.c:270
do_count_frames
static int do_count_frames
Definition: ffprobe.c:98
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1262
writer_child_next
static void * writer_child_next(void *obj, void *prev)
Definition: ffprobe.c: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:3083
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:3507
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:1500
AVHDRPlusColorTransformParams::window_upper_left_corner_y
AVRational window_upper_left_corner_y
The relative y coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:76
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1312
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1401
AVHDRPlusColorTransformParams::window_lower_right_corner_x
AVRational window_lower_right_corner_x
The relative x coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:85
SECTION_ID_SUBTITLE
@ SECTION_ID_SUBTITLE
Definition: ffprobe.c:228
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:717
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVIAMFSubmixElement::headphones_rendering_mode
enum AVIAMFHeadphonesMode headphones_rendering_mode
A value that indicates whether the referenced channel-based Audio Element shall be rendered to stereo...
Definition: iamf.h:478
xml_print_str
static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c: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:1145
probe_file
static int probe_file(WriterContext *wctx, const char *filename, const char *print_filename)
Definition: ffprobe.c:4008
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:1593
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:391
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:740
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:4106
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:3265
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2263
pixel_formats
static enum AVPixelFormat pixel_formats[]
Definition: vf_sr.c:64
do_show_chapter_tags
static int do_show_chapter_tags
Definition: ffprobe.c: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:1310
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:227
key
const char * key
Definition: hwcontext_opencl.c:189
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
color_range
color_range
Definition: vf_selectivecolor.c:43
flat_escape_value_str
static const char * flat_escape_value_str(AVBPrint *dst, const char *src)
Definition: ffprobe.c: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:605
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
AV_FILM_GRAIN_PARAMS_NONE
@ AV_FILM_GRAIN_PARAMS_NONE
Definition: film_grain_params.h:25
AVFormatContext::probe_score
int probe_score
format probing score.
Definition: avformat.h:1768
show_chapters
static int show_chapters(WriterContext *w, InputFile *ifile)
Definition: ffprobe.c:3804
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:3869
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:3564
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:1300
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:771
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:787
NULL
#define NULL
Definition: coverity.c:32
compact_print_str
static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
Definition: ffprobe.c: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:4639
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:2654
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:443
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
AVHDRVividColorTransformParams::color_saturation_gain
AVRational color_saturation_gain[8]
Indicates the color correction strength parameter.
Definition: hdr_dynamic_vivid_metadata.h:296
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
av_hash_init
void av_hash_init(AVHashContext *ctx)
Initialize or reset a hash context.
Definition: hash.c:151
AV_DOVI_MAPPING_MMR
@ AV_DOVI_MAPPING_MMR
Definition: dovi_meta.h:109
OPT_EXPERT
#define OPT_EXPERT
Definition: cmdutils.h:207
ERROR
static void ERROR(const char *str)
Definition: audio_fifo.c:58
do_read_frames
static int do_read_frames
Definition: ffprobe.c: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:340
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:393
filter_codec_opts
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst, AVDictionary **opts_used)
Filter out options for given codec.
Definition: cmdutils.c:1350
print_q
#define print_q(k, v, s)
Definition: ffprobe.c: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:1342
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:310
WriterContext::name
char * name
name of this writer instance
Definition: ffprobe.c:543
options
Definition: swscale.c:42
AVHDRVividColorTransformParams::color_saturation_mapping_flag
int color_saturation_mapping_flag
This flag indicates that the metadata for the color saturation mapping in the processing window is pr...
Definition: hdr_dynamic_vivid_metadata.h:283
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3582
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:2684
print_stream_group_params
static void print_stream_group_params(WriterContext *w, AVStreamGroup *stg)
Definition: ffprobe.c:3731
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVFilmGrainParams::subsampling_x
int subsampling_x
Intended subsampling ratio, or 0 for luma-only streams.
Definition: film_grain_params.h:274
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:126
do_show_programs
static int do_show_programs
Definition: ffprobe.c: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:266
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:3107
real_options
static const OptionDef real_options[]
Definition: ffprobe.c:4576
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:699
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:3829
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:809
SECTION_ID_CHAPTER
@ SECTION_ID_CHAPTER
Definition: ffprobe.c: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:1019
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:1356
AVStereo3D::primary_eye
enum AVStereo3DPrimaryEye primary_eye
Which eye is the primary eye when rendering in 2D.
Definition: stereo3d.h:222
color_primaries
static const AVColorPrimariesDesc color_primaries[AVCOL_PRI_NB]
Definition: csp.c:76
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1127
print_input_filename
static const char * print_input_filename
Definition: ffprobe.c: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:2534
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:540
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:694
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:4151
csv
int csv
Definition: checkasm.c:407
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:192
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:132
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:296
AVDOVIRpuDataHeader::vdr_rpu_profile
uint8_t vdr_rpu_profile
Definition: dovi_meta.h:90
AVDynamicHDRPlus::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_metadata.h:259
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
av_stereo3d_primary_eye_name
const char * av_stereo3d_primary_eye_name(unsigned int eye)
Provide a human-readable name of a given stereo3d primary eye.
Definition: stereo3d.c:133
XMLContext::fully_qualified
int fully_qualified
Definition: ffprobe.c:1805
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1416
SECTION_FLAG_IS_ARRAY
#define SECTION_FLAG_IS_ARRAY
the section contains an array of elements of the same type
Definition: ffprobe.c:236
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:565
SectionID
SectionID
Definition: ffprobe.c: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:246
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:1167
opt_show_versions
static int opt_show_versions(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4550
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:238
opt_input_file
static int opt_input_file(void *optctx, const char *arg)
Definition: ffprobe.c:4312
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
PAL
#define PAL
Definition: bktr.c:68
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:753
ffprobe_show_library_versions
static void ffprobe_show_library_versions(WriterContext *w)
Definition: ffprobe.c:4137
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:2260
avdevice.h
show_error
static void show_error(WriterContext *w, int err)
Definition: ffprobe.c:3861
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:2836
AVHDRVividColorToneMappingParams::base_param_k1
int base_param_k1
indicates k1_0 in the base parameter, base_param_k1 <= 1: k1_0 = base_param_k1 base_param_k1 > 1: res...
Definition: hdr_dynamic_vivid_metadata.h:130
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:194
AVIAMFParamDefinition::constant_subblock_duration
unsigned int constant_subblock_duration
The duration of every subblock in the case where all subblocks, with the optional exception of the la...
Definition: iamf.h:238
WriterContext::nb_section_frame
unsigned int nb_section_frame
number of the frame section in case we are in "packets_and_frames" section
Definition: ffprobe.c: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:995
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVHashContext
Definition: hash.c:66
line
Definition: graph2dot.c:48
SECTION_ID_STREAM_GROUP_STREAM_TAGS
@ SECTION_ID_STREAM_GROUP_STREAM_TAGS
Definition: ffprobe.c: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:545
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:64
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
do_show_format
static int do_show_format
Definition: ffprobe.c: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:261
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:1125
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:1201
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:1168
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:752
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:728
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:48
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:142
bprint.h
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
AVHDRPlusColorTransformParams::semimajor_axis_internal_ellipse
uint16_t semimajor_axis_internal_ellipse
The semi-major axis value of the internal ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:125
AVStreamGroupTileGrid::width
int width
Width of the final image for presentation.
Definition: avformat.h:1072
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:140
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2258
AVClassCategory
AVClassCategory
Definition: log.h:28
AVFilmGrainParams::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:280
AV_STREAM_GROUP_PARAMS_NONE
@ AV_STREAM_GROUP_PARAMS_NONE
Definition: avformat.h:1124
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:139
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AVIAMFParamDefinition::parameter_id
unsigned int parameter_id
Identifier for the paremeter substream.
Definition: iamf.h:218
SECTION_ID_PROGRAM
@ SECTION_ID_PROGRAM
Definition: ffprobe.c:197
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1260
print_color_space
static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
Definition: ffprobe.c:2664
ffprobe_show_pixel_formats
static void ffprobe_show_pixel_formats(WriterContext *w)
Definition: ffprobe.c:4156
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:1418
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:253
show_usage
static void show_usage(void)
Definition: ffprobe.c:4099
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:2813
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:198
do_bitexact
static int do_bitexact
Definition: ffprobe.c:97
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:656
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:274
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:417
opt_show_entries
static int opt_show_entries(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:4262
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:4537
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:233
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
AV_PKT_DATA_MPEGTS_STREAM_ID
@ AV_PKT_DATA_MPEGTS_STREAM_ID
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:212
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1224
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:166
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
upcase_string
static char * upcase_string(char *dst, size_t dst_size, const char *src)
Definition: ffprobe.c:1097
profile
int profile
Definition: mxfenc.c:2249
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:659
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:669
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilmGrainH274Params::intensity_interval_lower_bound
uint8_t intensity_interval_lower_bound[3][256]
Specifies the lower ounds of each intensity interval for whichthe set of model values applies for the...
Definition: film_grain_params.h:210
SECTION_ID_FRAME_SIDE_DATA_TIMECODE
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE
Definition: ffprobe.c: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:404
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
SECTION_ID_PROGRAM_VERSION
@ SECTION_ID_PROGRAM_VERSION
Definition: ffprobe.c: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:1031
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:553
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:269
AVDOVIReshapingCurve
Definition: dovi_meta.h:117
version.h
section::get_type
const char *(* get_type)(const void *data)
function returning a type if defined, must be defined when SECTION_FLAG_HAS_TYPE is defined
Definition: ffprobe.c:246
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:817
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
tag
uint32_t tag
Definition: movenc.c:1879
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
log_buffer
static LogBuffer * log_buffer
Definition: ffprobe.c: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:1181
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:141
log_callback_help
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:70
flat_print_int
static void flat_print_int(WriterContext *wctx, const char *key, int64_t value)
Definition: ffprobe.c:1499
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
InputFile::streams
InputStream ** streams
Definition: ffmpeg.h:488
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:4375
AVHDRVivid3SplineParams
HDR Vivid three spline params.
Definition: hdr_dynamic_vivid_metadata.h:30
avformat.h
dovi_meta.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
AVHDRVividColorTransformParams::minimum_maxrgb
AVRational minimum_maxrgb
Indicates the minimum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:239
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:550
flat_init
static av_cold int flat_init(WriterContext *wctx)
Definition: ffprobe.c: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:563
AVDOVIRpuDataHeader::vdr_rpu_level
uint8_t vdr_rpu_level
Definition: dovi_meta.h:91
WriterContext::writer
const Writer * writer
the Writer of which this is an instance
Definition: ffprobe.c: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:1134
AVHDRVividColorToneMappingParams::base_param_m_n
AVRational base_param_m_n
base_param_m_n in the base parameter, in multiples of 1.0/10.
Definition: hdr_dynamic_vivid_metadata.h:123
XML_INDENT
#define XML_INDENT()
Definition: ffprobe.c: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:451
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:168
hash.h
CompactContext::nokey
int nokey
Definition: ffprobe.c: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:1188
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:4557
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
PRINT_STRING_VALIDATE
#define PRINT_STRING_VALIDATE
Definition: ffprobe.c: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:200
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:187
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
hdr_dynamic_metadata.h
AV_PKT_DATA_AFD
@ AV_PKT_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:258
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
ini_options
static const AVOption ini_options[]
Definition: ffprobe.c:1538
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:914
print_dynamic_hdr10_plus
static void print_dynamic_hdr10_plus(WriterContext *w, const AVDynamicHDRPlus *metadata)
Definition: ffprobe.c: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:1435
AVHDRVividColorToneMappingParams
Color tone mapping parameters at a processing window in a dynamic metadata for CUVA 005....
Definition: hdr_dynamic_vivid_metadata.h:77
AVPacket::stream_index
int stream_index
Definition: packet.h:541
AVFilmGrainH274Params::num_model_values
uint8_t num_model_values[3]
Specifies the number of model values present for each intensity interval in which the film grain has ...
Definition: film_grain_params.h:204
AVFilmGrainParams::color_range
enum AVColorRange color_range
Intended video signal characteristics.
Definition: film_grain_params.h:279
FlatContext::sep_str
const char * sep_str
Definition: ffprobe.c: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:4352
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:647
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:117
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
XMLContext
Definition: ffprobe.c: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:1161
AVIAMFLayer::ambisonics_mode
enum AVIAMFAmbisonicsMode ambisonics_mode
Ambisonics mode as defined in section 3.6.3 of IAMF.
Definition: iamf.h:328
CompactContext::item_sep_str
char * item_sep_str
Definition: ffprobe.c: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:325
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
default_print_section_header
static void default_print_section_header(WriterContext *wctx, const void *data)
Definition: ffprobe.c: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:1375
AVStreamGroupTileGrid::height
int height
Height of the final image for presentation.
Definition: avformat.h:1082
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:217
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVIAMFLayer::output_gain
AVRational output_gain
Output gain as defined in section 3.6.2 of IAMF.
Definition: iamf.h:316
compact_options
static const AVOption compact_options[]
Definition: ffprobe.c: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:478
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:119
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
WriterContext::nb_sections
int nb_sections
number of sections
Definition: ffprobe.c:547
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
cmdutils.h
show_stream
static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int container)
Definition: ffprobe.c:3267
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance
AVRational targeted_system_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the targeted system display.
Definition: hdr_dynamic_metadata.h:297
print_dynamic_hdr_vivid
static void print_dynamic_hdr_vivid(WriterContext *w, const AVDynamicHDRVivid *metadata)
Definition: ffprobe.c:2313
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: frame.c:1062
SHOW_LIB_VERSION
#define SHOW_LIB_VERSION(libname, LIBNAME)
Definition: ffprobe.c:4122
IN_PROGRAM
#define IN_PROGRAM
Definition: ffprobe.c:3264
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
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:616
AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
@ AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
Definition: iamf.h:345
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:269
ALPHA
@ ALPHA
Definition: drawutils.c:33
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1215
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:153
AVDynamicHDRVivid::system_start_code
uint8_t system_start_code
The system start code.
Definition: hdr_dynamic_vivid_metadata.h:314
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1425
writer_print_section_footer
static void writer_print_section_footer(WriterContext *wctx)
Definition: ffprobe.c: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:797
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:2674
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:1026
unit_value::d
double d
Definition: ffprobe.c:445
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:489
print_iamf_mix_presentation_params
static void print_iamf_mix_presentation_params(WriterContext *w, const AVStreamGroup *stg, const AVIAMFMixPresentation *mix_presentation)
Definition: ffprobe.c:3712
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:698
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1261
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
do_analyze_frames
static int do_analyze_frames
Definition: ffprobe.c:96
AVHDRVividColorToneMappingParams::three_spline
AVHDRVivid3SplineParams three_spline[2]
Definition: hdr_dynamic_vivid_metadata.h:225
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:163
AVHDRVividColorToneMappingParams::base_param_m_p
AVRational base_param_m_p
base_param_m_p in the base parameter, in multiples of 1.0/16383.
Definition: hdr_dynamic_vivid_metadata.h:95
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:242
AVIAMFMixPresentation::submixes
AVIAMFSubmix ** submixes
Array of submixes.
Definition: iamf.h:622
print_error
static void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.h:468
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:162
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
stream_specifier
static char * stream_specifier
Definition: ffprobe.c: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:682
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:1328
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:3603
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:44
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2259
CompactContext::terminate_line
int terminate_line[SECTION_MAX_NB_LEVELS]
Definition: ffprobe.c: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:578
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
AVDOVIDataMapping::num_x_partitions
uint32_t num_x_partitions
Definition: dovi_meta.h:160
AVFilmGrainAOMParams::ar_coeff_shift
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
Definition: film_grain_params.h:93
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:551
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:35
version.h
writer_class
static const AVClass writer_class
Definition: ffprobe.c: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:3168
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:3538
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:70
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86
writer_register
static int writer_register(const Writer *writer)
Definition: ffprobe.c:1038
Generated on Fri Feb 28 2025 19:21:30 for FFmpeg by   doxygen 1.8.17