namespace NSpeex
{
    using System;

    internal class NbEncoder : NbCodec, IEncoder
    {
        protected internal float abr_count;
        protected internal float abr_drift;
        protected internal float abr_drift2;
        protected internal int abr_enabled;
        private float[] autocorr;
        private int bounded_pitch;
        private float[] buf2;
        private float[] bw_lpc1;
        private float[] bw_lpc2;
        protected internal int complexity;
        private int dtx_count;
        private float[] exc2Buf;
        private int exc2Idx;
        private float[] innov2;
        private float[] interp_lpc;
        private float[] interp_lsp;
        private float[] lagWindow;
        private float[] lsp;
        private float[] mem_exc;
        private float[] mem_sw;
        private float[] mem_sw_whole;
        public static readonly int[] NB_QUALITY_MAP = new int[] { 1, 8, 2, 3, 3, 4, 4, 5, 5, 6, 7 };
        private float[] old_lsp;
        private int[] pitch;
        private float pre_mem2;
        private float[] rc;
        protected internal float relative_quality;
        protected internal int sampling_rate;
        protected internal int submodeSelect;
        private float[] swBuf;
        private int swIdx;
        protected internal int vad_enabled;
        private NSpeex.Vbr vbr;
        protected internal int vbr_enabled;
        protected internal float vbr_quality;
        private float[] window;

