Go to the documentation of this file.
29 #define MAX_NB_COEFFS 16
56 #define PFILTER(name, type, sin, cos, cc) \
57 static void pfilter_channel_## name(AVFilterContext *ctx, \
59 AVFrame *in, AVFrame *out) \
61 AFreqShift *s = ctx->priv; \
62 const int nb_samples = in->nb_samples; \
63 const type *src = (const type *)in->extended_data[ch]; \
64 type *dst = (type *)out->extended_data[ch]; \
65 type *i1 = (type *)s->i1->extended_data[ch]; \
66 type *o1 = (type *)s->o1->extended_data[ch]; \
67 type *i2 = (type *)s->i2->extended_data[ch]; \
68 type *o2 = (type *)s->o2->extended_data[ch]; \
69 const type *c = s->cc; \
70 const type level = s->level; \
71 type shift = s->shift * M_PI; \
72 type cos_theta = cos(shift); \
73 type sin_theta = sin(shift); \
75 for (int n = 0; n < nb_samples; n++) { \
76 type xn1 = src[n], xn2 = src[n]; \
79 for (int j = 0; j < s->nb_coeffs; j++) { \
80 I = c[j] * (xn1 + o2[j]) - i2[j]; \
88 for (int j = s->nb_coeffs; j < s->nb_coeffs*2; j++) { \
89 Q = c[j] * (xn2 + o2[j]) - i2[j]; \
96 Q = o2[s->nb_coeffs * 2 - 1]; \
98 dst[n] = (I * cos_theta - Q * sin_theta) * level; \
102 PFILTER(flt,
float, sin, cos, cf)
103 PFILTER(dbl,
double, sin, cos, cd)
105 #define FFILTER(name, type, sin, cos, fmod, cc) \
106 static void ffilter_channel_## name(AVFilterContext *ctx, \
108 AVFrame *in, AVFrame *out) \
110 AFreqShift *s = ctx->priv; \
111 const int nb_samples = in->nb_samples; \
112 const type *src = (const type *)in->extended_data[ch]; \
113 type *dst = (type *)out->extended_data[ch]; \
114 type *i1 = (type *)s->i1->extended_data[ch]; \
115 type *o1 = (type *)s->o1->extended_data[ch]; \
116 type *i2 = (type *)s->i2->extended_data[ch]; \
117 type *o2 = (type *)s->o2->extended_data[ch]; \
118 const type *c = s->cc; \
119 const type level = s->level; \
120 type ts = 1. / in->sample_rate; \
121 type shift = s->shift; \
122 int64_t N = s->in_samples; \
124 for (int n = 0; n < nb_samples; n++) { \
125 type xn1 = src[n], xn2 = src[n]; \
128 for (int j = 0; j < s->nb_coeffs; j++) { \
129 I = c[j] * (xn1 + o2[j]) - i2[j]; \
137 for (int j = s->nb_coeffs; j < s->nb_coeffs*2; j++) { \
138 Q = c[j] * (xn2 + o2[j]) - i2[j]; \
145 Q = o2[s->nb_coeffs * 2 - 1]; \
147 theta = 2. * M_PI * fmod(shift * (N + n) * ts, 1.); \
148 dst[n] = (I * cos(theta) - Q * sin(theta)) * level; \
153 FFILTER(dbl,
double, sin, cos, fmod, cd)
157 double kksqrt, e, e2, e4, k, q;
159 k = tan((1. - transition * 2.) *
M_PI / 4.);
161 kksqrt = pow(1 - k * k, 0.25);
162 e = 0.5 * (1. - kksqrt) / (1. + kksqrt);
165 q = e * (1. + e4 * (2. + e4 * (15. + 150. * e4)));
171 static double ipowp(
double x, int64_t n)
194 q_ii1 *= sin((
i * 2 + 1) *
c *
M_PI / order) * j;
199 }
while (
fabs(q_ii1) > 1e-100);
213 q_i2 *= cos(
i * 2 *
c *
M_PI / order) * j;
218 }
while (
fabs(q_i2) > 1e-100);
228 const double ww = num / den;
229 const double wwsq = ww * ww;
231 const double x = sqrt((1 - wwsq * k) * (1 - wwsq / k)) / (1 + wwsq);
232 const double coef = (1 - x) / (1 + x);
237 static void compute_coefs(
double *coef_arrd,
float *coef_arrf,
int nbr_coefs,
double transition)
239 const int order = nbr_coefs * 2 + 1;
244 for (
int n = 0; n < nbr_coefs; n++) {
245 const int idx = (n / 2) + (n & 1) * nbr_coefs / 2;
248 coef_arrf[idx] = coef_arrd[idx];
257 if (
s->old_nb_coeffs !=
s->nb_coeffs)
259 s->old_nb_coeffs =
s->nb_coeffs;
265 if (!
s->i1 || !
s->o1 || !
s->i2 || !
s->o2)
269 if (!strcmp(
ctx->filter->name,
"afreqshift"))
270 s->filter_channel = ffilter_channel_dbl;
272 s->filter_channel = pfilter_channel_dbl;
274 if (!strcmp(
ctx->filter->name,
"afreqshift"))
275 s->filter_channel = ffilter_channel_flt;
277 s->filter_channel = pfilter_channel_flt;
296 for (
int ch = start; ch < end; ch++)
297 s->filter_channel(
ctx, ch, in,
out);
310 if (
s->old_nb_coeffs !=
s->nb_coeffs)
312 s->old_nb_coeffs =
s->nb_coeffs;
346 #define OFFSET(x) offsetof(AFreqShift, x)
347 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
375 .
name =
"afreqshift",
378 .priv_class = &afreqshift_class,
398 .
name =
"aphaseshift",
401 .priv_class = &aphaseshift_class,
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
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.
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
static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static const AVFilterPad inputs[]
This structure describes decoded (raw) audio or video data.
double cd[MAX_NB_COEFFS *2]
const char * name
Filter name.
int nb_channels
Number of channels in this layout.
A link between two filters.
static const AVOption aphaseshift_options[]
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
const AVFilter ff_af_aphaseshift
AVChannelLayout ch_layout
Channel layout of the audio data.
A filter pad used for either input or output.
static double compute_acc_den(double q, int order, int c)
float cf[MAX_NB_COEFFS *2]
#define PFILTER(name, type, sin, cos, cc)
static enum AVSampleFormat sample_fmts[]
#define FILTER_INPUTS(array)
static void compute_transition_param(double *K, double *Q, double transition)
Describe the class of an AVClass context structure.
static __device__ float fabs(float a)
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
static double ipowp(double x, int64_t n)
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
#define FFILTER(name, type, sin, cos, fmod, cc)
static double compute_acc_num(double q, int order, int c)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static int shift(int a, int b)
#define FILTER_SAMPLEFMTS_ARRAY(array)
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
static int config_input(AVFilterLink *inlink)
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
static av_cold void uninit(AVFilterContext *ctx)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
int nb_samples
number of audio samples (per channel) described by this frame
#define i(width, name, range_min, range_max)
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
AVSampleFormat
Audio sample formats.
Used for passing data between threads.
const AVFilter ff_af_afreqshift
const char * name
Pad name.
static void compute_coefs(double *coef_arrd, float *coef_arrf, int nbr_coefs, double transition)
static const AVOption afreqshift_options[]
void(* filter_channel)(AVFilterContext *ctx, int channel, AVFrame *in, AVFrame *out)
static const AVFilterPad outputs[]
@ AV_SAMPLE_FMT_DBLP
double, planar
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
#define FILTER_OUTPUTS(array)
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
AVFILTER_DEFINE_CLASS(afreqshift)
static double compute_coef(int index, double k, double q, int order)