codeparm.c

手机加密通话软件

}

/*

*************************************************************************
*                                                                         *
* ROUTINE
*		Pack
*
* FUNCTION
*		Pack CELP parameters
* SYNOPSIS
*		Pack(NParams, Params, BitAllocs, NumPacked, Channel)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*	NParams		int	 i	Number of parameters to pack
*	Params		int	 i	Frame of encoded analysis parameters
*	BitAllocs	int	 i	Bit allocations for each parameter
*	NumPacked	int	 o	Number of bits packed
*	Channel		int	 o	Frame of channel bits
*
**************************************************************************/

void Pack(
int		NParams,
int		Params[],
int		BitAllocs[], 
int		*NumPacked,
int		Channel[])
{
int		i, j, k=0;

	for(i=0; i<NParams; i++) { /* For each parameter */
	  for(j=0;j<BitAllocs[i]; j++) { /* For each bit in each parameter */
	    Channel[k++] = (Params[i] & (1<<j)) >> j;
	  }
	}

	*NumPacked = k;

}

/*

*************************************************************************
*                                                                         *
* ROUTINE
*		Unpack
*
* FUNCTION
*		Unpack CELP parameters
* SYNOPSIS
*		Unpack(NParams, BitAllocs, Channel, NumUnpacked, Params)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*	NParams		int	 i	Number of parameters to unpack
*	BitAllocs	int	 i	Bit allocations for each parameter
*	Channel		int	 i	Frame of channel bits
*	NumUnpacked	int	 o	Number of bits unpacked
*	Params		int	 o	Frame of analysis parameters
*
**************************************************************************/

void Unpack(
int		NParams,
int		BitAllocs[],
int		Channel[],
int		*NumUnpacked,
int		Params[]) 
{
int	i, j, k=0;

	for(i=0; i<NParams; i++) { /* For each parameter */
	  Params[i] = 0;
	  for(j=0; j<BitAllocs[i]; j++) { /* For each bit in each parameter */
	    Params[i] |= Channel[k++] << j;
	  }
	}

	*NumUnpacked = k;

}

/*

*************************************************************************
*                                                                         *
* ROUTINE
*		ADelayEncode
*
* FUNCTION
*		Encode the Adaptive Delay
* SYNOPSIS
*		ADelayEncode(UDelay, QDelay)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*	UDelay		float	 i	Unquantized adaptive delay
*	QDelay		int	 o	Quantized adaptive delay
*
**************************************************************************/

#include "adencode.h"
extern float DelayTable[MAX_NUM_ADAPT];

void ACBDelayEncode(
float	Udelay, 
int	*Qdelay)
{
int		i, j;
static int	even=FALSE;
static int	LastIndex=1;
int		MinDelayPtr, MaxDelayPtr;

	if(!even)	{
/*  On odd frames search through delay table until a match is found */
	  for(i=0;i<MAX_NUM_ADAPT;i++)	{
	    if (Udelay == DelayTable[i])	{
	      LastIndex = i;
	      break;
	    }
	  }

/*  Retrieve encoded delay value from table */
	  *Qdelay = adencode[i];

	}
	else		{	
/*  On even frames search for delta delay */
	  MinDelayPtr = LastIndex - (NUM_DELTA_ADELAYS / 2 - 1);
	  MaxDelayPtr = LastIndex + (NUM_DELTA_ADELAYS / 2);
	  if (MinDelayPtr < 0)	{
	    MinDelayPtr = 0;
	    MaxDelayPtr = NUM_DELTA_ADELAYS - 1;
	  }
	  if (MaxDelayPtr > NUM_FULL_ADELAYS-1)	{
	    MaxDelayPtr = NUM_FULL_ADELAYS - 1;
	    MinDelayPtr = NUM_FULL_ADELAYS - NUM_DELTA_ADELAYS;
	  }
	  for(i=MinDelayPtr, j=0; i<=MaxDelayPtr; i++, j++)	{
	    if (Udelay == DelayTable[i])	{
	      *Qdelay = j;
	      break;
	    }
	  }
	  
	}


/*  Update even flag */
	even = (even) ? FALSE : TRUE;

}
/*

*************************************************************************
*                                                                         *
* ROUTINE
*		ACBDelayDecode
*
* FUNCTION
*		Decode the Adaptive Delay
* SYNOPSIS
*		ACBDelayDecode(QDelay, UDelay)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*	QDelay		int	 i	Quantized adaptive delay
*	UDelay		float	 o	Unquantized adaptive delay
*
**************************************************************************/