        public virtual int Encode(Bits bits, float[] ins0)
        {
            int num;
            int num5;
            float num6;
            Array.Copy(base.frmBuf, base.frameSize, base.frmBuf, 0, base.bufSize - base.frameSize);
            base.frmBuf[base.bufSize - base.frameSize] = ins0[0] - (base.preemph * base.pre_mem);
            for (num = 1; num < base.frameSize; num++)
            {
                base.frmBuf[(base.bufSize - base.frameSize) + num] = ins0[num] - (base.preemph * ins0[num - 1]);
            }
            base.pre_mem = ins0[base.frameSize - 1];
            Array.Copy(this.exc2Buf, base.frameSize, this.exc2Buf, 0, base.bufSize - base.frameSize);
            Array.Copy(base.excBuf, base.frameSize, base.excBuf, 0, base.bufSize - base.frameSize);
            Array.Copy(this.swBuf, base.frameSize, this.swBuf, 0, base.bufSize - base.frameSize);
            for (num = 0; num < base.windowSize; num++)
            {
                this.buf2[num] = base.frmBuf[num + base.frmIdx] * this.window[num];
            }
            Lpc.Autocorr(this.buf2, this.autocorr, base.lpcSize + 1, base.windowSize);
            this.autocorr[0] += 10f;
            this.autocorr[0] *= base.lpc_floor;
            for (num = 0; num < (base.lpcSize + 1); num++)
            {
                this.autocorr[num] *= this.lagWindow[num];
            }
            Lpc.Wld(base.lpc, this.autocorr, this.rc, base.lpcSize);
            Array.Copy(base.lpc, 0, base.lpc, 1, base.lpcSize);
            base.lpc[0] = 1f;
            int num2 = Lsp.Lpc2lsp(base.lpc, base.lpcSize, this.lsp, 15, 0.2f);
            if (num2 == base.lpcSize)
            {
                for (num = 0; num < base.lpcSize; num++)
                {
                    this.lsp[num] = (float)Math.Acos((double)this.lsp[num]);
                }
            }
            else
            {
                if (this.complexity > 1)
                {
                    num2 = Lsp.Lpc2lsp(base.lpc, base.lpcSize, this.lsp, 11, 0.05f);
                }
                if (num2 == base.lpcSize)
                {
                    for (num = 0; num < base.lpcSize; num++)
                    {
                        this.lsp[num] = (float)Math.Acos((double)this.lsp[num]);
                    }
                }
                else
                {
                    num = 0;
                    while (num < base.lpcSize)
                    {
                        this.lsp[num] = this.old_lsp[num];
                        num++;
                    }
                }
            }
            float num3 = 0f;
            for (num = 0; num < base.lpcSize; num++)
            {
                num3 += (this.old_lsp[num] - this.lsp[num]) * (this.old_lsp[num] - this.lsp[num]);
            }
            if (base.first != 0)
            {
                for (num = 0; num < base.lpcSize; num++)
                {
                    this.interp_lsp[num] = this.lsp[num];
                }
            }
            else
            {
                num = 0;
                while (num < base.lpcSize)
                {
                    this.interp_lsp[num] = (0.375f * this.old_lsp[num]) + (0.625f * this.lsp[num]);
                    num++;
                }
            }
            Lsp.Enforce_margin(this.interp_lsp, base.lpcSize, 0.002f);
            for (num = 0; num < base.lpcSize; num++)
            {
                this.interp_lsp[num] = (float)Math.Cos((double)this.interp_lsp[num]);
            }
            base.m_lsp.Lsp2lpc(this.interp_lsp, this.interp_lpc, base.lpcSize);
            if (((base.submodes[base.submodeID] == null) || (this.vbr_enabled != 0)) || (((this.vad_enabled != 0) || (base.submodes[base.submodeID].ForcedPitchGain != 0)) || (base.submodes[base.submodeID].LbrPitch != -1)))
            {
                int[] pitch = new int[6];
                float[] gain = new float[6];
                Filters.Bw_lpc(base.gamma1, this.interp_lpc, this.bw_lpc1, base.lpcSize);
                Filters.Bw_lpc(base.gamma2, this.interp_lpc, this.bw_lpc2, base.lpcSize);
                Filters.Filter_mem2(base.frmBuf, base.frmIdx, this.bw_lpc1, this.bw_lpc2, this.swBuf, this.swIdx, base.frameSize, base.lpcSize, this.mem_sw_whole, 0);
                Ltp.Open_loop_nbest_pitch(this.swBuf, this.swIdx, base.min_pitch, base.max_pitch, base.frameSize, pitch, gain, 6);
                num5 = pitch[0];
                num6 = gain[0];
                for (num = 1; num < 6; num++)
                {
                    if ((gain[num] > (0.85 * num6)) && (((Math.Abs((double)(pitch[num] - (((double)num5) / 2.0))) <= 1.0) || (Math.Abs((double)(pitch[num] - (((double)num5) / 3.0))) <= 1.0)) || ((Math.Abs((double)(pitch[num] - (((double)num5) / 4.0))) <= 1.0) || (Math.Abs((double)(pitch[num] - (((double)num5) / 5.0))) <= 1.0))))
                    {
                        num5 = pitch[num];
                    }
                }
            }
            else
            {
                num5 = 0;
                num6 = 0f;
            }
            Filters.Fir_mem2(base.frmBuf, base.frmIdx, this.interp_lpc, base.excBuf, base.excIdx, base.frameSize, base.lpcSize, this.mem_exc);
            float num4 = 0f;
            for (num = 0; num < base.frameSize; num++)
            {
                num4 += base.excBuf[base.excIdx + num] * base.excBuf[base.excIdx + num];
            }
            num4 = (float)Math.Sqrt((double)(1f + (num4 / ((float)base.frameSize))));
            if ((this.vbr != null) && ((this.vbr_enabled != 0) || (this.vad_enabled != 0)))
            {
                if (this.abr_enabled != 0)
                {
                    float num7 = 0f;
                    if ((this.abr_drift2 * this.abr_drift) > 0f)
                    {
                        num7 = (-1E-05f * this.abr_drift) / (1f + this.abr_count);
                        if (num7 > 0.05f)
                        {
                            num7 = 0.05f;
                        }
                        if (num7 < -0.05f)
                        {
                            num7 = -0.05f;
                        }
                    }
                    this.vbr_quality += num7;
                    if (this.vbr_quality > 10f)
                    {
                        this.vbr_quality = 10f;
                    }
                    if (this.vbr_quality < 0f)
                    {
                        this.vbr_quality = 0f;
                    }
                }
                this.relative_quality = this.vbr.Analysis(ins0, base.frameSize, num5, num6);
                if (this.vbr_enabled != 0)
                {
                    int num8;
                    int num9 = 0;
                    float num10 = 100f;
                    for (num8 = 8; num8 > 0; num8--)
                    {
                        float num12;
                        int index = (int)Math.Floor((double)this.vbr_quality);
                        if (index == 10)
                        {
                            num12 = NSpeex.Vbr.nb_thresh[num8][index];
                        }
                        else
                        {
                            num12 = ((this.vbr_quality - index) * NSpeex.Vbr.nb_thresh[num8][index + 1]) + (((1 + index) - this.vbr_quality) * NSpeex.Vbr.nb_thresh[num8][index]);
                        }
                        if ((this.relative_quality > num12) && ((this.relative_quality - num12) < num10))
                        {
                            num9 = num8;
                            num10 = this.relative_quality - num12;
                        }
                    }
                    num8 = num9;
                    if (num8 == 0)
                    {
                        if (((this.dtx_count == 0) || (num3 > 0.05)) || ((base.dtx_enabled == 0) || (this.dtx_count > 20)))
                        {
                            num8 = 1;
                            this.dtx_count = 1;
                        }
                        else
                        {
                            num8 = 0;
                            this.dtx_count++;
                        }
                    }
                    else
                    {
                        this.dtx_count = 0;
                    }
                    this.Mode = num8;
                    if (this.abr_enabled != 0)
                    {
                        int bitRate = this.BitRate;
                        this.abr_drift += bitRate - this.abr_enabled;
                        this.abr_drift2 = (0.95f * this.abr_drift2) + (0.05f * (bitRate - this.abr_enabled));
                        float? nullable = 1f;
                        this.abr_count += nullable.Value;
                    }
                }
                else
                {
                    int submodeSelect;
                    if (this.relative_quality < 2f)
                    {
                        if (((this.dtx_count == 0) || (num3 > 0.05)) || ((base.dtx_enabled == 0) || (this.dtx_count > 20)))
                        {
                            this.dtx_count = 1;
                            submodeSelect = 1;
                        }
                        else
                        {
                            submodeSelect = 0;
                            this.dtx_count++;
                        }
                    }
                    else
                    {
                        this.dtx_count = 0;
                        submodeSelect = this.submodeSelect;
                    }
                    base.submodeID = submodeSelect;
                }
            }
            else
            {
                this.relative_quality = -1f;
            }
            bits.Pack(0, 1);
            bits.Pack(base.submodeID, 4);
            if (base.submodes[base.submodeID] == null)
            {
                for (num = 0; num < base.frameSize; num++)
                {
                    float num34;
                    this.swBuf[this.swIdx + num] = num34 = 0f;
                    base.excBuf[base.excIdx + num] = this.exc2Buf[this.exc2Idx + num] = num34;
                }
                for (num = 0; num < base.lpcSize; num++)
                {
                    this.mem_sw[num] = 0f;
                }
                base.first = 1;
                this.bounded_pitch = 1;
                Filters.Iir_mem2(base.excBuf, base.excIdx, base.interp_qlpc, base.frmBuf, base.frmIdx, base.frameSize, base.lpcSize, base.mem_sp);
                ins0[0] = base.frmBuf[base.frmIdx] + (base.preemph * this.pre_mem2);
                for (num = 1; num < base.frameSize; num++)
                {
                    ins0[num] = base.frmBuf[base.frmIdx = num] + (base.preemph * ins0[num - 1]);
                }
                this.pre_mem2 = ins0[base.frameSize - 1];
                return 0;
            }
            if (base.first != 0)
            {
                for (num = 0; num < base.lpcSize; num++)
                {
                    this.old_lsp[num] = this.lsp[num];
                }
            }
            base.submodes[base.submodeID].LsqQuant.Quant(this.lsp, base.qlsp, base.lpcSize, bits);
            if (base.submodes[base.submodeID].LbrPitch != -1)
            {
                bits.Pack(num5 - base.min_pitch, 7);
            }
            if (base.submodes[base.submodeID].ForcedPitchGain != 0)
            {
                int num15 = (int)Math.Floor((double)(0.5 + (15f * num6)));
                if (num15 > 15)
                {
                    num15 = 15;
                }
                if (num15 < 0)
                {
                    num15 = 0;
                }
                bits.Pack(num15, 4);
                num6 = 0.066667f * num15;
            }
            int data = (int)Math.Floor((double)(0.5 + (3.5 * Math.Log((double)num4))));
            if (data < 0)
            {
                data = 0;
            }
            if (data > 0x1f)
            {
                data = 0x1f;
            }
            num4 = (float)Math.Exp(((double)data) / 3.5);
            bits.Pack(data, 5);
            if (base.first != 0)
            {
                for (num = 0; num < base.lpcSize; num++)
                {
                    base.old_qlsp[num] = base.qlsp[num];
                }
            }
            float[] y = new float[base.subframeSize];
            float[] target = new float[base.subframeSize];
            float[] numArray4 = new float[base.subframeSize];
            float[] mem = new float[base.lpcSize];
            float[] numArray5 = new float[base.frameSize];
            num = 0;
            while (num < base.frameSize)
            {
                numArray5[num] = base.frmBuf[base.frmIdx + num];
                num++;
            }
            for (int i = 0; i < base.nbSubframes; i++)
            {
                int num25;
                int num26;
                int num19 = base.subframeSize * i;
                int xs = base.frmIdx + num19;
                int num22 = base.excIdx + num19;
                int ys = this.swIdx + num19;
                int num23 = this.exc2Idx + num19;
                float num18 = ((float)(1.0 + i)) / ((float)base.nbSubframes);
                num = 0;
                while (num < base.lpcSize)
                {
                    this.interp_lsp[num] = ((1f - num18) * this.old_lsp[num]) + (num18 * this.lsp[num]);
                    num++;
                }
                num = 0;
                while (num < base.lpcSize)
                {
                    base.interp_qlsp[num] = ((1f - num18) * base.old_qlsp[num]) + (num18 * base.qlsp[num]);
                    num++;
                }
                Lsp.Enforce_margin(this.interp_lsp, base.lpcSize, 0.002f);
                Lsp.Enforce_margin(base.interp_qlsp, base.lpcSize, 0.002f);
                num = 0;
                while (num < base.lpcSize)
                {
                    this.interp_lsp[num] = (float)Math.Cos((double)this.interp_lsp[num]);
                    num++;
                }
                base.m_lsp.Lsp2lpc(this.interp_lsp, this.interp_lpc, base.lpcSize);
                num = 0;
                while (num < base.lpcSize)
                {
                    base.interp_qlsp[num] = (float)Math.Cos((double)base.interp_qlsp[num]);
                    num++;
                }
                base.m_lsp.Lsp2lpc(base.interp_qlsp, base.interp_qlpc, base.lpcSize);
                num18 = 1f;
                base.pi_gain[i] = 0f;
                num = 0;
                while (num <= base.lpcSize)
                {
                    base.pi_gain[i] += num18 * base.interp_qlpc[num];
                    num18 = -num18;
                    num++;
                }
                Filters.Bw_lpc(base.gamma1, this.interp_lpc, this.bw_lpc1, base.lpcSize);
                if (base.gamma2 >= 0f)
                {
                    Filters.Bw_lpc(base.gamma2, this.interp_lpc, this.bw_lpc2, base.lpcSize);
                }
                else
                {
                    this.bw_lpc2[0] = 1f;
                    this.bw_lpc2[1] = -base.preemph;
                    num = 2;
                    while (num <= base.lpcSize)
                    {
                        this.bw_lpc2[num] = 0f;
                        num++;
                    }
                }
                num = 0;
                while (num < base.subframeSize)
                {
                    base.excBuf[num22 + num] = 0f;
                    num++;
                }
                base.excBuf[num22] = 1f;
                Filters.Syn_percep_zero(base.excBuf, num22, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, numArray4, base.subframeSize, base.lpcSize);
                num = 0;
                while (num < base.subframeSize)
                {
                    base.excBuf[num22 + num] = 0f;
                    num++;
                }
                num = 0;
                while (num < base.subframeSize)
                {
                    this.exc2Buf[num23 + num] = 0f;
                    num++;
                }
                num = 0;
                while (num < base.lpcSize)
                {
                    mem[num] = base.mem_sp[num];
                    num++;
                }
                Filters.Iir_mem2(base.excBuf, num22, base.interp_qlpc, base.excBuf, num22, base.subframeSize, base.lpcSize, mem);
                num = 0;
                while (num < base.lpcSize)
                {
                    mem[num] = this.mem_sw[num];
                    num++;
                }
                Filters.Filter_mem2(base.excBuf, num22, this.bw_lpc1, this.bw_lpc2, y, 0, base.subframeSize, base.lpcSize, mem, 0);
                num = 0;
                while (num < base.lpcSize)
                {
                    mem[num] = this.mem_sw[num];
                    num++;
                }
                Filters.Filter_mem2(base.frmBuf, xs, this.bw_lpc1, this.bw_lpc2, this.swBuf, ys, base.subframeSize, base.lpcSize, mem, 0);
                num = 0;
                while (num < base.subframeSize)
                {
                    target[num] = this.swBuf[ys + num] - y[num];
                    num++;
                }
                num = 0;
                while (num < base.subframeSize)
                {
                    base.excBuf[num22 + num] = this.exc2Buf[num23 + num] = 0f;
                    num++;
                }
                if (base.submodes[base.submodeID].LbrPitch != -1)
                {
                    int lbrPitch = base.submodes[base.submodeID].LbrPitch;
                    if (lbrPitch != 0)
                    {
                        if (num5 < ((base.min_pitch + lbrPitch) - 1))
                        {
                            num5 = (base.min_pitch + lbrPitch) - 1;
                        }
                        if (num5 > (base.max_pitch - lbrPitch))
                        {
                            num5 = base.max_pitch - lbrPitch;
                        }
                        num25 = (num5 - lbrPitch) + 1;
                        num26 = num5 + lbrPitch;
                    }
                    else
                    {
                        num25 = num26 = num5;
                    }
                }
                else
                {
                    num25 = base.min_pitch;
                    num26 = base.max_pitch;
                }
                if ((this.bounded_pitch != 0) && (num26 > num19))
                {
                    num26 = num19;
                }
                this.pitch[i] = base.submodes[base.submodeID].Ltp.Quant(target, this.swBuf, ys, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, base.excBuf, num22, num25, num26, num6, base.lpcSize, base.subframeSize, bits, this.exc2Buf, num23, numArray4, this.complexity);
                Filters.Syn_percep_zero(base.excBuf, num22, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, y, base.subframeSize, base.lpcSize);
                num = 0;
                while (num < base.subframeSize)
                {
                    target[num] -= y[num];
                    num++;
                }
                float num29 = 0f;
                int es = i * base.subframeSize;
                num = 0;
                while (num < base.subframeSize)
                {
                    base.innov[es + num] = 0f;
                    num++;
                }
                Filters.Residue_percep_zero(target, 0, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.buf2, base.subframeSize, base.lpcSize);
                num = 0;
                while (num < base.subframeSize)
                {
                    num29 += this.buf2[num] * this.buf2[num];
                    num++;
                }
                num29 = (float)Math.Sqrt((double)(0.1f + (num29 / ((float)base.subframeSize))));
                num29 /= num4;
                if (base.submodes[base.submodeID].HaveSubframeGain != 0)
                {
                    int num31;
                    num29 = (float)Math.Log((double)num29);
                    if (base.submodes[base.submodeID].HaveSubframeGain == 3)
                    {
                        num31 = VQ.Index(num29, NbCodec.exc_gain_quant_scal3, 8);
                        bits.Pack(num31, 3);
                        num29 = NbCodec.exc_gain_quant_scal3[num31];
                    }
                    else
                    {
                        num31 = VQ.Index(num29, NbCodec.exc_gain_quant_scal1, 2);
                        bits.Pack(num31, 1);
                        num29 = NbCodec.exc_gain_quant_scal1[num31];
                    }
                    num29 = (float)Math.Exp((double)num29);
                }
                else
                {
                    num29 = 1f;
                }
                num29 *= num4;
                float num30 = 1f / num29;
                num = 0;
                while (num < base.subframeSize)
                {
                    target[num] *= num30;
                    num++;
                }
                base.submodes[base.submodeID].Innovation.Quantify(target, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, base.lpcSize, base.subframeSize, base.innov, es, numArray4, bits, this.complexity);
                num = 0;
                while (num < base.subframeSize)
                {
                    base.innov[es + num] *= num29;
                    num++;
                }
                num = 0;
                while (num < base.subframeSize)
                {
                    base.excBuf[num22 + num] += base.innov[es + num];
                    num++;
                }
                if (base.submodes[base.submodeID].DoubleCodebook != 0)
                {
                    float[] exc = new float[base.subframeSize];
                    num = 0;
                    while (num < base.subframeSize)
                    {
                        target[num] *= 2.2f;
                        num++;
                    }
                    base.submodes[base.submodeID].Innovation.Quantify(target, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, base.lpcSize, base.subframeSize, exc, 0, numArray4, bits, this.complexity);
                    num = 0;
                    while (num < base.subframeSize)
                    {
                        exc[num] *= (float)(num29 * 0.45454545454545453);
                        num++;
                    }
                    num = 0;
                    while (num < base.subframeSize)
                    {
                        base.excBuf[num22 + num] += exc[num];
                        num++;
                    }
                }
                num = 0;
                while (num < base.subframeSize)
                {
                    target[num] *= num29;
                    num++;
                }
                num = 0;
                while (num < base.lpcSize)
                {
                    mem[num] = base.mem_sp[num];
                    num++;
                }
                Filters.Iir_mem2(base.excBuf, num22, base.interp_qlpc, base.frmBuf, xs, base.subframeSize, base.lpcSize, base.mem_sp);
                Filters.Filter_mem2(base.frmBuf, xs, this.bw_lpc1, this.bw_lpc2, this.swBuf, ys, base.subframeSize, base.lpcSize, this.mem_sw, 0);
                num = 0;
                while (num < base.subframeSize)
                {
                    this.exc2Buf[num23 + num] = base.excBuf[num22 + num];
                    num++;
                }
            }
            if (base.submodeID >= 1)
            {
                for (num = 0; num < base.lpcSize; num++)
                {
                    this.old_lsp[num] = this.lsp[num];
                }
                for (num = 0; num < base.lpcSize; num++)
                {
                    base.old_qlsp[num] = base.qlsp[num];
                }
            }
            if (base.submodeID == 1)
            {
                if (this.dtx_count != 0)
                {
                    bits.Pack(15, 4);
                }
                else
                {
                    bits.Pack(0, 4);
                }
            }
            base.first = 0;
            float num32 = 0f;
            float num33 = 0f;
            for (num = 0; num < base.frameSize; num++)
            {
                num32 += base.frmBuf[base.frmIdx + num] * base.frmBuf[base.frmIdx + num];
                num33 += (base.frmBuf[base.frmIdx + num] - numArray5[num]) * (base.frmBuf[base.frmIdx + num] - numArray5[num]);
            }
            Math.Log((double)((num32 + 1f) / (num33 + 1f)));
            ins0[0] = base.frmBuf[base.frmIdx] + (base.preemph * this.pre_mem2);
            for (num = 1; num < base.frameSize; num++)
            {
                ins0[num] = base.frmBuf[base.frmIdx + num] + (base.preemph * ins0[num - 1]);
            }
            this.pre_mem2 = ins0[base.frameSize - 1];
            if ((base.submodes[base.submodeID].Innovation is NoiseSearch) || (base.submodeID == 0))
            {
                this.bounded_pitch = 1;
            }
            else
            {
                this.bounded_pitch = 0;
            }
            return 1;
        }

