cod_ld8k.c

具有浮点指令的g.729语音压缩编码

/* ITU-T G.729 Software Package Release 2 (November 2006) */
/*
   ITU-T G.729 Annex C - Reference C code for floating point
                         implementation of G.729
                         Version 1.01 of 15.September.98
*/

/*
----------------------------------------------------------------------
                    COPYRIGHT NOTICE
----------------------------------------------------------------------
   ITU-T G.729 Annex C ANSI C source code
   Copyright (C) 1998, AT&T, France Telecom, NTT, University of
   Sherbrooke.  All rights reserved.

----------------------------------------------------------------------
*/

/*
 File : COD_LD8K.C
 Used for the floating point version of G.729 main body
 (not for G.729A)
*/

/*-----------------------------------------------------------------*
 *   Functions coder_ld8k and init_coder_ld8k                      *
 *             ~~~~~~~~~~     ~~~~~~~~~~~~~~~                      *
 *-----------------------------------------------------------------*/

#include "typedef.h"
#include "ld8k.h"

/*-----------------------------------------------------------*
 *    Coder constant parameters (defined in "ld8k.h")        *
 *-----------------------------------------------------------*
 *   L_WINDOW    : LPC analysis window size.                 *
 *   L_NEXT      : Samples of next frame needed for autocor. *
 *   L_FRAME     : Frame size.                               *
 *   L_SUBFR     : Sub-frame size.                           *
 *   M           : LPC order.                                *
 *   MP1         : LPC order+1                               *
 *   L_TOTAL     : Total size of speech buffer.              *
 *   PIT_MIN     : Minimum pitch lag.                        *
 *   PIT_MAX     : Maximum pitch lag.                        *
 *   L_INTERPOL  : Length of filter for interpolation        *
 *-----------------------------------------------------------*/


 /*--------------------------------------------------------*
  *         Static memory allocation.                      *
  *--------------------------------------------------------*/

        /* Speech vector */

static FLOAT old_speech[L_TOTAL];
static FLOAT *speech, *p_window;
FLOAT  *new_speech;                       /* Global variable */

                /* Weighted speech vector */

static FLOAT old_wsp[L_FRAME+PIT_MAX];
static FLOAT *wsp;

                /* Excitation vector */

static FLOAT old_exc[L_FRAME+PIT_MAX+L_INTERPOL];
static FLOAT *exc;

        /* Zero vector */

static FLOAT ai_zero[L_SUBFR+MP1];
static FLOAT *zero;


                /* Lsp (Line spectral pairs) */
static FLOAT lsp_old[M]=
     { (F)0.9595,  (F)0.8413,  (F)0.6549,  (F)0.4154,  (F)0.1423,
      (F)-0.1423, (F)-0.4154, (F)-0.6549, (F)-0.8413, (F)-0.9595};
static FLOAT lsp_old_q[M];

        /* Filter's memory */

static FLOAT mem_syn[M], mem_w0[M], mem_w[M];
static FLOAT mem_err[M+L_SUBFR], *error;

static FLOAT sharp;

/*----------------------------------------------------------------------------
 * init_coder_ld8k - initialization of variables for the encoder
 *----------------------------------------------------------------------------
 */
void init_coder_ld8k(void)
{
  /*-----------------------------------------------------------------------*
   *      Initialize pointers to speech vector.                            *
   *                                                                       *
   *                                                                       *
   *   |--------------------|-------------|-------------|------------|     *
   *     previous speech           sf1           sf2         L_NEXT        *
   *                                                                       *
   *   <----------------  Total speech vector (L_TOTAL)   ----------->     *
   *   |   <------------  LPC analysis window (L_WINDOW)  ----------->     *
   *   |   |               <-- present frame (L_FRAME) -->                 *
   * old_speech            |              <-- new speech (L_FRAME) -->     *
   *     p_wind            |              |                                *
   *                     speech           |                                *
   *                             new_speech                                *
   *-----------------------------------------------------------------------*/

  new_speech = old_speech + L_TOTAL - L_FRAME;         /* New speech     */
  speech     = new_speech - L_NEXT;                    /* Present frame  */
  p_window   = old_speech + L_TOTAL - L_WINDOW;        /* For LPC window */

  /* Initialize static pointers */

  wsp    = old_wsp + PIT_MAX;
  exc    = old_exc + PIT_MAX + L_INTERPOL;
  zero   = ai_zero + MP1;
  error  = mem_err + M;

  /* Static vectors to zero */

  set_zero(old_speech, L_TOTAL);
  set_zero(old_exc, PIT_MAX+L_INTERPOL);
  set_zero(old_wsp, PIT_MAX);
  set_zero(mem_syn, M);
  set_zero(mem_w,   M);
  set_zero(mem_w0,  M);
  set_zero(mem_err, M);
  set_zero(zero, L_SUBFR);
  sharp = SHARPMIN;

  /* Initialize lsp_old_q[] */
  copy(lsp_old, lsp_old_q, M);

  lsp_encw_reset();
  init_exc_err();

 return;
}

