#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
+#include "libavutil/avstring.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavutil/dict.h"
static const char *unit_byte_str = "byte" ;
static const char *unit_bit_per_second_str = "bit/s";
-void exit_program(int ret)
+void av_noreturn exit_program(int ret)
{
exit(ret);
}
-static char *value_string(char *buf, int buf_size, double val, const char *unit)
+struct unit_value {
+ union { double d; int i; } val;
+ const char *unit;
+};
+
+static char *value_string(char *buf, int buf_size, struct unit_value uv)
{
- if (unit == unit_second_str && use_value_sexagesimal_format) {
+ double vald;
+ int show_float = 0;
+
+ if (uv.unit == unit_second_str) {
+ vald = uv.val.d;
+ show_float = 1;
+ } else {
+ vald = uv.val.i;
+ }
+
+ if (uv.unit == unit_second_str && use_value_sexagesimal_format) {
double secs;
int hours, mins;
- secs = val;
+ secs = vald;
mins = (int)secs / 60;
secs = secs - mins * 60;
hours = mins / 60;
snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
} else if (use_value_prefix) {
const char *prefix_string;
- int index;
+ int index, l;
- if (unit == unit_byte_str && use_byte_value_binary_prefix) {
- index = (int) (log(val)/log(2)) / 10;
+ if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
+ index = (int) (log(vald)/log(2)) / 10;
index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) -1);
- val /= pow(2, index*10);
+ vald /= pow(2, index*10);
prefix_string = binary_unit_prefixes[index];
} else {
- index = (int) (log10(val)) / 3;
+ index = (int) (log10(vald)) / 3;
index = av_clip(index, 0, FF_ARRAY_ELEMS(decimal_unit_prefixes) -1);
- val /= pow(10, index*3);
+ vald /= pow(10, index*3);
prefix_string = decimal_unit_prefixes[index];
}
- snprintf(buf, buf_size, "%.3f%s%s%s", val, prefix_string || show_value_unit ? " " : "",
- prefix_string, show_value_unit ? unit : "");
+ if (show_float || vald != (int)vald) l = snprintf(buf, buf_size, "%.3f", vald);
+ else l = snprintf(buf, buf_size, "%d", (int)vald);
+ snprintf(buf+l, buf_size-l, "%s%s%s", prefix_string || show_value_unit ? " " : "",
+ prefix_string, show_value_unit ? uv.unit : "");
} else {
- snprintf(buf, buf_size, "%f%s%s", val, show_value_unit ? " " : "",
- show_value_unit ? unit : "");
+ int l;
+
+ if (show_float) l = snprintf(buf, buf_size, "%.3f", vald);
+ else l = snprintf(buf, buf_size, "%d", (int)vald);
+ snprintf(buf+l, buf_size-l, "%s%s", show_value_unit ? " " : "",
+ show_value_unit ? uv.unit : "");
}
return buf;
if (val == AV_NOPTS_VALUE) {
snprintf(buf, buf_size, "N/A");
} else {
- value_string(buf, buf_size, val * av_q2d(*time_base), unit_second_str);
+ double d = val * av_q2d(*time_base);
+ value_string(buf, buf_size, (struct unit_value){.val.d=d, .unit=unit_second_str});
}
return buf;
unsigned int nb_chapter; ///< number of the chapter, starting at 0
};
+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)
{
if (*wctx && (*wctx)->writer->uninit)
goto fail;
}
+ (*wctx)->class = &writer_class;
(*wctx)->writer = writer;
if ((*wctx)->writer->init)
ret = (*wctx)->writer->init(*wctx, args, opaque);
return NULL;
}
+#define ESCAPE_INIT_BUF_SIZE 256
+
+#define ESCAPE_CHECK_SIZE(src, size, max_size) \
+ if (size > max_size) { \
+ char buf[64]; \
+ snprintf(buf, sizeof(buf), "%s", src); \
+ av_log(log_ctx, AV_LOG_WARNING, \
+ "String '%s...' with is too big\n", buf); \
+ return "FFPROBE_TOO_BIG_STRING"; \
+ }
+
+#define ESCAPE_REALLOC_BUF(dst_size_p, dst_p, src, size) \
+ if (*dst_size_p < size) { \
+ char *q = av_realloc(*dst_p, size); \
+ if (!q) { \
+ char buf[64]; \
+ snprintf(buf, sizeof(buf), "%s", src); \
+ av_log(log_ctx, AV_LOG_WARNING, \
+ "String '%s...' could not be escaped\n", buf); \
+ return "FFPROBE_THIS_STRING_COULD_NOT_BE_ESCAPED"; \
+ } \
+ *dst_size_p = size; \
+ *dst = q; \
+ }
+
/* WRITERS */
/* Default output */
printf("\n");
}
+/* 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] = src[i]-32;
+ dst[i] = 0;
+ return dst;
+}
+
static void default_print_section_header(WriterContext *wctx, const char *section)
{
+ char buf[32];
+
if (wctx->nb_section)
printf("\n");
- printf("[%s]\n", section);
+ printf("[%s]\n", upcase_string(buf, sizeof(buf), section));
}
static void default_print_section_footer(WriterContext *wctx, const char *section)
{
- printf("[/%s]", section);
+ char buf[32];
+
+ printf("[/%s]", upcase_string(buf, sizeof(buf), section));
}
static void default_print_str(WriterContext *wctx, const char *key, const char *value)
typedef struct {
int multiple_entries; ///< tells if the given chapter requires multiple entries
+ char *buf;
+ size_t buf_size;
} JSONContext;
-static char *json_escape_str(const char *s)
+static av_cold int json_init(WriterContext *wctx, const char *args, void *opaque)
+{
+ JSONContext *json = wctx->priv;
+
+ json->buf_size = ESCAPE_INIT_BUF_SIZE;
+ if (!(json->buf = av_malloc(json->buf_size)))
+ return AVERROR(ENOMEM);
+
+ return 0;
+}
+
+static av_cold void json_uninit(WriterContext *wctx)
+{
+ JSONContext *json = wctx->priv;
+ av_freep(&json->buf);
+}
+
+static const char *json_escape_str(char **dst, size_t *dst_size, const char *src,
+ void *log_ctx)
{
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;
+ const char *p;
+ char *q;
+ size_t size = 1;
// 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
+ for (p = src; *p; p++) {
+ ESCAPE_CHECK_SIZE(src, size, SIZE_MAX-6);
+ if (strchr(json_escape, *p)) size += 2; // simple escape
+ else if ((unsigned char)*p < 32) size += 6; // handle non-printable chars
+ else size += 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;
+ ESCAPE_REALLOC_BUF(dst_size, dst, src, size);
+
+ q = *dst;
+ for (p = src; *p; p++) {
+ char *s = strchr(json_escape, *p);
+ if (s) {
+ *q++ = '\\';
+ *q++ = json_subst[s - json_escape];
+ } else if ((unsigned char)*p < 32) {
+ snprintf(q, 7, "\\u00%02x", *p & 0xff);
+ q += 6;
} else {
- *p++ = s[i];
+ *q++ = *p;
}
}
- *p = 0;
- return ret;
+ *q = 0;
+ return *dst;
}
static void json_print_header(WriterContext *wctx)
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 : "",
+ printf("\n \"%s\":%s", json_escape_str(&json->buf, &json->buf_size, chapter, wctx),
json->multiple_entries ? " [" : " ");
- av_free(chapter_esc);
}
static void json_print_chapter_footer(WriterContext *wctx, const char *chapter)
const char *key, const char *value,
const char *indent)
{
- char *key_esc = json_escape_str(key);
- char *value_esc = json_escape_str(value);
+ JSONContext *json = wctx->priv;
- printf("%s\"%s\": \"%s\"", indent,
- key_esc ? key_esc : "",
- value_esc ? value_esc : "");
- av_free(key_esc);
- av_free(value_esc);
+ printf("%s\"%s\":", indent, json_escape_str(&json->buf, &json->buf_size, key, wctx));
+ printf(" \"%s\"", json_escape_str(&json->buf, &json->buf_size, value, wctx));
}
#define INDENT " "
static void json_print_int(WriterContext *wctx, const char *key, int value)
{
- char *key_esc = json_escape_str(key);
+ JSONContext *json = wctx->priv;
if (wctx->nb_item) printf(",\n");
- printf(INDENT "\"%s\": %d", key_esc ? key_esc : "", value);
- av_free(key_esc);
+ printf(INDENT "\"%s\": %d",
+ json_escape_str(&json->buf, &json->buf_size, key, wctx), value);
}
static void json_show_tags(WriterContext *wctx, AVDictionary *dict)
.name = "json",
.priv_size = sizeof(JSONContext),
+ .init = json_init,
+ .uninit = json_uninit,
.print_header = json_print_header,
.print_footer = json_print_footer,
.print_chapter_header = json_print_chapter_header,
#define print_int(k, v) writer_print_integer(w, k, v)
#define print_str(k, v) writer_print_string(w, k, v)
+#define print_ts(k, v) writer_print_string(w, k, ts_value_string (val_str, sizeof(val_str), v))
+#define print_time(k, v, tb) writer_print_string(w, k, time_value_string(val_str, sizeof(val_str), v, tb))
+#define print_val(k, v, u) writer_print_string(w, k, value_string (val_str, sizeof(val_str), \
+ (struct unit_value){.val.i = v, .unit=u}))
#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)
AVStream *st = fmt_ctx->streams[pkt->stream_index];
struct print_buf pbuf = {.s = NULL};
- print_section_header("PACKET");
+ print_section_header("packet");
print_str("codec_type", av_x_if_null(av_get_media_type_string(st->codec->codec_type), "unknown"));
print_int("stream_index", pkt->stream_index);
- 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("dts", ts_value_string (val_str, sizeof(val_str), pkt->dts));
- print_str("dts_time", time_value_string(val_str, sizeof(val_str), pkt->dts, &st->time_base));
- print_str("duration", ts_value_string (val_str, sizeof(val_str), pkt->duration));
- print_str("duration_time", time_value_string(val_str, sizeof(val_str), pkt->duration, &st->time_base));
- print_str("size", value_string (val_str, sizeof(val_str), pkt->size, unit_byte_str));
+ print_ts ("pts", pkt->pts);
+ print_time("pts_time", pkt->pts, &st->time_base);
+ print_ts ("dts", pkt->dts);
+ print_time("dts_time", pkt->dts, &st->time_base);
+ print_ts ("duration", pkt->duration);
+ print_time("duration_time", pkt->duration, &st->time_base);
+ print_val("size", pkt->size, unit_byte_str);
print_fmt("pos", "%"PRId64, pkt->pos);
print_fmt("flags", "%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');
- print_section_footer("PACKET");
+ print_section_footer("packet");
av_free(pbuf.s);
fflush(stdout);
AVRational display_aspect_ratio;
struct print_buf pbuf = {.s = NULL};
- print_section_header("STREAM");
+ print_section_header("stream");
print_int("index", stream->index);
break;
case AVMEDIA_TYPE_AUDIO:
- print_str("sample_rate", value_string(val_str, sizeof(val_str), dec_ctx->sample_rate, unit_hertz_str));
+ print_str("sample_fmt",
+ av_x_if_null(av_get_sample_fmt_name(dec_ctx->sample_fmt), "unknown"));
+ print_val("sample_rate", dec_ctx->sample_rate, unit_hertz_str);
print_int("channels", dec_ctx->channels);
print_int("bits_per_sample", av_get_bits_per_sample(dec_ctx->codec_id));
break;
} else {
print_str("codec_type", "unknown");
}
+ if (dec_ctx->codec && dec_ctx->codec->priv_class) {
+ const AVOption *opt = NULL;
+ while (opt = av_opt_next(dec_ctx->priv_data,opt)) {
+ uint8_t *str;
+ if (opt->flags) continue;
+ if (av_opt_get(dec_ctx->priv_data, opt->name, 0, &str) >= 0) {
+ print_str(opt->name, str);
+ av_free(str);
+ }
+ }
+ }
if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS)
print_fmt("id", "0x%x", stream->id);
print_fmt("r_frame_rate", "%d/%d", stream->r_frame_rate.num, stream->r_frame_rate.den);
print_fmt("avg_frame_rate", "%d/%d", stream->avg_frame_rate.num, stream->avg_frame_rate.den);
print_fmt("time_base", "%d/%d", stream->time_base.num, stream->time_base.den);
- print_str("start_time", time_value_string(val_str, sizeof(val_str), stream->start_time, &stream->time_base));
- print_str("duration", time_value_string(val_str, sizeof(val_str), stream->duration, &stream->time_base));
+ print_time("start_time", stream->start_time, &stream->time_base);
+ print_time("duration", stream->duration, &stream->time_base);
if (stream->nb_frames)
print_fmt("nb_frames", "%"PRId64, stream->nb_frames);
show_tags(stream->metadata);
- print_section_footer("STREAM");
+ print_section_footer("stream");
av_free(pbuf.s);
fflush(stdout);
}
static void show_format(WriterContext *w, AVFormatContext *fmt_ctx)
{
char val_str[128];
+ int64_t size = avio_size(fmt_ctx->pb);
struct print_buf pbuf = {.s = NULL};
- print_section_header("FORMAT");
+ print_section_header("format");
print_str("filename", fmt_ctx->filename);
print_int("nb_streams", fmt_ctx->nb_streams);
print_str("format_name", fmt_ctx->iformat->name);
print_str("format_long_name", fmt_ctx->iformat->long_name);
- print_str("start_time", time_value_string(val_str, sizeof(val_str), fmt_ctx->start_time, &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("bit_rate", value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate, unit_bit_per_second_str));
+ print_time("start_time", fmt_ctx->start_time, &AV_TIME_BASE_Q);
+ print_time("duration", fmt_ctx->duration, &AV_TIME_BASE_Q);
+ if (size >= 0)
+ print_val("size", size, unit_byte_str);
+ print_val("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
show_tags(fmt_ctx->metadata);
- print_section_footer("FORMAT");
+ print_section_footer("format");
av_free(pbuf.s);
fflush(stdout);
}
AVFormatContext *fmt_ctx;
int ret;
Writer *w;
+ char *buf;
+ char *w_name = NULL, *w_args = NULL;
WriterContext *wctx;
writer_register_all();
if (!print_format)
print_format = av_strdup("default");
- w = writer_get_by_name(print_format);
+ w_name = av_strtok(print_format, "=", &buf);
+ w_args = buf;
+
+ w = writer_get_by_name(w_name);
if (!w) {
- fprintf(stderr, "Invalid output format '%s'\n", print_format);
- return AVERROR(EINVAL);
+ av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
+ ret = AVERROR(EINVAL);
+ goto end;
}
- if ((ret = writer_open(&wctx, w, NULL, NULL)) < 0)
- return ret;
-
+ if ((ret = writer_open(&wctx, w, w_args, NULL)) < 0)
+ goto end;
if ((ret = open_input_file(&fmt_ctx, filename)))
- return ret;
+ goto end;
writer_print_header(wctx);
PRINT_CHAPTER(packets);
av_close_input_file(fmt_ctx);
writer_close(&wctx);
- return 0;
+end:
+ av_freep(&print_format);
+
+ return ret;
}
static void show_usage(void)
static int opt_help(const char *opt, const char *arg)
{
- const AVClass *class = avformat_get_class();
av_log_set_callback(log_callback_help);
show_usage();
show_help_options(options, "Main options:\n", 0, 0);
printf("\n");
- av_opt_show2(&class, NULL,
- AV_OPT_FLAG_DECODING_PARAM, 0);
+
+ show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
+
return 0;
}
parse_loglevel(argc, argv, options);
av_register_all();
+ avformat_network_init();
init_opts();
#if CONFIG_AVDEVICE
avdevice_register_all();
ret = probe_file(input_filename);
+ avformat_network_deinit();
+
return ret;
}
projects / ffmpeg / blobdiff