namespace NSpeex
{
    using System;

    internal class Filters
    {
        private int last_pitch;
        private float[] last_pitch_gain;
        private float smooth_gain;
        private float[] xx;

        public Filters()
        {
            float num;
            this.last_pitch_gain = new float[3];
            this.xx = new float[0x400];
            this.last_pitch = 0;
            this.last_pitch_gain[2] = num = 0f;
            this.last_pitch_gain[0] = this.last_pitch_gain[1] = num;
            this.smooth_gain = 1f;
        }

        public static void Bw_lpc(float gamma, float[] lpc_in, float[] lpc_out, int order)
        {
            float num = 1f;
            for (int i = 0; i < (order + 1); i++)
            {
                lpc_out[i] = num * lpc_in[i];
                num *= gamma;
            }
        }

        public void Comb_filter(float[] exc, int esi, float[] new_exc, int nsi, int nsf, int pitch, float[] pitch_gain, float comb_gain)
        {
            int num;
            float num3 = 0f;
            float num4 = 0f;
            float num8 = 0f;
            for (num = esi; num < (esi + nsf); num++)
            {
                num3 += exc[num] * exc[num];
            }
            num8 = 0.5f * Math.Abs((float)(((((pitch_gain[0] + pitch_gain[1]) + pitch_gain[2]) + this.last_pitch_gain[0]) + this.last_pitch_gain[1]) + this.last_pitch_gain[2]));
            if (num8 > 1.3f)
            {
                comb_gain *= 1.3f / num8;
            }
            if (num8 < 0.5f)
            {
                comb_gain *= 2f * num8;
            }
            float num6 = 1f / ((float)nsf);
            float num7 = 0f;
            num = 0;
            for (int i = esi; num < nsf; i++)
            {
                num7 += num6;
                new_exc[nsi + num] = (exc[i] + ((comb_gain * num7) * (((pitch_gain[0] * exc[(i - pitch) + 1]) + (pitch_gain[1] * exc[i - pitch])) + (pitch_gain[2] * exc[(i - pitch) - 1])))) + ((comb_gain * (1f - num7)) * (((this.last_pitch_gain[0] * exc[(i - this.last_pitch) + 1]) + (this.last_pitch_gain[1] * exc[i - this.last_pitch])) + (this.last_pitch_gain[2] * exc[(i - this.last_pitch) - 1])));
                num++;
            }
            this.last_pitch_gain[0] = pitch_gain[0];
            this.last_pitch_gain[1] = pitch_gain[1];
            this.last_pitch_gain[2] = pitch_gain[2];
            this.last_pitch = pitch;
            for (num = nsi; num < (nsi + nsf); num++)
            {
                num4 += new_exc[num] * new_exc[num];
            }
            float num5 = (float)Math.Sqrt((double)(num3 / (0.1f + num4)));
            if (num5 < 0.5f)
            {
                num5 = 0.5f;
            }
            if (num5 > 1f)
            {
                num5 = 1f;
            }
            for (num = nsi; num < (nsi + nsf); num++)
            {
                this.smooth_gain = (0.96f * this.smooth_gain) + (0.04f * num5);
                new_exc[num] *= this.smooth_gain;
            }
        }

        public static void Filter_mem2(float[] x, int xs, float[] num, float[] den, int N, int ord, float[] mem, int ms)
        {
            for (int i = 0; i < N; i++)
            {
                float num4 = x[xs + i];
                x[xs + i] = (num[0] * num4) + mem[ms];
                float num5 = x[xs + i];
                for (int j = 0; j < (ord - 1); j++)
                {
                    mem[ms + j] = (mem[(ms + j) + 1] + (num[j + 1] * num4)) - (den[j + 1] * num5);
                }
                mem[(ms + ord) - 1] = (num[ord] * num4) - (den[ord] * num5);
            }
        }

        public static void Filter_mem2(float[] x, int xs, float[] num, float[] den, float[] y, int ys, int N, int ord, float[] mem, int ms)
        {
            for (int i = 0; i < N; i++)
            {
                float num4 = x[xs + i];
                y[ys + i] = (num[0] * num4) + mem[0];
                float num5 = y[ys + i];
                for (int j = 0; j < (ord - 1); j++)
                {
                    mem[ms + j] = (mem[(ms + j) + 1] + (num[j + 1] * num4)) - (den[j + 1] * num5);
                }
                mem[(ms + ord) - 1] = (num[ord] * num4) - (den[ord] * num5);
            }
        }

