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/avutil.h"
40 #include "libavutil/bprint.h"
41 #include "libavutil/channel_layout.h"
42 #include "libavutil/display.h"
43 #include "libavutil/film_grain_params.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 "libavfilter/version.h"
67 #include "textformat/avtextformat.h"
68 #include "cmdutils.h"
69 #include "opt_common.h"
70 
71 #include "libavutil/thread.h"
72 
73 // attached as opaque_ref to packets/frames
74 typedef struct FrameData {
75  int64_t pkt_pos;
76  int pkt_size;
77 } FrameData;
78 
79 typedef struct InputStream {
80  AVStream *st;
81 
82  AVCodecContext *dec_ctx;
83 } InputStream;
84 
85 typedef struct InputFile {
86  AVFormatContext *fmt_ctx;
87 
88  InputStream *streams;
89  int nb_streams;
90 } InputFile;
91 
92 const char program_name[] = "ffprobe";
93 const int program_birth_year = 2007;
94 
95 static int do_analyze_frames = 0;
96 static int do_bitexact = 0;
97 static int do_count_frames = 0;
98 static int do_count_packets = 0;
99 static int do_read_frames = 0;
100 static int do_read_packets = 0;
101 static int do_show_chapters = 0;
102 static int do_show_error = 0;
103 static int do_show_format = 0;
104 static int do_show_frames = 0;
105 static int do_show_packets = 0;
106 static int do_show_programs = 0;
107 static int do_show_stream_groups = 0;
108 static int do_show_stream_group_components = 0;
109 static int do_show_streams = 0;
110 static int do_show_stream_disposition = 0;
111 static int do_show_stream_group_disposition = 0;
112 static int do_show_data = 0;
113 static int do_show_program_version = 0;
114 static int do_show_library_versions = 0;
115 static int do_show_pixel_formats = 0;
116 static int do_show_pixel_format_flags = 0;
117 static int do_show_pixel_format_components = 0;
118 static int do_show_log = 0;
119 
120 static int do_show_chapter_tags = 0;
121 static int do_show_format_tags = 0;
122 static int do_show_frame_tags = 0;
123 static int do_show_program_tags = 0;
124 static int do_show_stream_group_tags = 0;
125 static int do_show_stream_tags = 0;
126 static int do_show_packet_tags = 0;
127 
128 static int show_value_unit = 0;
129 static int use_value_prefix = 0;
130 static int use_byte_value_binary_prefix = 0;
131 static int use_value_sexagesimal_format = 0;
132 static int show_private_data = 1;
133 
134 static const char *audio_codec_name = NULL;
135 static const char *data_codec_name = NULL;
136 static const char *subtitle_codec_name = NULL;
137 static const char *video_codec_name = NULL;
138 
139 #define SHOW_OPTIONAL_FIELDS_AUTO -1
140 #define SHOW_OPTIONAL_FIELDS_NEVER 0
141 #define SHOW_OPTIONAL_FIELDS_ALWAYS 1
142 static int show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
143 
144 static char *output_format;
145 static char *stream_specifier;
146 static char *show_data_hash;
147 static char *data_dump_format;
148 
149 typedef struct ReadInterval {
150  int id; ///< identifier
151  int64_t start, end; ///< start, end in second/AV_TIME_BASE units
152  int has_start, has_end;
153  int start_is_offset, end_is_offset;
154  int duration_frames;
155 } ReadInterval;
156 
157 static ReadInterval *read_intervals;
158 static int read_intervals_nb = 0;
159 
160 static int find_stream_info = 1;
161 
162 /* section structure definition */
163 
164 typedef enum {
165  SECTION_ID_CHAPTER,
166  SECTION_ID_CHAPTER_TAGS,
167  SECTION_ID_CHAPTERS,
168  SECTION_ID_ERROR,
169  SECTION_ID_FORMAT,
170  SECTION_ID_FORMAT_TAGS,
171  SECTION_ID_FRAME,
172  SECTION_ID_FRAMES,
173  SECTION_ID_FRAME_TAGS,
174  SECTION_ID_FRAME_SIDE_DATA_LIST,
175  SECTION_ID_FRAME_SIDE_DATA,
176  SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST,
177  SECTION_ID_FRAME_SIDE_DATA_TIMECODE,
178  SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST,
179  SECTION_ID_FRAME_SIDE_DATA_COMPONENT,
180  SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST,
181  SECTION_ID_FRAME_SIDE_DATA_PIECE,
182  SECTION_ID_FRAME_LOG,
183  SECTION_ID_FRAME_LOGS,
184  SECTION_ID_LIBRARY_VERSION,
185  SECTION_ID_LIBRARY_VERSIONS,
186  SECTION_ID_PACKET,
187  SECTION_ID_PACKET_TAGS,
188  SECTION_ID_PACKETS,
189  SECTION_ID_PACKETS_AND_FRAMES,
190  SECTION_ID_PACKET_SIDE_DATA_LIST,
191  SECTION_ID_PACKET_SIDE_DATA,
192  SECTION_ID_PIXEL_FORMAT,
193  SECTION_ID_PIXEL_FORMAT_FLAGS,
194  SECTION_ID_PIXEL_FORMAT_COMPONENT,
195  SECTION_ID_PIXEL_FORMAT_COMPONENTS,
196  SECTION_ID_PIXEL_FORMATS,
197  SECTION_ID_PROGRAM_STREAM_DISPOSITION,
198  SECTION_ID_PROGRAM_STREAM_TAGS,
199  SECTION_ID_PROGRAM,
200  SECTION_ID_PROGRAM_STREAMS,
201  SECTION_ID_PROGRAM_STREAM,
202  SECTION_ID_PROGRAM_TAGS,
203  SECTION_ID_PROGRAM_VERSION,
204  SECTION_ID_PROGRAMS,
205  SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION,
206  SECTION_ID_STREAM_GROUP_STREAM_TAGS,
207  SECTION_ID_STREAM_GROUP,
208  SECTION_ID_STREAM_GROUP_COMPONENTS,
209  SECTION_ID_STREAM_GROUP_COMPONENT,
210  SECTION_ID_STREAM_GROUP_SUBCOMPONENTS,
211  SECTION_ID_STREAM_GROUP_SUBCOMPONENT,
212  SECTION_ID_STREAM_GROUP_PIECES,
213  SECTION_ID_STREAM_GROUP_PIECE,
214  SECTION_ID_STREAM_GROUP_SUBPIECES,
215  SECTION_ID_STREAM_GROUP_SUBPIECE,
216  SECTION_ID_STREAM_GROUP_BLOCKS,
217  SECTION_ID_STREAM_GROUP_BLOCK,
218  SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST,
219  SECTION_ID_STREAM_GROUP_SIDE_DATA,
220  SECTION_ID_STREAM_GROUP_STREAMS,
221  SECTION_ID_STREAM_GROUP_STREAM,
222  SECTION_ID_STREAM_GROUP_DISPOSITION,
223  SECTION_ID_STREAM_GROUP_TAGS,
224  SECTION_ID_STREAM_GROUPS,
225  SECTION_ID_ROOT,
226  SECTION_ID_STREAM,
227  SECTION_ID_STREAM_DISPOSITION,
228  SECTION_ID_STREAMS,
229  SECTION_ID_STREAM_TAGS,
230  SECTION_ID_STREAM_SIDE_DATA_LIST,
231  SECTION_ID_STREAM_SIDE_DATA,
232  SECTION_ID_SUBTITLE,
233 } SectionID;
234 
235 static const char *get_packet_side_data_type(const void *data)
236 {
237  const AVPacketSideData *sd = (const AVPacketSideData *)data;
238  return av_x_if_null(av_packet_side_data_name(sd->type), "unknown");
239 }
240 
241 static const char *get_frame_side_data_type(const void *data)
242 {
243  const AVFrameSideData *sd = (const AVFrameSideData *)data;
244  return av_x_if_null(av_frame_side_data_name(sd->type), "unknown");
245 }
246 
247 static const char *get_raw_string_type(const void *data)
248 {
249  return data;
250 }
251 
252 static const char *get_stream_group_type(const void *data)
253 {
254  const AVStreamGroup *stg = (const AVStreamGroup *)data;
255  return av_x_if_null(avformat_stream_group_name(stg->type), "unknown");
256 }
257 
258 static const AVTextFormatSection sections[] = {
259  [SECTION_ID_CHAPTERS] = { SECTION_ID_CHAPTERS, "chapters", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_CHAPTER, -1 } },
260  [SECTION_ID_CHAPTER] = { SECTION_ID_CHAPTER, "chapter", 0, { SECTION_ID_CHAPTER_TAGS, -1 } },
261  [SECTION_ID_CHAPTER_TAGS] = { SECTION_ID_CHAPTER_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "chapter_tags" },
262  [SECTION_ID_ERROR] = { SECTION_ID_ERROR, "error", 0, { -1 } },
263  [SECTION_ID_FORMAT] = { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },
264  [SECTION_ID_FORMAT_TAGS] = { SECTION_ID_FORMAT_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },
265  [SECTION_ID_FRAMES] = { SECTION_ID_FRAMES, "frames", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, SECTION_ID_SUBTITLE, -1 } },
266  [SECTION_ID_FRAME] = { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_LOGS, -1 } },
267  [SECTION_ID_FRAME_TAGS] = { SECTION_ID_FRAME_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },
268  [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "frame_side_data_list" },
269  [SECTION_ID_FRAME_SIDE_DATA] = { SECTION_ID_FRAME_SIDE_DATA, "side_data", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_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 },
270  [SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST] = { SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST, "timecodes", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_TIMECODE, -1 } },
271  [SECTION_ID_FRAME_SIDE_DATA_TIMECODE] = { SECTION_ID_FRAME_SIDE_DATA_TIMECODE, "timecode", 0, { -1 } },
272  [SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST] = { SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST, "components", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_COMPONENT, -1 }, .element_name = "component", .unique_name = "frame_side_data_components" },
273  [SECTION_ID_FRAME_SIDE_DATA_COMPONENT] = { SECTION_ID_FRAME_SIDE_DATA_COMPONENT, "component", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_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 },
274  [SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST] = { SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST, "pieces", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_PIECE, -1 }, .element_name = "piece", .unique_name = "frame_side_data_pieces" },
275  [SECTION_ID_FRAME_SIDE_DATA_PIECE] = { SECTION_ID_FRAME_SIDE_DATA_PIECE, "piece", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE, { -1 }, .element_name = "piece_entry", .unique_name = "frame_side_data_piece", .get_type = get_raw_string_type },
276  [SECTION_ID_FRAME_LOGS] = { SECTION_ID_FRAME_LOGS, "logs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_LOG, -1 } },
277  [SECTION_ID_FRAME_LOG] = { SECTION_ID_FRAME_LOG, "log", 0, { -1 }, },
278  [SECTION_ID_LIBRARY_VERSIONS] = { SECTION_ID_LIBRARY_VERSIONS, "library_versions", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } },
279  [SECTION_ID_LIBRARY_VERSION] = { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },
280  [SECTION_ID_PACKETS] = { SECTION_ID_PACKETS, "packets", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
281  [SECTION_ID_PACKETS_AND_FRAMES] = { SECTION_ID_PACKETS_AND_FRAMES, "packets_and_frames", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_NUMBERING_BY_TYPE, { SECTION_ID_PACKET, -1} },
282  [SECTION_ID_PACKET] = { SECTION_ID_PACKET, "packet", 0, { SECTION_ID_PACKET_TAGS, SECTION_ID_PACKET_SIDE_DATA_LIST, -1 } },
283  [SECTION_ID_PACKET_TAGS] = { SECTION_ID_PACKET_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "packet_tags" },
284  [SECTION_ID_PACKET_SIDE_DATA_LIST] ={ SECTION_ID_PACKET_SIDE_DATA_LIST, "side_data_list", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "packet_side_data_list" },
285  [SECTION_ID_PACKET_SIDE_DATA] = { SECTION_ID_PACKET_SIDE_DATA, "side_data", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE, { -1 }, .unique_name = "packet_side_data", .element_name = "side_datum", .get_type = get_packet_side_data_type },
286  [SECTION_ID_PIXEL_FORMATS] = { SECTION_ID_PIXEL_FORMATS, "pixel_formats", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_PIXEL_FORMAT, -1 } },
287  [SECTION_ID_PIXEL_FORMAT] = { SECTION_ID_PIXEL_FORMAT, "pixel_format", 0, { SECTION_ID_PIXEL_FORMAT_FLAGS, SECTION_ID_PIXEL_FORMAT_COMPONENTS, -1 } },
288  [SECTION_ID_PIXEL_FORMAT_FLAGS] = { SECTION_ID_PIXEL_FORMAT_FLAGS, "flags", 0, { -1 }, .unique_name = "pixel_format_flags" },
289  [SECTION_ID_PIXEL_FORMAT_COMPONENTS] = { SECTION_ID_PIXEL_FORMAT_COMPONENTS, "components", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, {SECTION_ID_PIXEL_FORMAT_COMPONENT, -1 }, .unique_name = "pixel_format_components" },
290  [SECTION_ID_PIXEL_FORMAT_COMPONENT] = { SECTION_ID_PIXEL_FORMAT_COMPONENT, "component", 0, { -1 } },
291  [SECTION_ID_PROGRAM_STREAM_DISPOSITION] = { SECTION_ID_PROGRAM_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "program_stream_disposition" },
292  [SECTION_ID_PROGRAM_STREAM_TAGS] = { SECTION_ID_PROGRAM_STREAM_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_stream_tags" },
293  [SECTION_ID_PROGRAM] = { SECTION_ID_PROGRAM, "program", 0, { SECTION_ID_PROGRAM_TAGS, SECTION_ID_PROGRAM_STREAMS, -1 } },
294  [SECTION_ID_PROGRAM_STREAMS] = { SECTION_ID_PROGRAM_STREAMS, "streams", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM_STREAM, -1 }, .unique_name = "program_streams" },
295  [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" },
296  [SECTION_ID_PROGRAM_TAGS] = { SECTION_ID_PROGRAM_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_tags" },
297  [SECTION_ID_PROGRAM_VERSION] = { SECTION_ID_PROGRAM_VERSION, "program_version", 0, { -1 } },
298  [SECTION_ID_PROGRAMS] = { SECTION_ID_PROGRAMS, "programs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM, -1 } },
299  [SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION] = { SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_group_stream_disposition" },
300  [SECTION_ID_STREAM_GROUP_STREAM_TAGS] = { SECTION_ID_STREAM_GROUP_STREAM_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_group_stream_tags" },
301  [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 } },
302  [SECTION_ID_STREAM_GROUP_COMPONENTS] = { SECTION_ID_STREAM_GROUP_COMPONENTS, "components", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_COMPONENT, -1 }, .element_name = "component", .unique_name = "stream_group_components" },
303  [SECTION_ID_STREAM_GROUP_COMPONENT] = { SECTION_ID_STREAM_GROUP_COMPONENT, "component", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS, -1 }, .unique_name = "stream_group_component", .element_name = "component_entry", .get_type = get_stream_group_type },
304  [SECTION_ID_STREAM_GROUP_SUBCOMPONENTS] = { SECTION_ID_STREAM_GROUP_SUBCOMPONENTS, "subcomponents", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_SUBCOMPONENT, -1 }, .element_name = "component" },
305  [SECTION_ID_STREAM_GROUP_SUBCOMPONENT] = { SECTION_ID_STREAM_GROUP_SUBCOMPONENT, "subcomponent", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_PIECES, -1 }, .element_name = "subcomponent_entry", .get_type = get_raw_string_type },
306  [SECTION_ID_STREAM_GROUP_PIECES] = { SECTION_ID_STREAM_GROUP_PIECES, "pieces", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_PIECE, -1 }, .element_name = "piece", .unique_name = "stream_group_pieces" },
307  [SECTION_ID_STREAM_GROUP_PIECE] = { SECTION_ID_STREAM_GROUP_PIECE, "piece", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_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 },
308  [SECTION_ID_STREAM_GROUP_SUBPIECES] = { SECTION_ID_STREAM_GROUP_SUBPIECES, "subpieces", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_SUBPIECE, -1 }, .element_name = "subpiece" },
309  [SECTION_ID_STREAM_GROUP_SUBPIECE] = { SECTION_ID_STREAM_GROUP_SUBPIECE, "subpiece", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE, { SECTION_ID_STREAM_GROUP_BLOCKS, -1 }, .element_name = "subpiece_entry", .get_type = get_raw_string_type },
310  [SECTION_ID_STREAM_GROUP_BLOCKS] = { SECTION_ID_STREAM_GROUP_BLOCKS, "blocks", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_BLOCK, -1 }, .element_name = "block" },
311  [SECTION_ID_STREAM_GROUP_BLOCK] = { SECTION_ID_STREAM_GROUP_BLOCK, "block", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS|AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE, { -1 }, .element_name = "block_entry", .get_type = get_raw_string_type },
312  [SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST] = { SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST, "side_data_list", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "stream_group_side_data_list" },
313  [SECTION_ID_STREAM_GROUP_SIDE_DATA] = { SECTION_ID_STREAM_GROUP_SIDE_DATA, "side_data", AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE|AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .unique_name = "stream_group_side_data", .element_name = "side_datum", .get_type = get_packet_side_data_type },
314  [SECTION_ID_STREAM_GROUP_STREAMS] = { SECTION_ID_STREAM_GROUP_STREAMS, "streams", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP_STREAM, -1 }, .unique_name = "stream_group_streams" },
315  [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" },
316  [SECTION_ID_STREAM_GROUP_DISPOSITION] = { SECTION_ID_STREAM_GROUP_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_group_disposition" },
317  [SECTION_ID_STREAM_GROUP_TAGS] = { SECTION_ID_STREAM_GROUP_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_group_tags" },
318  [SECTION_ID_STREAM_GROUPS] = { SECTION_ID_STREAM_GROUPS, "stream_groups", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_GROUP, -1 } },
319  [SECTION_ID_ROOT] = { SECTION_ID_ROOT, "root", AV_TEXTFORMAT_SECTION_FLAG_IS_WRAPPER,
320  { SECTION_ID_CHAPTERS, SECTION_ID_FORMAT, SECTION_ID_FRAMES, SECTION_ID_PROGRAMS, SECTION_ID_STREAM_GROUPS, SECTION_ID_STREAMS,
321  SECTION_ID_PACKETS, SECTION_ID_ERROR, SECTION_ID_PROGRAM_VERSION, SECTION_ID_LIBRARY_VERSIONS,
322  SECTION_ID_PIXEL_FORMATS, -1} },
323  [SECTION_ID_STREAMS] = { SECTION_ID_STREAMS, "streams", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM, -1 } },
324  [SECTION_ID_STREAM] = { SECTION_ID_STREAM, "stream", 0, { SECTION_ID_STREAM_DISPOSITION, SECTION_ID_STREAM_TAGS, SECTION_ID_STREAM_SIDE_DATA_LIST, -1 } },
325  [SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },
326  [SECTION_ID_STREAM_TAGS] = { SECTION_ID_STREAM_TAGS, "tags", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },
327  [SECTION_ID_STREAM_SIDE_DATA_LIST] ={ SECTION_ID_STREAM_SIDE_DATA_LIST, "side_data_list", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "stream_side_data_list" },
328  [SECTION_ID_STREAM_SIDE_DATA] = { SECTION_ID_STREAM_SIDE_DATA, "side_data", AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE|AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .unique_name = "stream_side_data", .element_name = "side_datum", .get_type = get_packet_side_data_type },
329  [SECTION_ID_SUBTITLE] = { SECTION_ID_SUBTITLE, "subtitle", 0, { -1 } },
330 };
331 
332 typedef struct EntrySelection {
333  int show_all_entries;
334  AVDictionary *entries_to_show;
335 } EntrySelection;
336 
337 static EntrySelection selected_entries[FF_ARRAY_ELEMS(sections)] = { 0 };
338 
339 static const OptionDef *options;
340 
341 /* FFprobe context */
342 static const char *input_filename;
343 static const char *print_input_filename;
344 static const AVInputFormat *iformat = NULL;
345 static const char *output_filename = NULL;
346 
347 static const char unit_second_str[] = "s" ;
348 static const char unit_hertz_str[] = "Hz" ;
349 static const char unit_byte_str[] = "byte" ;
350 static const char unit_bit_per_second_str[] = "bit/s";
351 
352 static int nb_streams;
353 static uint64_t *nb_streams_packets;
354 static uint64_t *nb_streams_frames;
355 static int *selected_streams;
356 static int *streams_with_closed_captions;
357 static int *streams_with_film_grain;
358 
359 static AVMutex log_mutex = AV_MUTEX_INITIALIZER;
360 
361 typedef struct LogBuffer {
362  char *context_name;
363  int log_level;
364  char *log_message;
365  AVClassCategory category;
366  char *parent_name;
367  AVClassCategory parent_category;
368 }LogBuffer;
369 
370 static LogBuffer *log_buffer;
371 static int log_buffer_size;
372 
373 static int is_key_selected_callback(AVTextFormatContext *tctx, const char *key)
374 {
375  const AVTextFormatSection *section = tctx->section[tctx->level];
376  const EntrySelection *selection = &selected_entries[section - sections];
377 
378  return selection->show_all_entries || av_dict_get(selection->entries_to_show, key, NULL, 0);
379 }
380 
381 static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
382 {
383  AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
384  va_list vl2;
385  char line[1024];
386  static int print_prefix = 1;
387  void *new_log_buffer;
388 
389  va_copy(vl2, vl);
390  av_log_default_callback(ptr, level, fmt, vl);
391  av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
392  va_end(vl2);
393 
394 #if HAVE_THREADS
395  ff_mutex_lock(&log_mutex);
396 
397  new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer));
398  if (new_log_buffer) {
399  char *msg;
400  int i;
401 
402  log_buffer = new_log_buffer;
403  memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size]));
404  log_buffer[log_buffer_size].context_name= avc ? av_strdup(avc->item_name(ptr)) : NULL;
405  if (avc) {
406  if (avc->get_category) log_buffer[log_buffer_size].category = avc->get_category(ptr);
407  else log_buffer[log_buffer_size].category = avc->category;
408  }
409  log_buffer[log_buffer_size].log_level = level;
410  msg = log_buffer[log_buffer_size].log_message = av_strdup(line);
411  for (i=strlen(msg) - 1; i>=0 && msg[i] == '\n'; i--) {
412  msg[i] = 0;
413  }
414  if (avc && avc->parent_log_context_offset) {
415  AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
416  avc->parent_log_context_offset);
417  if (parent && *parent) {
418  log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent));
419  log_buffer[log_buffer_size].parent_category =
420  (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category;
421  }
422  }
423  log_buffer_size ++;
424  }
425 
426  ff_mutex_unlock(&log_mutex);
427 #endif
428 }
429 
430 
431 #define print_fmt(k, f, ...) do { \
432  av_bprint_clear(&pbuf); \
433  av_bprintf(&pbuf, f, __VA_ARGS__); \
434  avtext_print_string(tfc, k, pbuf.str, 0); \
435 } while (0)
436 
437 #define print_list_fmt(k, f, n, m, ...) do { \
438  av_bprint_clear(&pbuf); \
439  for (int idx = 0; idx < n; idx++) { \
440  for (int idx2 = 0; idx2 < m; idx2++) { \
441  if (idx > 0 || idx2 > 0) \
442  av_bprint_chars(&pbuf, ' ', 1); \
443  av_bprintf(&pbuf, f, __VA_ARGS__); \
444  } \
445  } \
446  avtext_print_string(tfc, k, pbuf.str, 0); \
447 } while (0)
448 
449 #define print_int(k, v) avtext_print_integer(tfc, k, v, 0)
450 #define print_q(k, v, s) avtext_print_rational(tfc, k, v, s)
451 #define print_str(k, v) avtext_print_string(tfc, k, v, 0)
452 #define print_str_opt(k, v) avtext_print_string(tfc, k, v, AV_TEXTFORMAT_PRINT_STRING_OPTIONAL)
453 #define print_str_validate(k, v) avtext_print_string(tfc, k, v, AV_TEXTFORMAT_PRINT_STRING_VALIDATE)
454 #define print_time(k, v, tb) avtext_print_time(tfc, k, v, tb, 0)
455 #define print_ts(k, v) avtext_print_ts(tfc, k, v, 0)
456 #define print_duration_time(k, v, tb) avtext_print_time(tfc, k, v, tb, 1)
457 #define print_duration_ts(k, v) avtext_print_ts(tfc, k, v, 1)
458 #define print_val(k, v, u) avtext_print_unit_integer(tfc, k, v, u)
459 
460 static void print_integers(AVTextFormatContext *tfc, const char *key,
461  const void *data, int size, const char *format,
462  int columns, int bytes, int offset_add)
463 {
464  AVBPrint bp;
465  unsigned offset = 0;
466 
467  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
468  av_bprint_chars(&bp, '\n', 1);
469  while (size) {
470  av_bprintf(&bp, "%08x: ", offset);
471  for (int i = 0, l = FFMIN(size, columns); i < l; i++) {
472  if (bytes == 1) av_bprintf(&bp, format, *(const uint8_t*)data);
473  else if (bytes == 2) av_bprintf(&bp, format, AV_RN16(data));
474  else if (bytes == 4) av_bprintf(&bp, format, AV_RN32(data));
475  data = (const char*)data + bytes;
476  size--;
477  }
478  av_bprint_chars(&bp, '\n', 1);
479  offset += offset_add;
480  }
481  avtext_print_string(tfc, key, bp.str, 0);
482 }
483 
484 #define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n) \
485 { \
486  ret = av_reallocp_array(&(ptr), (new_n), sizeof(*(ptr))); \
487  if (ret < 0) \
488  goto end; \
489  memset( (ptr) + (cur_n), 0, ((new_n) - (cur_n)) * sizeof(*(ptr)) ); \
490 }
491 
492 static inline int show_tags(AVTextFormatContext *tfc, AVDictionary *tags, int section_id)
493 {
494  const AVDictionaryEntry *tag = NULL;
495  int ret = 0;
496 
497  if (!tags)
498  return 0;
499  avtext_print_section_header(tfc, NULL, section_id);
500 
501  while ((tag = av_dict_iterate(tags, tag))) {
502  if ((ret = print_str_validate(tag->key, tag->value)) < 0)
503  break;
504  }
505  avtext_print_section_footer(tfc);
506 
507  return ret;
508 }
509 
510 static void print_displaymatrix(AVTextFormatContext *tfc, const int32_t matrix[9])
511 {
512  double rotation = av_display_rotation_get(matrix);
513  if (isnan(rotation))
514  rotation = 0;
515  print_integers(tfc, "displaymatrix", matrix, 9, " %11d", 3, 4, 1);
516  print_int("rotation", rotation);
517 }
518 
519 static void print_mastering_display_metadata(AVTextFormatContext *tfc,
520  const AVMasteringDisplayMetadata *metadata)
521 {
522  if (metadata->has_primaries) {
523  print_q("red_x", metadata->display_primaries[0][0], '/');
524  print_q("red_y", metadata->display_primaries[0][1], '/');
525  print_q("green_x", metadata->display_primaries[1][0], '/');
526  print_q("green_y", metadata->display_primaries[1][1], '/');
527  print_q("blue_x", metadata->display_primaries[2][0], '/');
528  print_q("blue_y", metadata->display_primaries[2][1], '/');
529 
530  print_q("white_point_x", metadata->white_point[0], '/');
531  print_q("white_point_y", metadata->white_point[1], '/');
532  }
533 
534  if (metadata->has_luminance) {
535  print_q("min_luminance", metadata->min_luminance, '/');
536  print_q("max_luminance", metadata->max_luminance, '/');
537  }
538 }
539 
540 static void print_context_light_level(AVTextFormatContext *tfc,
541  const AVContentLightMetadata *metadata)
542 {
543  print_int("max_content", metadata->MaxCLL);
544  print_int("max_average", metadata->MaxFALL);
545 }
546 
547 static void print_dovi_metadata(AVTextFormatContext *tfc, const AVDOVIMetadata *dovi)
548 {
549  if (!dovi)
550  return;
551 
552  {
553  const AVDOVIRpuDataHeader *hdr = av_dovi_get_header(dovi);
554  const AVDOVIDataMapping *mapping = av_dovi_get_mapping(dovi);
555  const AVDOVIColorMetadata *color = av_dovi_get_color(dovi);
556  AVBPrint pbuf;
557 
558  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
559 
560  // header
561  print_int("rpu_type", hdr->rpu_type);
562  print_int("rpu_format", hdr->rpu_format);
563  print_int("vdr_rpu_profile", hdr->vdr_rpu_profile);
564  print_int("vdr_rpu_level", hdr->vdr_rpu_level);
565  print_int("chroma_resampling_explicit_filter_flag",
566  hdr->chroma_resampling_explicit_filter_flag);
567  print_int("coef_data_type", hdr->coef_data_type);
568  print_int("coef_log2_denom", hdr->coef_log2_denom);
569  print_int("vdr_rpu_normalized_idc", hdr->vdr_rpu_normalized_idc);
570  print_int("bl_video_full_range_flag", hdr->bl_video_full_range_flag);
571  print_int("bl_bit_depth", hdr->bl_bit_depth);
572  print_int("el_bit_depth", hdr->el_bit_depth);
573  print_int("vdr_bit_depth", hdr->vdr_bit_depth);
574  print_int("spatial_resampling_filter_flag",
575  hdr->spatial_resampling_filter_flag);
576  print_int("el_spatial_resampling_filter_flag",
577  hdr->el_spatial_resampling_filter_flag);
578  print_int("disable_residual_flag", hdr->disable_residual_flag);
579 
580  // data mapping values
581  print_int("vdr_rpu_id", mapping->vdr_rpu_id);
582  print_int("mapping_color_space", mapping->mapping_color_space);
583  print_int("mapping_chroma_format_idc",
584  mapping->mapping_chroma_format_idc);
585 
586  print_int("nlq_method_idc", mapping->nlq_method_idc);
587  switch (mapping->nlq_method_idc) {
588  case AV_DOVI_NLQ_NONE:
589  print_str("nlq_method_idc_name", "none");
590  break;
591  case AV_DOVI_NLQ_LINEAR_DZ:
592  print_str("nlq_method_idc_name", "linear_dz");
593  break;
594  default:
595  print_str("nlq_method_idc_name", "unknown");
596  break;
597  }
598 
599  print_int("num_x_partitions", mapping->num_x_partitions);
600  print_int("num_y_partitions", mapping->num_y_partitions);
601 
602  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
603 
604  for (int c = 0; c < 3; c++) {
605  const AVDOVIReshapingCurve *curve = &mapping->curves[c];
606  avtext_print_section_header(tfc, "Reshaping curve", SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
607 
608  print_list_fmt("pivots", "%"PRIu16, curve->num_pivots, 1, curve->pivots[idx]);
609 
610  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST);
611  for (int i = 0; i < curve->num_pivots - 1; i++) {
612  AVBPrint piece_buf;
613 
614  av_bprint_init(&piece_buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
615  switch (curve->mapping_idc[i]) {
616  case AV_DOVI_MAPPING_POLYNOMIAL:
617  av_bprintf(&piece_buf, "Polynomial");
618  break;
619  case AV_DOVI_MAPPING_MMR:
620  av_bprintf(&piece_buf, "MMR");
621  break;
622  default:
623  av_bprintf(&piece_buf, "Unknown");
624  break;
625  }
626  av_bprintf(&piece_buf, " mapping");
627 
628  avtext_print_section_header(tfc, piece_buf.str, SECTION_ID_FRAME_SIDE_DATA_PIECE);
629  print_int("mapping_idc", curve->mapping_idc[i]);
630  switch (curve->mapping_idc[i]) {
631  case AV_DOVI_MAPPING_POLYNOMIAL:
632  print_str("mapping_idc_name", "polynomial");
633  print_int("poly_order", curve->poly_order[i]);
634  print_list_fmt("poly_coef", "%"PRIi64,
635  curve->poly_order[i] + 1, 1,
636  curve->poly_coef[i][idx]);
637  break;
638  case AV_DOVI_MAPPING_MMR:
639  print_str("mapping_idc_name", "mmr");
640  print_int("mmr_order", curve->mmr_order[i]);
641  print_int("mmr_constant", curve->mmr_constant[i]);
642  print_list_fmt("mmr_coef", "%"PRIi64,
643  curve->mmr_order[i], 7,
644  curve->mmr_coef[i][idx][idx2]);
645  break;
646  default:
647  print_str("mapping_idc_name", "unknown");
648  break;
649  }
650 
651  // SECTION_ID_FRAME_SIDE_DATA_PIECE
652  avtext_print_section_footer(tfc);
653  }
654 
655  // SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
656  avtext_print_section_footer(tfc);
657 
658  if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
659  const AVDOVINLQParams *nlq = &mapping->nlq[c];
660  print_int("nlq_offset", nlq->nlq_offset);
661  print_int("vdr_in_max", nlq->vdr_in_max);
662 
663  switch (mapping->nlq_method_idc) {
664  case AV_DOVI_NLQ_LINEAR_DZ:
665  print_int("linear_deadzone_slope", nlq->linear_deadzone_slope);
666  print_int("linear_deadzone_threshold", nlq->linear_deadzone_threshold);
667  break;
668  }
669  }
670 
671  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
672  avtext_print_section_footer(tfc);
673  }
674 
675  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
676  avtext_print_section_footer(tfc);
677 
678  // color metadata
679  print_int("dm_metadata_id", color->dm_metadata_id);
680  print_int("scene_refresh_flag", color->scene_refresh_flag);
681  print_list_fmt("ycc_to_rgb_matrix", "%d/%d",
682  FF_ARRAY_ELEMS(color->ycc_to_rgb_matrix), 1,
683  color->ycc_to_rgb_matrix[idx].num,
684  color->ycc_to_rgb_matrix[idx].den);
685  print_list_fmt("ycc_to_rgb_offset", "%d/%d",
686  FF_ARRAY_ELEMS(color->ycc_to_rgb_offset), 1,
687  color->ycc_to_rgb_offset[idx].num,
688  color->ycc_to_rgb_offset[idx].den);
689  print_list_fmt("rgb_to_lms_matrix", "%d/%d",
690  FF_ARRAY_ELEMS(color->rgb_to_lms_matrix), 1,
691  color->rgb_to_lms_matrix[idx].num,
692  color->rgb_to_lms_matrix[idx].den);
693  print_int("signal_eotf", color->signal_eotf);
694  print_int("signal_eotf_param0", color->signal_eotf_param0);
695  print_int("signal_eotf_param1", color->signal_eotf_param1);
696  print_int("signal_eotf_param2", color->signal_eotf_param2);
697  print_int("signal_bit_depth", color->signal_bit_depth);
698  print_int("signal_color_space", color->signal_color_space);
699  print_int("signal_chroma_format", color->signal_chroma_format);
700  print_int("signal_full_range_flag", color->signal_full_range_flag);
701  print_int("source_min_pq", color->source_min_pq);
702  print_int("source_max_pq", color->source_max_pq);
703  print_int("source_diagonal", color->source_diagonal);
704 
705  av_bprint_finalize(&pbuf, NULL);
706  }
707 }
708 
709 static void print_dynamic_hdr10_plus(AVTextFormatContext *tfc, const AVDynamicHDRPlus *metadata)
710 {
711  if (!metadata)
712  return;
713  print_int("application version", metadata->application_version);
714  print_int("num_windows", metadata->num_windows);
715  for (int n = 1; n < metadata->num_windows; n++) {
716  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
717  print_q("window_upper_left_corner_x",
718  params->window_upper_left_corner_x,'/');
719  print_q("window_upper_left_corner_y",
720  params->window_upper_left_corner_y,'/');
721  print_q("window_lower_right_corner_x",
722  params->window_lower_right_corner_x,'/');
723  print_q("window_lower_right_corner_y",
724  params->window_lower_right_corner_y,'/');
725  print_q("window_upper_left_corner_x",
726  params->window_upper_left_corner_x,'/');
727  print_q("window_upper_left_corner_y",
728  params->window_upper_left_corner_y,'/');
729  print_int("center_of_ellipse_x",
730  params->center_of_ellipse_x ) ;
731  print_int("center_of_ellipse_y",
732  params->center_of_ellipse_y );
733  print_int("rotation_angle",
734  params->rotation_angle);
735  print_int("semimajor_axis_internal_ellipse",
736  params->semimajor_axis_internal_ellipse);
737  print_int("semimajor_axis_external_ellipse",
738  params->semimajor_axis_external_ellipse);
739  print_int("semiminor_axis_external_ellipse",
740  params->semiminor_axis_external_ellipse);
741  print_int("overlap_process_option",
742  params->overlap_process_option);
743  }
744  print_q("targeted_system_display_maximum_luminance",
745  metadata->targeted_system_display_maximum_luminance,'/');
746  if (metadata->targeted_system_display_actual_peak_luminance_flag) {
747  print_int("num_rows_targeted_system_display_actual_peak_luminance",
748  metadata->num_rows_targeted_system_display_actual_peak_luminance);
749  print_int("num_cols_targeted_system_display_actual_peak_luminance",
750  metadata->num_cols_targeted_system_display_actual_peak_luminance);
751  for (int i = 0; i < metadata->num_rows_targeted_system_display_actual_peak_luminance; i++) {
752  for (int j = 0; j < metadata->num_cols_targeted_system_display_actual_peak_luminance; j++) {
753  print_q("targeted_system_display_actual_peak_luminance",
754  metadata->targeted_system_display_actual_peak_luminance[i][j],'/');
755  }
756  }
757  }
758  for (int n = 0; n < metadata->num_windows; n++) {
759  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
760  for (int i = 0; i < 3; i++) {
761  print_q("maxscl",params->maxscl[i],'/');
762  }
763  print_q("average_maxrgb",
764  params->average_maxrgb,'/');
765  print_int("num_distribution_maxrgb_percentiles",
766  params->num_distribution_maxrgb_percentiles);
767  for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
768  print_int("distribution_maxrgb_percentage",
769  params->distribution_maxrgb[i].percentage);
770  print_q("distribution_maxrgb_percentile",
771  params->distribution_maxrgb[i].percentile,'/');
772  }
773  print_q("fraction_bright_pixels",
774  params->fraction_bright_pixels,'/');
775  }
776  if (metadata->mastering_display_actual_peak_luminance_flag) {
777  print_int("num_rows_mastering_display_actual_peak_luminance",
778  metadata->num_rows_mastering_display_actual_peak_luminance);
779  print_int("num_cols_mastering_display_actual_peak_luminance",
780  metadata->num_cols_mastering_display_actual_peak_luminance);
781  for (int i = 0; i < metadata->num_rows_mastering_display_actual_peak_luminance; i++) {
782  for (int j = 0; j < metadata->num_cols_mastering_display_actual_peak_luminance; j++) {
783  print_q("mastering_display_actual_peak_luminance",
784  metadata->mastering_display_actual_peak_luminance[i][j],'/');
785  }
786  }
787  }
788 
789  for (int n = 0; n < metadata->num_windows; n++) {
790  const AVHDRPlusColorTransformParams *params = &metadata->params[n];
791  if (params->tone_mapping_flag) {
792  print_q("knee_point_x", params->knee_point_x,'/');
793  print_q("knee_point_y", params->knee_point_y,'/');
794  print_int("num_bezier_curve_anchors",
795  params->num_bezier_curve_anchors );
796  for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
797  print_q("bezier_curve_anchors",
798  params->bezier_curve_anchors[i],'/');
799  }
800  }
801  if (params->color_saturation_mapping_flag) {
802  print_q("color_saturation_weight",
803  params->color_saturation_weight,'/');
804  }
805  }
806 }
807 
808 static void print_dynamic_hdr_smpte2094_app5(AVTextFormatContext *tfc, const AVDynamicHDRSmpte2094App5 *metadata)
809 {
810  if (!metadata)
811  return;
812  print_int("application_version", metadata->application_version);
813  print_int("minimum_application_version", metadata->minimum_application_version);
814  print_int("has_custom_hdr_reference_white_flag", metadata->has_custom_hdr_reference_white_flag);
815  print_int("has_adaptive_tone_map_flag", metadata->has_adaptive_tone_map_flag);
816 
817  if (metadata->has_custom_hdr_reference_white_flag)
818  print_int("hdr_reference_white", metadata->hdr_reference_white);
819 
820  if (!metadata->has_adaptive_tone_map_flag)
821  return;
822 
823  print_int("baseline_hdr_headroom", metadata->baseline_hdr_headroom);
824  print_int("use_reference_white_tone_mapping_flag", metadata->use_reference_white_tone_mapping_flag);
825 
826  if (metadata->use_reference_white_tone_mapping_flag)
827  return;
828 
829  print_int("num_alternate_images", metadata->num_alternate_images);
830  print_int("gain_application_space_chromaticities_flag", metadata->gain_application_space_chromaticities_flag);
831  print_int("has_common_component_mix_params_flag", metadata->has_common_component_mix_params_flag);
832  print_int("has_common_curve_params_flag", metadata->has_common_curve_params_flag);
833 
834  if (metadata->gain_application_space_chromaticities_flag == 3) {
835  for (int i = 0; i < 8; i++)
836  print_int("gain_application_space_chromaticities", metadata->gain_application_space_chromaticities[i]);
837  }
838 
839  for (int a = 0; a < metadata->num_alternate_images; a++) {
840  print_int("alternate_hdr_headroom", metadata->alternate_hdr_headrooms[a]);
841 
842  print_int("component_mixing_type", metadata->component_mixing_type[a]);
843  if (metadata->component_mixing_type[a] == 3) {
844  for (int k = 0; k < 6; k++) {
845  print_int("has_component_mixing_coefficient_flag", metadata->has_component_mixing_coefficient_flag[a][k]);
846  if (metadata->has_component_mixing_coefficient_flag[a][k])
847  print_int("component_mixing_coefficient", metadata->component_mixing_coefficient[a][k]);
848  }
849  }
850 
851  print_int("gain_curve_num_control_points_minus_1", metadata->gain_curve_num_control_points_minus_1[a]);
852  print_int("gain_curve_use_pchip_slope_flag", metadata->gain_curve_use_pchip_slope_flag[a]);
853  for (int c = 0; c <= metadata->gain_curve_num_control_points_minus_1[a]; c++)
854  print_int("gain_curve_control_point_x", metadata->gain_curve_control_points_x[a][c]);
855  for (int c = 0; c <= metadata->gain_curve_num_control_points_minus_1[a]; c++)
856  print_int("gain_curve_control_point_y", metadata->gain_curve_control_points_y[a][c]);
857  if (!metadata->gain_curve_use_pchip_slope_flag[a]) {
858  for (int c = 0; c <= metadata->gain_curve_num_control_points_minus_1[a]; c++)
859  print_int("gain_curve_control_point_theta", metadata->gain_curve_control_points_theta[a][c]);
860  }
861  }
862 }
863 
864 static void print_dynamic_hdr_vivid(AVTextFormatContext *tfc, const AVDynamicHDRVivid *metadata)
865 {
866  if (!metadata)
867  return;
868  print_int("system_start_code", metadata->system_start_code);
869  print_int("num_windows", metadata->num_windows);
870 
871  for (int n = 0; n < metadata->num_windows; n++) {
872  const AVHDRVividColorTransformParams *params = &metadata->params[n];
873 
874  print_q("minimum_maxrgb", params->minimum_maxrgb, '/');
875  print_q("average_maxrgb", params->average_maxrgb, '/');
876  print_q("variance_maxrgb", params->variance_maxrgb, '/');
877  print_q("maximum_maxrgb", params->maximum_maxrgb, '/');
878  }
879 
880  for (int n = 0; n < metadata->num_windows; n++) {
881  const AVHDRVividColorTransformParams *params = &metadata->params[n];
882 
883  print_int("tone_mapping_mode_flag", params->tone_mapping_mode_flag);
884  if (params->tone_mapping_mode_flag) {
885  print_int("tone_mapping_param_num", params->tone_mapping_param_num);
886  for (int i = 0; i < params->tone_mapping_param_num; i++) {
887  const AVHDRVividColorToneMappingParams *tm_params = &params->tm_params[i];
888 
889  print_q("targeted_system_display_maximum_luminance",
890  tm_params->targeted_system_display_maximum_luminance, '/');
891  print_int("base_enable_flag", tm_params->base_enable_flag);
892  if (tm_params->base_enable_flag) {
893  print_q("base_param_m_p", tm_params->base_param_m_p, '/');
894  print_q("base_param_m_m", tm_params->base_param_m_m, '/');
895  print_q("base_param_m_a", tm_params->base_param_m_a, '/');
896  print_q("base_param_m_b", tm_params->base_param_m_b, '/');
897  print_q("base_param_m_n", tm_params->base_param_m_n, '/');
898 
899  print_int("base_param_k1", tm_params->base_param_k1);
900  print_int("base_param_k2", tm_params->base_param_k2);
901  print_int("base_param_k3", tm_params->base_param_k3);
902  print_int("base_param_Delta_enable_mode",
903  tm_params->base_param_Delta_enable_mode);
904  print_q("base_param_Delta", tm_params->base_param_Delta, '/');
905  }
906  print_int("3Spline_enable_flag", tm_params->three_Spline_enable_flag);
907  if (tm_params->three_Spline_enable_flag) {
908  print_int("3Spline_num", tm_params->three_Spline_num);
909 
910  for (int j = 0; j < tm_params->three_Spline_num; j++) {
911  const AVHDRVivid3SplineParams *three_spline = &tm_params->three_spline[j];
912  print_int("3Spline_TH_mode", three_spline->th_mode);
913  if (three_spline->th_mode == 0 || three_spline->th_mode == 2)
914  print_q("3Spline_TH_enable_MB", three_spline->th_enable_mb, '/');
915  print_q("3Spline_TH_enable", three_spline->th_enable, '/');
916  print_q("3Spline_TH_Delta1", three_spline->th_delta1, '/');
917  print_q("3Spline_TH_Delta2", three_spline->th_delta2, '/');
918  print_q("3Spline_enable_Strength", three_spline->enable_strength, '/');
919  }
920  }
921  }
922  }
923 
924  print_int("color_saturation_mapping_flag", params->color_saturation_mapping_flag);
925  if (params->color_saturation_mapping_flag) {
926  print_int("color_saturation_num", params->color_saturation_num);
927  for (int i = 0; i < params->color_saturation_num; i++) {
928  print_q("color_saturation_gain", params->color_saturation_gain[i], '/');
929  }
930  }
931  }
932 }
933 
934 static void print_ambient_viewing_environment(AVTextFormatContext *tfc,
935  const AVAmbientViewingEnvironment *env)
936 {
937  if (!env)
938  return;
939 
940  print_q("ambient_illuminance", env->ambient_illuminance, '/');
941  print_q("ambient_light_x", env->ambient_light_x, '/');
942  print_q("ambient_light_y", env->ambient_light_y, '/');
943 }
944 
945 static void print_film_grain_params(AVTextFormatContext *tfc,
946  const AVFilmGrainParams *fgp)
947 {
948  const char *color_range, *color_primaries, *color_trc, *color_space;
949  const char *const film_grain_type_names[] = {
950  [AV_FILM_GRAIN_PARAMS_NONE] = "none",
951  [AV_FILM_GRAIN_PARAMS_AV1] = "av1",
952  [AV_FILM_GRAIN_PARAMS_H274] = "h274",
953  };
954 
955  AVBPrint pbuf;
956  if (!fgp || fgp->type >= FF_ARRAY_ELEMS(film_grain_type_names))
957  return;
958 
959  color_range = av_color_range_name(fgp->color_range);
960  color_primaries = av_color_primaries_name(fgp->color_primaries);
961  color_trc = av_color_transfer_name(fgp->color_trc);
962  color_space = av_color_space_name(fgp->color_space);
963 
964  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
965  print_str("type", film_grain_type_names[fgp->type]);
966  print_fmt("seed", "%"PRIu64, fgp->seed);
967  print_int("width", fgp->width);
968  print_int("height", fgp->height);
969  print_int("subsampling_x", fgp->subsampling_x);
970  print_int("subsampling_y", fgp->subsampling_y);
971  print_str("color_range", color_range ? color_range : "unknown");
972  print_str("color_primaries", color_primaries ? color_primaries : "unknown");
973  print_str("color_trc", color_trc ? color_trc : "unknown");
974  print_str("color_space", color_space ? color_space : "unknown");
975 
976  switch (fgp->type) {
977  case AV_FILM_GRAIN_PARAMS_NONE:
978  break;
979  case AV_FILM_GRAIN_PARAMS_AV1: {
980  const AVFilmGrainAOMParams *aom = &fgp->codec.aom;
981  const int num_ar_coeffs_y = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
982  const int num_ar_coeffs_uv = num_ar_coeffs_y + !!aom->num_y_points;
983  print_int("chroma_scaling_from_luma", aom->chroma_scaling_from_luma);
984  print_int("scaling_shift", aom->scaling_shift);
985  print_int("ar_coeff_lag", aom->ar_coeff_lag);
986  print_int("ar_coeff_shift", aom->ar_coeff_shift);
987  print_int("grain_scale_shift", aom->grain_scale_shift);
988  print_int("overlap_flag", aom->overlap_flag);
989  print_int("limit_output_range", aom->limit_output_range);
990 
991  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
992 
993  if (aom->num_y_points) {
994  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
995 
996  print_int("bit_depth_luma", fgp->bit_depth_luma);
997  print_list_fmt("y_points_value", "%"PRIu8, aom->num_y_points, 1, aom->y_points[idx][0]);
998  print_list_fmt("y_points_scaling", "%"PRIu8, aom->num_y_points, 1, aom->y_points[idx][1]);
999  print_list_fmt("ar_coeffs_y", "%"PRId8, num_ar_coeffs_y, 1, aom->ar_coeffs_y[idx]);
1000 
1001  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
1002  avtext_print_section_footer(tfc);
1003  }
1004 
1005  for (int uv = 0; uv < 2; uv++) {
1006  if (!aom->num_uv_points[uv] && !aom->chroma_scaling_from_luma)
1007  continue;
1008 
1009  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
1010 
1011  print_int("bit_depth_chroma", fgp->bit_depth_chroma);
1012  print_list_fmt("uv_points_value", "%"PRIu8, aom->num_uv_points[uv], 1, aom->uv_points[uv][idx][0]);
1013  print_list_fmt("uv_points_scaling", "%"PRIu8, aom->num_uv_points[uv], 1, aom->uv_points[uv][idx][1]);
1014  print_list_fmt("ar_coeffs_uv", "%"PRId8, num_ar_coeffs_uv, 1, aom->ar_coeffs_uv[uv][idx]);
1015  print_int("uv_mult", aom->uv_mult[uv]);
1016  print_int("uv_mult_luma", aom->uv_mult_luma[uv]);
1017  print_int("uv_offset", aom->uv_offset[uv]);
1018 
1019  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
1020  avtext_print_section_footer(tfc);
1021  }
1022 
1023  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
1024  avtext_print_section_footer(tfc);
1025  break;
1026  }
1027  case AV_FILM_GRAIN_PARAMS_H274: {
1028  const AVFilmGrainH274Params *h274 = &fgp->codec.h274;
1029  print_int("model_id", h274->model_id);
1030  print_int("blending_mode_id", h274->blending_mode_id);
1031  print_int("log2_scale_factor", h274->log2_scale_factor);
1032 
1033  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
1034 
1035  for (int c = 0; c < 3; c++) {
1036  if (!h274->component_model_present[c])
1037  continue;
1038 
1039  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
1040  print_int(c ? "bit_depth_chroma" : "bit_depth_luma", c ? fgp->bit_depth_chroma : fgp->bit_depth_luma);
1041 
1042  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST);
1043  for (int i = 0; i < h274->num_intensity_intervals[c]; i++) {
1044 
1045  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_PIECE);
1046  print_int("intensity_interval_lower_bound", h274->intensity_interval_lower_bound[c][i]);
1047  print_int("intensity_interval_upper_bound", h274->intensity_interval_upper_bound[c][i]);
1048  print_list_fmt("comp_model_value", "%"PRId16, h274->num_model_values[c], 1, h274->comp_model_value[c][i][idx]);
1049 
1050  // SECTION_ID_FRAME_SIDE_DATA_PIECE
1051  avtext_print_section_footer(tfc);
1052  }
1053 
1054  // SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
1055  avtext_print_section_footer(tfc);
1056 
1057  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
1058  avtext_print_section_footer(tfc);
1059  }
1060 
1061  // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
1062  avtext_print_section_footer(tfc);
1063  break;
1064  }
1065  }
1066 
1067  av_bprint_finalize(&pbuf, NULL);
1068 }
1069 
1070 static void print_pkt_side_data(AVTextFormatContext *tfc,
1071  int width,
1072  int height,
1073  const AVPacketSideData *sd,
1074  SectionID id_data)
1075 {
1076  const char *name = av_packet_side_data_name(sd->type);
1077 
1078  avtext_print_section_header(tfc, sd, id_data);
1079  print_str("side_data_type", name ? name : "unknown");
1080  if (sd->type == AV_PKT_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
1081  print_displaymatrix(tfc, (const int32_t*)sd->data);
1082  } else if (sd->type == AV_PKT_DATA_STEREO3D) {
1083  const AVStereo3D *stereo = (AVStereo3D *)sd->data;
1084  print_str("type", av_stereo3d_type_name(stereo->type));
1085  print_int("inverted", !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
1086  print_str("view", av_stereo3d_view_name(stereo->view));
1087  print_str("primary_eye", av_stereo3d_primary_eye_name(stereo->primary_eye));
1088  print_int("baseline", stereo->baseline);
1089  print_q("horizontal_disparity_adjustment", stereo->horizontal_disparity_adjustment, '/');
1090  print_q("horizontal_field_of_view", stereo->horizontal_field_of_view, '/');
1091  } else if (sd->type == AV_PKT_DATA_SPHERICAL) {
1092  const AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
1093  print_str("projection", av_spherical_projection_name(spherical->projection));
1094  if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
1095  print_int("padding", spherical->padding);
1096  } else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
1097  size_t l, t, r, b;
1098  av_spherical_tile_bounds(spherical, width, height,
1099  &l, &t, &r, &b);
1100  print_int("bound_left", l);
1101  print_int("bound_top", t);
1102  print_int("bound_right", r);
1103  print_int("bound_bottom", b);
1104  }
1105 
1106  print_int("yaw", (double) spherical->yaw / (1 << 16));
1107  print_int("pitch", (double) spherical->pitch / (1 << 16));
1108  print_int("roll", (double) spherical->roll / (1 << 16));
1109  } else if (sd->type == AV_PKT_DATA_SKIP_SAMPLES && sd->size == 10) {
1110  print_int("skip_samples", AV_RL32(sd->data));
1111  print_int("discard_padding", AV_RL32(sd->data + 4));
1112  print_int("skip_reason", AV_RL8(sd->data + 8));
1113  print_int("discard_reason", AV_RL8(sd->data + 9));
1114  } else if (sd->type == AV_PKT_DATA_MASTERING_DISPLAY_METADATA) {
1115  print_mastering_display_metadata(tfc, (AVMasteringDisplayMetadata *)sd->data);
1116  } else if (sd->type == AV_PKT_DATA_CONTENT_LIGHT_LEVEL) {
1117  print_context_light_level(tfc, (AVContentLightMetadata *)sd->data);
1118  } else if (sd->type == AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT) {
1119  print_ambient_viewing_environment(
1120  tfc, (const AVAmbientViewingEnvironment *)sd->data);
1121  } else if (sd->type == AV_PKT_DATA_DYNAMIC_HDR10_PLUS) {
1122  AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
1123  print_dynamic_hdr10_plus(tfc, metadata);
1124  } else if (sd->type == AV_PKT_DATA_DOVI_CONF) {
1125  AVDOVIDecoderConfigurationRecord *dovi = (AVDOVIDecoderConfigurationRecord *)sd->data;
1126  const char *comp = "unknown";
1127  print_int("dv_version_major", dovi->dv_version_major);
1128  print_int("dv_version_minor", dovi->dv_version_minor);
1129  print_int("dv_profile", dovi->dv_profile);
1130  print_int("dv_level", dovi->dv_level);
1131  print_int("rpu_present_flag", dovi->rpu_present_flag);
1132  print_int("el_present_flag", dovi->el_present_flag);
1133  print_int("bl_present_flag", dovi->bl_present_flag);
1134  print_int("dv_bl_signal_compatibility_id", dovi->dv_bl_signal_compatibility_id);
1135  switch (dovi->dv_md_compression)
1136  {
1137  case AV_DOVI_COMPRESSION_NONE: comp = "none"; break;
1138  case AV_DOVI_COMPRESSION_LIMITED: comp = "limited"; break;
1139  case AV_DOVI_COMPRESSION_RESERVED: comp = "reserved"; break;
1140  case AV_DOVI_COMPRESSION_EXTENDED: comp = "extended"; break;
1141  }
1142  print_str("dv_md_compression", comp);
1143  } else if (sd->type == AV_PKT_DATA_AUDIO_SERVICE_TYPE) {
1144  enum AVAudioServiceType *t = (enum AVAudioServiceType *)sd->data;
1145  print_int("service_type", *t);
1146  } else if (sd->type == AV_PKT_DATA_MPEGTS_STREAM_ID) {
1147  print_int("id", *sd->data);
1148  } else if (sd->type == AV_PKT_DATA_CPB_PROPERTIES) {
1149  const AVCPBProperties *prop = (AVCPBProperties *)sd->data;
1150  print_int("max_bitrate", prop->max_bitrate);
1151  print_int("min_bitrate", prop->min_bitrate);
1152  print_int("avg_bitrate", prop->avg_bitrate);
1153  print_int("buffer_size", prop->buffer_size);
1154  print_int("vbv_delay", prop->vbv_delay);
1155  } else if (sd->type == AV_PKT_DATA_WEBVTT_IDENTIFIER ||
1156  sd->type == AV_PKT_DATA_WEBVTT_SETTINGS) {
1157  if (do_show_data)
1158  avtext_print_data(tfc, "data", sd->data, sd->size);
1159  avtext_print_data_hash(tfc, "data_hash", sd->data, sd->size);
1160  } else if (sd->type == AV_PKT_DATA_FRAME_CROPPING && sd->size >= sizeof(uint32_t) * 4) {
1161  print_int("crop_top", AV_RL32(sd->data));
1162  print_int("crop_bottom", AV_RL32(sd->data + 4));
1163  print_int("crop_left", AV_RL32(sd->data + 8));
1164  print_int("crop_right", AV_RL32(sd->data + 12));
1165  } else if (sd->type == AV_PKT_DATA_AFD && sd->size > 0) {
1166  print_int("active_format", *sd->data);
1167  } else if (sd->type == AV_PKT_DATA_EXIF) {
1168  print_int("size", sd->size);
1169  } else if (sd->type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL && sd->size >= 8) {
1170  print_int("block_additional_id", AV_RB64(sd->data));
1171  if (do_show_data)
1172  avtext_print_data(tfc, "block_additional_data", sd->data + 8, sd->size - 8);
1173  }
1174 }
1175 
1176 static void print_private_data(AVTextFormatContext *tfc, void *priv_data)
1177 {
1178  const AVOption *opt = NULL;
1179  while (opt = av_opt_next(priv_data, opt)) {
1180  uint8_t *str;
1181  if (!(opt->flags & AV_OPT_FLAG_EXPORT)) continue;
1182  if (av_opt_get(priv_data, opt->name, 0, &str) >= 0) {
1183  print_str(opt->name, str);
1184  av_free(str);
1185  }
1186  }
1187 }
1188 
1189 static void print_pixel_format(AVTextFormatContext *tfc, enum AVPixelFormat pix_fmt)
1190 {
1191  const char *s = av_get_pix_fmt_name(pix_fmt);
1192  enum AVPixelFormat swapped_pix_fmt;
1193 
1194  if (!s) {
1195  print_str_opt("pix_fmt", "unknown");
1196  } else if (!do_bitexact ||
1197  (swapped_pix_fmt = av_pix_fmt_swap_endianness(pix_fmt)) == AV_PIX_FMT_NONE) {
1198  print_str ("pix_fmt", s);
1199  } else {
1200  const char *s2 = av_get_pix_fmt_name(swapped_pix_fmt);
1201  char buf[128];
1202  size_t i = 0;
1203 
1204  while (s[i] && s[i] == s2[i] && i < sizeof(buf) - 1) {
1205  buf[i] = s[i];
1206  i++;
1207  }
1208  buf[i] = '\0';
1209 
1210  print_str ("pix_fmt", buf);
1211  }
1212 }
1213 
1214 static void print_color_range(AVTextFormatContext *tfc, enum AVColorRange color_range)
1215 {
1216  const char *val = av_color_range_name(color_range);
1217  if (!val || color_range == AVCOL_RANGE_UNSPECIFIED) {
1218  print_str_opt("color_range", "unknown");
1219  } else {
1220  print_str("color_range", val);
1221  }
1222 }
1223 
1224 static void print_color_space(AVTextFormatContext *tfc, enum AVColorSpace color_space)
1225 {
1226  const char *val = av_color_space_name(color_space);
1227  if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
1228  print_str_opt("color_space", "unknown");
1229  } else {
1230  print_str("color_space", val);
1231  }
1232 }
1233 
1234 static void print_primaries(AVTextFormatContext *tfc, enum AVColorPrimaries color_primaries)
1235 {
1236  const char *val = av_color_primaries_name(color_primaries);
1237  if (!val || color_primaries == AVCOL_PRI_UNSPECIFIED) {
1238  print_str_opt("color_primaries", "unknown");
1239  } else {
1240  print_str("color_primaries", val);
1241  }
1242 }
1243 
1244 static void print_color_trc(AVTextFormatContext *tfc, enum AVColorTransferCharacteristic color_trc)
1245 {
1246  const char *val = av_color_transfer_name(color_trc);
1247  if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
1248  print_str_opt("color_transfer", "unknown");
1249  } else {
1250  print_str("color_transfer", val);
1251  }
1252 }
1253 
1254 static void print_chroma_location(AVTextFormatContext *tfc, enum AVChromaLocation chroma_location)
1255 {
1256  const char *val = av_chroma_location_name(chroma_location);
1257  if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
1258  print_str_opt("chroma_location", "unspecified");
1259  } else {
1260  print_str("chroma_location", val);
1261  }
1262 }
1263 
1264 static void print_alpha_mode(AVTextFormatContext *tfc, enum AVAlphaMode alpha_mode)
1265 {
1266  const char *val = av_alpha_mode_name(alpha_mode);
1267  if (!val || alpha_mode == AVALPHA_MODE_UNSPECIFIED) {
1268  print_str_opt("alpha_mode", "unspecified");
1269  } else {
1270  print_str("alpha_mode", val);
1271  }
1272 }
1273 
1274 static void clear_log(int need_lock)
1275 {
1276  int i;
1277 
1278  if (need_lock)
1279  ff_mutex_lock(&log_mutex);
1280  for (i=0; i<log_buffer_size; i++) {
1281  av_freep(&log_buffer[i].context_name);
1282  av_freep(&log_buffer[i].parent_name);
1283  av_freep(&log_buffer[i].log_message);
1284  }
1285  log_buffer_size = 0;
1286  if(need_lock)
1287  ff_mutex_unlock(&log_mutex);
1288 }
1289 
1290 static int show_log(AVTextFormatContext *tfc, int section_ids, int section_id, int log_level)
1291 {
1292  int i;
1293  ff_mutex_lock(&log_mutex);
1294  if (!log_buffer_size) {
1295  ff_mutex_unlock(&log_mutex);
1296  return 0;
1297  }
1298  avtext_print_section_header(tfc, NULL, section_ids);
1299 
1300  for (i=0; i<log_buffer_size; i++) {
1301  if (log_buffer[i].log_level <= log_level) {
1302  avtext_print_section_header(tfc, NULL, section_id);
1303  print_str("context", log_buffer[i].context_name);
1304  print_int("level", log_buffer[i].log_level);
1305  print_int("category", log_buffer[i].category);
1306  if (log_buffer[i].parent_name) {
1307  print_str("parent_context", log_buffer[i].parent_name);
1308  print_int("parent_category", log_buffer[i].parent_category);
1309  } else {
1310  print_str_opt("parent_context", "N/A");
1311  print_str_opt("parent_category", "N/A");
1312  }
1313  print_str("message", log_buffer[i].log_message);
1314  avtext_print_section_footer(tfc);
1315  }
1316  }
1317  clear_log(0);
1318  ff_mutex_unlock(&log_mutex);
1319 
1320  avtext_print_section_footer(tfc);
1321 
1322  return 0;
1323 }
1324 
1325 static void show_packet(AVTextFormatContext *tfc, InputFile *ifile, AVPacket *pkt, int packet_idx)
1326 {
1327  AVStream *st = ifile->streams[pkt->stream_index].st;
1328  AVBPrint pbuf;
1329  const char *s;
1330 
1331  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
1332 
1333  avtext_print_section_header(tfc, NULL, SECTION_ID_PACKET);
1334 
1335  s = av_get_media_type_string(st->codecpar->codec_type);
1336  if (s) print_str ("codec_type", s);
1337  else print_str_opt("codec_type", "unknown");
1338  print_int("stream_index", pkt->stream_index);
1339  print_ts ("pts", pkt->pts);
1340  print_time("pts_time", pkt->pts, &st->time_base);
1341  print_ts ("dts", pkt->dts);
1342  print_time("dts_time", pkt->dts, &st->time_base);
1343  print_duration_ts("duration", pkt->duration);
1344  print_duration_time("duration_time", pkt->duration, &st->time_base);
1345  print_val("size", pkt->size, unit_byte_str);
1346  if (pkt->pos != -1) print_fmt ("pos", "%"PRId64, pkt->pos);
1347  else print_str_opt("pos", "N/A");
1348  print_fmt("flags", "%c%c%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_',
1349  pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_',
1350  pkt->flags & AV_PKT_FLAG_CORRUPT ? 'C' : '_');
1351  if (do_show_data)
1352  avtext_print_data(tfc, "data", pkt->data, pkt->size);
1353  avtext_print_data_hash(tfc, "data_hash", pkt->data, pkt->size);
1354 
1355  if (pkt->side_data_elems) {
1356  size_t size;
1357  const uint8_t *side_metadata;
1358 
1359  side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);
1360  if (side_metadata && size && do_show_packet_tags) {
1361  AVDictionary *dict = NULL;
1362  if (av_packet_unpack_dictionary(side_metadata, size, &dict) >= 0)
1363  show_tags(tfc, dict, SECTION_ID_PACKET_TAGS);
1364  av_dict_free(&dict);
1365  }
1366 
1367  avtext_print_section_header(tfc, NULL, SECTION_ID_PACKET_SIDE_DATA_LIST);
1368  for (int i = 0; i < pkt->side_data_elems; i++) {
1369  print_pkt_side_data(tfc, st->codecpar->width, st->codecpar->height, &pkt->side_data[i],
1370  SECTION_ID_PACKET_SIDE_DATA);
1371  avtext_print_section_footer(tfc);
1372  }
1373  avtext_print_section_footer(tfc);
1374  }
1375 
1376  avtext_print_section_footer(tfc);
1377 
1378  av_bprint_finalize(&pbuf, NULL);
1379  fflush(stdout);
1380 }
1381 
1382 static void show_subtitle(AVTextFormatContext *tfc, AVSubtitle *sub, AVStream *stream,
1383  AVFormatContext *fmt_ctx)
1384 {
1385  AVBPrint pbuf;
1386 
1387  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
1388 
1389  avtext_print_section_header(tfc, NULL, SECTION_ID_SUBTITLE);
1390 
1391  print_str ("media_type", "subtitle");
1392  print_ts ("pts", sub->pts);
1393  print_time("pts_time", sub->pts, &AV_TIME_BASE_Q);
1394  print_int ("format", sub->format);
1395  print_int ("start_display_time", sub->start_display_time);
1396  print_int ("end_display_time", sub->end_display_time);
1397  print_int ("num_rects", sub->num_rects);
1398 
1399  avtext_print_section_footer(tfc);
1400 
1401  av_bprint_finalize(&pbuf, NULL);
1402  fflush(stdout);
1403 }
1404 
1405 static void print_frame_side_data(AVTextFormatContext *tfc,
1406  const AVFrame *frame,
1407  const AVStream *stream)
1408 {
1409  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_LIST);
1410 
1411  for (int i = 0; i < frame->nb_side_data; i++) {
1412  const AVFrameSideData *sd = frame->side_data[i];
1413  const char *name;
1414 
1415  avtext_print_section_header(tfc, sd, SECTION_ID_FRAME_SIDE_DATA);
1416  name = av_frame_side_data_name(sd->type);
1417  print_str("side_data_type", name ? name : "unknown");
1418  if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
1419  print_displaymatrix(tfc, (const int32_t*)sd->data);
1420  } else if (sd->type == AV_FRAME_DATA_AFD && sd->size > 0) {
1421  print_int("active_format", *sd->data);
1422  } else if (sd->type == AV_FRAME_DATA_GOP_TIMECODE && sd->size >= 8) {
1423  char tcbuf[AV_TIMECODE_STR_SIZE];
1424  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
1425  print_str("timecode", tcbuf);
1426  } else if (sd->type == AV_FRAME_DATA_S12M_TIMECODE && sd->size == 16) {
1427  uint32_t *tc = (uint32_t*)sd->data;
1428  int m = FFMIN(tc[0],3);
1429  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST);
1430  for (int j = 1; j <= m ; j++) {
1431  char tcbuf[AV_TIMECODE_STR_SIZE];
1432  av_timecode_make_smpte_tc_string2(tcbuf, stream->avg_frame_rate, tc[j], 0, 0);
1433  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME_SIDE_DATA_TIMECODE);
1434  print_str("value", tcbuf);
1435  avtext_print_section_footer(tfc);
1436  }
1437  avtext_print_section_footer(tfc);
1438  } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
1439  print_mastering_display_metadata(tfc, (AVMasteringDisplayMetadata *)sd->data);
1440  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_PLUS) {
1441  AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
1442  print_dynamic_hdr10_plus(tfc, metadata);
1443  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_SMPTE_2094_APP5) {
1444  AVDynamicHDRSmpte2094App5 *metadata = (AVDynamicHDRSmpte2094App5 *)sd->data;
1445  print_dynamic_hdr_smpte2094_app5(tfc, metadata);
1446  } else if (sd->type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL) {
1447  print_context_light_level(tfc, (AVContentLightMetadata *)sd->data);
1448  } else if (sd->type == AV_FRAME_DATA_ICC_PROFILE) {
1449  const AVDictionaryEntry *tag = av_dict_get(sd->metadata, "name", NULL, AV_DICT_MATCH_CASE);
1450  if (tag)
1451  print_str(tag->key, tag->value);
1452  print_int("size", sd->size);
1453  } else if (sd->type == AV_FRAME_DATA_DOVI_METADATA) {
1454  print_dovi_metadata(tfc, (const AVDOVIMetadata *)sd->data);
1455  } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_VIVID) {
1456  AVDynamicHDRVivid *metadata = (AVDynamicHDRVivid *)sd->data;
1457  print_dynamic_hdr_vivid(tfc, metadata);
1458  } else if (sd->type == AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT) {
1459  print_ambient_viewing_environment(tfc, (const AVAmbientViewingEnvironment *)sd->data);
1460  } else if (sd->type == AV_FRAME_DATA_FILM_GRAIN_PARAMS) {
1461  AVFilmGrainParams *fgp = (AVFilmGrainParams *)sd->data;
1462  print_film_grain_params(tfc, fgp);
1463  } else if (sd->type == AV_FRAME_DATA_VIEW_ID) {
1464  print_int("view_id", *(int*)sd->data);
1465  } else if (sd->type == AV_FRAME_DATA_EXIF) {
1466  print_int("size", sd->size);
1467  }
1468  avtext_print_section_footer(tfc);
1469  }
1470  avtext_print_section_footer(tfc);
1471 }
1472 
1473 static void show_frame(AVTextFormatContext *tfc, AVFrame *frame, AVStream *stream,
1474  AVFormatContext *fmt_ctx)
1475 {
1476  FrameData *fd = frame->opaque_ref ? (FrameData*)frame->opaque_ref->data : NULL;
1477  AVBPrint pbuf;
1478  char val_str[128];
1479  const char *s;
1480 
1481  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
1482 
1483  avtext_print_section_header(tfc, NULL, SECTION_ID_FRAME);
1484 
1485  s = av_get_media_type_string(stream->codecpar->codec_type);
1486  if (s) print_str ("media_type", s);
1487  else print_str_opt("media_type", "unknown");
1488  print_int("stream_index", stream->index);
1489  print_int("key_frame", !!(frame->flags & AV_FRAME_FLAG_KEY));
1490  print_ts ("pts", frame->pts);
1491  print_time("pts_time", frame->pts, &stream->time_base);
1492  print_ts ("pkt_dts", frame->pkt_dts);
1493  print_time("pkt_dts_time", frame->pkt_dts, &stream->time_base);
1494  print_ts ("best_effort_timestamp", frame->best_effort_timestamp);
1495  print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
1496  print_duration_ts ("duration", frame->duration);
1497  print_duration_time("duration_time", frame->duration, &stream->time_base);
1498  if (fd && fd->pkt_pos != -1) print_fmt ("pkt_pos", "%"PRId64, fd->pkt_pos);
1499  else print_str_opt("pkt_pos", "N/A");
1500  if (fd && fd->pkt_size != -1) print_val ("pkt_size", fd->pkt_size, unit_byte_str);
1501  else print_str_opt("pkt_size", "N/A");
1502 
1503  switch (stream->codecpar->codec_type) {
1504  AVRational sar;
1505 
1506  case AVMEDIA_TYPE_VIDEO:
1507  print_int("width", frame->width);
1508  print_int("height", frame->height);
1509  print_int("crop_top", frame->crop_top);
1510  print_int("crop_bottom", frame->crop_bottom);
1511  print_int("crop_left", frame->crop_left);
1512  print_int("crop_right", frame->crop_right);
1513  print_pixel_format(tfc, frame->format);
1514  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
1515  if (sar.num) {
1516  print_q("sample_aspect_ratio", sar, ':');
1517  } else {
1518  print_str_opt("sample_aspect_ratio", "N/A");
1519  }
1520  print_fmt("pict_type", "%c", av_get_picture_type_char(frame->pict_type));
1521  print_int("interlaced_frame", !!(frame->flags & AV_FRAME_FLAG_INTERLACED));
1522  print_int("top_field_first", !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
1523  print_int("lossless", !!(frame->flags & AV_FRAME_FLAG_LOSSLESS));
1524  print_int("repeat_pict", frame->repeat_pict);
1525 
1526  print_color_range(tfc, frame->color_range);
1527  print_color_space(tfc, frame->colorspace);
1528  print_primaries(tfc, frame->color_primaries);
1529  print_color_trc(tfc, frame->color_trc);
1530  print_chroma_location(tfc, frame->chroma_location);
1531  print_alpha_mode(tfc, frame->alpha_mode);
1532  break;
1533 
1534  case AVMEDIA_TYPE_AUDIO:
1535  s = av_get_sample_fmt_name(frame->format);
1536  if (s) print_str ("sample_fmt", s);
1537  else print_str_opt("sample_fmt", "unknown");
1538  print_int("nb_samples", frame->nb_samples);
1539  print_int("channels", frame->ch_layout.nb_channels);
1540  if (frame->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
1541  av_channel_layout_describe(&frame->ch_layout, val_str, sizeof(val_str));
1542  print_str ("channel_layout", val_str);
1543  } else
1544  print_str_opt("channel_layout", "unknown");
1545  break;
1546  }
1547  if (do_show_frame_tags)
1548  show_tags(tfc, frame->metadata, SECTION_ID_FRAME_TAGS);
1549  if (do_show_log)
1550  show_log(tfc, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log);
1551  if (frame->nb_side_data)
1552  print_frame_side_data(tfc, frame, stream);
1553 
1554  avtext_print_section_footer(tfc);
1555 
1556  av_bprint_finalize(&pbuf, NULL);
1557  fflush(stdout);
1558 }
1559 
1560 static av_always_inline int process_frame(AVTextFormatContext *tfc,
1561  InputFile *ifile,
1562  AVFrame *frame, const AVPacket *pkt,
1563  int *packet_new)
1564 {
1565  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
1566  AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
1567  AVCodecParameters *par = ifile->streams[pkt->stream_index].st->codecpar;
1568  AVSubtitle sub;
1569  int ret = 0, got_frame = 0;
1570 
1571  clear_log(1);
1572  if (dec_ctx) {
1573  switch (par->codec_type) {
1574  case AVMEDIA_TYPE_VIDEO:
1575  case AVMEDIA_TYPE_AUDIO:
1576  if (*packet_new) {
1577  ret = avcodec_send_packet(dec_ctx, pkt);
1578  if (ret == AVERROR(EAGAIN)) {
1579  ret = 0;
1580  } else if (ret >= 0 || ret == AVERROR_EOF) {
1581  ret = 0;
1582  *packet_new = 0;
1583  }
1584  }
1585  if (ret >= 0) {
1586  ret = avcodec_receive_frame(dec_ctx, frame);
1587  if (ret >= 0) {
1588  got_frame = 1;
1589  } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
1590  ret = 0;
1591  }
1592  }
1593  break;
1594 
1595  case AVMEDIA_TYPE_SUBTITLE:
1596  if (*packet_new)
1597  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
1598  *packet_new = 0;
1599  break;
1600  default:
1601  *packet_new = 0;
1602  }
1603  } else {
1604  *packet_new = 0;
1605  }
1606 
1607  if (ret < 0)
1608  return ret;
1609  if (got_frame) {
1610  int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
1611  nb_streams_frames[pkt->stream_index]++;
1612  if (do_show_frames)
1613  if (is_sub)
1614  show_subtitle(tfc, &sub, ifile->streams[pkt->stream_index].st, fmt_ctx);
1615  else
1616  show_frame(tfc, frame, ifile->streams[pkt->stream_index].st, fmt_ctx);
1617 
1618  if (!is_sub && do_analyze_frames) {
1619  for (int i = 0; i < frame->nb_side_data; i++) {
1620  if (frame->side_data[i]->type == AV_FRAME_DATA_A53_CC)
1621  streams_with_closed_captions[pkt->stream_index] = 1;
1622  else if (frame->side_data[i]->type == AV_FRAME_DATA_FILM_GRAIN_PARAMS)
1623  streams_with_film_grain[pkt->stream_index] = 1;
1624  }
1625  }
1626 
1627  if (is_sub)
1628  avsubtitle_free(&sub);
1629  }
1630  return got_frame || *packet_new;
1631 }
1632 
1633 static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
1634 {
1635  av_log(log_ctx, log_level, "id:%d", interval->id);
1636 
1637  if (interval->has_start) {
1638  av_log(log_ctx, log_level, " start:%s%s", interval->start_is_offset ? "+" : "",
1639  av_ts2timestr(interval->start, &AV_TIME_BASE_Q));
1640  } else {
1641  av_log(log_ctx, log_level, " start:N/A");
1642  }
1643 
1644  if (interval->has_end) {
1645  av_log(log_ctx, log_level, " end:%s", interval->end_is_offset ? "+" : "");
1646  if (interval->duration_frames)
1647  av_log(log_ctx, log_level, "#%"PRId64, interval->end);
1648  else
1649  av_log(log_ctx, log_level, "%s", av_ts2timestr(interval->end, &AV_TIME_BASE_Q));
1650  } else {
1651  av_log(log_ctx, log_level, " end:N/A");
1652  }
1653 
1654  av_log(log_ctx, log_level, "\n");
1655 }
1656 
1657 static int read_interval_packets(AVTextFormatContext *tfc, InputFile *ifile,
1658  const ReadInterval *interval, int64_t *cur_ts)
1659 {
1660  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
1661  AVPacket *pkt = NULL;
1662  AVFrame *frame = NULL;
1663  int ret = 0, i = 0, frame_count = 0;
1664  int64_t start = -INT64_MAX, end = interval->end;
1665  int has_start = 0, has_end = interval->has_end && !interval->end_is_offset;
1666 
1667  av_log(NULL, AV_LOG_VERBOSE, "Processing read interval ");
1668  log_read_interval(interval, NULL, AV_LOG_VERBOSE);
1669 
1670  if (interval->has_start) {
1671  int64_t target;
1672  if (interval->start_is_offset) {
1673  if (*cur_ts == AV_NOPTS_VALUE) {
1674  av_log(NULL, AV_LOG_ERROR,
1675  "Could not seek to relative position since current "
1676  "timestamp is not defined\n");
1677  ret = AVERROR(EINVAL);
1678  goto end;
1679  }
1680  target = *cur_ts + interval->start;
1681  } else {
1682  target = interval->start;
1683  }
1684 
1685  av_log(NULL, AV_LOG_VERBOSE, "Seeking to read interval start point %s\n",
1686  av_ts2timestr(target, &AV_TIME_BASE_Q));
1687  if ((ret = avformat_seek_file(fmt_ctx, -1, -INT64_MAX, target, INT64_MAX, 0)) < 0) {
1688  av_log(NULL, AV_LOG_ERROR, "Could not seek to position %"PRId64": %s\n",
1689  interval->start, av_err2str(ret));
1690  goto end;
1691  }
1692  }
1693 
1694  frame = av_frame_alloc();
1695  if (!frame) {
1696  ret = AVERROR(ENOMEM);
1697  goto end;
1698  }
1699  pkt = av_packet_alloc();
1700  if (!pkt) {
1701  ret = AVERROR(ENOMEM);
1702  goto end;
1703  }
1704  while (!av_read_frame(fmt_ctx, pkt)) {
1705  if (fmt_ctx->nb_streams > nb_streams) {
1706  REALLOCZ_ARRAY_STREAM(nb_streams_frames, nb_streams, fmt_ctx->nb_streams);
1707  REALLOCZ_ARRAY_STREAM(nb_streams_packets, nb_streams, fmt_ctx->nb_streams);
1708  REALLOCZ_ARRAY_STREAM(selected_streams, nb_streams, fmt_ctx->nb_streams);
1709  REALLOCZ_ARRAY_STREAM(streams_with_closed_captions, nb_streams, fmt_ctx->nb_streams);
1710  REALLOCZ_ARRAY_STREAM(streams_with_film_grain, nb_streams, fmt_ctx->nb_streams);
1711  nb_streams = fmt_ctx->nb_streams;
1712  }
1713  if (selected_streams[pkt->stream_index]) {
1714  AVRational tb = ifile->streams[pkt->stream_index].st->time_base;
1715  int64_t pts = pkt->pts != AV_NOPTS_VALUE ? pkt->pts : pkt->dts;
1716 
1717  if (pts != AV_NOPTS_VALUE)
1718  *cur_ts = av_rescale_q(pts, tb, AV_TIME_BASE_Q);
1719 
1720  if (!has_start && *cur_ts != AV_NOPTS_VALUE) {
1721  start = *cur_ts;
1722  has_start = 1;
1723  }
1724 
1725  if (has_start && !has_end && interval->end_is_offset) {
1726  end = start + interval->end;
1727  has_end = 1;
1728  }
1729 
1730  if (interval->end_is_offset && interval->duration_frames) {
1731  if (frame_count >= interval->end)
1732  break;
1733  } else if (has_end && *cur_ts != AV_NOPTS_VALUE && *cur_ts >= end) {
1734  break;
1735  }
1736 
1737  frame_count++;
1738  if (do_read_packets) {
1739  if (do_show_packets)
1740  show_packet(tfc, ifile, pkt, i++);
1741  nb_streams_packets[pkt->stream_index]++;
1742  }
1743  if (do_read_frames) {
1744  int packet_new = 1;
1745  FrameData *fd;
1746 
1747  pkt->opaque_ref = av_buffer_allocz(sizeof(*fd));
1748  if (!pkt->opaque_ref) {
1749  ret = AVERROR(ENOMEM);
1750  goto end;
1751  }
1752  fd = (FrameData*)pkt->opaque_ref->data;
1753  fd->pkt_pos = pkt->pos;
1754  fd->pkt_size = pkt->size;
1755 
1756  while (process_frame(tfc, ifile, frame, pkt, &packet_new) > 0);
1757  }
1758  }
1759  av_packet_unref(pkt);
1760  }
1761  av_packet_unref(pkt);
1762  //Flush remaining frames that are cached in the decoder
1763  for (i = 0; i < ifile->nb_streams; i++) {
1764  pkt->stream_index = i;
1765  if (do_read_frames) {
1766  while (process_frame(tfc, ifile, frame, pkt, &(int){1}) > 0);
1767  }
1768  }
1769 
1770 end:
1771  av_frame_free(&frame);
1772  av_packet_free(&pkt);
1773  if (ret < 0) {
1774  av_log(NULL, AV_LOG_ERROR, "Could not read packets in interval ");
1775  log_read_interval(interval, NULL, AV_LOG_ERROR);
1776  }
1777  return ret;
1778 }
1779 
1780 static void flush_buffers(InputFile *ifile)
1781 {
1782  int i;
1783 
1784  if (!do_read_frames)
1785  return;
1786  for (i = 0; i < ifile->nb_streams; i++) {
1787  if (ifile->streams[i].dec_ctx)
1788  avcodec_flush_buffers(ifile->streams[i].dec_ctx);
1789  }
1790 }
1791 
1792 static int read_packets(AVTextFormatContext *tfc, InputFile *ifile)
1793 {
1794  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
1795  int i, ret = 0;
1796  int64_t cur_ts = fmt_ctx->start_time;
1797 
1798  if (read_intervals_nb == 0) {
1799  ReadInterval interval = (ReadInterval) { .has_start = 0, .has_end = 0 };
1800  ret = read_interval_packets(tfc, ifile, &interval, &cur_ts);
1801  } else {
1802  for (i = 0; i < read_intervals_nb; i++) {
1803  /* flushing buffers can reset parts of the private context which may be
1804  * read by show_streams(), so only flush between each read_interval */
1805  if (i)
1806  flush_buffers(ifile);
1807  ret = read_interval_packets(tfc, ifile, &read_intervals[i], &cur_ts);
1808  if (ret < 0)
1809  break;
1810  }
1811  }
1812 
1813  return ret;
1814 }
1815 
1816 static void print_dispositions(AVTextFormatContext *tfc, uint32_t disposition, SectionID section_id)
1817 {
1818  avtext_print_section_header(tfc, NULL, section_id);
1819  for (int i = 0; i < sizeof(disposition) * CHAR_BIT; i++) {
1820  const char *disposition_str = av_disposition_to_string(1U << i);
1821 
1822  if (disposition_str)
1823  print_int(disposition_str, !!(disposition & (1U << i)));
1824  }
1825  avtext_print_section_footer(tfc);
1826 }
1827 
1828 #define IN_PROGRAM 1
1829 #define IN_STREAM_GROUP 2
1830 
1831 static int show_stream(AVTextFormatContext *tfc, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int container)
1832 {
1833  AVStream *stream = ist->st;
1834  AVCodecParameters *par;
1835  AVCodecContext *dec_ctx;
1836  char val_str[128];
1837  const char *s;
1838  AVRational sar, dar;
1839  AVBPrint pbuf;
1840  const AVCodecDescriptor *cd;
1841  const SectionID section_header[] = {
1842  SECTION_ID_STREAM,
1843  SECTION_ID_PROGRAM_STREAM,
1844  SECTION_ID_STREAM_GROUP_STREAM,
1845  };
1846  const SectionID section_disposition[] = {
1847  SECTION_ID_STREAM_DISPOSITION,
1848  SECTION_ID_PROGRAM_STREAM_DISPOSITION,
1849  SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION,
1850  };
1851  const SectionID section_tags[] = {
1852  SECTION_ID_STREAM_TAGS,
1853  SECTION_ID_PROGRAM_STREAM_TAGS,
1854  SECTION_ID_STREAM_GROUP_STREAM_TAGS,
1855  };
1856  int ret = 0;
1857  const char *profile = NULL;
1858 
1859  av_assert0(container < FF_ARRAY_ELEMS(section_header));
1860 
1861  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
1862 
1863  avtext_print_section_header(tfc, NULL, section_header[container]);
1864 
1865  print_int("index", stream->index);
1866 
1867  par = stream->codecpar;
1868  dec_ctx = ist->dec_ctx;
1869  if (cd = avcodec_descriptor_get(par->codec_id)) {
1870  print_str("codec_name", cd->name);
1871  if (!do_bitexact) {
1872  print_str("codec_long_name",
1873  cd->long_name ? cd->long_name : "unknown");
1874  }
1875  } else {
1876  print_str_opt("codec_name", "unknown");
1877  if (!do_bitexact) {
1878  print_str_opt("codec_long_name", "unknown");
1879  }
1880  }
1881 
1882  if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
1883  print_str("profile", profile);
1884  else {
1885  if (par->profile != AV_PROFILE_UNKNOWN) {
1886  char profile_num[12];
1887  snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
1888  print_str("profile", profile_num);
1889  } else
1890  print_str_opt("profile", "unknown");
1891  }
1892 
1893  s = av_get_media_type_string(par->codec_type);
1894  if (s) print_str ("codec_type", s);
1895  else print_str_opt("codec_type", "unknown");
1896 
1897  /* print AVI/FourCC tag */
1898  print_str("codec_tag_string", av_fourcc2str(par->codec_tag));
1899  print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
1900 
1901  av_bprint_clear(&pbuf);
1902  if (!av_mime_codec_str(par, stream->avg_frame_rate, &pbuf))
1903  print_str("mime_codec_string", pbuf.str);
1904 
1905  switch (par->codec_type) {
1906  case AVMEDIA_TYPE_VIDEO:
1907  print_int("width", par->width);
1908  print_int("height", par->height);
1909  if (dec_ctx) {
1910  print_int("coded_width", dec_ctx->coded_width);
1911  print_int("coded_height", dec_ctx->coded_height);
1912 
1913  if (do_analyze_frames) {
1914  print_int("closed_captions", streams_with_closed_captions[stream->index]);
1915  print_int("film_grain", streams_with_film_grain[stream->index]);
1916  }
1917  }
1918  print_int("has_b_frames", par->video_delay);
1919  sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
1920  if (sar.num) {
1921  print_q("sample_aspect_ratio", sar, ':');
1922  av_reduce(&dar.num, &dar.den,
1923  (int64_t) par->width * sar.num,
1924  (int64_t) par->height * sar.den,
1925  1024*1024);
1926  print_q("display_aspect_ratio", dar, ':');
1927  } else {
1928  print_str_opt("sample_aspect_ratio", "N/A");
1929  print_str_opt("display_aspect_ratio", "N/A");
1930  }
1931  print_pixel_format(tfc, par->format);
1932  print_int("level", par->level);
1933 
1934  print_color_range(tfc, par->color_range);
1935  print_color_space(tfc, par->color_space);
1936  print_color_trc(tfc, par->color_trc);
1937  print_primaries(tfc, par->color_primaries);
1938  print_chroma_location(tfc, par->chroma_location);
1939 
1940  if (par->field_order == AV_FIELD_PROGRESSIVE)
1941  print_str("field_order", "progressive");
1942  else if (par->field_order == AV_FIELD_TT)
1943  print_str("field_order", "tt");
1944  else if (par->field_order == AV_FIELD_BB)
1945  print_str("field_order", "bb");
1946  else if (par->field_order == AV_FIELD_TB)
1947  print_str("field_order", "tb");
1948  else if (par->field_order == AV_FIELD_BT)
1949  print_str("field_order", "bt");
1950  else
1951  print_str_opt("field_order", "unknown");
1952 
1953  if (dec_ctx && do_read_frames)
1954  print_int("refs", dec_ctx->refs);
1955  break;
1956 
1957  case AVMEDIA_TYPE_AUDIO:
1958  s = av_get_sample_fmt_name(par->format);
1959  if (s) print_str ("sample_fmt", s);
1960  else print_str_opt("sample_fmt", "unknown");
1961  print_val("sample_rate", par->sample_rate, unit_hertz_str);
1962  print_int("channels", par->ch_layout.nb_channels);
1963 
1964  if (par->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
1965  av_channel_layout_describe(&par->ch_layout, val_str, sizeof(val_str));
1966  print_str ("channel_layout", val_str);
1967  } else {
1968  print_str_opt("channel_layout", "unknown");
1969  }
1970 
1971  print_int("bits_per_sample", av_get_bits_per_sample(par->codec_id));
1972 
1973  print_int("initial_padding", par->initial_padding);
1974  break;
1975 
1976  case AVMEDIA_TYPE_SUBTITLE:
1977  if (par->width)
1978  print_int("width", par->width);
1979  else
1980  print_str_opt("width", "N/A");
1981  if (par->height)
1982  print_int("height", par->height);
1983  else
1984  print_str_opt("height", "N/A");
1985  break;
1986  }
1987 
1988  if (show_private_data) {
1989  if (dec_ctx && dec_ctx->codec->priv_class)
1990  print_private_data(tfc, dec_ctx->priv_data);
1991  if (fmt_ctx->iformat->priv_class)
1992  print_private_data(tfc, fmt_ctx->priv_data);
1993  }
1994 
1995  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%x", stream->id);
1996  else print_str_opt("id", "N/A");
1997  print_q("r_frame_rate", stream->r_frame_rate, '/');
1998  print_q("avg_frame_rate", stream->avg_frame_rate, '/');
1999  print_q("time_base", stream->time_base, '/');
2000  print_ts ("start_pts", stream->start_time);
2001  print_time("start_time", stream->start_time, &stream->time_base);
2002  print_ts ("duration_ts", stream->duration);
2003  print_time("duration", stream->duration, &stream->time_base);
2004  if (par->bit_rate > 0) print_val ("bit_rate", par->bit_rate, unit_bit_per_second_str);
2005  else print_str_opt("bit_rate", "N/A");
2006  if (dec_ctx && dec_ctx->rc_max_rate > 0)
2007  print_val ("max_bit_rate", dec_ctx->rc_max_rate, unit_bit_per_second_str);
2008  else
2009  print_str_opt("max_bit_rate", "N/A");
2010  if (dec_ctx && dec_ctx->bits_per_raw_sample > 0) print_fmt("bits_per_raw_sample", "%d", dec_ctx->bits_per_raw_sample);
2011  else print_str_opt("bits_per_raw_sample", "N/A");
2012  if (stream->nb_frames) print_fmt ("nb_frames", "%"PRId64, stream->nb_frames);
2013  else print_str_opt("nb_frames", "N/A");
2014  if (nb_streams_frames[stream_idx]) print_fmt ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
2015  else print_str_opt("nb_read_frames", "N/A");
2016  if (nb_streams_packets[stream_idx]) print_fmt ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
2017  else print_str_opt("nb_read_packets", "N/A");
2018  if (do_show_data)
2019  avtext_print_data(tfc, "extradata", par->extradata,
2020  par->extradata_size);
2021 
2022  if (par->extradata_size > 0) {
2023  print_int("extradata_size", par->extradata_size);
2024  avtext_print_data_hash(tfc, "extradata_hash", par->extradata,
2025  par->extradata_size);
2026  }
2027 
2028  /* Print disposition information */
2029  if (do_show_stream_disposition) {
2030  av_assert0(container < FF_ARRAY_ELEMS(section_disposition));
2031  print_dispositions(tfc, stream->disposition, section_disposition[container]);
2032  }
2033 
2034  if (do_show_stream_tags) {
2035  av_assert0(container < FF_ARRAY_ELEMS(section_tags));
2036  ret = show_tags(tfc, stream->metadata, section_tags[container]);
2037  }
2038 
2039  if (stream->codecpar->nb_coded_side_data) {
2040  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_SIDE_DATA_LIST);
2041  for (int i = 0; i < stream->codecpar->nb_coded_side_data; i++) {
2042  print_pkt_side_data(tfc, stream->codecpar->width, stream->codecpar->height, &stream->codecpar->coded_side_data[i],
2043  SECTION_ID_STREAM_SIDE_DATA);
2044  avtext_print_section_footer(tfc);
2045  }
2046  avtext_print_section_footer(tfc);
2047  }
2048 
2049  avtext_print_section_footer(tfc);
2050  av_bprint_finalize(&pbuf, NULL);
2051  fflush(stdout);
2052 
2053  return ret;
2054 }
2055 
2056 static int show_streams(AVTextFormatContext *tfc, InputFile *ifile)
2057 {
2058  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2059  int i, ret = 0;
2060 
2061  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAMS);
2062  for (i = 0; i < ifile->nb_streams; i++)
2063  if (selected_streams[i]) {
2064  ret = show_stream(tfc, fmt_ctx, i, &ifile->streams[i], 0);
2065  if (ret < 0)
2066  break;
2067  }
2068  avtext_print_section_footer(tfc);
2069 
2070  return ret;
2071 }
2072 
2073 static int show_program(AVTextFormatContext *tfc, InputFile *ifile, AVProgram *program)
2074 {
2075  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2076  int i, ret = 0;
2077 
2078  avtext_print_section_header(tfc, NULL, SECTION_ID_PROGRAM);
2079  print_int("program_id", program->id);
2080  print_int("program_num", program->program_num);
2081  print_int("nb_streams", program->nb_stream_indexes);
2082  print_int("pmt_pid", program->pmt_pid);
2083  print_int("pcr_pid", program->pcr_pid);
2084  if (do_show_program_tags)
2085  ret = show_tags(tfc, program->metadata, SECTION_ID_PROGRAM_TAGS);
2086  if (ret < 0)
2087  goto end;
2088 
2089  avtext_print_section_header(tfc, NULL, SECTION_ID_PROGRAM_STREAMS);
2090  for (i = 0; i < program->nb_stream_indexes; i++) {
2091  if (selected_streams[program->stream_index[i]]) {
2092  ret = show_stream(tfc, fmt_ctx, program->stream_index[i], &ifile->streams[program->stream_index[i]], IN_PROGRAM);
2093  if (ret < 0)
2094  break;
2095  }
2096  }
2097  avtext_print_section_footer(tfc);
2098 
2099 end:
2100  avtext_print_section_footer(tfc);
2101  return ret;
2102 }
2103 
2104 static int show_programs(AVTextFormatContext *tfc, InputFile *ifile)
2105 {
2106  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2107  int i, ret = 0;
2108 
2109  avtext_print_section_header(tfc, NULL, SECTION_ID_PROGRAMS);
2110  for (i = 0; i < fmt_ctx->nb_programs; i++) {
2111  AVProgram *program = fmt_ctx->programs[i];
2112  if (!program)
2113  continue;
2114  ret = show_program(tfc, ifile, program);
2115  if (ret < 0)
2116  break;
2117  }
2118  avtext_print_section_footer(tfc);
2119  return ret;
2120 }
2121 
2122 static void print_tile_grid_params(AVTextFormatContext *tfc, const AVStreamGroup *stg,
2123  const AVStreamGroupTileGrid *tile_grid)
2124 {
2125  avtext_print_section_header(tfc, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
2126  print_int("nb_tiles", tile_grid->nb_tiles);
2127  print_int("coded_width", tile_grid->coded_width);
2128  print_int("coded_height", tile_grid->coded_height);
2129  print_int("horizontal_offset", tile_grid->horizontal_offset);
2130  print_int("vertical_offset", tile_grid->vertical_offset);
2131  print_int("width", tile_grid->width);
2132  print_int("height", tile_grid->height);
2133  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
2134  for (int i = 0; i < tile_grid->nb_tiles; i++) {
2135  avtext_print_section_header(tfc, "tile_offset", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
2136  print_int("stream_index", tile_grid->offsets[i].idx);
2137  print_int("tile_horizontal_offset", tile_grid->offsets[i].horizontal);
2138  print_int("tile_vertical_offset", tile_grid->offsets[i].vertical);
2139  avtext_print_section_footer(tfc);
2140  }
2141  avtext_print_section_footer(tfc);
2142  if (tile_grid->nb_coded_side_data) {
2143  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST);
2144  for (int i = 0; i < tile_grid->nb_coded_side_data; i++) {
2145  print_pkt_side_data(tfc, tile_grid->width, tile_grid->height, &tile_grid->coded_side_data[i],
2146  SECTION_ID_STREAM_GROUP_SIDE_DATA);
2147  avtext_print_section_footer(tfc);
2148  }
2149  avtext_print_section_footer(tfc);
2150  }
2151  avtext_print_section_footer(tfc);
2152 }
2153 
2154 static void print_iamf_param_definition(AVTextFormatContext *tfc, const char *name,
2155  const AVIAMFParamDefinition *param, SectionID section_id)
2156 {
2157  SectionID subsection_id, parameter_section_id;
2158  subsection_id = sections[section_id].children_ids[0];
2159  av_assert0(subsection_id != -1);
2160  parameter_section_id = sections[subsection_id].children_ids[0];
2161  av_assert0(parameter_section_id != -1);
2162  avtext_print_section_header(tfc, "IAMF Param Definition", section_id);
2163  print_str("name", name);
2164  print_int("nb_subblocks", param->nb_subblocks);
2165  print_int("type", param->type);
2166  print_int("parameter_id", param->parameter_id);
2167  print_int("parameter_rate", param->parameter_rate);
2168  print_int("duration", param->duration);
2169  print_int("constant_subblock_duration", param->constant_subblock_duration);
2170  if (param->nb_subblocks > 0)
2171  avtext_print_section_header(tfc, NULL, subsection_id);
2172  for (int i = 0; i < param->nb_subblocks; i++) {
2173  const void *subblock = av_iamf_param_definition_get_subblock(param, i);
2174  switch(param->type) {
2175  case AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN: {
2176  const AVIAMFMixGain *mix = subblock;
2177  avtext_print_section_header(tfc, "IAMF Mix Gain Parameters", parameter_section_id);
2178  print_int("subblock_duration", mix->subblock_duration);
2179  print_int("animation_type", mix->animation_type);
2180  print_q("start_point_value", mix->start_point_value, '/');
2181  print_q("end_point_value", mix->end_point_value, '/');
2182  print_q("control_point_value", mix->control_point_value, '/');
2183  print_q("control_point_relative_time", mix->control_point_relative_time, '/');
2184  avtext_print_section_footer(tfc); // parameter_section_id
2185  break;
2186  }
2187  case AV_IAMF_PARAMETER_DEFINITION_DEMIXING: {
2188  const AVIAMFDemixingInfo *demix = subblock;
2189  avtext_print_section_header(tfc, "IAMF Demixing Info", parameter_section_id);
2190  print_int("subblock_duration", demix->subblock_duration);
2191  print_int("dmixp_mode", demix->dmixp_mode);
2192  avtext_print_section_footer(tfc); // parameter_section_id
2193  break;
2194  }
2195  case AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN: {
2196  const AVIAMFReconGain *recon = subblock;
2197  avtext_print_section_header(tfc, "IAMF Recon Gain", parameter_section_id);
2198  print_int("subblock_duration", recon->subblock_duration);
2199  avtext_print_section_footer(tfc); // parameter_section_id
2200  break;
2201  }
2202  }
2203  }
2204  if (param->nb_subblocks > 0)
2205  avtext_print_section_footer(tfc); // subsection_id
2206  avtext_print_section_footer(tfc); // section_id
2207 }
2208 
2209 static void print_iamf_audio_element_params(AVTextFormatContext *tfc, const AVStreamGroup *stg,
2210  const AVIAMFAudioElement *audio_element)
2211 {
2212  AVBPrint pbuf;
2213 
2214  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2215 
2216  avtext_print_section_header(tfc, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
2217  print_int("nb_layers", audio_element->nb_layers);
2218  print_int("audio_element_type", audio_element->audio_element_type);
2219  print_int("default_w", audio_element->default_w);
2220  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
2221  for (int i = 0; i < audio_element->nb_layers; i++) {
2222  const AVIAMFLayer *layer = audio_element->layers[i];
2223  char val_str[128];
2224  avtext_print_section_header(tfc, "IAMF Audio Layer", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
2225  av_channel_layout_describe(&layer->ch_layout, val_str, sizeof(val_str));
2226  print_str("channel_layout", val_str);
2227  if (audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL) {
2228  print_int("output_gain_flags", layer->output_gain_flags);
2229  print_q("output_gain", layer->output_gain, '/');
2230  } else if (audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE) {
2231  print_int("ambisonics_mode", layer->ambisonics_mode);
2232  if (layer->ambisonics_mode == AV_IAMF_AMBISONICS_MODE_PROJECTION)
2233  print_list_fmt("demixing_matrix", "%d/%d", layer->nb_demixing_matrix, 1, layer->demixing_matrix[idx].num,
2234  layer->demixing_matrix[idx].den);
2235  }
2236  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
2237  }
2238  if (audio_element->demixing_info)
2239  print_iamf_param_definition(tfc, "demixing_info", audio_element->demixing_info,
2240  SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
2241  if (audio_element->recon_gain_info)
2242  print_iamf_param_definition(tfc, "recon_gain_info", audio_element->recon_gain_info,
2243  SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
2244  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
2245  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_COMPONENT
2246 
2247  av_bprint_finalize(&pbuf, NULL);
2248 }
2249 
2250 static void print_iamf_submix_params(AVTextFormatContext *tfc, const AVIAMFSubmix *submix)
2251 {
2252  avtext_print_section_header(tfc, "IAMF Submix", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
2253  print_int("nb_elements", submix->nb_elements);
2254  print_int("nb_layouts", submix->nb_layouts);
2255  print_q("default_mix_gain", submix->default_mix_gain, '/');
2256  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_PIECES);
2257  for (int i = 0; i < submix->nb_elements; i++) {
2258  const AVIAMFSubmixElement *element = submix->elements[i];
2259  avtext_print_section_header(tfc, "IAMF Submix Element", SECTION_ID_STREAM_GROUP_PIECE);
2260  print_int("stream_id", element->audio_element_id);
2261  print_q("default_mix_gain", element->default_mix_gain, '/');
2262  print_int("headphones_rendering_mode", element->headphones_rendering_mode);
2263  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_SUBPIECES);
2264  if (element->annotations) {
2265  const AVDictionaryEntry *annotation = NULL;
2266  avtext_print_section_header(tfc, "IAMF Annotations", SECTION_ID_STREAM_GROUP_SUBPIECE);
2267  while (annotation = av_dict_iterate(element->annotations, annotation))
2268  print_str(annotation->key, annotation->value);
2269  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBPIECE
2270  }
2271  if (element->element_mix_config)
2272  print_iamf_param_definition(tfc, "element_mix_config", element->element_mix_config,
2273  SECTION_ID_STREAM_GROUP_SUBPIECE);
2274  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBPIECES
2275  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_PIECE
2276  }
2277  if (submix->output_mix_config)
2278  print_iamf_param_definition(tfc, "output_mix_config", submix->output_mix_config,
2279  SECTION_ID_STREAM_GROUP_PIECE);
2280  for (int i = 0; i < submix->nb_layouts; i++) {
2281  const AVIAMFSubmixLayout *layout = submix->layouts[i];
2282  char val_str[128];
2283  avtext_print_section_header(tfc, "IAMF Submix Layout", SECTION_ID_STREAM_GROUP_PIECE);
2284  av_channel_layout_describe(&layout->sound_system, val_str, sizeof(val_str));
2285  print_str("sound_system", val_str);
2286  print_q("integrated_loudness", layout->integrated_loudness, '/');
2287  print_q("digital_peak", layout->digital_peak, '/');
2288  print_q("true_peak", layout->true_peak, '/');
2289  print_q("dialogue_anchored_loudness", layout->dialogue_anchored_loudness, '/');
2290  print_q("album_anchored_loudness", layout->album_anchored_loudness, '/');
2291  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_PIECE
2292  }
2293  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_PIECES
2294  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
2295 }
2296 
2297 static void print_iamf_mix_presentation_params(AVTextFormatContext *tfc, const AVStreamGroup *stg,
2298  const AVIAMFMixPresentation *mix_presentation)
2299 {
2300  avtext_print_section_header(tfc, stg, SECTION_ID_STREAM_GROUP_COMPONENT);
2301  print_int("nb_submixes", mix_presentation->nb_submixes);
2302  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_SUBCOMPONENTS);
2303  if (mix_presentation->annotations) {
2304  const AVDictionaryEntry *annotation = NULL;
2305  avtext_print_section_header(tfc, "IAMF Annotations", SECTION_ID_STREAM_GROUP_SUBCOMPONENT);
2306  while (annotation = av_dict_iterate(mix_presentation->annotations, annotation))
2307  print_str(annotation->key, annotation->value);
2308  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBCOMPONENT
2309  }
2310  for (int i = 0; i < mix_presentation->nb_submixes; i++)
2311  print_iamf_submix_params(tfc, mix_presentation->submixes[i]);
2312  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
2313  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_COMPONENT
2314 }
2315 
2316 static void print_stream_group_params(AVTextFormatContext *tfc, AVStreamGroup *stg)
2317 {
2318  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_COMPONENTS);
2319  if (stg->type == AV_STREAM_GROUP_PARAMS_TILE_GRID)
2320  print_tile_grid_params(tfc, stg, stg->params.tile_grid);
2321  else if (stg->type == AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT)
2322  print_iamf_audio_element_params(tfc, stg, stg->params.iamf_audio_element);
2323  else if (stg->type == AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION)
2324  print_iamf_mix_presentation_params(tfc, stg, stg->params.iamf_mix_presentation);
2325  avtext_print_section_footer(tfc); // SECTION_ID_STREAM_GROUP_COMPONENTS
2326 }
2327 
2328 static int show_stream_group(AVTextFormatContext *tfc, InputFile *ifile, AVStreamGroup *stg)
2329 {
2330  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2331  AVBPrint pbuf;
2332  int i, ret = 0;
2333 
2334  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2335  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP);
2336  print_int("index", stg->index);
2337  if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%"PRIx64, stg->id);
2338  else print_str_opt("id", "N/A");
2339  print_int("nb_streams", stg->nb_streams);
2340  if (stg->type != AV_STREAM_GROUP_PARAMS_NONE)
2341  print_str("type", av_x_if_null(avformat_stream_group_name(stg->type), "unknown"));
2342  else
2343  print_str_opt("type", "unknown");
2344  if (do_show_stream_group_components)
2345  print_stream_group_params(tfc, stg);
2346 
2347  /* Print disposition information */
2348  if (do_show_stream_group_disposition)
2349  print_dispositions(tfc, stg->disposition, SECTION_ID_STREAM_GROUP_DISPOSITION);
2350 
2351  if (do_show_stream_group_tags)
2352  ret = show_tags(tfc, stg->metadata, SECTION_ID_STREAM_GROUP_TAGS);
2353  if (ret < 0)
2354  goto end;
2355 
2356  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUP_STREAMS);
2357  for (i = 0; i < stg->nb_streams; i++) {
2358  if (selected_streams[stg->streams[i]->index]) {
2359  ret = show_stream(tfc, fmt_ctx, stg->streams[i]->index, &ifile->streams[stg->streams[i]->index], IN_STREAM_GROUP);
2360  if (ret < 0)
2361  break;
2362  }
2363  }
2364  avtext_print_section_footer(tfc);
2365 
2366 end:
2367  av_bprint_finalize(&pbuf, NULL);
2368  avtext_print_section_footer(tfc);
2369  return ret;
2370 }
2371 
2372 static int show_stream_groups(AVTextFormatContext *tfc, InputFile *ifile)
2373 {
2374  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2375  int i, ret = 0;
2376 
2377  avtext_print_section_header(tfc, NULL, SECTION_ID_STREAM_GROUPS);
2378  for (i = 0; i < fmt_ctx->nb_stream_groups; i++) {
2379  AVStreamGroup *stg = fmt_ctx->stream_groups[i];
2380 
2381  ret = show_stream_group(tfc, ifile, stg);
2382  if (ret < 0)
2383  break;
2384  }
2385  avtext_print_section_footer(tfc);
2386  return ret;
2387 }
2388 
2389 static int show_chapters(AVTextFormatContext *tfc, InputFile *ifile)
2390 {
2391  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2392  int i, ret = 0;
2393 
2394  avtext_print_section_header(tfc, NULL, SECTION_ID_CHAPTERS);
2395  for (i = 0; i < fmt_ctx->nb_chapters; i++) {
2396  AVChapter *chapter = fmt_ctx->chapters[i];
2397 
2398  avtext_print_section_header(tfc, NULL, SECTION_ID_CHAPTER);
2399  print_int("id", chapter->id);
2400  print_q ("time_base", chapter->time_base, '/');
2401  print_int("start", chapter->start);
2402  print_time("start_time", chapter->start, &chapter->time_base);
2403  print_int("end", chapter->end);
2404  print_time("end_time", chapter->end, &chapter->time_base);
2405  if (do_show_chapter_tags)
2406  ret = show_tags(tfc, chapter->metadata, SECTION_ID_CHAPTER_TAGS);
2407  avtext_print_section_footer(tfc);
2408  }
2409  avtext_print_section_footer(tfc);
2410 
2411  return ret;
2412 }
2413 
2414 static int show_format(AVTextFormatContext *tfc, InputFile *ifile)
2415 {
2416  AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2417  int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
2418  int ret = 0;
2419 
2420  avtext_print_section_header(tfc, NULL, SECTION_ID_FORMAT);
2421  print_str_validate("filename", fmt_ctx->url);
2422  print_int("nb_streams", fmt_ctx->nb_streams);
2423  print_int("nb_programs", fmt_ctx->nb_programs);
2424  print_int("nb_stream_groups", fmt_ctx->nb_stream_groups);
2425  print_str("format_name", fmt_ctx->iformat->name);
2426  if (!do_bitexact) {
2427  if (fmt_ctx->iformat->long_name) print_str ("format_long_name", fmt_ctx->iformat->long_name);
2428  else print_str_opt("format_long_name", "unknown");
2429  }
2430  print_time("start_time", fmt_ctx->start_time, &AV_TIME_BASE_Q);
2431  print_time("duration", fmt_ctx->duration, &AV_TIME_BASE_Q);
2432  if (size >= 0) print_val ("size", size, unit_byte_str);
2433  else print_str_opt("size", "N/A");
2434  if (fmt_ctx->bit_rate > 0) print_val ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
2435  else print_str_opt("bit_rate", "N/A");
2436  print_int("probe_score", fmt_ctx->probe_score);
2437  if (do_show_format_tags)
2438  ret = show_tags(tfc, fmt_ctx->metadata, SECTION_ID_FORMAT_TAGS);
2439 
2440  avtext_print_section_footer(tfc);
2441  fflush(stdout);
2442  return ret;
2443 }
2444 
2445 static void show_error(AVTextFormatContext *tfc, int err)
2446 {
2447  avtext_print_section_header(tfc, NULL, SECTION_ID_ERROR);
2448  print_int("code", err);
2449  print_str("string", av_err2str(err));
2450  avtext_print_section_footer(tfc);
2451 }
2452 
2453 static int get_decoder_by_name(const char *codec_name, const AVCodec **codec)
2454 {
2455  if (codec_name == NULL)
2456  return 0;
2457 
2458  *codec = avcodec_find_decoder_by_name(codec_name);
2459  if (*codec == NULL) {
2460  av_log(NULL, AV_LOG_ERROR,
2461  "No codec could be found with name '%s'\n", codec_name);
2462  return AVERROR(EINVAL);
2463  }
2464  return 0;
2465 }
2466 
2467 static int set_decoders(AVFormatContext *fmt_ctx)
2468 {
2469  int ret;
2470 
2471 #define GET_DECODER(type_) \
2472  ret = get_decoder_by_name(type_##_codec_name, &fmt_ctx->type_##_codec); \
2473  if (ret < 0) return ret;
2474 
2475  GET_DECODER(audio);
2476  GET_DECODER(data);
2477  GET_DECODER(subtitle);
2478  GET_DECODER(video);
2479  return 0;
2480 }
2481 
2482 static const AVCodec *get_decoder_for_stream(AVFormatContext *fmt_ctx, AVStream *stream)
2483 {
2484  const AVCodec *codec = NULL;
2485  switch (stream->codecpar->codec_type) {
2486  case AVMEDIA_TYPE_VIDEO: codec = fmt_ctx->video_codec; break;
2487  case AVMEDIA_TYPE_AUDIO: codec = fmt_ctx->audio_codec; break;
2488  case AVMEDIA_TYPE_SUBTITLE: codec = fmt_ctx->subtitle_codec; break;
2489  case AVMEDIA_TYPE_DATA: codec = fmt_ctx->data_codec; break;
2490  }
2491 
2492  if (codec != NULL)
2493  return codec;
2494 
2495  if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
2496  av_log(NULL, AV_LOG_WARNING,
2497  "Failed to probe codec for input stream %d\n", stream->index);
2498  return NULL;
2499  }
2500 
2501  codec = avcodec_find_decoder(stream->codecpar->codec_id);
2502  if (codec == NULL) {
2503  av_log(NULL, AV_LOG_WARNING,
2504  "Unsupported codec with id %d for input stream %d\n",
2505  stream->codecpar->codec_id, stream->index);
2506  return NULL;
2507  }
2508 
2509  return codec;
2510 }
2511 
2512 static int open_input_file(InputFile *ifile, const char *filename,
2513  const char *print_filename)
2514 {
2515  int err, i;
2516  AVFormatContext *fmt_ctx = NULL;
2517  const AVDictionaryEntry *t = NULL;
2518  int scan_all_pmts_set = 0;
2519 
2520  fmt_ctx = avformat_alloc_context();
2521  if (!fmt_ctx)
2522  return AVERROR(ENOMEM);
2523 
2524  err = set_decoders(fmt_ctx);
2525  if (err < 0)
2526  return err;
2527  if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2528  av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2529  scan_all_pmts_set = 1;
2530  }
2531  if ((err = avformat_open_input(&fmt_ctx, filename,
2532  iformat, &format_opts)) < 0) {
2533  print_error(filename, err);
2534  return err;
2535  }
2536  if (print_filename) {
2537  av_freep(&fmt_ctx->url);
2538  fmt_ctx->url = av_strdup(print_filename);
2539  }
2540  ifile->fmt_ctx = fmt_ctx;
2541  if (scan_all_pmts_set)
2542  av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2543  while ((t = av_dict_iterate(format_opts, t)))
2544  av_log(NULL, AV_LOG_WARNING, "Option %s skipped - not known to demuxer.\n", t->key);
2545 
2546  if (find_stream_info) {
2547  AVDictionary **opts;
2548  int orig_nb_streams = fmt_ctx->nb_streams;
2549 
2550  err = setup_find_stream_info_opts(fmt_ctx, codec_opts, &opts);
2551  if (err < 0)
2552  return err;
2553 
2554  err = avformat_find_stream_info(fmt_ctx, opts);
2555 
2556  for (i = 0; i < orig_nb_streams; i++)
2557  av_dict_free(&opts[i]);
2558  av_freep(&opts);
2559 
2560  if (err < 0) {
2561  print_error(filename, err);
2562  return err;
2563  }
2564  }
2565 
2566  av_dump_format(fmt_ctx, 0, filename, 0);
2567 
2568  ifile->streams = av_calloc(fmt_ctx->nb_streams, sizeof(*ifile->streams));
2569  if (!ifile->streams)
2570  exit(1);
2571  ifile->nb_streams = fmt_ctx->nb_streams;
2572 
2573  /* bind a decoder to each input stream */
2574  for (i = 0; i < fmt_ctx->nb_streams; i++) {
2575  InputStream *ist = &ifile->streams[i];
2576  AVStream *stream = fmt_ctx->streams[i];
2577  const AVCodec *codec;
2578 
2579  ist->st = stream;
2580 
2581  codec = get_decoder_for_stream(fmt_ctx, stream);
2582  if (!codec)
2583  continue;
2584 
2585  {
2586  AVDictionary *opts;
2587 
2588  err = filter_codec_opts(codec_opts, stream->codecpar->codec_id,
2589  fmt_ctx, stream, codec, &opts, NULL);
2590  if (err < 0)
2591  exit(1);
2592 
2593  ist->dec_ctx = avcodec_alloc_context3(codec);
2594  if (!ist->dec_ctx)
2595  exit(1);
2596 
2597  err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
2598  if (err < 0)
2599  exit(1);
2600 
2601  if (do_show_log) {
2602  // For logging it is needed to disable at least frame threads as otherwise
2603  // the log information would need to be reordered and matches up to contexts and frames
2604  // That is in fact possible but not trivial
2605  av_dict_set(&codec_opts, "threads", "1", 0);
2606  }
2607 
2608  av_dict_set(&opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
2609 
2610  ist->dec_ctx->pkt_timebase = stream->time_base;
2611 
2612  if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
2613  av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
2614  stream->index);
2615  exit(1);
2616  }
2617 
2618  if ((t = av_dict_iterate(opts, NULL))) {
2619  av_log(NULL, AV_LOG_ERROR, "Option %s for input stream %d not found\n",
2620  t->key, stream->index);
2621  return AVERROR_OPTION_NOT_FOUND;
2622  }
2623  }
2624  }
2625 
2626  ifile->fmt_ctx = fmt_ctx;
2627  return 0;
2628 }
2629 
2630 static void close_input_file(InputFile *ifile)
2631 {
2632  int i;
2633 
2634  /* close decoder for each stream */
2635  for (i = 0; i < ifile->nb_streams; i++)
2636  avcodec_free_context(&ifile->streams[i].dec_ctx);
2637 
2638  av_freep(&ifile->streams);
2639  ifile->nb_streams = 0;
2640 
2641  avformat_close_input(&ifile->fmt_ctx);
2642 }
2643 
2644 static int probe_file(AVTextFormatContext *tfc, const char *filename,
2645  const char *print_filename)
2646 {
2647  InputFile ifile = { 0 };
2648  int ret, i;
2649  int section_id;
2650 
2651  do_analyze_frames = do_analyze_frames && do_show_streams;
2652  do_read_frames = do_show_frames || do_count_frames || do_analyze_frames;
2653  do_read_packets = do_show_packets || do_count_packets;
2654 
2655  ret = open_input_file(&ifile, filename, print_filename);
2656  if (ret < 0)
2657  goto end;
2658 
2659 #define CHECK_END if (ret < 0) goto end
2660 
2661  nb_streams = ifile.fmt_ctx->nb_streams;
2662  REALLOCZ_ARRAY_STREAM(nb_streams_frames,0,ifile.fmt_ctx->nb_streams);
2663  REALLOCZ_ARRAY_STREAM(nb_streams_packets,0,ifile.fmt_ctx->nb_streams);
2664  REALLOCZ_ARRAY_STREAM(selected_streams,0,ifile.fmt_ctx->nb_streams);
2665  REALLOCZ_ARRAY_STREAM(streams_with_closed_captions,0,ifile.fmt_ctx->nb_streams);
2666  REALLOCZ_ARRAY_STREAM(streams_with_film_grain,0,ifile.fmt_ctx->nb_streams);
2667 
2668  for (i = 0; i < ifile.fmt_ctx->nb_streams; i++) {
2669  if (stream_specifier) {
2670  ret = avformat_match_stream_specifier(ifile.fmt_ctx,
2671  ifile.fmt_ctx->streams[i],
2672  stream_specifier);
2673  CHECK_END;
2674  else
2675  selected_streams[i] = ret;
2676  ret = 0;
2677  } else {
2678  selected_streams[i] = 1;
2679  }
2680  if (!selected_streams[i])
2681  ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
2682  }
2683 
2684  if (do_read_frames || do_read_packets) {
2685  if (do_show_frames && do_show_packets &&
2686  tfc->formatter->flags & AV_TEXTFORMAT_FLAG_SUPPORTS_MIXED_ARRAY_CONTENT)
2687  section_id = SECTION_ID_PACKETS_AND_FRAMES;
2688  else if (do_show_packets && !do_show_frames)
2689  section_id = SECTION_ID_PACKETS;
2690  else // (!do_show_packets && do_show_frames)
2691  section_id = SECTION_ID_FRAMES;
2692  if (do_show_frames || do_show_packets)
2693  avtext_print_section_header(tfc, NULL, section_id);
2694  ret = read_packets(tfc, &ifile);
2695  if (do_show_frames || do_show_packets)
2696  avtext_print_section_footer(tfc);
2697  CHECK_END;
2698  }
2699 
2700  if (do_show_programs) {
2701  ret = show_programs(tfc, &ifile);
2702  CHECK_END;
2703  }
2704 
2705  if (do_show_stream_groups) {
2706  ret = show_stream_groups(tfc, &ifile);
2707  CHECK_END;
2708  }
2709 
2710  if (do_show_streams) {
2711  ret = show_streams(tfc, &ifile);
2712  CHECK_END;
2713  }
2714  if (do_show_chapters) {
2715  ret = show_chapters(tfc, &ifile);
2716  CHECK_END;
2717  }
2718  if (do_show_format) {
2719  ret = show_format(tfc, &ifile);
2720  CHECK_END;
2721  }
2722 
2723 end:
2724  if (ifile.fmt_ctx)
2725  close_input_file(&ifile);
2726  av_freep(&nb_streams_frames);
2727  av_freep(&nb_streams_packets);
2728  av_freep(&selected_streams);
2729  av_freep(&streams_with_closed_captions);
2730  av_freep(&streams_with_film_grain);
2731  av_freep(&audio_codec_name);
2732  av_freep(&data_codec_name);
2733  av_freep(&subtitle_codec_name);
2734  av_freep(&video_codec_name);
2735 
2736  return ret;
2737 }
2738 
2739 static void show_usage(void)
2740 {
2741  av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
2742  av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] INPUT_FILE\n", program_name);
2743  av_log(NULL, AV_LOG_INFO, "\n");
2744 }
2745 
2746 static void ffprobe_show_program_version(AVTextFormatContext *tfc)
2747 {
2748  AVBPrint pbuf;
2749  av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2750 
2751  avtext_print_section_header(tfc, NULL, SECTION_ID_PROGRAM_VERSION);
2752  print_str("version", FFMPEG_VERSION);
2753  print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
2754  program_birth_year, CONFIG_THIS_YEAR);
2755  print_str("compiler_ident", CC_IDENT);
2756  print_str("configuration", FFMPEG_CONFIGURATION);
2757  avtext_print_section_footer(tfc);
2758 
2759  av_bprint_finalize(&pbuf, NULL);
2760 }
2761 
2762 #define SHOW_LIB_VERSION(libname, LIBNAME) \
2763  do { \
2764  if (CONFIG_##LIBNAME) { \
2765  unsigned int version = libname##_version(); \
2766  avtext_print_section_header(tfc, NULL, SECTION_ID_LIBRARY_VERSION); \
2767  print_str("name", "lib" #libname); \
2768  print_int("major", LIB##LIBNAME##_VERSION_MAJOR); \
2769  print_int("minor", LIB##LIBNAME##_VERSION_MINOR); \
2770  print_int("micro", LIB##LIBNAME##_VERSION_MICRO); \
2771  print_int("version", version); \
2772  print_str("ident", LIB##LIBNAME##_IDENT); \
2773  avtext_print_section_footer(tfc); \
2774  } \
2775  } while (0)
2776 
2777 static void ffprobe_show_library_versions(AVTextFormatContext *tfc)
2778 {
2779  avtext_print_section_header(tfc, NULL, SECTION_ID_LIBRARY_VERSIONS);
2780  SHOW_LIB_VERSION(avutil, AVUTIL);
2781  SHOW_LIB_VERSION(avcodec, AVCODEC);
2782  SHOW_LIB_VERSION(avformat, AVFORMAT);
2783  SHOW_LIB_VERSION(avdevice, AVDEVICE);
2784  SHOW_LIB_VERSION(avfilter, AVFILTER);
2785  SHOW_LIB_VERSION(swscale, SWSCALE);
2786  SHOW_LIB_VERSION(swresample, SWRESAMPLE);
2787  avtext_print_section_footer(tfc);
2788 }
2789 
2790 #define PRINT_PIX_FMT_FLAG(flagname, name) \
2791  do { \
2792  print_int(name, !!(pixdesc->flags & AV_PIX_FMT_FLAG_##flagname)); \
2793  } while (0)
2794 
2795 static void ffprobe_show_pixel_formats(AVTextFormatContext *tfc)
2796 {
2797  const AVPixFmtDescriptor *pixdesc = NULL;
2798  int i, n;
2799 
2800  avtext_print_section_header(tfc, NULL, SECTION_ID_PIXEL_FORMATS);
2801  while (pixdesc = av_pix_fmt_desc_next(pixdesc)) {
2802  avtext_print_section_header(tfc, NULL, SECTION_ID_PIXEL_FORMAT);
2803  print_str("name", pixdesc->name);
2804  print_int("nb_components", pixdesc->nb_components);
2805  if ((pixdesc->nb_components >= 3) && !(pixdesc->flags & AV_PIX_FMT_FLAG_RGB)) {
2806  print_int ("log2_chroma_w", pixdesc->log2_chroma_w);
2807  print_int ("log2_chroma_h", pixdesc->log2_chroma_h);
2808  } else {
2809  print_str_opt("log2_chroma_w", "N/A");
2810  print_str_opt("log2_chroma_h", "N/A");
2811  }
2812  n = av_get_bits_per_pixel(pixdesc);
2813  if (n) print_int ("bits_per_pixel", n);
2814  else print_str_opt("bits_per_pixel", "N/A");
2815  if (do_show_pixel_format_flags) {
2816  avtext_print_section_header(tfc, NULL, SECTION_ID_PIXEL_FORMAT_FLAGS);
2817  PRINT_PIX_FMT_FLAG(BE, "big_endian");
2818  PRINT_PIX_FMT_FLAG(PAL, "palette");
2819  PRINT_PIX_FMT_FLAG(BITSTREAM, "bitstream");
2820  PRINT_PIX_FMT_FLAG(HWACCEL, "hwaccel");
2821  PRINT_PIX_FMT_FLAG(PLANAR, "planar");
2822  PRINT_PIX_FMT_FLAG(RGB, "rgb");
2823  PRINT_PIX_FMT_FLAG(ALPHA, "alpha");
2824  avtext_print_section_footer(tfc);
2825  }
2826  if (do_show_pixel_format_components && (pixdesc->nb_components > 0)) {
2827  avtext_print_section_header(tfc, NULL, SECTION_ID_PIXEL_FORMAT_COMPONENTS);
2828  for (i = 0; i < pixdesc->nb_components; i++) {
2829  avtext_print_section_header(tfc, NULL, SECTION_ID_PIXEL_FORMAT_COMPONENT);
2830  print_int("index", i + 1);
2831  print_int("bit_depth", pixdesc->comp[i].depth);
2832  avtext_print_section_footer(tfc);
2833  }
2834  avtext_print_section_footer(tfc);
2835  }
2836  avtext_print_section_footer(tfc);
2837  }
2838  avtext_print_section_footer(tfc);
2839 }
2840 
2841 static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
2842 {
2843  if (!av_strcasecmp(arg, "always")) show_optional_fields = SHOW_OPTIONAL_FIELDS_ALWAYS;
2844  else if (!av_strcasecmp(arg, "never")) show_optional_fields = SHOW_OPTIONAL_FIELDS_NEVER;
2845  else if (!av_strcasecmp(arg, "auto")) show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
2846 
2847  if (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO && av_strcasecmp(arg, "auto")) {
2848  double num;
2849  int ret = parse_number("show_optional_fields", arg, OPT_TYPE_INT,
2850  SHOW_OPTIONAL_FIELDS_AUTO, SHOW_OPTIONAL_FIELDS_ALWAYS, &num);
2851  if (ret < 0)
2852  return ret;
2853  show_optional_fields = num;
2854  }
2855  return 0;
2856 }
2857 
2858 static int opt_format(void *optctx, const char *opt, const char *arg)
2859 {
2860  iformat = av_find_input_format(arg);
2861  if (!iformat) {
2862  av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
2863  return AVERROR(EINVAL);
2864  }
2865  return 0;
2866 }
2867 
2868 static inline void mark_section_show_entries(SectionID section_id,
2869  int show_all_entries, AVDictionary *entries)
2870 {
2871  EntrySelection *selection = &selected_entries[section_id];
2872 
2873  selection->show_all_entries = show_all_entries;
2874  if (show_all_entries) {
2875  const AVTextFormatSection *section = &sections[section_id];
2876  for (const int *id = section->children_ids; *id != -1; id++)
2877  mark_section_show_entries(*id, show_all_entries, entries);
2878  } else {
2879  av_dict_copy(&selection->entries_to_show, entries, 0);
2880  }
2881 }
2882 
2883 static int match_section(const char *section_name,
2884  int show_all_entries, AVDictionary *entries)
2885 {
2886  int i, ret = 0;
2887 
2888  for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) {
2889  const struct AVTextFormatSection *section = &sections[i];
2890  if (!strcmp(section_name, section->name) ||
2891  (section->unique_name && !strcmp(section_name, section->unique_name))) {
2892  av_log(NULL, AV_LOG_DEBUG,
2893  "'%s' matches section with unique name '%s'\n", section_name,
2894  (char *)av_x_if_null(section->unique_name, section->name));
2895  ret++;
2896  mark_section_show_entries(section->id, show_all_entries, entries);
2897  }
2898  }
2899  return ret;
2900 }
2901 
2902 static int opt_show_entries(void *optctx, const char *opt, const char *arg)
2903 {
2904  const char *p = arg;
2905  int ret = 0;
2906 
2907  while (*p) {
2908  AVDictionary *entries = NULL;
2909  char *section_name = av_get_token(&p, "=:");
2910  int show_all_entries = 0;
2911 
2912  if (!section_name) {
2913  av_log(NULL, AV_LOG_ERROR,
2914  "Missing section name for option '%s'\n", opt);
2915  return AVERROR(EINVAL);
2916  }
2917 
2918  if (*p == '=') {
2919  p++;
2920  while (*p && *p != ':') {
2921  char *entry = av_get_token(&p, ",:");
2922  if (!entry)
2923  break;
2924  av_log(NULL, AV_LOG_VERBOSE,
2925  "Adding '%s' to the entries to show in section '%s'\n",
2926  entry, section_name);
2927  av_dict_set(&entries, entry, "", AV_DICT_DONT_STRDUP_KEY);
2928  if (*p == ',')
2929  p++;
2930  }
2931  } else {
2932  show_all_entries = 1;
2933  }
2934 
2935  ret = match_section(section_name, show_all_entries, entries);
2936  if (ret == 0) {
2937  av_log(NULL, AV_LOG_ERROR, "No match for section '%s'\n", section_name);
2938  ret = AVERROR(EINVAL);
2939  }
2940  av_dict_free(&entries);
2941  av_free(section_name);
2942 
2943  if (ret <= 0)
2944  break;
2945  if (*p)
2946  p++;
2947  }
2948 
2949  return ret;
2950 }
2951 
2952 static int opt_input_file(void *optctx, const char *arg)
2953 {
2954  if (input_filename) {
2955  av_log(NULL, AV_LOG_ERROR,
2956  "Argument '%s' provided as input filename, but '%s' was already specified.\n",
2957  arg, input_filename);
2958  return AVERROR(EINVAL);
2959  }
2960  if (!strcmp(arg, "-"))
2961  arg = "fd:";
2962  input_filename = av_strdup(arg);
2963  if (!input_filename)
2964  return AVERROR(ENOMEM);
2965 
2966  return 0;
2967 }
2968 
2969 static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
2970 {
2971  opt_input_file(optctx, arg);
2972  return 0;
2973 }
2974 
2975 static int opt_output_file_o(void *optctx, const char *opt, const char *arg)
2976 {
2977  if (output_filename) {
2978  av_log(NULL, AV_LOG_ERROR,
2979  "Argument '%s' provided as output filename, but '%s' was already specified.\n",
2980  arg, output_filename);
2981  return AVERROR(EINVAL);
2982  }
2983  if (!strcmp(arg, "-"))
2984  arg = "fd:";
2985  output_filename = av_strdup(arg);
2986  if (!output_filename)
2987  return AVERROR(ENOMEM);
2988 
2989  return 0;
2990 }
2991 
2992 static int opt_print_filename(void *optctx, const char *opt, const char *arg)
2993 {
2994  av_freep(&print_input_filename);
2995  print_input_filename = av_strdup(arg);
2996  return print_input_filename ? 0 : AVERROR(ENOMEM);
2997 }
2998 
2999 void show_help_default(const char *opt, const char *arg)
3000 {
3001  av_log_set_callback(log_callback_help);
3002  show_usage();
3003  show_help_options(options, "Main options:", 0, 0);
3004  printf("\n");
3005 
3006  show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3007  show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3008 }
3009 
3010 /**
3011  * Parse interval specification, according to the format:
3012  * INTERVAL ::= [START|+START_OFFSET][%[END|+END_OFFSET]]
3013  * INTERVALS ::= INTERVAL[,INTERVALS]
3014 */
3015 static int parse_read_interval(const char *interval_spec,
3016  ReadInterval *interval)
3017 {
3018  int ret = 0;
3019  char *next, *p, *spec = av_strdup(interval_spec);
3020  if (!spec)
3021  return AVERROR(ENOMEM);
3022 
3023  if (!*spec) {
3024  av_log(NULL, AV_LOG_ERROR, "Invalid empty interval specification\n");
3025  ret = AVERROR(EINVAL);
3026  goto end;
3027  }
3028 
3029  p = spec;
3030  next = strchr(spec, '%');
3031  if (next)
3032  *next++ = 0;
3033 
3034  /* parse first part */
3035  if (*p) {
3036  interval->has_start = 1;
3037 
3038  if (*p == '+') {
3039  interval->start_is_offset = 1;
3040  p++;
3041  } else {
3042  interval->start_is_offset = 0;
3043  }
3044 
3045  ret = av_parse_time(&interval->start, p, 1);
3046  if (ret < 0) {
3047  av_log(NULL, AV_LOG_ERROR, "Invalid interval start specification '%s'\n", p);
3048  goto end;
3049  }
3050  } else {
3051  interval->has_start = 0;
3052  }
3053 
3054  /* parse second part */
3055  p = next;
3056  if (p && *p) {
3057  int64_t us;
3058  interval->has_end = 1;
3059 
3060  if (*p == '+') {
3061  interval->end_is_offset = 1;
3062  p++;
3063  } else {
3064  interval->end_is_offset = 0;
3065  }
3066 
3067  if (interval->end_is_offset && *p == '#') {
3068  long long int lli;
3069  char *tail;
3070  interval->duration_frames = 1;
3071  p++;
3072  lli = strtoll(p, &tail, 10);
3073  if (*tail || lli < 0) {
3074  av_log(NULL, AV_LOG_ERROR,
3075  "Invalid or negative value '%s' for duration number of frames\n", p);
3076  goto end;
3077  }
3078  interval->end = lli;
3079  } else {
3080  interval->duration_frames = 0;
3081  ret = av_parse_time(&us, p, 1);
3082  if (ret < 0) {
3083  av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
3084  goto end;
3085  }
3086  interval->end = us;
3087  }
3088  } else {
3089  interval->has_end = 0;
3090  }
3091 
3092 end:
3093  av_free(spec);
3094  return ret;
3095 }
3096 
3097 static int parse_read_intervals(const char *intervals_spec)
3098 {
3099  int ret, n, i;
3100  char *p, *spec = av_strdup(intervals_spec);
3101  if (!spec)
3102  return AVERROR(ENOMEM);
3103 
3104  /* preparse specification, get number of intervals */
3105  for (n = 0, p = spec; *p; p++)
3106  if (*p == ',')
3107  n++;
3108  n++;
3109 
3110  read_intervals = av_malloc_array(n, sizeof(*read_intervals));
3111  if (!read_intervals) {
3112  ret = AVERROR(ENOMEM);
3113  goto end;
3114  }
3115  read_intervals_nb = n;
3116 
3117  /* parse intervals */
3118  p = spec;
3119  for (i = 0; p; i++) {
3120  char *next;
3121 
3122  av_assert0(i < read_intervals_nb);
3123  next = strchr(p, ',');
3124  if (next)
3125  *next++ = 0;
3126 
3127  read_intervals[i].id = i;
3128  ret = parse_read_interval(p, &read_intervals[i]);
3129  if (ret < 0) {
3130  av_log(NULL, AV_LOG_ERROR, "Error parsing read interval #%d '%s'\n",
3131  i, p);
3132  goto end;
3133  }
3134  av_log(NULL, AV_LOG_VERBOSE, "Parsed log interval ");
3135  log_read_interval(&read_intervals[i], NULL, AV_LOG_VERBOSE);
3136  p = next;
3137  }
3138  av_assert0(i == read_intervals_nb);
3139 
3140 end:
3141  av_free(spec);
3142  return ret;
3143 }
3144 
3145 static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
3146 {
3147  return parse_read_intervals(arg);
3148 }
3149 
3150 static int opt_pretty(void *optctx, const char *opt, const char *arg)
3151 {
3152  show_value_unit = 1;
3153  use_value_prefix = 1;
3154  use_byte_value_binary_prefix = 1;
3155  use_value_sexagesimal_format = 1;
3156  return 0;
3157 }
3158 
3159 static void print_section(SectionID id, int level)
3160 {
3161  const int *pid;
3162  const struct AVTextFormatSection *section = &sections[id];
3163  printf("%c%c%c%c",
3164  section->flags & AV_TEXTFORMAT_SECTION_FLAG_IS_WRAPPER ? 'W' : '.',
3165  section->flags & AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY ? 'A' : '.',
3166  section->flags & AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS ? 'V' : '.',
3167  section->flags & AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE ? 'T' : '.');
3168  printf("%*c %s", level * 4, ' ', section->name);
3169  if (section->unique_name)
3170  printf("/%s", section->unique_name);
3171  printf("\n");
3172 
3173  for (pid = section->children_ids; *pid != -1; pid++)
3174  print_section(*pid, level+1);
3175 }
3176 
3177 static int opt_sections(void *optctx, const char *opt, const char *arg)
3178 {
3179  printf("Sections:\n"
3180  "W... = Section is a wrapper (contains other sections, no local entries)\n"
3181  ".A.. = Section contains an array of elements of the same type\n"
3182  "..V. = Section may contain a variable number of fields with variable keys\n"
3183  "...T = Section contain a unique type\n"
3184  "FLAGS NAME/UNIQUE_NAME\n"
3185  "----\n");
3186  print_section(SECTION_ID_ROOT, 0);
3187  return 0;
3188 }
3189 
3190 static int opt_codec(void *optctx, const char *opt, const char *arg)
3191 {
3192  const char *spec = strchr(opt, ':');
3193  const char **name;
3194  if (!spec) {
3195  av_log(NULL, AV_LOG_ERROR,
3196  "No media specifier was specified for '%s' in option '%s'. Use -%s:<media_spec> "
3197  "where <media_spec> can be one of: 'a' (audio), 'v' (video), 's' (subtitle), 'd' (data)\n",
3198  arg, opt, opt);
3199  return AVERROR(EINVAL);
3200  }
3201  spec++;
3202 
3203  switch (spec[0]) {
3204  case 'a' : name = &audio_codec_name; break;
3205  case 'd' : name = &data_codec_name; break;
3206  case 's' : name = &subtitle_codec_name; break;
3207  case 'v' : name = &video_codec_name; break;
3208  default:
3209  av_log(NULL, AV_LOG_ERROR,
3210  "Invalid media specifier '%s' in option '%s'. "
3211  "Must be one of: 'a' (audio), 'v' (video), 's' (subtitle), 'd' (data)\n", spec, opt);
3212  return AVERROR(EINVAL);
3213  }
3214 
3215  av_freep(name);
3216  *name = av_strdup(arg);
3217  return *name ? 0 : AVERROR(ENOMEM);
3218 }
3219 
3220 static int opt_show_versions(void *optctx, const char *opt, const char *arg)
3221 {
3222  mark_section_show_entries(SECTION_ID_PROGRAM_VERSION, 1, NULL);
3223  mark_section_show_entries(SECTION_ID_LIBRARY_VERSION, 1, NULL);
3224  return 0;
3225 }
3226 
3227 #define DEFINE_OPT_SHOW_SECTION(section, target_section_id) \
3228  static int opt_show_##section(void *optctx, const char *opt, const char *arg) \
3229  { \
3230  mark_section_show_entries(SECTION_ID_##target_section_id, 1, NULL); \
3231  return 0; \
3232  }
3233 
3234 DEFINE_OPT_SHOW_SECTION(chapters, CHAPTERS)
3235 DEFINE_OPT_SHOW_SECTION(error, ERROR)
3236 DEFINE_OPT_SHOW_SECTION(format, FORMAT)
3237 DEFINE_OPT_SHOW_SECTION(frames, FRAMES)
3238 DEFINE_OPT_SHOW_SECTION(library_versions, LIBRARY_VERSIONS)
3239 DEFINE_OPT_SHOW_SECTION(packets, PACKETS)
3240 DEFINE_OPT_SHOW_SECTION(pixel_formats, PIXEL_FORMATS)
3241 DEFINE_OPT_SHOW_SECTION(program_version, PROGRAM_VERSION)
3242 DEFINE_OPT_SHOW_SECTION(streams, STREAMS)
3243 DEFINE_OPT_SHOW_SECTION(programs, PROGRAMS)
3244 DEFINE_OPT_SHOW_SECTION(stream_groups, STREAM_GROUPS)
3245 
3246 static const OptionDef real_options[] = {
3247  CMDUTILS_COMMON_OPTIONS
3248  { "f", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_format}, "force format", "format" },
3249  { "unit", OPT_TYPE_BOOL, 0, {&show_value_unit}, "show unit of the displayed values" },
3250  { "prefix", OPT_TYPE_BOOL, 0, {&use_value_prefix}, "use SI prefixes for the displayed values" },
3251  { "byte_binary_prefix", OPT_TYPE_BOOL, 0, {&use_byte_value_binary_prefix},
3252  "use binary prefixes for byte units" },
3253  { "sexagesimal", OPT_TYPE_BOOL, 0, {&use_value_sexagesimal_format},
3254  "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
3255  { "pretty", OPT_TYPE_FUNC, 0, {.func_arg = opt_pretty},
3256  "prettify the format of displayed values, make it more human readable" },
3257  { "output_format", OPT_TYPE_STRING, 0, { &output_format },
3258  "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
3259  { "print_format", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format (deprecated)" },
3260  { "of", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format", "format" },
3261  { "select_streams", OPT_TYPE_STRING, 0, { &stream_specifier }, "select the specified streams", "stream_specifier" },
3262  { "sections", OPT_TYPE_FUNC, OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
3263  { "data_dump_format", OPT_TYPE_STRING, 0, { &data_dump_format }, "set data dump format (available formats are: xxd, base64)" },
3264  { "show_data", OPT_TYPE_BOOL, 0, { &do_show_data }, "show packets data" },
3265  { "show_data_hash", OPT_TYPE_STRING, 0, { &show_data_hash }, "show packets data hash" },
3266  { "show_error", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_error }, "show probing error" },
3267  { "show_format", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_format }, "show format/container info" },
3268  { "show_frames", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_frames }, "show frames info" },
3269  { "show_entries", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_show_entries},
3270  "show a set of specified entries", "entry_list" },
3271 #if HAVE_THREADS
3272  { "show_log", OPT_TYPE_INT, 0, { &do_show_log }, "show log" },
3273 #endif
3274  { "show_packets", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_packets }, "show packets info" },
3275  { "show_programs", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_programs }, "show programs info" },
3276  { "show_stream_groups", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_stream_groups }, "show stream groups info" },
3277  { "show_streams", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_streams }, "show streams info" },
3278  { "show_chapters", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_chapters }, "show chapters info" },
3279  { "count_frames", OPT_TYPE_BOOL, 0, { &do_count_frames }, "count the number of frames per stream" },
3280  { "count_packets", OPT_TYPE_BOOL, 0, { &do_count_packets }, "count the number of packets per stream" },
3281  { "show_program_version", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" },
3282  { "show_library_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_library_versions }, "show library versions" },
3283  { "show_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_versions }, "show program and library versions" },
3284  { "show_pixel_formats", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" },
3285  { "show_optional_fields", OPT_TYPE_FUNC, OPT_FUNC_ARG, { .func_arg = &opt_show_optional_fields }, "show optional fields" },
3286  { "show_private_data", OPT_TYPE_BOOL, 0, { &show_private_data }, "show private data" },
3287  { "private", OPT_TYPE_BOOL, 0, { &show_private_data }, "same as show_private_data" },
3288  { "analyze_frames", OPT_TYPE_BOOL, 0, { &do_analyze_frames }, "analyze frames to provide additional stream-level information" },
3289  { "bitexact", OPT_TYPE_BOOL, 0, {&do_bitexact}, "force bitexact output" },
3290  { "read_intervals", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
3291  { "i", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
3292  { "o", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_output_file_o}, "write to specified output", "output_file"},
3293  { "print_filename", OPT_TYPE_FUNC, OPT_FUNC_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"},
3294  { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3295  "read and decode the streams to fill missing information with heuristics" },
3296  { "c", OPT_TYPE_FUNC, OPT_FUNC_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3297  { "codec", OPT_TYPE_FUNC, OPT_FUNC_ARG, { .func_arg = opt_codec}, "alias for -c (force decoder)", "decoder_name" },
3298  { NULL, },
3299 };
3300 
3301 static inline int check_section_show_entries(int section_id)
3302 {
3303  const EntrySelection *selection = &selected_entries[section_id];
3304 
3305  if (selection->show_all_entries || selection->entries_to_show)
3306  return 1;
3307 
3308  const AVTextFormatSection *section = &sections[section_id];
3309  for (const int *id = section->children_ids; *id != -1; id++)
3310  if (check_section_show_entries(*id))
3311  return 1;
3312  return 0;
3313 }
3314 
3315 #define SET_DO_SHOW(id, varname) do { \
3316  if (check_section_show_entries(SECTION_ID_##id)) \
3317  do_show_##varname = 1; \
3318  } while (0)
3319 
3320 int main(int argc, char **argv)
3321 {
3322  const AVTextFormatter *f;
3323  AVTextFormatContext *tctx;
3324  AVTextWriterContext *wctx;
3325  char *buf;
3326  char *f_name = NULL, *f_args = NULL;
3327  int ret, input_ret;
3328  AVTextFormatDataDump data_dump_format_id = AV_TEXTFORMAT_DATADUMP_XXD;
3329 
3330  init_dynload();
3331 
3332  setvbuf(stderr, NULL, _IONBF, 0); /* win32 runtime needs this */
3333 
3334  av_log_set_flags(AV_LOG_SKIP_REPEATED);
3335 
3336  options = real_options;
3337  parse_loglevel(argc, argv, options);
3338  avformat_network_init();
3339 #if CONFIG_AVDEVICE
3340  avdevice_register_all();
3341 #endif
3342 
3343  show_banner(argc, argv, options);
3344  ret = parse_options(NULL, argc, argv, options, opt_input_file);
3345  if (ret < 0) {
3346  ret = (ret == AVERROR_EXIT) ? 0 : ret;
3347  goto end;
3348  }
3349 
3350  if (do_show_log)
3351  av_log_set_callback(log_callback);
3352 
3353  /* mark things to show, based on -show_entries */
3354  SET_DO_SHOW(CHAPTERS, chapters);
3355  SET_DO_SHOW(ERROR, error);
3356  SET_DO_SHOW(FORMAT, format);
3357  SET_DO_SHOW(FRAMES, frames);
3358  SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
3359  SET_DO_SHOW(PACKETS, packets);
3360  SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
3361  SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
3362  SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
3363  SET_DO_SHOW(PROGRAM_VERSION, program_version);
3364  SET_DO_SHOW(PROGRAMS, programs);
3365  SET_DO_SHOW(STREAM_GROUP_DISPOSITION, stream_group_disposition);
3366  SET_DO_SHOW(STREAM_GROUPS, stream_groups);
3367  SET_DO_SHOW(STREAM_GROUP_COMPONENTS, stream_group_components);
3368  SET_DO_SHOW(STREAMS, streams);
3369  SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
3370  SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
3371  SET_DO_SHOW(STREAM_GROUP_STREAM_DISPOSITION, stream_disposition);
3372 
3373  SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
3374  SET_DO_SHOW(FORMAT_TAGS, format_tags);
3375  SET_DO_SHOW(FRAME_TAGS, frame_tags);
3376  SET_DO_SHOW(PROGRAM_TAGS, program_tags);
3377  SET_DO_SHOW(STREAM_GROUP_TAGS, stream_group_tags);
3378  SET_DO_SHOW(STREAM_TAGS, stream_tags);
3379  SET_DO_SHOW(PROGRAM_STREAM_TAGS, stream_tags);
3380  SET_DO_SHOW(STREAM_GROUP_STREAM_TAGS, stream_tags);
3381  SET_DO_SHOW(PACKET_TAGS, packet_tags);
3382 
3383  if (do_bitexact && (do_show_program_version || do_show_library_versions)) {
3384  av_log(NULL, AV_LOG_ERROR,
3385  "-bitexact and -show_program_version or -show_library_versions "
3386  "options are incompatible\n");
3387  ret = AVERROR(EINVAL);
3388  goto end;
3389  }
3390 
3391  if (!output_format)
3392  output_format = av_strdup("default");
3393  if (!output_format) {
3394  ret = AVERROR(ENOMEM);
3395  goto end;
3396  }
3397  f_name = av_strtok(output_format, "=", &buf);
3398  if (!f_name) {
3399  av_log(NULL, AV_LOG_ERROR,
3400  "No name specified for the output format\n");
3401  ret = AVERROR(EINVAL);
3402  goto end;
3403  }
3404  f_args = buf;
3405 
3406  f = avtext_get_formatter_by_name(f_name);
3407  if (!f) {
3408  av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", f_name);
3409  ret = AVERROR(EINVAL);
3410  goto end;
3411  }
3412 
3413  if (data_dump_format) {
3414  if (!strcmp(data_dump_format, "xxd")) {
3415  data_dump_format_id = AV_TEXTFORMAT_DATADUMP_XXD;
3416  } else if (!strcmp(data_dump_format, "base64")) {
3417  data_dump_format_id = AV_TEXTFORMAT_DATADUMP_BASE64;
3418  } else {
3419  av_log(NULL, AV_LOG_ERROR, "Unknown data dump format with name '%s'\n", data_dump_format);
3420  ret = AVERROR(EINVAL);
3421  goto end;
3422  }
3423  }
3424 
3425  if (output_filename) {
3426  ret = avtextwriter_create_file(&wctx, output_filename);
3427  } else
3428  ret = avtextwriter_create_stdout(&wctx);
3429 
3430  if (ret < 0)
3431  goto end;
3432 
3433  AVTextFormatOptions tf_options = {
3434  .is_key_selected = is_key_selected_callback,
3435  .show_optional_fields = show_optional_fields,
3436  .show_value_unit = show_value_unit,
3437  .use_value_prefix = use_value_prefix,
3438  .use_byte_value_binary_prefix = use_byte_value_binary_prefix,
3439  .use_value_sexagesimal_format = use_value_sexagesimal_format,
3440  .data_dump_format = data_dump_format_id,
3441  };
3442 
3443  if ((ret = avtext_context_open(&tctx, f, wctx, f_args, sections, FF_ARRAY_ELEMS(sections), tf_options, show_data_hash)) >= 0) {
3444  if (f == &avtextformatter_xml)
3445  tctx->string_validation_utf8_flags |= AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES;
3446 
3447  avtext_print_section_header(tctx, NULL, SECTION_ID_ROOT);
3448 
3449  if (do_show_program_version)
3450  ffprobe_show_program_version(tctx);
3451  if (do_show_library_versions)
3452  ffprobe_show_library_versions(tctx);
3453  if (do_show_pixel_formats)
3454  ffprobe_show_pixel_formats(tctx);
3455 
3456  if (!input_filename &&
3457  ((do_show_format || do_show_programs || do_show_stream_groups || do_show_streams || do_show_chapters || do_show_packets || do_show_error) ||
3458  (!do_show_program_version && !do_show_library_versions && !do_show_pixel_formats))) {
3459  show_usage();
3460  av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
3461  av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
3462  ret = AVERROR(EINVAL);
3463  } else if (input_filename) {
3464  ret = probe_file(tctx, input_filename, print_input_filename);
3465  if (ret < 0 && do_show_error)
3466  show_error(tctx, ret);
3467  }
3468 
3469  input_ret = ret;
3470 
3471  avtext_print_section_footer(tctx);
3472 
3473  ret = avtextwriter_context_close(&wctx);
3474  if (ret < 0)
3475  av_log(NULL, AV_LOG_ERROR, "Writing output failed (closing writer): %s\n", av_err2str(ret));
3476 
3477  ret = avtext_context_close(&tctx);
3478  if (ret < 0)
3479  av_log(NULL, AV_LOG_ERROR, "Writing output failed (closing formatter): %s\n", av_err2str(ret));
3480 
3481  ret = FFMIN(ret, input_ret);
3482  }
3483 
3484 end:
3485  av_freep(&output_format);
3486  av_freep(&output_filename);
3487  av_freep(&input_filename);
3488  av_freep(&print_input_filename);
3489  av_freep(&read_intervals);
3490 
3491  uninit_opts();
3492  for (size_t i = 0; i < FF_ARRAY_ELEMS(selected_entries); ++i)
3493  av_dict_free(&selected_entries[i].entries_to_show);
3494 
3495  avformat_network_deinit();
3496 
3497  return ret < 0;
3498 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
main
int main(int argc, char **argv)
Definition: ffprobe.c:3320
AVSubtitle
Definition: avcodec.h:2094
SECTION_ID_STREAM_SIDE_DATA_LIST
@ SECTION_ID_STREAM_SIDE_DATA_LIST
Definition: ffprobe.c:230
opt_format
static int opt_format(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:2858
AVHDRVividColorTransformParams::maximum_maxrgb
AVRational maximum_maxrgb
Indicates the maximum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:206
clear_log
static void clear_log(int need_lock)
Definition: ffprobe.c:1274
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:2868
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:105
RGB
Definition: cms.c:66
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:432
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:207
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:107
AVCodec
AVCodec.
Definition: codec.h:172
av_pix_fmt_swap_endianness
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
Definition: pixdesc.c:3511
SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST
@ SECTION_ID_STREAM_GROUP_SIDE_DATA_LIST
Definition: ffprobe.c:218
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
AVIAMFSubmix::elements
AVIAMFSubmixElement ** elements
Array of submix elements.
Definition: iamf.h:568
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVIAMFAudioElement::nb_layers
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
Definition: iamf.h:371
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:130
av_mime_codec_str
int av_mime_codec_str(const AVCodecParameters *par, AVRational frame_rate, struct AVBPrint *out)
Make a RFC 4281/6381 like string describing a codec for MIME types.
Definition: codecstring.c:233
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
avtextwriter_create_stdout
int avtextwriter_create_stdout(AVTextWriterContext **pwctx)
Definition: tw_stdout.c:71
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVFormatContext::stream_groups
AVStreamGroup ** stream_groups
A list of all stream groups in the file.
Definition: avformat.h:1350
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:208
do_show_log
static int do_show_log
Definition: ffprobe.c:118
AVStreamGroup::id
int64_t id
Group type-specific group ID.
Definition: avformat.h:1116
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
InputFile::fmt_ctx
AVFormatContext * fmt_ctx
Definition: ffprobe.c:86
dec_ctx
static AVCodecContext * dec_ctx
Definition: decode_filter_audio.c:45
SECTION_ID_STREAM_SIDE_DATA
@ SECTION_ID_STREAM_SIDE_DATA
Definition: ffprobe.c:231
AVIAMFSubmix::layouts
AVIAMFSubmixLayout ** layouts
Array of submix layouts.
Definition: iamf.h:583
do_show_frame_tags
static int do_show_frame_tags
Definition: ffprobe.c:122
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:717
PLANAR
#define PLANAR
Definition: flacdsp.c:42
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1226
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
opt_show_optional_fields
static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:2841
printf
__device__ int printf(const char *,...)
opt.h
FrameData::pkt_pos
int64_t pkt_pos
Definition: ffplay.c:149
read_intervals_nb
static int read_intervals_nb
Definition: ffprobe.c:158
opt_output_file_o
static int opt_output_file_o(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:2975
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:1132
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:476
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:104
ReadInterval::end_is_offset
int end_is_offset
Definition: ffprobe.c:153
EntrySelection::show_all_entries
int show_all_entries
Definition: ffprobe.c:333
LogBuffer::log_message
char * log_message
Definition: ffprobe.c:364
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:666
libm.h
FrameData
Definition: ffmpeg.h:722
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
AVFilmGrainParams::bit_depth_luma
int bit_depth_luma
Intended bit depth, or 0 for unknown/unspecified.
Definition: film_grain_params.h:238
AVStreamGroupTileGrid::offsets
struct AVStreamGroupTileGrid::@446 * offsets
An nb_tiles sized array of offsets in pixels from the topleft edge of the canvas, indicating where ea...
AVHDRVividColorToneMappingParams::base_enable_flag
int base_enable_flag
This flag indicates that transfer the base parameter(for value of 1)
Definition: hdr_dynamic_vivid_metadata.h:88
print_str
#define print_str(k, v)
Definition: ffprobe.c:451
LogBuffer::context_name
char * context_name
Definition: ffprobe.c:362
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
AVHDRPlusColorTransformParams::rotation_angle
uint8_t rotation_angle
The clockwise rotation angle in degree of arc with respect to the positive direction of the x-axis of...
Definition: hdr_dynamic_metadata.h:118
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:79
print_val
#define print_val(k, v, u)
Definition: ffprobe.c:458
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
SECTION_ID_PACKET_SIDE_DATA_LIST
@ SECTION_ID_PACKET_SIDE_DATA_LIST
Definition: ffprobe.c:190
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1363
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVHDRPlusPercentile::percentile
AVRational percentile
The linearized maxRGB value at a specific percentile in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:52
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:206
AVAmbientViewingEnvironment
Ambient viewing environment metadata as defined by H.274.
Definition: ambient_viewing_environment.h:36
SECTION_ID_STREAM_GROUP_SIDE_DATA
@ SECTION_ID_STREAM_GROUP_SIDE_DATA
Definition: ffprobe.c:219
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:396
thread.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
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:1018
AVIAMFAudioElement::layers
AVIAMFLayer ** layers
Definition: iamf.h:362
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:815
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:213
process_frame
static av_always_inline int process_frame(AVTextFormatContext *tfc, InputFile *ifile, AVFrame *frame, const AVPacket *pkt, int *packet_new)
Definition: ffprobe.c:1560
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
matrix
Definition: vc1dsp.c:43
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:650
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:263
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
av_alpha_mode_name
const char * av_alpha_mode_name(enum AVAlphaMode mode)
Definition: pixdesc.c:3921
selected_streams
static int * selected_streams
Definition: ffprobe.c:355
SECTION_ID_PROGRAM_TAGS
@ SECTION_ID_PROGRAM_TAGS
Definition: ffprobe.c:202
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2098
EntrySelection
Definition: ffprobe.c:332
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:208
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse
uint16_t semimajor_axis_external_ellipse
The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:134
AVFilmGrainH274Params::blending_mode_id
int blending_mode_id
Specifies the blending mode used to blend the simulated film grain with the decoded images.
Definition: film_grain_params.h:145
AVIAMFMixPresentation::nb_submixes
unsigned int nb_submixes
Number of submixes in the presentation.
Definition: iamf.h:632
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:191
AVStreamGroup::disposition
int disposition
Stream group disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1174
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
AVHDRVividColorTransformParams::tone_mapping_param_num
int tone_mapping_param_num
The number of tone mapping param.
Definition: hdr_dynamic_vivid_metadata.h:218
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:64
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:247
print_ts
#define print_ts(k, v)
Definition: ffprobe.c:455
opt_input_file_i
static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:2969
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:434
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1331
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:409
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:237
AVHDRVividColorTransformParams::variance_maxrgb
AVRational variance_maxrgb
Indicates the variance brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:199
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:549
SECTION_ID_STREAM_GROUP_COMPONENTS
@ SECTION_ID_STREAM_GROUP_COMPONENTS
Definition: ffprobe.c:208
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:179
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
print_context_light_level
static void print_context_light_level(AVTextFormatContext *tfc, const AVContentLightMetadata *metadata)
Definition: ffprobe.c:540
SECTION_ID_PIXEL_FORMAT_COMPONENTS
@ SECTION_ID_PIXEL_FORMAT_COMPONENTS
Definition: ffprobe.c:195
AVPacket::data
uint8_t * data
Definition: packet.h:588
ReadInterval::duration_frames
int duration_frames
Definition: ffprobe.c:154
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
AVOption
AVOption.
Definition: opt.h:429
b
#define b
Definition: input.c:42
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
SECTION_ID_STREAM
@ SECTION_ID_STREAM
Definition: ffprobe.c:226
SECTION_ID_PIXEL_FORMAT_FLAGS
@ SECTION_ID_PIXEL_FORMAT_FLAGS
Definition: ffprobe.c:193
LogBuffer
Definition: ffprobe.c:361
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:833
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:1025
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1225
data
const char data[16]
Definition: mxf.c:149
AVTextWriterContext
Definition: avtextwriters.h:42
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:3463
avtextformat.h
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
AV_DOVI_NLQ_NONE
@ AV_DOVI_NLQ_NONE
Definition: dovi_meta.h:131
AVTextFormatContext
Definition: avtextformat.h:133
AVFilmGrainParams::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:233
do_show_stream_tags
static int do_show_stream_tags
Definition: ffprobe.c:125
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:120
SECTION_ID_PIXEL_FORMAT
@ SECTION_ID_PIXEL_FORMAT
Definition: ffprobe.c:192
version.h
AVHDRPlusColorTransformParams::tone_mapping_flag
uint8_t tone_mapping_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_metadata.h:189
streams_with_closed_captions
static int * streams_with_closed_captions
Definition: ffprobe.c:356
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
SECTION_ID_PROGRAM_STREAM
@ SECTION_ID_PROGRAM_STREAM
Definition: ffprobe.c:201
category
category
Definition: openal-dec.c:249
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1461
video_codec_name
static const char * video_codec_name
Definition: ffprobe.c:137
SECTION_ID_FORMAT
@ SECTION_ID_FORMAT
Definition: ffprobe.c:169
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
show_subtitle
static void show_subtitle(AVTextFormatContext *tfc, AVSubtitle *sub, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:1382
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:3408
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:606
SECTION_ID_STREAM_GROUP_SUBCOMPONENT
@ SECTION_ID_STREAM_GROUP_SUBCOMPONENT
Definition: ffprobe.c:211
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:3301
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:3159
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:472
AVHDRVivid3SplineParams::th_mode
int th_mode
The mode of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:35
AVHDRPlusColorTransformParams::distribution_maxrgb
AVHDRPlusPercentile distribution_maxrgb[15]
The linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:176
AVDictionary
Definition: dict.c:32
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:636
AVStreamGroupTileGrid::vertical
int vertical
Offset in pixels from the top edge of the canvas where the tile should be placed.
Definition: avformat.h:1000
AVFilmGrainParams::codec
union AVFilmGrainParams::@524 codec
Additional fields may be added both here and in any structure included.
SECTION_ID_STREAM_GROUP_BLOCKS
@ SECTION_ID_STREAM_GROUP_BLOCKS
Definition: ffprobe.c:216
AVDOVIRpuDataHeader::rpu_format
uint16_t rpu_format
Definition: dovi_meta.h:89
avcodec_profile_name
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:439
get_decoder_by_name
static int get_decoder_by_name(const char *codec_name, const AVCodec **codec)
Definition: ffprobe.c:2453
do_show_stream_group_components
static int do_show_stream_group_components
Definition: ffprobe.c:108
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1588
AVDOVIDataMapping::mapping_color_space
uint8_t mapping_color_space
Definition: dovi_meta.h:154
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:345
AVHDRVividColorTransformParams::color_saturation_num
int color_saturation_num
The number of color saturation param.
Definition: hdr_dynamic_vivid_metadata.h:235
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
print_frame_side_data
static void print_frame_side_data(AVTextFormatContext *tfc, const AVFrame *frame, const AVStream *stream)
Definition: ffprobe.c:1405
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:394
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:326
print_dispositions
static void print_dispositions(AVTextFormatContext *tfc, uint32_t disposition, SectionID section_id)
Definition: ffprobe.c:1816
ffprobe_show_pixel_formats
static void ffprobe_show_pixel_formats(AVTextFormatContext *tfc)
Definition: ffprobe.c:2795
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:643
AVFilmGrainParams::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:232
do_show_format_tags
static int do_show_format_tags
Definition: ffprobe.c:121
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:213
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3877
AVTextFormatDataDump
AVTextFormatDataDump
Definition: avtextformat.h:92
hdr_dynamic_vivid_metadata.h
do_show_frames
static int do_show_frames
Definition: ffprobe.c:104
OptionDef
Definition: cmdutils.h:195
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:217
AVInputFormat::long_name
const char * long_name
Descriptive name for the format, meant to be more human-readable than name.
Definition: avformat.h:556
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:662
SECTION_ID_FRAME_TAGS
@ SECTION_ID_FRAME_TAGS
Definition: ffprobe.c:173
print_chroma_location
static void print_chroma_location(AVTextFormatContext *tfc, enum AVChromaLocation chroma_location)
Definition: ffprobe.c:1254
ReadInterval::id
int id
identifier
Definition: ffprobe.c:150
AVTextFormatSection::id
int id
unique id identifying a section
Definition: avtextformat.h:42
ff_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:189
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
print_dynamic_hdr_smpte2094_app5
static void print_dynamic_hdr_smpte2094_app5(AVTextFormatContext *tfc, const AVDynamicHDRSmpte2094App5 *metadata)
Definition: ffprobe.c:808
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:114
AVStereo3D::horizontal_field_of_view
AVRational horizontal_field_of_view
Horizontal field of view, in degrees.
Definition: stereo3d.h:239
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
InputStream
Definition: ffmpeg.h:483
AVTextFormatContext::level
int level
current level, starting from 0
Definition: avtextformat.h:144
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:377
AVPacketSideData::size
size_t size
Definition: packet.h:411
match_section
static int match_section(const char *section_name, int show_all_entries, AVDictionary *entries)
Definition: ffprobe.c:2883
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
AVTextFormatSection::name
const char * name
Definition: avtextformat.h:43
unit_hertz_str
static const char unit_hertz_str[]
Definition: ffprobe.c:348
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
subtitle_codec_name
static const char * subtitle_codec_name
Definition: ffprobe.c:136
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:214
SHOW_OPTIONAL_FIELDS_NEVER
#define SHOW_OPTIONAL_FIELDS_NEVER
Definition: ffprobe.c:140
SECTION_ID_STREAMS
@ SECTION_ID_STREAMS
Definition: ffprobe.c:228
print_color_space
static void print_color_space(AVTextFormatContext *tfc, enum AVColorSpace color_space)
Definition: ffprobe.c:1224
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
show_optional_fields
static int show_optional_fields
Definition: ffprobe.c:142
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3856
SECTION_ID_STREAM_GROUP
@ SECTION_ID_STREAM_GROUP
Definition: ffprobe.c:207
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:3150
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:448
ffprobe_show_program_version
static void ffprobe_show_program_version(AVTextFormatContext *tfc)
Definition: ffprobe.c:2746
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:624
AVHDRVividColorTransformParams::tm_params
AVHDRVividColorToneMappingParams tm_params[2]
The color tone mapping parameters.
Definition: hdr_dynamic_vivid_metadata.h:223
show_format
static int show_format(AVTextFormatContext *tfc, InputFile *ifile)
Definition: ffprobe.c:2414
AV_DOVI_COMPRESSION_EXTENDED
@ AV_DOVI_COMPRESSION_EXTENDED
Definition: dovi_meta.h:71
LogBuffer::log_level
int log_level
Definition: ffprobe.c:363
AVStreamGroupTileGrid
AVStreamGroupTileGrid holds information on how to combine several independent images on a single canv...
Definition: avformat.h:951
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
AV_TEXTFORMAT_SECTION_FLAG_NUMBERING_BY_TYPE
#define AV_TEXTFORMAT_SECTION_FLAG_NUMBERING_BY_TYPE
the items in this array section should be numbered individually by type
Definition: avtextformat.h:50
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
frames
if it could not because there are no more frames
Definition: filter_design.txt:267
timecode.h
AV_TEXTFORMAT_DATADUMP_BASE64
@ AV_TEXTFORMAT_DATADUMP_BASE64
Definition: avtextformat.h:94
AVIAMFSubmixLayout
Submix layout as defined in section 3.7.6 of IAMF.
Definition: iamf.h:517
avformat_stream_group_name
const char * avformat_stream_group_name(enum AVStreamGroupParamsType type)
Definition: avformat.c:260
AVDOVIDecoderConfigurationRecord::dv_md_compression
uint8_t dv_md_compression
Definition: dovi_meta.h:64
AVStreamGroupTileGrid::coded_width
int coded_width
Width of the canvas.
Definition: avformat.h:966
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:697
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
AVChapter
Definition: avformat.h:1222
val
static double val(void *priv, double ch)
Definition: aeval.c:77
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffprobe.c:2999
AVStreamGroupTileGrid::coded_height
int coded_height
Width of the canvas.
Definition: avformat.h:972
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:181
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:615
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
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:803
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:342
print_private_data
static void print_private_data(AVTextFormatContext *tfc, void *priv_data)
Definition: ffprobe.c:1176
print_duration_ts
#define print_duration_ts(k, v)
Definition: ffprobe.c:457
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:391
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
streams_with_film_grain
static int * streams_with_film_grain
Definition: ffprobe.c:357
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:561
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:216
InputFile
Definition: ffmpeg.h:529
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:100
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:112
opt_read_intervals
static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3145
AVFilmGrainH274Params::intensity_interval_upper_bound
uint8_t intensity_interval_upper_bound[3][256]
Specifies the upper bound of each intensity interval for which the set of model values applies for th...
Definition: film_grain_params.h:179
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:413
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:2630
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
parse_read_intervals
static int parse_read_intervals(const char *intervals_spec)
Definition: ffprobe.c:3097
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1405
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:549
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:925
show_error
static void show_error(AVTextFormatContext *tfc, int err)
Definition: ffprobe.c:2445
AVIAMFSubmixElement::annotations
AVDictionary * annotations
A dictionary of strings describing the submix in different languages.
Definition: iamf.h:493
AVTextFormatSection::flags
int flags
Definition: avtextformat.h:56
AVFilmGrainParams::bit_depth_chroma
int bit_depth_chroma
Definition: film_grain_params.h:239
avassert.h
do_show_error
static int do_show_error
Definition: ffprobe.c:102
show_frame
static void show_frame(AVTextFormatContext *tfc, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:1473
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
CHECK_END
#define CHECK_END
AVTextFormatOptions::is_key_selected
int(* is_key_selected)(struct AVTextFormatContext *tctx, const char *key)
Callback to discard certain elements based upon the key used.
Definition: avtextformat.h:124
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1495
film_grain_params.h
AVFrameSideData::size
size_t size
Definition: frame.h:292
AVInputFormat
Definition: avformat.h:544
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:644
av_dump_format
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate,...
Definition: dump.c:845
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
nb_streams_frames
static uint64_t * nb_streams_frames
Definition: ffprobe.c:354
AVFilmGrainParams::width
int width
Intended display resolution.
Definition: film_grain_params.h:220
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:649
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:231
AVMutex
#define AVMutex
Definition: thread.h:184
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:653
SECTION_ID_STREAM_GROUP_STREAMS
@ SECTION_ID_STREAM_GROUP_STREAMS
Definition: ffprobe.c:220
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:362
SECTION_ID_FORMAT_TAGS
@ SECTION_ID_FORMAT_TAGS
Definition: ffprobe.c:170
AVDOVIRpuDataHeader::vdr_bit_depth
uint8_t vdr_bit_depth
Definition: dovi_meta.h:99
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1089
AVDOVIRpuDataHeader::rpu_type
uint8_t rpu_type
Definition: dovi_meta.h:88
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:97
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1225
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:345
ReadInterval::end
int64_t end
start, end in second/AV_TIME_BASE units
Definition: ffprobe.c:151
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
stereo3d.h
print_displaymatrix
static void print_displaymatrix(AVTextFormatContext *tfc, const int32_t matrix[9])
Definition: ffprobe.c:510
log_read_interval
static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
Definition: ffprobe.c:1633
intreadwrite.h
AVFormatContext::video_codec
const struct AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1785
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVTextFormatter
Definition: avtextformat.h:97
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
show_packet
static void show_packet(AVTextFormatContext *tfc, InputFile *ifile, AVPacket *pkt, int packet_idx)
Definition: ffprobe.c:1325
unit_bit_per_second_str
static const char unit_bit_per_second_str[]
Definition: ffprobe.c:350
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1460
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
avtext_print_data_hash
void avtext_print_data_hash(AVTextFormatContext *tctx, const char *key, const uint8_t *data, int size)
Definition: avtextformat.c:568
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:549
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1275
audio_codec_name
static const char * audio_codec_name
Definition: ffprobe.c:134
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1364
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:232
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVDictionaryEntry::key
char * key
Definition: dict.h:91
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
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
show_program
static int show_program(AVTextFormatContext *tfc, InputFile *ifile, AVProgram *program)
Definition: ffprobe.c:2073
av_iamf_param_definition_get_subblock
static av_always_inline void * av_iamf_param_definition_get_subblock(const AVIAMFParamDefinition *par, unsigned int idx)
Get the subblock at the specified.
Definition: iamf.h:260
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:119
avtextwriter_context_close
int avtextwriter_context_close(AVTextWriterContext **pwctx)
Definition: avtextformat.c:606
AVTextFormatSection
Definition: avtextformat.h:41
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:179
get_decoder_for_stream
static const AVCodec * get_decoder_for_stream(AVFormatContext *fmt_ctx, AVStream *stream)
Definition: ffprobe.c:2482
get_frame_side_data_type
static const char * get_frame_side_data_type(const void *data)
Definition: ffprobe.c:241
print_fmt
#define print_fmt(k, f,...)
Definition: ffprobe.c:431
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Alias for avcodec_receive_frame_flags(avctx, frame, 0).
Definition: avcodec.c:723
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
print_primaries
static void print_primaries(AVTextFormatContext *tfc, enum AVColorPrimaries color_primaries)
Definition: ffprobe.c:1234
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:481
do_show_stream_group_tags
static int do_show_stream_group_tags
Definition: ffprobe.c:124
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1108
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1565
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AVPacketSideData::data
uint8_t * data
Definition: packet.h:410
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:58
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:664
avtext_context_open
int avtext_context_open(AVTextFormatContext **ptctx, const AVTextFormatter *formatter, AVTextWriterContext *writer_context, const char *args, const AVTextFormatSection *sections, int nb_sections, AVTextFormatOptions options, char *show_data_hash)
Definition: avtextformat.c:127
get_raw_string_type
static const char * get_raw_string_type(const void *data)
Definition: ffprobe.c:247
SECTION_ID_ROOT
@ SECTION_ID_ROOT
Definition: ffprobe.c:225
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
AV_FRAME_DATA_DYNAMIC_HDR_SMPTE_2094_APP5
@ AV_FRAME_DATA_DYNAMIC_HDR_SMPTE_2094_APP5
HDR dynamic metadata associated with a video frame.
Definition: frame.h:269
nb_streams
static int nb_streams
Definition: ffprobe.c:352
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:1829
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2100
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:120
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:117
AV_DOVI_MAPPING_POLYNOMIAL
@ AV_DOVI_MAPPING_POLYNOMIAL
Definition: dovi_meta.h:108
AV_TEXTFORMAT_DATADUMP_XXD
@ AV_TEXTFORMAT_DATADUMP_XXD
Definition: avtextformat.h:93
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1282
SECTION_ID_STREAM_GROUP_SUBPIECE
@ SECTION_ID_STREAM_GROUP_SUBPIECE
Definition: ffprobe.c:215
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
AVFilmGrainH274Params::comp_model_value
int16_t comp_model_value[3][256][6]
Specifies the model values for the component for each intensity interval.
Definition: film_grain_params.h:190
key
const char * key
Definition: hwcontext_opencl.c:189
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
color_range
color_range
Definition: vf_selectivecolor.c:43
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:202
AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE
#define AV_TEXTFORMAT_SECTION_FLAG_HAS_TYPE
For these sections the element_name field is mandatory.
Definition: avtextformat.h:49
InputStream::dec_ctx
AVCodecContext * dec_ctx
Definition: ffprobe.c:82
do_show_chapters
static int do_show_chapters
Definition: ffprobe.c:101
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:282
AV_FILM_GRAIN_PARAMS_NONE
@ AV_FILM_GRAIN_PARAMS_NONE
Definition: film_grain_params.h:25
AVFormatContext::data_codec
const struct AVCodec * data_codec
Forced data codec.
Definition: avformat.h:1809
AVFormatContext::probe_score
int probe_score
format probing score.
Definition: avformat.h:1728
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:363
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:160
SECTION_ID_FRAME_LOGS
@ SECTION_ID_FRAME_LOGS
Definition: ffprobe.c:183
arg
const char * arg
Definition: jacosubdec.c:65
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:116
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
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:2512
AVDOVINLQParams::linear_deadzone_threshold
uint64_t linear_deadzone_threshold
Definition: dovi_meta.h:144
InputFile::streams
InputStream * streams
Definition: ffprobe.c:88
AVTextFormatSection::unique_name
const char * unique_name
unique section name, in case the name is ambiguous
Definition: avtextformat.h:59
print_tile_grid_params
static void print_tile_grid_params(AVTextFormatContext *tfc, const AVStreamGroup *stg, const AVStreamGroupTileGrid *tile_grid)
Definition: ffprobe.c:2122
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:3772
ReadInterval::start
int64_t start
Definition: ffprobe.c:151
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
AVFormatContext
Format I/O context.
Definition: avformat.h:1263
print_int
#define print_int(k, v)
Definition: ffprobe.c:449
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
static AVDictionary * opts
Definition: movenc.c:51
read_intervals
static ReadInterval * read_intervals
Definition: ffprobe.c:157
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:767
SECTION_ID_STREAM_GROUPS
@ SECTION_ID_STREAM_GROUPS
Definition: ffprobe.c:224
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.
AV_PKT_DATA_EXIF
@ AV_PKT_DATA_EXIF
Extensible image file format metadata.
Definition: packet.h:369
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
ReadInterval::has_end
int has_end
Definition: ffprobe.c:152
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:184
print_alpha_mode
static void print_alpha_mode(AVTextFormatContext *tfc, enum AVAlphaMode alpha_mode)
Definition: ffprobe.c:1264
metadata
Stream codec metadata
Definition: ogg-flac-chained-meta.txt:2
SECTION_ID_FRAME_LOG
@ SECTION_ID_FRAME_LOG
Definition: ffprobe.c:182
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:783
NULL
#define NULL
Definition: coverity.c:32
avtext_print_string
int avtext_print_string(AVTextFormatContext *tctx, const char *key, const char *val, int flags)
Definition: avtextformat.c:439
AVTextFormatContext::section
const AVTextFormatSection * section[SECTION_MAX_NB_LEVELS]
section per each level
Definition: avtextformat.h:151
SET_DO_SHOW
#define SET_DO_SHOW(id, varname)
Definition: ffprobe.c:3315
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:1077
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:92
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:63
InputStream::st
AVStream * st
Definition: ffmpeg.h:491
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
AVHDRVividColorTransformParams::color_saturation_gain
AVRational color_saturation_gain[8]
Indicates the color correction strength parameter.
Definition: hdr_dynamic_vivid_metadata.h:242
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
show_stream_groups
static int show_stream_groups(AVTextFormatContext *tfc, InputFile *ifile)
Definition: ffprobe.c:2372
AV_DOVI_MAPPING_MMR
@ AV_DOVI_MAPPING_MMR
Definition: dovi_meta.h:109
OPT_EXPERT
#define OPT_EXPERT
Definition: cmdutils.h:211
ERROR
static void ERROR(const char *str)
Definition: audio_fifo.c:58
do_read_frames
static int do_read_frames
Definition: ffprobe.c:99
AVDynamicHDRSmpte2094App5
This struct represents dynamic metadata for color volume transform as specified in the SMPTE 2094-50 ...
Definition: hdr_dynamic_metadata.h:387
AVStreamGroupTileGrid::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the grid.
Definition: avformat.h:1054
SECTION_ID_LIBRARY_VERSION
@ SECTION_ID_LIBRARY_VERSION
Definition: ffprobe.c:184
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
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
SECTION_ID_STREAM_TAGS
@ SECTION_ID_STREAM_TAGS
Definition: ffprobe.c:229
isnan
#define isnan(x)
Definition: libm.h:342
SHOW_OPTIONAL_FIELDS_ALWAYS
#define SHOW_OPTIONAL_FIELDS_ALWAYS
Definition: ffprobe.c:141
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:412
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:1423
print_q
#define print_q(k, v, s)
Definition: ffprobe.c:450
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:1305
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:482
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:213
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
AVDynamicHDRVivid
This struct represents dynamic metadata for color volume transform - CUVA 005.1:2021 standard.
Definition: hdr_dynamic_vivid_metadata.h:256
is_key_selected_callback
static int is_key_selected_callback(AVTextFormatContext *tctx, const char *key)
Definition: ffprobe.c:373
options
Definition: swscale.c:45
AVHDRVividColorTransformParams::color_saturation_mapping_flag
int color_saturation_mapping_flag
This flag indicates that the metadata for the color saturation mapping in the processing window is pr...
Definition: hdr_dynamic_vivid_metadata.h:229
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:824
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3790
show_stream
static int show_stream(AVTextFormatContext *tfc, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int container)
Definition: ffprobe.c:1831
AVHDRPlusColorTransformParams::fraction_bright_pixels
AVRational fraction_bright_pixels
The fraction of selected pixels in the image that contains the brightest pixel in the scene.
Definition: hdr_dynamic_metadata.h:183
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:592
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:144
AVTextFormatContext::formatter
const AVTextFormatter * formatter
the AVTextFormatter of which this is an instance
Definition: avtextformat.h:135
GET_DECODER
#define GET_DECODER(type_)
print_integers
static void print_integers(AVTextFormatContext *tfc, const char *key, const void *data, int size, const char *format, int columns, int bytes, int offset_add)
Definition: ffprobe.c:460
set_decoders
static int set_decoders(AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2467
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVFilmGrainParams::subsampling_x
int subsampling_x
Intended subsampling ratio, or 0 for luma-only streams.
Definition: film_grain_params.h:225
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:126
do_show_programs
static int do_show_programs
Definition: ffprobe.c:106
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
avtext_get_formatter_by_name
const AVTextFormatter * avtext_get_formatter_by_name(const char *name)
Definition: avtextformat.c:684
AVHDRVividColorTransformParams::tone_mapping_mode_flag
int tone_mapping_mode_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_vivid_metadata.h:212
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
real_options
static const OptionDef real_options[]
Definition: ffprobe.c:3246
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:743
AVCodecParameters::level
int level
Definition: codec_par.h:129
swresample.h
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:349
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffprobe.c:93
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
print_color_trc
static void print_color_trc(AVTextFormatContext *tfc, enum AVColorTransferCharacteristic color_trc)
Definition: ffprobe.c:1244
AVAudioServiceType
AVAudioServiceType
Definition: defs.h:235
AVFormatContext::audio_codec
const struct AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1793
print_iamf_audio_element_params
static void print_iamf_audio_element_params(AVTextFormatContext *tfc, const AVStreamGroup *stg, const AVIAMFAudioElement *audio_element)
Definition: ffprobe.c:2209
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:805
SECTION_ID_CHAPTER
@ SECTION_ID_CHAPTER
Definition: ffprobe.c:165
AVIAMFSubmixElement::audio_element_id
unsigned int audio_element_id
The id of the Audio Element this submix element references.
Definition: iamf.h:455
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1049
print_duration_time
#define print_duration_time(k, v, tb)
Definition: ffprobe.c:456
print_iamf_param_definition
static void print_iamf_param_definition(AVTextFormatContext *tfc, const char *name, const AVIAMFParamDefinition *param, SectionID section_id)
Definition: ffprobe.c:2154
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:559
show_value_unit
static int show_value_unit
Definition: ffprobe.c:128
print_dynamic_hdr_vivid
static void print_dynamic_hdr_vivid(AVTextFormatContext *tfc, const AVDynamicHDRVivid *metadata)
Definition: ffprobe.c:864
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1319
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:1090
print_input_filename
static const char * print_input_filename
Definition: ffprobe.c:343
AVAlphaMode
AVAlphaMode
Correlation between the alpha channel and color values.
Definition: pixfmt.h:810
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:172
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:58
FrameData::pkt_size
int pkt_size
Definition: ffprobe.c:76
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:2607
fmt_ctx
static AVFormatContext * fmt_ctx
Definition: decode_filter_audio.c:44
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:68
f
f
Definition: af_crystalizer.c:122
SECTION_ID_STREAM_GROUP_PIECES
@ SECTION_ID_STREAM_GROUP_PIECES
Definition: ffprobe.c:212
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
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:492
AVPacket::size
int size
Definition: packet.h:589
ReadInterval::start_is_offset
int start_is_offset
Definition: ffprobe.c:153
do_show_packet_tags
static int do_show_packet_tags
Definition: ffprobe.c:126
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:618
SECTION_ID_STREAM_DISPOSITION
@ SECTION_ID_STREAM_DISPOSITION
Definition: ffprobe.c:227
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:163
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
height
#define height
Definition: dsp.h:89
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
PRINT_PIX_FMT_FLAG
#define PRINT_PIX_FMT_FLAG(flagname, name)
Definition: ffprobe.c:2790
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:133
AVFilmGrainH274Params::component_model_present
int component_model_present[3]
Indicates if the modelling of film grain for a given component is present.
Definition: film_grain_params.h:155
show_programs
static int show_programs(AVTextFormatContext *tfc, InputFile *ifile)
Definition: ffprobe.c:2104
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:132
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
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:132
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1379
avtext_print_section_footer
void avtext_print_section_footer(AVTextFormatContext *tctx)
Definition: avtextformat.c:266
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:550
SectionID
SectionID
Definition: ffprobe.c:164
AV_MUTEX_INITIALIZER
#define AV_MUTEX_INITIALIZER
Definition: thread.h:185
REALLOCZ_ARRAY_STREAM
#define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n)
Definition: ffprobe.c:484
SECTION_ID_STREAM_GROUP_COMPONENT
@ SECTION_ID_STREAM_GROUP_COMPONENT
Definition: ffprobe.c:209
print_iamf_submix_params
static void print_iamf_submix_params(AVTextFormatContext *tfc, const AVIAMFSubmix *submix)
Definition: ffprobe.c:2250
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:140
size
int size
Definition: twinvq_data.h:10344
SECTION_ID_CHAPTER_TAGS
@ SECTION_ID_CHAPTER_TAGS
Definition: ffprobe.c:166
AVHDRVividColorTransformParams::average_maxrgb
AVRational average_maxrgb
Indicates the average brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:192
show_private_data
static int show_private_data
Definition: ffprobe.c:132
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:247
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1130
opt_show_versions
static int opt_show_versions(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3220
AVFrameSideData::data
uint8_t * data
Definition: frame.h:291
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:201
opt_input_file
static int opt_input_file(void *optctx, const char *arg)
Definition: ffprobe.c:2952
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:797
SECTION_ID_PACKETS_AND_FRAMES
@ SECTION_ID_PACKETS_AND_FRAMES
Definition: ffprobe.c:189
AVOption::name
const char * name
Definition: opt.h:430
use_value_prefix
static int use_value_prefix
Definition: ffprobe.c:129
SECTION_ID_ERROR
@ SECTION_ID_ERROR
Definition: ffprobe.c:168
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:292
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2097
avdevice.h
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:352
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: opt_common.c:235
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
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
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:587
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:200
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
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AVIAMFAudioElement
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
Definition: iamf.h:359
AVTextFormatter::flags
int flags
a combination or AV_TEXTFORMAT__FLAG_*
Definition: avtextformat.h:109
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:174
print_iamf_mix_presentation_params
static void print_iamf_mix_presentation_params(AVTextFormatContext *tfc, const AVStreamGroup *stg, const AVIAMFMixPresentation *mix_presentation)
Definition: ffprobe.c:2297
SECTION_ID_PACKET_TAGS
@ SECTION_ID_PACKET_TAGS
Definition: ffprobe.c:187
AVStreamGroupTileGrid::nb_tiles
unsigned int nb_tiles
Amount of tiles in the grid.
Definition: avformat.h:959
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
line
Definition: graph2dot.c:48
SECTION_ID_STREAM_GROUP_STREAM_TAGS
@ SECTION_ID_STREAM_GROUP_STREAM_TAGS
Definition: ffprobe.c:206
ff_mutex_lock
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:188
AVIAMFMixGain
Mix Gain Parameter Data as defined in section 3.8.1 of IAMF.
Definition: iamf.h:77
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:594
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:233
do_show_format
static int do_show_format
Definition: ffprobe.c:103
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:297
log_mutex
static AVMutex log_mutex
Definition: ffprobe.c:359
AVFilmGrainParams::h274
AVFilmGrainH274Params h274
Definition: film_grain_params.h:248
ReadInterval
Definition: ffprobe.c:149
va_copy
#define va_copy(dst, src)
Definition: va_copy.h:31
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1088
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:1164
AVFilmGrainAOMParams::ar_coeffs_y
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
Definition: film_grain_params.h:80
print_color_range
static void print_color_range(AVTextFormatContext *tfc, enum AVColorRange color_range)
Definition: ffprobe.c:1214
OPT_TYPE_BOOL
@ OPT_TYPE_BOOL
Definition: cmdutils.h:82
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1131
do_show_stream_disposition
static int do_show_stream_disposition
Definition: ffprobe.c:110
do_show_stream_groups
static int do_show_stream_groups
Definition: ffprobe.c:107
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:796
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
do_count_packets
static int do_count_packets
Definition: ffprobe.c:98
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:344
SHOW_OPTIONAL_FIELDS_AUTO
#define SHOW_OPTIONAL_FIELDS_AUTO
Definition: ffprobe.c:139
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:152
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
EntrySelection::entries_to_show
AVDictionary * entries_to_show
Definition: ffprobe.c:334
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:312
AVStreamGroupTileGrid::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: avformat.h:1059
SECTION_ID_PROGRAM_STREAM_TAGS
@ SECTION_ID_PROGRAM_STREAM_TAGS
Definition: ffprobe.c:198
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:720
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
print_ambient_viewing_environment
static void print_ambient_viewing_environment(AVTextFormatContext *tfc, const AVAmbientViewingEnvironment *env)
Definition: ffprobe.c:934
AVStreamGroupTileGrid::width
int width
Width of the final image for presentation.
Definition: avformat.h:1036
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:146
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2095
AVClassCategory
AVClassCategory
Definition: log.h:28
AVFilmGrainParams::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:231
AV_STREAM_GROUP_PARAMS_NONE
@ AV_STREAM_GROUP_PARAMS_NONE
Definition: avformat.h:1087
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:581
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:131
AVIAMFParamDefinition::parameter_id
unsigned int parameter_id
Identifier for the parameter substream.
Definition: iamf.h:218
AVIAMFLayer::demixing_matrix
AVRational * demixing_matrix
Demixing matrix as defined in section 3.6.3 of IAMF.
Definition: iamf.h:336
print_film_grain_params
static void print_film_grain_params(AVTextFormatContext *tfc, const AVFilmGrainParams *fgp)
Definition: ffprobe.c:945
SECTION_ID_PROGRAM
@ SECTION_ID_PROGRAM
Definition: ffprobe.c:199
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1223
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:1491
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
AVFormatContext::subtitle_codec
const struct AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1801
show_usage
static void show_usage(void)
Definition: ffprobe.c:2739
AVFilmGrainH274Params
This structure describes how to handle film grain synthesis for codecs using the ITU-T H....
Definition: film_grain_params.h:132
SECTION_ID_STREAM_GROUP_STREAM
@ SECTION_ID_STREAM_GROUP_STREAM
Definition: ffprobe.c:221
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
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS
#define AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS
the section may contain a variable number of fields with variable keys.
Definition: avtextformat.h:47
AVFilmGrainH274Params::num_intensity_intervals
uint16_t num_intensity_intervals[3]
Specifies the number of intensity intervals for which a specific set of model values has been estimat...
Definition: film_grain_params.h:161
do_bitexact
static int do_bitexact
Definition: ffprobe.c:96
avtextwriter_create_file
int avtextwriter_create_file(AVTextWriterContext **pwctx, const char *output_filename)
Definition: tw_avio.c:79
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
read_interval_packets
static int read_interval_packets(AVTextFormatContext *tfc, InputFile *ifile, const ReadInterval *interval, int64_t *cur_ts)
Definition: ffprobe.c:1657
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:700
display.h
SECTION_ID_PACKETS
@ SECTION_ID_PACKETS
Definition: ffprobe.c:188
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:215
AVIAMFMixPresentation
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
Definition: iamf.h:616
AVFilmGrainParams::subsampling_y
int subsampling_y
Definition: film_grain_params.h:225
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:287
AVDOVIDataMapping::num_y_partitions
uint32_t num_y_partitions
Definition: dovi_meta.h:161
LogBuffer::category
AVClassCategory category
Definition: ffprobe.c:365
parse_options
int parse_options(void *optctx, int argc, char **argv, const OptionDef *options, int(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:420
opt_show_entries
static int opt_show_entries(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:2902
av_always_inline
#define av_always_inline
Definition: attributes.h:68
SECTION_ID_FRAME_SIDE_DATA
@ SECTION_ID_FRAME_SIDE_DATA
Definition: ffprobe.c:175
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
print_pixel_format
static void print_pixel_format(AVTextFormatContext *tfc, enum AVPixelFormat pix_fmt)
Definition: ffprobe.c:1189
SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
@ SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
Definition: ffprobe.c:178
opt_sections
static int opt_sections(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3177
avtextformatter_xml
const AVTextFormatter avtextformatter_xml
Definition: tf_xml.c:202
OPT_FUNC_ARG
#define OPT_FUNC_ARG
Definition: cmdutils.h:205
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
AVHDRVividColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for CUVA 005....
Definition: hdr_dynamic_vivid_metadata.h:179
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
AV_PKT_DATA_MPEGTS_STREAM_ID
@ AV_PKT_DATA_MPEGTS_STREAM_ID
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:212
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1187
AVStreamGroup::params
union AVStreamGroup::@447 params
Group type-specific parameters.
print_dynamic_hdr10_plus
static void print_dynamic_hdr10_plus(AVTextFormatContext *tfc, const AVDynamicHDRPlus *metadata)
Definition: ffprobe.c:709
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:166
AVTextFormatContext::string_validation_utf8_flags
unsigned int string_validation_utf8_flags
Definition: avtextformat.h:161
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
profile
int profile
Definition: mxfenc.c:2297
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
do_show_stream_group_disposition
static int do_show_stream_group_disposition
Definition: ffprobe.c:111
AVDOVINLQParams
Coefficients of the non-linear inverse quantization.
Definition: dovi_meta.h:139
AVHDRVividColorToneMappingParams::base_param_Delta_enable_mode
int base_param_Delta_enable_mode
This flag indicates that delta mode of base parameter(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:191
ambient_viewing_environment.h
use_value_sexagesimal_format
static int use_value_sexagesimal_format
Definition: ffprobe.c:131
SECTION_ID_LIBRARY_VERSIONS
@ SECTION_ID_LIBRARY_VERSIONS
Definition: ffprobe.c:185
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:657
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilmGrainH274Params::intensity_interval_lower_bound
uint8_t intensity_interval_lower_bound[3][256]
Specifies the lower ounds of each intensity interval for whichthe set of model values applies for the...
Definition: film_grain_params.h:173
SECTION_ID_FRAME_SIDE_DATA_TIMECODE
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE
Definition: ffprobe.c:177
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:366
AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
@ AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
Definition: iamf.h:349
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:203
AVIAMFLayer::nb_demixing_matrix
unsigned int nb_demixing_matrix
The length of the Demixing matrix array.
Definition: iamf.h:343
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
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:995
AV_TEXTFORMAT_FLAG_SUPPORTS_MIXED_ARRAY_CONTENT
#define AV_TEXTFORMAT_FLAG_SUPPORTS_MIXED_ARRAY_CONTENT
Definition: avtextformat.h:70
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:556
AVDOVINLQParams::linear_deadzone_slope
uint64_t linear_deadzone_slope
Definition: dovi_meta.h:143
SECTION_ID_PROGRAMS
@ SECTION_ID_PROGRAMS
Definition: ffprobe.c:204
version.h
AVIAMFSubmix::nb_layouts
unsigned int nb_layouts
Number of layouts in the submix.
Definition: iamf.h:590
AVFilmGrainParams::height
int height
Definition: film_grain_params.h:220
AVDOVIReshapingCurve
Definition: dovi_meta.h:117
version.h
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:813
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:188
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
show_log
static int show_log(AVTextFormatContext *tfc, int section_ids, int section_id, int log_level)
Definition: ffprobe.c:1290
tag
uint32_t tag
Definition: movenc.c:2046
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:756
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
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:370
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:381
AVALPHA_MODE_UNSPECIFIED
@ AVALPHA_MODE_UNSPECIFIED
Unknown alpha handling, or no alpha channel.
Definition: pixfmt.h:811
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:265
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:303
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:145
AVStreamGroup::metadata
AVDictionary * metadata
Metadata that applies to the whole group.
Definition: avformat.h:1144
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
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
AV_TEXTFORMAT_SECTION_FLAG_IS_WRAPPER
#define AV_TEXTFORMAT_SECTION_FLAG_IS_WRAPPER
the section only contains other sections, but has no data at its own level
Definition: avtextformat.h:45
InputFile::streams
InputStream ** streams
Definition: ffmpeg.h:548
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:3015
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:122
AVHDRVividColorTransformParams::minimum_maxrgb
AVRational minimum_maxrgb
Indicates the minimum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:185
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:599
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:400
id
enum AVCodecID id
Definition: dts2pts.c:549
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
log_buffer_size
static int log_buffer_size
Definition: ffprobe.c:371
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:573
AVDOVIRpuDataHeader::vdr_rpu_level
uint8_t vdr_rpu_level
Definition: dovi_meta.h:91
SECTION_ID_FRAME
@ SECTION_ID_FRAME
Definition: ffprobe.c:171
av_dovi_get_color
static av_always_inline AVDOVIColorMetadata * av_dovi_get_color(const AVDOVIMetadata *data)
Definition: dovi_meta.h:375
AVStreamGroup
Definition: avformat.h:1097
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
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:439
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:750
show_tags
static int show_tags(AVTextFormatContext *tfc, AVDictionary *tags, int section_id)
Definition: ffprobe.c:492
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:147
flush_buffers
static void flush_buffers(InputFile *ifile)
Definition: ffprobe.c:1780
show_streams
static int show_streams(AVTextFormatContext *tfc, InputFile *ifile)
Definition: ffprobe.c:2056
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
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:1151
get_packet_side_data_type
static const char * get_packet_side_data_type(const void *data)
Definition: ffprobe.c:235
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:606
nb_streams_packets
static uint64_t * nb_streams_packets
Definition: ffprobe.c:353
AVTextFormatSection::children_ids
const int children_ids[SECTION_MAX_NB_CHILDREN+1]
list of children section IDS, terminated by -1
Definition: avtextformat.h:57
do_show_program_version
static int do_show_program_version
Definition: ffprobe.c:113
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:3227
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:563
AVTextFormatOptions
Definition: avtextformat.h:115
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
probe_file
static int probe_file(AVTextFormatContext *tfc, const char *filename, const char *print_filename)
Definition: ffprobe.c:2644
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_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:227
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:196
video
A Quick Description Of Rate Distortion Theory We want to encode a video
Definition: rate_distortion.txt:3
sections
static const AVTextFormatSection sections[]
Definition: ffprobe.c:258
SECTION_ID_STREAM_GROUP_BLOCK
@ SECTION_ID_STREAM_GROUP_BLOCK
Definition: ffprobe.c:217
print_str_validate
#define print_str_validate(k, v)
Definition: ffprobe.c:453
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:290
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:171
output_format
static char * output_format
Definition: ffprobe.c:144
AVFilmGrainH274Params::log2_scale_factor
int log2_scale_factor
Specifies a scale factor used in the film grain characterization equations.
Definition: film_grain_params.h:150
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
hdr_dynamic_metadata.h
AV_PKT_DATA_AFD
@ AV_PKT_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:258
selected_entries
static EntrySelection selected_entries[FF_ARRAY_ELEMS(sections)]
Definition: ffprobe.c:337
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:878
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommends skipping the specified number of samples.
Definition: packet.h:153
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:60
options
static const OptionDef * options
Definition: ffprobe.c:339
do_show_pixel_formats
static int do_show_pixel_formats
Definition: ffprobe.c:115
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:619
AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
Subblocks are of struct type AVIAMFMixGain.
Definition: iamf.h:173
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
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:146
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1398
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:590
AVFilmGrainH274Params::num_model_values
uint8_t num_model_values[3]
Specifies the number of model values present for each intensity interval in which the film grain has ...
Definition: film_grain_params.h:167
AVFilmGrainParams::color_range
enum AVColorRange color_range
Intended video signal characteristics.
Definition: film_grain_params.h:230
ffprobe_show_library_versions
static void ffprobe_show_library_versions(AVTextFormatContext *tfc)
Definition: ffprobe.c:2777
data_codec_name
static const char * data_codec_name
Definition: ffprobe.c:135
ALPHA
@ ALPHA
Definition: drawutils.c:33
opt_print_filename
static int opt_print_filename(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:2992
AVIAMFSubmix::nb_elements
unsigned int nb_elements
Number of elements in the submix.
Definition: iamf.h:575
get_stream_group_type
static const char * get_stream_group_type(const void *data)
Definition: ffprobe.c:252
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:615
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_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
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:57
do_show_program_tags
static int do_show_program_tags
Definition: ffprobe.c:123
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
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:380
avutil.h
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_apv.c:70
AVIAMFAudioElement::demixing_info
AVIAMFParamDefinition * demixing_info
Demixing information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:379
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:598
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1124
print_stream_group_params
static void print_stream_group_params(AVTextFormatContext *tfc, AVStreamGroup *stg)
Definition: ffprobe.c:2316
AVIAMFLayer::ambisonics_mode
enum AVIAMFAmbisonicsMode ambisonics_mode
Ambisonics mode as defined in section 3.6.3 of IAMF.
Definition: iamf.h:328
av_strdup
#define av_strdup(s)
Definition: ops_asmgen.c:47
mastering_display_metadata.h
av_dovi_get_mapping
static av_always_inline AVDOVIDataMapping * av_dovi_get_mapping(const AVDOVIMetadata *data)
Definition: dovi_meta.h:369
AV_DOVI_COMPRESSION_NONE
@ AV_DOVI_COMPRESSION_NONE
Definition: dovi_meta.h:68
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:175
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:289
AVCodecParameters::format
int format
Definition: codec_par.h:92
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
SECTION_ID_STREAM_GROUP_TAGS
@ SECTION_ID_STREAM_GROUP_TAGS
Definition: ffprobe.c:223
AVIAMFMixPresentation::annotations
AVDictionary * annotations
A dictionary of strings describing the mix in different languages.
Definition: iamf.h:644
SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST
@ SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST
Definition: ffprobe.c:176
AVFormatContext::nb_stream_groups
unsigned int nb_stream_groups
Number of elements in AVFormatContext.stream_groups.
Definition: avformat.h:1338
AVStreamGroupTileGrid::height
int height
Height of the final image for presentation.
Definition: avformat.h:1046
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:217
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
AVIAMFLayer::output_gain
AVRational output_gain
Output gain as defined in section 3.6.2 of IAMF.
Definition: iamf.h:316
AV_IAMF_AMBISONICS_MODE_PROJECTION
@ AV_IAMF_AMBISONICS_MODE_PROJECTION
Definition: iamf.h:274
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:466
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:119
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:247
cmdutils.h
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:608
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: side_data.c:71
SHOW_LIB_VERSION
#define SHOW_LIB_VERSION(libname, LIBNAME)
Definition: ffprobe.c:2762
IN_PROGRAM
#define IN_PROGRAM
Definition: ffprobe.c:1828
data_dump_format
static char * data_dump_format
Definition: ffprobe.c:147
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:464
AVIAMFParamDefinition::parameter_rate
unsigned int parameter_rate
Sample rate for the parameter substream.
Definition: iamf.h:222
AV_FRAME_DATA_EXIF
@ AV_FRAME_DATA_EXIF
Extensible image file format metadata.
Definition: frame.h:262
read_packets
static int read_packets(AVTextFormatContext *tfc, InputFile *ifile)
Definition: ffprobe.c:1792
int32_t
int32_t
Definition: audioconvert.c:56
AVIAMFSubmixElement
Submix element as defined in section 3.7 of IAMF.
Definition: iamf.h:449
AVDOVINLQParams::nlq_offset
uint16_t nlq_offset
Definition: dovi_meta.h:140
timestamp.h
AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
@ AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
Definition: iamf.h:348
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:293
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:1205
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:153
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:1388
SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
@ SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
Definition: ffprobe.c:180
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:200
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:92
do_show_data
static int do_show_data
Definition: ffprobe.c:112
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:124
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:222
avtext_print_data
void avtext_print_data(AVTextFormatContext *tctx, const char *key, const uint8_t *data, int size)
Definition: avtextformat.c:549
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:130
LogBuffer::parent_category
AVClassCategory parent_category
Definition: ffprobe.c:367
print_dovi_metadata
static void print_dovi_metadata(AVTextFormatContext *tfc, const AVDOVIMetadata *dovi)
Definition: ffprobe.c:547
SECTION_ID_PROGRAM_STREAM_DISPOSITION
@ SECTION_ID_PROGRAM_STREAM_DISPOSITION
Definition: ffprobe.c:197
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3888
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:386
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:92
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:793
SECTION_ID_STREAM_GROUP_SUBPIECES
@ SECTION_ID_STREAM_GROUP_SUBPIECES
Definition: ffprobe.c:214
show_data_hash
static char * show_data_hash
Definition: ffprobe.c:146
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION
@ SECTION_ID_STREAM_GROUP_STREAM_DISPOSITION
Definition: ffprobe.c:205
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:87
width
#define width
Definition: dsp.h:89
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:109
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:990
opt_codec
static int opt_codec(void *optctx, const char *opt, const char *arg)
Definition: ffprobe.c:3190
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:549
show_chapters
static int show_chapters(AVTextFormatContext *tfc, InputFile *ifile)
Definition: ffprobe.c:2389
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:742
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1224
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
do_analyze_frames
static int do_analyze_frames
Definition: ffprobe.c:95
avtext_context_close
int avtext_context_close(AVTextFormatContext **ptctx)
Definition: avtextformat.c:102
AVHDRVividColorToneMappingParams::three_spline
AVHDRVivid3SplineParams three_spline[2]
Definition: hdr_dynamic_vivid_metadata.h:171
AVHDRVividColorToneMappingParams::base_param_m_p
AVRational base_param_m_p
base_param_m_p in the base parameter, in multiples of 1.0/16383.
Definition: hdr_dynamic_vivid_metadata.h:95
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:205
AVIAMFMixPresentation::submixes
AVIAMFSubmix ** submixes
Array of submixes.
Definition: iamf.h:625
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:472
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:162
snprintf
#define snprintf
Definition: snprintf.h:34
stream_specifier
static char * stream_specifier
Definition: ffprobe.c:145
AV_FRAME_FLAG_LOSSLESS
#define AV_FRAME_FLAG_LOSSLESS
A decoder can use this flag to mark frames which were originally encoded losslessly.
Definition: frame.h:670
log_callback
static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
Definition: ffprobe.c:381
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:1291
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:152
SECTION_ID_CHAPTERS
@ SECTION_ID_CHAPTERS
Definition: ffprobe.c:167
print_time
#define print_time(k, v, tb)
Definition: ffprobe.c:454
print_mastering_display_metadata
static void print_mastering_display_metadata(AVTextFormatContext *tfc, const AVMasteringDisplayMetadata *metadata)
Definition: ffprobe.c:519
print_pkt_side_data
static void print_pkt_side_data(AVTextFormatContext *tfc, int width, int height, const AVPacketSideData *sd, SectionID id_data)
Definition: ffprobe.c:1070
AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY
#define AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY
the section contains an array of elements of the same type
Definition: avtextformat.h:46
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:100
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3823
print_str_opt
#define print_str_opt(k, v)
Definition: ffprobe.c:452
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2096
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
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:194
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:144
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
SECTION_ID_PACKET
@ SECTION_ID_PACKET
Definition: ffprobe.c:186
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:574
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:347
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:311
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:600
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
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:3376
do_show_packets
static int do_show_packets
Definition: ffprobe.c:105
AV_IAMF_PARAMETER_DEFINITION_DEMIXING
@ AV_IAMF_PARAMETER_DEFINITION_DEMIXING
Subblocks are of struct type AVIAMFDemixingInfo.
Definition: iamf.h:177
SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
@ SECTION_ID_STREAM_GROUP_SUBCOMPONENTS
Definition: ffprobe.c:210
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:347
print_list_fmt
#define print_list_fmt(k, f, n, m,...)
Definition: ffprobe.c:437
avdevice_register_all
FF_VISIBILITY_POP_HIDDEN av_cold void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:67
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
avtext_print_section_header
void avtext_print_section_header(AVTextFormatContext *tctx, const void *data, int section_id)
Definition: avtextformat.c:248
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86
show_stream_group
static int show_stream_group(AVTextFormatContext *tfc, InputFile *ifile, AVStreamGroup *stg)
Definition: ffprobe.c:2328
Generated on Wed Apr 15 2026 19:22:10 for FFmpeg by   doxygen 1.8.17