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