/*----------------------------------------------------------------------------
 * coder_ld8k - encoder routine ( speech data should be in new_speech )
 *----------------------------------------------------------------------------
 */
void coder_ld8k(
 int ana[]             /* output: analysis parameters */
)
{
  /* LPC coefficients */
  FLOAT r[MP1];                /* Autocorrelations low and hi          */
  FLOAT A_t[(MP1)*2];          /* A(z) unquantized for the 2 subframes */
  FLOAT Aq_t[(MP1)*2];         /* A(z)   quantized for the 2 subframes */
  FLOAT Ap1[MP1];              /* A(z) with spectral expansion         */
  FLOAT Ap2[MP1];              /* A(z) with spectral expansion         */
  FLOAT *A, *Aq;               /* Pointer on A_t and Aq_t              */

  /* LSP coefficients */
  FLOAT lsp_new[M], lsp_new_q[M]; /* LSPs at 2th subframe                 */
  FLOAT lsf_int[M];               /* Interpolated LSF 1st subframe.       */
  FLOAT lsf_new[M];

  /* Variable added for adaptive gamma1 and gamma2 of the PWF */

  FLOAT rc[M];                        /* Reflection coefficients */
  FLOAT gamma1[2];             /* Gamma1 for 1st and 2nd subframes */
  FLOAT gamma2[2];             /* Gamma2 for 1st and 2nd subframes */

  /* Other vectors */
  FLOAT synth[L_FRAME];        /* Buffer for synthesis speech        */
  FLOAT h1[L_SUBFR];           /* Impulse response h1[]              */
  FLOAT xn[L_SUBFR];           /* Target vector for pitch search     */
  FLOAT xn2[L_SUBFR];          /* Target vector for codebook search  */
  FLOAT code[L_SUBFR];         /* Fixed codebook excitation          */
  FLOAT y1[L_SUBFR];           /* Filtered adaptive excitation       */
  FLOAT y2[L_SUBFR];           /* Filtered fixed codebook excitation */
  FLOAT g_coeff[5];            /* Correlations between xn, y1, & y2:
                                  <y1,y1>, <xn,y1>, <y2,y2>, <xn,y2>,<y1,y2>*/

  /* Scalars */

  int   i, j, i_gamma, i_subfr;
  int   T_op, t0, t0_min, t0_max, t0_frac;
  int   index, taming;
  FLOAT gain_pit, gain_code;

/*------------------------------------------------------------------------*
 *  - Perform LPC analysis:                                               *
 *       * autocorrelation + lag windowing                                *
 *       * Levinson-durbin algorithm to find a[]                          *
 *       * convert a[] to lsp[]                                           *
 *       * quantize and code the LSPs                                     *
 *       * find the interpolated LSPs and convert to a[] for the 2        *
 *         subframes (both quantized and unquantized)                     *
 *------------------------------------------------------------------------*/

  /* LP analysis */

  autocorr(p_window, M, r);                     /* Autocorrelations */
  lag_window(M, r);                             /* Lag windowing    */
  levinson(r, &A_t[MP1], rc);                   /* Levinson Durbin  */
  az_lsp(&A_t[MP1], lsp_new, lsp_old);          /* From A(z) to lsp */

  /* LSP quantization */

  qua_lsp(lsp_new, lsp_new_q, ana);
  ana += 2;                         /* Advance analysis parameters pointer */

  /*--------------------------------------------------------------------*
   * Find interpolated LPC parameters in all subframes (both quantized  *
   * and unquantized).                                                  *
   * The interpolated parameters are in array A_t[] of size (M+1)*4     *
   * and the quantized interpolated parameters are in array Aq_t[]      *
   *--------------------------------------------------------------------*/

  int_lpc(lsp_old, lsp_new, lsf_int, lsf_new,  A_t);
  int_qlpc(lsp_old_q, lsp_new_q, Aq_t);

  /* update the LSPs for the next frame */

  for(i=0; i<M; i++)
  {
    lsp_old[i]   = lsp_new[i];
    lsp_old_q[i] = lsp_new_q[i];