/*

* Copyright (c) 2007-2010 Stefano Sabatini

*

* This file is part of FFmpeg.

*

* FFmpeg is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* FFmpeg is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with FFmpeg; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

*/

/**

* @file

* simple media prober based on the FFmpeg libraries

*/

#include "config.h"

#include "version.h"

#include <string.h>

#include "libavformat/avformat.h"

#include "libavcodec/avcodec.h"

#include "libavutil/avassert.h"

#include "libavutil/avstring.h"

#include "libavutil/bprint.h"

#include "libavutil/opt.h"

#include "libavutil/pixdesc.h"

#include "libavutil/dict.h"

#include "libavutil/libm.h"

#include "libavutil/timecode.h"

#include "libavdevice/avdevice.h"

#include "libswscale/swscale.h"

#include "libswresample/swresample.h"

#include "libpostproc/postprocess.h"

#include "cmdutils.h"

const char program_name[] = "ffprobe";

const int program_birth_year = 2007;

static int do_bitexact = 0;

static int do_count_frames = 0;

static int do_count_packets = 0;

static int do_read_frames = 0;

static int do_read_packets = 0;

static int do_show_error = 0;

static int do_show_format = 0;

static int do_show_frames = 0;

static int do_show_packets = 0;

static int do_show_streams = 0;

static int do_show_stream_disposition = 0;

static int do_show_data = 0;

static int do_show_program_version = 0;

static int do_show_library_versions = 0;

static int show_value_unit = 0;

static int use_value_prefix = 0;

static int use_byte_value_binary_prefix = 0;

static int use_value_sexagesimal_format = 0;

static int show_private_data = 1;

static char *print_format;

static char *stream_specifier;

/* section structure definition */

#define SECTION_MAX_NB_CHILDREN 10

struct section {

};

typedef enum {

SECTION_ID_NONE = -1,

SECTION_ID_ERROR,

SECTION_ID_FORMAT,

SECTION_ID_FORMAT_TAGS,

SECTION_ID_FRAME,

SECTION_ID_FRAMES,

SECTION_ID_FRAME_TAGS,

SECTION_ID_LIBRARY_VERSION,

SECTION_ID_LIBRARY_VERSIONS,

SECTION_ID_PACKET,

SECTION_ID_PACKETS,

SECTION_ID_PACKETS_AND_FRAMES,

SECTION_ID_PROGRAM_VERSION,

SECTION_ID_ROOT,

SECTION_ID_STREAM,

SECTION_ID_STREAM_DISPOSITION,

SECTION_ID_STREAMS,

SECTION_ID_STREAM_TAGS,

} SectionID;

static struct section sections[] = {

[SECTION_ID_ERROR] = { SECTION_ID_ERROR, "error", 0, { -1 } },

[SECTION_ID_FORMAT] = { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },

[SECTION_ID_FORMAT_TAGS] = { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },

[SECTION_ID_FRAMES] = { SECTION_ID_FRAMES, "frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, -1 } },

[SECTION_ID_FRAME] = { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, -1 } },

[SECTION_ID_FRAME_TAGS] = { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },

[SECTION_ID_LIBRARY_VERSIONS] = { SECTION_ID_LIBRARY_VERSIONS, "library_versions", SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } },

[SECTION_ID_LIBRARY_VERSION] = { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },

[SECTION_ID_PACKETS] = { SECTION_ID_PACKETS, "packets", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },

[SECTION_ID_PACKETS_AND_FRAMES] = { SECTION_ID_PACKETS_AND_FRAMES, "packets_and_frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },

[SECTION_ID_PACKET] = { SECTION_ID_PACKET, "packet", 0, { -1 } },

[SECTION_ID_PROGRAM_VERSION] = { SECTION_ID_PROGRAM_VERSION, "program_version", 0, { -1 } },

[SECTION_ID_ROOT] = { SECTION_ID_ROOT, "root", SECTION_FLAG_IS_WRAPPER,

{ SECTION_ID_FORMAT, SECTION_ID_FRAMES, SECTION_ID_STREAMS, SECTION_ID_PACKETS,

SECTION_ID_ERROR, SECTION_ID_PROGRAM_VERSION, SECTION_ID_LIBRARY_VERSIONS, -1} },

[SECTION_ID_STREAMS] = { SECTION_ID_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM, -1 } },