        public void Fir_mem_up(float[] x, float[] a, float[] y, int N, int M, float[] mem)
        {
            int num;
            for (num = 0; num < (N / 2); num++)
            {
                this.xx[2 * num] = x[((N / 2) - 1) - num];
            }
            for (num = 0; num < (M - 1); num += 2)
            {
                this.xx[N + num] = mem[num + 1];
            }
            for (num = 0; num < N; num += 4)
            {
                float num4;
                float num5;
                float num6;
                float num3 = num4 = num5 = num6 = 0f;
                float num7 = this.xx[(N - 4) - num];
                for (int i = 0; i < M; i += 4)
                {
                    float num9 = a[i];
                    float num10 = a[i + 1];
                    float num8 = this.xx[((N - 2) + i) - num];
                    num3 += num9 * num8;
                    num4 += num10 * num8;
                    num5 += num9 * num7;
                    num6 += num10 * num7;
                    num9 = a[i + 2];
                    num10 = a[i + 3];
                    num7 = this.xx[(N + i) - num];
                    num3 += num9 * num7;
                    num4 += num10 * num7;
                    num5 += num9 * num8;
                    num6 += num10 * num8;
                }
                y[num] = num3;
                y[num + 1] = num4;
                y[num + 2] = num5;
                y[num + 3] = num6;
            }
            for (num = 0; num < (M - 1); num += 2)
            {
                mem[num + 1] = this.xx[num];
            }
        }

        public static void Fir_mem2(float[] x, int xs, float[] num, float[] y, int ys, int N, int ord, float[] mem)
        {
            for (int i = 0; i < N; i++)
            {
                float num4 = x[xs + i];
                y[ys + i] = (num[0] * num4) + mem[0];
                for (int j = 0; j < (ord - 1); j++)
                {
                    mem[j] = mem[j + 1] + (num[j + 1] * num4);
                }
                mem[ord - 1] = num[ord] * num4;
            }
        }

        public static void Iir_mem2(float[] x, int xs, float[] den, float[] y, int ys, int N, int ord, float[] mem)
        {
            for (int i = 0; i < N; i++)
            {
                y[ys + i] = x[xs + i] + mem[0];
                for (int j = 0; j < (ord - 1); j++)
                {
                    mem[j] = mem[j + 1] - (den[j + 1] * y[ys + i]);
                }
                mem[ord - 1] = -den[ord] * y[ys + i];
            }
        }

        public static void Qmf_decomp(float[] xx_0, float[] aa, float[] y1, float[] y2, int N, int M, float[] mem)
        {
            int num;
            float[] numArray = new float[M];
            float[] numArray2 = new float[(N + M) - 1];
            int num5 = M - 1;
            int num4 = M >> 1;
            for (num = 0; num < M; num++)
            {
                numArray[(M - num) - 1] = aa[num];
            }
            for (num = 0; num < (M - 1); num++)
            {
                numArray2[num] = mem[(M - num) - 2];
            }
            for (num = 0; num < N; num++)
            {
                numArray2[(num + M) - 1] = xx_0[num];
            }
            num = 0;
            for (int i = 0; num < N; i++)
            {
                y1[i] = 0f;
                y2[i] = 0f;
                for (int j = 0; j < num4; j++)
                {
                    y1[i] += numArray[j] * (numArray2[num + j] + numArray2[(num5 + num) - j]);
                    y2[i] -= numArray[j] * (numArray2[num + j] - numArray2[(num5 + num) - j]);
                    j++;
                    y1[i] += numArray[j] * (numArray2[num + j] + numArray2[(num5 + num) - j]);
                    y2[i] += numArray[j] * (numArray2[num + j] - numArray2[(num5 + num) - j]);
                }
                num += 2;
            }
            for (num = 0; num < (M - 1); num++)
            {
                mem[num] = xx_0[(N - num) - 1];
            }
        }

        public static void Residue_percep_zero(float[] xx_0, int xxs, float[] ak, float[] awk1, float[] awk2, float[] y, int N, int ord)
        {
            float[] mem = new float[ord];
            Filter_mem2(xx_0, xxs, ak, awk1, y, 0, N, ord, mem, 0);
            for (int i = 0; i < ord; i++)
            {
                mem[i] = 0f;
            }
            Fir_mem2(y, 0, awk2, y, 0, N, ord, mem);
        }

        public static void Syn_percep_zero(float[] xx_0, int xxs, float[] ak, float[] awk1, float[] awk2, float[] y, int N, int ord)
        {
            float[] mem = new float[ord];
            Filter_mem2(xx_0, xxs, awk1, ak, y, 0, N, ord, mem, 0);
            for (int i = 0; i < ord; i++)
            {
                mem[i] = 0f;
            }
            Iir_mem2(y, 0, awk2, y, 0, N, ord, mem);
        }
    }
}