[FFmpeg-devel] [RFC] Lowpass filter
Kostya
kostya.shishkov
Tue Aug 26 18:48:07 CEST 2008
On Tue, Aug 26, 2008 at 02:18:18PM +0200, Michael Niedermayer wrote:
> On Tue, Aug 26, 2008 at 08:48:54AM +0300, Kostya wrote:
[...]
> > /*
> > * Lowpass IIR filter
>
> Is there anything specific to lowpassing in the code?
> If not than IIR filter would be a better name.
Here's your generic version (but with implementation for only one particular case).
> [...]
> > /**
> > * Initialize filter coefficients.
> > *
> > * @param order filter order
> > * @param cutoff_ratio cutoff to input frequency ratio
> > *
> > * @return pointer to filter coefficients structure or NULL if filter cannot be created
> > */
> > struct FFLPFilterCoeffs* ff_lowpass_filter_init_coeffs(int order, float cutoff_ratio);
>
> This should also have a enum for filter type.
>
>
> [...]
> > //maximum supported filter order
> > #define MAXORDER 30
>
> does it work with order 30 or are roundoff errors causing problems already,
> i mean at some order they will ...
They do, but with this filter order I've managed to get filtered signal
resembling original one.
[...]
> --
> Michael GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB
>
> I have never wished to cater to the crowd; for what I know they do not
> approve, and what they approve I do not know. -- Epicurus
-------------- next part --------------
/*
* IIR filter
* Copyright (c) 2008 Konstantin Shishkov
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file filter.h
* IIR filter interface (maybe FIR will be here too)
*/
#ifndef FFMPEG_FILTER_H
#define FFMPEG_FILTER_H
#include "avcodec.h"
struct FFFilterCoeffs;
struct FFFilterState;
enum FilterType{
FF_FILTER_TYPE_BESSEL,
FF_FILTER_TYPE_BUTTERWORTH,
FF_FILTER_TYPE_CHEBYSHEV,
FF_FILTER_TYPE_ELLIPTIC,
};
enum FilterMode{
FF_FILTER_MODE_LOWPASS,
FF_FILTER_MODE_HIGHPASS,
FF_FILTER_MODE_BANDPASS,
FF_FILTER_MODE_BANDSTOP,
};
/**
* Initialize filter coefficients.
*
* @param filt_type filter type (e.g. Butterworth)
* @param filt_mode filter mode (e.g. lowpass)
* @param order filter order
* @param cutoff_ratio cutoff to input frequency ratio
* @param stopband stopband to input frequency ratio (used by bandpass and bandstop filter modes)
* @param ripple ripple factor (used only in Chebyshev filters)
*
* @return pointer to filter coefficients structure or NULL if filter cannot be created
*/
struct FFFilterCoeffs* ff_filter_init_coeffs(enum FilterType filt_type,
enum FilterMode filt_mode,
int order, float cutoff_ratio,
float stopband, float ripple);
/**
* Create new filter state.
*
* @param order filter order
*
* @return pointer to new filter state or NULL if state creation fails
*/
struct FFFilterState* ff_filter_init_state(int order);
/**
* Free filter coefficients.
*
* @param coeffs pointer allocated with ff_filter_init_coeffs()
*/
void ff_filter_free_coeffs(struct FFFilterCoeffs *coeffs);
/**
* Free filter state.
*
* @param state pointer allocated with ff_filter_init_state()
*/
void ff_filter_free_state(struct FFFilterState *state);
/**
* Perform lowpass filtering on input samples.
*
* @param coeffs pointer to filter coefficients
* @param state pointer to filter state
* @param size input length
* @param src source samples
* @param sstep source stride
* @param dst filtered samples (destination may be the same as input)
* @param dstep destination stride
*/
void ff_filter(const struct FFFilterCoeffs *coeffs, struct FFFilterState *state, int size, int16_t *src, int sstep, int16_t *dst, int dstep);
#endif /* FFMPEG_FILTER_H */
-------------- next part --------------
/*
* IIR filter
* Copyright (c) 2008 Konstantin Shishkov
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file filter.c
* different IIR filters implementation
*/
#include "filter.h"
#include <complex.h>
#include <math.h>
/**
* IIR filter global parameters
*/
typedef struct FFFilterCoeffs{
int order;
float gain;
int *cx;
float *cy;
}FFFilterCoeffs;
/**
* IIR filter state
*/
typedef struct FFFilterState{
float *x;
}FFFilterState;
//maximum supported filter order
#define MAXORDER 30
struct FFFilterCoeffs* ff_filter_init_coeffs(enum FilterType filt_type,
enum FilterMode filt_mode,
int order, float cutoff_ratio,
float stopband, float ripple)
{
int i, j, size;
FFFilterCoeffs *c;
double wa;
complex p[MAXORDER + 1];
if(filt_type != FF_FILTER_TYPE_BESSEL || filt_mode != FF_FILTER_MODE_LOWPASS)
return NULL;
if(order <= 1 || (order & 1) || order > MAXORDER || cutoff_ratio >= 1.0)
return NULL;
c = av_malloc(sizeof(FFFilterCoeffs));
c->cx = av_mallocz(sizeof(c->cx[0]) * (order / 2 + 1));
c->cy = av_malloc (sizeof(c->cy[0]) * order);
c->order = order;
wa = 2 * tan(M_PI * 0.5 * cutoff_ratio);
c->cx[0] = 1;
for(i = 1; i < order / 2 + 1; i++)
c->cx[i] = c->cx[i - 1] * (order - i + 1LL) / i;
p[0] = 1.0;
for(i = 1; i <= order; i++)
p[i] = 0.0;
for(i = 0; i < order; i++){
complex zp;
double th = (i + order/2 + 0.5) * M_PI / order;
zp = cexp(I*th) * wa;
zp = (zp + 2.0) / (zp - 2.0);
for(j = order; j >= 1; j--)
p[j] = zp*p[j] + p[j - 1];
p[0] *= zp;
}
c->gain = creal(p[order]);
for(i = 0; i < order; i++){
c->gain += creal(p[i]);
c->cy[i] = creal(-p[i] / p[order]);
}
c->gain /= 1 << order;
return c;
}
struct FFFilterState* ff_filter_init_state(int order)
{
FFFilterState *s = av_mallocz(sizeof(FFFilterState) + sizeof(s->x[0]) * order);
s->x = (void*)s + sizeof(s->x);
return s;
}
#define FILTER(i0, i1, i2, i3) \
in = *src * c->gain \
+ c->cy[0]*s->x[i0] + c->cy[1]*s->x[i1] \
+ c->cy[2]*s->x[i2] + c->cy[3]*s->x[i3]; \
res = (s->x[i0] + in )*1 \
+ (s->x[i1] + s->x[i3])*4 \
+ s->x[i2] *6; \
*dst = av_clip_int16(lrintf(res)); \
s->x[i0] = in; \
src += sstep; \
dst += dstep; \
void ff_filter(const struct FFFilterCoeffs *c, struct FFFilterState *s, int size, int16_t *src, int sstep, int16_t *dst, int dstep)
{
int i;
if(c->order == 4){
for(i = 0; i < size; i += 4){
float in, res;
FILTER(0, 1, 2, 3);
FILTER(1, 2, 3, 0);
FILTER(2, 3, 0, 1);
FILTER(3, 0, 1, 2);
}
}else{
for(i = 0; i < size; i++){
int j;
float in, res;
in = *src * c->gain;
for(j = 0; j < c->order; j++)
in += c->cy[j] * s->x[j];
res = s->x[0] + in + s->x[c->order/2] * c->cx[c->order/2];
for(j = 1; j < (c->order / 2); j++)
res += (s->x[j] + s->x[c->order - j]) * c->cx[j];
for(j = 0; j < c->order - 1; j++)
s->x[j] = s->x[j + 1];
*dst = av_clip_int16(lrintf(res));
s->x[c->order - 1] = in;
src += sstep;
dst += sstep;
}
}
}
void ff_filter_free_state(struct FFFilterState *state)
{
av_free(state);
}
void ff_filter_free_coeffs(struct FFFilterCoeffs *coeffs)
{
if(coeffs){
av_free(coeffs->cx);
av_free(coeffs->cy);
}
av_free(coeffs);
}
More information about the ffmpeg-devel
mailing list