[SECTION_ID_STREAM] = { SECTION_ID_STREAM, "stream", 0, { SECTION_ID_STREAM_DISPOSITION, SECTION_ID_STREAM_TAGS, -1 } },

[SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },

[SECTION_ID_STREAM_TAGS] = { SECTION_ID_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },

};

static const OptionDef *options;

/* FFprobe context */

static const char *input_filename;

static AVInputFormat *iformat = NULL;

static const char *const binary_unit_prefixes [] = { "", "Ki", "Mi", "Gi", "Ti", "Pi" };

static const char *const decimal_unit_prefixes[] = { "", "K" , "M" , "G" , "T" , "P" };

static const char unit_second_str[] = "s" ;

static const char unit_hertz_str[] = "Hz" ;

static const char unit_byte_str[] = "byte" ;

static const char unit_bit_per_second_str[] = "bit/s";

static uint64_t *nb_streams_packets;

static uint64_t *nb_streams_frames;

static int *selected_streams;

static void exit_program(void)

{

int i;

for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)

av_dict_free(&(sections[i].entries_to_show));

}

struct unit_value {

union { double d; long long int i; } val;

const char *unit;

};

static char *value_string(char *buf, int buf_size, struct unit_value uv)

{

double vald;

long long int vali;

int show_float = 0;

if (uv.unit == unit_second_str) {

vald = uv.val.d;

show_float = 1;

} else {

vald = vali = uv.val.i;

}

if (uv.unit == unit_second_str && use_value_sexagesimal_format) {

double secs;

int hours, mins;

secs = vald;

mins = (int)secs / 60;

secs = secs - mins * 60;

hours = mins / 60;

mins %= 60;

snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);

} else {

const char *prefix_string = "";

if (use_value_prefix && vald > 1) {

long long int index;

if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {

index = (long long int) (log2(vald)) / 10;

index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) - 1);

vald /= exp2(index * 10);

prefix_string = binary_unit_prefixes[index];

} else {

index = (long long int) (log10(vald)) / 3;

index = av_clip(index, 0, FF_ARRAY_ELEMS(decimal_unit_prefixes) - 1);

vald /= pow(10, index * 3);

prefix_string = decimal_unit_prefixes[index];

}

}

if (show_float || (use_value_prefix && vald != (long long int)vald))

snprintf(buf, buf_size, "%f", vald);

else

snprintf(buf, buf_size, "%lld", vali);

av_strlcatf(buf, buf_size, "%s%s%s", *prefix_string || show_value_unit ? " " : "",

prefix_string, show_value_unit ? uv.unit : "");

}

return buf;

}

/* WRITERS API */

typedef struct WriterContext WriterContext;

#define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1

#define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2

typedef struct Writer {

} Writer;

#define SECTION_MAX_NB_LEVELS 10

struct WriterContext {

};

static const char *writer_get_name(void *p)

{

WriterContext *wctx = p;

return wctx->writer->name;

}

static const AVClass writer_class = {

"Writer",

writer_get_name,

NULL,

LIBAVUTIL_VERSION_INT,

};

static void writer_close(WriterContext **wctx)

{

int i;

if (!*wctx)

return;

if ((*wctx)->writer->uninit)

(*wctx)->writer->uninit(*wctx);

for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)

av_bprint_finalize(&(*wctx)->section_pbuf[i], NULL);

if ((*wctx)->writer->priv_class)

av_opt_free((*wctx)->priv);

av_freep(&((*wctx)->priv));

av_freep(wctx);

}

static int writer_open(WriterContext **wctx, const Writer *writer, const char *args,

const struct section *sections, int nb_sections)

{

int i, ret = 0;

if (!(*wctx = av_mallocz(sizeof(WriterContext)))) {

ret = AVERROR(ENOMEM);

goto fail;

}

if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {

ret = AVERROR(ENOMEM);

goto fail;

}

(*wctx)->class = &writer_class;

(*wctx)->writer = writer;

(*wctx)->level = -1;

(*wctx)->sections = sections;

(*wctx)->nb_sections = nb_sections;

if (writer->priv_class) {

void *priv_ctx = (*wctx)->priv;

*((const AVClass **)priv_ctx) = writer->priv_class;

av_opt_set_defaults(priv_ctx);

if (args &&

(ret = av_set_options_string(priv_ctx, args, "=", ":")) < 0)

goto fail;

}

for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)

