cod_lf.c

关于AMR-WB+语音压缩编码的实现代码

      /*---------------------------------------------------------------*
       *  Quantize ISF parameters (46 bits) every 20 ms                *
       *---------------------------------------------------------------*/
      /* Convert isps to frequency domain 0..6400 */
      E_LPC_isp_isf_conversion(&isp[(k+1)*M], isfnew, M);
      /* quantize 1st and 2nd LPC with 46 bits */
      qpisf_2s_46b(isfnew, isfnew, past_isfq_1, prm, 4);
      prm += NPRM_LPC;
      /* Convert isfs to the cosine domain */
      isf2isp(isfnew, &isp_q[(k+1)*M], M);
      /* interpol quantized lpc */
      int_lpc_np1(&isp_q[k*M], &isp_q[(k+1)*M], Aq, 4, M);
      /* lpc coefficient needed for HF extension */
      mvr2r(Aq, &AqLF[k*4*(M+1)], 5*(M+1));
      /*---------------------------------------------------------------*
       *  Call ACELP 4 subfr x 5ms = 20 ms frame                       *
       *---------------------------------------------------------------*/
      mem_w0[k+1] = mem_w0[k];
      mem_xnq[k+1] = mem_xnq[k];
      ovlp_size[k+1] = 0;
      coder_acelp(&A[k*(NB_SUBFR/4)*(M+1)],
                  Aq,
                  &speech[k*L_DIV],
                  &mem_w0[k+1],
                  &mem_xnq[k+1],
                  &synth[k*L_DIV],
                  &exc[k*L_DIV],
                  &wovlp[(k+1)*128],
                  L_DIV,
                  codec_mode,
                  norm_corr[k],
                  norm_corr2[k],
                  T_op[k],
                  T_op2[k],
                  T_out,
                  p_out,
		  st->mem_gain_code,
                  pit_adj,
                  prm);
      /* average integer pitch-lag for high band coding */
      ave_T_out[k] = (int)((T_op[k]+T_op2[k]));
      ave_p_out[k] = (p_out[0]+p_out[1]+p_out[2]+p_out[3])/4.0f;
      mem_wsyn[k+1] = mem_wsyn[k];
{
  float buf[L_FRAME_PLUS];
      find_wsp(&A[k*(NB_SUBFR/4)*(M+1)], &synth[k*L_DIV], buf, &mem_wsyn[k+1], L_DIV);
      snr = segsnr(&wsp[k*L_DIV], buf, L_DIV, L_SUBFR);
	  if (st->SwitchFlagPlusToWB) {
		snr = 100000;
		st->SwitchFlagPlusToWB = 0;
	  }
}
      mod[k] = 0;
      coding_mod[k] = 0;
      /*--------------------------------------------------*
       * Call short TCX coder and find segmental SNR       *
       *--------------------------------------------------*/
      mvr2r(&synth[(k*L_DIV)-M], synth_tcx, M);
      mem_w0_tcx = mem_w0[k];
      mem_xnq_tcx = mem_xnq[k];
      mvr2r(&wovlp[k*128], wovlp_tcx, 128);
      coder_tcx(Aq,
                &speech[k*L_DIV],
                &mem_w0_tcx, &mem_xnq_tcx,
                &synth_tcx[M],
                exc_tcx,
                wovlp_tcx,
                ovlp_size[k],
                L_DIV,
                ((nbits/4)-NBITS_LPC),
                prm_tcx);
      mem_wsyn_tcx = mem_wsyn[k];
{
  float buf[L_FRAME_PLUS];
      find_wsp(&A[k*(NB_SUBFR/4)*(M+1)], &synth_tcx[M], buf, &mem_wsyn_tcx, L_DIV);
      tmp = segsnr(&wsp[k*L_DIV], buf, L_DIV, L_SUBFR);
}
      /*--------------------------------------------------------*
       * Save tcx parameters if tcx segmental SNR is better     *
       *--------------------------------------------------------*/
      if (tmp > snr) {
        snr = tmp;
        mod[k] = 1;
        coding_mod[k] = 1;
        mem_w0[k+1] = mem_w0_tcx;
        mem_xnq[k+1] = mem_xnq_tcx;
        mem_wsyn[k+1] = mem_wsyn_tcx;
        ovlp_size[k+1] = 32;
        mvr2r(wovlp_tcx, &wovlp[(k+1)*128], 128);
        mvr2r(&synth_tcx[M], &synth[k*L_DIV], L_DIV);
        mvr2r(exc_tcx, &exc[k*L_DIV], L_DIV);
        mvi2i(prm_tcx, prm, NPRM_TCX20);
      }
      snr1 += 0.5f*snr;
    } /* end of coding mode ACELP or TCX_20MS */
    k = (i1*2);
    /* set pointer to parameters */
    prm = param + (k*NPRM_DIV);
    /*---------------------------------------------------------------*
     *  Quantize ISF parameters (46 bits) every 40 ms                *
     *---------------------------------------------------------------*/
    /* Convert isps to frequency domain 0..6400 */
    E_LPC_isp_isf_conversion(&isp[(k+2)*M], isfnew, M);
    /* quantize 1st and 2nd LPC with 46 bits */
    qpisf_2s_46b(isfnew, isfnew, past_isfq_2, prm_tcx, 4);
    /* Convert isfs to the cosine domain */
    isf2isp(isfnew, ispnew_q, M);
    /* interpol quantized lpc */
    int_lpc_np1(&isp_q[k*M], ispnew_q, Aq, (NB_SUBFR/2), M);
    /*--------------------------------------------------*
     * Call medium TCX coder and find segmental SNR       *
     *--------------------------------------------------*/
    mvr2r(&synth[(k*L_DIV)-M], synth_tcx, M);
    mem_w0_tcx = mem_w0[k];
    mem_xnq_tcx = mem_xnq[k];
    mvr2r(&wovlp[k*128], wovlp_tcx, 128);
    coder_tcx(Aq,
              &speech[k*L_DIV],
              &mem_w0_tcx, &mem_xnq_tcx,
              &synth_tcx[M],
              exc_tcx,
              wovlp_tcx,
              ovlp_size[k],
              2*L_DIV,
              ((nbits/2)-NBITS_LPC),
              prm_tcx+NPRM_LPC);
    mem_wsyn_tcx = mem_wsyn[k];
{
  float buf[L_FRAME_PLUS];
    find_wsp(&A[i1*(NB_SUBFR/2)*(M+1)], &synth_tcx[M], buf, &mem_wsyn_tcx, 2*L_DIV);
    tmp = segsnr(&wsp[k*L_DIV], buf, 2*L_DIV, L_SUBFR);
}
    /*--------------------------------------------------------*
     * Save tcx parameters if tcx segmental SNR is better     *
     *--------------------------------------------------------*/
    if (tmp > snr1) {
      snr1 = tmp;
      for (i=0; i<2; i++) {
        mod[k+i] = 2;
        coding_mod[k+i] = 2;
      }
      mvr2r(ispnew_q, &isp_q[(k+2)*M], M);
      mem_w0[k+2] = mem_w0_tcx;
      mem_xnq[k+2] = mem_xnq_tcx;
      mem_wsyn[k+2] = mem_wsyn_tcx;
      ovlp_size[k+2] = 64;
      mvr2r(past_isfq_2, past_isfq_1, M);
      mvr2r(wovlp_tcx, &wovlp[(k+2)*128], 128);
      mvr2r(&synth_tcx[M], &synth[k*L_DIV], 2*L_DIV);
      mvr2r(exc_tcx, &exc[k*L_DIV], 2*L_DIV);
      mvi2i(prm_tcx, prm, NPRM_LPC+NPRM_TCX40);
      /* lpc coefficient needed for HF extension */
      mvr2r(Aq, &AqLF[k*4*(M+1)], 9*(M+1));
    }
    snr2 += 0.5f*snr1;
  } /* end of i1 */
  k = 0;
  /* set pointer to parameters */
  prm = param + (k*NPRM_DIV);
  /*---------------------------------------------------------------*
   *  Quantize ISF parameters (46 bits) every 80 ms                *
   *---------------------------------------------------------------*/
  mvr2r(st->past_isfq, past_isfq_2, M);
  /* Convert isps to frequency domain 0..6400 */
  E_LPC_isp_isf_conversion(&isp[(k+4)*M], isfnew, M);
  /* quantize 1st and 2nd LPC with 46 bits */
  qpisf_2s_46b(isfnew, isfnew, past_isfq_2, prm_tcx, 4);
  /* Convert isfs to the cosine domain */
  isf2isp(isfnew, ispnew_q, M);
  /* interpol quantized lpc */
  int_lpc_np1(&isp_q[k*M], ispnew_q, Aq, NB_SUBFR, M);
  /*--------------------------------------------------*
   * Call long TCX coder and find segmental SNR       *
   *--------------------------------------------------*/
  mvr2r(&synth[(k*L_DIV)-M], synth_tcx, M);
  mem_w0_tcx = mem_w0[k];
  mem_xnq_tcx = mem_xnq[k];
  mvr2r(&wovlp[k*128], wovlp_tcx, 128);
  coder_tcx(Aq,
            &speech[k*L_DIV],
            &mem_w0_tcx, &mem_xnq_tcx,
            &synth_tcx[M],
            exc_tcx,
            wovlp_tcx,
            ovlp_size[k],
            4*L_DIV,
            (nbits-NBITS_LPC),
            prm_tcx+NPRM_LPC);
  mem_wsyn_tcx = mem_wsyn[k];
{
  float buf[L_FRAME_PLUS];
  find_wsp(&A[0*(NB_SUBFR/2)*(M+1)], &synth_tcx[M], buf, &mem_wsyn_tcx, 4*L_DIV);
  tmp = segsnr(&wsp[k*L_DIV], buf, 4*L_DIV, L_SUBFR);
}
  /*--------------------------------------------------------*
   * Save tcx parameters if tcx segmental SNR is better     *
   *--------------------------------------------------------*/
  if (tmp > snr2) {
    snr2 = tmp;
    for (i=0; i<4; i++) {
      mod[k+i] = 3;
      coding_mod[k+i] = 3;
    }
    mvr2r(ispnew_q, &isp_q[(k+4)*M], M);
    mem_w0[k+4] = mem_w0_tcx;
    mem_xnq[k+4] = mem_xnq_tcx;
    mem_wsyn[k+4] = mem_wsyn_tcx;
    ovlp_size[k+4] = 128;
    mvr2r(past_isfq_2, past_isfq_1, M);
        mvr2r(wovlp_tcx, &wovlp[(k+4)*128], 128);
    mvr2r(&synth_tcx[M], &synth[k*L_DIV], 4*L_DIV);
    mvr2r(exc_tcx, &exc[k*L_DIV], 4*L_DIV);
    mvi2i(prm_tcx, prm, NPRM_LPC+NPRM_TCX80);
    /* lpc coefficient needed for HF extension */
    mvr2r(Aq, &AqLF[k*4*(M+1)], 17*(M+1));
  }
  /*--------------------------------------------------*
   * Update filter memory.                            *
   *--------------------------------------------------*/
  st->old_ovlp_size = ovlp_size[NB_DIV];
  st->old_mem_w0 = mem_w0[NB_DIV];
  st->old_mem_xnq = mem_xnq[NB_DIV];
  st->old_mem_wsyn = mem_wsyn[NB_DIV];
  mvr2r(&wovlp[4*128], st->old_wovlp, 128);
  mvr2r(past_isfq_1, st->past_isfq, M);
  mvr2r(&isp_q[NB_DIV*M], st->ispold_q, M);
  /*--------------------------------------------------*
   * Update exc for next frame.                       *
   *--------------------------------------------------*/
  mvr2r(&old_exc[L_FRAME_PLUS], st->old_exc, PIT_MAX_MAX+L_INTERPOL);
  mvr2r(old_d_wsp, st->old_d_wsp, PIT_MAX_MAX/OPL_DECIM);   /* d_wsp already shifted */
  return;
}
/*--------------------------------------------------*
 * Find weighted speech (formula from AMR-WB)       *
 *--------------------------------------------------*/
void find_wsp(float A[],
              float speech[],        /* speech[-M..lg]   */
              float wsp[],           /* wsp[0..lg]       */
              float *mem_wsp,        /* memory           */
              int lg)
{
  int i_subfr;
  float *p_A, Ap[M+1];
  p_A = A;
  for (i_subfr=0; i_subfr<lg; i_subfr+=L_SUBFR) {
    E_LPC_a_weight(p_A, Ap, GAMMA1, M);
    E_UTIL_residu(Ap, &speech[i_subfr], &wsp[i_subfr], L_SUBFR);
    p_A += (M+1);
  }
  E_UTIL_deemph(wsp, TILT_FAC, lg, mem_wsp);
  return;
}