示例#1
0
 /// <summary>Line Spectral Pair Quantification (Lbr).</summary>
 /// <remarks>Line Spectral Pair Quantification (Lbr).</remarks>
 /// <param name="lsp">- Line Spectral Pairs table.</param>
 /// <param name="qlsp">- Quantified Line Spectral Pairs table.</param>
 /// <param name="order"></param>
 /// <param name="bits">- Speex bits buffer.</param>
 public override sealed void quant(float[] lsp, float[] qlsp, int order, org.xiph.speex.Bits
     bits)
 {
     int i;
     float tmp1;
     float tmp2;
     int id;
     float[] quant_weight = new float[MAX_LSP_SIZE];
     for (i = 0; i < order; i++)
     {
         qlsp[i] = lsp[i];
     }
     quant_weight[0] = 1 / (qlsp[1] - qlsp[0]);
     quant_weight[order - 1] = 1 / (qlsp[order - 1] - qlsp[order - 2]);
     for (i = 1; i < order - 1; i++)
     {
         tmp1 = 1 / ((.15f + qlsp[i] - qlsp[i - 1]) * (.15f + qlsp[i] - qlsp[i - 1]));
         tmp2 = 1 / ((.15f + qlsp[i + 1] - qlsp[i]) * (.15f + qlsp[i + 1] - qlsp[i]));
         quant_weight[i] = tmp1 > tmp2 ? tmp1 : tmp2;
     }
     for (i = 0; i < order; i++)
     {
         qlsp[i] -= (.25f * i + .25f);
     }
     for (i = 0; i < order; i++)
     {
         qlsp[i] *= 256;
     }
     id = lsp_quant(qlsp, 0, cdbk_nb, NB_CDBK_SIZE, order);
     bits.pack(id, 6);
     for (i = 0; i < order; i++)
     {
         qlsp[i] *= 2;
     }
     id = lsp_weight_quant(qlsp, 0, quant_weight, 0, cdbk_nb_low1, NB_CDBK_SIZE_LOW1,
         5);
     bits.pack(id, 6);
     id = lsp_weight_quant(qlsp, 5, quant_weight, 5, cdbk_nb_high1, NB_CDBK_SIZE_HIGH1
         , 5);
     bits.pack(id, 6);
     for (i = 0; i < order; i++)
     {
         qlsp[i] *= 0.0019531f;
     }
     for (i = 0; i < order; i++)
     {
         qlsp[i] = lsp[i] - qlsp[i];
     }
 }
示例#2
0
 /// <summary>Line Spectral Pair Quantification (high).</summary>
 /// <remarks>Line Spectral Pair Quantification (high).</remarks>
 /// <param name="lsp">- Line Spectral Pairs table.</param>
 /// <param name="qlsp">- Quantified Line Spectral Pairs table.</param>
 /// <param name="order"></param>
 /// <param name="bits">- Speex bits buffer.</param>
 public override sealed void quant(float[] lsp, float[] qlsp, int order, org.xiph.speex.Bits
     bits)
 {
     int i;
     float tmp1;
     float tmp2;
     int id;
     float[] quant_weight = new float[MAX_LSP_SIZE];
     for (i = 0; i < order; i++)
     {
         qlsp[i] = lsp[i];
     }
     quant_weight[0] = 1 / (qlsp[1] - qlsp[0]);
     quant_weight[order - 1] = 1 / (qlsp[order - 1] - qlsp[order - 2]);
     for (i = 1; i < order - 1; i++)
     {
         tmp1 = 1 / (qlsp[i] - qlsp[i - 1]);
         tmp2 = 1 / (qlsp[i + 1] - qlsp[i]);
         quant_weight[i] = tmp1 > tmp2 ? tmp1 : tmp2;
     }
     for (i = 0; i < order; i++)
     {
         qlsp[i] -= (.3125f * i + .75f);
     }
     for (i = 0; i < order; i++)
     {
         qlsp[i] *= 256;
     }
     id = lsp_quant(qlsp, 0, high_lsp_cdbk, 64, order);
     bits.pack(id, 6);
     for (i = 0; i < order; i++)
     {
         qlsp[i] *= 2;
     }
     id = lsp_weight_quant(qlsp, 0, quant_weight, 0, high_lsp_cdbk2, 64, order);
     bits.pack(id, 6);
     for (i = 0; i < order; i++)
     {
         qlsp[i] *= 0.0019531f;
     }
     for (i = 0; i < order; i++)
     {
         qlsp[i] = lsp[i] - qlsp[i];
     }
 }
