Exemplo n.º 1
0
        /// <summary>
        /// Encode the given input signal.
        /// </summary>
        /// <param name="bits">Speex bits buffer.</param>
        /// <param name="vin">the raw mono audio frame to encode</param>
        /// <returns>1 if successful.</returns>
        public int Encode(Bits bits, float[] vin)
        {
            int i;

            float[] mem, innov, syn_resp;
            float[] low_pi_gain, low_exc, low_innov;
            int     dtx;

            /* Compute the two sub-bands by filtering with h0 and h1*/
            Filters.qmf_decomp(vin, h0, x0d, x1d, fullFrameSize, QMF_ORDER, h0_mem);
            /* Encode the narrowband part*/
            lowenc.Encode(bits, x0d);

            /* High-band buffering / sync with low band */
            for (i = 0; i < windowSize - frameSize; i++)
            {
                high[i] = high[frameSize + i];
            }
            for (i = 0; i < frameSize; i++)
            {
                high[windowSize - frameSize + i] = x1d[i];
            }

            Array.Copy(excBuf, frameSize, excBuf, 0, bufSize - frameSize);

            low_pi_gain = lowenc.PitchGain;
            low_exc     = lowenc.Excitation;
            low_innov   = lowenc.Innovation;


            int low_mode = lowenc.Mode;

            if (low_mode == 0)
            {
                dtx = 1;
            }
            else
            {
                dtx = 0;
            }

            /* Start encoding the high-band */
            for (i = 0; i < windowSize; i++)
            {
                buf[i] = high[i] * window[i];
            }

            /* Compute auto-correlation */
            Lpc.autocorr(buf, autocorr, lpcSize + 1, windowSize);

            autocorr[0] += 1;         /* prevents NANs */
            autocorr[0] *= lpc_floor; /* Noise floor in auto-correlation domain */
            /* Lag windowing: equivalent to filtering in the power-spectrum domain */
            for (i = 0; i < lpcSize + 1; i++)
            {
                autocorr[i] *= lagWindow[i];
            }

            /* Levinson-Durbin */
            Lpc.wld(lpc, autocorr, rc, lpcSize); // tmperr
            Array.Copy(lpc, 0, lpc, 1, lpcSize);
            lpc[0] = 1;
            /* LPC to LSPs (x-domain) transform */
            int roots = Lsp.lpc2lsp(lpc, lpcSize, lsp, 15, 0.2f);

            if (roots != lpcSize)
            {
                roots = Lsp.lpc2lsp(lpc, lpcSize, lsp, 11, 0.02f);
                if (roots != lpcSize)
                {
                    /*If we can't find all LSP's, do some damage control and use a flat filter*/
                    for (i = 0; i < lpcSize; i++)
                    {
                        lsp[i] = (float)Math.Cos(Math.PI * ((float)(i + 1)) / (lpcSize + 1));
                    }
                }
            }
            /* x-domain to angle domain*/
            for (i = 0; i < lpcSize; i++)
            {
                lsp[i] = (float)Math.Acos(lsp[i]);
            }

            float lsp_dist = 0;

            for (i = 0; i < lpcSize; i++)
            {
                lsp_dist += (old_lsp[i] - lsp[i]) * (old_lsp[i] - lsp[i]);
            }
            /*VBR stuff*/
            if ((vbr_enabled != 0 || vad_enabled != 0) && dtx == 0)
            {
                float e_low = 0, e_high = 0;
                float ratio;
                if (abr_enabled != 0)
                {
                    float qual_change = 0;
                    if (abr_drift2 * abr_drift > 0)
                    {
                        /* Only adapt if long-term and short-term drift are the same sign */
                        qual_change = -.00001f * abr_drift / (1 + abr_count);
                        if (qual_change > .1f)
                        {
                            qual_change = .1f;
                        }
                        if (qual_change < -.1f)
                        {
                            qual_change = -.1f;
                        }
                    }
                    vbr_quality += qual_change;
                    if (vbr_quality > 10)
                    {
                        vbr_quality = 10;
                    }
                    if (vbr_quality < 0)
                    {
                        vbr_quality = 0;
                    }
                }
                for (i = 0; i < frameSize; i++)
                {
                    e_low  += x0d[i] * x0d[i];
                    e_high += high[i] * high[i];
                }
                ratio            = (float)Math.Log((1 + e_high) / (1 + e_low));
                relative_quality = lowenc.RelativeQuality;

                if (ratio < -4)
                {
                    ratio = -4;
                }
                if (ratio > 2)
                {
                    ratio = 2;
                }
                /*if (ratio>-2)*/
                if (vbr_enabled != 0)
                {
                    int modeid;
                    modeid            = nb_modes - 1;
                    relative_quality += 1.0f * (ratio + 2f);
                    if (relative_quality < -1)
                    {
                        relative_quality = -1;
                    }
                    while (modeid != 0)
                    {
                        int   v1;
                        float thresh;
                        v1 = (int)Math.Floor(vbr_quality);
                        if (v1 == 10)
                        {
                            thresh = NSpeex.Vbr.hb_thresh[modeid][v1];
                        }
                        else
                        {
                            thresh = (vbr_quality - v1) * NSpeex.Vbr.hb_thresh[modeid][v1 + 1] + (1 + v1 - vbr_quality) * NSpeex.Vbr.hb_thresh[modeid][v1];
                        }
                        if (relative_quality >= thresh)
                        {
                            break;
                        }
                        modeid--;
                    }
                    Mode = modeid;
                    if (abr_enabled != 0)
                    {
                        int bitrate = BitRate;
                        abr_drift += (bitrate - abr_enabled);
                        abr_drift2 = .95f * abr_drift2 + .05f * (bitrate - abr_enabled);
                        abr_count += 1.0f;
                    }
                }
                else
                {
                    /* VAD only */
                    int modeid;
                    if (relative_quality < 2.0)
                    {
                        modeid = 1;
                    }
                    else
                    {
                        modeid = submodeSelect;
                    }
                    /*speex_encoder_ctl(state, SPEEX_SET_MODE, &mode);*/
                    submodeID = modeid;
                }
            }
            bits.Pack(1, 1);
            if (dtx != 0)
            {
                bits.Pack(0, SB_SUBMODE_BITS);
            }
            else
            {
                bits.Pack(submodeID, SB_SUBMODE_BITS);
            }
            /* If null mode (no transmission), just set a couple things to zero*/
            if (dtx != 0 || submodes[submodeID] == null)
            {
                for (i = 0; i < frameSize; i++)
                {
                    excBuf[excIdx + i] = swBuf[i] = VERY_SMALL;
                }

                for (i = 0; i < lpcSize; i++)
                {
                    mem_sw[i] = 0;
                }
                first = 1;

                /* Final signal synthesis from excitation */
                Filters.iir_mem2(excBuf, excIdx, interp_qlpc, high, 0, subframeSize, lpcSize, mem_sp);

                /* Reconstruct the original */
                filters.fir_mem_up(x0d, h0, y0, fullFrameSize, QMF_ORDER, g0_mem);
                filters.fir_mem_up(high, h1, y1, fullFrameSize, QMF_ORDER, g1_mem);

                for (i = 0; i < fullFrameSize; i++)
                {
                    vin[i] = 2 * (y0[i] - y1[i]);
                }

                if (dtx != 0)
                {
                    return(0);
                }
                else
                {
                    return(1);
                }
            }
            /* LSP quantization */
            submodes[submodeID].lsqQuant.quant(lsp, qlsp, lpcSize, bits);

            if (first != 0)
            {
                for (i = 0; i < lpcSize; i++)
                {
                    old_lsp[i] = lsp[i];
                }
                for (i = 0; i < lpcSize; i++)
                {
                    old_qlsp[i] = qlsp[i];
                }
            }
            mem      = new float[lpcSize];
            syn_resp = new float[subframeSize];
            innov    = new float[subframeSize];
            for (int sub = 0; sub < nbSubframes; sub++)
            {
                float tmp, filter_ratio;
                int   exc, sp, sw, resp;
                int   offset;
                float rl, rh, eh = 0, el = 0;
                int   fold;

                offset = subframeSize * sub;
                sp     = offset;
                exc    = excIdx + offset;
                resp   = offset;
                sw     = offset;
                /* LSP interpolation (quantized and unquantized) */
                tmp = (1.0f + sub) / nbSubframes;
                for (i = 0; i < lpcSize; i++)
                {
                    interp_lsp[i] = (1 - tmp) * old_lsp[i] + tmp * lsp[i];
                }
                for (i = 0; i < lpcSize; i++)
                {
                    interp_qlsp[i] = (1 - tmp) * old_qlsp[i] + tmp * qlsp[i];
                }

                Lsp.enforce_margin(interp_lsp, lpcSize, .05f);
                Lsp.enforce_margin(interp_qlsp, lpcSize, .05f);
                /* Compute interpolated LPCs (quantized and unquantized) */
                for (i = 0; i < lpcSize; i++)
                {
                    interp_lsp[i] = (float)Math.Cos(interp_lsp[i]);
                }
                for (i = 0; i < lpcSize; i++)
                {
                    interp_qlsp[i] = (float)Math.Cos(interp_qlsp[i]);
                }

                m_lsp.lsp2lpc(interp_lsp, interp_lpc, lpcSize);
                m_lsp.lsp2lpc(interp_qlsp, interp_qlpc, lpcSize);

                Filters.bw_lpc(gamma1, interp_lpc, bw_lpc1, lpcSize);
                Filters.bw_lpc(gamma2, interp_lpc, bw_lpc2, lpcSize);

                /* Compute mid-band (4000 Hz for wideband) response of low-band and high-band
                 * filters */
                rl           = rh = 0;
                tmp          = 1;
                pi_gain[sub] = 0;
                for (i = 0; i <= lpcSize; i++)
                {
                    rh           += tmp * interp_qlpc[i];
                    tmp           = -tmp;
                    pi_gain[sub] += interp_qlpc[i];
                }
                rl = low_pi_gain[sub];
                rl = 1 / (Math.Abs(rl) + .01f);
                rh = 1 / (Math.Abs(rh) + .01f);
                /* Compute ratio, will help predict the gain */
                filter_ratio = Math.Abs(.01f + rh) / (.01f + Math.Abs(rl));

                fold = filter_ratio < 5 ? 1 : 0;
                /*printf ("filter_ratio %f\n", filter_ratio);*/
                fold = 0;
                /* Compute "real excitation" */
                Filters.fir_mem2(high, sp, interp_qlpc, excBuf, exc, subframeSize, lpcSize, mem_sp2);
                /* Compute energy of low-band and high-band excitation */
                for (i = 0; i < subframeSize; i++)
                {
                    eh += excBuf[exc + i] * excBuf[exc + i];
                }
                if (submodes[submodeID].innovation == null)
                {
                    float g;
                    /*speex_bits_pack(bits, 1, 1);*/
                    for (i = 0; i < subframeSize; i++)
                    {
                        el += low_innov[offset + i] * low_innov[offset + i];
                    }

                    /* Gain to use if we want to use the low-band excitation for high-band */
                    g = eh / (.01f + el);
                    g = (float)Math.Sqrt(g);

                    g *= filter_ratio;
                    int quant = (int)Math.Floor(.5 + 10 + 8.0 * Math.Log((g + .0001)));
                    /*speex_warning_int("tata", quant);*/
                    if (quant < 0)
                    {
                        quant = 0;
                    }
                    if (quant > 31)
                    {
                        quant = 31;
                    }
                    bits.Pack(quant, 5);
                    g  = (float)(.1 * Math.Exp(quant / 9.4));
                    g /= filter_ratio;
                }
                else
                {
                    float gc, scale, scale_1;

                    for (i = 0; i < subframeSize; i++)
                    {
                        el += low_exc[offset + i] * low_exc[offset + i];
                    }
                    gc = (float)(Math.Sqrt(1 + eh) * filter_ratio / Math.Sqrt((1 + el) * subframeSize));
                    {
                        int qgc = (int)Math.Floor(.5 + 3.7 * (Math.Log(gc) + 2));
                        if (qgc < 0)
                        {
                            qgc = 0;
                        }
                        if (qgc > 15)
                        {
                            qgc = 15;
                        }
                        bits.Pack(qgc, 4);
                        gc = (float)Math.Exp((1 / 3.7) * qgc - 2);
                    }
                    scale   = gc * (float)Math.Sqrt(1 + el) / filter_ratio;
                    scale_1 = 1 / scale;

                    for (i = 0; i < subframeSize; i++)
                    {
                        excBuf[exc + i] = 0;
                    }
                    excBuf[exc] = 1;
                    Filters.syn_percep_zero(excBuf, exc, interp_qlpc, bw_lpc1, bw_lpc2, syn_resp, subframeSize, lpcSize);

                    /* Reset excitation */
                    for (i = 0; i < subframeSize; i++)
                    {
                        excBuf[exc + i] = 0;
                    }

                    /* Compute zero response (ringing) of A(z/g1) / ( A(z/g2) * Aq(z) ) */
                    for (i = 0; i < lpcSize; i++)
                    {
                        mem[i] = mem_sp[i];
                    }
                    Filters.iir_mem2(excBuf, exc, interp_qlpc, excBuf, exc, subframeSize, lpcSize, mem);
                    for (i = 0; i < lpcSize; i++)
                    {
                        mem[i] = mem_sw[i];
                    }
                    Filters.filter_mem2(excBuf, exc, bw_lpc1, bw_lpc2, res, resp, subframeSize, lpcSize, mem, 0);

                    /* Compute weighted signal */
                    for (i = 0; i < lpcSize; i++)
                    {
                        mem[i] = mem_sw[i];
                    }
                    Filters.filter_mem2(high, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize, lpcSize, mem, 0);

                    /* Compute target signal */
                    for (i = 0; i < subframeSize; i++)
                    {
                        target[i] = swBuf[sw + i] - res[resp + i];
                    }

                    for (i = 0; i < subframeSize; i++)
                    {
                        excBuf[exc + i] = 0;
                    }

                    for (i = 0; i < subframeSize; i++)
                    {
                        target[i] *= scale_1;
                    }

                    /* Reset excitation */
                    for (i = 0; i < subframeSize; i++)
                    {
                        innov[i] = 0;
                    }
                    /*print_vec(target, st->subframeSize, "\ntarget");*/
                    submodes[submodeID].innovation.Quant(target, interp_qlpc, bw_lpc1, bw_lpc2,
                                                         lpcSize, subframeSize, innov, 0, syn_resp,
                                                         bits, (complexity + 1) >> 1);
                    /*print_vec(target, st->subframeSize, "after");*/

                    for (i = 0; i < subframeSize; i++)
                    {
                        excBuf[exc + i] += innov[i] * scale;
                    }
                    if (submodes[submodeID].double_codebook != 0)
                    {
                        float[] innov2 = new float[subframeSize];
                        for (i = 0; i < subframeSize; i++)
                        {
                            innov2[i] = 0;
                        }
                        for (i = 0; i < subframeSize; i++)
                        {
                            target[i] *= 2.5f;
                        }
                        submodes[submodeID].innovation.Quant(target, interp_qlpc, bw_lpc1, bw_lpc2,
                                                             lpcSize, subframeSize, innov2, 0, syn_resp,
                                                             bits, (complexity + 1) >> 1);
                        for (i = 0; i < subframeSize; i++)
                        {
                            innov2[i] *= scale * (1f / 2.5f);
                        }
                        for (i = 0; i < subframeSize; i++)
                        {
                            excBuf[exc + i] += innov2[i];
                        }
                    }
                }
                /*Keep the previous memory*/
                for (i = 0; i < lpcSize; i++)
                {
                    mem[i] = mem_sp[i];
                }
                /* Final signal synthesis from excitation */
                Filters.iir_mem2(excBuf, exc, interp_qlpc, high, sp, subframeSize, lpcSize, mem_sp);

                /* Compute weighted signal again, from synthesized speech (not sure it's the right thing) */
                Filters.filter_mem2(high, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize, lpcSize, mem_sw, 0);
            }
            //#ifndef RELEASE
            /* Reconstruct the original */
            filters.fir_mem_up(x0d, h0, y0, fullFrameSize, QMF_ORDER, g0_mem);
            filters.fir_mem_up(high, h1, y1, fullFrameSize, QMF_ORDER, g1_mem);

            for (i = 0; i < fullFrameSize; i++)
            {
                vin[i] = 2 * (y0[i] - y1[i]);
            }
            //#endif
            for (i = 0; i < lpcSize; i++)
            {
                old_lsp[i] = lsp[i];
            }
            for (i = 0; i < lpcSize; i++)
            {
                old_qlsp[i] = qlsp[i];
            }
            first = 0;
            return(1);
        }
