ffprobe: Print AVMasteringDisplayMetadata side data contents
[ffmpeg.git] / ffprobe.c
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
31 #include "libavformat/avformat.h"
32 #include "libavcodec/avcodec.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/bprint.h"
36 #include "libavutil/display.h"
37 #include "libavutil/hash.h"
38 #include "libavutil/mastering_display_metadata.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/spherical.h"
42 #include "libavutil/stereo3d.h"
43 #include "libavutil/dict.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/libm.h"
46 #include "libavutil/parseutils.h"
47 #include "libavutil/timecode.h"
48 #include "libavutil/timestamp.h"
49 #include "libavdevice/avdevice.h"
50 #include "libswscale/swscale.h"
51 #include "libswresample/swresample.h"
52 #include "libpostproc/postprocess.h"
53 #include "cmdutils.h"
54
55 #include "libavutil/thread.h"
56
57 #if !HAVE_THREADS
58 #  ifdef pthread_mutex_lock
59 #    undef pthread_mutex_lock
60 #  endif
61 #  define pthread_mutex_lock(a) do{}while(0)
62 #  ifdef pthread_mutex_unlock
63 #    undef pthread_mutex_unlock
64 #  endif
65 #  define pthread_mutex_unlock(a) do{}while(0)
66 #endif
67
68 typedef struct InputStream {
69     AVStream *st;
70
71     AVCodecContext *dec_ctx;
72 } InputStream;
73
74 typedef struct InputFile {
75     AVFormatContext *fmt_ctx;
76
77     InputStream *streams;
78     int       nb_streams;
79 } InputFile;
80
81 const char program_name[] = "ffprobe";
82 const int program_birth_year = 2007;
83
84 static int do_bitexact = 0;
85 static int do_count_frames = 0;
86 static int do_count_packets = 0;
87 static int do_read_frames  = 0;
88 static int do_read_packets = 0;
89 static int do_show_chapters = 0;
90 static int do_show_error   = 0;
91 static int do_show_format  = 0;
92 static int do_show_frames  = 0;
93 static int do_show_packets = 0;
94 static int do_show_programs = 0;
95 static int do_show_streams = 0;
96 static int do_show_stream_disposition = 0;
97 static int do_show_data    = 0;
98 static int do_show_program_version  = 0;
99 static int do_show_library_versions = 0;
100 static int do_show_pixel_formats = 0;
101 static int do_show_pixel_format_flags = 0;
102 static int do_show_pixel_format_components = 0;
103 static int do_show_log = 0;
104
105 static int do_show_chapter_tags = 0;
106 static int do_show_format_tags = 0;
107 static int do_show_frame_tags = 0;
108 static int do_show_program_tags = 0;
109 static int do_show_stream_tags = 0;
110 static int do_show_packet_tags = 0;
111
112 static int show_value_unit              = 0;
113 static int use_value_prefix             = 0;
114 static int use_byte_value_binary_prefix = 0;
115 static int use_value_sexagesimal_format = 0;
116 static int show_private_data            = 1;
117
118 static char *print_format;
119 static char *stream_specifier;
120 static char *show_data_hash;
121
122 typedef struct ReadInterval {
123     int id;             ///< identifier
124     int64_t start, end; ///< start, end in second/AV_TIME_BASE units
125     int has_start, has_end;
126     int start_is_offset, end_is_offset;
127     int duration_frames;
128 } ReadInterval;
129
130 static ReadInterval *read_intervals;
131 static int read_intervals_nb = 0;
132
133 /* section structure definition */
134
135 #define SECTION_MAX_NB_CHILDREN 10
136
137 struct section {
138     int id;             ///< unique id identifying a section
139     const char *name;
140
141 #define SECTION_FLAG_IS_WRAPPER      1 ///< the section only contains other sections, but has no data at its own level
142 #define SECTION_FLAG_IS_ARRAY        2 ///< the section contains an array of elements of the same type
143 #define SECTION_FLAG_HAS_VARIABLE_FIELDS 4 ///< the section may contain a variable number of fields with variable keys.
144                                            ///  For these sections the element_name field is mandatory.
145     int flags;
146     int children_ids[SECTION_MAX_NB_CHILDREN+1]; ///< list of children section IDS, terminated by -1
147     const char *element_name; ///< name of the contained element, if provided
148     const char *unique_name;  ///< unique section name, in case the name is ambiguous
149     AVDictionary *entries_to_show;
150     int show_all_entries;
151 };
152
153 typedef enum {
154     SECTION_ID_NONE = -1,
155     SECTION_ID_CHAPTER,
156     SECTION_ID_CHAPTER_TAGS,
157     SECTION_ID_CHAPTERS,
158     SECTION_ID_ERROR,
159     SECTION_ID_FORMAT,
160     SECTION_ID_FORMAT_TAGS,
161     SECTION_ID_FRAME,
162     SECTION_ID_FRAMES,
163     SECTION_ID_FRAME_TAGS,
164     SECTION_ID_FRAME_SIDE_DATA_LIST,
165     SECTION_ID_FRAME_SIDE_DATA,
166     SECTION_ID_FRAME_LOG,
167     SECTION_ID_FRAME_LOGS,
168     SECTION_ID_LIBRARY_VERSION,
169     SECTION_ID_LIBRARY_VERSIONS,
170     SECTION_ID_PACKET,
171     SECTION_ID_PACKET_TAGS,
172     SECTION_ID_PACKETS,
173     SECTION_ID_PACKETS_AND_FRAMES,
174     SECTION_ID_PACKET_SIDE_DATA_LIST,
175     SECTION_ID_PACKET_SIDE_DATA,
176     SECTION_ID_PIXEL_FORMAT,
177     SECTION_ID_PIXEL_FORMAT_FLAGS,
178     SECTION_ID_PIXEL_FORMAT_COMPONENT,
179     SECTION_ID_PIXEL_FORMAT_COMPONENTS,
180     SECTION_ID_PIXEL_FORMATS,
181     SECTION_ID_PROGRAM_STREAM_DISPOSITION,
182     SECTION_ID_PROGRAM_STREAM_TAGS,
183     SECTION_ID_PROGRAM,
184     SECTION_ID_PROGRAM_STREAMS,
185     SECTION_ID_PROGRAM_STREAM,
186     SECTION_ID_PROGRAM_TAGS,
187     SECTION_ID_PROGRAM_VERSION,
188     SECTION_ID_PROGRAMS,
189     SECTION_ID_ROOT,
190     SECTION_ID_STREAM,
191     SECTION_ID_STREAM_DISPOSITION,
192     SECTION_ID_STREAMS,
193     SECTION_ID_STREAM_TAGS,
194     SECTION_ID_STREAM_SIDE_DATA_LIST,
195     SECTION_ID_STREAM_SIDE_DATA,
196     SECTION_ID_SUBTITLE,
197 } SectionID;
198
199 static struct section sections[] = {
200     [SECTION_ID_CHAPTERS] =           { SECTION_ID_CHAPTERS, "chapters", SECTION_FLAG_IS_ARRAY, { SECTION_ID_CHAPTER, -1 } },
201     [SECTION_ID_CHAPTER] =            { SECTION_ID_CHAPTER, "chapter", 0, { SECTION_ID_CHAPTER_TAGS, -1 } },
202     [SECTION_ID_CHAPTER_TAGS] =       { SECTION_ID_CHAPTER_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "chapter_tags" },
203     [SECTION_ID_ERROR] =              { SECTION_ID_ERROR, "error", 0, { -1 } },
204     [SECTION_ID_FORMAT] =             { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },
205     [SECTION_ID_FORMAT_TAGS] =        { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },
206     [SECTION_ID_FRAMES] =             { SECTION_ID_FRAMES, "frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, SECTION_ID_SUBTITLE, -1 } },
207     [SECTION_ID_FRAME] =              { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_LOGS, -1 } },
208     [SECTION_ID_FRAME_TAGS] =         { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },
209     [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "frame_side_data_list" },
210     [SECTION_ID_FRAME_SIDE_DATA] =     { SECTION_ID_FRAME_SIDE_DATA, "side_data", 0, { -1 } },
211     [SECTION_ID_FRAME_LOGS] =         { SECTION_ID_FRAME_LOGS, "logs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_LOG, -1 } },
212     [SECTION_ID_FRAME_LOG] =          { SECTION_ID_FRAME_LOG, "log", 0, { -1 },  },
213     [SECTION_ID_LIBRARY_VERSIONS] =   { SECTION_ID_LIBRARY_VERSIONS, "library_versions", SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } },
214     [SECTION_ID_LIBRARY_VERSION] =    { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },
215     [SECTION_ID_PACKETS] =            { SECTION_ID_PACKETS, "packets", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
216     [SECTION_ID_PACKETS_AND_FRAMES] = { SECTION_ID_PACKETS_AND_FRAMES, "packets_and_frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
217     [SECTION_ID_PACKET] =             { SECTION_ID_PACKET, "packet", 0, { SECTION_ID_PACKET_TAGS, SECTION_ID_PACKET_SIDE_DATA_LIST, -1 } },
218     [SECTION_ID_PACKET_TAGS] =        { SECTION_ID_PACKET_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "packet_tags" },
219     [SECTION_ID_PACKET_SIDE_DATA_LIST] ={ SECTION_ID_PACKET_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "packet_side_data_list" },
220     [SECTION_ID_PACKET_SIDE_DATA] =     { SECTION_ID_PACKET_SIDE_DATA, "side_data", 0, { -1 } },
221     [SECTION_ID_PIXEL_FORMATS] =      { SECTION_ID_PIXEL_FORMATS, "pixel_formats", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PIXEL_FORMAT, -1 } },
222     [SECTION_ID_PIXEL_FORMAT] =       { SECTION_ID_PIXEL_FORMAT, "pixel_format", 0, { SECTION_ID_PIXEL_FORMAT_FLAGS, SECTION_ID_PIXEL_FORMAT_COMPONENTS, -1 } },
223     [SECTION_ID_PIXEL_FORMAT_FLAGS] = { SECTION_ID_PIXEL_FORMAT_FLAGS, "flags", 0, { -1 }, .unique_name = "pixel_format_flags" },
224     [SECTION_ID_PIXEL_FORMAT_COMPONENTS] = { SECTION_ID_PIXEL_FORMAT_COMPONENTS, "components", SECTION_FLAG_IS_ARRAY, {SECTION_ID_PIXEL_FORMAT_COMPONENT, -1 }, .unique_name = "pixel_format_components" },
225     [SECTION_ID_PIXEL_FORMAT_COMPONENT]  = { SECTION_ID_PIXEL_FORMAT_COMPONENT, "component", 0, { -1 } },
226     [SECTION_ID_PROGRAM_STREAM_DISPOSITION] = { SECTION_ID_PROGRAM_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "program_stream_disposition" },
227     [SECTION_ID_PROGRAM_STREAM_TAGS] =        { SECTION_ID_PROGRAM_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_stream_tags" },
228     [SECTION_ID_PROGRAM] =                    { SECTION_ID_PROGRAM, "program", 0, { SECTION_ID_PROGRAM_TAGS, SECTION_ID_PROGRAM_STREAMS, -1 } },
229     [SECTION_ID_PROGRAM_STREAMS] =            { SECTION_ID_PROGRAM_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM_STREAM, -1 }, .unique_name = "program_streams" },
230     [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" },
231     [SECTION_ID_PROGRAM_TAGS] =               { SECTION_ID_PROGRAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_tags" },
232     [SECTION_ID_PROGRAM_VERSION] =    { SECTION_ID_PROGRAM_VERSION, "program_version", 0, { -1 } },
233     [SECTION_ID_PROGRAMS] =                   { SECTION_ID_PROGRAMS, "programs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM, -1 } },
234     [SECTION_ID_ROOT] =               { SECTION_ID_ROOT, "root", SECTION_FLAG_IS_WRAPPER,
235                                         { SECTION_ID_CHAPTERS, SECTION_ID_FORMAT, SECTION_ID_FRAMES, SECTION_ID_PROGRAMS, SECTION_ID_STREAMS,
236                                           SECTION_ID_PACKETS, SECTION_ID_ERROR, SECTION_ID_PROGRAM_VERSION, SECTION_ID_LIBRARY_VERSIONS,
237                                           SECTION_ID_PIXEL_FORMATS, -1} },
238     [SECTION_ID_STREAMS] =            { SECTION_ID_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM, -1 } },
239     [SECTION_ID_STREAM] =             { SECTION_ID_STREAM, "stream", 0, { SECTION_ID_STREAM_DISPOSITION, SECTION_ID_STREAM_TAGS, SECTION_ID_STREAM_SIDE_DATA_LIST, -1 } },
240     [SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },
241     [SECTION_ID_STREAM_TAGS] =        { SECTION_ID_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },
242     [SECTION_ID_STREAM_SIDE_DATA_LIST] ={ SECTION_ID_STREAM_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "stream_side_data_list" },
243     [SECTION_ID_STREAM_SIDE_DATA] =     { SECTION_ID_STREAM_SIDE_DATA, "side_data", 0, { -1 } },
244     [SECTION_ID_SUBTITLE] =           { SECTION_ID_SUBTITLE, "subtitle", 0, { -1 } },
245 };
246
247 static const OptionDef *options;
248
249 /* FFprobe context */
250 static const char *input_filename;
251 static AVInputFormat *iformat = NULL;
252
253 static struct AVHashContext *hash;
254
255 static const struct {
256     double bin_val;
257     double dec_val;
258     const char *bin_str;
259     const char *dec_str;
260 } si_prefixes[] = {
261     { 1.0, 1.0, "", "" },
262     { 1.024e3, 1e3, "Ki", "K" },
263     { 1.048576e6, 1e6, "Mi", "M" },
264     { 1.073741824e9, 1e9, "Gi", "G" },
265     { 1.099511627776e12, 1e12, "Ti", "T" },
266     { 1.125899906842624e15, 1e15, "Pi", "P" },
267 };
268
269 static const char unit_second_str[]         = "s"    ;
270 static const char unit_hertz_str[]          = "Hz"   ;
271 static const char unit_byte_str[]           = "byte" ;
272 static const char unit_bit_per_second_str[] = "bit/s";
273
274 static int nb_streams;
275 static uint64_t *nb_streams_packets;
276 static uint64_t *nb_streams_frames;
277 static int *selected_streams;
278
279 #if HAVE_THREADS
280 pthread_mutex_t log_mutex;
281 #endif
282 typedef struct LogBuffer {
283     char *context_name;
284     int log_level;
285     char *log_message;
286     AVClassCategory category;
287     char *parent_name;
288     AVClassCategory parent_category;
289 }LogBuffer;
290
291 static LogBuffer *log_buffer;
292 static int log_buffer_size;
293
294 static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
295 {
296     AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
297     va_list vl2;
298     char line[1024];
299     static int print_prefix = 1;
300     void *new_log_buffer;
301
302     va_copy(vl2, vl);
303     av_log_default_callback(ptr, level, fmt, vl);
304     av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
305     va_end(vl2);
306
307 #if HAVE_THREADS
308     pthread_mutex_lock(&log_mutex);
309
310     new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer));
311     if (new_log_buffer) {
312         char *msg;
313         int i;
314
315         log_buffer = new_log_buffer;
316         memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size]));
317         log_buffer[log_buffer_size].context_name= avc ? av_strdup(avc->item_name(ptr)) : NULL;
318         if (avc) {
319             if (avc->get_category) log_buffer[log_buffer_size].category = avc->get_category(ptr);
320             else                   log_buffer[log_buffer_size].category = avc->category;
321         }
322         log_buffer[log_buffer_size].log_level   = level;
323         msg = log_buffer[log_buffer_size].log_message = av_strdup(line);
324         for (i=strlen(msg) - 1; i>=0 && msg[i] == '\n'; i--) {
325             msg[i] = 0;
326         }
327         if (avc && avc->parent_log_context_offset) {
328             AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
329                                    avc->parent_log_context_offset);
330             if (parent && *parent) {
331                 log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent));
332                 log_buffer[log_buffer_size].parent_category =
333                     (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category;
334             }
335         }
336         log_buffer_size ++;
337     }
338
339     pthread_mutex_unlock(&log_mutex);
340 #endif
341 }
342
343 static void ffprobe_cleanup(int ret)
344 {
345     int i;
346     for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
347         av_dict_free(&(sections[i].entries_to_show));
348
349 #if HAVE_THREADS
350     pthread_mutex_destroy(&log_mutex);
351 #endif
352 }
353
354 struct unit_value {
355     union { double d; long long int i; } val;
356     const char *unit;
357 };
358
359 static char *value_string(char *buf, int buf_size, struct unit_value uv)
360 {
361     double vald;
362     long long int vali;
363     int show_float = 0;
364
365     if (uv.unit == unit_second_str) {
366         vald = uv.val.d;
367         show_float = 1;
368     } else {
369         vald = vali = uv.val.i;
370     }
371
372     if (uv.unit == unit_second_str && use_value_sexagesimal_format) {
373         double secs;
374         int hours, mins;
375         secs  = vald;
376         mins  = (int)secs / 60;
377         secs  = secs - mins * 60;
378         hours = mins / 60;
379         mins %= 60;
380         snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
381     } else {
382         const char *prefix_string = "";
383
384         if (use_value_prefix && vald > 1) {
385             long long int index;
386
387             if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
388                 index = (long long int) (log2(vald)) / 10;
389                 index = av_clip(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
390                 vald /= si_prefixes[index].bin_val;
391                 prefix_string = si_prefixes[index].bin_str;
392             } else {
393                 index = (long long int) (log10(vald)) / 3;
394                 index = av_clip(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
395                 vald /= si_prefixes[index].dec_val;
396                 prefix_string = si_prefixes[index].dec_str;
397             }
398             vali = vald;
399         }
400
401         if (show_float || (use_value_prefix && vald != (long long int)vald))
402             snprintf(buf, buf_size, "%f", vald);
403         else
404             snprintf(buf, buf_size, "%lld", vali);
405         av_strlcatf(buf, buf_size, "%s%s%s", *prefix_string || show_value_unit ? " " : "",
406                  prefix_string, show_value_unit ? uv.unit : "");
407     }
408
409     return buf;
410 }
411
412 /* WRITERS API */
413
414 typedef struct WriterContext WriterContext;
415
416 #define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1
417 #define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2
418
419 typedef enum {
420     WRITER_STRING_VALIDATION_FAIL,
421     WRITER_STRING_VALIDATION_REPLACE,
422     WRITER_STRING_VALIDATION_IGNORE,
423     WRITER_STRING_VALIDATION_NB
424 } StringValidation;
425
426 typedef struct Writer {
427     const AVClass *priv_class;      ///< private class of the writer, if any
428     int priv_size;                  ///< private size for the writer context
429     const char *name;
430
431     int  (*init)  (WriterContext *wctx);
432     void (*uninit)(WriterContext *wctx);
433
434     void (*print_section_header)(WriterContext *wctx);
435     void (*print_section_footer)(WriterContext *wctx);
436     void (*print_integer)       (WriterContext *wctx, const char *, long long int);
437     void (*print_rational)      (WriterContext *wctx, AVRational *q, char *sep);
438     void (*print_string)        (WriterContext *wctx, const char *, const char *);
439     int flags;                  ///< a combination or WRITER_FLAG_*
440 } Writer;
441
442 #define SECTION_MAX_NB_LEVELS 10
443
444 struct WriterContext {
445     const AVClass *class;           ///< class of the writer
446     const Writer *writer;           ///< the Writer of which this is an instance
447     char *name;                     ///< name of this writer instance
448     void *priv;                     ///< private data for use by the filter
449
450     const struct section *sections; ///< array containing all sections
451     int nb_sections;                ///< number of sections
452
453     int level;                      ///< current level, starting from 0
454
455     /** number of the item printed in the given section, starting from 0 */
456     unsigned int nb_item[SECTION_MAX_NB_LEVELS];
457
458     /** section per each level */
459     const struct section *section[SECTION_MAX_NB_LEVELS];
460     AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]; ///< generic print buffer dedicated to each section,
461                                                   ///  used by various writers
462
463     unsigned int nb_section_packet; ///< number of the packet section in case we are in "packets_and_frames" section
464     unsigned int nb_section_frame;  ///< number of the frame  section in case we are in "packets_and_frames" section
465     unsigned int nb_section_packet_frame; ///< nb_section_packet or nb_section_frame according if is_packets_and_frames
466
467     int string_validation;
468     char *string_validation_replacement;
469     unsigned int string_validation_utf8_flags;
470 };
471
472 static const char *writer_get_name(void *p)
473 {
474     WriterContext *wctx = p;
475     return wctx->writer->name;
476 }
477
478 #define OFFSET(x) offsetof(WriterContext, x)
479
480 static const AVOption writer_options[] = {
481     { "string_validation", "set string validation mode",
482       OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
483     { "sv", "set string validation mode",
484       OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
485     { "ignore",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_IGNORE},  .unit = "sv" },
486     { "replace", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_REPLACE}, .unit = "sv" },
487     { "fail",    NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_FAIL},    .unit = "sv" },
488     { "string_validation_replacement", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str=""}},
489     { "svr", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str="\xEF\xBF\xBD"}},
490     { NULL }
491 };
492
493 static void *writer_child_next(void *obj, void *prev)
494 {
495     WriterContext *ctx = obj;
496     if (!prev && ctx->writer && ctx->writer->priv_class && ctx->priv)
497         return ctx->priv;
498     return NULL;
499 }
500
501 static const AVClass writer_class = {
502     .class_name = "Writer",
503     .item_name  = writer_get_name,
504     .option     = writer_options,
505     .version    = LIBAVUTIL_VERSION_INT,
506     .child_next = writer_child_next,
507 };
508
509 static void writer_close(WriterContext **wctx)
510 {
511     int i;
512
513     if (!*wctx)
514         return;
515
516     if ((*wctx)->writer->uninit)
517         (*wctx)->writer->uninit(*wctx);
518     for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
519         av_bprint_finalize(&(*wctx)->section_pbuf[i], NULL);
520     if ((*wctx)->writer->priv_class)
521         av_opt_free((*wctx)->priv);
522     av_freep(&((*wctx)->priv));
523     av_opt_free(*wctx);
524     av_freep(wctx);
525 }
526
527 static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
528 {
529     int i;
530     av_bprintf(bp, "0X");
531     for (i = 0; i < ubuf_size; i++)
532         av_bprintf(bp, "%02X", ubuf[i]);
533 }
534
535
536 static int writer_open(WriterContext **wctx, const Writer *writer, const char *args,
537                        const struct section *sections, int nb_sections)
538 {
539     int i, ret = 0;
540
541     if (!(*wctx = av_mallocz(sizeof(WriterContext)))) {
542         ret = AVERROR(ENOMEM);
543         goto fail;
544     }
545
546     if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
547         ret = AVERROR(ENOMEM);
548         goto fail;
549     }
550
551     (*wctx)->class = &writer_class;
552     (*wctx)->writer = writer;
553     (*wctx)->level = -1;
554     (*wctx)->sections = sections;
555     (*wctx)->nb_sections = nb_sections;
556
557     av_opt_set_defaults(*wctx);
558
559     if (writer->priv_class) {
560         void *priv_ctx = (*wctx)->priv;
561         *((const AVClass **)priv_ctx) = writer->priv_class;
562         av_opt_set_defaults(priv_ctx);
563     }
564
565     /* convert options to dictionary */
566     if (args) {
567         AVDictionary *opts = NULL;
568         AVDictionaryEntry *opt = NULL;
569
570         if ((ret = av_dict_parse_string(&opts, args, "=", ":", 0)) < 0) {
571             av_log(*wctx, AV_LOG_ERROR, "Failed to parse option string '%s' provided to writer context\n", args);
572             av_dict_free(&opts);
573             goto fail;
574         }
575
576         while ((opt = av_dict_get(opts, "", opt, AV_DICT_IGNORE_SUFFIX))) {
577             if ((ret = av_opt_set(*wctx, opt->key, opt->value, AV_OPT_SEARCH_CHILDREN)) < 0) {
578                 av_log(*wctx, AV_LOG_ERROR, "Failed to set option '%s' with value '%s' provided to writer context\n",
579                        opt->key, opt->value);
580                 av_dict_free(&opts);
581                 goto fail;
582             }
583         }
584
585         av_dict_free(&opts);
586     }
587
588     /* validate replace string */
589     {
590         const uint8_t *p = (*wctx)->string_validation_replacement;
591         const uint8_t *endp = p + strlen(p);
592         while (*p) {
593             const uint8_t *p0 = p;
594             int32_t code;
595             ret = av_utf8_decode(&code, &p, endp, (*wctx)->string_validation_utf8_flags);
596             if (ret < 0) {
597                 AVBPrint bp;
598                 av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
599                 bprint_bytes(&bp, p0, p-p0),
600                     av_log(wctx, AV_LOG_ERROR,
601                            "Invalid UTF8 sequence %s found in string validation replace '%s'\n",
602                            bp.str, (*wctx)->string_validation_replacement);
603                 return ret;
604             }
605         }
606     }
607
608     for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
609         av_bprint_init(&(*wctx)->section_pbuf[i], 1, AV_BPRINT_SIZE_UNLIMITED);
610
611     if ((*wctx)->writer->init)
612         ret = (*wctx)->writer->init(*wctx);
613     if (ret < 0)
614         goto fail;
615
616     return 0;
617
618 fail:
619     writer_close(wctx);
620     return ret;
621 }
622
623 static inline void writer_print_section_header(WriterContext *wctx,
624                                                int section_id)
625 {
626     int parent_section_id;
627     wctx->level++;
628     av_assert0(wctx->level < SECTION_MAX_NB_LEVELS);
629     parent_section_id = wctx->level ?
630         (wctx->section[wctx->level-1])->id : SECTION_ID_NONE;
631
632     wctx->nb_item[wctx->level] = 0;
633     wctx->section[wctx->level] = &wctx->sections[section_id];
634
635     if (section_id == SECTION_ID_PACKETS_AND_FRAMES) {
636         wctx->nb_section_packet = wctx->nb_section_frame =
637         wctx->nb_section_packet_frame = 0;
638     } else if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
639         wctx->nb_section_packet_frame = section_id == SECTION_ID_PACKET ?
640             wctx->nb_section_packet : wctx->nb_section_frame;
641     }
642
643     if (wctx->writer->print_section_header)
644         wctx->writer->print_section_header(wctx);
645 }
646
647 static inline void writer_print_section_footer(WriterContext *wctx)
648 {
649     int section_id = wctx->section[wctx->level]->id;
650     int parent_section_id = wctx->level ?
651         wctx->section[wctx->level-1]->id : SECTION_ID_NONE;
652
653     if (parent_section_id != SECTION_ID_NONE)
654         wctx->nb_item[wctx->level-1]++;
655     if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
656         if (section_id == SECTION_ID_PACKET) wctx->nb_section_packet++;
657         else                                     wctx->nb_section_frame++;
658     }
659     if (wctx->writer->print_section_footer)
660         wctx->writer->print_section_footer(wctx);
661     wctx->level--;
662 }
663
664 static inline void writer_print_integer(WriterContext *wctx,
665                                         const char *key, long long int val)
666 {
667     const struct section *section = wctx->section[wctx->level];
668
669     if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {
670         wctx->writer->print_integer(wctx, key, val);
671         wctx->nb_item[wctx->level]++;
672     }
673 }
674
675 static inline int validate_string(WriterContext *wctx, char **dstp, const char *src)
676 {
677     const uint8_t *p, *endp;
678     AVBPrint dstbuf;
679     int invalid_chars_nb = 0, ret = 0;
680
681     av_bprint_init(&dstbuf, 0, AV_BPRINT_SIZE_UNLIMITED);
682
683     endp = src + strlen(src);
684     for (p = (uint8_t *)src; *p;) {
685         uint32_t code;
686         int invalid = 0;
687         const uint8_t *p0 = p;
688
689         if (av_utf8_decode(&code, &p, endp, wctx->string_validation_utf8_flags) < 0) {
690             AVBPrint bp;
691             av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
692             bprint_bytes(&bp, p0, p-p0);
693             av_log(wctx, AV_LOG_DEBUG,
694                    "Invalid UTF-8 sequence %s found in string '%s'\n", bp.str, src);
695             invalid = 1;
696         }
697
698         if (invalid) {
699             invalid_chars_nb++;
700
701             switch (wctx->string_validation) {
702             case WRITER_STRING_VALIDATION_FAIL:
703                 av_log(wctx, AV_LOG_ERROR,
704                        "Invalid UTF-8 sequence found in string '%s'\n", src);
705                 ret = AVERROR_INVALIDDATA;
706                 goto end;
707                 break;
708
709             case WRITER_STRING_VALIDATION_REPLACE:
710                 av_bprintf(&dstbuf, "%s", wctx->string_validation_replacement);
711                 break;
712             }
713         }
714
715         if (!invalid || wctx->string_validation == WRITER_STRING_VALIDATION_IGNORE)
716             av_bprint_append_data(&dstbuf, p0, p-p0);
717     }
718
719     if (invalid_chars_nb && wctx->string_validation == WRITER_STRING_VALIDATION_REPLACE) {
720         av_log(wctx, AV_LOG_WARNING,
721                "%d invalid UTF-8 sequence(s) found in string '%s', replaced with '%s'\n",
722                invalid_chars_nb, src, wctx->string_validation_replacement);
723     }
724
725 end:
726     av_bprint_finalize(&dstbuf, dstp);
727     return ret;
728 }
729
730 #define PRINT_STRING_OPT      1
731 #define PRINT_STRING_VALIDATE 2
732
733 static inline int writer_print_string(WriterContext *wctx,
734                                       const char *key, const char *val, int flags)
735 {
736     const struct section *section = wctx->section[wctx->level];
737     int ret = 0;
738
739     if ((flags & PRINT_STRING_OPT)
740         && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS))
741         return 0;
742
743     if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {
744         if (flags & PRINT_STRING_VALIDATE) {
745             char *key1 = NULL, *val1 = NULL;
746             ret = validate_string(wctx, &key1, key);
747             if (ret < 0) goto end;
748             ret = validate_string(wctx, &val1, val);
749             if (ret < 0) goto end;
750             wctx->writer->print_string(wctx, key1, val1);
751         end:
752             if (ret < 0) {
753                 av_log(wctx, AV_LOG_ERROR,
754                        "Invalid key=value string combination %s=%s in section %s\n",
755                        key, val, section->unique_name);
756             }
757             av_free(key1);
758             av_free(val1);
759         } else {
760             wctx->writer->print_string(wctx, key, val);
761         }
762
763         wctx->nb_item[wctx->level]++;
764     }
765
766     return ret;
767 }
768
769 static inline void writer_print_rational(WriterContext *wctx,
770                                          const char *key, AVRational q, char sep)
771 {
772     AVBPrint buf;
773     av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
774     av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);
775     writer_print_string(wctx, key, buf.str, 0);
776 }
777
778 static void writer_print_time(WriterContext *wctx, const char *key,
779                               int64_t ts, const AVRational *time_base, int is_duration)
780 {
781     char buf[128];
782
783     if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
784         writer_print_string(wctx, key, "N/A", PRINT_STRING_OPT);
785     } else {
786         double d = ts * av_q2d(*time_base);
787         struct unit_value uv;
788         uv.val.d = d;
789         uv.unit = unit_second_str;
790         value_string(buf, sizeof(buf), uv);
791         writer_print_string(wctx, key, buf, 0);
792     }
793 }
794
795 static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
796 {
797     if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
798         writer_print_string(wctx, key, "N/A", PRINT_STRING_OPT);
799     } else {
800         writer_print_integer(wctx, key, ts);
801     }
802 }
803
804 static void writer_print_data(WriterContext *wctx, const char *name,
805                               uint8_t *data, int size)
806 {
807     AVBPrint bp;
808     int offset = 0, l, i;
809
810     av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
811     av_bprintf(&bp, "\n");
812     while (size) {
813         av_bprintf(&bp, "%08x: ", offset);
814         l = FFMIN(size, 16);
815         for (i = 0; i < l; i++) {
816             av_bprintf(&bp, "%02x", data[i]);
817             if (i & 1)
818                 av_bprintf(&bp, " ");
819         }
820         av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);
821         for (i = 0; i < l; i++)
822             av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);
823         av_bprintf(&bp, "\n");
824         offset += l;
825         data   += l;
826         size   -= l;
827     }
828     writer_print_string(wctx, name, bp.str, 0);
829     av_bprint_finalize(&bp, NULL);
830 }
831
832 static void writer_print_data_hash(WriterContext *wctx, const char *name,
833                                    uint8_t *data, int size)
834 {
835     char *p, buf[AV_HASH_MAX_SIZE * 2 + 64] = { 0 };
836
837     if (!hash)
838         return;
839     av_hash_init(hash);
840     av_hash_update(hash, data, size);
841     snprintf(buf, sizeof(buf), "%s:", av_hash_get_name(hash));
842     p = buf + strlen(buf);
843     av_hash_final_hex(hash, p, buf + sizeof(buf) - p);
844     writer_print_string(wctx, name, buf, 0);
845 }
846
847 static void writer_print_integers(WriterContext *wctx, const char *name,
848                                   uint8_t *data, int size, const char *format,
849                                   int columns, int bytes, int offset_add)
850 {
851     AVBPrint bp;
852     int offset = 0, l, i;
853
854     av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
855     av_bprintf(&bp, "\n");
856     while (size) {
857         av_bprintf(&bp, "%08x: ", offset);
858         l = FFMIN(size, columns);
859         for (i = 0; i < l; i++) {
860             if      (bytes == 1) av_bprintf(&bp, format, *data);
861             else if (bytes == 2) av_bprintf(&bp, format, AV_RN16(data));
862             else if (bytes == 4) av_bprintf(&bp, format, AV_RN32(data));
863             data += bytes;
864             size --;
865         }
866         av_bprintf(&bp, "\n");
867         offset += offset_add;
868     }
869     writer_print_string(wctx, name, bp.str, 0);
870     av_bprint_finalize(&bp, NULL);
871 }
872
873 #define MAX_REGISTERED_WRITERS_NB 64
874
875 static const Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];
876
877 static int writer_register(const Writer *writer)
878 {
879     static int next_registered_writer_idx = 0;
880
881     if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)
882         return AVERROR(ENOMEM);
883
884     registered_writers[next_registered_writer_idx++] = writer;
885     return 0;
886 }
887
888 static const Writer *writer_get_by_name(const char *name)
889 {
890     int i;
891
892     for (i = 0; registered_writers[i]; i++)
893         if (!strcmp(registered_writers[i]->name, name))
894             return registered_writers[i];
895
896     return NULL;
897 }
898
899
900 /* WRITERS */
901
902 #define DEFINE_WRITER_CLASS(name)                   \
903 static const char *name##_get_name(void *ctx)       \
904 {                                                   \
905     return #name ;                                  \
906 }                                                   \
907 static const AVClass name##_class = {               \
908     .class_name = #name,                            \
909     .item_name  = name##_get_name,                  \
910     .option     = name##_options                    \
911 }
912
913 /* Default output */
914
915 typedef struct DefaultContext {
916     const AVClass *class;
917     int nokey;
918     int noprint_wrappers;
919     int nested_section[SECTION_MAX_NB_LEVELS];
920 } DefaultContext;
921
922 #undef OFFSET
923 #define OFFSET(x) offsetof(DefaultContext, x)
924
925 static const AVOption default_options[] = {
926     { "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
927     { "nw",               "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
928     { "nokey",          "force no key printing",     OFFSET(nokey),          AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
929     { "nk",             "force no key printing",     OFFSET(nokey),          AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
930     {NULL},
931 };
932
933 DEFINE_WRITER_CLASS(default);
934
935 /* lame uppercasing routine, assumes the string is lower case ASCII */
936 static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
937 {
938     int i;
939     for (i = 0; src[i] && i < dst_size-1; i++)
940         dst[i] = av_toupper(src[i]);
941     dst[i] = 0;
942     return dst;
943 }
944
945 static void default_print_section_header(WriterContext *wctx)
946 {
947     DefaultContext *def = wctx->priv;
948     char buf[32];
949     const struct section *section = wctx->section[wctx->level];
950     const struct section *parent_section = wctx->level ?
951         wctx->section[wctx->level-1] : NULL;
952
953     av_bprint_clear(&wctx->section_pbuf[wctx->level]);
954     if (parent_section &&
955         !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
956         def->nested_section[wctx->level] = 1;
957         av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
958                    wctx->section_pbuf[wctx->level-1].str,
959                    upcase_string(buf, sizeof(buf),
960                                  av_x_if_null(section->element_name, section->name)));
961     }
962
963     if (def->noprint_wrappers || def->nested_section[wctx->level])
964         return;
965
966     if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
967         printf("[%s]\n", upcase_string(buf, sizeof(buf), section->name));
968 }
969
970 static void default_print_section_footer(WriterContext *wctx)
971 {
972     DefaultContext *def = wctx->priv;
973     const struct section *section = wctx->section[wctx->level];
974     char buf[32];
975
976     if (def->noprint_wrappers || def->nested_section[wctx->level])
977         return;
978
979     if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
980         printf("[/%s]\n", upcase_string(buf, sizeof(buf), section->name));
981 }
982
983 static void default_print_str(WriterContext *wctx, const char *key, const char *value)
984 {
985     DefaultContext *def = wctx->priv;
986
987     if (!def->nokey)
988         printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
989     printf("%s\n", value);
990 }
991
992 static void default_print_int(WriterContext *wctx, const char *key, long long int value)
993 {
994     DefaultContext *def = wctx->priv;
995
996     if (!def->nokey)
997         printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
998     printf("%lld\n", value);
999 }
1000
1001 static const Writer default_writer = {
1002     .name                  = "default",
1003     .priv_size             = sizeof(DefaultContext),
1004     .print_section_header  = default_print_section_header,
1005     .print_section_footer  = default_print_section_footer,
1006     .print_integer         = default_print_int,
1007     .print_string          = default_print_str,
1008     .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
1009     .priv_class            = &default_class,
1010 };
1011
1012 /* Compact output */
1013
1014 /**
1015  * Apply C-language-like string escaping.
1016  */
1017 static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1018 {
1019     const char *p;
1020
1021     for (p = src; *p; p++) {
1022         switch (*p) {
1023         case '\b': av_bprintf(dst, "%s", "\\b");  break;
1024         case '\f': av_bprintf(dst, "%s", "\\f");  break;
1025         case '\n': av_bprintf(dst, "%s", "\\n");  break;
1026         case '\r': av_bprintf(dst, "%s", "\\r");  break;
1027         case '\\': av_bprintf(dst, "%s", "\\\\"); break;
1028         default:
1029             if (*p == sep)
1030                 av_bprint_chars(dst, '\\', 1);
1031             av_bprint_chars(dst, *p, 1);
1032         }
1033     }
1034     return dst->str;
1035 }
1036
1037 /**
1038  * Quote fields containing special characters, check RFC4180.
1039  */
1040 static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1041 {
1042     char meta_chars[] = { sep, '"', '\n', '\r', '\0' };
1043     int needs_quoting = !!src[strcspn(src, meta_chars)];
1044
1045     if (needs_quoting)
1046         av_bprint_chars(dst, '"', 1);
1047
1048     for (; *src; src++) {
1049         if (*src == '"')
1050             av_bprint_chars(dst, '"', 1);
1051         av_bprint_chars(dst, *src, 1);
1052     }
1053     if (needs_quoting)
1054         av_bprint_chars(dst, '"', 1);
1055     return dst->str;
1056 }
1057
1058 static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
1059 {
1060     return src;
1061 }
1062
1063 typedef struct CompactContext {
1064     const AVClass *class;
1065     char *item_sep_str;
1066     char item_sep;
1067     int nokey;
1068     int print_section;
1069     char *escape_mode_str;
1070     const char * (*escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx);
1071     int nested_section[SECTION_MAX_NB_LEVELS];
1072     int has_nested_elems[SECTION_MAX_NB_LEVELS];
1073     int terminate_line[SECTION_MAX_NB_LEVELS];
1074 } CompactContext;
1075
1076 #undef OFFSET
1077 #define OFFSET(x) offsetof(CompactContext, x)
1078
1079 static const AVOption compact_options[]= {
1080     {"item_sep", "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str="|"},  CHAR_MIN, CHAR_MAX },
1081     {"s",        "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str="|"},  CHAR_MIN, CHAR_MAX },
1082     {"nokey",    "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_BOOL,   {.i64=0},    0,        1        },
1083     {"nk",       "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_BOOL,   {.i64=0},    0,        1        },
1084     {"escape",   "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"},  CHAR_MIN, CHAR_MAX },
1085     {"e",        "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"},  CHAR_MIN, CHAR_MAX },
1086     {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL,   {.i64=1},    0,        1        },
1087     {"p",             "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL,   {.i64=1},    0,        1        },
1088     {NULL},
1089 };
1090
1091 DEFINE_WRITER_CLASS(compact);
1092
1093 static av_cold int compact_init(WriterContext *wctx)
1094 {
1095     CompactContext *compact = wctx->priv;
1096
1097     if (strlen(compact->item_sep_str) != 1) {
1098         av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
1099                compact->item_sep_str);
1100         return AVERROR(EINVAL);
1101     }
1102     compact->item_sep = compact->item_sep_str[0];
1103
1104     if      (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;
1105     else if (!strcmp(compact->escape_mode_str, "c"   )) compact->escape_str = c_escape_str;
1106     else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;
1107     else {
1108         av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);
1109         return AVERROR(EINVAL);
1110     }
1111
1112     return 0;
1113 }
1114
1115 static void compact_print_section_header(WriterContext *wctx)
1116 {
1117     CompactContext *compact = wctx->priv;
1118     const struct section *section = wctx->section[wctx->level];
1119     const struct section *parent_section = wctx->level ?
1120         wctx->section[wctx->level-1] : NULL;
1121     compact->terminate_line[wctx->level] = 1;
1122     compact->has_nested_elems[wctx->level] = 0;
1123
1124     av_bprint_clear(&wctx->section_pbuf[wctx->level]);
1125     if (!(section->flags & SECTION_FLAG_IS_ARRAY) && parent_section &&
1126         !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
1127         compact->nested_section[wctx->level] = 1;
1128         compact->has_nested_elems[wctx->level-1] = 1;
1129         av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
1130                    wctx->section_pbuf[wctx->level-1].str,
1131                    (char *)av_x_if_null(section->element_name, section->name));
1132         wctx->nb_item[wctx->level] = wctx->nb_item[wctx->level-1];
1133     } else {
1134         if (parent_section && compact->has_nested_elems[wctx->level-1] &&
1135             (section->flags & SECTION_FLAG_IS_ARRAY)) {
1136             compact->terminate_line[wctx->level-1] = 0;
1137             printf("\n");
1138         }
1139         if (compact->print_section &&
1140             !(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
1141             printf("%s%c", section->name, compact->item_sep);
1142     }
1143 }
1144
1145 static void compact_print_section_footer(WriterContext *wctx)
1146 {
1147     CompactContext *compact = wctx->priv;
1148
1149     if (!compact->nested_section[wctx->level] &&
1150         compact->terminate_line[wctx->level] &&
1151         !(wctx->section[wctx->level]->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
1152         printf("\n");
1153 }
1154
1155 static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
1156 {
1157     CompactContext *compact = wctx->priv;
1158     AVBPrint buf;
1159
1160     if (wctx->nb_item[wctx->level]) printf("%c", compact->item_sep);
1161     if (!compact->nokey)
1162         printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
1163     av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1164     printf("%s", compact->escape_str(&buf, value, compact->item_sep, wctx));
1165     av_bprint_finalize(&buf, NULL);
1166 }
1167
1168 static void compact_print_int(WriterContext *wctx, const char *key, long long int value)
1169 {
1170     CompactContext *compact = wctx->priv;
1171
1172     if (wctx->nb_item[wctx->level]) printf("%c", compact->item_sep);
1173     if (!compact->nokey)
1174         printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);
1175     printf("%lld", value);
1176 }
1177
1178 static const Writer compact_writer = {
1179     .name                 = "compact",
1180     .priv_size            = sizeof(CompactContext),
1181     .init                 = compact_init,
1182     .print_section_header = compact_print_section_header,
1183     .print_section_footer = compact_print_section_footer,
1184     .print_integer        = compact_print_int,
1185     .print_string         = compact_print_str,
1186     .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
1187     .priv_class           = &compact_class,
1188 };
1189
1190 /* CSV output */
1191
1192 #undef OFFSET
1193 #define OFFSET(x) offsetof(CompactContext, x)
1194
1195 static const AVOption csv_options[] = {
1196     {"item_sep", "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str=","},  CHAR_MIN, CHAR_MAX },
1197     {"s",        "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str=","},  CHAR_MIN, CHAR_MAX },
1198     {"nokey",    "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_BOOL,   {.i64=1},    0,        1        },
1199     {"nk",       "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_BOOL,   {.i64=1},    0,        1        },
1200     {"escape",   "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, CHAR_MIN, CHAR_MAX },
1201     {"e",        "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, CHAR_MIN, CHAR_MAX },
1202     {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL,   {.i64=1},    0,        1        },
1203     {"p",             "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL,   {.i64=1},    0,        1        },
1204     {NULL},
1205 };
1206
1207 DEFINE_WRITER_CLASS(csv);
1208
1209 static const Writer csv_writer = {
1210     .name                 = "csv",
1211     .priv_size            = sizeof(CompactContext),
1212     .init                 = compact_init,
1213     .print_section_header = compact_print_section_header,
1214     .print_section_footer = compact_print_section_footer,
1215     .print_integer        = compact_print_int,
1216     .print_string         = compact_print_str,
1217     .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
1218     .priv_class           = &csv_class,
1219 };
1220
1221 /* Flat output */
1222
1223 typedef struct FlatContext {
1224     const AVClass *class;
1225     const char *sep_str;
1226     char sep;
1227     int hierarchical;
1228 } FlatContext;
1229
1230 #undef OFFSET
1231 #define OFFSET(x) offsetof(FlatContext, x)
1232
1233 static const AVOption flat_options[]= {
1234     {"sep_char", "set separator",    OFFSET(sep_str),    AV_OPT_TYPE_STRING, {.str="."},  CHAR_MIN, CHAR_MAX },
1235     {"s",        "set separator",    OFFSET(sep_str),    AV_OPT_TYPE_STRING, {.str="."},  CHAR_MIN, CHAR_MAX },
1236     {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1237     {"h",            "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1238     {NULL},
1239 };
1240
1241 DEFINE_WRITER_CLASS(flat);
1242
1243 static av_cold int flat_init(WriterContext *wctx)
1244 {
1245     FlatContext *flat = wctx->priv;
1246
1247     if (strlen(flat->sep_str) != 1) {
1248         av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
1249                flat->sep_str);
1250         return AVERROR(EINVAL);
1251     }
1252     flat->sep = flat->sep_str[0];
1253
1254     return 0;
1255 }
1256
1257 static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
1258 {
1259     const char *p;
1260
1261     for (p = src; *p; p++) {
1262         if (!((*p >= '0' && *p <= '9') ||
1263               (*p >= 'a' && *p <= 'z') ||
1264               (*p >= 'A' && *p <= 'Z')))
1265             av_bprint_chars(dst, '_', 1);
1266         else
1267             av_bprint_chars(dst, *p, 1);
1268     }
1269     return dst->str;
1270 }
1271
1272 static const char *flat_escape_value_str(AVBPrint *dst, const char *src)
1273 {
1274     const char *p;
1275
1276     for (p = src; *p; p++) {
1277         switch (*p) {
1278         case '\n': av_bprintf(dst, "%s", "\\n");  break;
1279         case '\r': av_bprintf(dst, "%s", "\\r");  break;
1280         case '\\': av_bprintf(dst, "%s", "\\\\"); break;
1281         case '"':  av_bprintf(dst, "%s", "\\\""); break;
1282         case '`':  av_bprintf(dst, "%s", "\\`");  break;
1283         case '$':  av_bprintf(dst, "%s", "\\$");  break;
1284         default:   av_bprint_chars(dst, *p, 1);   break;
1285         }
1286     }
1287     return dst->str;
1288 }
1289
1290 static void flat_print_section_header(WriterContext *wctx)
1291 {
1292     FlatContext *flat = wctx->priv;
1293     AVBPrint *buf = &wctx->section_pbuf[wctx->level];
1294     const struct section *section = wctx->section[wctx->level];
1295     const struct section *parent_section = wctx->level ?
1296         wctx->section[wctx->level-1] : NULL;
1297
1298     /* build section header */
1299     av_bprint_clear(buf);
1300     if (!parent_section)
1301         return;
1302     av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
1303
1304     if (flat->hierarchical ||
1305         !(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {
1306         av_bprintf(buf, "%s%s", wctx->section[wctx->level]->name, flat->sep_str);
1307
1308         if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
1309             int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
1310                 wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
1311             av_bprintf(buf, "%d%s", n, flat->sep_str);
1312         }
1313     }
1314 }
1315
1316 static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
1317 {
1318     printf("%s%s=%lld\n", wctx->section_pbuf[wctx->level].str, key, value);
1319 }
1320
1321 static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
1322 {
1323     FlatContext *flat = wctx->priv;
1324     AVBPrint buf;
1325
1326     printf("%s", wctx->section_pbuf[wctx->level].str);
1327     av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1328     printf("%s=", flat_escape_key_str(&buf, key, flat->sep));
1329     av_bprint_clear(&buf);
1330     printf("\"%s\"\n", flat_escape_value_str(&buf, value));
1331     av_bprint_finalize(&buf, NULL);
1332 }
1333
1334 static const Writer flat_writer = {
1335     .name                  = "flat",
1336     .priv_size             = sizeof(FlatContext),
1337     .init                  = flat_init,
1338     .print_section_header  = flat_print_section_header,
1339     .print_integer         = flat_print_int,
1340     .print_string          = flat_print_str,
1341     .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1342     .priv_class            = &flat_class,
1343 };
1344
1345 /* INI format output */
1346
1347 typedef struct INIContext {
1348     const AVClass *class;
1349     int hierarchical;
1350 } INIContext;
1351
1352 #undef OFFSET
1353 #define OFFSET(x) offsetof(INIContext, x)
1354
1355 static const AVOption ini_options[] = {
1356     {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1357     {"h",            "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
1358     {NULL},
1359 };
1360
1361 DEFINE_WRITER_CLASS(ini);
1362
1363 static char *ini_escape_str(AVBPrint *dst, const char *src)
1364 {
1365     int i = 0;
1366     char c = 0;
1367
1368     while (c = src[i++]) {
1369         switch (c) {
1370         case '\b': av_bprintf(dst, "%s", "\\b"); break;
1371         case '\f': av_bprintf(dst, "%s", "\\f"); break;
1372         case '\n': av_bprintf(dst, "%s", "\\n"); break;
1373         case '\r': av_bprintf(dst, "%s", "\\r"); break;
1374         case '\t': av_bprintf(dst, "%s", "\\t"); break;
1375         case '\\':
1376         case '#' :
1377         case '=' :
1378         case ':' : av_bprint_chars(dst, '\\', 1);
1379         default:
1380             if ((unsigned char)c < 32)
1381                 av_bprintf(dst, "\\x00%02x", c & 0xff);
1382             else
1383                 av_bprint_chars(dst, c, 1);
1384             break;
1385         }
1386     }
1387     return dst->str;
1388 }
1389
1390 static void ini_print_section_header(WriterContext *wctx)
1391 {
1392     INIContext *ini = wctx->priv;
1393     AVBPrint *buf = &wctx->section_pbuf[wctx->level];
1394     const struct section *section = wctx->section[wctx->level];
1395     const struct section *parent_section = wctx->level ?
1396         wctx->section[wctx->level-1] : NULL;
1397
1398     av_bprint_clear(buf);
1399     if (!parent_section) {
1400         printf("# ffprobe output\n\n");
1401         return;
1402     }
1403
1404     if (wctx->nb_item[wctx->level-1])
1405         printf("\n");
1406
1407     av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
1408     if (ini->hierarchical ||
1409         !(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {
1410         av_bprintf(buf, "%s%s", buf->str[0] ? "." : "", wctx->section[wctx->level]->name);
1411
1412         if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
1413             int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
1414                 wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
1415             av_bprintf(buf, ".%d", n);
1416         }
1417     }
1418
1419     if (!(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER)))
1420         printf("[%s]\n", buf->str);
1421 }
1422
1423 static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
1424 {
1425     AVBPrint buf;
1426
1427     av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1428     printf("%s=", ini_escape_str(&buf, key));
1429     av_bprint_clear(&buf);
1430     printf("%s\n", ini_escape_str(&buf, value));
1431     av_bprint_finalize(&buf, NULL);
1432 }
1433
1434 static void ini_print_int(WriterContext *wctx, const char *key, long long int value)
1435 {
1436     printf("%s=%lld\n", key, value);
1437 }
1438
1439 static const Writer ini_writer = {
1440     .name                  = "ini",
1441     .priv_size             = sizeof(INIContext),
1442     .print_section_header  = ini_print_section_header,
1443     .print_integer         = ini_print_int,
1444     .print_string          = ini_print_str,
1445     .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1446     .priv_class            = &ini_class,
1447 };
1448
1449 /* JSON output */
1450
1451 typedef struct JSONContext {
1452     const AVClass *class;
1453     int indent_level;
1454     int compact;
1455     const char *item_sep, *item_start_end;
1456 } JSONContext;
1457
1458 #undef OFFSET
1459 #define OFFSET(x) offsetof(JSONContext, x)
1460
1461 static const AVOption json_options[]= {
1462     { "compact", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1463     { "c",       "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
1464     { NULL }
1465 };
1466
1467 DEFINE_WRITER_CLASS(json);
1468
1469 static av_cold int json_init(WriterContext *wctx)
1470 {
1471     JSONContext *json = wctx->priv;
1472
1473     json->item_sep       = json->compact ? ", " : ",\n";
1474     json->item_start_end = json->compact ? " "  : "\n";
1475
1476     return 0;
1477 }
1478
1479 static const char *json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
1480 {
1481     static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
1482     static const char json_subst[]  = {'"', '\\',  'b',  'f',  'n',  'r',  't', 0};
1483     const char *p;
1484
1485     for (p = src; *p; p++) {
1486         char *s = strchr(json_escape, *p);
1487         if (s) {
1488             av_bprint_chars(dst, '\\', 1);
1489             av_bprint_chars(dst, json_subst[s - json_escape], 1);
1490         } else if ((unsigned char)*p < 32) {
1491             av_bprintf(dst, "\\u00%02x", *p & 0xff);
1492         } else {
1493             av_bprint_chars(dst, *p, 1);
1494         }
1495     }
1496     return dst->str;
1497 }
1498
1499 #define JSON_INDENT() printf("%*c", json->indent_level * 4, ' ')
1500
1501 static void json_print_section_header(WriterContext *wctx)
1502 {
1503     JSONContext *json = wctx->priv;
1504     AVBPrint buf;
1505     const struct section *section = wctx->section[wctx->level];
1506     const struct section *parent_section = wctx->level ?
1507         wctx->section[wctx->level-1] : NULL;
1508
1509     if (wctx->level && wctx->nb_item[wctx->level-1])
1510         printf(",\n");
1511
1512     if (section->flags & SECTION_FLAG_IS_WRAPPER) {
1513         printf("{\n");
1514         json->indent_level++;
1515     } else {
1516         av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1517         json_escape_str(&buf, section->name, wctx);
1518         JSON_INDENT();
1519
1520         json->indent_level++;
1521         if (section->flags & SECTION_FLAG_IS_ARRAY) {
1522             printf("\"%s\": [\n", buf.str);
1523         } else if (parent_section && !(parent_section->flags & SECTION_FLAG_IS_ARRAY)) {
1524             printf("\"%s\": {%s", buf.str, json->item_start_end);
1525         } else {
1526             printf("{%s", json->item_start_end);
1527
1528             /* this is required so the parser can distinguish between packets and frames */
1529             if (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES) {
1530                 if (!json->compact)
1531                     JSON_INDENT();
1532                 printf("\"type\": \"%s\"%s", section->name, json->item_sep);
1533             }
1534         }
1535         av_bprint_finalize(&buf, NULL);
1536     }
1537 }
1538
1539 static void json_print_section_footer(WriterContext *wctx)
1540 {
1541     JSONContext *json = wctx->priv;
1542     const struct section *section = wctx->section[wctx->level];
1543
1544     if (wctx->level == 0) {
1545         json->indent_level--;
1546         printf("\n}\n");
1547     } else if (section->flags & SECTION_FLAG_IS_ARRAY) {
1548         printf("\n");
1549         json->indent_level--;
1550         JSON_INDENT();
1551         printf("]");
1552     } else {
1553         printf("%s", json->item_start_end);
1554         json->indent_level--;
1555         if (!json->compact)
1556             JSON_INDENT();
1557         printf("}");
1558     }
1559 }
1560
1561 static inline void json_print_item_str(WriterContext *wctx,
1562                                        const char *key, const char *value)
1563 {
1564     AVBPrint buf;
1565
1566     av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1567     printf("\"%s\":", json_escape_str(&buf, key,   wctx));
1568     av_bprint_clear(&buf);
1569     printf(" \"%s\"", json_escape_str(&buf, value, wctx));
1570     av_bprint_finalize(&buf, NULL);
1571 }
1572
1573 static void json_print_str(WriterContext *wctx, const char *key, const char *value)
1574 {
1575     JSONContext *json = wctx->priv;
1576
1577     if (wctx->nb_item[wctx->level])
1578         printf("%s", json->item_sep);
1579     if (!json->compact)
1580         JSON_INDENT();
1581     json_print_item_str(wctx, key, value);
1582 }
1583
1584 static void json_print_int(WriterContext *wctx, const char *key, long long int value)
1585 {
1586     JSONContext *json = wctx->priv;
1587     AVBPrint buf;
1588
1589     if (wctx->nb_item[wctx->level])
1590         printf("%s", json->item_sep);
1591     if (!json->compact)
1592         JSON_INDENT();
1593
1594     av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1595     printf("\"%s\": %lld", json_escape_str(&buf, key, wctx), value);
1596     av_bprint_finalize(&buf, NULL);
1597 }
1598
1599 static const Writer json_writer = {
1600     .name                 = "json",
1601     .priv_size            = sizeof(JSONContext),
1602     .init                 = json_init,
1603     .print_section_header = json_print_section_header,
1604     .print_section_footer = json_print_section_footer,
1605     .print_integer        = json_print_int,
1606     .print_string         = json_print_str,
1607     .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1608     .priv_class           = &json_class,
1609 };
1610
1611 /* XML output */
1612
1613 typedef struct XMLContext {
1614     const AVClass *class;
1615     int within_tag;
1616     int indent_level;
1617     int fully_qualified;
1618     int xsd_strict;
1619 } XMLContext;
1620
1621 #undef OFFSET
1622 #define OFFSET(x) offsetof(XMLContext, x)
1623
1624 static const AVOption xml_options[] = {
1625     {"fully_qualified", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0},  0, 1 },
1626     {"q",               "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0},  0, 1 },
1627     {"xsd_strict",      "ensure that the output is XSD compliant",         OFFSET(xsd_strict),      AV_OPT_TYPE_BOOL, {.i64=0},  0, 1 },
1628     {"x",               "ensure that the output is XSD compliant",         OFFSET(xsd_strict),      AV_OPT_TYPE_BOOL, {.i64=0},  0, 1 },
1629     {NULL},
1630 };
1631
1632 DEFINE_WRITER_CLASS(xml);
1633
1634 static av_cold int xml_init(WriterContext *wctx)
1635 {
1636     XMLContext *xml = wctx->priv;
1637
1638     if (xml->xsd_strict) {
1639         xml->fully_qualified = 1;
1640 #define CHECK_COMPLIANCE(opt, opt_name)                                 \
1641         if (opt) {                                                      \
1642             av_log(wctx, AV_LOG_ERROR,                                  \
1643                    "XSD-compliant output selected but option '%s' was selected, XML output may be non-compliant.\n" \
1644                    "You need to disable such option with '-no%s'\n", opt_name, opt_name); \
1645             return AVERROR(EINVAL);                                     \
1646         }
1647         CHECK_COMPLIANCE(show_private_data, "private");
1648         CHECK_COMPLIANCE(show_value_unit,   "unit");
1649         CHECK_COMPLIANCE(use_value_prefix,  "prefix");
1650
1651         if (do_show_frames && do_show_packets) {
1652             av_log(wctx, AV_LOG_ERROR,
1653                    "Interleaved frames and packets are not allowed in XSD. "
1654                    "Select only one between the -show_frames and the -show_packets options.\n");
1655             return AVERROR(EINVAL);
1656         }
1657     }
1658
1659     return 0;
1660 }
1661
1662 static const char *xml_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
1663 {
1664     const char *p;
1665
1666     for (p = src; *p; p++) {
1667         switch (*p) {
1668         case '&' : av_bprintf(dst, "%s", "&amp;");  break;
1669         case '<' : av_bprintf(dst, "%s", "&lt;");   break;
1670         case '>' : av_bprintf(dst, "%s", "&gt;");   break;
1671         case '"' : av_bprintf(dst, "%s", "&quot;"); break;
1672         case '\'': av_bprintf(dst, "%s", "&apos;"); break;
1673         default: av_bprint_chars(dst, *p, 1);
1674         }
1675     }
1676
1677     return dst->str;
1678 }
1679
1680 #define XML_INDENT() printf("%*c", xml->indent_level * 4, ' ')
1681
1682 static void xml_print_section_header(WriterContext *wctx)
1683 {
1684     XMLContext *xml = wctx->priv;
1685     const struct section *section = wctx->section[wctx->level];
1686     const struct section *parent_section = wctx->level ?
1687         wctx->section[wctx->level-1] : NULL;
1688
1689     if (wctx->level == 0) {
1690         const char *qual = " xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
1691             "xmlns:ffprobe='http://www.ffmpeg.org/schema/ffprobe' "
1692             "xsi:schemaLocation='http://www.ffmpeg.org/schema/ffprobe ffprobe.xsd'";
1693
1694         printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
1695         printf("<%sffprobe%s>\n",
1696                xml->fully_qualified ? "ffprobe:" : "",
1697                xml->fully_qualified ? qual : "");
1698         return;
1699     }
1700
1701     if (xml->within_tag) {
1702         xml->within_tag = 0;
1703         printf(">\n");
1704     }
1705     if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
1706         xml->indent_level++;
1707     } else {
1708         if (parent_section && (parent_section->flags & SECTION_FLAG_IS_WRAPPER) &&
1709             wctx->level && wctx->nb_item[wctx->level-1])
1710             printf("\n");
1711         xml->indent_level++;
1712
1713         if (section->flags & SECTION_FLAG_IS_ARRAY) {
1714             XML_INDENT(); printf("<%s>\n", section->name);
1715         } else {
1716             XML_INDENT(); printf("<%s ", section->name);
1717             xml->within_tag = 1;
1718         }
1719     }
1720 }
1721
1722 static void xml_print_section_footer(WriterContext *wctx)
1723 {
1724     XMLContext *xml = wctx->priv;
1725     const struct section *section = wctx->section[wctx->level];
1726
1727     if (wctx->level == 0) {
1728         printf("</%sffprobe>\n", xml->fully_qualified ? "ffprobe:" : "");
1729     } else if (xml->within_tag) {
1730         xml->within_tag = 0;
1731         printf("/>\n");
1732         xml->indent_level--;
1733     } else if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
1734         xml->indent_level--;
1735     } else {
1736         XML_INDENT(); printf("</%s>\n", section->name);
1737         xml->indent_level--;
1738     }
1739 }
1740
1741 static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
1742 {
1743     AVBPrint buf;
1744     XMLContext *xml = wctx->priv;
1745     const struct section *section = wctx->section[wctx->level];
1746
1747     av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
1748
1749     if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
1750         XML_INDENT();
1751         printf("<%s key=\"%s\"",
1752                section->element_name, xml_escape_str(&buf, key, wctx));
1753         av_bprint_clear(&buf);
1754         printf(" value=\"%s\"/>\n", xml_escape_str(&buf, value, wctx));
1755     } else {
1756         if (wctx->nb_item[wctx->level])
1757             printf(" ");
1758         printf("%s=\"%s\"", key, xml_escape_str(&buf, value, wctx));
1759     }
1760
1761     av_bprint_finalize(&buf, NULL);
1762 }
1763
1764 static void xml_print_int(WriterContext *wctx, const char *key, long long int value)
1765 {
1766     if (wctx->nb_item[wctx->level])
1767         printf(" ");
1768     printf("%s=\"%lld\"", key, value);
1769 }
1770
1771 static Writer xml_writer = {
1772     .name                 = "xml",
1773     .priv_size            = sizeof(XMLContext),
1774     .init                 = xml_init,
1775     .print_section_header = xml_print_section_header,
1776     .print_section_footer = xml_print_section_footer,
1777     .print_integer        = xml_print_int,
1778     .print_string         = xml_print_str,
1779     .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
1780     .priv_class           = &xml_class,
1781 };
1782
1783 static void writer_register_all(void)
1784 {
1785     static int initialized;
1786
1787     if (initialized)
1788         return;
1789     initialized = 1;
1790
1791     writer_register(&default_writer);
1792     writer_register(&compact_writer);
1793     writer_register(&csv_writer);
1794     writer_register(&flat_writer);
1795     writer_register(&ini_writer);
1796     writer_register(&json_writer);
1797     writer_register(&xml_writer);
1798 }
1799
1800 #define print_fmt(k, f, ...) do {              \
1801     av_bprint_clear(&pbuf);                    \
1802     av_bprintf(&pbuf, f, __VA_ARGS__);         \
1803     writer_print_string(w, k, pbuf.str, 0);    \
1804 } while (0)
1805
1806 #define print_int(k, v)         writer_print_integer(w, k, v)
1807 #define print_q(k, v, s)        writer_print_rational(w, k, v, s)
1808 #define print_str(k, v)         writer_print_string(w, k, v, 0)
1809 #define print_str_opt(k, v)     writer_print_string(w, k, v, PRINT_STRING_OPT)
1810 #define print_str_validate(k, v) writer_print_string(w, k, v, PRINT_STRING_VALIDATE)
1811 #define print_time(k, v, tb)    writer_print_time(w, k, v, tb, 0)
1812 #define print_ts(k, v)          writer_print_ts(w, k, v, 0)
1813 #define print_duration_time(k, v, tb) writer_print_time(w, k, v, tb, 1)
1814 #define print_duration_ts(k, v)       writer_print_ts(w, k, v, 1)
1815 #define print_val(k, v, u) do {                                     \
1816     struct unit_value uv;                                           \
1817     uv.val.i = v;                                                   \
1818     uv.unit = u;                                                    \
1819     writer_print_string(w, k, value_string(val_str, sizeof(val_str), uv), 0); \
1820 } while (0)
1821
1822 #define print_section_header(s) writer_print_section_header(w, s)
1823 #define print_section_footer(s) writer_print_section_footer(w, s)
1824
1825 #define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n)                        \
1826 {                                                                       \
1827     ret = av_reallocp_array(&(ptr), (new_n), sizeof(*(ptr)));           \
1828     if (ret < 0)                                                        \
1829         goto end;                                                       \
1830     memset( (ptr) + (cur_n), 0, ((new_n) - (cur_n)) * sizeof(*(ptr)) ); \
1831 }
1832
1833 static inline int show_tags(WriterContext *w, AVDictionary *tags, int section_id)
1834 {
1835     AVDictionaryEntry *tag = NULL;
1836     int ret = 0;
1837
1838     if (!tags)
1839         return 0;
1840     writer_print_section_header(w, section_id);
1841
1842     while ((tag = av_dict_get(tags, "", tag, AV_DICT_IGNORE_SUFFIX))) {
1843         if ((ret = print_str_validate(tag->key, tag->value)) < 0)
1844             break;
1845     }
1846     writer_print_section_footer(w);
1847
1848     return ret;
1849 }
1850
1851 static void print_pkt_side_data(WriterContext *w,
1852                                 AVCodecParameters *par,
1853                                 const AVPacketSideData *side_data,
1854                                 int nb_side_data,
1855                                 SectionID id_data_list,
1856                                 SectionID id_data)
1857 {
1858     int i;
1859
1860     writer_print_section_header(w, id_data_list);
1861     for (i = 0; i < nb_side_data; i++) {
1862         const AVPacketSideData *sd = &side_data[i];
1863         const char *name = av_packet_side_data_name(sd->type);
1864
1865         writer_print_section_header(w, id_data);
1866         print_str("side_data_type", name ? name : "unknown");
1867         if (sd->type == AV_PKT_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
1868             writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
1869             print_int("rotation", av_display_rotation_get((int32_t *)sd->data));
1870         } else if (sd->type == AV_PKT_DATA_STEREO3D) {
1871             const AVStereo3D *stereo = (AVStereo3D *)sd->data;
1872             print_str("type", av_stereo3d_type_name(stereo->type));
1873             print_int("inverted", !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
1874         } else if (sd->type == AV_PKT_DATA_SPHERICAL) {
1875             const AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
1876             print_str("projection", av_spherical_projection_name(spherical->projection));
1877             if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
1878                 print_int("padding", spherical->padding);
1879             } else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
1880                 size_t l, t, r, b;
1881                 av_spherical_tile_bounds(spherical, par->width, par->height,
1882                                          &l, &t, &r, &b);
1883                 print_int("bound_left", l);
1884                 print_int("bound_top", t);
1885                 print_int("bound_right", r);
1886                 print_int("bound_bottom", b);
1887             }
1888
1889             print_int("yaw", (double) spherical->yaw / (1 << 16));
1890             print_int("pitch", (double) spherical->pitch / (1 << 16));
1891             print_int("roll", (double) spherical->roll / (1 << 16));
1892         } else if (sd->type == AV_PKT_DATA_SKIP_SAMPLES && sd->size == 10) {
1893             print_int("skip_samples",    AV_RL32(sd->data));
1894             print_int("discard_padding", AV_RL32(sd->data + 4));
1895             print_int("skip_reason",     AV_RL8(sd->data + 8));
1896             print_int("discard_reason",  AV_RL8(sd->data + 9));
1897         } else if (sd->type == AV_PKT_DATA_MASTERING_DISPLAY_METADATA) {
1898             AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
1899
1900             if (metadata->has_primaries) {
1901                 print_q("red_x", metadata->display_primaries[0][0], '/');
1902                 print_q("red_y", metadata->display_primaries[0][1], '/');
1903                 print_q("green_x", metadata->display_primaries[1][0], '/');
1904                 print_q("green_y", metadata->display_primaries[1][1], '/');
1905                 print_q("blue_x", metadata->display_primaries[2][0], '/');
1906                 print_q("blue_y", metadata->display_primaries[2][1], '/');
1907
1908                 print_q("white_point_x", metadata->white_point[0], '/');
1909                 print_q("white_point_y", metadata->white_point[1], '/');
1910             }
1911
1912             if (metadata->has_luminance) {
1913                 print_q("min_luminance", metadata->min_luminance, '/');
1914                 print_q("max_luminance", metadata->max_luminance, '/');
1915             }
1916         }
1917         writer_print_section_footer(w);
1918     }
1919     writer_print_section_footer(w);
1920 }
1921
1922 static void clear_log(int need_lock)
1923 {
1924     int i;
1925
1926     if (need_lock)
1927         pthread_mutex_lock(&log_mutex);
1928     for (i=0; i<log_buffer_size; i++) {
1929         av_freep(&log_buffer[i].context_name);
1930         av_freep(&log_buffer[i].parent_name);
1931         av_freep(&log_buffer[i].log_message);
1932     }
1933     log_buffer_size = 0;
1934     if(need_lock)
1935         pthread_mutex_unlock(&log_mutex);
1936 }
1937
1938 static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
1939 {
1940     int i;
1941     pthread_mutex_lock(&log_mutex);
1942     if (!log_buffer_size) {
1943         pthread_mutex_unlock(&log_mutex);
1944         return 0;
1945     }
1946     writer_print_section_header(w, section_ids);
1947
1948     for (i=0; i<log_buffer_size; i++) {
1949         if (log_buffer[i].log_level <= log_level) {
1950             writer_print_section_header(w, section_id);
1951             print_str("context", log_buffer[i].context_name);
1952             print_int("level", log_buffer[i].log_level);
1953             print_int("category", log_buffer[i].category);
1954             if (log_buffer[i].parent_name) {
1955                 print_str("parent_context", log_buffer[i].parent_name);
1956                 print_int("parent_category", log_buffer[i].parent_category);
1957             } else {
1958                 print_str_opt("parent_context", "N/A");
1959                 print_str_opt("parent_category", "N/A");
1960             }
1961             print_str("message", log_buffer[i].log_message);
1962             writer_print_section_footer(w);
1963         }
1964     }
1965     clear_log(0);
1966     pthread_mutex_unlock(&log_mutex);
1967
1968     writer_print_section_footer(w);
1969
1970     return 0;
1971 }
1972
1973 static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
1974 {
1975     char val_str[128];
1976     AVStream *st = ifile->streams[pkt->stream_index].st;
1977     AVBPrint pbuf;
1978     const char *s;
1979
1980     av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
1981
1982     writer_print_section_header(w, SECTION_ID_PACKET);
1983
1984     s = av_get_media_type_string(st->codecpar->codec_type);
1985     if (s) print_str    ("codec_type", s);
1986     else   print_str_opt("codec_type", "unknown");
1987     print_int("stream_index",     pkt->stream_index);
1988     print_ts  ("pts",             pkt->pts);
1989     print_time("pts_time",        pkt->pts, &st->time_base);
1990     print_ts  ("dts",             pkt->dts);
1991     print_time("dts_time",        pkt->dts, &st->time_base);
1992     print_duration_ts("duration",        pkt->duration);
1993     print_duration_time("duration_time", pkt->duration, &st->time_base);
1994     print_duration_ts("convergence_duration", pkt->convergence_duration);
1995     print_duration_time("convergence_duration_time", pkt->convergence_duration, &st->time_base);
1996     print_val("size",             pkt->size, unit_byte_str);
1997     if (pkt->pos != -1) print_fmt    ("pos", "%"PRId64, pkt->pos);
1998     else                print_str_opt("pos", "N/A");
1999     print_fmt("flags", "%c%c",      pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_',
2000               pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_');
2001
2002     if (pkt->side_data_elems) {
2003         int size;
2004         const uint8_t *side_metadata;
2005
2006         side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);
2007         if (side_metadata && size && do_show_packet_tags) {
2008             AVDictionary *dict = NULL;
2009             if (av_packet_unpack_dictionary(side_metadata, size, &dict) >= 0)
2010                 show_tags(w, dict, SECTION_ID_PACKET_TAGS);
2011             av_dict_free(&dict);
2012         }
2013
2014         print_pkt_side_data(w, st->codecpar, pkt->side_data, pkt->side_data_elems,
2015                             SECTION_ID_PACKET_SIDE_DATA_LIST,
2016                             SECTION_ID_PACKET_SIDE_DATA);
2017     }
2018
2019     if (do_show_data)
2020         writer_print_data(w, "data", pkt->data, pkt->size);
2021     writer_print_data_hash(w, "data_hash", pkt->data, pkt->size);
2022     writer_print_section_footer(w);
2023
2024     av_bprint_finalize(&pbuf, NULL);
2025     fflush(stdout);
2026 }
2027
2028 static void show_subtitle(WriterContext *w, AVSubtitle *sub, AVStream *stream,
2029                           AVFormatContext *fmt_ctx)
2030 {
2031     AVBPrint pbuf;
2032
2033     av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2034
2035     writer_print_section_header(w, SECTION_ID_SUBTITLE);
2036
2037     print_str ("media_type",         "subtitle");
2038     print_ts  ("pts",                 sub->pts);
2039     print_time("pts_time",            sub->pts, &AV_TIME_BASE_Q);
2040     print_int ("format",              sub->format);
2041     print_int ("start_display_time",  sub->start_display_time);
2042     print_int ("end_display_time",    sub->end_display_time);
2043     print_int ("num_rects",           sub->num_rects);
2044
2045     writer_print_section_footer(w);
2046
2047     av_bprint_finalize(&pbuf, NULL);
2048     fflush(stdout);
2049 }
2050
2051 static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
2052                        AVFormatContext *fmt_ctx)
2053 {
2054     AVBPrint pbuf;
2055     char val_str[128];
2056     const char *s;
2057     int i;
2058
2059     av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2060
2061     writer_print_section_header(w, SECTION_ID_FRAME);
2062
2063     s = av_get_media_type_string(stream->codecpar->codec_type);
2064     if (s) print_str    ("media_type", s);
2065     else   print_str_opt("media_type", "unknown");
2066     print_int("stream_index",           stream->index);
2067     print_int("key_frame",              frame->key_frame);
2068     print_ts  ("pkt_pts",               frame->pts);
2069     print_time("pkt_pts_time",          frame->pts, &stream->time_base);
2070     print_ts  ("pkt_dts",               frame->pkt_dts);
2071     print_time("pkt_dts_time",          frame->pkt_dts, &stream->time_base);
2072     print_ts  ("best_effort_timestamp", frame->best_effort_timestamp);
2073     print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
2074     print_duration_ts  ("pkt_duration",      frame->pkt_duration);
2075     print_duration_time("pkt_duration_time", frame->pkt_duration, &stream->time_base);
2076     if (frame->pkt_pos != -1) print_fmt    ("pkt_pos", "%"PRId64, frame->pkt_pos);
2077     else                      print_str_opt("pkt_pos", "N/A");
2078     if (frame->pkt_size != -1) print_val    ("pkt_size", frame->pkt_size, unit_byte_str);
2079     else                       print_str_opt("pkt_size", "N/A");
2080
2081     switch (stream->codecpar->codec_type) {
2082         AVRational sar;
2083
2084     case AVMEDIA_TYPE_VIDEO:
2085         print_int("width",                  frame->width);
2086         print_int("height",                 frame->height);
2087         s = av_get_pix_fmt_name(frame->format);
2088         if (s) print_str    ("pix_fmt", s);
2089         else   print_str_opt("pix_fmt", "unknown");
2090         sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
2091         if (sar.num) {
2092             print_q("sample_aspect_ratio", sar, ':');
2093         } else {
2094             print_str_opt("sample_aspect_ratio", "N/A");
2095         }
2096         print_fmt("pict_type",              "%c", av_get_picture_type_char(frame->pict_type));
2097         print_int("coded_picture_number",   frame->coded_picture_number);
2098         print_int("display_picture_number", frame->display_picture_number);
2099         print_int("interlaced_frame",       frame->interlaced_frame);
2100         print_int("top_field_first",        frame->top_field_first);
2101         print_int("repeat_pict",            frame->repeat_pict);
2102         break;
2103
2104     case AVMEDIA_TYPE_AUDIO:
2105         s = av_get_sample_fmt_name(frame->format);
2106         if (s) print_str    ("sample_fmt", s);
2107         else   print_str_opt("sample_fmt", "unknown");
2108         print_int("nb_samples",         frame->nb_samples);
2109         print_int("channels", frame->channels);
2110         if (frame->channel_layout) {
2111             av_bprint_clear(&pbuf);
2112             av_bprint_channel_layout(&pbuf, frame->channels,
2113                                      frame->channel_layout);
2114             print_str    ("channel_layout", pbuf.str);
2115         } else
2116             print_str_opt("channel_layout", "unknown");
2117         break;
2118     }
2119     if (do_show_frame_tags)
2120         show_tags(w, frame->metadata, SECTION_ID_FRAME_TAGS);
2121     if (do_show_log)
2122         show_log(w, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log);
2123     if (frame->nb_side_data) {
2124         writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_LIST);
2125         for (i = 0; i < frame->nb_side_data; i++) {
2126             AVFrameSideData *sd = frame->side_data[i];
2127             const char *name;
2128
2129             writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA);
2130             name = av_frame_side_data_name(sd->type);
2131             print_str("side_data_type", name ? name : "unknown");
2132             if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
2133                 writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
2134                 print_int("rotation", av_display_rotation_get((int32_t *)sd->data));
2135             } else if (sd->type == AV_FRAME_DATA_GOP_TIMECODE && sd->size >= 8) {
2136                 char tcbuf[AV_TIMECODE_STR_SIZE];
2137                 av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
2138                 print_str("timecode", tcbuf);
2139             } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
2140                 AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
2141
2142                 if (metadata->has_primaries) {
2143                     print_q("red_x", metadata->display_primaries[0][0], '/');
2144                     print_q("red_y", metadata->display_primaries[0][1], '/');
2145                     print_q("green_x", metadata->display_primaries[1][0], '/');
2146                     print_q("green_y", metadata->display_primaries[1][1], '/');
2147                     print_q("blue_x", metadata->display_primaries[2][0], '/');
2148                     print_q("blue_y", metadata->display_primaries[2][1], '/');
2149
2150                     print_q("white_point_x", metadata->white_point[0], '/');
2151                     print_q("white_point_y", metadata->white_point[1], '/');
2152                 }
2153
2154                 if (metadata->has_luminance) {
2155                     print_q("min_luminance", metadata->min_luminance, '/');
2156                     print_q("max_luminance", metadata->max_luminance, '/');
2157                 }
2158             }
2159             writer_print_section_footer(w);
2160         }
2161         writer_print_section_footer(w);
2162     }
2163
2164     writer_print_section_footer(w);
2165
2166     av_bprint_finalize(&pbuf, NULL);
2167     fflush(stdout);
2168 }
2169
2170 static av_always_inline int process_frame(WriterContext *w,
2171                                           InputFile *ifile,
2172                                           AVFrame *frame, AVPacket *pkt,
2173                                           int *packet_new)
2174 {
2175     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2176     AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
2177     AVCodecParameters *par = ifile->streams[pkt->stream_index].st->codecpar;
2178     AVSubtitle sub;
2179     int ret = 0, got_frame = 0;
2180
2181     clear_log(1);
2182     if (dec_ctx && dec_ctx->codec) {
2183         switch (par->codec_type) {
2184         case AVMEDIA_TYPE_VIDEO:
2185         case AVMEDIA_TYPE_AUDIO:
2186             if (*packet_new) {
2187                 ret = avcodec_send_packet(dec_ctx, pkt);
2188                 if (ret == AVERROR(EAGAIN)) {
2189                     ret = 0;
2190                 } else if (ret >= 0 || ret == AVERROR_EOF) {
2191                     ret = 0;
2192                     *packet_new = 0;
2193                 }
2194             }
2195             if (ret >= 0) {
2196                 ret = avcodec_receive_frame(dec_ctx, frame);
2197                 if (ret >= 0) {
2198                     got_frame = 1;
2199                 } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
2200                     ret = 0;
2201                 }
2202             }
2203             break;
2204
2205         case AVMEDIA_TYPE_SUBTITLE:
2206             ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
2207             *packet_new = 0;
2208             break;
2209         default:
2210             *packet_new = 0;
2211         }
2212     } else {
2213         *packet_new = 0;
2214     }
2215
2216     if (ret < 0)
2217         return ret;
2218     if (got_frame) {
2219         int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
2220         nb_streams_frames[pkt->stream_index]++;
2221         if (do_show_frames)
2222             if (is_sub)
2223                 show_subtitle(w, &sub, ifile->streams[pkt->stream_index].st, fmt_ctx);
2224             else
2225                 show_frame(w, frame, ifile->streams[pkt->stream_index].st, fmt_ctx);
2226         if (is_sub)
2227             avsubtitle_free(&sub);
2228     }
2229     return got_frame || *packet_new;
2230 }
2231
2232 static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
2233 {
2234     av_log(log_ctx, log_level, "id:%d", interval->id);
2235
2236     if (interval->has_start) {
2237         av_log(log_ctx, log_level, " start:%s%s", interval->start_is_offset ? "+" : "",
2238                av_ts2timestr(interval->start, &AV_TIME_BASE_Q));
2239     } else {
2240         av_log(log_ctx, log_level, " start:N/A");
2241     }
2242
2243     if (interval->has_end) {
2244         av_log(log_ctx, log_level, " end:%s", interval->end_is_offset ? "+" : "");
2245         if (interval->duration_frames)
2246             av_log(log_ctx, log_level, "#%"PRId64, interval->end);
2247         else
2248             av_log(log_ctx, log_level, "%s", av_ts2timestr(interval->end, &AV_TIME_BASE_Q));
2249     } else {
2250         av_log(log_ctx, log_level, " end:N/A");
2251     }
2252
2253     av_log(log_ctx, log_level, "\n");
2254 }
2255
2256 static int read_interval_packets(WriterContext *w, InputFile *ifile,
2257                                  const ReadInterval *interval, int64_t *cur_ts)
2258 {
2259     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2260     AVPacket pkt;
2261     AVFrame *frame = NULL;
2262     int ret = 0, i = 0, frame_count = 0;
2263     int64_t start = -INT64_MAX, end = interval->end;
2264     int has_start = 0, has_end = interval->has_end && !interval->end_is_offset;
2265
2266     av_init_packet(&pkt);
2267
2268     av_log(NULL, AV_LOG_VERBOSE, "Processing read interval ");
2269     log_read_interval(interval, NULL, AV_LOG_VERBOSE);
2270
2271     if (interval->has_start) {
2272         int64_t target;
2273         if (interval->start_is_offset) {
2274             if (*cur_ts == AV_NOPTS_VALUE) {
2275                 av_log(NULL, AV_LOG_ERROR,
2276                        "Could not seek to relative position since current "
2277                        "timestamp is not defined\n");
2278                 ret = AVERROR(EINVAL);
2279                 goto end;
2280             }
2281             target = *cur_ts + interval->start;
2282         } else {
2283             target = interval->start;
2284         }
2285
2286         av_log(NULL, AV_LOG_VERBOSE, "Seeking to read interval start point %s\n",
2287                av_ts2timestr(target, &AV_TIME_BASE_Q));
2288         if ((ret = avformat_seek_file(fmt_ctx, -1, -INT64_MAX, target, INT64_MAX, 0)) < 0) {
2289             av_log(NULL, AV_LOG_ERROR, "Could not seek to position %"PRId64": %s\n",
2290                    interval->start, av_err2str(ret));
2291             goto end;
2292         }
2293     }
2294
2295     frame = av_frame_alloc();
2296     if (!frame) {
2297         ret = AVERROR(ENOMEM);
2298         goto end;
2299     }
2300     while (!av_read_frame(fmt_ctx, &pkt)) {
2301         if (ifile->nb_streams > nb_streams) {
2302             REALLOCZ_ARRAY_STREAM(nb_streams_frames,  nb_streams, fmt_ctx->nb_streams);
2303             REALLOCZ_ARRAY_STREAM(nb_streams_packets, nb_streams, fmt_ctx->nb_streams);
2304             REALLOCZ_ARRAY_STREAM(selected_streams,   nb_streams, fmt_ctx->nb_streams);
2305             nb_streams = ifile->nb_streams;
2306         }
2307         if (selected_streams[pkt.stream_index]) {
2308             AVRational tb = ifile->streams[pkt.stream_index].st->time_base;
2309
2310             if (pkt.pts != AV_NOPTS_VALUE)
2311                 *cur_ts = av_rescale_q(pkt.pts, tb, AV_TIME_BASE_Q);
2312
2313             if (!has_start && *cur_ts != AV_NOPTS_VALUE) {
2314                 start = *cur_ts;
2315                 has_start = 1;
2316             }
2317
2318             if (has_start && !has_end && interval->end_is_offset) {
2319                 end = start + interval->end;
2320                 has_end = 1;
2321             }
2322
2323             if (interval->end_is_offset && interval->duration_frames) {
2324                 if (frame_count >= interval->end)
2325                     break;
2326             } else if (has_end && *cur_ts != AV_NOPTS_VALUE && *cur_ts >= end) {
2327                 break;
2328             }
2329
2330             frame_count++;
2331             if (do_read_packets) {
2332                 if (do_show_packets)
2333                     show_packet(w, ifile, &pkt, i++);
2334                 nb_streams_packets[pkt.stream_index]++;
2335             }
2336             if (do_read_frames) {
2337                 int packet_new = 1;
2338                 while (process_frame(w, ifile, frame, &pkt, &packet_new) > 0);
2339             }
2340         }
2341         av_packet_unref(&pkt);
2342     }
2343     av_init_packet(&pkt);
2344     pkt.data = NULL;
2345     pkt.size = 0;
2346     //Flush remaining frames that are cached in the decoder
2347     for (i = 0; i < fmt_ctx->nb_streams; i++) {
2348         pkt.stream_index = i;
2349         if (do_read_frames)
2350             while (process_frame(w, ifile, frame, &pkt, &(int){1}) > 0);
2351     }
2352
2353 end:
2354     av_frame_free(&frame);
2355     if (ret < 0) {
2356         av_log(NULL, AV_LOG_ERROR, "Could not read packets in interval ");
2357         log_read_interval(interval, NULL, AV_LOG_ERROR);
2358     }
2359     return ret;
2360 }
2361
2362 static int read_packets(WriterContext *w, InputFile *ifile)
2363 {
2364     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2365     int i, ret = 0;
2366     int64_t cur_ts = fmt_ctx->start_time;
2367
2368     if (read_intervals_nb == 0) {
2369         ReadInterval interval = (ReadInterval) { .has_start = 0, .has_end = 0 };
2370         ret = read_interval_packets(w, ifile, &interval, &cur_ts);
2371     } else {
2372         for (i = 0; i < read_intervals_nb; i++) {
2373             ret = read_interval_packets(w, ifile, &read_intervals[i], &cur_ts);
2374             if (ret < 0)
2375                 break;
2376         }
2377     }
2378
2379     return ret;
2380 }
2381
2382 static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int in_program)
2383 {
2384     AVStream *stream = ist->st;
2385     AVCodecParameters *par;
2386     AVCodecContext *dec_ctx;
2387     char val_str[128];
2388     const char *s;
2389     AVRational sar, dar;
2390     AVBPrint pbuf;
2391     const AVCodecDescriptor *cd;
2392     int ret = 0;
2393     const char *profile = NULL;
2394
2395     av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2396
2397     writer_print_section_header(w, in_program ? SECTION_ID_PROGRAM_STREAM : SECTION_ID_STREAM);
2398
2399     print_int("index", stream->index);
2400
2401     par     = stream->codecpar;
2402     dec_ctx = ist->dec_ctx;
2403     if (cd = avcodec_descriptor_get(par->codec_id)) {
2404         print_str("codec_name", cd->name);
2405         if (!do_bitexact) {
2406             print_str("codec_long_name",
2407                       cd->long_name ? cd->long_name : "unknown");
2408         }
2409     } else {
2410         print_str_opt("codec_name", "unknown");
2411         if (!do_bitexact) {
2412             print_str_opt("codec_long_name", "unknown");
2413         }
2414     }
2415
2416     if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
2417         print_str("profile", profile);
2418     else {
2419         if (par->profile != FF_PROFILE_UNKNOWN) {
2420             char profile_num[12];
2421             snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
2422             print_str("profile", profile_num);
2423         } else
2424             print_str_opt("profile", "unknown");
2425     }
2426
2427     s = av_get_media_type_string(par->codec_type);
2428     if (s) print_str    ("codec_type", s);
2429     else   print_str_opt("codec_type", "unknown");
2430 #if FF_API_LAVF_AVCTX
2431     if (dec_ctx)
2432         print_q("codec_time_base", dec_ctx->time_base, '/');
2433 #endif
2434
2435     /* print AVI/FourCC tag */
2436     print_str("codec_tag_string",    av_fourcc2str(par->codec_tag));
2437     print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
2438
2439     switch (par->codec_type) {
2440     case AVMEDIA_TYPE_VIDEO:
2441         print_int("width",        par->width);
2442         print_int("height",       par->height);
2443         if (dec_ctx) {
2444             print_int("coded_width",  dec_ctx->coded_width);
2445             print_int("coded_height", dec_ctx->coded_height);
2446         }
2447         print_int("has_b_frames", par->video_delay);
2448         sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
2449         if (sar.den) {
2450             print_q("sample_aspect_ratio", sar, ':');
2451             av_reduce(&dar.num, &dar.den,
2452                       par->width  * sar.num,
2453                       par->height * sar.den,
2454                       1024*1024);
2455             print_q("display_aspect_ratio", dar, ':');
2456         } else {
2457             print_str_opt("sample_aspect_ratio", "N/A");
2458             print_str_opt("display_aspect_ratio", "N/A");
2459         }
2460         s = av_get_pix_fmt_name(par->format);
2461         if (s) print_str    ("pix_fmt", s);
2462         else   print_str_opt("pix_fmt", "unknown");
2463         print_int("level",   par->level);
2464         if (par->color_range != AVCOL_RANGE_UNSPECIFIED)
2465             print_str    ("color_range", av_color_range_name(par->color_range));
2466         else
2467             print_str_opt("color_range", "N/A");
2468
2469         s = av_get_colorspace_name(par->color_space);
2470         if (s) print_str    ("color_space", s);
2471         else   print_str_opt("color_space", "unknown");
2472
2473         if (par->color_trc != AVCOL_TRC_UNSPECIFIED)
2474             print_str("color_transfer", av_color_transfer_name(par->color_trc));
2475         else
2476             print_str_opt("color_transfer", av_color_transfer_name(par->color_trc));
2477
2478         if (par->color_primaries != AVCOL_PRI_UNSPECIFIED)
2479             print_str("color_primaries", av_color_primaries_name(par->color_primaries));
2480         else
2481             print_str_opt("color_primaries", av_color_primaries_name(par->color_primaries));
2482
2483         if (par->chroma_location != AVCHROMA_LOC_UNSPECIFIED)
2484             print_str("chroma_location", av_chroma_location_name(par->chroma_location));
2485         else
2486             print_str_opt("chroma_location", av_chroma_location_name(par->chroma_location));
2487
2488         if (par->field_order == AV_FIELD_PROGRESSIVE)
2489             print_str("field_order", "progressive");
2490         else if (par->field_order == AV_FIELD_TT)
2491             print_str("field_order", "tt");
2492         else if (par->field_order == AV_FIELD_BB)
2493             print_str("field_order", "bb");
2494         else if (par->field_order == AV_FIELD_TB)
2495             print_str("field_order", "tb");
2496         else if (par->field_order == AV_FIELD_BT)
2497             print_str("field_order", "bt");
2498         else
2499             print_str_opt("field_order", "unknown");
2500
2501 #if FF_API_PRIVATE_OPT
2502         if (dec_ctx && dec_ctx->timecode_frame_start >= 0) {
2503             char tcbuf[AV_TIMECODE_STR_SIZE];
2504             av_timecode_make_mpeg_tc_string(tcbuf, dec_ctx->timecode_frame_start);
2505             print_str("timecode", tcbuf);
2506         } else {
2507             print_str_opt("timecode", "N/A");
2508         }
2509 #endif
2510         if (dec_ctx)
2511             print_int("refs", dec_ctx->refs);
2512         break;
2513
2514     case AVMEDIA_TYPE_AUDIO:
2515         s = av_get_sample_fmt_name(par->format);
2516         if (s) print_str    ("sample_fmt", s);
2517         else   print_str_opt("sample_fmt", "unknown");
2518         print_val("sample_rate",     par->sample_rate, unit_hertz_str);
2519         print_int("channels",        par->channels);
2520
2521         if (par->channel_layout) {
2522             av_bprint_clear(&pbuf);
2523             av_bprint_channel_layout(&pbuf, par->channels, par->channel_layout);
2524             print_str    ("channel_layout", pbuf.str);
2525         } else {
2526             print_str_opt("channel_layout", "unknown");
2527         }
2528
2529         print_int("bits_per_sample", av_get_bits_per_sample(par->codec_id));
2530         break;
2531
2532     case AVMEDIA_TYPE_SUBTITLE:
2533         if (par->width)
2534             print_int("width",       par->width);
2535         else
2536             print_str_opt("width",   "N/A");
2537         if (par->height)
2538             print_int("height",      par->height);
2539         else
2540             print_str_opt("height",  "N/A");
2541         break;
2542     }
2543
2544     if (dec_ctx && dec_ctx->codec && dec_ctx->codec->priv_class && show_private_data) {
2545         const AVOption *opt = NULL;
2546         while (opt = av_opt_next(dec_ctx->priv_data,opt)) {
2547             uint8_t *str;
2548             if (opt->flags) continue;
2549             if (av_opt_get(dec_ctx->priv_data, opt->name, 0, &str) >= 0) {
2550                 print_str(opt->name, str);
2551                 av_free(str);
2552             }
2553         }
2554     }
2555
2556     if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt    ("id", "0x%x", stream->id);
2557     else                                          print_str_opt("id", "N/A");
2558     print_q("r_frame_rate",   stream->r_frame_rate,   '/');
2559     print_q("avg_frame_rate", stream->avg_frame_rate, '/');
2560     print_q("time_base",      stream->time_base,      '/');
2561     print_ts  ("start_pts",   stream->start_time);
2562     print_time("start_time",  stream->start_time, &stream->time_base);
2563     print_ts  ("duration_ts", stream->duration);
2564     print_time("duration",    stream->duration, &stream->time_base);
2565     if (par->bit_rate > 0)     print_val    ("bit_rate", par->bit_rate, unit_bit_per_second_str);
2566     else                       print_str_opt("bit_rate", "N/A");
2567 #if FF_API_LAVF_AVCTX
2568     if (stream->codec->rc_max_rate > 0) print_val ("max_bit_rate", stream->codec->rc_max_rate, unit_bit_per_second_str);
2569     else                                print_str_opt("max_bit_rate", "N/A");
2570 #endif
2571     if (dec_ctx && dec_ctx->bits_per_raw_sample > 0) print_fmt("bits_per_raw_sample", "%d", dec_ctx->bits_per_raw_sample);
2572     else                                             print_str_opt("bits_per_raw_sample", "N/A");
2573     if (stream->nb_frames) print_fmt    ("nb_frames", "%"PRId64, stream->nb_frames);
2574     else                   print_str_opt("nb_frames", "N/A");
2575     if (nb_streams_frames[stream_idx])  print_fmt    ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
2576     else                                print_str_opt("nb_read_frames", "N/A");
2577     if (nb_streams_packets[stream_idx]) print_fmt    ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
2578     else                                print_str_opt("nb_read_packets", "N/A");
2579     if (do_show_data)
2580         writer_print_data(w, "extradata", par->extradata,
2581                                           par->extradata_size);
2582     writer_print_data_hash(w, "extradata_hash", par->extradata,
2583                                                 par->extradata_size);
2584
2585     /* Print disposition information */
2586 #define PRINT_DISPOSITION(flagname, name) do {                                \
2587         print_int(name, !!(stream->disposition & AV_DISPOSITION_##flagname)); \
2588     } while (0)
2589
2590     if (do_show_stream_disposition) {
2591     writer_print_section_header(w, in_program ? SECTION_ID_PROGRAM_STREAM_DISPOSITION : SECTION_ID_STREAM_DISPOSITION);
2592     PRINT_DISPOSITION(DEFAULT,          "default");
2593     PRINT_DISPOSITION(DUB,              "dub");
2594     PRINT_DISPOSITION(ORIGINAL,         "original");
2595     PRINT_DISPOSITION(COMMENT,          "comment");
2596     PRINT_DISPOSITION(LYRICS,           "lyrics");
2597     PRINT_DISPOSITION(KARAOKE,          "karaoke");
2598     PRINT_DISPOSITION(FORCED,           "forced");
2599     PRINT_DISPOSITION(HEARING_IMPAIRED, "hearing_impaired");
2600     PRINT_DISPOSITION(VISUAL_IMPAIRED,  "visual_impaired");
2601     PRINT_DISPOSITION(CLEAN_EFFECTS,    "clean_effects");
2602     PRINT_DISPOSITION(ATTACHED_PIC,     "attached_pic");
2603     PRINT_DISPOSITION(TIMED_THUMBNAILS, "timed_thumbnails");
2604     writer_print_section_footer(w);
2605     }
2606
2607     if (do_show_stream_tags)
2608         ret = show_tags(w, stream->metadata, in_program ? SECTION_ID_PROGRAM_STREAM_TAGS : SECTION_ID_STREAM_TAGS);
2609
2610     if (stream->nb_side_data) {
2611         print_pkt_side_data(w, stream->codecpar, stream->side_data, stream->nb_side_data,
2612                             SECTION_ID_STREAM_SIDE_DATA_LIST,
2613                             SECTION_ID_STREAM_SIDE_DATA);
2614     }
2615
2616     writer_print_section_footer(w);
2617     av_bprint_finalize(&pbuf, NULL);
2618     fflush(stdout);
2619
2620     return ret;
2621 }
2622
2623 static int show_streams(WriterContext *w, InputFile *ifile)
2624 {
2625     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2626     int i, ret = 0;
2627
2628     writer_print_section_header(w, SECTION_ID_STREAMS);
2629     for (i = 0; i < ifile->nb_streams; i++)
2630         if (selected_streams[i]) {
2631             ret = show_stream(w, fmt_ctx, i, &ifile->streams[i], 0);
2632             if (ret < 0)
2633                 break;
2634         }
2635     writer_print_section_footer(w);
2636
2637     return ret;
2638 }
2639
2640 static int show_program(WriterContext *w, InputFile *ifile, AVProgram *program)
2641 {
2642     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2643     int i, ret = 0;
2644
2645     writer_print_section_header(w, SECTION_ID_PROGRAM);
2646     print_int("program_id", program->id);
2647     print_int("program_num", program->program_num);
2648     print_int("nb_streams", program->nb_stream_indexes);
2649     print_int("pmt_pid", program->pmt_pid);
2650     print_int("pcr_pid", program->pcr_pid);
2651     print_ts("start_pts", program->start_time);
2652     print_time("start_time", program->start_time, &AV_TIME_BASE_Q);
2653     print_ts("end_pts", program->end_time);
2654     print_time("end_time", program->end_time, &AV_TIME_BASE_Q);
2655     if (do_show_program_tags)
2656         ret = show_tags(w, program->metadata, SECTION_ID_PROGRAM_TAGS);
2657     if (ret < 0)
2658         goto end;
2659
2660     writer_print_section_header(w, SECTION_ID_PROGRAM_STREAMS);
2661     for (i = 0; i < program->nb_stream_indexes; i++) {
2662         if (selected_streams[program->stream_index[i]]) {
2663             ret = show_stream(w, fmt_ctx, program->stream_index[i], &ifile->streams[program->stream_index[i]], 1);
2664             if (ret < 0)
2665                 break;
2666         }
2667     }
2668     writer_print_section_footer(w);
2669
2670 end:
2671     writer_print_section_footer(w);
2672     return ret;
2673 }
2674
2675 static int show_programs(WriterContext *w, InputFile *ifile)
2676 {
2677     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2678     int i, ret = 0;
2679
2680     writer_print_section_header(w, SECTION_ID_PROGRAMS);
2681     for (i = 0; i < fmt_ctx->nb_programs; i++) {
2682         AVProgram *program = fmt_ctx->programs[i];
2683         if (!program)
2684             continue;
2685         ret = show_program(w, ifile, program);
2686         if (ret < 0)
2687             break;
2688     }
2689     writer_print_section_footer(w);
2690     return ret;
2691 }
2692
2693 static int show_chapters(WriterContext *w, InputFile *ifile)
2694 {
2695     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2696     int i, ret = 0;
2697
2698     writer_print_section_header(w, SECTION_ID_CHAPTERS);
2699     for (i = 0; i < fmt_ctx->nb_chapters; i++) {
2700         AVChapter *chapter = fmt_ctx->chapters[i];
2701
2702         writer_print_section_header(w, SECTION_ID_CHAPTER);
2703         print_int("id", chapter->id);
2704         print_q  ("time_base", chapter->time_base, '/');
2705         print_int("start", chapter->start);
2706         print_time("start_time", chapter->start, &chapter->time_base);
2707         print_int("end", chapter->end);
2708         print_time("end_time", chapter->end, &chapter->time_base);
2709         if (do_show_chapter_tags)
2710             ret = show_tags(w, chapter->metadata, SECTION_ID_CHAPTER_TAGS);
2711         writer_print_section_footer(w);
2712     }
2713     writer_print_section_footer(w);
2714
2715     return ret;
2716 }
2717
2718 static int show_format(WriterContext *w, InputFile *ifile)
2719 {
2720     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
2721     char val_str[128];
2722     int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
2723     int ret = 0;
2724
2725     writer_print_section_header(w, SECTION_ID_FORMAT);
2726     print_str_validate("filename", fmt_ctx->filename);
2727     print_int("nb_streams",       fmt_ctx->nb_streams);
2728     print_int("nb_programs",      fmt_ctx->nb_programs);
2729     print_str("format_name",      fmt_ctx->iformat->name);
2730     if (!do_bitexact) {
2731         if (fmt_ctx->iformat->long_name) print_str    ("format_long_name", fmt_ctx->iformat->long_name);
2732         else                             print_str_opt("format_long_name", "unknown");
2733     }
2734     print_time("start_time",      fmt_ctx->start_time, &AV_TIME_BASE_Q);
2735     print_time("duration",        fmt_ctx->duration,   &AV_TIME_BASE_Q);
2736     if (size >= 0) print_val    ("size", size, unit_byte_str);
2737     else           print_str_opt("size", "N/A");
2738     if (fmt_ctx->bit_rate > 0) print_val    ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
2739     else                       print_str_opt("bit_rate", "N/A");
2740     print_int("probe_score", av_format_get_probe_score(fmt_ctx));
2741     if (do_show_format_tags)
2742         ret = show_tags(w, fmt_ctx->metadata, SECTION_ID_FORMAT_TAGS);
2743
2744     writer_print_section_footer(w);
2745     fflush(stdout);
2746     return ret;
2747 }
2748
2749 static void show_error(WriterContext *w, int err)
2750 {
2751     char errbuf[128];
2752     const char *errbuf_ptr = errbuf;
2753
2754     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
2755         errbuf_ptr = strerror(AVUNERROR(err));
2756
2757     writer_print_section_header(w, SECTION_ID_ERROR);
2758     print_int("code", err);
2759     print_str("string", errbuf_ptr);
2760     writer_print_section_footer(w);
2761 }
2762
2763 static int open_input_file(InputFile *ifile, const char *filename)
2764 {
2765     int err, i, orig_nb_streams;
2766     AVFormatContext *fmt_ctx = NULL;
2767     AVDictionaryEntry *t;
2768     AVDictionary **opts;
2769     int scan_all_pmts_set = 0;
2770
2771     fmt_ctx = avformat_alloc_context();
2772     if (!fmt_ctx) {
2773         print_error(filename, AVERROR(ENOMEM));
2774         exit_program(1);
2775     }
2776
2777     fmt_ctx->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
2778
2779     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2780         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2781         scan_all_pmts_set = 1;
2782     }
2783     if ((err = avformat_open_input(&fmt_ctx, filename,
2784                                    iformat, &format_opts)) < 0) {
2785         print_error(filename, err);
2786         return err;
2787     }
2788     ifile->fmt_ctx = fmt_ctx;
2789     if (scan_all_pmts_set)
2790         av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2791     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2792         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2793         return AVERROR_OPTION_NOT_FOUND;
2794     }
2795
2796     /* fill the streams in the format context */
2797     opts = setup_find_stream_info_opts(fmt_ctx, codec_opts);
2798     orig_nb_streams = fmt_ctx->nb_streams;
2799
2800     err = avformat_find_stream_info(fmt_ctx, opts);
2801
2802     for (i = 0; i < orig_nb_streams; i++)
2803         av_dict_free(&opts[i]);
2804     av_freep(&opts);
2805
2806     if (err < 0) {
2807         print_error(filename, err);
2808         return err;
2809     }
2810
2811     av_dump_format(fmt_ctx, 0, filename, 0);
2812
2813     ifile->streams = av_mallocz_array(fmt_ctx->nb_streams,
2814                                       sizeof(*ifile->streams));
2815     if (!ifile->streams)
2816         exit(1);
2817     ifile->nb_streams = fmt_ctx->nb_streams;
2818
2819     /* bind a decoder to each input stream */
2820     for (i = 0; i < fmt_ctx->nb_streams; i++) {
2821         InputStream *ist = &ifile->streams[i];
2822         AVStream *stream = fmt_ctx->streams[i];
2823         AVCodec *codec;
2824
2825         ist->st = stream;
2826
2827         if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
2828             av_log(NULL, AV_LOG_WARNING,
2829                    "Failed to probe codec for input stream %d\n",
2830                     stream->index);
2831             continue;
2832         }
2833
2834         codec = avcodec_find_decoder(stream->codecpar->codec_id);
2835         if (!codec) {
2836             av_log(NULL, AV_LOG_WARNING,
2837                     "Unsupported codec with id %d for input stream %d\n",
2838                     stream->codecpar->codec_id, stream->index);
2839             continue;
2840         }
2841         {
2842             AVDictionary *opts = filter_codec_opts(codec_opts, stream->codecpar->codec_id,
2843                                                    fmt_ctx, stream, codec);
2844
2845             ist->dec_ctx = avcodec_alloc_context3(codec);
2846             if (!ist->dec_ctx)
2847                 exit(1);
2848
2849             err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
2850             if (err < 0)
2851                 exit(1);
2852
2853             if (do_show_log) {
2854                 // For loging it is needed to disable at least frame threads as otherwise
2855                 // the log information would need to be reordered and matches up to contexts and frames
2856                 // That is in fact possible but not trivial
2857                 av_dict_set(&codec_opts, "threads", "1", 0);
2858             }
2859
2860             av_codec_set_pkt_timebase(ist->dec_ctx, stream->time_base);
2861             ist->dec_ctx->framerate = stream->avg_frame_rate;
2862
2863             if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
2864                 av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
2865                        stream->index);
2866                 exit(1);
2867             }
2868
2869             if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2870                 av_log(NULL, AV_LOG_ERROR, "Option %s for input stream %d not found\n",
2871                        t->key, stream->index);
2872                 return AVERROR_OPTION_NOT_FOUND;
2873             }
2874         }
2875     }
2876
2877     ifile->fmt_ctx = fmt_ctx;
2878     return 0;
2879 }
2880
2881 static void close_input_file(InputFile *ifile)
2882 {
2883     int i;
2884
2885     /* close decoder for each stream */
2886     for (i = 0; i < ifile->nb_streams; i++)
2887         if (ifile->streams[i].st->codecpar->codec_id != AV_CODEC_ID_NONE)
2888             avcodec_free_context(&ifile->streams[i].dec_ctx);
2889
2890     av_freep(&ifile->streams);
2891     ifile->nb_streams = 0;
2892
2893     avformat_close_input(&ifile->fmt_ctx);
2894 }
2895
2896 static int probe_file(WriterContext *wctx, const char *filename)
2897 {
2898     InputFile ifile = { 0 };
2899     int ret, i;
2900     int section_id;
2901
2902     do_read_frames = do_show_frames || do_count_frames;
2903     do_read_packets = do_show_packets || do_count_packets;
2904
2905     ret = open_input_file(&ifile, filename);
2906     if (ret < 0)
2907         goto end;
2908
2909 #define CHECK_END if (ret < 0) goto end
2910
2911     nb_streams = ifile.fmt_ctx->nb_streams;
2912     REALLOCZ_ARRAY_STREAM(nb_streams_frames,0,ifile.fmt_ctx->nb_streams);
2913     REALLOCZ_ARRAY_STREAM(nb_streams_packets,0,ifile.fmt_ctx->nb_streams);
2914     REALLOCZ_ARRAY_STREAM(selected_streams,0,ifile.fmt_ctx->nb_streams);
2915
2916     for (i = 0; i < ifile.fmt_ctx->nb_streams; i++) {
2917         if (stream_specifier) {
2918             ret = avformat_match_stream_specifier(ifile.fmt_ctx,
2919                                                   ifile.fmt_ctx->streams[i],
2920                                                   stream_specifier);
2921             CHECK_END;
2922             else
2923                 selected_streams[i] = ret;
2924             ret = 0;
2925         } else {
2926             selected_streams[i] = 1;
2927         }
2928         if (!selected_streams[i])
2929             ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
2930     }
2931
2932     if (do_read_frames || do_read_packets) {
2933         if (do_show_frames && do_show_packets &&
2934             wctx->writer->flags & WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER)
2935             section_id = SECTION_ID_PACKETS_AND_FRAMES;
2936         else if (do_show_packets && !do_show_frames)
2937             section_id = SECTION_ID_PACKETS;
2938         else // (!do_show_packets && do_show_frames)
2939             section_id = SECTION_ID_FRAMES;
2940         if (do_show_frames || do_show_packets)
2941             writer_print_section_header(wctx, section_id);
2942         ret = read_packets(wctx, &ifile);
2943         if (do_show_frames || do_show_packets)
2944             writer_print_section_footer(wctx);
2945         CHECK_END;
2946     }
2947
2948     if (do_show_programs) {
2949         ret = show_programs(wctx, &ifile);
2950         CHECK_END;
2951     }
2952
2953     if (do_show_streams) {
2954         ret = show_streams(wctx, &ifile);
2955         CHECK_END;
2956     }
2957     if (do_show_chapters) {
2958         ret = show_chapters(wctx, &ifile);
2959         CHECK_END;
2960     }
2961     if (do_show_format) {
2962         ret = show_format(wctx, &ifile);
2963         CHECK_END;
2964     }
2965
2966 end:
2967     if (ifile.fmt_ctx)
2968         close_input_file(&ifile);
2969     av_freep(&nb_streams_frames);
2970     av_freep(&nb_streams_packets);
2971     av_freep(&selected_streams);
2972
2973     return ret;
2974 }
2975
2976 static void show_usage(void)
2977 {
2978     av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
2979     av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] [INPUT_FILE]\n", program_name);
2980     av_log(NULL, AV_LOG_INFO, "\n");
2981 }
2982
2983 static void ffprobe_show_program_version(WriterContext *w)
2984 {
2985     AVBPrint pbuf;
2986     av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
2987
2988     writer_print_section_header(w, SECTION_ID_PROGRAM_VERSION);
2989     print_str("version", FFMPEG_VERSION);
2990     print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
2991               program_birth_year, CONFIG_THIS_YEAR);
2992     print_str("compiler_ident", CC_IDENT);
2993     print_str("configuration", FFMPEG_CONFIGURATION);
2994     writer_print_section_footer(w);
2995
2996     av_bprint_finalize(&pbuf, NULL);
2997 }
2998
2999 #define SHOW_LIB_VERSION(libname, LIBNAME)                              \
3000     do {                                                                \
3001         if (CONFIG_##LIBNAME) {                                         \
3002             unsigned int version = libname##_version();                 \
3003             writer_print_section_header(w, SECTION_ID_LIBRARY_VERSION); \
3004             print_str("name",    "lib" #libname);                       \
3005             print_int("major",   LIB##LIBNAME##_VERSION_MAJOR);         \
3006             print_int("minor",   LIB##LIBNAME##_VERSION_MINOR);         \
3007             print_int("micro",   LIB##LIBNAME##_VERSION_MICRO);         \
3008             print_int("version", version);                              \
3009             print_str("ident",   LIB##LIBNAME##_IDENT);                 \
3010             writer_print_section_footer(w);                             \
3011         }                                                               \
3012     } while (0)
3013
3014 static void ffprobe_show_library_versions(WriterContext *w)
3015 {
3016     writer_print_section_header(w, SECTION_ID_LIBRARY_VERSIONS);
3017     SHOW_LIB_VERSION(avutil,     AVUTIL);
3018     SHOW_LIB_VERSION(avcodec,    AVCODEC);
3019     SHOW_LIB_VERSION(avformat,   AVFORMAT);
3020     SHOW_LIB_VERSION(avdevice,   AVDEVICE);
3021     SHOW_LIB_VERSION(avfilter,   AVFILTER);
3022     SHOW_LIB_VERSION(swscale,    SWSCALE);
3023     SHOW_LIB_VERSION(swresample, SWRESAMPLE);
3024     SHOW_LIB_VERSION(postproc,   POSTPROC);
3025     writer_print_section_footer(w);
3026 }
3027
3028 #define PRINT_PIX_FMT_FLAG(flagname, name)                                \
3029     do {                                                                  \
3030         print_int(name, !!(pixdesc->flags & AV_PIX_FMT_FLAG_##flagname)); \
3031     } while (0)
3032
3033 static void ffprobe_show_pixel_formats(WriterContext *w)
3034 {
3035     const AVPixFmtDescriptor *pixdesc = NULL;
3036     int i, n;
3037
3038     writer_print_section_header(w, SECTION_ID_PIXEL_FORMATS);
3039     while (pixdesc = av_pix_fmt_desc_next(pixdesc)) {
3040         writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT);
3041         print_str("name", pixdesc->name);
3042         print_int("nb_components", pixdesc->nb_components);
3043         if ((pixdesc->nb_components >= 3) && !(pixdesc->flags & AV_PIX_FMT_FLAG_RGB)) {
3044             print_int    ("log2_chroma_w", pixdesc->log2_chroma_w);
3045             print_int    ("log2_chroma_h", pixdesc->log2_chroma_h);
3046         } else {
3047             print_str_opt("log2_chroma_w", "N/A");
3048             print_str_opt("log2_chroma_h", "N/A");
3049         }
3050         n = av_get_bits_per_pixel(pixdesc);
3051         if (n) print_int    ("bits_per_pixel", n);
3052         else   print_str_opt("bits_per_pixel", "N/A");
3053         if (do_show_pixel_format_flags) {
3054             writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT_FLAGS);
3055             PRINT_PIX_FMT_FLAG(BE,        "big_endian");
3056             PRINT_PIX_FMT_FLAG(PAL,       "palette");
3057             PRINT_PIX_FMT_FLAG(BITSTREAM, "bitstream");
3058             PRINT_PIX_FMT_FLAG(HWACCEL,   "hwaccel");
3059             PRINT_PIX_FMT_FLAG(PLANAR,    "planar");
3060             PRINT_PIX_FMT_FLAG(RGB,       "rgb");
3061             PRINT_PIX_FMT_FLAG(PSEUDOPAL, "pseudopal");
3062             PRINT_PIX_FMT_FLAG(ALPHA,     "alpha");
3063             writer_print_section_footer(w);
3064         }
3065         if (do_show_pixel_format_components && (pixdesc->nb_components > 0)) {
3066             writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT_COMPONENTS);
3067             for (i = 0; i < pixdesc->nb_components; i++) {
3068                 writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT_COMPONENT);
3069                 print_int("index", i + 1);
3070                 print_int("bit_depth", pixdesc->comp[i].depth);
3071                 writer_print_section_footer(w);
3072             }
3073             writer_print_section_footer(w);
3074         }
3075         writer_print_section_footer(w);
3076     }
3077     writer_print_section_footer(w);
3078 }
3079
3080 static int opt_format(void *optctx, const char *opt, const char *arg)
3081 {
3082     iformat = av_find_input_format(arg);
3083     if (!iformat) {
3084         av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
3085         return AVERROR(EINVAL);
3086     }
3087     return 0;
3088 }
3089
3090 static inline void mark_section_show_entries(SectionID section_id,
3091                                              int show_all_entries, AVDictionary *entries)
3092 {
3093     struct section *section = &sections[section_id];
3094
3095     section->show_all_entries = show_all_entries;
3096     if (show_all_entries) {
3097         SectionID *id;
3098         for (id = section->children_ids; *id != -1; id++)
3099             mark_section_show_entries(*id, show_all_entries, entries);
3100     } else {
3101         av_dict_copy(&section->entries_to_show, entries, 0);
3102     }
3103 }
3104
3105 static int match_section(const char *section_name,
3106                          int show_all_entries, AVDictionary *entries)
3107 {
3108     int i, ret = 0;
3109
3110     for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) {
3111         const struct section *section = &sections[i];
3112         if (!strcmp(section_name, section->name) ||
3113             (section->unique_name && !strcmp(section_name, section->unique_name))) {
3114             av_log(NULL, AV_LOG_DEBUG,
3115                    "'%s' matches section with unique name '%s'\n", section_name,
3116                    (char *)av_x_if_null(section->unique_name, section->name));
3117             ret++;
3118             mark_section_show_entries(section->id, show_all_entries, entries);
3119         }
3120     }
3121     return ret;
3122 }
3123
3124 static int opt_show_entries(void *optctx, const char *opt, const char *arg)
3125 {
3126     const char *p = arg;
3127     int ret = 0;
3128
3129     while (*p) {
3130         AVDictionary *entries = NULL;
3131         char *section_name = av_get_token(&p, "=:");
3132         int show_all_entries = 0;
3133
3134         if (!section_name) {
3135             av_log(NULL, AV_LOG_ERROR,
3136                    "Missing section name for option '%s'\n", opt);
3137             return AVERROR(EINVAL);
3138         }
3139
3140         if (*p == '=') {
3141             p++;
3142             while (*p && *p != ':') {
3143                 char *entry = av_get_token(&p, ",:");
3144                 if (!entry)
3145                     break;
3146                 av_log(NULL, AV_LOG_VERBOSE,
3147                        "Adding '%s' to the entries to show in section '%s'\n",
3148                        entry, section_name);
3149                 av_dict_set(&entries, entry, "", AV_DICT_DONT_STRDUP_KEY);
3150                 if (*p == ',')
3151                     p++;
3152             }
3153         } else {
3154             show_all_entries = 1;
3155         }
3156
3157         ret = match_section(section_name, show_all_entries, entries);
3158         if (ret == 0) {
3159             av_log(NULL, AV_LOG_ERROR, "No match for section '%s'\n", section_name);
3160             ret = AVERROR(EINVAL);
3161         }
3162         av_dict_free(&entries);
3163         av_free(section_name);
3164
3165         if (ret <= 0)
3166             break;
3167         if (*p)
3168             p++;
3169     }
3170
3171     return ret;
3172 }
3173
3174 static int opt_show_format_entry(void *optctx, const char *opt, const char *arg)
3175 {
3176     char *buf = av_asprintf("format=%s", arg);
3177     int ret;
3178
3179     if (!buf)
3180         return AVERROR(ENOMEM);
3181
3182     av_log(NULL, AV_LOG_WARNING,
3183            "Option '%s' is deprecated, use '-show_entries format=%s' instead\n",
3184            opt, arg);
3185     ret = opt_show_entries(optctx, opt, buf);
3186     av_free(buf);
3187     return ret;
3188 }
3189
3190 static void opt_input_file(void *optctx, const char *arg)
3191 {
3192     if (input_filename) {
3193         av_log(NULL, AV_LOG_ERROR,
3194                 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3195                 arg, input_filename);
3196         exit_program(1);
3197     }
3198     if (!strcmp(arg, "-"))
3199         arg = "pipe:";
3200     input_filename = arg;
3201 }
3202
3203 static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
3204 {
3205     opt_input_file(optctx, arg);
3206     return 0;
3207 }
3208
3209 void show_help_default(const char *opt, const char *arg)
3210 {
3211     av_log_set_callback(log_callback_help);
3212     show_usage();
3213     show_help_options(options, "Main options:", 0, 0, 0);
3214     printf("\n");
3215
3216     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3217     show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3218 }
3219
3220 /**
3221  * Parse interval specification, according to the format:
3222  * INTERVAL ::= [START|+START_OFFSET][%[END|+END_OFFSET]]
3223  * INTERVALS ::= INTERVAL[,INTERVALS]
3224 */
3225 static int parse_read_interval(const char *interval_spec,
3226                                ReadInterval *interval)
3227 {
3228     int ret = 0;
3229     char *next, *p, *spec = av_strdup(interval_spec);
3230     if (!spec)
3231         return AVERROR(ENOMEM);
3232
3233     if (!*spec) {
3234         av_log(NULL, AV_LOG_ERROR, "Invalid empty interval specification\n");
3235         ret = AVERROR(EINVAL);
3236         goto end;
3237     }
3238
3239     p = spec;
3240     next = strchr(spec, '%');
3241     if (next)
3242         *next++ = 0;
3243
3244     /* parse first part */
3245     if (*p) {
3246         interval->has_start = 1;
3247
3248         if (*p == '+') {
3249             interval->start_is_offset = 1;
3250             p++;
3251         } else {
3252             interval->start_is_offset = 0;
3253         }
3254
3255         ret = av_parse_time(&interval->start, p, 1);
3256         if (ret < 0) {
3257             av_log(NULL, AV_LOG_ERROR, "Invalid interval start specification '%s'\n", p);
3258             goto end;
3259         }
3260     } else {
3261         interval->has_start = 0;
3262     }
3263
3264     /* parse second part */
3265     p = next;
3266     if (p && *p) {
3267         int64_t us;
3268         interval->has_end = 1;
3269
3270         if (*p == '+') {
3271             interval->end_is_offset = 1;
3272             p++;
3273         } else {
3274             interval->end_is_offset = 0;
3275         }
3276
3277         if (interval->end_is_offset && *p == '#') {
3278             long long int lli;
3279             char *tail;
3280             interval->duration_frames = 1;
3281             p++;
3282             lli = strtoll(p, &tail, 10);
3283             if (*tail || lli < 0) {
3284                 av_log(NULL, AV_LOG_ERROR,
3285                        "Invalid or negative value '%s' for duration number of frames\n", p);
3286                 goto end;
3287             }
3288             interval->end = lli;
3289         } else {
3290             ret = av_parse_time(&us, p, 1);
3291             if (ret < 0) {
3292                 av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
3293                 goto end;
3294             }
3295             interval->end = us;
3296         }
3297     } else {
3298         interval->has_end = 0;
3299     }
3300
3301 end:
3302     av_free(spec);
3303     return ret;
3304 }
3305
3306 static int parse_read_intervals(const char *intervals_spec)
3307 {
3308     int ret, n, i;
3309     char *p, *spec = av_strdup(intervals_spec);
3310     if (!spec)
3311         return AVERROR(ENOMEM);
3312
3313     /* preparse specification, get number of intervals */
3314     for (n = 0, p = spec; *p; p++)
3315         if (*p == ',')
3316             n++;
3317     n++;
3318
3319     read_intervals = av_malloc_array(n, sizeof(*read_intervals));
3320     if (!read_intervals) {
3321         ret = AVERROR(ENOMEM);
3322         goto end;
3323     }
3324     read_intervals_nb = n;
3325
3326     /* parse intervals */
3327     p = spec;
3328     for (i = 0; p; i++) {
3329         char *next;
3330
3331         av_assert0(i < read_intervals_nb);
3332         next = strchr(p, ',');
3333         if (next)
3334             *next++ = 0;
3335
3336         read_intervals[i].id = i;
3337         ret = parse_read_interval(p, &read_intervals[i]);
3338         if (ret < 0) {
3339             av_log(NULL, AV_LOG_ERROR, "Error parsing read interval #%d '%s'\n",
3340                    i, p);
3341             goto end;
3342         }
3343         av_log(NULL, AV_LOG_VERBOSE, "Parsed log interval ");
3344         log_read_interval(&read_intervals[i], NULL, AV_LOG_VERBOSE);
3345         p = next;
3346     }
3347     av_assert0(i == read_intervals_nb);
3348
3349 end:
3350     av_free(spec);
3351     return ret;
3352 }
3353
3354 static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
3355 {
3356     return parse_read_intervals(arg);
3357 }
3358
3359 static int opt_pretty(void *optctx, const char *opt, const char *arg)
3360 {
3361     show_value_unit              = 1;
3362     use_value_prefix             = 1;
3363     use_byte_value_binary_prefix = 1;
3364     use_value_sexagesimal_format = 1;
3365     return 0;
3366 }
3367
3368 static void print_section(SectionID id, int level)
3369 {
3370     const SectionID *pid;
3371     const struct section *section = &sections[id];
3372     printf("%c%c%c",
3373            section->flags & SECTION_FLAG_IS_WRAPPER           ? 'W' : '.',
3374            section->flags & SECTION_FLAG_IS_ARRAY             ? 'A' : '.',
3375            section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS  ? 'V' : '.');
3376     printf("%*c  %s", level * 4, ' ', section->name);
3377     if (section->unique_name)
3378         printf("/%s", section->unique_name);
3379     printf("\n");
3380
3381     for (pid = section->children_ids; *pid != -1; pid++)
3382         print_section(*pid, level+1);
3383 }
3384
3385 static int opt_sections(void *optctx, const char *opt, const char *arg)
3386 {
3387     printf("Sections:\n"
3388            "W.. = Section is a wrapper (contains other sections, no local entries)\n"
3389            ".A. = Section contains an array of elements of the same type\n"
3390            "..V = Section may contain a variable number of fields with variable keys\n"
3391            "FLAGS NAME/UNIQUE_NAME\n"
3392            "---\n");
3393     print_section(SECTION_ID_ROOT, 0);
3394     return 0;
3395 }
3396
3397 static int opt_show_versions(const char *opt, const char *arg)
3398 {
3399     mark_section_show_entries(SECTION_ID_PROGRAM_VERSION, 1, NULL);
3400     mark_section_show_entries(SECTION_ID_LIBRARY_VERSION, 1, NULL);
3401     return 0;
3402 }
3403
3404 #define DEFINE_OPT_SHOW_SECTION(section, target_section_id)             \
3405     static int opt_show_##section(const char *opt, const char *arg)     \
3406     {                                                                   \
3407         mark_section_show_entries(SECTION_ID_##target_section_id, 1, NULL); \
3408         return 0;                                                       \
3409     }
3410
3411 DEFINE_OPT_SHOW_SECTION(chapters,         CHAPTERS)
3412 DEFINE_OPT_SHOW_SECTION(error,            ERROR)
3413 DEFINE_OPT_SHOW_SECTION(format,           FORMAT)
3414 DEFINE_OPT_SHOW_SECTION(frames,           FRAMES)
3415 DEFINE_OPT_SHOW_SECTION(library_versions, LIBRARY_VERSIONS)
3416 DEFINE_OPT_SHOW_SECTION(packets,          PACKETS)
3417 DEFINE_OPT_SHOW_SECTION(pixel_formats,    PIXEL_FORMATS)
3418 DEFINE_OPT_SHOW_SECTION(program_version,  PROGRAM_VERSION)
3419 DEFINE_OPT_SHOW_SECTION(streams,          STREAMS)
3420 DEFINE_OPT_SHOW_SECTION(programs,         PROGRAMS)
3421
3422 static const OptionDef real_options[] = {
3423     CMDUTILS_COMMON_OPTIONS
3424     { "f", HAS_ARG, {.func_arg = opt_format}, "force format", "format" },
3425     { "unit", OPT_BOOL, {&show_value_unit}, "show unit of the displayed values" },
3426     { "prefix", OPT_BOOL, {&use_value_prefix}, "use SI prefixes for the displayed values" },
3427     { "byte_binary_prefix", OPT_BOOL, {&use_byte_value_binary_prefix},
3428       "use binary prefixes for byte units" },
3429     { "sexagesimal", OPT_BOOL,  {&use_value_sexagesimal_format},
3430       "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
3431     { "pretty", 0, {.func_arg = opt_pretty},
3432       "prettify the format of displayed values, make it more human readable" },
3433     { "print_format", OPT_STRING | HAS_ARG, {(void*)&print_format},
3434       "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
3435     { "of", OPT_STRING | HAS_ARG, {(void*)&print_format}, "alias for -print_format", "format" },
3436     { "select_streams", OPT_STRING | HAS_ARG, {(void*)&stream_specifier}, "select the specified streams", "stream_specifier" },
3437     { "sections", OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
3438     { "show_data",    OPT_BOOL, {(void*)&do_show_data}, "show packets data" },
3439     { "show_data_hash", OPT_STRING | HAS_ARG, {(void*)&show_data_hash}, "show packets data hash" },
3440     { "show_error",   0, {(void*)&opt_show_error},  "show probing error" },
3441     { "show_format",  0, {(void*)&opt_show_format}, "show format/container info" },
3442     { "show_frames",  0, {(void*)&opt_show_frames}, "show frames info" },
3443     { "show_format_entry", HAS_ARG, {.func_arg = opt_show_format_entry},
3444       "show a particular entry from the format/container info", "entry" },
3445     { "show_entries", HAS_ARG, {.func_arg = opt_show_entries},
3446       "show a set of specified entries", "entry_list" },
3447 #if HAVE_THREADS
3448     { "show_log", OPT_INT|HAS_ARG, {(void*)&do_show_log}, "show log" },
3449 #endif
3450     { "show_packets", 0, {(void*)&opt_show_packets}, "show packets info" },
3451     { "show_programs", 0, {(void*)&opt_show_programs}, "show programs info" },
3452     { "show_streams", 0, {(void*)&opt_show_streams}, "show streams info" },
3453     { "show_chapters", 0, {(void*)&opt_show_chapters}, "show chapters info" },
3454     { "count_frames", OPT_BOOL, {(void*)&do_count_frames}, "count the number of frames per stream" },
3455     { "count_packets", OPT_BOOL, {(void*)&do_count_packets}, "count the number of packets per stream" },
3456     { "show_program_version",  0, {(void*)&opt_show_program_version},  "show ffprobe version" },
3457     { "show_library_versions", 0, {(void*)&opt_show_library_versions}, "show library versions" },
3458     { "show_versions",         0, {(void*)&opt_show_versions}, "show program and library versions" },
3459     { "show_pixel_formats", 0, {(void*)&opt_show_pixel_formats}, "show pixel format descriptions" },
3460     { "show_private_data", OPT_BOOL, {(void*)&show_private_data}, "show private data" },
3461     { "private",           OPT_BOOL, {(void*)&show_private_data}, "same as show_private_data" },
3462     { "bitexact", OPT_BOOL, {&do_bitexact}, "force bitexact output" },
3463     { "read_intervals", HAS_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
3464     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default}, "generic catch all option", "" },
3465     { "i", HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
3466     { NULL, },
3467 };
3468
3469 static inline int check_section_show_entries(int section_id)
3470 {
3471     int *id;
3472     struct section *section = &sections[section_id];
3473     if (sections[section_id].show_all_entries || sections[section_id].entries_to_show)
3474         return 1;
3475     for (id = section->children_ids; *id != -1; id++)
3476         if (check_section_show_entries(*id))
3477             return 1;
3478     return 0;
3479 }
3480
3481 #define SET_DO_SHOW(id, varname) do {                                   \
3482         if (check_section_show_entries(SECTION_ID_##id))                \
3483             do_show_##varname = 1;                                      \
3484     } while (0)
3485
3486 int main(int argc, char **argv)
3487 {
3488     const Writer *w;
3489     WriterContext *wctx;
3490     char *buf;
3491     char *w_name = NULL, *w_args = NULL;
3492     int ret, i;
3493
3494     init_dynload();
3495
3496 #if HAVE_THREADS
3497     ret = pthread_mutex_init(&log_mutex, NULL);
3498     if (ret != 0) {
3499         goto end;
3500     }
3501 #endif
3502     av_log_set_flags(AV_LOG_SKIP_REPEATED);
3503     register_exit(ffprobe_cleanup);
3504
3505     options = real_options;
3506     parse_loglevel(argc, argv, options);
3507     av_register_all();
3508     avformat_network_init();
3509     init_opts();
3510 #if CONFIG_AVDEVICE
3511     avdevice_register_all();
3512 #endif
3513
3514     show_banner(argc, argv, options);
3515     parse_options(NULL, argc, argv, options, opt_input_file);
3516
3517     if (do_show_log)
3518         av_log_set_callback(log_callback);
3519
3520     /* mark things to show, based on -show_entries */
3521     SET_DO_SHOW(CHAPTERS, chapters);
3522     SET_DO_SHOW(ERROR, error);
3523     SET_DO_SHOW(FORMAT, format);
3524     SET_DO_SHOW(FRAMES, frames);
3525     SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
3526     SET_DO_SHOW(PACKETS, packets);
3527     SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
3528     SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
3529     SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
3530     SET_DO_SHOW(PROGRAM_VERSION, program_version);
3531     SET_DO_SHOW(PROGRAMS, programs);
3532     SET_DO_SHOW(STREAMS, streams);
3533     SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
3534     SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
3535
3536     SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
3537     SET_DO_SHOW(FORMAT_TAGS, format_tags);
3538     SET_DO_SHOW(FRAME_TAGS, frame_tags);
3539     SET_DO_SHOW(PROGRAM_TAGS, program_tags);
3540     SET_DO_SHOW(STREAM_TAGS, stream_tags);
3541     SET_DO_SHOW(PROGRAM_STREAM_TAGS, stream_tags);
3542     SET_DO_SHOW(PACKET_TAGS, packet_tags);
3543
3544     if (do_bitexact && (do_show_program_version || do_show_library_versions)) {
3545         av_log(NULL, AV_LOG_ERROR,
3546                "-bitexact and -show_program_version or -show_library_versions "
3547                "options are incompatible\n");
3548         ret = AVERROR(EINVAL);
3549         goto end;
3550     }
3551
3552     writer_register_all();
3553
3554     if (!print_format)
3555         print_format = av_strdup("default");
3556     if (!print_format) {
3557         ret = AVERROR(ENOMEM);
3558         goto end;
3559     }
3560     w_name = av_strtok(print_format, "=", &buf);
3561     if (!w_name) {
3562         av_log(NULL, AV_LOG_ERROR,
3563                "No name specified for the output format\n");
3564         ret = AVERROR(EINVAL);
3565         goto end;
3566     }
3567     w_args = buf;
3568
3569     if (show_data_hash) {
3570         if ((ret = av_hash_alloc(&hash, show_data_hash)) < 0) {
3571             if (ret == AVERROR(EINVAL)) {
3572                 const char *n;
3573                 av_log(NULL, AV_LOG_ERROR,
3574                        "Unknown hash algorithm '%s'\nKnown algorithms:",
3575                        show_data_hash);
3576                 for (i = 0; (n = av_hash_names(i)); i++)
3577                     av_log(NULL, AV_LOG_ERROR, " %s", n);
3578                 av_log(NULL, AV_LOG_ERROR, "\n");
3579             }
3580             goto end;
3581         }
3582     }
3583
3584     w = writer_get_by_name(w_name);
3585     if (!w) {
3586         av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
3587         ret = AVERROR(EINVAL);
3588         goto end;
3589     }
3590
3591     if ((ret = writer_open(&wctx, w, w_args,
3592                            sections, FF_ARRAY_ELEMS(sections))) >= 0) {
3593         if (w == &xml_writer)
3594             wctx->string_validation_utf8_flags |= AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES;
3595
3596         writer_print_section_header(wctx, SECTION_ID_ROOT);
3597
3598         if (do_show_program_version)
3599             ffprobe_show_program_version(wctx);
3600         if (do_show_library_versions)
3601             ffprobe_show_library_versions(wctx);
3602         if (do_show_pixel_formats)
3603             ffprobe_show_pixel_formats(wctx);
3604
3605         if (!input_filename &&
3606             ((do_show_format || do_show_programs || do_show_streams || do_show_chapters || do_show_packets || do_show_error) ||
3607              (!do_show_program_version && !do_show_library_versions && !do_show_pixel_formats))) {
3608             show_usage();
3609             av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
3610             av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
3611             ret = AVERROR(EINVAL);
3612         } else if (input_filename) {
3613             ret = probe_file(wctx, input_filename);
3614             if (ret < 0 && do_show_error)
3615                 show_error(wctx, ret);
3616         }
3617
3618         writer_print_section_footer(wctx);
3619         writer_close(&wctx);
3620     }
3621
3622 end:
3623     av_freep(&print_format);
3624     av_freep(&read_intervals);
3625     av_hash_freep(&hash);
3626
3627     uninit_opts();
3628     for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
3629         av_dict_free(&(sections[i].entries_to_show));
3630
3631     avformat_network_deinit();
3632
3633     return ret < 0;
3634 }