Go to the documentation of this file.
47 #define ABS_UP_THRES 10
48 #define HIST_GRAIN 100
49 #define HIST_SIZE ((ABS_UP_THRES - ABS_THRES) * HIST_GRAIN + 1)
160 #define OFFSET(x) offsetof(EBUR128Context, x)
161 #define A AV_OPT_FLAG_AUDIO_PARAM
162 #define V AV_OPT_FLAG_VIDEO_PARAM
163 #define F AV_OPT_FLAG_FILTERING_PARAM
164 #define X AV_OPT_FLAG_EXPORT
165 #define R AV_OPT_FLAG_READONLY
170 {
"framelog",
"force frame logging level",
OFFSET(loglevel),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX,
A|
V|
F, .unit =
"level" },
180 {
"panlaw",
"set a specific pan law for dual-mono files",
OFFSET(pan_law),
AV_OPT_TYPE_DOUBLE, {.dbl = -3.01029995663978}, -10.0, 0.0,
A|
F },
181 {
"target",
"set a specific target level in LUFS (-23 to 0)",
OFFSET(target),
AV_OPT_TYPE_INT, {.i64 = -23}, -23, 0,
V|
F },
192 {
"integrated",
"integrated loudness (LUFS)",
OFFSET(integrated_loudness),
AV_OPT_TYPE_DOUBLE, {.dbl = 0}, -DBL_MAX, DBL_MAX,
A|
F|
X|
R },
224 const int above_opt_max = y > ebur128->
y_opt_max;
225 const int below_opt_min = y < ebur128->
y_opt_min;
226 const int reached = y >= v;
228 const int colorid = 8*below_opt_min+ 4*
line + 2*reached + above_opt_max;
234 v += 2 * ebur128->
meter;
264 for (
i = 0; buf[
i];
i++) {
266 uint8_t *p = pic->
data[0] + y*pic->
linesize[0] + (x +
i*8)*3;
268 for (char_y = 0; char_y < font_height; char_y++) {
270 if (font[buf[
i] * font_height + char_y] &
mask)
273 memcpy(p,
"\x00\x00\x00", 3);
286 for (
i = 0;
i <
len;
i++) {
287 memcpy(p,
"\x00\xff\x00", 3);
302 if (ebur128->
w < 640 || ebur128->
h < 480) {
304 "minimum size is 640x480\n", ebur128->
w, ebur128->
h);
307 outlink->
w = ebur128->
w;
308 outlink->
h = ebur128->
h;
317 ebur128->
text.
y = 40;
318 ebur128->
text.
w = 3 * 8;
350 for (
int y = 0; y < ebur128->
h; y++)
351 memset(outpicref->
data[0] + y * outpicref->
linesize[0], 0, ebur128->
w * 3);
357 x =
PAD + (i < 10 && i > -10) * 8;
361 "%c%d", i < 0 ? '-' : i > 0 ?
'+' :
' ',
FFABS(
i));
370 for (y = 0; y < ebur128->
graph.
h; y++) {
373 for (x = 0; x < ebur128->
graph.
w; x++)
374 memcpy(p + x*3,
c, 3);
379 #define DRAW_RECT(r) do { \
380 drawline(outpicref, r.x, r.y - 1, r.w, 3); \
381 drawline(outpicref, r.x, r.y + r.h, r.w, 3); \
382 drawline(outpicref, r.x - 1, r.y, r.h, outpicref->linesize[0]); \
383 drawline(outpicref, r.x + r.w, r.y, r.h, outpicref->linesize[0]); \
399 double f0 = 1681.974450955533;
400 double G = 3.999843853973347;
401 double Q = 0.7071752369554196;
403 double K = tan(
M_PI * f0 / (
double)
inlink->sample_rate);
404 double Vh = pow(10.0,
G / 20.0);
405 double Vb = pow(Vh, 0.4996667741545416);
407 double a0 = 1.0 +
K /
Q +
K *
K;
409 ebur128->
pre_b[0] = (Vh + Vb *
K /
Q +
K *
K) /
a0;
410 ebur128->
pre_b[1] = 2.0 * (
K *
K - Vh) /
a0;
411 ebur128->
pre_b[2] = (Vh - Vb *
K /
Q +
K *
K) /
a0;
412 ebur128->
pre_a[1] = 2.0 * (
K *
K - 1.0) /
a0;
415 f0 = 38.13547087602444;
416 Q = 0.5003270373238773;
419 ebur128->
rlb_b[0] = 1.0;
420 ebur128->
rlb_b[1] = -2.0;
421 ebur128->
rlb_b[2] = 1.0;
422 ebur128->
rlb_a[1] = 2.0 * (
K *
K - 1.0) / (1.0 +
K /
Q +
K *
K);
423 ebur128->
rlb_a[2] = (1.0 -
K /
Q +
K *
K) / (1.0 +
K /
Q +
K *
K);
443 #define BACK_MASK (AV_CH_BACK_LEFT |AV_CH_BACK_CENTER |AV_CH_BACK_RIGHT| \
444 AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_BACK_RIGHT| \
445 AV_CH_SIDE_LEFT |AV_CH_SIDE_RIGHT| \
446 AV_CH_SURROUND_DIRECT_LEFT |AV_CH_SURROUND_DIRECT_RIGHT)
449 ebur128->
x =
av_calloc(nb_channels, 3 *
sizeof(*ebur128->
x));
450 ebur128->
y =
av_calloc(nb_channels, 3 *
sizeof(*ebur128->
y));
451 ebur128->
z =
av_calloc(nb_channels, 3 *
sizeof(*ebur128->
z));
453 if (!ebur128->
ch_weighting || !ebur128->
x || !ebur128->
y || !ebur128->
z)
456 #define I400_BINS(x) ((x) * 4 / 10)
457 #define I3000_BINS(x) ((x) * 3)
467 for (
i = 0;
i < nb_channels;
i++) {
472 }
else if (chl < 64 && (1ULL << chl) &
BACK_MASK) {
490 #if CONFIG_SWRESAMPLE
494 ebur128->swr_buf =
av_malloc_array(nb_channels, 19200 *
sizeof(
double));
498 if (!ebur128->swr_buf || !ebur128->
true_peaks ||
525 #define ENERGY(loudness) (ff_exp10(((loudness) + 0.691) / 10.))
526 #define LOUDNESS(energy) (-0.691 + 10 * log10(energy))
527 #define DBFS(energy) (20 * log10(energy))
560 "True-peak mode requires libswresample to be performed\n");
602 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)
610 double relative_threshold;
621 if (!relative_threshold)
622 relative_threshold = 1e-12;
626 return gate_hist_pos;
631 int i, ch, idx_insample,
ret;
636 const double *
samples = (
double *)insamples->
data[0];
639 #
if CONFIG_SWRESAMPLE
641 const double *swr_samples = ebur128->swr_buf;
642 int ret =
swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200,
643 (
const uint8_t **)insamples->
data, nb_samples);
646 for (ch = 0; ch < nb_channels; ch++)
648 for (idx_insample = 0; idx_insample <
ret; idx_insample++) {
649 for (ch = 0; ch < nb_channels; ch++) {
659 for (idx_insample = ebur128->
idx_insample; idx_insample < nb_samples; idx_insample++) {
663 #define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \
664 ebur128->i##time.cache_pos++; \
665 if (ebur128->i##time.cache_pos == \
666 ebur128->i##time.cache_size) { \
667 ebur128->i##time.filled = 1; \
668 ebur128->i##time.cache_pos = 0; \
675 for (ch = 0; ch < nb_channels; ch++) {
681 ebur128->
x[ch * 3] =
samples[idx_insample * nb_channels + ch];
687 #define FILTER(Y, X, NUM, DEN) do { \
688 double *dst = ebur128->Y + ch*3; \
689 double *src = ebur128->X + ch*3; \
692 dst[0] = src[0]*NUM[0] + src[1]*NUM[1] + src[2]*NUM[2] \
693 - dst[1]*DEN[1] - dst[2]*DEN[2]; \
698 ebur128->
x[ch * 3 + 2] = ebur128->
x[ch * 3 + 1];
699 ebur128->
x[ch * 3 + 1] = ebur128->
x[ch * 3 ];
702 bin = ebur128->
z[ch * 3] * ebur128->
z[ch * 3];
710 ebur128->
i400.
cache [ch][bin_id_400 ] = bin;
714 #define FIND_PEAK(global, sp, ptype) do { \
718 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
719 for (ch = 0; ch < ebur128->nb_channels; ch++) \
720 maxpeak = FFMAX(maxpeak, sp[ch]); \
721 global = DBFS(maxpeak); \
732 double loudness_400, loudness_3000;
733 double power_400 = 1e-12, power_3000 = 1e-12;
741 #define COMPUTE_LOUDNESS(m, time) do { \
742 if (ebur128->i##time.filled) { \
744 for (ch = 0; ch < nb_channels; ch++) \
745 power_##time += ebur128->ch_weighting[ch] * ebur128->i##time.sum[ch]; \
746 power_##time /= I##time##_BINS(inlink->sample_rate); \
748 loudness_##time = LOUDNESS(power_##time); \
755 #define I_GATE_THRES -10 // initially defined to -8 LU in the first EBU standard
758 double integrated_sum = 0.0;
759 uint64_t nb_integrated = 0;
767 nb_integrated += nb_v;
773 if (nb_channels == 1 && ebur128->
dual_mono) {
780 #define LRA_GATE_THRES -20
781 #define LRA_LOWER_PRC 10
782 #define LRA_HIGHER_PRC 95
787 uint64_t nb_powers = 0;
824 if (nb_channels == 1 && ebur128->
dual_mono) {
825 loudness_400 -= ebur128->
pan_law;
826 loudness_3000 -= ebur128->
pan_law;
829 #define LOG_FMT "TARGET:%d LUFS M:%6.1f S:%6.1f I:%6.1f %s LRA:%6.1f LU"
837 int y_loudness_lu_graph, y_loudness_lu_gauge;
840 gauge_value = loudness_400 - ebur128->
target;
842 gauge_value = loudness_3000 - ebur128->
target;
845 y_loudness_lu_graph =
lu_to_y(ebur128, loudness_3000 - ebur128->
target);
846 y_loudness_lu_gauge =
lu_to_y(ebur128, gauge_value);
857 for (y = 0; y < ebur128->
graph.
h; y++) {
860 memmove(p, p + 3, (ebur128->
graph.
w - 1) * 3);
861 memcpy(p + (ebur128->
graph.
w - 1) * 3,
c, 3);
862 p += pic->linesize[0];
866 p = pic->data[0] + ebur128->
gauge.
y*pic->linesize[0] + ebur128->
gauge.
x*3;
867 for (y = 0; y < ebur128->
gauge.
h; y++) {
870 for (x = 0; x < ebur128->
gauge.
w; x++)
871 memcpy(p + x*3,
c, 3);
872 p += pic->linesize[0];
879 ebur128->
target, loudness_400, loudness_3000,
901 #define META_PREFIX "lavfi.r128."
903 #define SET_META(name, var) do { \
904 snprintf(metabuf, sizeof(metabuf), "%.3f", var); \
905 av_dict_set(&insamples->metadata, name, metabuf, 0); \
908 #define SET_META_PEAK(name, ptype) do { \
909 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
910 double max_peak = 0.0; \
912 for (ch = 0; ch < nb_channels; ch++) { \
913 snprintf(key, sizeof(key), \
914 META_PREFIX AV_STRINGIFY(name) "_peaks_ch%d", ch); \
915 max_peak = fmax(max_peak, ebur128->name##_peaks[ch]); \
916 SET_META(key, ebur128->name##_peaks[ch]); \
918 snprintf(key, sizeof(key), \
919 META_PREFIX AV_STRINGIFY(name) "_peak"); \
920 SET_META(key, max_peak); \
939 ebur128->
target, loudness_400, loudness_3000,
948 #define PRINT_PEAKS(str, sp, ptype) do { \
949 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
950 av_log(ctx, ebur128->loglevel, " " str ":"); \
951 for (ch = 0; ch < nb_channels; ch++) \
952 av_log(ctx, ebur128->loglevel, " %5.1f", DBFS(sp[ch])); \
953 av_log(ctx, ebur128->loglevel, " dBFS"); \
1053 " Integrated loudness:\n"
1055 " Threshold: %5.1f LUFS\n\n"
1056 " Loudness range:\n"
1058 " Threshold: %5.1f LUFS\n"
1059 " LRA low: %5.1f LUFS\n"
1060 " LRA high: %5.1f LUFS",
1065 #define PRINT_PEAK_SUMMARY(str, value, ptype) do { \
1066 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
1067 av_log(ctx, AV_LOG_INFO, "\n\n " str " peak:\n" \
1068 " Peak: %5.1f dBFS", value); \
1098 #if CONFIG_SWRESAMPLE
1122 .priv_class = &ebur128_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
AVPixelFormat
Pixel format.
int dual_mono
whether or not to treat single channel input files as dual-mono
double * z
3 RLB-filter samples cache for each channel
double * ch_weighting
channel weighting mapping
int y_opt_min
the y value (pixel position) for -1 LU
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
int filled
1 if the cache is completely filled, 0 otherwise
int gauge_type
whether gauge shows momentary or short
int y_opt_max
the y value (pixel position) for 1 LU
#define SET_META_PEAK(name, ptype)
#define PRINT_PEAKS(str, sp, ptype)
static const uint8_t * get_graph_color(const EBUR128Context *ebur128, int v, int y)
#define AV_LOG_QUIET
Print no output.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static enum AVSampleFormat sample_fmts[]
int do_video
1 if video output enabled, 0 otherwise
int sample_count
sample count used for refresh frequency, reset at refresh
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define FILTER_INPUTS(array)
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
enum AVChannel av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx)
Get the channel with the given index in a channel layout.
AVFILTER_DEFINE_CLASS(ebur128)
static const AVOption ebur128_options[]
#define AV_LOG_VERBOSE
Detailed information.
#define FIND_PEAK(global, sp, ptype)
static av_cold int init(AVFilterContext *ctx)
const char * name
Filter name.
static int config_audio_output(AVFilterLink *outlink)
double sum_kept_powers
sum of the powers (weighted sums) above absolute threshold
int nb_channels
Number of channels in this layout.
A link between two filters.
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Link properties exposed to filter code, but not external callers.
static av_cold void uninit(AVFilterContext *ctx)
double pan_law
pan law value used to calculate dual-mono measurements
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
double rlb_b[3]
rlb-filter numerator coefficients
static void drawline(AVFrame *pic, int x, int y, int len, int step)
static struct hist_entry * get_histogram(void)
int scale
display scale type of statistics
double rlb_a[3]
rlb-filter denominator coefficients
int cache_pos
focus on the last added bin in the cache array
int nb_samples
number of samples to consume per single input frame
A filter pad used for either input or output.
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t *const *out_arg, int out_count, const uint8_t *const *in_arg, int in_count)
Convert audio.
static const uint8_t font_colors[]
int metadata
whether or not to inject loudness results in frames
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define MOVE_TO_NEXT_CACHED_ENTRY(time)
#define FILTER(Y, X, NUM, DEN)
struct rect graph
rectangle for the main graph in the center
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
static int config_video_output(AVFilterLink *outlink)
double integrated_loudness
integrated loudness in LUFS (I)
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
int target
target level in LUFS used to set relative zero LU in visualization
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static enum AVPixelFormat pix_fmts[]
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt,...)
The libswresample context.
double loudness
L = -0.691 + 10 * log10(E)
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
double * true_peaks_per_frame
true peaks in a frame per channel
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
double * sample_peaks
sample peaks per channel
#define HIST_GRAIN
defines histogram precision
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Describe the class of an AVClass context structure.
static __device__ float fabs(float a)
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
int peak_mode
enabled peak modes
Rational number (pair of numerator and denominator).
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
double pre_b[3]
pre-filter numerator coefficients
struct rect gauge
rectangle for the gauge on the right
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
static FilterLink * ff_filter_link(AVFilterLink *link)
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
@ PEAK_MODE_SAMPLES_PEAKS
unsigned count
how many times the corresponding value occurred
double pre_a[3]
pre-filter denominator coefficients
int y_zero_lu
the y value (pixel position) for 0 LU
struct integrator i3000
3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
static int activate(AVFilterContext *ctx)
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)
int format
agreed upon media format
static AVRational av_make_q(int num, int den)
Create an AVRational.
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
AVFilterContext * src
source filter
double true_peak
global true peak
static double a0(void *priv, double x, double y)
double sample_peak
global sample peak
AVFrame * outpicref
output picture reference, updated regularly
FF_FILTER_FORWARD_WANTED(outlink, inlink)
int h
size of the video output
#define AV_LOG_INFO
Standard information.
int sample_rate
samples per second
int nb_samples
number of audio samples (per channel) described by this frame
const uint8_t avpriv_vga16_font[4096]
#define i(width, name, range_min, range_max)
double * y
3 pre-filter samples cache for each channel
struct rect text
rectangle for the LU legend on the left
int w
agreed upon image width
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
#define av_malloc_array(a, b)
AVSampleFormat
Audio sample formats.
#define FILTER_QUERY_FUNC2(func)
double rel_threshold
relative threshold
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
#define ABS_THRES
silence gate: we discard anything below this absolute (LUFS) threshold
const char * name
Pad name.
int nb_kept_powers
number of sum above absolute threshold
double * true_peaks
true peaks per channel
void * av_calloc(size_t nmemb, size_t size)
double loudness_range
loudness range in LU (LRA)
double energy
E = 10^((L + 0.691) / 10)
static const uint8_t graph_colors[]
double * sum
sum of the last N ms filtered samples (cache content)
double lra_high
low and high LRA values
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
const AVFilter ff_af_ebur128
int scale_range
the range of LU values according to the meter
static float power(float r, float g, float b, float max)
#define SET_META(name, var)
@ AV_CHAN_LOW_FREQUENCY_2
int h
agreed upon image height
int meter
select a EBU mode between +9 and +18
@ AV_OPT_TYPE_INT
Underlying C type is int.
AVFrame * insamples
input samples reference, updated regularly
Filter the word “frame” indicates either a video frame or a group of audio samples
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
double ** cache
window of filtered samples (N ms)
static const AVFilterPad ebur128_inputs[]
AVChannelLayout ch_layout
channel layout of current buffer (see libavutil/channel_layout.h)
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
const uint8_t avpriv_cga_font[2048]
static void scale(int *out, const int *in, const int w, const int h, const int shift)
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
int nb_channels
number of channels in the input
int idx_insample
current sample position of processed samples in single input frame
#define FF_FILTER_FORWARD_STATUS_ALL(inlink, filter)
Acknowledge the status on an input link and forward it to an output link.
struct integrator i400
400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
static int config_audio_input(AVFilterLink *inlink)
struct hist_entry * histogram
histogram of the powers, used to compute LRA and I
double * x
3 input samples cache for each channel
#define PRINT_PEAK_SUMMARY(str, value, ptype)
@ AV_SAMPLE_FMT_DBL
double
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable.
static int lu_to_y(const EBUR128Context *ebur128, double v)
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
int loglevel
log level for frame logging
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
#define COMPUTE_LOUDNESS(m, time)
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
A histogram is an array of HIST_SIZE hist_entry storing all the energies recorded (with an accuracy o...