FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
f_bench.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/opt.h"
20 #include "libavutil/time.h"
21 #include "avfilter.h"
22 #include "formats.h"
23 #include "internal.h"
24 
29 };
30 
31 typedef struct BenchContext {
32  const AVClass *class;
33  int action;
34  int64_t max, min;
35  int64_t sum;
36  int n;
37 } BenchContext;
38 
39 #define OFFSET(x) offsetof(BenchContext, x)
40 #define DEFINE_OPTIONS(filt_name, FLAGS) \
41 static const AVOption filt_name##_options[] = { \
42  { "action", "set action", OFFSET(action), AV_OPT_TYPE_INT, {.i64=ACTION_START}, 0, NB_ACTION-1, FLAGS, "action" }, \
43  { "start", "start timer", 0, AV_OPT_TYPE_CONST, {.i64=ACTION_START}, INT_MIN, INT_MAX, FLAGS, "action" }, \
44  { "stop", "stop timer", 0, AV_OPT_TYPE_CONST, {.i64=ACTION_STOP}, INT_MIN, INT_MAX, FLAGS, "action" }, \
45  { NULL } \
46 }
47 
48 #define START_TIME_KEY "lavfi.bench.start_time"
49 #define T2F(v) ((v) / 1000000.)
50 
52 {
53  BenchContext *s = ctx->priv;
54  s->min = INT64_MAX;
55  s->max = INT64_MIN;
56  return 0;
57 }
58 
59 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
60 {
61  AVFilterContext *ctx = inlink->dst;
62  BenchContext *s = ctx->priv;
63  AVFilterLink *outlink = ctx->outputs[0];
64  const int64_t t = av_gettime();
65 
66  if (t < 0)
67  return ff_filter_frame(outlink, in);
68 
69  if (s->action == ACTION_START) {
71  } else if (s->action == ACTION_STOP) {
73  if (e) {
74  const int64_t start = strtoll(e->value, NULL, 0);
75  const int64_t diff = t - start;
76  s->sum += diff;
77  s->n++;
78  s->min = FFMIN(s->min, diff);
79  s->max = FFMAX(s->max, diff);
80  av_log(s, AV_LOG_INFO, "t:%f avg:%f max:%f min:%f\n",
81  T2F(diff), T2F(s->sum / s->n), T2F(s->max), T2F(s->min));
82  }
84  }
85 
86  return ff_filter_frame(outlink, in);
87 }
88 
89 #if CONFIG_BENCH_FILTER
92 
93 static const AVFilterPad bench_inputs[] = {
94  {
95  .name = "default",
96  .type = AVMEDIA_TYPE_VIDEO,
97  .filter_frame = filter_frame,
98  },
99  { NULL }
100 };
101 
102 static const AVFilterPad bench_outputs[] = {
103  {
104  .name = "default",
105  .type = AVMEDIA_TYPE_VIDEO,
106  },
107  { NULL }
108 };
109 
111  .name = "bench",
112  .description = NULL_IF_CONFIG_SMALL("Benchmark part of a filtergraph."),
113  .priv_size = sizeof(BenchContext),
114  .init = init,
115  .inputs = bench_inputs,
116  .outputs = bench_outputs,
117  .priv_class = &bench_class,
118 };
119 #endif /* CONFIG_BENCH_FILTER */
120 
121 #if CONFIG_ABENCH_FILTER
123 AVFILTER_DEFINE_CLASS(abench);
124 
125 static const AVFilterPad abench_inputs[] = {
126  {
127  .name = "default",
128  .type = AVMEDIA_TYPE_AUDIO,
129  .filter_frame = filter_frame,
130  },
131  { NULL }
132 };
133 
134 static const AVFilterPad abench_outputs[] = {
135  {
136  .name = "default",
137  .type = AVMEDIA_TYPE_AUDIO,
138  },
139  { NULL }
140 };
141 
143  .name = "abench",
144  .description = NULL_IF_CONFIG_SMALL("Benchmark part of a filtergraph."),
145  .priv_size = sizeof(BenchContext),
146  .init = init,
147  .inputs = abench_inputs,
148  .outputs = abench_outputs,
149  .priv_class = &abench_class,
150 };
151 #endif /* CONFIG_ABENCH_FILTER */
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
int64_t max
Definition: f_bench.c:34
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
#define START_TIME_KEY
Definition: f_bench.c:48
Main libavfilter public API header.
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int action
Definition: f_bench.c:33
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
#define av_cold
Definition: attributes.h:82
AVOptions.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
AVDictionary * metadata
metadata.
Definition: frame.h:505
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
AVFilter ff_vf_bench
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:291
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define FFMAX(a, b)
Definition: common.h:94
int64_t sum
Definition: f_bench.c:35
#define FFMIN(a, b)
Definition: common.h:96
static av_cold int init(AVFilterContext *ctx)
Definition: f_bench.c:51
AVFormatContext * ctx
Definition: movenc.c:48
#define T2F(v)
Definition: f_bench.c:49
#define DEFINE_OPTIONS(filt_name, FLAGS)
Definition: f_bench.c:40
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:279
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
BenchAction
Definition: f_bench.c:25
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
const char * name
Filter name.
Definition: avfilter.h:148
int64_t min
Definition: f_bench.c:34
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
static av_always_inline int diff(const uint32_t a, const uint32_t b)
char * value
Definition: dict.h:87
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:334
An instance of a filter.
Definition: avfilter.h:338
void INT64 start
Definition: avisynth_c.h:690
internal API functions
AVFilter ff_af_abench
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: f_bench.c:59