Go to the documentation of this file.
57 65.406392, 92.498606, 130.81278, 184.99721, 261.62557, 369.99442, 523.25113, 739.9884, 1046.5023,
58 1479.9768, 2093.0045, 2959.9536, 4186.0091, 5919.9072, 8372.0181, 11839.814, 16744.036
66 for (m = 1; m <=
M; m++) {
69 t = pow(x / 2, m) /
s->fact[m];
79 float omega = 2 *
M_PI *
f;
81 if (n * omega * t == 0)
83 return 2 *
f * t *
sinf(n * omega * t) / (n * omega * t);
88 return n == 0 ? 1.f : 0.f;
100 float lhn2 =
hn_lpf(n, param[
i].upper,
fs);
101 ret += param[
i].
gain * (lhn2 - lhn);
115 return .5842f * pow(
a - 21, 0.4
f) + 0.07886f * (
a - 21);
116 return .1102f * (
a - 8.7f);
137 float scale = 1.f, iscale = 1.f;
149 s->winlen = (1 << (wb-1))-1;
150 s->tabsize = 1 << wb;
152 s->ires =
av_calloc(
s->tabsize + 2,
sizeof(
float));
154 s->fsamples =
av_calloc(
s->tabsize,
sizeof(
float));
155 s->fsamples_out =
av_calloc(
s->tabsize + 2,
sizeof(
float));
156 if (!
s->ires || !
s->irest || !
s->fsamples || !
s->fsamples_out)
159 for (
i = 0;
i <=
M;
i++) {
161 for (j = 1; j <=
i; j++)
172 const int winlen =
s->winlen;
173 const int tabsize =
s->tabsize;
180 for (
i = 0;
i < winlen;
i++)
181 s->irest[
i] =
hn(
i - winlen / 2, param,
fs) *
win(
s,
i - winlen / 2, winlen);
182 for (;
i < tabsize;
i++)
185 s->tx_fn(
s->rdft,
s->ires,
s->irest,
sizeof(
float));
193 const float *ires =
s->ires;
194 float *fsamples_out =
s->fsamples_out;
195 float *fsamples =
s->fsamples;
207 ptr = (
float *)
out->extended_data[ch];
208 dst = (
float *)
s->out->extended_data[ch];
212 fsamples[
i] =
src[
i];
213 for (;
i <
s->tabsize;
i++)
216 s->tx_fn(
s->rdft, fsamples_out, fsamples,
sizeof(
float));
218 for (
i = 0;
i <=
s->tabsize / 2;
i++) {
221 re = ires[
i*2 ] * fsamples_out[
i*2] - ires[
i*2+1] * fsamples_out[
i*2+1];
222 im = ires[
i*2+1] * fsamples_out[
i*2] + ires[
i*2 ] * fsamples_out[
i*2+1];
224 fsamples_out[
i*2 ] = re;
225 fsamples_out[
i*2+1] = im;
230 for (
i = 0;
i <
s->winlen;
i++)
231 dst[
i] += fsamples[
i] /
s->tabsize;
232 for (
i =
s->winlen; i < s->tabsize;
i++)
233 dst[
i] = fsamples[
i] /
s->tabsize;
234 for (
i = 0;
i <
out->nb_samples;
i++)
236 for (
i = 0;
i <
s->winlen;
i++)
326 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
327 #define OFFSET(x) offsetof(SuperEqualizerContext, x)
354 .
name =
"superequalizer",
357 .priv_class = &superequalizer_class,
static float hn_lpf(int n, float f, float fs)
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
@ AV_SAMPLE_FMT_FLTP
float, planar
static av_cold void uninit(AVFilterContext *ctx)
static const AVOption superequalizer_options[]
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 ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static float alpha(float a)
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).
EqParameter params[NBANDS+1]
const char * name
Filter name.
const AVFilter ff_af_superequalizer
int nb_channels
Number of channels in this layout.
A link between two filters.
static void make_fir(SuperEqualizerContext *s, float *lbc, float *rbc, EqParameter *param, float fs)
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
static float win(SuperEqualizerContext *s, float n, int N)
AVChannelLayout ch_layout
Channel layout of the audio data.
A filter pad used for either input or output.
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
static av_cold int init(AVFilterContext *ctx)
static int config_output(AVFilterLink *outlink)
static void process_param(float *bc, EqParameter *param, float fs)
static const float bands[]
#define FILTER_OUTPUTS(array)
static const AVFilterPad superequalizer_outputs[]
static float izero(SuperEqualizerContext *s, float x)
Describe the class of an AVClass context structure.
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.
#define fs(width, name, subs,...)
static __device__ float sqrtf(float a)
#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static float hn(int n, EqParameter *param, float fs)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
AVFilterContext * src
source filter
static int equ_init(SuperEqualizerContext *s, int wb)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
FF_FILTER_FORWARD_WANTED(outlink, inlink)
static const AVFilterPad superequalizer_inputs[]
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
int sample_rate
samples per second
int nb_samples
number of audio samples (per channel) described by this frame
#define i(width, name, range_min, range_max)
uint8_t ** extended_data
pointers to the data planes/channels.
const char * name
Pad name.
void * av_calloc(size_t nmemb, size_t size)
@ AV_TX_FLOAT_RDFT
Real to complex and complex to real DFTs.
static int config_input(AVFilterLink *inlink)
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
FF_FILTER_FORWARD_STATUS(inlink, outlink)
AVFILTER_DEFINE_CLASS(superequalizer)
static float hn_imp(int n)
static int activate(AVFilterContext *ctx)