ld8a.h

语音编码G.729 语音编码G.729

int pitch_ol_fast(  /* output: open loop pitch lag                        */
   FLOAT signal[],  /* input : signal used to compute the open loop pitch */
                    /*     signal[-pit_max] to signal[-1] should be known */
   int L_frame      /* input : length of frame to compute pitch           */
);

int pitch_fr3_fast(     /* output: integer part of pitch period */
 FLOAT exc[],           /* input : excitation buffer            */
 FLOAT xn[],            /* input : target vector                */
 FLOAT h[],             /* input : impulse response.            */
 int L_subfr,           /* input : Length of subframe           */
 int t0_min,            /* input : minimum value in the searched range */
 int t0_max,            /* input : maximum value in the searched range */
 int i_subfr,           /* input : indicator for first subframe        */
 int *pit_frac          /* output: chosen fraction                     */
);

FLOAT g_pitch(FLOAT xn[], FLOAT y1[], FLOAT g_coeff[], int l);

int enc_lag3(     /* output: Return index of encoding */
  int T0,         /* input : Pitch delay              */
  int T0_frac,    /* input : Fractional pitch delay   */
  int *T0_min,    /* in/out: Minimum search delay     */
  int *T0_max,    /* in/out: Maximum search delay     */
  int pit_min,    /* input : Minimum pitch delay      */
  int pit_max,    /* input : Maximum pitch delay      */
  int pit_flag    /* input : Flag for 1st subframe    */
);

void dec_lag3(     /* Decode the pitch lag                   */
  int index,       /* input : received pitch index           */
  int pit_min,     /* input : minimum pitch lag              */
  int pit_max,     /* input : maximum pitch lag              */
  int i_subfr,     /* input : subframe flag                  */
  int *T0,         /* output: integer part of pitch lag      */
  int *T0_frac     /* output: fractional part of pitch lag   */
);

void pred_lt_3(       /* Compute adaptive codebook                       */
 FLOAT exc[],         /* in/out: excitation vector, exc[0:l_sub-1] = out */
 int t0,              /* input : pitch lag                               */
 int frac,            /* input : Fraction of pitch lag (-1, 0, 1)  / 3   */
 int l_sub            /* input : length of subframe.                     */
);

int parity_pitch(int pitch_i);

int check_parity_pitch(int pitch_i, int parity);

void cor_h_x(
     FLOAT h[],         /* (i) :Impulse response of filters      */
     FLOAT X[],         /* (i) :Target vector                    */
     FLOAT D[]          /* (o) :Correlations between h[] and D[] */
);

/*-----------------------*
 * Innovative codebook.  *
 *-----------------------*/

int ACELP_code_A(       /* (o) :index of pulses positions    */
  FLOAT x[],            /* (i) :Target vector                */
  FLOAT h[],            /* (i) :Inpulse response of filters  */
  int T0,               /* (i) :Pitch lag                    */
  FLOAT pitch_sharp,    /* (i) :Last quantized pitch gain    */
  FLOAT code[],         /* (o) :Innovative codebook          */
  FLOAT y[],            /* (o) :Filtered innovative codebook */
  int *sign             /* (o) :Signs of 4 pulses            */
);

void  decod_ACELP(int signs, int positions, FLOAT cod[]);

/*-----------------------------------------------------------*
 * Prototypes of LSP VQ functions                            *
 *-----------------------------------------------------------*/

struct lsp_cod_state_t
{
	FLOAT freq_prev[MA_NP][M];    /* previous LSP vector       */
};

void lsp_codw_reset(struct lsp_cod_state_t *);

void qua_lsp(struct lsp_cod_state_t *,
  FLOAT lsp[],       /* (i) : Unquantized LSP            */
  FLOAT lsp_q[],     /* (o) : Quantized LSP              */
  int ana[]          /* (o) : indexes                    */
);

void lsp_expand_1( FLOAT buf[], FLOAT c);

void lsp_expand_2( FLOAT buf[], FLOAT c);

void lsp_expand_1_2( FLOAT buf[], FLOAT c);

void lsp_get_quant(
  const FLOAT lspcb1[][M],
  const FLOAT lspcb2[][M],
  int code0,
  int code1,
  int code2,
  const FLOAT fg[][M],
  FLOAT freq_prev[][M],
  FLOAT lspq[],
  const FLOAT fg_sum[]
);

struct lsp_dec_state_t
{
	/* memory */
	FLOAT freq_prev[MA_NP][M];    /* previous LSP vector       */

	/* memory for frame erase operation */
	int prev_ma;                  /* previous MA prediction coef.*/
	FLOAT prev_lsp[M];            /* previous LSP vector         */
};

void lsp_decw_reset(struct lsp_dec_state_t *);

void d_lsp(struct lsp_dec_state_t *,
int index[],           /* input : indexes                 */
FLOAT lsp_new[],       /* output: decoded lsp             */
int bfi                /* input : frame erase information */
);