av_bprint_init(&(*wctx)->section_pbuf[i], 1, AV_BPRINT_SIZE_UNLIMITED);

if ((*wctx)->writer->init)

ret = (*wctx)->writer->init(*wctx);

if (ret < 0)

goto fail;

return 0;

fail:

writer_close(wctx);

return ret;

}

static inline void writer_print_section_header(WriterContext *wctx,

int section_id)

{

int parent_section_id;

wctx->level++;

av_assert0(wctx->level < SECTION_MAX_NB_LEVELS);

parent_section_id = wctx->level ?

(wctx->section[wctx->level-1])->id : SECTION_ID_NONE;

wctx->nb_item[wctx->level] = 0;

wctx->section[wctx->level] = &wctx->sections[section_id];

if (section_id == SECTION_ID_PACKETS_AND_FRAMES) {

wctx->nb_section_packet = wctx->nb_section_frame =

wctx->nb_section_packet_frame = 0;

} else if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {

wctx->nb_section_packet_frame = section_id == SECTION_ID_PACKET ?

wctx->nb_section_packet : wctx->nb_section_frame;

}

if (wctx->writer->print_section_header)

wctx->writer->print_section_header(wctx);

}

static inline void writer_print_section_footer(WriterContext *wctx)

{

int section_id = wctx->section[wctx->level]->id;

int parent_section_id = wctx->level ?

wctx->section[wctx->level-1]->id : SECTION_ID_NONE;

if (parent_section_id != SECTION_ID_NONE)

wctx->nb_item[wctx->level-1]++;

if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {

if (section_id == SECTION_ID_PACKET) wctx->nb_section_packet++;

else wctx->nb_section_frame++;

}

if (wctx->writer->print_section_footer)

wctx->writer->print_section_footer(wctx);

wctx->level--;

}

static inline void writer_print_integer(WriterContext *wctx,

const char *key, long long int val)

{

const struct section *section = wctx->section[wctx->level];

if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {

wctx->writer->print_integer(wctx, key, val);

wctx->nb_item[wctx->level]++;

}

}

static inline void writer_print_string(WriterContext *wctx,

const char *key, const char *val, int opt)

{

const struct section *section = wctx->section[wctx->level];

if (opt && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS))

return;

if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {

wctx->writer->print_string(wctx, key, val);

wctx->nb_item[wctx->level]++;

}

}

static inline void writer_print_rational(WriterContext *wctx,

const char *key, AVRational q, char sep)

{

AVBPrint buf;

av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);

av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);

writer_print_string(wctx, key, buf.str, 0);

}

static void writer_print_time(WriterContext *wctx, const char *key,

int64_t ts, const AVRational *time_base, int is_duration)

{

char buf[128];

if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {

writer_print_string(wctx, key, "N/A", 1);

} else {

double d = ts * av_q2d(*time_base);

struct unit_value uv;

uv.val.d = d;

uv.unit = unit_second_str;

value_string(buf, sizeof(buf), uv);

writer_print_string(wctx, key, buf, 0);

}

}

static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)

{

if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {

writer_print_string(wctx, key, "N/A", 1);

} else {

writer_print_integer(wctx, key, ts);

}

}

static void writer_print_data(WriterContext *wctx, const char *name,

uint8_t *data, int size)

{

AVBPrint bp;

int offset = 0, l, i;

av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);

av_bprintf(&bp, "\n");

while (size) {

av_bprintf(&bp, "%08x: ", offset);

l = FFMIN(size, 16);

for (i = 0; i < l; i++) {

av_bprintf(&bp, "%02x", data[i]);

if (i & 1)

av_bprintf(&bp, " ");

}

av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);

for (i = 0; i < l; i++)

av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);

av_bprintf(&bp, "\n");

offset += l;

data += l;

size -= l;

}

writer_print_string(wctx, name, bp.str, 0);

av_bprint_finalize(&bp, NULL);

}

#define MAX_REGISTERED_WRITERS_NB 64

static const Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];

static int writer_register(const Writer *writer)

{

static int next_registered_writer_idx = 0;

if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)

return AVERROR(ENOMEM);

registered_writers[next_registered_writer_idx++] = writer;

return 0;

}

static const Writer *writer_get_by_name(const char *name)

{

int i;

for (i = 0; registered_writers[i]; i++)

if (!strcmp(registered_writers[i]->name, name))

return registered_writers[i];

return NULL;

}

/* WRITERS */

