namespace NSpeex
{
    using System;

    internal class Ltp3Tap : Ltp
    {
        private float[][] e;
        private float[] gain = new float[3];
        private int gain_bits;
        private int[] gain_cdbk;
        private int pitch_bits;

        public Ltp3Tap(int[] gain_cdbk_0, int gain_bits_1, int pitch_bits_2)
        {
            this.gain_cdbk = gain_cdbk_0;
            this.gain_bits = gain_bits_1;
            this.pitch_bits = pitch_bits_2;
            this.e = this.CreateJaggedArray<float>(3, 0x80);
        }

        private T[][] CreateJaggedArray<T>(int dim1, int dim2)
        {
            T[][] localArray = new T[dim1][];
            for (int i = 0; i < dim1; i++)
            {
                localArray[i] = new T[dim2];
                Array.Clear(localArray[i], 0, dim2);
            }
            return localArray;
        }

        private float Pitch_gain_search_3tap(float[] target, float[] ak, float[] awk1, float[] awk2, float[] exc, int es, int pitch, int p, int nsf, Bits bits, float[] exc2, int e2s, float[] r, int[] cdbk_index)
        {
            int num;
            int num2;
            float[] numArray2 = new float[3];
            float[][] numArray3 = this.CreateJaggedArray<float>(3, 3);
            int num3 = ((int)1) << this.gain_bits;
            float[][] numArray = this.CreateJaggedArray<float>(3, nsf);
            this.e = this.CreateJaggedArray<float>(3, nsf);
            for (num = 2; num >= 0; num--)
            {
                int num6 = (pitch + 1) - num;
                num2 = 0;
                while (num2 < nsf)
                {
                    if ((num2 - num6) < 0)
                    {
                        this.e[num][num2] = exc2[(e2s + num2) - num6];
                    }
                    else if (((num2 - num6) - pitch) < 0)
                    {
                        this.e[num][num2] = exc2[((e2s + num2) - num6) - pitch];
                    }
                    else
                    {
                        this.e[num][num2] = 0f;
                    }
                    num2++;
                }
                if (num == 2)
                {
                    Filters.Syn_percep_zero(this.e[num], 0, ak, awk1, awk2, numArray[num], nsf, p);
                }
                else
                {
                    num2 = 0;
                    while (num2 < (nsf - 1))
                    {
                        numArray[num][num2 + 1] = numArray[num + 1][num2];
                        num2++;
                    }
                    numArray[num][0] = 0f;
                    num2 = 0;
                    while (num2 < nsf)
                    {
                        numArray[num][num2] += this.e[num][0] * r[num2];
                        num2++;
                    }
                }
            }
            for (num = 0; num < 3; num++)
            {
                numArray2[num] = Ltp.Inner_prod(numArray[num], 0, target, 0, nsf);
            }
            for (num = 0; num < 3; num++)
            {
                for (num2 = 0; num2 <= num; num2++)
                {
                    numArray3[num][num2] = numArray3[num2][num] = Ltp.Inner_prod(numArray[num], 0, numArray[num2], 0, nsf);
                }
            }
            float[] numArray4 = new float[9];
            int index = 0;
            int num8 = 0;
            float num9 = 0f;
            numArray4[0] = numArray2[2];
            numArray4[1] = numArray2[1];
            numArray4[2] = numArray2[0];
            numArray4[3] = numArray3[1][2];
            numArray4[4] = numArray3[0][1];
            numArray4[5] = numArray3[0][2];
            numArray4[6] = numArray3[2][2];
            numArray4[7] = numArray3[1][1];
            numArray4[8] = numArray3[0][0];
            for (num = 0; num < num3; num++)
            {
                float num10 = 0f;
                index = 3 * num;
                float num11 = (0.015625f * this.gain_cdbk[index]) + 0.5f;
                float num12 = (0.015625f * this.gain_cdbk[index + 1]) + 0.5f;
                float num13 = (0.015625f * this.gain_cdbk[index + 2]) + 0.5f;
                num10 += numArray4[0] * num11;
                num10 += numArray4[1] * num12;
                num10 += numArray4[2] * num13;
                num10 -= (numArray4[3] * num11) * num12;
                num10 -= (numArray4[4] * num13) * num12;
                num10 -= (numArray4[5] * num13) * num11;
                num10 -= ((0.5f * numArray4[6]) * num11) * num11;
                num10 -= ((0.5f * numArray4[7]) * num12) * num12;
                num10 -= ((0.5f * numArray4[8]) * num13) * num13;
                if ((num10 > num9) || (num == 0))
                {
                    num9 = num10;
                    num8 = num;
                }
            }
            this.gain[0] = (0.015625f * this.gain_cdbk[num8 * 3]) + 0.5f;
            this.gain[1] = (0.015625f * this.gain_cdbk[(num8 * 3) + 1]) + 0.5f;
            this.gain[2] = (0.015625f * this.gain_cdbk[(num8 * 3) + 2]) + 0.5f;
            cdbk_index[0] = num8;
            for (num = 0; num < nsf; num++)
            {
                exc[es + num] = ((this.gain[0] * this.e[2][num]) + (this.gain[1] * this.e[1][num])) + (this.gain[2] * this.e[0][num]);
            }
            float num4 = 0f;
            float num5 = 0f;
            for (num = 0; num < nsf; num++)
            {
                num4 += target[num] * target[num];
            }
            for (num = 0; num < nsf; num++)
            {
                num5 += (((target[num] - (this.gain[2] * numArray[0][num])) - (this.gain[1] * numArray[1][num])) - (this.gain[0] * numArray[2][num])) * (((target[num] - (this.gain[2] * numArray[0][num])) - (this.gain[1] * numArray[1][num])) - (this.gain[0] * numArray[2][num]));
            }
            return num5;
        }