        protected override void Init(int frameSize, int subframeSize, int lpcSize, int bufSize)
        {
            base.Init(frameSize, subframeSize, lpcSize, bufSize);
            this.complexity = 3;
            this.vbr_enabled = 0;
            this.vad_enabled = 0;
            this.abr_enabled = 0;
            this.vbr_quality = 8f;
            this.submodeSelect = 5;
            this.pre_mem2 = 0f;
            this.bounded_pitch = 1;
            this.exc2Buf = new float[bufSize];
            this.exc2Idx = bufSize - base.windowSize;
            this.swBuf = new float[bufSize];
            this.swIdx = bufSize - base.windowSize;
            this.window = Misc.Window(base.windowSize, subframeSize);
            this.lagWindow = Misc.LagWindow(lpcSize, base.lag_factor);
            this.autocorr = new float[lpcSize + 1];
            this.buf2 = new float[base.windowSize];
            this.interp_lpc = new float[lpcSize + 1];
            base.interp_qlpc = new float[lpcSize + 1];
            this.bw_lpc1 = new float[lpcSize + 1];
            this.bw_lpc2 = new float[lpcSize + 1];
            this.lsp = new float[lpcSize];
            base.qlsp = new float[lpcSize];
            this.old_lsp = new float[lpcSize];
            base.old_qlsp = new float[lpcSize];
            this.interp_lsp = new float[lpcSize];
            base.interp_qlsp = new float[lpcSize];
            this.rc = new float[lpcSize];
            base.mem_sp = new float[lpcSize];
            this.mem_sw = new float[lpcSize];
            this.mem_sw_whole = new float[lpcSize];
            this.mem_exc = new float[lpcSize];
            this.vbr = new NSpeex.Vbr();
            this.dtx_count = 0;
            this.abr_count = 0f;
            this.sampling_rate = 0x1f40;
            base.awk1 = new float[lpcSize + 1];
            base.awk2 = new float[lpcSize + 1];
            base.awk3 = new float[lpcSize + 1];
            this.innov2 = new float[40];
            this.pitch = new int[base.nbSubframes];
        }