void lsp_prev_extract(
  FLOAT lsp[M],
  FLOAT lsp_ele[M],
  const FLOAT fg[MA_NP][M],
  FLOAT freq_prev[MA_NP][M],
  const FLOAT fg_sum_inv[M]
);

void lsp_prev_update(
  FLOAT lsp_ele[M],
  FLOAT freq_prev[MA_NP][M]
);

void lsp_stability(
 FLOAT  buf[]           /*in/out: LSP parameters  */
);

void lsp_prev_compose(
  FLOAT lsp_ele[],
  FLOAT lsp[],
  const FLOAT fg[][M],
  FLOAT freq_prev[][M],
  const FLOAT fg_sum[]
);

void get_wegt( FLOAT     flsp[], FLOAT   wegt[] );

void get_freq_prev(const FLOAT freq_prev[MA_NP][M], FLOAT x[MA_NP][M]);
void update_freq_prev(FLOAT freq_prev[MA_NP][M], const FLOAT x[MA_NP][M]);

/*--------------------------------------------------------------------------*
 * gain VQ functions.                                                       *
 *--------------------------------------------------------------------------*/

struct gain_state_t
{
	FLOAT past_qua_en[4];
};

void gain_past_reset(struct gain_state_t *);

int qua_gain(struct gain_state_t *,
		FLOAT code[], FLOAT *coeff, int lcode, FLOAT *gain_pit,
        FLOAT *gain_code, int tameflag   );

void  dec_gain(struct gain_state_t *,
			   int indice, FLOAT code[], int lcode, int bfi, FLOAT *gain_pit,
               FLOAT *gain_code);

void gain_predict(
  FLOAT past_qua_en[],  /* input :Past quantized energies       */
  FLOAT code[],         /* input: Innovative vector.            */
  int l_subfr,          /* input : Subframe length.             */
  FLOAT *gcode0         /* output : Predicted codebook gain     */
);

void gain_update(
  FLOAT past_qua_en[], /* input/output :Past quantized energies  */
  FLOAT g_code         /* input        : quantized gain          */
);

void gain_update_erasure(FLOAT *past_qua_en);

void  corr_xy2(FLOAT xn[], FLOAT y1[], FLOAT y2[], FLOAT g_coeff[]);

/*-----------------------*
 * Bitstream function    *
 *-----------------------*/
void prm2bits_ld8k(int prm[], INT16 bits[]);
void bits2prm_ld8k(INT16 bits[], int prm[]);
int  read_frame(FILE *f_serial, int *parm);

/*-----------------------------------------------------------*
 * Prototypes for the post filtering                         *
 *-----------------------------------------------------------*/

struct postfilt_state_t
{
	/* inverse filtered synthesis (with A(z/GAMMA2_PST))   */
	FLOAT res2_buf[PIT_MAX+L_SUBFR];
	FLOAT *res2;

	/* memory of filter 1/A(z/GAMMA1_PST) */
	FLOAT mem_syn_pst[M];

	FLOAT mem_pre;
    FLOAT past_gain;
};

void init_post_filter(struct postfilt_state_t *);

void post_filter(struct postfilt_state_t *,
  FLOAT *syn,     /* in/out: synthesis speech (postfiltered is output)    */
  FLOAT *a_t,     /* input : interpolated LPC parameters in all subframes */
  int *T,         /* input : decoded pitch lags in all subframes          */
  int Vad         /* input : decoded frame type          */
);

/*------------------------------------------------------------*
 * prototypes for taming procedure.                           *
 *------------------------------------------------------------*/

void init_exc_err(FLOAT exc_err[4]);
void update_exc_err(FLOAT exc_err[4], FLOAT gain_pit, int t0);
int test_err(FLOAT exc_err[4], int t0, int t0_frac);

/*-----------------------------------------------------------*
 * Prototypes for auxiliary functions                        *
 *-----------------------------------------------------------*/

INLINE_PREFIX void set_zero(FLOAT  dst[], int L);
INLINE_PREFIX void copy(const FLOAT src[], FLOAT dst[], int L);
INLINE_PREFIX INT16 random_g729(INT16 *seed);

void fwrite16(
 FLOAT *data,           /* input: inputdata            */
 int length,            /* input: length of data array */
 FILE *fp               /* input: file pointer         */
);

void dvsub(FLOAT *in1, FLOAT *in2, FLOAT *out, int npts);

FLOAT dvdot(FLOAT *in1, FLOAT *in2, int npts);

void dvwadd(FLOAT *in1, FLOAT scalar1, FLOAT *in2, FLOAT scalar2,
             FLOAT *out, int npts);

void dvsmul(FLOAT *in, FLOAT scalar, FLOAT *out, int npts);

#ifdef INLINE_FUNCS
#	include "utilinl.c"
#	include "lpcfinl.c"
#endif

#endif /* _LD8A_H_INCL */