Skip to content

F
ffmpeg.wasm-core
Commit eff7684b authored by Stefano Sabatini's avatar Stefano Sabatini
Browse files
Options

ffprobe: extend writers API, and move the writers up in the file 

The new provided API is more flexible and is decoupled from the
application level code, so it is easier to maintain.
parent 2b43bfa0
Show whitespace changes
Inline Side-by-side
Showing with 377 additions and 205 deletions
ffprobe.c
View file @ eff7684b
...@@ -121,123 +121,165 @@ static char *ts_value_string (char *buf, int buf_size, int64_t ts) ...@@ -121,123 +121,165 @@ static char *ts_value_string (char *buf, int buf_size, int64_t ts)
return buf; return buf;
} }
/* WRITERS API */
struct writer { typedef struct WriterContext WriterContext;
const char *name;
const char *item_sep; ///< separator between key/value couples
const char *items_sep; ///< separator between sets of key/value couples
const char *section_sep; ///< separator between sections (streams, packets, ...)
const char *header, *footer;
void (*print_section_start)(const char *, int);
void (*print_section_end) (const char *, int);
void (*print_header)(const char *);
void (*print_footer)(const char *);
void (*print_integer)(const char *, int);
void (*print_string)(const char *, const char *);
void (*show_tags)(struct writer *w, AVDictionary *dict);
};
typedef struct Writer {
int priv_size; ///< private size for the writer context
const char *name;
/* JSON output */ int (*init) (WriterContext *wctx, const char *args, void *opaque);
void (*uninit)(WriterContext *wctx);
void (*print_header)(WriterContext *ctx);
void (*print_footer)(WriterContext *ctx);
void (*print_chapter_header)(WriterContext *wctx, const char *);
void (*print_chapter_footer)(WriterContext *wctx, const char *);
void (*print_section_header)(WriterContext *wctx, const char *);
void (*print_section_footer)(WriterContext *wctx, const char *);
void (*print_integer) (WriterContext *wctx, const char *, int);
void (*print_string) (WriterContext *wctx, const char *, const char *);
void (*show_tags) (WriterContext *wctx, AVDictionary *dict);
} Writer;
struct WriterContext {
const AVClass *class; ///< class of the writer
const Writer *writer; ///< the Writer of which this is an instance
char *name; ///< name of this writer instance
void *priv; ///< private data for use by the filter
unsigned int nb_item; ///< number of the item printed in the given section, starting at 0
unsigned int nb_section; ///< number of the section printed in the given section sequence, starting at 0
unsigned int nb_chapter; ///< number of the chapter, starting at 0
};
static void json_print_header(const char *section) static void writer_close(WriterContext **wctx)
{ {
printf("{\n"); if (*wctx && (*wctx)->writer->uninit)
(*wctx)->writer->uninit(*wctx);
av_freep(&((*wctx)->priv));
av_freep(wctx);
} }
static char *json_escape_str(const char *s) static int writer_open(WriterContext **wctx, const Writer *writer,
const char *args, void *opaque)
{ {
static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0}; int ret = 0;
static const char json_subst[] = {'"', '\\', 'b', 'f', 'n', 'r', 't', 0};
char *ret, *p;
int i, len = 0;
// compute the length of the escaped string if (!(*wctx = av_malloc(sizeof(WriterContext)))) {
for (i = 0; s[i]; i++) { ret = AVERROR(ENOMEM);
if (strchr(json_escape, s[i])) len += 2; // simple escape goto fail;
else if ((unsigned char)s[i] < 32) len += 6; // handle non-printable chars
else len += 1; // char copy
} }
p = ret = av_malloc(len + 1); if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
if (!p) ret = AVERROR(ENOMEM);
return NULL; goto fail;
for (i = 0; s[i]; i++) {
char *q = strchr(json_escape, s[i]);
if (q) {
*p++ = '\\';
*p++ = json_subst[q - json_escape];
} else if ((unsigned char)s[i] < 32) {
snprintf(p, 7, "\\u00%02x", s[i] & 0xff);
p += 6;
} else {
*p++ = s[i];
}
} }
*p = 0;
(*wctx)->writer = writer;
if ((*wctx)->writer->init)
ret = (*wctx)->writer->init(*wctx, args, opaque);
if (ret < 0)
goto fail;
return 0;
fail:
writer_close(wctx);
return ret; return ret;
} }
static void json_print_str(const char *key, const char *value) static inline void writer_print_header(WriterContext *wctx)
{ {
char *key_esc = json_escape_str(key); if (wctx->writer->print_header)
char *value_esc = json_escape_str(value); wctx->writer->print_header(wctx);
printf(" \"%s\": \"%s\"", wctx->nb_chapter = 0;
key_esc ? key_esc : "",
value_esc ? value_esc : "");
av_free(key_esc);
av_free(value_esc);
} }
static void json_print_int(const char *key, int value) static inline void writer_print_footer(WriterContext *wctx)
{ {
char *key_esc = json_escape_str(key); if (wctx->writer->print_footer)
printf(" \"%s\": %d", key_esc ? key_esc : "", value); wctx->writer->print_footer(wctx);
av_free(key_esc);
} }
static void json_print_footer(const char *section) static inline void writer_print_chapter_header(WriterContext *wctx,
const char *header)
{ {
printf("\n }"); if (wctx->writer->print_chapter_header)
wctx->writer->print_chapter_header(wctx, header);
wctx->nb_section = 0;
} }
static void json_print_section_start(const char *section, int multiple_entries) static inline void writer_print_chapter_footer(WriterContext *wctx,
const char *footer)
{ {
char *section_esc = json_escape_str(section); if (wctx->writer->print_chapter_footer)
printf("\n \"%s\":%s", section_esc ? section_esc : "", wctx->writer->print_chapter_footer(wctx, footer);
multiple_entries ? " [" : " "); wctx->nb_chapter++;
av_free(section_esc);
} }
static void json_print_section_end(const char *section, int multiple_entries) static inline void writer_print_section_header(WriterContext *wctx,
const char *header)
{ {
if (multiple_entries) if (wctx->writer->print_section_header)
printf("]"); wctx->writer->print_section_header(wctx, header);
wctx->nb_item = 0;
} }
static inline void writer_print_section_footer(WriterContext *wctx,
const char *footer)
{
if (wctx->writer->print_section_footer)
wctx->writer->print_section_footer(wctx, footer);
wctx->nb_section++;
}
/* Default output */ static inline void writer_print_integer(WriterContext *wctx,
const char *key, int val)
static void default_print_header(const char *section)
{ {
printf("[%s]\n", section); wctx->writer->print_integer(wctx, key, val);
wctx->nb_item++;
} }
static void default_print_str(const char *key, const char *value) static inline void writer_print_string(WriterContext *wctx,
const char *key, const char *val)
{ {
printf("%s=%s", key, value); wctx->writer->print_string(wctx, key, val);
wctx->nb_item++;
} }
static void default_print_int(const char *key, int value) static inline void writer_show_tags(WriterContext *wctx, AVDictionary *dict)
{ {
printf("%s=%d", key, value); wctx->writer->show_tags(wctx, dict);
} }
static void default_print_footer(const char *section) #define MAX_REGISTERED_WRITERS_NB 64
static Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];
static int writer_register(Writer *writer)
{ {
printf("\n[/%s]", section); 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 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;
}
/* Print helpers */ /* Print helpers */
...@@ -278,37 +320,237 @@ fail: ...@@ -278,37 +320,237 @@ fail:
return NULL; return NULL;
} }
#define print_fmt0(k, f, ...) do { \ /* WRITERS */
if (fast_asprintf(&pbuf, f, __VA_ARGS__)) \
w->print_string(k, pbuf.s); \
} while (0)
#define print_fmt( k, f, ...) do { \
if (w->item_sep) \
printf("%s", w->item_sep); \
print_fmt0(k, f, __VA_ARGS__); \
} while (0)
#define print_int0(k, v) w->print_integer(k, v) /* Default output */
#define print_int( k, v) do { \
if (w->item_sep) \ static void default_print_footer(WriterContext *wctx)
printf("%s", w->item_sep); \ {
print_int0(k, v); \ printf("\n");
} while (0) }
static void default_print_chapter_header(WriterContext *wctx, const char *chapter)
{
if (wctx->nb_chapter)
printf("\n");
}
static void default_print_section_header(WriterContext *wctx, const char *section)
{
if (wctx->nb_section)
printf("\n");
printf("[%s]\n", section);
}
static void default_print_section_footer(WriterContext *wctx, const char *section)
{
printf("[/%s]", section);
}
static void default_print_str(WriterContext *wctx, const char *key, const char *value)
{
printf("%s=%s\n", key, value);
}
static void default_print_int(WriterContext *wctx, const char *key, int value)
{
printf("%s=%d\n", key, value);
}
static void default_show_tags(WriterContext *wctx, AVDictionary *dict)
{
AVDictionaryEntry *tag = NULL;
while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
printf("TAG:");
writer_print_string(wctx, tag->key, tag->value);
}
}
static Writer default_writer = {
.name = "default",
.print_footer = default_print_footer,
.print_chapter_header = default_print_chapter_header,
.print_section_header = default_print_section_header,
.print_section_footer = default_print_section_footer,
.print_integer = default_print_int,
.print_string = default_print_str,
.show_tags = default_show_tags
};
/* JSON output */
typedef struct {
int multiple_entries; ///< tells if the given chapter requires multiple entries
} JSONContext;
static char *json_escape_str(const char *s)
{
static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
static const char json_subst[] = {'"', '\\', 'b', 'f', 'n', 'r', 't', 0};
char *ret, *p;
int i, len = 0;
// compute the length of the escaped string
for (i = 0; s[i]; i++) {
if (strchr(json_escape, s[i])) len += 2; // simple escape
else if ((unsigned char)s[i] < 32) len += 6; // handle non-printable chars
else len += 1; // char copy
}
p = ret = av_malloc(len + 1);
if (!p)
return NULL;
for (i = 0; s[i]; i++) {
char *q = strchr(json_escape, s[i]);
if (q) {
*p++ = '\\';
*p++ = json_subst[q - json_escape];
} else if ((unsigned char)s[i] < 32) {
snprintf(p, 7, "\\u00%02x", s[i] & 0xff);
p += 6;
} else {
*p++ = s[i];
}
}
*p = 0;
return ret;
}
#define print_str0(k, v) print_fmt0(k, "%s", v) static void json_print_header(WriterContext *wctx)
#define print_str( k, v) print_fmt (k, "%s", v) {
printf("{");
}
static void json_print_footer(WriterContext *wctx)
{
printf("\n}\n");
}
static void show_packet(struct writer *w, AVFormatContext *fmt_ctx, AVPacket *pkt, int packet_idx) static void json_print_chapter_header(WriterContext *wctx, const char *chapter)
{
JSONContext *json = wctx->priv;
char *chapter_esc;
if (wctx->nb_chapter)
printf(",");
json->multiple_entries = !strcmp(chapter, "packets") || !strcmp(chapter, "streams");
chapter_esc = json_escape_str(chapter);
printf("\n \"%s\":%s", chapter_esc ? chapter_esc : "",
json->multiple_entries ? " [" : " ");
av_free(chapter_esc);
}
static void json_print_chapter_footer(WriterContext *wctx, const char *chapter)
{
JSONContext *json = wctx->priv;
if (json->multiple_entries)
printf("]");
}
static void json_print_section_header(WriterContext *wctx, const char *section)
{
if (wctx->nb_section) printf(",");
printf("{\n");
}
static void json_print_section_footer(WriterContext *wctx, const char *section)
{
printf("\n }");
}
static inline void json_print_item_str(WriterContext *wctx,
const char *key, const char *value,
const char *indent)
{
char *key_esc = json_escape_str(key);
char *value_esc = json_escape_str(value);
printf("%s\"%s\": \"%s\"", indent,
key_esc ? key_esc : "",
value_esc ? value_esc : "");
av_free(key_esc);
av_free(value_esc);
}
#define INDENT " "
static void json_print_str(WriterContext *wctx, const char *key, const char *value)
{
if (wctx->nb_item) printf(",\n");
json_print_item_str(wctx, key, value, INDENT);
}
static void json_print_int(WriterContext *wctx, const char *key, int value)
{
char *key_esc = json_escape_str(key);
if (wctx->nb_item) printf(",\n");
printf(INDENT "\"%s\": %d", key_esc ? key_esc : "", value);
av_free(key_esc);
}
static void json_show_tags(WriterContext *wctx, AVDictionary *dict)
{
AVDictionaryEntry *tag = NULL;
int is_first = 1;
if (!dict)
return;
printf(",\n" INDENT "\"tags\": {\n");
while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
if (is_first) is_first = 0;
else printf(",\n");
json_print_item_str(wctx, tag->key, tag->value, INDENT INDENT);
}
printf("\n }");
}
static Writer json_writer = {
.name = "json",
.priv_size = sizeof(JSONContext),
.print_header = json_print_header,
.print_footer = json_print_footer,
.print_chapter_header = json_print_chapter_header,
.print_chapter_footer = json_print_chapter_footer,
.print_section_header = json_print_section_header,
.print_section_footer = json_print_section_footer,
.print_integer = json_print_int,
.print_string = json_print_str,
.show_tags = json_show_tags,
};
static void writer_register_all(void)
{
static int initialized;
if (initialized)
return;
initialized = 1;
writer_register(&default_writer);
writer_register(&json_writer);
}
#define print_fmt(k, f, ...) do { \
if (fast_asprintf(&pbuf, f, __VA_ARGS__)) \
writer_print_string(w, k, pbuf.s); \
} while (0)
#define print_int(k, v) writer_print_integer(w, k, v)
#define print_str(k, v) writer_print_string(w, k, v)
#define print_section_header(s) writer_print_section_header(w, s)
#define print_section_footer(s) writer_print_section_footer(w, s)
#define show_tags(metadata) writer_show_tags(w, metadata)
static void show_packet(WriterContext *w, AVFormatContext *fmt_ctx, AVPacket *pkt, int packet_idx)
{ {
char val_str[128]; char val_str[128];
AVStream *st = fmt_ctx->streams[pkt->stream_index]; AVStream *st = fmt_ctx->streams[pkt->stream_index];
struct print_buf pbuf = {.s = NULL}; struct print_buf pbuf = {.s = NULL};
if (packet_idx) print_section_header("PACKET");
printf("%s", w->items_sep); print_str("codec_type", av_x_if_null(av_get_media_type_string(st->codec->codec_type), "unknown"));
w->print_header("PACKET");
print_str0("codec_type", av_x_if_null(av_get_media_type_string(st->codec->codec_type), "unknown"));
print_int("stream_index", pkt->stream_index); print_int("stream_index", pkt->stream_index);
print_str("pts", ts_value_string (val_str, sizeof(val_str), pkt->pts)); print_str("pts", ts_value_string (val_str, sizeof(val_str), pkt->pts));
print_str("pts_time", time_value_string(val_str, sizeof(val_str), pkt->pts, &st->time_base)); print_str("pts_time", time_value_string(val_str, sizeof(val_str), pkt->pts, &st->time_base));
...@@ -319,12 +561,13 @@ static void show_packet(struct writer *w, AVFormatContext *fmt_ctx, AVPacket *pk ...@@ -319,12 +561,13 @@ static void show_packet(struct writer *w, AVFormatContext *fmt_ctx, AVPacket *pk
print_str("size", value_string (val_str, sizeof(val_str), pkt->size, unit_byte_str)); print_str("size", value_string (val_str, sizeof(val_str), pkt->size, unit_byte_str));
print_fmt("pos", "%"PRId64, pkt->pos); print_fmt("pos", "%"PRId64, pkt->pos);
print_fmt("flags", "%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_'); print_fmt("flags", "%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');
w->print_footer("PACKET"); print_section_footer("PACKET");
av_free(pbuf.s); av_free(pbuf.s);
fflush(stdout); fflush(stdout);
} }
static void show_packets(struct writer *w, AVFormatContext *fmt_ctx) static void show_packets(WriterContext *w, AVFormatContext *fmt_ctx)
{ {
AVPacket pkt; AVPacket pkt;
int i = 0; int i = 0;
...@@ -335,39 +578,7 @@ static void show_packets(struct writer *w, AVFormatContext *fmt_ctx) ...@@ -335,39 +578,7 @@ static void show_packets(struct writer *w, AVFormatContext *fmt_ctx)
show_packet(w, fmt_ctx, &pkt, i++); show_packet(w, fmt_ctx, &pkt, i++);
} }
static void json_show_tags(struct writer *w, AVDictionary *dict) static void show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx)
{
AVDictionaryEntry *tag = NULL;
struct print_buf pbuf = {.s = NULL};
int first = 1;
if (!dict)
return;
printf(",\n \"tags\": {\n");
while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
if (first) {
print_str0(tag->key, tag->value);
first = 0;
} else {
print_str(tag->key, tag->value);
}
}
printf("\n }");
av_free(pbuf.s);
}
static void default_show_tags(struct writer *w, AVDictionary *dict)
{
AVDictionaryEntry *tag = NULL;
struct print_buf pbuf = {.s = NULL};
while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
printf("\nTAG:");
print_str0(tag->key, tag->value);
}
av_free(pbuf.s);
}
static void show_stream(struct writer *w, AVFormatContext *fmt_ctx, int stream_idx)
{ {
AVStream *stream = fmt_ctx->streams[stream_idx]; AVStream *stream = fmt_ctx->streams[stream_idx];
AVCodecContext *dec_ctx; AVCodecContext *dec_ctx;
...@@ -376,11 +587,9 @@ static void show_stream(struct writer *w, AVFormatContext *fmt_ctx, int stream_i ...@@ -376,11 +587,9 @@ static void show_stream(struct writer *w, AVFormatContext *fmt_ctx, int stream_i
AVRational display_aspect_ratio; AVRational display_aspect_ratio;
struct print_buf pbuf = {.s = NULL}; struct print_buf pbuf = {.s = NULL};
if (stream_idx) print_section_header("STREAM");
printf("%s", w->items_sep);
w->print_header("STREAM");
print_int0("index", stream->index); print_int("index", stream->index);
if ((dec_ctx = stream->codec)) { if ((dec_ctx = stream->codec)) {
if ((dec = dec_ctx->codec)) { if ((dec = dec_ctx->codec)) {
...@@ -439,27 +648,27 @@ static void show_stream(struct writer *w, AVFormatContext *fmt_ctx, int stream_i ...@@ -439,27 +648,27 @@ static void show_stream(struct writer *w, AVFormatContext *fmt_ctx, int stream_i
if (stream->nb_frames) if (stream->nb_frames)
print_fmt("nb_frames", "%"PRId64, stream->nb_frames); print_fmt("nb_frames", "%"PRId64, stream->nb_frames);
w->show_tags(w, stream->metadata); show_tags(stream->metadata);
w->print_footer("STREAM"); print_section_footer("STREAM");
av_free(pbuf.s); av_free(pbuf.s);
fflush(stdout); fflush(stdout);
} }
static void show_streams(struct writer *w, AVFormatContext *fmt_ctx) static void show_streams(WriterContext *w, AVFormatContext *fmt_ctx)
{ {
int i; int i;
for (i = 0; i < fmt_ctx->nb_streams; i++) for (i = 0; i < fmt_ctx->nb_streams; i++)
show_stream(w, fmt_ctx, i); show_stream(w, fmt_ctx, i);
} }
static void show_format(struct writer *w, AVFormatContext *fmt_ctx) static void show_format(WriterContext *w, AVFormatContext *fmt_ctx)
{ {
char val_str[128]; char val_str[128];
struct print_buf pbuf = {.s = NULL}; struct print_buf pbuf = {.s = NULL};
w->print_header("FORMAT"); print_section_header("FORMAT");
print_str0("filename", fmt_ctx->filename); print_str("filename", fmt_ctx->filename);
print_int("nb_streams", fmt_ctx->nb_streams); print_int("nb_streams", fmt_ctx->nb_streams);
print_str("format_name", fmt_ctx->iformat->name); print_str("format_name", fmt_ctx->iformat->name);
print_str("format_long_name", fmt_ctx->iformat->long_name); print_str("format_long_name", fmt_ctx->iformat->long_name);
...@@ -467,8 +676,8 @@ static void show_format(struct writer *w, AVFormatContext *fmt_ctx) ...@@ -467,8 +676,8 @@ static void show_format(struct writer *w, AVFormatContext *fmt_ctx)
print_str("duration", time_value_string(val_str, sizeof(val_str), fmt_ctx->duration, &AV_TIME_BASE_Q)); print_str("duration", time_value_string(val_str, sizeof(val_str), fmt_ctx->duration, &AV_TIME_BASE_Q));
print_str("size", value_string(val_str, sizeof(val_str), fmt_ctx->file_size, unit_byte_str)); print_str("size", value_string(val_str, sizeof(val_str), fmt_ctx->file_size, unit_byte_str));
print_str("bit_rate", value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate, unit_bit_per_second_str)); print_str("bit_rate", value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate, unit_bit_per_second_str));
w->show_tags(w, fmt_ctx->metadata); show_tags(fmt_ctx->metadata);
w->print_footer("FORMAT"); print_section_footer("FORMAT");
av_free(pbuf.s); av_free(pbuf.s);
fflush(stdout); fflush(stdout);
} }
...@@ -515,83 +724,46 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename) ...@@ -515,83 +724,46 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
return 0; return 0;
} }
#define WRITER_FUNC(func) \ #define PRINT_CHAPTER(name) do { \
.print_header = func ## _print_header, \
.print_footer = func ## _print_footer, \
.print_integer = func ## _print_int, \
.print_string = func ## _print_str, \
.show_tags = func ## _show_tags
static struct writer writers[] = {{
.name = "default",
.item_sep = "\n",
.items_sep = "\n",
.section_sep = "\n",
.footer = "\n",
WRITER_FUNC(default),
},{
.name = "json",
.header = "{",
.item_sep = ",\n",
.items_sep = ",",
.section_sep = ",",
.footer = "\n}\n",
.print_section_start = json_print_section_start,
.print_section_end = json_print_section_end,
WRITER_FUNC(json),
}
};
static int get_writer(const char *name)
{
int i;
if (!name)
return 0;
for (i = 0; i < FF_ARRAY_ELEMS(writers); i++)
if (!strcmp(writers[i].name, name))
return i;
return -1;
}
#define SECTION_PRINT(name, multiple_entries, left) do { \
if (do_show_ ## name) { \ if (do_show_ ## name) { \
if (w->print_section_start) \ writer_print_chapter_header(wctx, #name); \
w->print_section_start(#name, multiple_entries); \ show_ ## name (wctx, fmt_ctx); \
show_ ## name (w, fmt_ctx); \ writer_print_chapter_footer(wctx, #name); \
if (w->print_section_end) \
w->print_section_end(#name, multiple_entries); \
if (left) \
printf("%s", w->section_sep); \
} \ } \
} while (0) } while (0)
static int probe_file(const char *filename) static int probe_file(const char *filename)
{ {
AVFormatContext *fmt_ctx; AVFormatContext *fmt_ctx;
int ret, writer_id; int ret;
struct writer *w; Writer *w;
WriterContext *wctx;
writer_register_all();
writer_id = get_writer(print_format); if (!print_format)
if (writer_id < 0) { print_format = av_strdup("default");
w = writer_get_by_name(print_format);
if (!w) {
fprintf(stderr, "Invalid output format '%s'\n", print_format); fprintf(stderr, "Invalid output format '%s'\n", print_format);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
w = &writers[writer_id];
if ((ret = open_input_file(&fmt_ctx, filename))) if ((ret = writer_open(&wctx, w, NULL, NULL)) < 0)
return ret; return ret;
if (w->header) if ((ret = open_input_file(&fmt_ctx, filename)))
printf("%s", w->header); return ret;
SECTION_PRINT(packets, 1, do_show_streams || do_show_format);
SECTION_PRINT(streams, 1, do_show_format);
SECTION_PRINT(format, 0, 0);
if (w->footer) writer_print_header(wctx);
printf("%s", w->footer); PRINT_CHAPTER(packets);
PRINT_CHAPTER(streams);
PRINT_CHAPTER(format);
writer_print_footer(wctx);
av_close_input_file(fmt_ctx); av_close_input_file(fmt_ctx);
writer_close(&wctx);
return 0; return 0;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment