www.pudn.com > CryptoPhone-src-031122.zip > synth.c

/* Copyright 2001,2002,2003 NAH6 
 * All Rights Reserved 
 * 
 * Parts Copyright DoD, Parts Copyright Starium 
 * 
 */ 
          /*LINTLIBRARY*/ 
          /*PROTOLIB1*/ 
 
#include "main.h" 
#include  
#include "con_adap.h" 
#include "con_stch.h" 
#include "interp.h" 
#include "lp_syn.h" 
#include "movarray.h" 
#include "postfilt.h" 
#include "setarray.h" 
#include "synth.h" 
#include "filter.h" 
 
 
static void SquelchTest( 
int	len, 
int	frame_num, 
float	speech[]); 
 
static int clip( 
float 	s[], 
int 	l); 
 
/************************************************************************** 
*                                                                         * 
* ROUTINE 
*		Synthesis 
* 
* FUNCTION 
*		CELP synthesis 
* SYNOPSIS 
*		Synthesis(parameters, BitIntegrity, frame_num, speech_out) 
* 
*   formal 
* 
*                       data    I/O 
*       name            type    type    function 
*       ------------------------------------------------------------------- 
*	parameters	TX_PARAM i	Frame of CELP parameters 
*	BitIntegrity	INTEGRITY i	Integrity of decoded bitstream (future) 
*	frame_num	int	 i	Frame number 
*	speech_out	float	 o	Frame of output speech 
* 
**************************************************************************/ 
void Synthesis( 
TX_PARAM 	parameters, 
int		frame_num, 
float		speech_out[F_LEN]) 
{ 
float 		lsfint[NUM_SF][ORDER]; 
float		excitation[SF_LEN]; 
static float	adapt_cw[ACB_SIZE]; 
float		lpc_speech[SF_LEN], post_speech[SF_LEN]; 
int		sf; 
static int	first=TRUE; 
 
/*  Initialize */ 
	if (first)	{ 
	  first = FALSE; 
	  SetArray(ACB_SIZE, 0.0, adapt_cw); 
	} 
 
/*  Interpolate NUM_SF subframes of LSFs for subframe synthesis */ 
	Interpolate(parameters.lsf, lsfint, SYNTHESIS, frame_num); 
 
/*  Synthesisze speech on a subframe basis */ 
	for (sf = 0; sf < NUM_SF; sf++) { 
 
/*  Construct the stochastic codeword (initial excitation) */ 
	  ConstructStochCW(parameters.StochasticIndex[sf],  
		parameters.StochasticGain[sf], excitation); 
 
/*  Construct the adaptive codeword and update excitation */ 
	  ConstructAdaptCW(excitation, SF_LEN, adapt_cw, ACB_SIZE,  
		parameters.AdaptiveGain[sf], parameters.AdaptiveDelay[sf],  
		"long"); 
 
 
/*  Perform LP excitation to produce speech */ 
	  LP_Synthesis(excitation, lsfint[sf], frame_num, lpc_speech); 
 
/*  Apply post filter to lpc-speech */ 
	  PostFilter(lpc_speech, lsfint[sf], frame_num, post_speech); 
 
/*  Test for clipping */ 
	  SquelchTest(SF_LEN, frame_num, post_speech); 
 
#ifndef STREAMLINE 
/*  Apply high pass filter to speech */ 
	  HPF_OutSpeech(post_speech, &speech_out[sf*SF_LEN]); 
#else 
/*  Copy postfiltered speech to output buffer */ 
	  MoveArray(SF_LEN, post_speech, &speech_out[sf*SF_LEN]); 
#endif 
 
	} 
 
 
} 
/* 
 
************************************************************************* 
*                                                                         * 
* ROUTINE 
*		SquelchTest 
* 
* FUNCTION 
*		Test for clipping on input speech 
* SYNOPSIS 
*		SquelchTest(len, frame_num, speech) 
* 
*   formal 
* 
*                       data    I/O 
*       name            type    type    function 
*       ------------------------------------------------------------------- 
*	len		int	 i	Length of speech buffer 
*	frame_num	int	 i	Frame Number 
*	speech_out	float	i/o	Frame of speech 
* 
**************************************************************************/ 
 
void SquelchTest( 
int	len, 
int	frame_num, 
float	speech[]) 
{ 
int	i; 
 
	while (clip(speech, len))	{ 
	  printf("celp: Clipping detected at frame %d\n", frame_num); 
	  for(i=0;i 32768.0) 
    { 
      count++; 
      sum += fabs(s[i]); 
    } 
  } 
 
  /*	Clipping heuristics (could also use energy, delta energy, etc.)	*/ 
 
  return(((count >= 10) || (count >= 5 && sum > 1.e6)) ? TRUE : FALSE); 
}