        public virtual int Abr {
            get { return this.abr_enabled; }
            set {
                this.abr_enabled = (value != 0) ? 1 : 0;
                this.vbr_enabled = 1;
                int num = 10;
                int num3 = value;
                while (num >= 0)
                {
                    this.Quality = num;
                    if (this.BitRate <= num3)
                    {
                        break;
                    }
                    num--;
                }
                float num4 = num;
                if (num4 < 0f)
                {
                    num4 = 0f;
                }
                this.VbrQuality = num4;
                this.abr_count = 0f;
                this.abr_drift = 0f;
                this.abr_drift2 = 0f;
            }
        }

        public virtual int BitRate {
            get {
                if (base.submodes[base.submodeID] != null)
                {
                    return ((this.sampling_rate * base.submodes[base.submodeID].BitsPerFrame) / base.frameSize);
                }
                return ((this.sampling_rate * 5) / base.frameSize);
            }
            set {
                for (int i = 10; i >= 0; i--)
                {
                    this.Quality = i;
                    if (this.BitRate <= value)
                    {
                        return;
                    }
                }
            }
        }

        public virtual int Complexity {
            get { return this.complexity; }
            set {
                if (value < 0)
                {
                    value = 0;
                }
                if (value > 10)
                {
                    value = 10;
                }
                this.complexity = value;
            }
        }