示例#3
0
 //  private float reserved1;           /** Reserved for future use */
 //  private float reserved2;           /** Reserved for future use */
 /// <summary>
 /// Transforms a stereo frame into a mono frame and stores intensity stereo
 /// info in 'bits'.
 /// </summary>
 /// <remarks>
 /// Transforms a stereo frame into a mono frame and stores intensity stereo
 /// info in 'bits'.
 /// </remarks>
 /// <param name="bits">- Speex bits buffer.</param>
 /// <param name="data"></param>
 /// <param name="frameSize"></param>
 public static void encode(org.xiph.speex.Bits bits, float[] data, int frameSize)
 {
     int i;
     int tmp;
     float e_left = 0;
     float e_right = 0;
     float e_tot = 0;
     float balance;
     float e_ratio;
     for (i = 0; i < frameSize; i++)
     {
         e_left += data[2 * i] * data[2 * i];
         e_right += data[2 * i + 1] * data[2 * i + 1];
         data[i] = .5f * (data[2 * i] + data[2 * i + 1]);
         e_tot += data[i] * data[i];
     }
     balance = (e_left + 1) / (e_right + 1);
     e_ratio = e_tot / (1 + e_left + e_right);
     bits.pack(14, 5);
     bits.pack(SPEEX_INBAND_STEREO, 4);
     balance = (float)(4 * System.Math.Log(balance));
     if (balance > 0)
     {
         bits.pack(0, 1);
     }
     else
     {
         bits.pack(1, 1);
     }
     balance = (float)System.Math.Floor(.5f + System.Math.Abs(balance));
     if (balance > 30)
     {
         balance = 31;
     }
     bits.pack((int)balance, 5);
     tmp = org.xiph.speex.VQ.index(e_ratio, e_ratio_quant, 4);
     bits.pack(tmp, 2);
 }
 /// <summary>Codebook Search Quantification (Split Shape).</summary>
 /// <remarks>Codebook Search Quantification (Split Shape).</remarks>
 /// <param name="target">target vector</param>
 /// <param name="ak">LPCs for this subframe</param>
 /// <param name="awk1">Weighted LPCs for this subframe</param>
 /// <param name="awk2">Weighted LPCs for this subframe</param>
 /// <param name="p">number of LPC coeffs</param>
 /// <param name="nsf">number of samples in subframe</param>
 /// <param name="exc">excitation array.</param>
 /// <param name="es">position in excitation array.</param>
 /// <param name="r"></param>
 /// <param name="bits">Speex bits buffer.</param>
 /// <param name="complexity"></param>
 public override sealed void quant(float[] target, float[] ak, float[] awk1, float
     [] awk2, int p, int nsf, float[] exc, int es, float[] r, org.xiph.speex.Bits bits
     , int complexity)
 {
     int i;
     int j;
     int k;
     int m;
     int n;
     int q;
     float[] resp;
     float[] ndist;
     float[] odist;
     int[] best_index;
     float[] best_dist;
     int N = complexity;
     if (N > 10)
     {
         N = 10;
     }
     resp = new float[shape_cb_size * subvect_size];
     best_index = new int[N];
     best_dist = new float[N];
     ndist = new float[N];
     odist = new float[N];
     for (i = 0; i < N; i++)
     {
         for (j = 0; j < nb_subvect; j++)
         {
             nind[i][j] = oind[i][j] = -1;
         }
     }
     for (j = 0; j < N; j++)
     {
         for (i = 0; i < nsf; i++)
         {
             ot[j][i] = target[i];
         }
     }
     //    System.arraycopy(target, 0, t, 0, nsf);
     for (i = 0; i < shape_cb_size; i++)
     {
         int res;
         int shape;
         res = i * subvect_size;
         shape = i * subvect_size;
         for (j = 0; j < subvect_size; j++)
         {
             resp[res + j] = 0;
             for (k = 0; k <= j; k++)
             {
                 resp[res + j] += 0.03125f * shape_cb[shape + k] * r[j - k];
             }
         }
         E[i] = 0;
         for (j = 0; j < subvect_size; j++)
         {
             E[i] += resp[res + j] * resp[res + j];
         }
     }
     for (j = 0; j < N; j++)
     {
         odist[j] = 0;
     }
     for (i = 0; i < nb_subvect; i++)
     {
         int offset = i * subvect_size;
         for (j = 0; j < N; j++)
         {
             ndist[j] = -1;
         }
         for (j = 0; j < N; j++)
         {
             if (have_sign != 0)
             {
                 org.xiph.speex.VQ.nbest_sign(ot[j], offset, resp, subvect_size, shape_cb_size, E,
                     N, best_index, best_dist);
             }
             else
             {
                 org.xiph.speex.VQ.nbest(ot[j], offset, resp, subvect_size, shape_cb_size, E, N, best_index
                     , best_dist);
             }
             for (k = 0; k < N; k++)
             {
                 float[] ct;
                 float err = 0;
                 ct = ot[j];
                 for (m = offset; m < offset + subvect_size; m++)
                 {
                     t[m] = ct[m];
                 }
                 int rind;
                 int res;
                 float sign = 1;
                 rind = best_index[k];
                 if (rind >= shape_cb_size)
                 {
                     sign = -1;
                     rind -= shape_cb_size;
                 }
                 res = rind * subvect_size;
                 if (sign > 0)
                 {
                     for (m = 0; m < subvect_size; m++)
                     {
                         t[offset + m] -= resp[res + m];
                     }
                 }
                 else
                 {
                     for (m = 0; m < subvect_size; m++)
                     {
                         t[offset + m] += resp[res + m];
                     }
                 }
                 err = odist[j];
                 for (m = offset; m < offset + subvect_size; m++)
                 {
                     err += t[m] * t[m];
                 }
                 if (err < ndist[N - 1] || ndist[N - 1] < -0.5f)
                 {
                     for (m = offset + subvect_size; m < nsf; m++)
                     {
                         t[m] = ct[m];
                     }
                     for (m = 0; m < subvect_size; m++)
                     {
                         float g;
                         //int rind;
                         //float sign = 1;
                         sign = 1;
                         rind = best_index[k];
                         if (rind >= shape_cb_size)
                         {
                             sign = -1;
                             rind -= shape_cb_size;
                         }
                         g = sign * 0.03125f * shape_cb[rind * subvect_size + m];
                         q = subvect_size - m;
                         for (n = offset + subvect_size; n < nsf; n++, q++)
                         {
                             t[n] -= g * r[q];
                         }
                     }
                     for (m = 0; m < N; m++)
                     {
                         if (err < ndist[m] || ndist[m] < -0.5f)
                         {
                             for (n = N - 1; n > m; n--)
                             {
                                 for (q = offset + subvect_size; q < nsf; q++)
                                 {
                                     nt[n][q] = nt[n - 1][q];
                                 }
                                 for (q = 0; q < nb_subvect; q++)
                                 {
                                     nind[n][q] = nind[n - 1][q];
                                 }
                                 ndist[n] = ndist[n - 1];
                             }
                             for (q = offset + subvect_size; q < nsf; q++)
                             {
                                 nt[m][q] = t[q];
                             }
                             for (q = 0; q < nb_subvect; q++)
                             {
                                 nind[m][q] = oind[j][q];
                             }
                             nind[m][i] = best_index[k];
                             ndist[m] = err;
                             break;
                         }
                     }
                 }
             }
             if (i == 0)
             {
                 break;
             }
         }
         float[][] tmp2;
         tmp2 = ot;
         ot = nt;
         nt = tmp2;
         for (j = 0; j < N; j++)
         {
             for (m = 0; m < nb_subvect; m++)
             {
                 oind[j][m] = nind[j][m];
             }
         }
         for (j = 0; j < N; j++)
         {
             odist[j] = ndist[j];
         }
     }
     for (i = 0; i < nb_subvect; i++)
     {
         ind[i] = nind[0][i];
         bits.pack(ind[i], shape_bits + have_sign);
     }
     for (i = 0; i < nb_subvect; i++)
     {
         int rind;
         float sign = 1;
         rind = ind[i];
         if (rind >= shape_cb_size)
         {
             sign = -1;
             rind -= shape_cb_size;
         }
         for (j = 0; j < subvect_size; j++)
         {
             e[subvect_size * i + j] = sign * 0.03125f * shape_cb[rind * subvect_size + j];
         }
     }
     for (j = 0; j < nsf; j++)
     {
         exc[es + j] += e[j];
     }
     org.xiph.speex.Filters.syn_percep_zero(e, 0, ak, awk1, awk2, r2, nsf, p);
     for (j = 0; j < nsf; j++)
     {
         target[j] -= r2[j];
     }
 }