#include "addecode.h"

void ACBDelayDecode(
int	QDelay, 
float	*UDelay)
{
static int 	even = FALSE;
static int	LastIndex = 0;
static int	first = TRUE;
static int	DeltaDecodeTable[NUM_FULL_ADELAYS];
int		MaxDelayPtr, MinDelayPtr;
int		i;

/*  Generate table for delta delay decoding */
	if(first)	{
	  first = FALSE;
	  for (i = 0; i < NUM_FULL_ADELAYS; i++)
  	  {
    	    DeltaDecodeTable[adencode[i]] = i;
  	  }
	}

	if (!even)	{
/*  On even subframes decode from table */
	  *UDelay = addecode[QDelay];
	  LastIndex = DeltaDecodeTable[QDelay];
	}
	else		{
/*  On odd subframes decode relative to previous frame */
	  MinDelayPtr = LastIndex - (NUM_DELTA_ADELAYS / 2 - 1);
	  MaxDelayPtr = LastIndex + (NUM_DELTA_ADELAYS / 2);
	  if (MinDelayPtr < 0)	{
	    MinDelayPtr = 0;
	    MaxDelayPtr = NUM_DELTA_ADELAYS - 1;
	  }
	  if (MaxDelayPtr > NUM_FULL_ADELAYS-1)	{
	    MaxDelayPtr = NUM_FULL_ADELAYS - 1;
	    MinDelayPtr = NUM_FULL_ADELAYS - NUM_DELTA_ADELAYS;
	  }
	  *UDelay = DelayTable[MinDelayPtr + QDelay];
	}

/*  Update even */
	even = (even) ? FALSE:TRUE;
}
/*

*************************************************************************
*                                                                         *
* ROUTINE
*		FS1016Encode
*
* FUNCTION
*		Translate from bit structure to FS1016 compatible array
* SYNOPSIS
*		FS1016Encode(InStruct, OutArray)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*	InStruct	TX_BITS	 i	Structure of quantized parameters
*	OutArray	int	 o	Array of FS1016 compatible parameters
*
**************************************************************************/

int FS1016Encode(
TX_BITS	InStruct,
int	OutArray[])
{
int	i, j=0;

/*  Put the LSFs into the array */
	for(i=0;i<ORDER;i++)	{
	  OutArray[j++] = InStruct.lsf[i];
	}

/*  Put each subframe's parameters into the array */
	for(i=0;i<NUM_SF;i++)	{
	  OutArray[j++] = InStruct.AdaptiveDelay[i];
	  OutArray[j++] = InStruct.AdaptiveGain[i];
	  OutArray[j++] = InStruct.StochasticIndex[i];
	  OutArray[j++] = InStruct.StochasticGain[i];
	}

/*  Now put in the Bishnu bit */
	OutArray[j++] = InStruct.Bishnu;

/*  Next the Hamming Code */
	OutArray[j++] = InStruct.Hamming;

/*  And last the sync bit */
	OutArray[j] = InStruct.Sync;

/*  Let the calling routine know how many parameters were filled */
	return(j+1);

}
/*

*************************************************************************
*                                                                         *
* ROUTINE
*		FS1016Decode
*
* FUNCTION
*		Translate to bit structure from FS1016 compatible array
* SYNOPSIS
*		FS1016Encode(InArray, OutStruct)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*	InArray		int	 i	Array of FS1016 compatible parameters
*	OutStruct	TX_BITS	 o	Structure of quantized parameters
*
**************************************************************************/

int FS1016Decode(
int	InArray[],
TX_BITS	*OutStruct)
{
int	i, j=0;

/*  Get the LSFs from the array */
	for(i=0;i<ORDER;i++)	{
	  OutStruct->lsf[i] = InArray[j++];
	}

/*  Put each subframe's parameters into the array */
	for(i=0;i<NUM_SF;i++)	{
	  OutStruct->AdaptiveDelay[i] = InArray[j++];
	  OutStruct->AdaptiveGain[i] = InArray[j++];
	  OutStruct->StochasticIndex[i] = InArray[j++];
	  OutStruct->StochasticGain[i] = InArray[j++];
	}

/*  Now put in the Bishnu bit */
	OutStruct->Bishnu = InArray[j++];

/*  Next the Hamming Code */
	OutStruct->Hamming = InArray[j++];

/*  And last the sync bit */
	OutStruct->Sync = InArray[j];


/*  Let the calling routine know how many parameters were filled */
	return(j+1);

}