namespace NSpeex
{
    using System;

    internal class SplitShapeSearch : CodebookSearch
    {
        private float[] e;
        private float[] E;
        private int have_sign;
        private int[] ind;
        private const int MAX_COMPLEXITY = 10;
        private int nb_subvect;
        private int[,] nind;
        private float[][] nt;
        private int[,] oind;
        private float[][] ot;
        private float[] r2;
        private int shape_bits;
        private int[] shape_cb;
        private int shape_cb_size;
        private int[] signs;
        private int subframesize;
        private int subvect_size;
        private float[] t;

        public SplitShapeSearch(int subframesize_0, int subvect_size_1, int nb_subvect_2, int[] shape_cb_3, int shape_bits_4, int have_sign_5)
        {
            this.subframesize = subframesize_0;
            this.subvect_size = subvect_size_1;
            this.nb_subvect = nb_subvect_2;
            this.shape_cb = shape_cb_3;
            this.shape_bits = shape_bits_4;
            this.have_sign = have_sign_5;
            this.ind = new int[nb_subvect_2];
            this.signs = new int[nb_subvect_2];
            this.shape_cb_size = ((int)1) << shape_bits_4;
            this.ot = this.CreateJaggedArray<float>(10, subframesize_0);
            this.nt = this.CreateJaggedArray<float>(10, subframesize_0);
            this.oind = new int[10, nb_subvect_2];
            this.nind = new int[10, nb_subvect_2];
            this.t = new float[subframesize_0];
            this.e = new float[subframesize_0];
            this.r2 = new float[subframesize_0];
            this.E = new float[this.shape_cb_size];
        }

        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;
        }