示例#5
0
 /// <summary>Encode the given input signal.</summary>
 /// <remarks>Encode the given input signal.</remarks>
 /// <param name="bits">- Speex bits buffer.</param>
 /// <param name="in">- the raw mono audio frame to encode.</param>
 /// <returns>return 1 if successful.</returns>
 public virtual int encode(org.xiph.speex.Bits bits, float[] @in)
 {
     int i;
     float[] res;
     float[] target;
     float[] mem;
     float[] syn_resp;
     float[] orig;
     float ener; //TODO: Check
     System.Array.Copy(frmBuf, frameSize, frmBuf, 0, bufSize - frameSize);
     frmBuf[bufSize - frameSize] = @in[0] - preemph * pre_mem;
     for (i = 1; i < frameSize; i++)
     {
         frmBuf[bufSize - frameSize + i] = @in[i] - preemph * @in[i - 1];
     }
     pre_mem = @in[frameSize - 1];
     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);
     for (i = 0; i < windowSize; i++)
     {
         buf2[i] = frmBuf[i + frmIdx] * window[i];
     }
     org.xiph.speex.Lpc.autocorr(buf2, autocorr, lpcSize + 1, windowSize);
     autocorr[0] += 10;
     autocorr[0] *= lpc_floor;
     for (i = 0; i < lpcSize + 1; i++)
     {
         autocorr[i] *= lagWindow[i];
     }
     org.xiph.speex.Lpc.wld(lpc, autocorr, rc, lpcSize);
     // tmperr
     System.Array.Copy(lpc, 0, lpc, 1, lpcSize);
     lpc[0] = 1;
     int roots = org.xiph.speex.Lsp.lpc2lsp(lpc, lpcSize, lsp, 15, 0.2f);
     if (roots == lpcSize)
     {
         for (i = 0; i < lpcSize; i++)
         {
             lsp[i] = (float)System.Math.Acos(lsp[i]);
         }
     }
     else
     {
         if (complexity > 1)
         {
             roots = org.xiph.speex.Lsp.lpc2lsp(lpc, lpcSize, lsp, 11, 0.05f);
         }
         if (roots == lpcSize)
         {
             for (i = 0; i < lpcSize; i++)
             {
                 lsp[i] = (float)System.Math.Acos(lsp[i]);
             }
         }
         else
         {
             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]);
     }
     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];
         }
     }
     org.xiph.speex.Lsp.enforce_margin(interp_lsp, lpcSize, .002f);
     for (i = 0; i < lpcSize; i++)
     {
         interp_lsp[i] = (float)System.Math.Cos(interp_lsp[i]);
     }
     m_lsp.lsp2lpc(interp_lsp, interp_lpc, lpcSize);
     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];
         org.xiph.speex.Filters.bw_lpc(gamma1, interp_lpc, bw_lpc1, lpcSize);
         org.xiph.speex.Filters.bw_lpc(gamma2, interp_lpc, bw_lpc2, lpcSize);
         org.xiph.speex.Filters.filter_mem2(frmBuf, frmIdx, bw_lpc1, bw_lpc2, swBuf, swIdx
             , frameSize, lpcSize, mem_sw_whole, 0);
         org.xiph.speex.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];
         for (i = 1; i < 6; i++)
         {
             if ((nol_pitch_coef[i] > .85f * ol_pitch_coef) && (System.Math.Abs(nol_pitch[i] -
                  ol_pitch / 2.0f) <= 1 || System.Math.Abs(nol_pitch[i] - ol_pitch / 3.0f) <= 1 ||
                  System.Math.Abs(nol_pitch[i] - ol_pitch / 4.0f) <= 1 || System.Math.Abs(nol_pitch
                 [i] - ol_pitch / 5.0f) <= 1))
             {
                 ol_pitch = nol_pitch[i];
             }
         }
     }
     else
     {
         ol_pitch = 0;
         ol_pitch_coef = 0;
     }
     org.xiph.speex.Filters.fir_mem2(frmBuf, frmIdx, interp_lpc, excBuf, excIdx, frameSize
         , lpcSize, mem_exc);
     ol_gain = 0;
     for (i = 0; i < frameSize; i++)
     {
         ol_gain += excBuf[excIdx + i] * excBuf[excIdx + i];
     }
     ol_gain = (float)System.Math.Sqrt(1 + ol_gain / frameSize);
     if (vbr != null && (vbr_enabled != 0 || vad_enabled != 0))
     {
         if (abr_enabled != 0)
         {
             float qual_change = 0;
             if (abr_drift2 * abr_drift > 0)
             {
                 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(@in, frameSize, ol_pitch, ol_pitch_coef);
         if (vbr_enabled != 0)
         {
             int mode;
             int choice = 0;
             float min_diff = 100;
             mode = 8;
             while (mode > 0)
             {
                 int v1;
                 float thresh;
                 v1 = (int)System.Math.Floor(vbr_quality);
                 if (v1 == 10)
                 {
                     thresh = org.xiph.speex.Vbr.nb_thresh[mode][v1];
                 }
                 else
                 {
                     thresh = (vbr_quality - v1) * org.xiph.speex.Vbr.nb_thresh[mode][v1 + 1] + (1 + v1
                          - vbr_quality) * org.xiph.speex.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;
             }
             setMode(mode);
             if (abr_enabled != 0)
             {
                 int bitrate;
                 bitrate = getBitRate();
                 abr_drift += (bitrate - abr_enabled);
                 abr_drift2 = .95f * abr_drift2 + .05f * (bitrate - abr_enabled);
                 abr_count += 1.0f;
             }
         }
         else
         {
             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;
             }
             submodeID = mode;
         }
     }
     else
     {
         relative_quality = -1;
     }
     bits.pack(0, 1);
     bits.pack(submodeID, NB_SUBMODE_BITS);
     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;
         org.xiph.speex.Filters.iir_mem2(excBuf, excIdx, interp_qlpc, frmBuf, frmIdx, frameSize
             , lpcSize, mem_sp);
         @in[0] = frmBuf[frmIdx] + preemph * pre_mem2;
         for (i = 1; i < frameSize; i++)
         {
             @in[i] = frmBuf[frmIdx + i] + preemph * @in[i - 1];
         }
         pre_mem2 = @in[frameSize - 1];
         return 0;
     }
     if (first != 0)
     {
         for (i = 0; i < lpcSize; i++)
         {
             old_lsp[i] = lsp[i];
         }
     }
     //#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 (submodes[submodeID].lbr_pitch != -1)
     {
         bits.pack(ol_pitch - min_pitch, 7);
     }
     if (submodes[submodeID].forced_pitch_gain != 0)
     {
         int quant;
         quant = (int)System.Math.Floor(.5f + 15 * ol_pitch_coef);
         if (quant > 15)
         {
             quant = 15;
         }
         if (quant < 0)
         {
             quant = 0;
         }
         bits.pack(quant, 4);
         ol_pitch_coef = (float)0.066667f * quant;
     }
     int qe = (int)(System.Math.Floor(0.5 + 3.5 * System.Math.Log(ol_gain)));
     if (qe < 0)
     {
         qe = 0;
     }
     if (qe > 31)
     {
         qe = 31;
     }
     ol_gain = (float)System.Math.Exp(qe / 3.5);
     bits.pack(qe, 5);
     if (first != 0)
     {
         for (i = 0; i < lpcSize; i++)
         {
             old_qlsp[i] = qlsp[i];
         }
     }
     res = new float[subframeSize];
     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];
     }
     for (int sub = 0; sub < nbSubframes; sub++)
     {
         float tmp;
         int offset;
         int sp;
         int sw;
         int exc;
         int exc2;
         int pitchval;
         offset = subframeSize * sub;
         sp = frmIdx + offset;
         exc = excIdx + offset;
         sw = swIdx + offset;
         exc2 = exc2Idx + offset;
         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];
         }
         org.xiph.speex.Lsp.enforce_margin(interp_lsp, lpcSize, .002f);
         org.xiph.speex.Lsp.enforce_margin(interp_qlsp, lpcSize, .002f);
         for (i = 0; i < lpcSize; i++)
         {
             interp_lsp[i] = (float)System.Math.Cos(interp_lsp[i]);
         }
         m_lsp.lsp2lpc(interp_lsp, interp_lpc, lpcSize);
         for (i = 0; i < lpcSize; i++)
         {
             interp_qlsp[i] = (float)System.Math.Cos(interp_qlsp[i]);
         }
         m_lsp.lsp2lpc(interp_qlsp, interp_qlpc, lpcSize);
         tmp = 1;
         pi_gain[sub] = 0;
         for (i = 0; i <= lpcSize; i++)
         {
             pi_gain[sub] += tmp * interp_qlpc[i];
             tmp = -tmp;
         }
         org.xiph.speex.Filters.bw_lpc(gamma1, interp_lpc, bw_lpc1, lpcSize);
         if (gamma2 >= 0)
         {
             org.xiph.speex.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;
             }
         }
         for (i = 0; i < subframeSize; i++)
         {
             excBuf[exc + i] = VERY_SMALL;
         }
         excBuf[exc] = 1;
         org.xiph.speex.Filters.syn_percep_zero(excBuf, exc, interp_qlpc, bw_lpc1, bw_lpc2
             , syn_resp, subframeSize, lpcSize);
         for (i = 0; i < subframeSize; i++)
         {
             excBuf[exc + i] = VERY_SMALL;
         }
         for (i = 0; i < subframeSize; i++)
         {
             exc2Buf[exc2 + i] = VERY_SMALL;
         }
         for (i = 0; i < lpcSize; i++)
         {
             mem[i] = mem_sp[i];
         }
         org.xiph.speex.Filters.iir_mem2(excBuf, exc, interp_qlpc, excBuf, exc, subframeSize
             , lpcSize, mem);
         for (i = 0; i < lpcSize; i++)
         {
             mem[i] = mem_sw[i];
         }
         org.xiph.speex.Filters.filter_mem2(excBuf, exc, bw_lpc1, bw_lpc2, res, 0, subframeSize
             , lpcSize, mem, 0);
         for (i = 0; i < lpcSize; i++)
         {
             mem[i] = mem_sw[i];
         }
         org.xiph.speex.Filters.filter_mem2(frmBuf, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize
             , lpcSize, mem, 0);
         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 (submodes[submodeID].ltp.quant)
         //    {
         int pit_min;
         int pit_max;
         if (submodes[submodeID].lbr_pitch != -1)
         {
             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;
         }
         if (bounded_pitch != 0 && pit_max > offset)
         {
             pit_max = offset;
         }
         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");
         //    }
         org.xiph.speex.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];
         }
         int innovptr;
         //float ener = 0;
         ener = 0;
         float ener_1;
         innovptr = sub * subframeSize;
         for (i = 0; i < subframeSize; i++)
         {
             innov[innovptr + i] = 0;
         }
         org.xiph.speex.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)System.Math.Sqrt(.1f + ener / subframeSize);
         ener /= ol_gain;
         if (submodes[submodeID].have_subframe_gain != 0)
         {
             //int qe;
             ener = (float)System.Math.Log(ener);
             if (submodes[submodeID].have_subframe_gain == 3)
             {
                 qe = org.xiph.speex.VQ.index(ener, exc_gain_quant_scal3, 8);
                 bits.pack(qe, 3);
                 ener = exc_gain_quant_scal3[qe];
             }
             else
             {
                 qe = org.xiph.speex.VQ.index(ener, exc_gain_quant_scal1, 2);
                 bits.pack(qe, 1);
                 ener = exc_gain_quant_scal1[qe];
             }
             ener = (float)System.Math.Exp(ener);
         }
         else
         {
             ener = 1f;
         }
         ener *= ol_gain;
         ener_1 = 1 / ener;
         for (i = 0; i < subframeSize; i++)
         {
             target[i] *= ener_1;
         }
         //      if (submodes[submodeID].innovation != null)
         //      {
         submodes[submodeID].innovation.quant(target, interp_qlpc, bw_lpc1, bw_lpc2, lpcSize
             , subframeSize, innov, innovptr, syn_resp, bits, complexity);
         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");
         //      }
         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;
         }
         for (i = 0; i < lpcSize; i++)
         {
             mem[i] = mem_sp[i];
         }
         org.xiph.speex.Filters.iir_mem2(excBuf, exc, interp_qlpc, frmBuf, sp, subframeSize
             , lpcSize, mem_sp);
         org.xiph.speex.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];
         }
     }
     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);
         }
     }
     first = 0;
     //float ener = 0;
     ener = 0;
     float 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");
     @in[0] = frmBuf[frmIdx] + preemph * pre_mem2;
     for (i = 1; i < frameSize; i++)
     {
         @in[i] = frmBuf[frmIdx + i] + preemph * @in[i - 1];
     }
     pre_mem2 = @in[frameSize - 1];
     if (submodes[submodeID].innovation is org.xiph.speex.NoiseSearch || submodeID ==
         0)
     {
         bounded_pitch = 1;
     }
     else
     {
         bounded_pitch = 0;
     }
     return 1;
 }
