cod_main.c

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

  float *new_mono_2k = old_mono_2k + L_OLD_SPEECH_2k;
  float *mono_2k=old_mono_2k+L_TOTAL_ST_2k-L_FRAME_2k-L_A_2k-L_FDEL_2k;
  float old_chan_2k[L_TOTAL_ST_2k];
  float *new_chan_2k = old_chan_2k + L_OLD_SPEECH_2k;
  float *chan_2k=old_chan_2k+L_TOTAL_ST_2k-L_FRAME_2k-L_A_2k-L_FDEL_2k;
  float old_mono_hi[L_TOTAL_ST_hi];
  float *new_mono_hi = old_mono_hi + L_OLD_SPEECH_hi;
  float *mono_hi=old_mono_hi + L_TOTAL_ST_hi - L_FRAME_PLUS-L_A_MAX;
  float old_chan_hi[L_TOTAL_ST_hi];
  float *new_chan_hi = old_chan_hi + L_OLD_SPEECH_hi;
  float *chan_hi=old_chan_hi + L_TOTAL_ST_hi - L_FRAME_PLUS-L_A_MAX;
  /* copy memory into working space */
  mvr2r(st->old_speech, old_speech, L_OLD_SPEECH_ST);   /*528*/
  mvr2r(st->old_speech_2k, old_mono_2k, L_OLD_SPEECH_2k); /*140*/
  mvr2r(st->old_speech_hi, old_mono_hi, L_OLD_SPEECH_hi);  /*448*/
  mix_ch(sig_left,sig_right,new_speech,L_FRAME_PLUS,1.0f,1.0f);
  /* do the lo,hi band-splitting on the mono signal */
  band_split_taligned_2k(new_speech,new_mono_2k,new_mono_hi,L_FRAME_PLUS);  /*128 samples delay  @ 12k8 */
  /* copy working space into memory */
  mvr2r(old_speech+L_FRAME_PLUS, st->old_speech, L_OLD_SPEECH_ST);
  mvr2r(old_mono_2k+L_FRAME_2k, st->old_speech_2k, L_OLD_SPEECH_2k);
  mvr2r(old_mono_hi+L_FRAME_PLUS, st->old_speech_hi, L_OLD_SPEECH_hi);
  /* copy memory into working space */
  mvr2r(st->old_chan, old_speech, L_OLD_SPEECH_ST);
  mvr2r(st->old_chan_2k, old_chan_2k, L_OLD_SPEECH_2k);
  mvr2r(st->old_chan_hi, old_chan_hi, L_OLD_SPEECH_hi);
  mvr2r(sig_right, new_speech, L_FRAME_PLUS);
  /* do the lo,hi band-splitting on the mono signal */
  band_split_taligned_2k(new_speech,new_chan_2k,new_chan_hi,L_FRAME_PLUS);
  /* copy working space into memory */
  mvr2r(old_speech+L_FRAME_PLUS, st->old_chan, L_OLD_SPEECH_ST);
  mvr2r(old_chan_2k+L_FRAME_2k, st->old_chan_2k, L_OLD_SPEECH_2k);
  mvr2r(old_chan_hi+L_FRAME_PLUS, st->old_chan_hi, L_OLD_SPEECH_hi);

  if (StbrMode < 0)
  {
    init_coder_stereo_x(st);
    st->mem_stereo_ovlp_size = L_OVLP_2k;
  }
  else
    coder_stereo_x(mono_hi,chan_hi,mono_2k,chan_2k,AqLF, StbrMode,prm_stereo,fscale,st);
}
 /*--------------------------------------------------*
  * encode bits for serial stream                    *
  *--------------------------------------------------*/
  /* mode (0=ACELP 20ms, 1=TCX 20ms, 2=TCX 40ms, 3=TCX 80ms) */
  /* for 20-ms packetization, divide by 4 the 80-ms bitstream */
  nbits_pack = (NBITS_CORE[codec_mode] + NBITS_BWE)/4;
  if (StbrMode >= 0)
    nbits_pack += (StereoNbits[StbrMode] + NBITS_BWE)/4;

  for (k=0; k<NB_DIV; k++) {
    int2bin(mod[k], 2, &serial[k*nbits_pack]);
  }
  enc_prm(mod, codec_mode, param, serial, nbits_pack);
  if (StbrMode >= 0)
  {
    enc_prm_stereo_x(prm_stereo, serial, nbits_pack, NBITS_BWE, StbrMode);
    enc_prm_hf(mod, prm_hf_left, serial-NBITS_BWE/4, nbits_pack);
  }
  enc_prm_hf(mod, prm_hf_right, serial, nbits_pack);

  return(nb_samp);
}
/*-----------------------------------------------------------------*
 * Funtion  coder_amrwb_plus_mono                                  *
 *          ~~~~~~~~~~~~~~~~                                       *
 *   - Main mono coder routine.                                    *
 *                                                                 *
 *-----------------------------------------------------------------*/