Exemplo n.º 2
0
        public virtual int Encode(Bits bits, float[] ins0)
        {
            Array.Copy(this.frmBuf, this.frameSize, this.frmBuf, 0, this.bufSize - this.frameSize);
            this.frmBuf[this.bufSize - this.frameSize] = ins0[0] - this.preemph * this.pre_mem;
            for (int i = 1; i < this.frameSize; i++)
            {
                this.frmBuf[this.bufSize - this.frameSize + i] = ins0[i] - this.preemph * ins0[i - 1];
            }
            this.pre_mem = ins0[this.frameSize - 1];
            Array.Copy(this.exc2Buf, this.frameSize, this.exc2Buf, 0, this.bufSize - this.frameSize);
            Array.Copy(this.excBuf, this.frameSize, this.excBuf, 0, this.bufSize - this.frameSize);
            Array.Copy(this.swBuf, this.frameSize, this.swBuf, 0, this.bufSize - this.frameSize);
            for (int i = 0; i < this.windowSize; i++)
            {
                this.buf2[i] = this.frmBuf[i + this.frmIdx] * this.window[i];
            }
            Lpc.Autocorr(this.buf2, this.autocorr, this.lpcSize + 1, this.windowSize);
            this.autocorr[0] += 10f;
            this.autocorr[0] *= this.lpc_floor;
            for (int i = 0; i < this.lpcSize + 1; i++)
            {
                this.autocorr[i] *= this.lagWindow[i];
            }
            Lpc.Wld(this.lpc, this.autocorr, this.rc, this.lpcSize);
            Array.Copy(this.lpc, 0, this.lpc, 1, this.lpcSize);
            this.lpc[0] = 1f;
            int num = Lsp.Lpc2lsp(this.lpc, this.lpcSize, this.lsp, 15, 0.2f);

            if (num == this.lpcSize)
            {
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.lsp[i] = (float)Math.Acos((double)this.lsp[i]);
                }
            }
            else
            {
                if (this.complexity > 1)
                {
                    num = Lsp.Lpc2lsp(this.lpc, this.lpcSize, this.lsp, 11, 0.05f);
                }
                if (num == this.lpcSize)
                {
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.lsp[i] = (float)Math.Acos((double)this.lsp[i]);
                    }
                }
                else
                {
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.lsp[i] = this.old_lsp[i];
                    }
                }
            }
            float num2 = 0f;

            for (int i = 0; i < this.lpcSize; i++)
            {
                num2 += (this.old_lsp[i] - this.lsp[i]) * (this.old_lsp[i] - this.lsp[i]);
            }
            if (this.first != 0)
            {
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.interp_lsp[i] = this.lsp[i];
                }
            }
            else
            {
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.interp_lsp[i] = 0.375f * this.old_lsp[i] + 0.625f * this.lsp[i];
                }
            }
            Lsp.Enforce_margin(this.interp_lsp, this.lpcSize, 0.002f);
            for (int i = 0; i < this.lpcSize; i++)
            {
                this.interp_lsp[i] = (float)Math.Cos((double)this.interp_lsp[i]);
            }
            this.m_lsp.Lsp2lpc(this.interp_lsp, this.interp_lpc, this.lpcSize);
            int   num3;
            float num4;

            if (this.submodes[this.submodeID] == null || this.vbr_enabled != 0 || this.vad_enabled != 0 || this.submodes[this.submodeID].ForcedPitchGain != 0 || this.submodes[this.submodeID].LbrPitch != -1)
            {
                int[]   array  = new int[6];
                float[] array2 = new float[6];
                Filters.Bw_lpc(this.gamma1, this.interp_lpc, this.bw_lpc1, this.lpcSize);
                Filters.Bw_lpc(this.gamma2, this.interp_lpc, this.bw_lpc2, this.lpcSize);
                Filters.Filter_mem2(this.frmBuf, this.frmIdx, this.bw_lpc1, this.bw_lpc2, this.swBuf, this.swIdx, this.frameSize, this.lpcSize, this.mem_sw_whole, 0);
                Ltp.Open_loop_nbest_pitch(this.swBuf, this.swIdx, this.min_pitch, this.max_pitch, this.frameSize, array, array2, 6);
                num3 = array[0];
                num4 = array2[0];
                for (int i = 1; i < 6; i++)
                {
                    if ((double)array2[i] > 0.85 * (double)num4 && (Math.Abs((double)array[i] - (double)num3 / 2.0) <= 1.0 || Math.Abs((double)array[i] - (double)num3 / 3.0) <= 1.0 || Math.Abs((double)array[i] - (double)num3 / 4.0) <= 1.0 || Math.Abs((double)array[i] - (double)num3 / 5.0) <= 1.0))
                    {
                        num3 = array[i];
                    }
                }
            }
            else
            {
                num3 = 0;
                num4 = 0f;
            }
            Filters.Fir_mem2(this.frmBuf, this.frmIdx, this.interp_lpc, this.excBuf, this.excIdx, this.frameSize, this.lpcSize, this.mem_exc);
            float num5 = 0f;

            for (int i = 0; i < this.frameSize; i++)
            {
                num5 += this.excBuf[this.excIdx + i] * this.excBuf[this.excIdx + i];
            }
            num5 = (float)Math.Sqrt((double)(1f + num5 / (float)this.frameSize));
            if (this.vbr != null && (this.vbr_enabled != 0 || this.vad_enabled != 0))
            {
                if (this.abr_enabled != 0)
                {
                    float num6 = 0f;
                    if (this.abr_drift2 * this.abr_drift > 0f)
                    {
                        num6 = -1E-05f * this.abr_drift / (1f + this.abr_count);
                        if (num6 > 0.05f)
                        {
                            num6 = 0.05f;
                        }
                        if (num6 < -0.05f)
                        {
                            num6 = -0.05f;
                        }
                    }
                    this.vbr_quality += num6;
                    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, this.frameSize, num3, num4);
                if (this.vbr_enabled != 0)
                {
                    int   num7 = 0;
                    float num8 = 100f;
                    int   j;
                    for (j = 8; j > 0; j--)
                    {
                        int   num9 = (int)Math.Floor((double)this.vbr_quality);
                        float num10;
                        if (num9 == 10)
                        {
                            num10 = NSpeex.Vbr.nb_thresh[j][num9];
                        }
                        else
                        {
                            num10 = (this.vbr_quality - (float)num9) * NSpeex.Vbr.nb_thresh[j][num9 + 1] + ((float)(1 + num9) - this.vbr_quality) * NSpeex.Vbr.nb_thresh[j][num9];
                        }
                        if (this.relative_quality > num10 && this.relative_quality - num10 < num8)
                        {
                            num7 = j;
                            num8 = this.relative_quality - num10;
                        }
                    }
                    j = num7;
                    if (j == 0)
                    {
                        if (this.dtx_count == 0 || (double)num2 > 0.05 || this.dtx_enabled == 0 || this.dtx_count > 20)
                        {
                            j = 1;
                            this.dtx_count = 1;
                        }
                        else
                        {
                            j = 0;
                            this.dtx_count++;
                        }
                    }
                    else
                    {
                        this.dtx_count = 0;
                    }
                    this.Mode = j;
                    if (this.abr_enabled != 0)
                    {
                        int bitRate = this.BitRate;
                        this.abr_drift += (float)(bitRate - this.abr_enabled);
                        this.abr_drift2 = 0.95f * this.abr_drift2 + 0.05f * (float)(bitRate - this.abr_enabled);
                        this.abr_count += new float?((float)1.0).Value;
                    }
                }
                else
                {
                    int submodeID;
                    if (this.relative_quality < 2f)
                    {
                        if (this.dtx_count == 0 || (double)num2 > 0.05 || this.dtx_enabled == 0 || this.dtx_count > 20)
                        {
                            this.dtx_count = 1;
                            submodeID      = 1;
                        }
                        else
                        {
                            submodeID = 0;
                            this.dtx_count++;
                        }
                    }
                    else
                    {
                        this.dtx_count = 0;
                        submodeID      = this.submodeSelect;
                    }
                    this.submodeID = submodeID;
                }
            }
            else
            {
                this.relative_quality = -1f;
            }
            bits.Pack(0, 1);
            bits.Pack(this.submodeID, 4);
            if (this.submodes[this.submodeID] == null)
            {
                for (int i = 0; i < this.frameSize; i++)
                {
                    this.excBuf[this.excIdx + i] = (this.exc2Buf[this.exc2Idx + i] = (this.swBuf[this.swIdx + i] = 0f));
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.mem_sw[i] = 0f;
                }
                this.first         = 1;
                this.bounded_pitch = 1;
                Filters.Iir_mem2(this.excBuf, this.excIdx, this.interp_qlpc, this.frmBuf, this.frmIdx, this.frameSize, this.lpcSize, this.mem_sp);
                ins0[0] = this.frmBuf[this.frmIdx] + this.preemph * this.pre_mem2;
                for (int i = 1; i < this.frameSize; i++)
                {
                    ins0[i] = this.frmBuf[this.frmIdx = i] + this.preemph * ins0[i - 1];
                }
                this.pre_mem2 = ins0[this.frameSize - 1];
                return(0);
            }
            if (this.first != 0)
            {
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.old_lsp[i] = this.lsp[i];
                }
            }
            this.submodes[this.submodeID].LsqQuant.Quant(this.lsp, this.qlsp, this.lpcSize, bits);
            if (this.submodes[this.submodeID].LbrPitch != -1)
            {
                bits.Pack(num3 - this.min_pitch, 7);
            }
            if (this.submodes[this.submodeID].ForcedPitchGain != 0)
            {
                int num11 = (int)Math.Floor(0.5 + (double)(15f * num4));
                if (num11 > 15)
                {
                    num11 = 15;
                }
                if (num11 < 0)
                {
                    num11 = 0;
                }
                bits.Pack(num11, 4);
                num4 = 0.066667f * (float)num11;
            }
            int num12 = (int)Math.Floor(0.5 + 3.5 * Math.Log((double)num5));

            if (num12 < 0)
            {
                num12 = 0;
            }
            if (num12 > 31)
            {
                num12 = 31;
            }
            num5 = (float)Math.Exp((double)num12 / 3.5);
            bits.Pack(num12, 5);
            if (this.first != 0)
            {
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.old_qlsp[i] = this.qlsp[i];
                }
            }
            float[] array3 = new float[this.subframeSize];
            float[] array4 = new float[this.subframeSize];
            float[] array5 = new float[this.subframeSize];
            float[] array6 = new float[this.lpcSize];
            float[] array7 = new float[this.frameSize];
            for (int i = 0; i < this.frameSize; i++)
            {
                array7[i] = this.frmBuf[this.frmIdx + i];
            }
            for (int k = 0; k < this.nbSubframes; k++)
            {
                int   num13 = this.subframeSize * k;
                int   num14 = this.frmIdx + num13;
                int   num15 = this.excIdx + num13;
                int   num16 = this.swIdx + num13;
                int   num17 = this.exc2Idx + num13;
                float num18 = (float)(1.0 + (double)k) / (float)this.nbSubframes;
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.interp_lsp[i] = (1f - num18) * this.old_lsp[i] + num18 * this.lsp[i];
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.interp_qlsp[i] = (1f - num18) * this.old_qlsp[i] + num18 * this.qlsp[i];
                }
                Lsp.Enforce_margin(this.interp_lsp, this.lpcSize, 0.002f);
                Lsp.Enforce_margin(this.interp_qlsp, this.lpcSize, 0.002f);
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.interp_lsp[i] = (float)Math.Cos((double)this.interp_lsp[i]);
                }
                this.m_lsp.Lsp2lpc(this.interp_lsp, this.interp_lpc, this.lpcSize);
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.interp_qlsp[i] = (float)Math.Cos((double)this.interp_qlsp[i]);
                }
                this.m_lsp.Lsp2lpc(this.interp_qlsp, this.interp_qlpc, this.lpcSize);
                num18           = 1f;
                this.pi_gain[k] = 0f;
                for (int i = 0; i <= this.lpcSize; i++)
                {
                    this.pi_gain[k] += num18 * this.interp_qlpc[i];
                    num18            = -num18;
                }
                Filters.Bw_lpc(this.gamma1, this.interp_lpc, this.bw_lpc1, this.lpcSize);
                if (this.gamma2 >= 0f)
                {
                    Filters.Bw_lpc(this.gamma2, this.interp_lpc, this.bw_lpc2, this.lpcSize);
                }
                else
                {
                    this.bw_lpc2[0] = 1f;
                    this.bw_lpc2[1] = -this.preemph;
                    for (int i = 2; i <= this.lpcSize; i++)
                    {
                        this.bw_lpc2[i] = 0f;
                    }
                }
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.excBuf[num15 + i] = 0f;
                }
                this.excBuf[num15] = 1f;
                Filters.Syn_percep_zero(this.excBuf, num15, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, array5, this.subframeSize, this.lpcSize);
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.excBuf[num15 + i] = 0f;
                }
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.exc2Buf[num17 + i] = 0f;
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    array6[i] = this.mem_sp[i];
                }
                Filters.Iir_mem2(this.excBuf, num15, this.interp_qlpc, this.excBuf, num15, this.subframeSize, this.lpcSize, array6);
                for (int i = 0; i < this.lpcSize; i++)
                {
                    array6[i] = this.mem_sw[i];
                }
                Filters.Filter_mem2(this.excBuf, num15, this.bw_lpc1, this.bw_lpc2, array3, 0, this.subframeSize, this.lpcSize, array6, 0);
                for (int i = 0; i < this.lpcSize; i++)
                {
                    array6[i] = this.mem_sw[i];
                }
                Filters.Filter_mem2(this.frmBuf, num14, this.bw_lpc1, this.bw_lpc2, this.swBuf, num16, this.subframeSize, this.lpcSize, array6, 0);
                for (int i = 0; i < this.subframeSize; i++)
                {
                    array4[i] = this.swBuf[num16 + i] - array3[i];
                }
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.excBuf[num15 + i] = (this.exc2Buf[num17 + i] = 0f);
                }
                int start;
                int num19;
                if (this.submodes[this.submodeID].LbrPitch != -1)
                {
                    int lbrPitch = this.submodes[this.submodeID].LbrPitch;
                    if (lbrPitch != 0)
                    {
                        if (num3 < this.min_pitch + lbrPitch - 1)
                        {
                            num3 = this.min_pitch + lbrPitch - 1;
                        }
                        if (num3 > this.max_pitch - lbrPitch)
                        {
                            num3 = this.max_pitch - lbrPitch;
                        }
                        start = num3 - lbrPitch + 1;
                        num19 = num3 + lbrPitch;
                    }
                    else
                    {
                        num19 = (start = num3);
                    }
                }
                else
                {
                    start = this.min_pitch;
                    num19 = this.max_pitch;
                }
                if (this.bounded_pitch != 0 && num19 > num13)
                {
                    num19 = num13;
                }
                int num20 = this.submodes[this.submodeID].Ltp.Quant(array4, this.swBuf, num16, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.excBuf, num15, start, num19, num4, this.lpcSize, this.subframeSize, bits, this.exc2Buf, num17, array5, this.complexity);
                this.pitch[k] = num20;
                Filters.Syn_percep_zero(this.excBuf, num15, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, array3, this.subframeSize, this.lpcSize);
                for (int i = 0; i < this.subframeSize; i++)
                {
                    array4[i] -= array3[i];
                }
                float num21 = 0f;
                int   num22 = k * this.subframeSize;
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.innov[num22 + i] = 0f;
                }
                Filters.Residue_percep_zero(array4, 0, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.buf2, this.subframeSize, this.lpcSize);
                for (int i = 0; i < this.subframeSize; i++)
                {
                    num21 += this.buf2[i] * this.buf2[i];
                }
                num21  = (float)Math.Sqrt((double)(0.1f + num21 / (float)this.subframeSize));
                num21 /= num5;
                if (this.submodes[this.submodeID].HaveSubframeGain != 0)
                {
                    num21 = (float)Math.Log((double)num21);
                    if (this.submodes[this.submodeID].HaveSubframeGain == 3)
                    {
                        int num23 = VQ.Index(num21, NbCodec.exc_gain_quant_scal3, 8);
                        bits.Pack(num23, 3);
                        num21 = NbCodec.exc_gain_quant_scal3[num23];
                    }
                    else
                    {
                        int num23 = VQ.Index(num21, NbCodec.exc_gain_quant_scal1, 2);
                        bits.Pack(num23, 1);
                        num21 = NbCodec.exc_gain_quant_scal1[num23];
                    }
                    num21 = (float)Math.Exp((double)num21);
                }
                else
                {
                    num21 = 1f;
                }
                num21 *= num5;
                float num24 = 1f / num21;
                for (int i = 0; i < this.subframeSize; i++)
                {
                    array4[i] *= num24;
                }
                this.submodes[this.submodeID].Innovation.Quantify(array4, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.lpcSize, this.subframeSize, this.innov, num22, array5, bits, this.complexity);
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.innov[num22 + i] *= num21;
                }
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.excBuf[num15 + i] += this.innov[num22 + i];
                }
                if (this.submodes[this.submodeID].DoubleCodebook != 0)
                {
                    float[] array8 = new float[this.subframeSize];
                    for (int i = 0; i < this.subframeSize; i++)
                    {
                        array4[i] *= 2.2f;
                    }
                    this.submodes[this.submodeID].Innovation.Quantify(array4, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.lpcSize, this.subframeSize, array8, 0, array5, bits, this.complexity);
                    for (int i = 0; i < this.subframeSize; i++)
                    {
                        array8[i] *= (float)((double)num21 * 0.45454545454545453);
                    }
                    for (int i = 0; i < this.subframeSize; i++)
                    {
                        this.excBuf[num15 + i] += array8[i];
                    }
                }
                for (int i = 0; i < this.subframeSize; i++)
                {
                    array4[i] *= num21;
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    array6[i] = this.mem_sp[i];
                }
                Filters.Iir_mem2(this.excBuf, num15, this.interp_qlpc, this.frmBuf, num14, this.subframeSize, this.lpcSize, this.mem_sp);
                Filters.Filter_mem2(this.frmBuf, num14, this.bw_lpc1, this.bw_lpc2, this.swBuf, num16, this.subframeSize, this.lpcSize, this.mem_sw, 0);
                for (int i = 0; i < this.subframeSize; i++)
                {
                    this.exc2Buf[num17 + i] = this.excBuf[num15 + i];
                }
            }
            if (this.submodeID >= 1)
            {
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.old_lsp[i] = this.lsp[i];
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.old_qlsp[i] = this.qlsp[i];
                }
            }
            if (this.submodeID == 1)
            {
                if (this.dtx_count != 0)
                {
                    bits.Pack(15, 4);
                }
                else
                {
                    bits.Pack(0, 4);
                }
            }
            this.first = 0;
            float num25 = 0f;
            float num26 = 0f;

            for (int i = 0; i < this.frameSize; i++)
            {
                num25 += this.frmBuf[this.frmIdx + i] * this.frmBuf[this.frmIdx + i];
                num26 += (this.frmBuf[this.frmIdx + i] - array7[i]) * (this.frmBuf[this.frmIdx + i] - array7[i]);
            }
            ins0[0] = this.frmBuf[this.frmIdx] + this.preemph * this.pre_mem2;
            for (int i = 1; i < this.frameSize; i++)
            {
                ins0[i] = this.frmBuf[this.frmIdx + i] + this.preemph * ins0[i - 1];
            }
            this.pre_mem2 = ins0[this.frameSize - 1];
            if (this.submodes[this.submodeID].Innovation is NoiseSearch || this.submodeID == 0)
            {
                this.bounded_pitch = 1;
            }
            else
            {
                this.bounded_pitch = 0;
            }
            return(1);
        }