        public virtual bool Dtx {
            get { return (base.dtx_enabled == 1); }
            set {
                base.dtx_enabled = value ? 1 : 0;
            }
        }

        public virtual int EncodedFrameSize { get { return NbCodec.NB_FRAME_SIZE[base.submodeID]; } }
        public virtual int LookAhead { get { return (base.windowSize - base.frameSize); } }

        public virtual int Mode {
            get { return base.submodeID; }
            set {
                if (value < 0)
                {
                    value = 0;
                }
                base.submodeID = this.submodeSelect = value;
            }
        }

        public virtual int Quality {
            set {
                if (value < 0)
                {
                    value = 0;
                }
                if (value > 10)
                {
                    value = 10;
                }
                base.submodeID = this.submodeSelect = NB_QUALITY_MAP[value];
            }
        }

        public virtual float RelativeQuality { get { return this.relative_quality; } }

        public virtual int SamplingRate {
            get { return this.sampling_rate; }
            set {
                this.sampling_rate = value;
            }
        }

        public virtual bool Vad {
            get { return (this.vad_enabled != 0); }
            set {
                this.vad_enabled = value ? 1 : 0;
            }
        }

        public virtual bool Vbr {
            get { return (this.vbr_enabled != 0); }
            set {
                this.vbr_enabled = value ? 1 : 0;
            }
        }

        public virtual float VbrQuality {
            get { return this.vbr_quality; }
            set {
                if (value < 0f)
                {
                    value = 0f;
                }
                if (value > 10f)
                {
                    value = 10f;
                }
                this.vbr_quality = value;
            }
        }
    }
}