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