示例#6
0
 /// <summary>Long Term Prediction Quantification (3Tap).</summary>
 /// <remarks>Long Term Prediction Quantification (3Tap).</remarks>
 /// <returns>pitch</returns>
 public override sealed int quant(float[] target, float[] sw, int sws, float[] ak, 
     float[] awk1, float[] awk2, float[] exc, int es, int start, int end, float pitch_coef
     , int p, int nsf, org.xiph.speex.Bits bits, float[] exc2, int e2s, float[] r, int
     complexity)
 {
     int i;
     int j;
     int[] cdbk_index = new int[1];
     int pitch = 0;
     int best_gain_index = 0;
     float[] best_exc;
     int best_pitch = 0;
     float err;
     float best_err = -1;
     int N;
     int[] nbest;
     float[] gains;
     N = complexity;
     if (N > 10)
     {
         N = 10;
     }
     nbest = new int[N];
     gains = new float[N];
     if (N == 0 || end < start)
     {
         bits.pack(0, pitch_bits);
         bits.pack(0, gain_bits);
         for (i = 0; i < nsf; i++)
         {
             exc[es + i] = 0;
         }
         return start;
     }
     best_exc = new float[nsf];
     if (N > end - start + 1)
     {
         N = end - start + 1;
     }
     open_loop_nbest_pitch(sw, sws, start, end, nsf, nbest, gains, N);
     for (i = 0; i < N; i++)
     {
         pitch = nbest[i];
         for (j = 0; j < nsf; j++)
         {
             exc[es + j] = 0;
         }
         err = pitch_gain_search_3tap(target, ak, awk1, awk2, exc, es, pitch, p, nsf, bits
             , exc2, e2s, r, cdbk_index);
         if (err < best_err || best_err < 0)
         {
             for (j = 0; j < nsf; j++)
             {
                 best_exc[j] = exc[es + j];
             }
             best_err = err;
             best_pitch = pitch;
             best_gain_index = cdbk_index[0];
         }
     }
     bits.pack(best_pitch - start, pitch_bits);
     bits.pack(best_gain_index, gain_bits);
     for (i = 0; i < nsf; i++)
     {
         exc[es + i] = best_exc[i];
     }
     return pitch;
 }
