#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"
static char *print_format;
-static const OptionDef options[];
+static const OptionDef *options;
/* FFprobe context */
static const char *input_filename;
long long int index;
if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
- index = (long long int) (log(vald)/log(2)) / 10;
+ index = (long long int) (log2(vald)) / 10;
index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) - 1);
vald /= pow(2, index * 10);
prefix_string = binary_unit_prefixes[index];
av_opt_set_defaults(def);
if (args &&
- (err = (av_set_options_string(def, args, "=", ":"))) < 0) {
- av_log(wctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+ (err = (av_set_options_string(def, args, "=", ":"))) < 0)
return err;
- }
return 0;
}
av_opt_set_defaults(compact);
if (args &&
- (err = (av_set_options_string(compact, args, "=", ":"))) < 0) {
- av_log(wctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+ (err = (av_set_options_string(compact, args, "=", ":"))) < 0)
return err;
- }
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);
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 },
- {"hierachical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
+ {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
{"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
{NULL},
};
av_opt_set_defaults(flat);
if (args &&
- (err = (av_set_options_string(flat, args, "=", ":"))) < 0) {
- av_log(wctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+ (err = (av_set_options_string(flat, args, "=", ":"))) < 0)
return err;
- }
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);
#define OFFSET(x) offsetof(INIContext, x)
static const AVOption ini_options[] = {
- {"hierachical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
+ {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
{"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
{NULL},
};
ini->class = &ini_class;
av_opt_set_defaults(ini);
- if (args && (err = av_set_options_string(ini, args, "=", ":")) < 0) {
- av_log(wctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+ if (args && (err = av_set_options_string(ini, args, "=", ":")) < 0)
return err;
- }
return 0;
}
av_opt_set_defaults(json);
if (args &&
- (err = (av_set_options_string(json, args, "=", ":"))) < 0) {
- av_log(wctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+ (err = (av_set_options_string(json, args, "=", ":"))) < 0)
return err;
- }
json->item_sep = json->compact ? ", " : ",\n";
json->item_start_end = json->compact ? " " : "\n";
av_opt_set_defaults(xml);
if (args &&
- (err = (av_set_options_string(xml, args, "=", ":"))) < 0) {
- av_log(wctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+ (err = (av_set_options_string(xml, args, "=", ":"))) < 0)
return err;
- }
if (xml->xsd_strict) {
xml->fully_qualified = 1;
fflush(stdout);
}
-static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream)
+static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
+ AVFormatContext *fmt_ctx)
{
AVBPrint pbuf;
const char *s;
else print_str_opt("pkt_pos", "N/A");
switch (stream->codec->codec_type) {
+ AVRational sar;
+
case AVMEDIA_TYPE_VIDEO:
print_int("width", frame->width);
print_int("height", frame->height);
s = av_get_pix_fmt_name(frame->format);
if (s) print_str ("pix_fmt", s);
else print_str_opt("pix_fmt", "unknown");
- if (frame->sample_aspect_ratio.num) {
- print_q("sample_aspect_ratio", frame->sample_aspect_ratio, ':');
+ sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
+ if (sar.num) {
+ print_q("sample_aspect_ratio", sar, ':');
} else {
print_str_opt("sample_aspect_ratio", "N/A");
}
if (s) print_str ("sample_fmt", s);
else print_str_opt("sample_fmt", "unknown");
print_int("nb_samples", frame->nb_samples);
+ print_int("channels", av_frame_get_channels(frame));
+ if (av_frame_get_channel_layout(frame)) {
+ av_bprint_clear(&pbuf);
+ av_bprint_channel_layout(&pbuf, av_frame_get_channels(frame),
+ av_frame_get_channel_layout(frame));
+ print_str ("channel_layout", pbuf.str);
+ } else
+ print_str_opt("channel_layout", "unknown");
break;
}
+ show_tags(av_frame_get_metadata(frame));
print_section_footer("frame");
fflush(stdout);
}
-static av_always_inline int get_decoded_frame(AVFormatContext *fmt_ctx,
- AVFrame *frame, int *got_frame,
- AVPacket *pkt)
+static av_always_inline int process_frame(WriterContext *w,
+ AVFormatContext *fmt_ctx,
+ AVFrame *frame, AVPacket *pkt)
{
AVCodecContext *dec_ctx = fmt_ctx->streams[pkt->stream_index]->codec;
- int ret = 0;
+ int ret = 0, got_frame = 0;
- *got_frame = 0;
- switch (dec_ctx->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- ret = avcodec_decode_video2(dec_ctx, frame, got_frame, pkt);
- break;
+ avcodec_get_frame_defaults(frame);
+ if (dec_ctx->codec) {
+ switch (dec_ctx->codec_type) {
+ case AVMEDIA_TYPE_VIDEO:
+ ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, pkt);
+ break;
- case AVMEDIA_TYPE_AUDIO:
- ret = avcodec_decode_audio4(dec_ctx, frame, got_frame, pkt);
- break;
+ case AVMEDIA_TYPE_AUDIO:
+ ret = avcodec_decode_audio4(dec_ctx, frame, &got_frame, pkt);
+ break;
+ }
}
- return ret;
+ if (ret < 0)
+ return ret;
+ ret = FFMIN(ret, pkt->size); /* guard against bogus return values */
+ pkt->data += ret;
+ pkt->size -= ret;
+ if (got_frame) {
+ nb_streams_frames[pkt->stream_index]++;
+ if (do_show_frames)
+ show_frame(w, frame, fmt_ctx->streams[pkt->stream_index], fmt_ctx);
+ }
+ return got_frame;
}
static void read_packets(WriterContext *w, AVFormatContext *fmt_ctx)
{
AVPacket pkt, pkt1;
AVFrame frame;
- int i = 0, ret, got_frame;
+ int i = 0;
av_init_packet(&pkt);
}
if (do_read_frames) {
pkt1 = pkt;
- while (pkt1.size) {
- avcodec_get_frame_defaults(&frame);
- ret = get_decoded_frame(fmt_ctx, &frame, &got_frame, &pkt1);
- if (ret < 0 || !got_frame)
- break;
- if (do_show_frames)
- show_frame(w, &frame, fmt_ctx->streams[pkt.stream_index]);
- pkt1.data += ret;
- pkt1.size -= ret;
- nb_streams_frames[pkt.stream_index]++;
- }
+ while (pkt1.size && process_frame(w, fmt_ctx, &frame, &pkt1) > 0);
}
av_free_packet(&pkt);
}
//Flush remaining frames that are cached in the decoder
for (i = 0; i < fmt_ctx->nb_streams; i++) {
pkt.stream_index = i;
- while (get_decoded_frame(fmt_ctx, &frame, &got_frame, &pkt) >= 0 && got_frame) {
- if (do_read_frames) {
- if (do_show_frames)
- show_frame(w, &frame, fmt_ctx->streams[pkt.stream_index]);
- nb_streams_frames[pkt.stream_index]++;
- }
- }
+ if (do_read_frames)
+ while (process_frame(w, fmt_ctx, &frame, &pkt) > 0);
}
}
AVCodec *dec;
char val_str[128];
const char *s;
- AVRational display_aspect_ratio;
+ AVRational sar, dar;
AVBPrint pbuf;
av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
print_int("width", dec_ctx->width);
print_int("height", dec_ctx->height);
print_int("has_b_frames", dec_ctx->has_b_frames);
- if (dec_ctx->sample_aspect_ratio.num) {
- print_q("sample_aspect_ratio", dec_ctx->sample_aspect_ratio, ':');
- av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
- dec_ctx->width * dec_ctx->sample_aspect_ratio.num,
- dec_ctx->height * dec_ctx->sample_aspect_ratio.den,
+ sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
+ if (sar.den) {
+ print_q("sample_aspect_ratio", sar, ':');
+ av_reduce(&dar.num, &dar.den,
+ dec_ctx->width * sar.num,
+ dec_ctx->height * sar.den,
1024*1024);
- print_q("display_aspect_ratio", display_aspect_ratio, ':');
+ print_q("display_aspect_ratio", dar, ':');
} else {
print_str_opt("sample_aspect_ratio", "N/A");
print_str_opt("display_aspect_ratio", "N/A");
else print_str_opt("nb_read_frames", "N/A");
if (nb_streams_packets[stream_idx]) print_fmt ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
else print_str_opt("nb_read_packets", "N/A");
- show_tags(stream->metadata);
if (do_show_data)
writer_print_data(w, "extradata", dec_ctx->extradata,
dec_ctx->extradata_size);
+ show_tags(stream->metadata);
print_section_footer("stream");
av_bprint_finalize(&pbuf, NULL);
AVStream *stream = fmt_ctx->streams[i];
AVCodec *codec;
- if (stream->codec->codec_id == CODEC_ID_PROBE) {
+ if (stream->codec->codec_id == AV_CODEC_ID_PROBE) {
av_log(NULL, AV_LOG_ERROR,
"Failed to probe codec for input stream %d\n",
stream->index);
/* close decoder for each stream */
for (i = 0; i < fmt_ctx->nb_streams; i++)
- if (fmt_ctx->streams[i]->codec->codec_id != CODEC_ID_NONE)
+ if (fmt_ctx->streams[i]->codec->codec_id != AV_CODEC_ID_NONE)
avcodec_close(fmt_ctx->streams[i]->codec);
avformat_close_input(ctx_ptr);
program_birth_year, this_year);
print_str("build_date", __DATE__);
print_str("build_time", __TIME__);
- print_str("compiler_type", CC_TYPE);
- print_str("compiler_version", CC_VERSION);
+ print_str("compiler_ident", CC_IDENT);
print_str("configuration", FFMPEG_CONFIGURATION);
print_section_footer("program_version");
writer_print_chapter_footer(w, "program_version");
return 0;
}
-static const OptionDef options[] = {
+static const OptionDef real_options[] = {
#include "cmdutils_common_opts.h"
{ "f", HAS_ARG, {(void*)opt_format}, "force format", "format" },
{ "unit", OPT_BOOL, {(void*)&show_value_unit}, "show unit of the displayed values" },
int ret;
av_log_set_flags(AV_LOG_SKIP_REPEATED);
+ options = real_options;
parse_loglevel(argc, argv, options);
av_register_all();
avformat_network_init();
projects / ffmpeg / blobdiff