Exemplo n.º 3
0
        public int Encode(Bits bits, float[] vin)
        {
            int i;

            float[] res, target, mem;
            float[] syn_resp;
            float[] orig;
            /* Copy new data in input buffer */
            System.Array.Copy(frmBuf, frameSize, frmBuf, 0, bufSize - frameSize);
            frmBuf[bufSize - frameSize] = vin[0] - preemph * pre_mem;
            for (i = 1; i < frameSize; i++)
            {
                frmBuf[bufSize - frameSize + i] = vin[i] - preemph * vin[i - 1];
            }
            pre_mem = vin[frameSize - 1];

            /* Move signals 1 frame towards the past */
            System.Array.Copy(exc2Buf, frameSize, exc2Buf, 0, bufSize - frameSize);
            System.Array.Copy(excBuf, frameSize, excBuf, 0, bufSize - frameSize);
            System.Array.Copy(swBuf, frameSize, swBuf, 0, bufSize - frameSize);

            /* Window for analysis */
            for (i = 0; i < windowSize; i++)
            {
                buf2[i] = frmBuf[i + frmIdx] * window[i];
            }

            /* Compute auto-correlation */
            Lpc.autocorr(buf2, autocorr, lpcSize + 1, windowSize);

            autocorr[0] += 10;        /* prevents NANs */
            autocorr[0] *= lpc_floor; /* Noise floor in auto-correlation domain */

            /* Lag windowing: equivalent to filtering in the power-spectrum domain */
            for (i = 0; i < lpcSize + 1; i++)
            {
                autocorr[i] *= lagWindow[i];
            }

            /* Levinson-Durbin */
            Lpc.wld(lpc, autocorr, rc, lpcSize); // tmperr
            System.Array.Copy(lpc, 0, lpc, 1, lpcSize);
            lpc[0] = 1;

            /* LPC to LSPs (x-domain) transform */
            int roots = Lsp.lpc2lsp(lpc, lpcSize, lsp, 15, 0.2f);

            /* Check if we found all the roots */
            if (roots == lpcSize)
            {
                /* LSP x-domain to angle domain*/
                for (i = 0; i < lpcSize; i++)
                {
                    lsp[i] = (float)Math.Acos(lsp[i]);
                }
            }
            else
            {
                /* Search again if we can afford it */
                if (complexity > 1)
                {
                    roots = Lsp.lpc2lsp(lpc, lpcSize, lsp, 11, 0.05f);
                }
                if (roots == lpcSize)
                {
                    /* LSP x-domain to angle domain*/
                    for (i = 0; i < lpcSize; i++)
                    {
                        lsp[i] = (float)Math.Acos(lsp[i]);
                    }
                }
                else
                {
                    /*If we can't find all LSP's, do some damage control and use previous filter*/
                    for (i = 0; i < lpcSize; i++)
                    {
                        lsp[i] = old_lsp[i];
                    }
                }
            }

            float lsp_dist = 0;

            for (i = 0; i < lpcSize; i++)
            {
                lsp_dist += (old_lsp[i] - lsp[i]) * (old_lsp[i] - lsp[i]);
            }

            /* Whole frame analysis (open-loop estimation of pitch and excitation gain) */
            float ol_gain;
            int   ol_pitch;
            float ol_pitch_coef;

            {
                if (first != 0)
                {
                    for (i = 0; i < lpcSize; i++)
                    {
                        interp_lsp[i] = lsp[i];
                    }
                }
                else
                {
                    for (i = 0; i < lpcSize; i++)
                    {
                        interp_lsp[i] = .375f * old_lsp[i] + .625f * lsp[i];
                    }
                }

                Lsp.enforce_margin(interp_lsp, lpcSize, .002f);

                /* Compute interpolated LPCs (unquantized) for whole frame*/
                for (i = 0; i < lpcSize; i++)
                {
                    interp_lsp[i] = (float)Math.Cos(interp_lsp[i]);
                }
                m_lsp.lsp2lpc(interp_lsp, interp_lpc, lpcSize);

                /*Open-loop pitch*/
                if (submodes[submodeID] == null ||
                    vbr_enabled != 0 || vad_enabled != 0 ||
                    submodes[submodeID].forced_pitch_gain != 0 ||
                    submodes[submodeID].lbr_pitch != -1)
                {
                    int[]   nol_pitch      = new int[6];
                    float[] nol_pitch_coef = new float[6];

                    Filters.bw_lpc(gamma1, interp_lpc, bw_lpc1, lpcSize);
                    Filters.bw_lpc(gamma2, interp_lpc, bw_lpc2, lpcSize);

                    Filters.filter_mem2(frmBuf, frmIdx, bw_lpc1, bw_lpc2, swBuf, swIdx,
                                        frameSize, lpcSize, mem_sw_whole, 0);

                    Ltp.open_loop_nbest_pitch(swBuf, swIdx, min_pitch, max_pitch, frameSize,
                                              nol_pitch, nol_pitch_coef, 6);
                    ol_pitch      = nol_pitch[0];
                    ol_pitch_coef = nol_pitch_coef[0];
                    /*Try to remove pitch multiples*/
                    for (i = 1; i < 6; i++)
                    {
                        if ((nol_pitch_coef[i] > .85 * ol_pitch_coef) &&
                            (Math.Abs(nol_pitch[i] - ol_pitch / 2.0) <= 1 ||
                             Math.Abs(nol_pitch[i] - ol_pitch / 3.0) <= 1 ||
                             Math.Abs(nol_pitch[i] - ol_pitch / 4.0) <= 1 ||
                             Math.Abs(nol_pitch[i] - ol_pitch / 5.0) <= 1))
                        {
                            /*ol_pitch_coef=nol_pitch_coef[i];*/
                            ol_pitch = nol_pitch[i];
                        }
                    }

                    /*if (ol_pitch>50)
                     * ol_pitch/=2;*/
                    /*ol_pitch_coef = sqrt(ol_pitch_coef);*/
                }
                else
                {
                    ol_pitch      = 0;
                    ol_pitch_coef = 0;
                }
                /*Compute "real" excitation*/
                Filters.fir_mem2(frmBuf, frmIdx, interp_lpc, excBuf, excIdx, frameSize, lpcSize, mem_exc);

                /* Compute open-loop excitation gain */
                ol_gain = 0;
                for (i = 0; i < frameSize; i++)
                {
                    ol_gain += excBuf[excIdx + i] * excBuf[excIdx + i];
                }

                ol_gain = (float)Math.Sqrt(1 + ol_gain / frameSize);
            }

            /*VBR stuff*/
            if (vbr != null && (vbr_enabled != 0 || vad_enabled != 0))
            {
                if (abr_enabled != 0)
                {
                    float qual_change = 0;
                    if (abr_drift2 * abr_drift > 0)
                    {
                        /* Only adapt if long-term and short-term drift are the same sign */
                        qual_change = -.00001f * abr_drift / (1 + abr_count);
                        if (qual_change > .05f)
                        {
                            qual_change = .05f;
                        }
                        if (qual_change < -.05f)
                        {
                            qual_change = -.05f;
                        }
                    }
                    vbr_quality += qual_change;
                    if (vbr_quality > 10)
                    {
                        vbr_quality = 10;
                    }
                    if (vbr_quality < 0)
                    {
                        vbr_quality = 0;
                    }
                }
                relative_quality = vbr.analysis(vin, frameSize, ol_pitch, ol_pitch_coef);
                /*if (delta_qual<0)*/
                /*  delta_qual*=.1*(3+st->vbr_quality);*/
                if (vbr_enabled != 0)
                {
                    int   mode;
                    int   choice   = 0;
                    float min_diff = 100;
                    mode = 8;
                    while (mode > 0)
                    {
                        int   v1;
                        float thresh;
                        v1 = (int)Math.Floor(vbr_quality);
                        if (v1 == 10)
                        {
                            thresh = NSpeex.Vbr.nb_thresh[mode][v1];
                        }
                        else
                        {
                            thresh = (vbr_quality - v1) * NSpeex.Vbr.nb_thresh[mode][v1 + 1] +
                                     (1 + v1 - vbr_quality) * NSpeex.Vbr.nb_thresh[mode][v1];
                        }
                        if (relative_quality > thresh &&
                            relative_quality - thresh < min_diff)
                        {
                            choice   = mode;
                            min_diff = relative_quality - thresh;
                        }
                        mode--;
                    }
                    mode = choice;
                    if (mode == 0)
                    {
                        if (dtx_count == 0 || lsp_dist > .05 || dtx_enabled == 0 || dtx_count > 20)
                        {
                            mode      = 1;
                            dtx_count = 1;
                        }
                        else
                        {
                            mode = 0;
                            dtx_count++;
                        }
                    }
                    else
                    {
                        dtx_count = 0;
                    }


                    Mode = mode;

                    if (abr_enabled != 0)
                    {
                        int bitrate;
                        bitrate    = BitRate;
                        abr_drift += (bitrate - abr_enabled);
                        abr_drift2 = .95f * abr_drift2 + .05f * (bitrate - abr_enabled);
                        abr_count += 1.0f;
                    }
                }
                else
                {
                    /*VAD only case*/
                    int mode;
                    if (relative_quality < 2)
                    {
                        if (dtx_count == 0 || lsp_dist > .05 || dtx_enabled == 0 || dtx_count > 20)
                        {
                            dtx_count = 1;
                            mode      = 1;
                        }
                        else
                        {
                            mode = 0;
                            dtx_count++;
                        }
                    }
                    else
                    {
                        dtx_count = 0;
                        mode      = submodeSelect;
                    }
                    /*speex_encoder_ctl(state, SPEEX_SET_MODE, &mode);*/
                    submodeID = mode;
                }
            }
            else
            {
                relative_quality = -1;
            }

            /* First, transmit a zero for narrowband */
            bits.Pack(0, 1);

            /* Transmit the sub-mode we use for this frame */
            bits.Pack(submodeID, NB_SUBMODE_BITS);

            /* If null mode (no transmission), just set a couple things to zero*/
            if (submodes[submodeID] == null)
            {
                for (i = 0; i < frameSize; i++)
                {
                    excBuf[excIdx + i] = exc2Buf[exc2Idx + i] = swBuf[swIdx + i] = VERY_SMALL;
                }

                for (i = 0; i < lpcSize; i++)
                {
                    mem_sw[i] = 0;
                }
                first         = 1;
                bounded_pitch = 1;

                /* Final signal synthesis from excitation */
                Filters.iir_mem2(excBuf, excIdx, interp_qlpc, frmBuf, frmIdx, frameSize, lpcSize, mem_sp);

                vin[0] = frmBuf[frmIdx] + preemph * pre_mem2;
                for (i = 1; i < frameSize; i++)
                {
                    vin[i] = frmBuf[frmIdx = i] + preemph * vin[i - 1];
                }
                pre_mem2 = vin[frameSize - 1];

                return(0);
            }

            /* LSP Quantization */
            if (first != 0)
            {
                for (i = 0; i < lpcSize; i++)
                {
                    old_lsp[i] = lsp[i];
                }
            }

            /*Quantize LSPs*/
            //#if 1 /*0 for unquantized*/
            submodes[submodeID].lsqQuant.quant(lsp, qlsp, lpcSize, bits);
            //#else
            //     for (i=0;i<lpcSize;i++)
            //       qlsp[i]=lsp[i];
            //#endif

            /*If we use low bit-rate pitch mode, transmit open-loop pitch*/
            if (submodes[submodeID].lbr_pitch != -1)
            {
                bits.Pack(ol_pitch - min_pitch, 7);
            }

            if (submodes[submodeID].forced_pitch_gain != 0)
            {
                int quant;
                quant = (int)Math.Floor(.5 + 15 * ol_pitch_coef);
                if (quant > 15)
                {
                    quant = 15;
                }
                if (quant < 0)
                {
                    quant = 0;
                }
                bits.Pack(quant, 4);
                ol_pitch_coef = (float)0.066667 * quant;
            }

            /*Quantize and transmit open-loop excitation gain*/
            {
                int qe = (int)(Math.Floor(0.5 + 3.5 * Math.Log(ol_gain)));
                if (qe < 0)
                {
                    qe = 0;
                }
                if (qe > 31)
                {
                    qe = 31;
                }
                ol_gain = (float)Math.Exp(qe / 3.5);
                bits.Pack(qe, 5);
            }

            /* Special case for first frame */
            if (first != 0)
            {
                for (i = 0; i < lpcSize; i++)
                {
                    old_qlsp[i] = qlsp[i];
                }
            }

            /* Filter response */
            res = new float[subframeSize];
            /* Target signal */
            target   = new float[subframeSize];
            syn_resp = new float[subframeSize];
            mem      = new float[lpcSize];
            orig     = new float[frameSize];
            for (i = 0; i < frameSize; i++)
            {
                orig[i] = frmBuf[frmIdx + i];
            }

            /* Loop on sub-frames */
            for (int sub = 0; sub < nbSubframes; sub++)
            {
                float tmp;
                int   offset;
                int   sp, sw, exc, exc2;
                int   pitchval;

                /* Offset relative to start of frame */
                offset = subframeSize * sub;
                /* Original signal */
                sp = frmIdx + offset;
                /* Excitation */
                exc = excIdx + offset;
                /* Weighted signal */
                sw = swIdx + offset;

                exc2 = exc2Idx + offset;

                /* LSP interpolation (quantized and unquantized) */
                tmp = (float)(1.0 + sub) / nbSubframes;
                for (i = 0; i < lpcSize; i++)
                {
                    interp_lsp[i] = (1 - tmp) * old_lsp[i] + tmp * lsp[i];
                }
                for (i = 0; i < lpcSize; i++)
                {
                    interp_qlsp[i] = (1 - tmp) * old_qlsp[i] + tmp * qlsp[i];
                }

                /* Make sure the filters are stable */
                Lsp.enforce_margin(interp_lsp, lpcSize, .002f);
                Lsp.enforce_margin(interp_qlsp, lpcSize, .002f);

                /* Compute interpolated LPCs (quantized and unquantized) */
                for (i = 0; i < lpcSize; i++)
                {
                    interp_lsp[i] = (float)Math.Cos(interp_lsp[i]);
                }
                m_lsp.lsp2lpc(interp_lsp, interp_lpc, lpcSize);

                for (i = 0; i < lpcSize; i++)
                {
                    interp_qlsp[i] = (float)Math.Cos(interp_qlsp[i]);
                }
                m_lsp.lsp2lpc(interp_qlsp, interp_qlpc, lpcSize);

                /* Compute analysis filter gain at w=pi (for use in SB-CELP) */
                tmp          = 1;
                pi_gain[sub] = 0;
                for (i = 0; i <= lpcSize; i++)
                {
                    pi_gain[sub] += tmp * interp_qlpc[i];
                    tmp           = -tmp;
                }

                /* Compute bandwidth-expanded (unquantized) LPCs for perceptual weighting */
                Filters.bw_lpc(gamma1, interp_lpc, bw_lpc1, lpcSize);
                if (gamma2 >= 0)
                {
                    Filters.bw_lpc(gamma2, interp_lpc, bw_lpc2, lpcSize);
                }
                else
                {
                    bw_lpc2[0] = 1;
                    bw_lpc2[1] = -preemph;
                    for (i = 2; i <= lpcSize; i++)
                    {
                        bw_lpc2[i] = 0;
                    }
                }

                /* Compute impulse response of A(z/g1) / ( A(z)*A(z/g2) )*/
                for (i = 0; i < subframeSize; i++)
                {
                    excBuf[exc + i] = 0;
                }
                excBuf[exc] = 1;
                Filters.syn_percep_zero(excBuf, exc, interp_qlpc, bw_lpc1, bw_lpc2, syn_resp, subframeSize, lpcSize);

                /* Reset excitation */
                for (i = 0; i < subframeSize; i++)
                {
                    excBuf[exc + i] = 0;
                }
                for (i = 0; i < subframeSize; i++)
                {
                    exc2Buf[exc2 + i] = 0;
                }

                /* Compute zero response of A(z/g1) / ( A(z/g2) * A(z) ) */
                for (i = 0; i < lpcSize; i++)
                {
                    mem[i] = mem_sp[i];
                }
                Filters.iir_mem2(excBuf, exc, interp_qlpc, excBuf, exc, subframeSize, lpcSize, mem);

                for (i = 0; i < lpcSize; i++)
                {
                    mem[i] = mem_sw[i];
                }
                Filters.filter_mem2(excBuf, exc, bw_lpc1, bw_lpc2, res, 0, subframeSize, lpcSize, mem, 0);

                /* Compute weighted signal */
                for (i = 0; i < lpcSize; i++)
                {
                    mem[i] = mem_sw[i];
                }
                Filters.filter_mem2(frmBuf, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize, lpcSize, mem, 0);

                /* Compute target signal */
                for (i = 0; i < subframeSize; i++)
                {
                    target[i] = swBuf[sw + i] - res[i];
                }

                for (i = 0; i < subframeSize; i++)
                {
                    excBuf[exc + i] = exc2Buf[exc2 + i] = 0;
                }

                /* If we have a long-term predictor (otherwise, something's wrong) */
                //    if (submodes[submodeID].ltp.quant)
                //    {
                int pit_min, pit_max;
                /* Long-term prediction */
                if (submodes[submodeID].lbr_pitch != -1)
                {
                    /* Low bit-rate pitch handling */
                    int margin;
                    margin = submodes[submodeID].lbr_pitch;
                    if (margin != 0)
                    {
                        if (ol_pitch < min_pitch + margin - 1)
                        {
                            ol_pitch = min_pitch + margin - 1;
                        }
                        if (ol_pitch > max_pitch - margin)
                        {
                            ol_pitch = max_pitch - margin;
                        }
                        pit_min = ol_pitch - margin + 1;
                        pit_max = ol_pitch + margin;
                    }
                    else
                    {
                        pit_min = pit_max = ol_pitch;
                    }
                }
                else
                {
                    pit_min = min_pitch;
                    pit_max = max_pitch;
                }

                /* Force pitch to use only the current frame if needed */
                if (bounded_pitch != 0 && pit_max > offset)
                {
                    pit_max = offset;
                }

                /* Perform pitch search */
                pitchval = submodes[submodeID].ltp.Quant(target, swBuf, sw, interp_qlpc, bw_lpc1, bw_lpc2,
                                                         excBuf, exc, pit_min, pit_max, ol_pitch_coef, lpcSize,
                                                         subframeSize, bits, exc2Buf, exc2, syn_resp, complexity);

                pitch[sub] = pitchval;

                //    } else {
                //      speex_error ("No pitch prediction, what's wrong");
                //    }

                /* Update target for adaptive codebook contribution */
                Filters.syn_percep_zero(excBuf, exc, interp_qlpc, bw_lpc1, bw_lpc2, res, subframeSize, lpcSize);
                for (i = 0; i < subframeSize; i++)
                {
                    target[i] -= res[i];
                }

                /* Quantization of innovation */
                {
                    int   innovptr;
                    float ener = 0, ener_1;

                    innovptr = sub * subframeSize;
                    for (i = 0; i < subframeSize; i++)
                    {
                        innov[innovptr + i] = 0;
                    }

                    Filters.residue_percep_zero(target, 0, interp_qlpc, bw_lpc1, bw_lpc2, buf2, subframeSize, lpcSize);
                    for (i = 0; i < subframeSize; i++)
                    {
                        ener += buf2[i] * buf2[i];
                    }
                    ener = (float)Math.Sqrt(.1f + ener / subframeSize);

                    /*for (i=0;i<subframeSize;i++)
                     * System.out.print(buf2[i]/ener + "\t");
                     */

                    ener /= ol_gain;

                    /* Calculate gain correction for the sub-frame (if any) */
                    if (submodes[submodeID].have_subframe_gain != 0)
                    {
                        int qe;
                        ener = (float)Math.Log(ener);
                        if (submodes[submodeID].have_subframe_gain == 3)
                        {
                            qe = VQ.index(ener, exc_gain_quant_scal3, 8);
                            bits.Pack(qe, 3);
                            ener = exc_gain_quant_scal3[qe];
                        }
                        else
                        {
                            qe = VQ.index(ener, exc_gain_quant_scal1, 2);
                            bits.Pack(qe, 1);
                            ener = exc_gain_quant_scal1[qe];
                        }
                        ener = (float)Math.Exp(ener);
                    }
                    else
                    {
                        ener = 1;
                    }

                    ener *= ol_gain;

                    /*System.out.println(ener + " " + ol_gain);*/

                    ener_1 = 1 / ener;

                    /* Normalize innovation */
                    for (i = 0; i < subframeSize; i++)
                    {
                        target[i] *= ener_1;
                    }

                    /* Quantize innovation */
                    //      if (submodes[submodeID].innovation != null)
                    //      {
                    /* Codebook search */
                    submodes[submodeID].innovation.Quant(target, interp_qlpc, bw_lpc1, bw_lpc2,
                                                         lpcSize, subframeSize, innov,
                                                         innovptr, syn_resp, bits, complexity);

                    /* De-normalize innovation and update excitation */
                    for (i = 0; i < subframeSize; i++)
                    {
                        innov[innovptr + i] *= ener;
                    }
                    for (i = 0; i < subframeSize; i++)
                    {
                        excBuf[exc + i] += innov[innovptr + i];
                    }
                    //      } else {
                    //        speex_error("No fixed codebook");
                    //      }

                    /* In some (rare) modes, we do a second search (more bits) to reduce noise even more */
                    if (submodes[submodeID].double_codebook != 0)
                    {
                        float[] innov2 = new float[subframeSize];
                        //          for (i=0;i<subframeSize;i++)
                        //            innov2[i]=0;
                        for (i = 0; i < subframeSize; i++)
                        {
                            target[i] *= 2.2f;
                        }
                        submodes[submodeID].innovation.Quant(target, interp_qlpc, bw_lpc1, bw_lpc2,
                                                             lpcSize, subframeSize, innov2, 0,
                                                             syn_resp, bits, complexity);
                        for (i = 0; i < subframeSize; i++)
                        {
                            innov2[i] *= ener * (1f / 2.2f);
                        }
                        for (i = 0; i < subframeSize; i++)
                        {
                            excBuf[exc + i] += innov2[i];
                        }
                    }

                    for (i = 0; i < subframeSize; i++)
                    {
                        target[i] *= ener;
                    }
                }

                /*Keep the previous memory*/
                for (i = 0; i < lpcSize; i++)
                {
                    mem[i] = mem_sp[i];
                }
                /* Final signal synthesis from excitation */
                Filters.iir_mem2(excBuf, exc, interp_qlpc, frmBuf, sp, subframeSize, lpcSize, mem_sp);

                /* Compute weighted signal again, from synthesized speech (not sure it's the right thing) */
                Filters.filter_mem2(frmBuf, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize, lpcSize, mem_sw, 0);
                for (i = 0; i < subframeSize; i++)
                {
                    exc2Buf[exc2 + i] = excBuf[exc + i];
                }
            }

            /* Store the LSPs for interpolation in the next frame */
            if (submodeID >= 1)
            {
                for (i = 0; i < lpcSize; i++)
                {
                    old_lsp[i] = lsp[i];
                }
                for (i = 0; i < lpcSize; i++)
                {
                    old_qlsp[i] = qlsp[i];
                }
            }

            if (submodeID == 1)
            {
                if (dtx_count != 0)
                {
                    bits.Pack(15, 4);
                }
                else
                {
                    bits.Pack(0, 4);
                }
            }

            /* The next frame will not be the first (Duh!) */
            first = 0;

            {
                float ener = 0, err = 0;
                float snr;
                for (i = 0; i < frameSize; i++)
                {
                    ener += frmBuf[frmIdx + i] * frmBuf[frmIdx + i];
                    err  += (frmBuf[frmIdx + i] - orig[i]) * (frmBuf[frmIdx + i] - orig[i]);
                }
                snr = (float)(10 * Math.Log((ener + 1) / (err + 1)));
                /*System.out.println("Frame result: SNR="+snr+" E="+ener+" Err="+err+"\r\n");*/
            }

            /* Replace input by synthesized speech */
            vin[0] = frmBuf[frmIdx] + preemph * pre_mem2;
            for (i = 1; i < frameSize; i++)
            {
                vin[i] = frmBuf[frmIdx + i] + preemph * vin[i - 1];
            }
            pre_mem2 = vin[frameSize - 1];

            if (submodes[submodeID].innovation is NoiseSearch || submodeID == 0)
            {
                bounded_pitch = 1;
            }
            else
            {
                bounded_pitch = 0;
            }

            return(1);
        }