#define DEFINE_WRITER_CLASS(name) \

static const char *name##_get_name(void *ctx) \

{ \

return #name ; \

} \

static const AVClass name##_class = { \

#name, \

name##_get_name, \

name##_options \

}

/* Default output */

typedef struct DefaultContext {

} DefaultContext;

#define OFFSET(x) offsetof(DefaultContext, x)

static const AVOption default_options[] = {

{ "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_INT, {.i64=0}, 0, 1 },

{ "nw", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_INT, {.i64=0}, 0, 1 },

{ "nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_INT, {.i64=0}, 0, 1 },

{ "nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_INT, {.i64=0}, 0, 1 },

{NULL},

};

DEFINE_WRITER_CLASS(default);

/* lame uppercasing routine, assumes the string is lower case ASCII */

static inline char *upcase_string(char *dst, size_t dst_size, const char *src)

{

int i;

for (i = 0; src[i] && i < dst_size-1; i++)

dst[i] = av_toupper(src[i]);

dst[i] = 0;

return dst;

}

static void default_print_section_header(WriterContext *wctx)

{

DefaultContext *def = wctx->priv;

char buf[32];

const struct section *section = wctx->section[wctx->level];

const struct section *parent_section = wctx->level ?

wctx->section[wctx->level-1] : NULL;

av_bprint_clear(&wctx->section_pbuf[wctx->level]);

if (parent_section &&

!(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {

def->nested_section[wctx->level] = 1;

av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",

wctx->section_pbuf[wctx->level-1].str,

upcase_string(buf, sizeof(buf),

av_x_if_null(section->element_name, section->name)));

}

if (def->noprint_wrappers || def->nested_section[wctx->level])

return;

if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))

printf("[%s]\n", upcase_string(buf, sizeof(buf), section->name));

}

static void default_print_section_footer(WriterContext *wctx)

{

DefaultContext *def = wctx->priv;

const struct section *section = wctx->section[wctx->level];

char buf[32];

if (def->noprint_wrappers || def->nested_section[wctx->level])

return;

if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))

printf("[/%s]\n", upcase_string(buf, sizeof(buf), section->name));

}

static void default_print_str(WriterContext *wctx, const char *key, const char *value)

{

DefaultContext *def = wctx->priv;

if (!def->nokey)

printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);

printf("%s\n", value);

}

static void default_print_int(WriterContext *wctx, const char *key, long long int value)

{

DefaultContext *def = wctx->priv;

if (!def->nokey)

printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);

printf("%lld\n", value);

}

static const Writer default_writer = {

.name = "default",

.priv_size = sizeof(DefaultContext),

.print_section_header = default_print_section_header,

.print_section_footer = default_print_section_footer,

.print_integer = default_print_int,

.print_string = default_print_str,

.flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,

.priv_class = &default_class,

};

/* Compact output */

/**

* Apply C-language-like string escaping.

*/

static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)

{

const char *p;

for (p = src; *p; p++) {

switch (*p) {

case '\b': av_bprintf(dst, "%s", "\\b"); break;

case '\f': av_bprintf(dst, "%s", "\\f"); break;

case '\n': av_bprintf(dst, "%s", "\\n"); break;

case '\r': av_bprintf(dst, "%s", "\\r"); break;

case '\\': av_bprintf(dst, "%s", "\\\\"); break;

default:

if (*p == sep)

av_bprint_chars(dst, '\\', 1);

av_bprint_chars(dst, *p, 1);

}

}

return dst->str;

}

/**

* Quote fields containing special characters, check RFC4180.

*/

static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)

{

char meta_chars[] = { sep, '"', '\n', '\r', '\0' };

int needs_quoting = !!src[strcspn(src, meta_chars)];

if (needs_quoting)

av_bprint_chars(dst, '"', 1);

for (; *src; src++) {

if (*src == '"')

av_bprint_chars(dst, '"', 1);

av_bprint_chars(dst, *src, 1);

}

if (needs_quoting)

av_bprint_chars(dst, '"', 1);

return dst->str;

}

static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)

{

return src;

}

typedef struct CompactContext {

} CompactContext;

#undef OFFSET

#define OFFSET(x) offsetof(CompactContext, x)

