PeerStreamer

#define CONV_S16(dest, source) dest = av_clip_int16(lrintf(source));

#define CONV_FLT(dest, source) dest = source;

#define FILTER_BW_O4_1(i0, i1, i2, i3, fmt)         \

    in = *src0 * 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;                 \

    CONV_##fmt(*dst0, res)                          \

    s->x[i0] = in;                                  \

    src0 += sstep;                                  \

    dst0 += dstep;

#define FILTER_BW_O4(type, fmt) {           \

    int i;                                  \

    const type *src0 = src;                 \

    type       *dst0 = dst;                 \

    for (i = 0; i < size; i += 4) {         \

        float in, res;                      \

        FILTER_BW_O4_1(0, 1, 2, 3, fmt);    \

        FILTER_BW_O4_1(1, 2, 3, 0, fmt);    \

        FILTER_BW_O4_1(2, 3, 0, 1, fmt);    \

        FILTER_BW_O4_1(3, 0, 1, 2, fmt);    \

    }                                       \

}

#define FILTER_DIRECT_FORM_II(type, fmt) {                                  \

    int i;                                                                  \

    const type *src0 = src;                                                 \

    type       *dst0 = dst;                                                 \

    for (i = 0; i < size; i++) {                                            \

        int j;                                                              \

        float in, res;                                                      \

        in = *src0 * 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 >> 1] * c->cx[c->order >> 1];    \

        for(j = 1; j < c->order >> 1; 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];                                          \

        CONV_##fmt(*dst0, res)                                              \

        s->x[c->order - 1] = in;                                            \

        src0 += sstep;                                                      \

        dst0 += dstep;                                                      \

    }                                                                       \

}

    if (c->order == 4) {

        FILTER_BW_O4(int16_t, S16)

    } else {

        FILTER_DIRECT_FORM_II(int16_t, S16)

    }

}

void ff_iir_filter_flt(const struct FFIIRFilterCoeffs *c,

                       struct FFIIRFilterState *s, int size,

                       const float *src, int sstep, void *dst, int dstep)

{

    if (c->order == 4) {

        FILTER_BW_O4(float, FLT)

    } else {

        FILTER_DIRECT_FORM_II(float, FLT)

 * Perform IIR filtering on signed 16-bit input samples.

/**

 * Perform IIR filtering on floating-point 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_iir_filter_flt(const struct FFIIRFilterCoeffs *coeffs,

                       struct FFIIRFilterState *state, int size,

                       const float *src, int sstep, void *dst, int dstep);