Exemplo n.º 4
0
        public virtual int Encode(Bits bits, float[] ins0)
        {
            Filters.Qmf_decomp(ins0, Codebook_Constants.h0, this.x0d, this.x1d, this.fullFrameSize, 64, this.h0_mem);
            this.lowenc.Encode(bits, this.x0d);
            for (int i = 0; i < this.windowSize - this.frameSize; i++)
            {
                this.high[i] = this.high[this.frameSize + i];
            }
            for (int i = 0; i < this.frameSize; i++)
            {
                this.high[this.windowSize - this.frameSize + i] = this.x1d[i];
            }
            Array.Copy(this.excBuf, this.frameSize, this.excBuf, 0, this.bufSize - this.frameSize);
            float[] piGain = this.lowenc.PiGain;
            float[] exc    = this.lowenc.Exc;
            float[] innov  = this.lowenc.Innov;
            int     num;

            if (this.lowenc.Mode == 0)
            {
                num = 1;
            }
            else
            {
                num = 0;
            }
            for (int i = 0; i < this.windowSize; i++)
            {
                this.buf[i] = this.high[i] * this.window[i];
            }
            Lpc.Autocorr(this.buf, this.autocorr, this.lpcSize + 1, this.windowSize);
            this.autocorr[0] += 1f;
            this.autocorr[0] *= this.lpc_floor;
            for (int i = 0; i < this.lpcSize + 1; i++)
            {
                this.autocorr[i] *= this.lagWindow[i];
            }
            Lpc.Wld(this.lpc, this.autocorr, this.rc, this.lpcSize);
            Array.Copy(this.lpc, 0, this.lpc, 1, this.lpcSize);
            this.lpc[0] = 1f;
            int num2 = Lsp.Lpc2lsp(this.lpc, this.lpcSize, this.lsp, 15, 0.2f);

            if (num2 != this.lpcSize)
            {
                num2 = Lsp.Lpc2lsp(this.lpc, this.lpcSize, this.lsp, 11, 0.02f);
                if (num2 != this.lpcSize)
                {
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.lsp[i] = (float)Math.Cos(3.1415926535897931 * (double)((float)(i + 1)) / (double)(this.lpcSize + 1));
                    }
                }
            }
            for (int i = 0; i < this.lpcSize; i++)
            {
                this.lsp[i] = (float)Math.Acos((double)this.lsp[i]);
            }
            float num3 = 0f;

            for (int i = 0; i < this.lpcSize; i++)
            {
                num3 += (this.old_lsp[i] - this.lsp[i]) * (this.old_lsp[i] - this.lsp[i]);
            }
            if ((this.vbr_enabled != 0 || this.vad_enabled != 0) && num == 0)
            {
                float num4 = 0f;
                float num5 = 0f;
                if (this.abr_enabled != 0)
                {
                    float num6 = 0f;
                    if (this.abr_drift2 * this.abr_drift > 0f)
                    {
                        num6 = -1E-05f * this.abr_drift / (1f + this.abr_count);
                        if (num6 > 0.1f)
                        {
                            num6 = 0.1f;
                        }
                        if (num6 < -0.1f)
                        {
                            num6 = -0.1f;
                        }
                    }
                    this.vbr_quality += num6;
                    if (this.vbr_quality > 10f)
                    {
                        this.vbr_quality = 10f;
                    }
                    if (this.vbr_quality < 0f)
                    {
                        this.vbr_quality = 0f;
                    }
                }
                for (int i = 0; i < this.frameSize; i++)
                {
                    num4 += this.x0d[i] * this.x0d[i];
                    num5 += this.high[i] * this.high[i];
                }
                float num7 = (float)Math.Log((double)((1f + num5) / (1f + num4)));
                this.relative_quality = this.lowenc.RelativeQuality;
                if (num7 < -4f)
                {
                    num7 = -4f;
                }
                if (num7 > 2f)
                {
                    num7 = 2f;
                }
                if (this.vbr_enabled != 0)
                {
                    int num8 = this.nb_modes - 1;
                    this.relative_quality += 1f * (num7 + 2f);
                    if (this.relative_quality < -1f)
                    {
                        this.relative_quality = -1f;
                    }
                    while (num8 != 0)
                    {
                        int   num9 = (int)Math.Floor((double)this.vbr_quality);
                        float num10;
                        if (num9 == 10)
                        {
                            num10 = NSpeex.Vbr.hb_thresh[num8][num9];
                        }
                        else
                        {
                            num10 = (this.vbr_quality - (float)num9) * NSpeex.Vbr.hb_thresh[num8][num9 + 1] + ((float)(1 + num9) - this.vbr_quality) * NSpeex.Vbr.hb_thresh[num8][num9];
                        }
                        if (this.relative_quality >= num10)
                        {
                            break;
                        }
                        num8--;
                    }
                    this.Mode = num8;
                    if (this.abr_enabled != 0)
                    {
                        int bitRate = this.BitRate;
                        this.abr_drift += (float)(bitRate - this.abr_enabled);
                        this.abr_drift2 = 0.95f * this.abr_drift2 + 0.05f * (float)(bitRate - this.abr_enabled);
                        this.abr_count += 1f;
                    }
                }
                else
                {
                    int submodeID;
                    if ((double)this.relative_quality < 2.0)
                    {
                        submodeID = 1;
                    }
                    else
                    {
                        submodeID = this.submodeSelect;
                    }
                    this.submodeID = submodeID;
                }
            }
            bits.Pack(1, 1);
            if (num != 0)
            {
                bits.Pack(0, 3);
            }
            else
            {
                bits.Pack(this.submodeID, 3);
            }
            if (num == 0 && this.submodes[this.submodeID] != null)
            {
                this.submodes[this.submodeID].LsqQuant.Quant(this.lsp, this.qlsp, this.lpcSize, bits);
                if (this.first != 0)
                {
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.old_lsp[i] = this.lsp[i];
                    }
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.old_qlsp[i] = this.qlsp[i];
                    }
                }
                float[] array  = new float[this.lpcSize];
                float[] array2 = new float[this.subframeSize];
                float[] array3 = new float[this.subframeSize];
                for (int j = 0; j < this.nbSubframes; j++)
                {
                    float num11 = 0f;
                    float num12 = 0f;
                    int   num13 = this.subframeSize * j;
                    int   num14 = num13;
                    int   num15 = this.excIdx + num13;
                    int   num16 = num13;
                    int   num17 = num13;
                    float num18 = (1f + (float)j) / (float)this.nbSubframes;
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.interp_lsp[i] = (1f - num18) * this.old_lsp[i] + num18 * this.lsp[i];
                    }
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.interp_qlsp[i] = (1f - num18) * this.old_qlsp[i] + num18 * this.qlsp[i];
                    }
                    Lsp.Enforce_margin(this.interp_lsp, this.lpcSize, 0.05f);
                    Lsp.Enforce_margin(this.interp_qlsp, this.lpcSize, 0.05f);
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.interp_lsp[i] = (float)Math.Cos((double)this.interp_lsp[i]);
                    }
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        this.interp_qlsp[i] = (float)Math.Cos((double)this.interp_qlsp[i]);
                    }
                    this.m_lsp.Lsp2lpc(this.interp_lsp, this.interp_lpc, this.lpcSize);
                    this.m_lsp.Lsp2lpc(this.interp_qlsp, this.interp_qlpc, this.lpcSize);
                    Filters.Bw_lpc(this.gamma1, this.interp_lpc, this.bw_lpc1, this.lpcSize);
                    Filters.Bw_lpc(this.gamma2, this.interp_lpc, this.bw_lpc2, this.lpcSize);
                    float num19 = 0f;
                    num18           = 1f;
                    this.pi_gain[j] = 0f;
                    for (int i = 0; i <= this.lpcSize; i++)
                    {
                        num19           += num18 * this.interp_qlpc[i];
                        num18            = -num18;
                        this.pi_gain[j] += this.interp_qlpc[i];
                    }
                    float value = piGain[j];
                    value = 1f / (Math.Abs(value) + 0.01f);
                    num19 = 1f / (Math.Abs(num19) + 0.01f);
                    float num20 = Math.Abs(0.01f + num19) / (0.01f + Math.Abs(value));
                    Filters.Fir_mem2(this.high, num14, this.interp_qlpc, this.excBuf, num15, this.subframeSize, this.lpcSize, this.mem_sp2);
                    for (int i = 0; i < this.subframeSize; i++)
                    {
                        num11 += this.excBuf[num15 + i] * this.excBuf[num15 + i];
                    }
                    if (this.submodes[this.submodeID].Innovation == null)
                    {
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            num12 += innov[num13 + i] * innov[num13 + i];
                        }
                        float num21 = num11 / (0.01f + num12);
                        num21  = (float)Math.Sqrt((double)num21);
                        num21 *= num20;
                        int num22 = (int)Math.Floor(10.5 + 8.0 * Math.Log((double)num21 + 0.0001));
                        if (num22 < 0)
                        {
                            num22 = 0;
                        }
                        if (num22 > 31)
                        {
                            num22 = 31;
                        }
                        bits.Pack(num22, 5);
                        num21  = (float)(0.1 * Math.Exp((double)num22 / 9.4));
                        num21 /= num20;
                    }
                    else
                    {
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            num12 += exc[num13 + i] * exc[num13 + i];
                        }
                        float num23 = (float)(Math.Sqrt((double)(1f + num11)) * (double)num20 / Math.Sqrt((double)((1f + num12) * (float)this.subframeSize)));
                        int   num24 = (int)Math.Floor(0.5 + 3.7 * (Math.Log((double)num23) + 2.0));
                        if (num24 < 0)
                        {
                            num24 = 0;
                        }
                        if (num24 > 15)
                        {
                            num24 = 15;
                        }
                        bits.Pack(num24, 4);
                        num23 = (float)Math.Exp(0.27027027027027023 * (double)num24 - 2.0);
                        float num25 = num23 * (float)Math.Sqrt((double)(1f + num12)) / num20;
                        float num26 = 1f / num25;
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            this.excBuf[num15 + i] = 0f;
                        }
                        this.excBuf[num15] = 1f;
                        Filters.Syn_percep_zero(this.excBuf, num15, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, array2, this.subframeSize, this.lpcSize);
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            this.excBuf[num15 + i] = 0f;
                        }
                        for (int i = 0; i < this.lpcSize; i++)
                        {
                            array[i] = this.mem_sp[i];
                        }
                        Filters.Iir_mem2(this.excBuf, num15, this.interp_qlpc, this.excBuf, num15, this.subframeSize, this.lpcSize, array);
                        for (int i = 0; i < this.lpcSize; i++)
                        {
                            array[i] = this.mem_sw[i];
                        }
                        Filters.Filter_mem2(this.excBuf, num15, this.bw_lpc1, this.bw_lpc2, this.res, num16, this.subframeSize, this.lpcSize, array, 0);
                        for (int i = 0; i < this.lpcSize; i++)
                        {
                            array[i] = this.mem_sw[i];
                        }
                        Filters.Filter_mem2(this.high, num14, this.bw_lpc1, this.bw_lpc2, this.swBuf, num17, this.subframeSize, this.lpcSize, array, 0);
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            this.target[i] = this.swBuf[num17 + i] - this.res[num16 + i];
                        }
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            this.excBuf[num15 + i] = 0f;
                        }
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            this.target[i] *= num26;
                        }
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            array3[i] = 0f;
                        }
                        this.submodes[this.submodeID].Innovation.Quantify(this.target, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.lpcSize, this.subframeSize, array3, 0, array2, bits, this.complexity + 1 >> 1);
                        for (int i = 0; i < this.subframeSize; i++)
                        {
                            this.excBuf[num15 + i] += array3[i] * num25;
                        }
                        if (this.submodes[this.submodeID].DoubleCodebook != 0)
                        {
                            float[] array4 = new float[this.subframeSize];
                            for (int i = 0; i < this.subframeSize; i++)
                            {
                                array4[i] = 0f;
                            }
                            for (int i = 0; i < this.subframeSize; i++)
                            {
                                this.target[i] *= 2.5f;
                            }
                            this.submodes[this.submodeID].Innovation.Quantify(this.target, this.interp_qlpc, this.bw_lpc1, this.bw_lpc2, this.lpcSize, this.subframeSize, array4, 0, array2, bits, this.complexity + 1 >> 1);
                            for (int i = 0; i < this.subframeSize; i++)
                            {
                                array4[i] *= (float)((double)num25 * 0.4);
                            }
                            for (int i = 0; i < this.subframeSize; i++)
                            {
                                this.excBuf[num15 + i] += array4[i];
                            }
                        }
                    }
                    for (int i = 0; i < this.lpcSize; i++)
                    {
                        array[i] = this.mem_sp[i];
                    }
                    Filters.Iir_mem2(this.excBuf, num15, this.interp_qlpc, this.high, num14, this.subframeSize, this.lpcSize, this.mem_sp);
                    Filters.Filter_mem2(this.high, num14, this.bw_lpc1, this.bw_lpc2, this.swBuf, num17, this.subframeSize, this.lpcSize, this.mem_sw, 0);
                }
                this.filters.Fir_mem_up(this.x0d, Codebook_Constants.h0, this.y0, this.fullFrameSize, 64, this.g0_mem);
                this.filters.Fir_mem_up(this.high, Codebook_Constants.h1, this.y1, this.fullFrameSize, 64, this.g1_mem);
                for (int i = 0; i < this.fullFrameSize; i++)
                {
                    ins0[i] = 2f * (this.y0[i] - this.y1[i]);
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.old_lsp[i] = this.lsp[i];
                }
                for (int i = 0; i < this.lpcSize; i++)
                {
                    this.old_qlsp[i] = this.qlsp[i];
                }
                this.first = 0;
                return(1);
            }
            for (int i = 0; i < this.frameSize; i++)
            {
                this.excBuf[this.excIdx + i] = (this.swBuf[i] = 0f);
            }
            for (int i = 0; i < this.lpcSize; i++)
            {
                this.mem_sw[i] = 0f;
            }
            this.first = 1;
            Filters.Iir_mem2(this.excBuf, this.excIdx, this.interp_qlpc, this.high, 0, this.subframeSize, this.lpcSize, this.mem_sp);
            this.filters.Fir_mem_up(this.x0d, Codebook_Constants.h0, this.y0, this.fullFrameSize, 64, this.g0_mem);
            this.filters.Fir_mem_up(this.high, Codebook_Constants.h1, this.y1, this.fullFrameSize, 64, this.g1_mem);
            for (int i = 0; i < this.fullFrameSize; i++)
            {
                ins0[i] = 2f * (this.y0[i] - this.y1[i]);
            }
            if (num != 0)
            {
                return(0);
            }
            return(1);
        }