示例#7
0
 /// <summary>Encode the given input signal.</summary>
 /// <remarks>Encode the given input signal.</remarks>
 /// <param name="bits">- Speex bits buffer.</param>
 /// <param name="in">- the raw mono audio frame to encode.</param>
 /// <returns>1 if successful.</returns>
 public virtual int encode(org.xiph.speex.Bits bits, float[] @in)
 {
     int i;
     float[] mem;
     float[] innov;
     float[] syn_resp;
     float[] low_pi_gain;
     float[] low_exc;
     float[] low_innov;
     int dtx;
     org.xiph.speex.Filters.qmf_decomp(@in, h0, x0d, x1d, fullFrameSize, QMF_ORDER, h0_mem
         );
     lowenc.encode(bits, x0d);
     for (i = 0; i < windowSize - frameSize; i++)
     {
         high[i] = high[frameSize + i];
     }
     for (i = 0; i < frameSize; i++)
     {
         high[windowSize - frameSize + i] = x1d[i];
     }
     System.Array.Copy(excBuf, frameSize, excBuf, 0, bufSize - frameSize);
     low_pi_gain = lowenc.getPiGain();
     low_exc = lowenc.getExc();
     low_innov = lowenc.getInnov();
     int low_mode = lowenc.getMode();
     if (low_mode == 0)
     {
         dtx = 1;
     }
     else
     {
         dtx = 0;
     }
     for (i = 0; i < windowSize; i++)
     {
         buf[i] = high[i] * window[i];
     }
     org.xiph.speex.Lpc.autocorr(buf, autocorr, lpcSize + 1, windowSize);
     autocorr[0] += 1;
     autocorr[0] *= lpc_floor;
     for (i = 0; i < lpcSize + 1; i++)
     {
         autocorr[i] *= lagWindow[i];
     }
     org.xiph.speex.Lpc.wld(lpc, autocorr, rc, lpcSize);
     // tmperr
     System.Array.Copy(lpc, 0, lpc, 1, lpcSize);
     lpc[0] = 1;
     int roots = org.xiph.speex.Lsp.lpc2lsp(lpc, lpcSize, lsp, 15, 0.2f);
     if (roots != lpcSize)
     {
         roots = org.xiph.speex.Lsp.lpc2lsp(lpc, lpcSize, lsp, 11, 0.02f);
         if (roots != lpcSize)
         {
             for (i = 0; i < lpcSize; i++)
             {
                 lsp[i] = (float)System.Math.Cos(System.Math.PI * ((float)(i + 1)) / (lpcSize + 1)
                     );
             }
         }
     }
     for (i = 0; i < lpcSize; i++)
     {
         lsp[i] = (float)System.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]);
     }
     if ((vbr_enabled != 0 || vad_enabled != 0) && dtx == 0)
     {
         float e_low = 0;
         float e_high = 0;
         float ratio;
         if (abr_enabled != 0)
         {
             float qual_change = 0;
             if (abr_drift2 * abr_drift > 0)
             {
                 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)System.Math.Log((1 + e_high) / (1 + e_low));
         relative_quality = lowenc.getRelativeQuality();
         if (ratio < -4)
         {
             ratio = -4;
         }
         if (ratio > 2)
         {
             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)System.Math.Floor(vbr_quality);
                 if (v1 == 10)
                 {
                     thresh = org.xiph.speex.Vbr.hb_thresh[modeid][v1];
                 }
                 else
                 {
                     thresh = (vbr_quality - v1) * org.xiph.speex.Vbr.hb_thresh[modeid][v1 + 1] + (1 +
                          v1 - vbr_quality) * org.xiph.speex.Vbr.hb_thresh[modeid][v1];
                 }
                 if (relative_quality >= thresh)
                 {
                     break;
                 }
                 modeid--;
             }
             setMode(modeid);
             if (abr_enabled != 0)
             {
                 int bitrate;
                 bitrate = getBitRate();
                 abr_drift += (bitrate - abr_enabled);
                 abr_drift2 = .95f * abr_drift2 + .05f * (bitrate - abr_enabled);
                 abr_count += 1.0f;
             }
         }
         else
         {
             int modeid;
             if (relative_quality < 2.0)
             {
                 modeid = 1;
             }
             else
             {
                 modeid = submodeSelect;
             }
             submodeID = modeid;
         }
     }
     bits.pack(1, 1);
     if (dtx != 0)
     {
         bits.pack(0, SB_SUBMODE_BITS);
     }
     else
     {
         bits.pack(submodeID, SB_SUBMODE_BITS);
     }
     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;
         org.xiph.speex.Filters.iir_mem2(excBuf, excIdx, interp_qlpc, high, 0, subframeSize
             , lpcSize, mem_sp);
         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++)
         {
             @in[i] = 2 * (y0[i] - y1[i]);
         }
         if (dtx != 0)
         {
             return 0;
         }
         else
         {
             return 1;
         }
     }
     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;
         float filter_ratio;
         int exc;
         int sp;
         int sw;
         int resp;
         int offset;
         float rl;
         float rh;
         float eh = 0;
         float el = 0;
         //      int fold;
         offset = subframeSize * sub;
         sp = offset;
         exc = excIdx + offset;
         resp = offset;
         sw = offset;
         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];
         }
         org.xiph.speex.Lsp.enforce_margin(interp_lsp, lpcSize, .05f);
         org.xiph.speex.Lsp.enforce_margin(interp_qlsp, lpcSize, .05f);
         for (i = 0; i < lpcSize; i++)
         {
             interp_lsp[i] = (float)System.Math.Cos(interp_lsp[i]);
         }
         for (i = 0; i < lpcSize; i++)
         {
             interp_qlsp[i] = (float)System.Math.Cos(interp_qlsp[i]);
         }
         m_lsp.lsp2lpc(interp_lsp, interp_lpc, lpcSize);
         m_lsp.lsp2lpc(interp_qlsp, interp_qlpc, lpcSize);
         org.xiph.speex.Filters.bw_lpc(gamma1, interp_lpc, bw_lpc1, lpcSize);
         org.xiph.speex.Filters.bw_lpc(gamma2, interp_lpc, bw_lpc2, lpcSize);
         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 / (System.Math.Abs(rl) + .01f);
         rh = 1 / (System.Math.Abs(rh) + .01f);
         filter_ratio = System.Math.Abs(.01f + rh) / (.01f + System.Math.Abs(rl));
         //      fold = filter_ratio<5 ? 1 : 0;
         //      fold=0;
         org.xiph.speex.Filters.fir_mem2(high, sp, interp_qlpc, excBuf, exc, subframeSize,
             lpcSize, mem_sp2);
         for (i = 0; i < subframeSize; i++)
         {
             eh += excBuf[exc + i] * excBuf[exc + i];
         }
         if (submodes[submodeID].innovation == null)
         {
             float g;
             for (i = 0; i < subframeSize; i++)
             {
                 el += low_innov[offset + i] * low_innov[offset + i];
             }
             g = eh / (.01f + el);
             g = (float)System.Math.Sqrt(g);
             g *= filter_ratio;
             int quant = (int)System.Math.Floor(.5 + 10 + 8.0 * System.Math.Log((g + .0001)));
             if (quant < 0)
             {
                 quant = 0;
             }
             if (quant > 31)
             {
                 quant = 31;
             }
             bits.pack(quant, 5);
             g = (float)(.1 * System.Math.Exp(quant / 9.4));
             g /= filter_ratio;
         }
         else
         {
             float gc;
             float scale;
             float scale_1;
             for (i = 0; i < subframeSize; i++)
             {
                 el += low_exc[offset + i] * low_exc[offset + i];
             }
             gc = (float)(System.Math.Sqrt(1 + eh) * filter_ratio / System.Math.Sqrt((1 + el)
                 * subframeSize));
             int qgc = (int)System.Math.Floor(.5 + 3.7 * (System.Math.Log(gc) + 2));
             if (qgc < 0)
             {
                 qgc = 0;
             }
             if (qgc > 15)
             {
                 qgc = 15;
             }
             bits.pack(qgc, 4);
             gc = (float)System.Math.Exp((1 / 3.7) * qgc - 2);
             scale = gc * (float)System.Math.Sqrt(1 + el) / filter_ratio;
             scale_1 = 1 / scale;
             for (i = 0; i < subframeSize; i++)
             {
                 excBuf[exc + i] = 0;
             }
             excBuf[exc] = 1;
             org.xiph.speex.Filters.syn_percep_zero(excBuf, exc, interp_qlpc, bw_lpc1, bw_lpc2
                 , syn_resp, subframeSize, lpcSize);
             for (i = 0; i < subframeSize; i++)
             {
                 excBuf[exc + i] = 0;
             }
             for (i = 0; i < lpcSize; i++)
             {
                 mem[i] = mem_sp[i];
             }
             org.xiph.speex.Filters.iir_mem2(excBuf, exc, interp_qlpc, excBuf, exc, subframeSize
                 , lpcSize, mem);
             for (i = 0; i < lpcSize; i++)
             {
                 mem[i] = mem_sw[i];
             }
             org.xiph.speex.Filters.filter_mem2(excBuf, exc, bw_lpc1, bw_lpc2, res, resp, subframeSize
                 , lpcSize, mem, 0);
             for (i = 0; i < lpcSize; i++)
             {
                 mem[i] = mem_sw[i];
             }
             org.xiph.speex.Filters.filter_mem2(high, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize
                 , lpcSize, mem, 0);
             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;
             }
             for (i = 0; i < subframeSize; i++)
             {
                 innov[i] = 0;
             }
             submodes[submodeID].innovation.quant(target, interp_qlpc, bw_lpc1, bw_lpc2, lpcSize
                 , subframeSize, innov, 0, syn_resp, bits, (complexity + 1) >> 1);
             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];
                 }
             }
         }
         for (i = 0; i < lpcSize; i++)
         {
             mem[i] = mem_sp[i];
         }
         org.xiph.speex.Filters.iir_mem2(excBuf, exc, interp_qlpc, high, sp, subframeSize,
             lpcSize, mem_sp);
         org.xiph.speex.Filters.filter_mem2(high, sp, bw_lpc1, bw_lpc2, swBuf, sw, subframeSize
             , lpcSize, mem_sw, 0);
     }
     //#ifndef RELEASE
     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++)
     {
         @in[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;
 }