        public sealed override void Quantify(float[] target, float[] ak, float[] awk1, float[] awk2, int p, int nsf, float[] exc, int es, float[] r, Bits bits, int complexity)
        {
            int num2;
            int num3;
            int n = complexity;
            if (n > 10)
            {
                n = 10;
            }
            float[] codebook = new float[this.shape_cb_size * this.subvect_size];
            int[] nbest = new int[n];
            float[] numArray5 = new float[n];
            float[] numArray2 = new float[n];
            float[] numArray3 = new float[n];
            int[] numArray6 = new int[n];
            int[] numArray7 = new int[n];
            int index = 0;
            while (index < n)
            {
                for (num2 = 0; num2 < this.nb_subvect; num2++)
                {
                    this.nind[index, num2] = this.oind[index, num2] = -1;
                }
                index++;
            }
            num2 = 0;
            while (num2 < n)
            {
                index = 0;
                while (index < nsf)
                {
                    this.ot[num2][index] = target[index];
                    index++;
                }
                num2++;
            }
            for (index = 0; index < this.shape_cb_size; index++)
            {
                int num8 = index * this.subvect_size;
                int num9 = index * this.subvect_size;
                num2 = 0;
                while (num2 < this.subvect_size)
                {
                    codebook[num8 + num2] = 0f;
                    num3 = 0;
                    while (num3 <= num2)
                    {
                        codebook[num8 + num2] += (0.03125f * this.shape_cb[num9 + num3]) * r[num2 - num3];
                        num3++;
                    }
                    num2++;
                }
                this.E[index] = 0f;
                for (num2 = 0; num2 < this.subvect_size; num2++)
                {
                    this.E[index] += codebook[num8 + num2] * codebook[num8 + num2];
                }
            }
            num2 = 0;
            while (num2 < n)
            {
                numArray3[num2] = 0f;
                num2++;
            }
            for (index = 0; index < this.nb_subvect; index++)
            {
                int num4;
                int num5;
                int offset = index * this.subvect_size;
                num2 = 0;
                while (num2 < n)
                {
                    numArray2[num2] = 2.147484E+09f;
                    num2++;
                }
                num2 = 0;
                while (num2 < n)
                {
                    numArray6[num2] = numArray7[num2] = 0;
                    num2++;
                }
                num2 = 0;
                while (num2 < n)
                {
                    float num11 = 0f;
                    num4 = offset;
                    while (num4 < (offset + this.subvect_size))
                    {
                        num11 += this.ot[num2][num4] * this.ot[num2][num4];
                        num4++;
                    }
                    num11 *= 0.5f;
                    if (this.have_sign != 0)
                    {
                        VQ.Nbest_sign(this.ot[num2], offset, codebook, this.subvect_size, this.shape_cb_size, this.E, n, nbest, numArray5);
                    }
                    else
                    {
                        VQ.Nbest(this.ot[num2], offset, codebook, this.subvect_size, this.shape_cb_size, this.E, n, nbest, numArray5);
                    }
                    for (num3 = 0; num3 < n; num3++)
                    {
                        float num12 = (numArray3[num2] + numArray5[num3]) + num11;
                        if (num12 < numArray2[n - 1])
                        {
                            num4 = 0;
                            while (num4 < n)
                            {
                                if (num12 < numArray2[num4])
                                {
                                    num5 = n - 1;
                                    while (num5 > num4)
                                    {
                                        numArray2[num5] = numArray2[num5 - 1];
                                        numArray6[num5] = numArray6[num5 - 1];
                                        numArray7[num5] = numArray7[num5 - 1];
                                        num5--;
                                    }
                                    numArray2[num4] = num12;
                                    numArray6[num5] = nbest[num3];
                                    numArray7[num5] = num2;
                                    break;
                                }
                                num4++;
                            }
                        }
                    }
                    if (index == 0)
                    {
                        break;
                    }
                    num2++;
                }
                num2 = 0;
                while (num2 < n)
                {
                    int num6;
                    num4 = (index + 1) * this.subvect_size;
                    while (num4 < nsf)
                    {
                        this.nt[num2][num4] = this.ot[numArray7[num2]][num4];
                        num4++;
                    }
                    num4 = 0;
                    while (num4 < this.subvect_size)
                    {
                        float num15 = 1f;
                        int num14 = numArray6[num2];
                        if (num14 >= this.shape_cb_size)
                        {
                            num15 = -1f;
                            num14 -= this.shape_cb_size;
                        }
                        num6 = this.subvect_size - num4;
                        float num13 = (num15 * 0.03125f) * this.shape_cb[(num14 * this.subvect_size) + num4];
                        num5 = 0;
                        for (int i = offset + this.subvect_size; num5 < (nsf - (this.subvect_size * (index + 1))); i++)
                        {
                            this.nt[num2][i] -= num13 * r[num5 + num6];
                            num5++;
                        }
                        num4++;
                    }
                    for (num6 = 0; num6 < this.nb_subvect; num6++)
                    {
                        this.nind[num2, num6] = this.oind[numArray7[num2], num6];
                    }
                    this.nind[num2, index] = numArray6[num2];
                    num2++;
                }
                float[][] ot = this.ot;
                this.ot = this.nt;
                this.nt = ot;
                num2 = 0;
                while (num2 < n)
                {
                    for (num4 = 0; num4 < this.nb_subvect; num4++)
                    {
                        this.oind[num2, num4] = this.nind[num2, num4];
                    }
                    num2++;
                }
                num2 = 0;
                while (num2 < n)
                {
                    numArray3[num2] = numArray2[num2];
                    num2++;
                }
            }
            for (index = 0; index < this.nb_subvect; index++)
            {
                this.ind[index] = this.nind[0, index];
                bits.Pack(this.ind[index], this.shape_bits + this.have_sign);
            }
            for (index = 0; index < this.nb_subvect; index++)
            {
                float num18 = 1f;
                int num17 = this.ind[index];
                if (num17 >= this.shape_cb_size)
                {
                    num18 = -1f;
                    num17 -= this.shape_cb_size;
                }
                num2 = 0;
                while (num2 < this.subvect_size)
                {
                    this.e[(this.subvect_size * index) + num2] = (num18 * 0.03125f) * this.shape_cb[(num17 * this.subvect_size) + num2];
                    num2++;
                }
            }
            for (num2 = 0; num2 < nsf; num2++)
            {
                exc[es + num2] += this.e[num2];
            }
            Filters.Syn_percep_zero(this.e, 0, ak, awk1, awk2, this.r2, nsf, p);
            for (num2 = 0; num2 < nsf; num2++)
            {
                target[num2] -= this.r2[num2];
            }
        }

        public sealed override void Unquantify(float[] exc, int es, int nsf, Bits bits)
        {
            int num;
            for (num = 0; num < this.nb_subvect; num++)
            {
                if (this.have_sign != 0)
                {
                    this.signs[num] = bits.Unpack(1);
                }
                else
                {
                    this.signs[num] = 0;
                }
                this.ind[num] = bits.Unpack(this.shape_bits);
            }
            for (num = 0; num < this.nb_subvect; num++)
            {
                float num3 = 1f;
                if (this.signs[num] != 0)
                {
                    num3 = -1f;
                }
                for (int i = 0; i < this.subvect_size; i++)
                {
                    exc[(es + (this.subvect_size * num)) + i] += (num3 * 0.03125f) * this.shape_cb[(this.ind[num] * this.subvect_size) + i];
                }
            }
        }
    }
}