int coder_amrwb_plus_mono(  /* output: number of sample processed */
  float channel_right[], /* input: used on mono and stereo       */
  int codec_mode,    /* input: AMR-WB+ mode (see cnst.h)         */
  int L_frame,       /* input: 80ms frame size                   */
  short serial[],    /* output: serial parameters                */
  Coder_State_Plus *st,    /* i/o : coder memory state                 */
  short use_case_mode,
  int fscale
)
{
  /* LPC coefficients of lower frequency */
  float AqLF[(NB_SUBFR+1)*(M+1)];
  int param[NB_DIV*NPRM_DIV];
  int prm_hf_right[NB_DIV*NPRM_BWE_DIV];
  /* vector working at fs=12.8kHz */
  float old_speech[L_TOTAL_ST];
  float old_synth[M+L_FRAME_PLUS];
  float *speech, *new_speech;
  float *synth;
  /* Scalars */
  int i, k, nbits_pack;
  int mod[NB_DIV];
  /* LTP parameters for high band */
  float ol_gain[NB_DIV];  
  int   T_out[NB_DIV];    
  float p_out[NB_DIV];    
  int nb_samp, fac_fs;
  /*ClassB parameters*/
  short excType[4];  
  int WorkLen,fac_up,fac_down;
  
  if ((L_frame-L_FRAME32k) == 0) 
  {
    fac_fs = FSCALE_DENOM*3/2;    
  }
  else 
  {
    fac_fs = fscale;              
  }
    /* 48k setting*/
  fac_up = (fac_fs<<3);
  fac_down = 180*8;       

  if (fscale != 0)
  {

#ifdef FILTER_44kHz
      if ((L_frame-(2*L_FRAME44k)) == 0)
      {
        fac_up = (fac_fs<<3);
        fac_down = 3*441;    
      }
#endif
      /*L_frame = ((L_frame_int*fac_down)+(*frac_mem))/fac_up;*/
      WorkLen = ((L_FRAME_PLUS*2*fac_down)+(st->right.decim_frac))/fac_up;
  }
  else
  {
      WorkLen = L_frame;       
  }
 /*---------------------------------------------------------------------*
  * Initialize pointers to speech vector.                               *
  *                                                                     *
  *                     20ms     20ms     20ms     20ms    >=20ms       *
  *             |----|--------|--------|--------|--------|--------|     *
  *           past sp   div1     div2     div3     div4    L_NEXT       *
  *             <--------  Total speech buffer (L_TOTAL_PLUS)  -------->     *
  *        old_speech                                                   *
  *                  <----- present frame (L_FRAME_PLUS) ----->              *
  *                  |        <------ new speech (L_FRAME_PLUS) ------->     *
  *                  |        |                                         *
  *                speech     |                                         *
  *                         new_speech                                  *
  *---------------------------------------------------------------------*/
  new_speech = old_speech + L_OLD_SPEECH_ST;
  speech     = old_speech + L_TOTAL_ST - L_FRAME_PLUS - L_A_MAX - L_BSP;
  synth      = old_synth + M;
 /*-----------------------------------------------------------------*
  * MONO/STEREO signal downsampling (codec working at 6.4kHz)       *
  * - decimate signal to fs=12.8kHz                                 *
  * - Perform 50Hz HP filtering of signal at fs=12.8kHz.            *
  * - Perform fixed preemphasis through 1 - g z^-1                  *
  * - Mix left and right channels into sum and difference signals   *
  * - perform parametric stereo encoding                            *
  *-----------------------------------------------------------------*/
  if (fscale == 0)
  {
    decim_12k8(channel_right, L_frame, new_speech, st->right.mem_decim, 0);
    nb_samp = L_frame;
  }
  else
  {
    
    nb_samp = decim_split_12k8(channel_right, L_frame, new_speech, channel_right,
                    L_FRAME_PLUS, fac_fs, 
                     fac_up,
                     fac_down,
                     WorkLen,
                    st->right.mem_decim, &(st->right.decim_frac));
  }
  hp50_12k8(new_speech, L_FRAME_PLUS, st->right.mem_sig_in, fscale);
 /*------------------------------------------------------------*
  * Encode MONO low frequency band using ACELP/TCX model       *
  *------------------------------------------------------------*/
  /* Apply preemphasis (for core codec only */
  E_UTIL_f_preemph(new_speech, PREEMPH_FAC, L_FRAME_PLUS, &(st->right.mem_preemph));
  /* copy memory into working space */
  mvr2r(st->old_speech_pe, old_speech, L_OLD_SPEECH_ST);
  mvr2r(st->old_synth, old_synth, M);
  if (use_case_mode == USE_CASE_B) {
    for(i=0;i<4;i++){
      st->stClass->vadFlag[i] = wb_vad(st->vadSt, &new_speech[256*i]);
      if (st->stClass->vadFlag[i] == 0){
        st->vad_hist++;
      }	 
      else {
        st->vad_hist = 0;
      }
      excType[i] = (short)(classifyExcitation(st->stClass, st->vadSt->level, (short)i));
    }
    /* encode mono lower band */
    coder_lf_b(codec_mode, speech, synth, mod, AqLF, st->window, param, 
               ol_gain, T_out, p_out, excType, fscale, st);
  } 
  else {
    for (i=0;i<4;i++) {
      excType[i] = 0;
    }
    /* encode mono lower band */
    coder_lf(codec_mode, speech, synth, mod, AqLF, st->window, param, 
             ol_gain, T_out, p_out, excType, fscale, st);
  }
  for(i=0;i<4;i++){ 
    mod[i] = excType[i];
  }
  st->prev_mod = (short)mod[3];
  /* update lower band memory for next frame */
  mvr2r(&old_speech[L_FRAME_PLUS], st->old_speech_pe, L_OLD_SPEECH_ST);
  mvr2r(&old_synth[L_FRAME_PLUS], st->old_synth, M);
 /*------------------------------------------------------------*
  * MONO/STEREO Bandwidth extension (2 channels used in stereo)*
  * - fold and decimate higher band into new_speech_hf         *
  *   (2000Hz..6400Hz <-- 6400Hz..10800 Hz)                    *
  * - encode HF using 0.8kbps per channel.                     *
  *------------------------------------------------------------*/
  if (L_frame > L_FRAME8k)
  {
    float old_speech_hf[L_TOTAL_ST];
    float *new_speech_hf, *speech_hf;
    float *syn_hf = old_synth; 
    new_speech_hf = old_speech_hf + L_OLD_SPEECH_ST;
    speech_hf     = old_speech_hf + L_TOTAL_ST - L_FRAME_PLUS - L_A_MAX - L_BSP;
    mvr2r(st->right.old_speech_hf, old_speech_hf, L_OLD_SPEECH_ST);
    if (fscale == 0)
    {
      decim_12k8(channel_right, L_frame, new_speech_hf, st->right.mem_decim_hf, (fscale == 0)?1:2);
    }
    else
    {
      /* HF was stored into channel_right */
      mvr2r(channel_right, new_speech_hf, L_FRAME_PLUS);
    }
    mvr2r(&old_speech_hf[L_FRAME_PLUS], st->right.old_speech_hf, L_OLD_SPEECH_ST);
    coder_hf(mod, AqLF, speech, speech_hf, syn_hf, st->window, prm_hf_right, fscale, &(st->right));
  } else {
    for (k=0; k<NB_DIV*NPRM_BWE_DIV; k++) {
      prm_hf_right[k] = 0;
    }
  }
 /*--------------------------------------------------*
  * encode bits for serial stream                    *
  *--------------------------------------------------*/
  /* mode (0=ACELP 20ms, 1=TCX 20ms, 2=TCX 40ms, 3=TCX 80ms) */
  /* for 20-ms packetization, divide by 4 the 80-ms bitstream */
  nbits_pack = (NBITS_CORE[codec_mode] + NBITS_BWE)/4;
  for (k=0; k<NB_DIV; k++) {
    int2bin(mod[k], 2, &serial[k*nbits_pack]);
  }
  enc_prm(mod, codec_mode, param, serial, nbits_pack);
  enc_prm_hf(mod, prm_hf_right, serial, nbits_pack);
  return(nb_samp);
}