        public sealed override int Quant(float[] target, float[] sw, int sws, float[] ak, float[] awk1, float[] awk2, float[] exc, int es, int start, int end, float pitch_coef, int p, int nsf, Bits bits, float[] exc2, int e2s, float[] r, int complexity)
        {
            int num;
            int[] numArray = new int[1];
            int pitch = 0;
            int data = 0;
            int num5 = 0;
            float num7 = -1f;
            int n = complexity;
            if (n > 10)
            {
                n = 10;
            }
            int[] numArray3 = new int[n];
            float[] gain = new float[n];
            if ((n == 0) || (end < start))
            {
                bits.Pack(0, this.pitch_bits);
                bits.Pack(0, this.gain_bits);
                for (num = 0; num < nsf; num++)
                {
                    exc[es + num] = 0f;
                }
                return start;
            }
            float[] numArray2 = new float[nsf];
            if (n > ((end - start) + 1))
            {
                n = (end - start) + 1;
            }
            Ltp.Open_loop_nbest_pitch(sw, sws, start, end, nsf, numArray3, gain, n);
            for (num = 0; num < n; num++)
            {
                pitch = numArray3[num];
                int index = 0;
                while (index < nsf)
                {
                    exc[es + index] = 0f;
                    index++;
                }
                float num6 = this.Pitch_gain_search_3tap(target, ak, awk1, awk2, exc, es, pitch, p, nsf, bits, exc2, e2s, r, numArray);
                if ((num6 < num7) || (num7 < 0f))
                {
                    for (index = 0; index < nsf; index++)
                    {
                        numArray2[index] = exc[es + index];
                    }
                    num7 = num6;
                    num5 = pitch;
                    data = numArray[0];
                }
            }
            bits.Pack(num5 - start, this.pitch_bits);
            bits.Pack(data, this.gain_bits);
            for (num = 0; num < nsf; num++)
            {
                exc[es + num] = numArray2[num];
            }
            return pitch;
        }

        public sealed override int Unquant(float[] exc, int es, int start, float pitch_coef, int nsf, float[] gain_val, Bits bits, int count_lost, int subframe_offset, float last_pitch_gain)
        {
            int num;
            int num2 = bits.Unpack(this.pitch_bits) + start;
            int num3 = bits.Unpack(this.gain_bits);
            this.gain[0] = (0.015625f * this.gain_cdbk[num3 * 3]) + 0.5f;
            this.gain[1] = (0.015625f * this.gain_cdbk[(num3 * 3) + 1]) + 0.5f;
            this.gain[2] = (0.015625f * this.gain_cdbk[(num3 * 3) + 2]) + 0.5f;
            if ((count_lost != 0) && (num2 > subframe_offset))
            {
                float num4 = Math.Abs(this.gain[1]);
                float num5 = (count_lost < 4) ? last_pitch_gain : (0.4f * last_pitch_gain);
                if (num5 > 0.95f)
                {
                    num5 = 0.95f;
                }
                if (this.gain[0] > 0f)
                {
                    num4 += this.gain[0];
                }
                else
                {
                    num4 -= 0.5f * this.gain[0];
                }
                if (this.gain[2] > 0f)
                {
                    num4 += this.gain[2];
                }
                else
                {
                    num4 -= 0.5f * this.gain[0];
                }
                if (num4 > num5)
                {
                    float num6 = num5 / num4;
                    for (num = 0; num < 3; num++)
                    {
                        this.gain[num] *= num6;
                    }
                }
            }
            gain_val[0] = this.gain[0];
            gain_val[1] = this.gain[1];
            gain_val[2] = this.gain[2];
            for (num = 0; num < 3; num++)
            {
                int num10 = (num2 + 1) - num;
                int num8 = nsf;
                if (num8 > num10)
                {
                    num8 = num10;
                }
                int num9 = nsf;
                if (num9 > (num10 + num2))
                {
                    num9 = num10 + num2;
                }
                int index = 0;
                while (index < num8)
                {
                    this.e[num][index] = exc[(es + index) - num10];
                    index++;
                }
                index = num8;
                while (index < num9)
                {
                    this.e[num][index] = exc[((es + index) - num10) - num2];
                    index++;
                }
                for (index = num9; index < nsf; index++)
                {
                    this.e[num][index] = 0f;
                }
            }
            for (num = 0; num < nsf; num++)
            {
                exc[es + num] = ((this.gain[0] * this.e[2][num]) + (this.gain[1] * this.e[1][num])) + (this.gain[2] * this.e[0][num]);
            }
            return num2;
        }
    }
}