static const AVOption compact_options[]= {

{"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, CHAR_MIN, CHAR_MAX },

{"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, CHAR_MIN, CHAR_MAX },

{"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_INT, {.i64=0}, 0, 1 },

{"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_INT, {.i64=0}, 0, 1 },

{"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, CHAR_MIN, CHAR_MAX },

{"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, CHAR_MIN, CHAR_MAX },

{"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{NULL},

};

DEFINE_WRITER_CLASS(compact);

static av_cold int compact_init(WriterContext *wctx)

{

CompactContext *compact = wctx->priv;

if (strlen(compact->item_sep_str) != 1) {

av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",

compact->item_sep_str);

return AVERROR(EINVAL);

}

compact->item_sep = compact->item_sep_str[0];

if (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;

else if (!strcmp(compact->escape_mode_str, "c" )) compact->escape_str = c_escape_str;

else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;

else {

av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);

return AVERROR(EINVAL);

}

return 0;

}

static void compact_print_section_header(WriterContext *wctx)

{

CompactContext *compact = wctx->priv;

const struct section *section = wctx->section[wctx->level];

const struct section *parent_section = wctx->level ?

wctx->section[wctx->level-1] : NULL;

av_bprint_clear(&wctx->section_pbuf[wctx->level]);

if (parent_section &&

!(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {

compact->nested_section[wctx->level] = 1;

av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",

wctx->section_pbuf[wctx->level-1].str,

(char *)av_x_if_null(section->element_name, section->name));

wctx->nb_item[wctx->level] = wctx->nb_item[wctx->level-1];

} else if (compact->print_section &&

!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))

printf("%s%c", section->name, compact->item_sep);

}

static void compact_print_section_footer(WriterContext *wctx)

{

CompactContext *compact = wctx->priv;

if (!compact->nested_section[wctx->level] &&

!(wctx->section[wctx->level]->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))

printf("\n");

}

static void compact_print_str(WriterContext *wctx, const char *key, const char *value)

{

CompactContext *compact = wctx->priv;

AVBPrint buf;

if (wctx->nb_item[wctx->level]) printf("%c", compact->item_sep);

if (!compact->nokey)

printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);

av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);

printf("%s", compact->escape_str(&buf, value, compact->item_sep, wctx));

av_bprint_finalize(&buf, NULL);

}

static void compact_print_int(WriterContext *wctx, const char *key, long long int value)

{

CompactContext *compact = wctx->priv;

if (wctx->nb_item[wctx->level]) printf("%c", compact->item_sep);

if (!compact->nokey)

printf("%s%s=", wctx->section_pbuf[wctx->level].str, key);

printf("%lld", value);

}

static const Writer compact_writer = {

.name = "compact",

.priv_size = sizeof(CompactContext),

.init = compact_init,

.print_section_header = compact_print_section_header,

.print_section_footer = compact_print_section_footer,

.print_integer = compact_print_int,

.print_string = compact_print_str,

.flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,

.priv_class = &compact_class,

};

/* CSV output */

#undef OFFSET

#define OFFSET(x) offsetof(CompactContext, x)

static const AVOption csv_options[] = {

{"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, CHAR_MIN, CHAR_MAX },

{"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, CHAR_MIN, CHAR_MAX },

{"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, CHAR_MIN, CHAR_MAX },

{"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, CHAR_MIN, CHAR_MAX },

{"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{NULL},

};

DEFINE_WRITER_CLASS(csv);

static const Writer csv_writer = {

.name = "csv",

.priv_size = sizeof(CompactContext),

.init = compact_init,

.print_section_header = compact_print_section_header,

.print_section_footer = compact_print_section_footer,

.print_integer = compact_print_int,

.print_string = compact_print_str,

.flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,

.priv_class = &csv_class,

};

/* Flat output */

typedef struct FlatContext {

} FlatContext;

#undef OFFSET

#define OFFSET(x) offsetof(FlatContext, x)

static const AVOption flat_options[]= {

{"sep_char", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, CHAR_MIN, CHAR_MAX },

{"s", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, CHAR_MIN, CHAR_MAX },

{"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{NULL},

};

DEFINE_WRITER_CLASS(flat);

static av_cold int flat_init(WriterContext *wctx)

{

FlatContext *flat = wctx->priv;

if (strlen(flat->sep_str) != 1) {

av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",

flat->sep_str);

return AVERROR(EINVAL);

}

flat->sep = flat->sep_str[0];

return 0;

}

static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)

{

const char *p;

for (p = src; *p; p++) {

if (!((*p >= '0' && *p <= '9') ||

(*p >= 'a' && *p <= 'z') ||

(*p >= 'A' && *p <= 'Z')))

av_bprint_chars(dst, '_', 1);

else

av_bprint_chars(dst, *p, 1);

}

return dst->str;

}

static const char *flat_escape_value_str(AVBPrint *dst, const char *src)

{

const char *p;

for (p = src; *p; p++) {

switch (*p) {

case '\n': av_bprintf(dst, "%s", "\\n"); break;

case '\r': av_bprintf(dst, "%s", "\\r"); break;

case '\\': av_bprintf(dst, "%s", "\\\\"); break;

case '"': av_bprintf(dst, "%s", "\\\""); break;

case '`': av_bprintf(dst, "%s", "\\`"); break;

case '$': av_bprintf(dst, "%s", "\\$"); break;

default: av_bprint_chars(dst, *p, 1); break;

}

}

return dst->str;

}

static void flat_print_section_header(WriterContext *wctx)

{

FlatContext *flat = wctx->priv;

AVBPrint *buf = &wctx->section_pbuf[wctx->level];

const struct section *section = wctx->section[wctx->level];

const struct section *parent_section = wctx->level ?

wctx->section[wctx->level-1] : NULL;

/* build section header */

av_bprint_clear(buf);

if (!parent_section)

return;

av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);

if (flat->hierarchical ||

!(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {

av_bprintf(buf, "%s%s", wctx->section[wctx->level]->name, flat->sep_str);

if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {

int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?

wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];

av_bprintf(buf, "%d%s", n, flat->sep_str);

}

}

}

static void flat_print_int(WriterContext *wctx, const char *key, long long int value)

{

printf("%s%s=%lld\n", wctx->section_pbuf[wctx->level].str, key, value);

}

static void flat_print_str(WriterContext *wctx, const char *key, const char *value)

{

FlatContext *flat = wctx->priv;

AVBPrint buf;

printf("%s", wctx->section_pbuf[wctx->level].str);

av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);

printf("%s=", flat_escape_key_str(&buf, key, flat->sep));

av_bprint_clear(&buf);

printf("\"%s\"\n", flat_escape_value_str(&buf, value));

av_bprint_finalize(&buf, NULL);

}

static const Writer flat_writer = {

.name = "flat",

.priv_size = sizeof(FlatContext),

.init = flat_init,

.print_section_header = flat_print_section_header,

.print_integer = flat_print_int,

.print_string = flat_print_str,

.flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,

.priv_class = &flat_class,

};

/* INI format output */

typedef struct {

const AVClass *class;

int hierarchical;

} INIContext;

#undef OFFSET

#define OFFSET(x) offsetof(INIContext, x)

static const AVOption ini_options[] = {

{"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.i64=1}, 0, 1 },

{NULL},

};

DEFINE_WRITER_CLASS(ini);

static char *ini_escape_str(AVBPrint *dst, const char *src)

{

int i = 0;

char c = 0;

while (c = src[i++]) {

switch (c) {

case '\b': av_bprintf(dst, "%s", "\\b"); break;

case '\f': av_bprintf(dst, "%s", "\\f"); break;

case '\n': av_bprintf(dst, "%s", "\\n"); break;

case '\r': av_bprintf(dst, "%s", "\\r"); break;

case '\t': av_bprintf(dst, "%s", "\\t"); break;

case '\\':

case '#' :

case '=' :

case ':' : av_bprint_chars(dst, '\\', 1);

default:

if ((unsigned char)c < 32)

av_bprintf(dst, "\\x00%02x", c & 0xff);

else

av_bprint_chars(dst, c, 1);

break;

}

}

return dst->str;

}

static void ini_print_section_header(WriterContext *wctx)

{

INIContext *ini = wctx->priv;

AVBPrint *buf = &wctx->section_pbuf[wctx->level];

const struct section *section = wctx->section[wctx->level];

const struct section *parent_section = wctx->level ?

wctx->section[wctx->level-1] : NULL;

av_bprint_clear(buf);

if (!parent_section) {

printf("# ffprobe output\n\n");

return;

}

if (wctx->nb_item[wctx->level-1])

printf("\n");

av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);

if (ini->hierarchical ||

!(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {

av_bprintf(buf, "%s%s", buf->str[0] ? "." : "", wctx->section[wctx->level]->name);

if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {

int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?

wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];