pcm.c

radius协议源码÷The Radius Stack will connect to a Radius Server. This stack implementation is built upo

static
void	let2s_array (tribyte *buffer, unsigned int count, short *ptr, int index)
{	unsigned char	*cptr ;
	int		k ;
	int 	value;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = (cptr [0] << 8) | (cptr [1] << 16) | (cptr [2] << 24) ;
		value = LE2H_INT (value) ;
		ptr [index] = (short) (value >> 16) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* let2s_array */

static
void	bei2s_array (int *buffer, unsigned int count, short *ptr, int index)
{	int	k ;
	int		value ;
	for (k = 0 ; k < count ; k++)
	{	value = BE2H_INT (buffer [k]) ;
		ptr [index] = (short) (value >> 16) ;
		index ++ ;
		} ;
} /* bei2s_array */

static
void	lei2s_array (int *buffer, unsigned int count, short *ptr, int index)
{	int	k ;
	int		value ;
	for (k = 0 ; k < count ; k++)
	{	value = LE2H_INT (buffer [k]) ;
		ptr [index] = (short) (value >> 16) ;
		index ++ ;
		} ;
} /* lei2s_array */

static
void	f2s_array (float *buffer, unsigned int count, short *ptr, int index)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((double) buffer [k]) ;
		index ++ ;
		} ;
} /* f2s_array */


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

static	
void	sc2i_array	(signed char *buffer, unsigned int count, int *ptr, int index)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((int) buffer [k]) ;
		index ++ ;
		} ;
} /* sc2i_array */

static	
void	uc2i_array	(unsigned char *buffer, unsigned int count, int *ptr, int index)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((((int) buffer [k]) - 128) % 256) ;
		index ++ ;
		} ;
} /* uc2i_array */

static
void	bes2i_array (short *buffer, unsigned int count, int *ptr, int index)
{	int	k ;
	short	value ;
	for (k = 0 ; k < count ; k++)
	{	value = BE2H_SHORT (buffer [k]) ;
		ptr [index] = ((int) value) ;
		index ++ ;
		} ;
} /* bes2i_array */

static
void	les2i_array (short *buffer, unsigned int count, int *ptr, int index)
{	int	k ;
	short	value ;
	for (k = 0 ; k < count ; k++)
	{	value = LE2H_SHORT (buffer [k]) ;
		ptr [index] = ((int) value) ;
		index ++ ;
		} ;
} /* les2i_array */

static
void	bet2i_array (tribyte *buffer, unsigned int count, int *ptr, int index)
{	unsigned char	*cptr ;
	int		k ;
	int 	value;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = (cptr [0] << 24) | (cptr [1] << 16) | (cptr [2] << 8) ;
		ptr [index] = value / 256 ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* bet2i_array */

static
void	let2i_array (tribyte *buffer, unsigned int count, int *ptr, int index)
{	unsigned char	*cptr ;
	int	k ;
	int 	value;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = (cptr [0] << 8) | (cptr [1] << 16) | (cptr [2] << 24) ;
		ptr [index] = value / 256 ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* let2i_array */

static
void	f2i_array (float *buffer, unsigned int count, int *ptr, int index)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = (int) ((double) buffer [k]) ;
		index ++ ;
		} ;
} /* f2i_array */


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

static	
void	sc2d_array	(signed char *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((double) buffer [k]) * normfact ;
		index ++ ;
		} ;
} /* sc2d_array */

static	
void	uc2d_array	(unsigned char *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((((int) buffer [k]) - 128) % 256) * normfact ;
		index ++ ;
		} ;
} /* uc2d_array */

static
void	bes2d_array (short *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	short	value ;
	for (k = 0 ; k < count ; k++)
	{	value = BE2H_SHORT (buffer [k]) ;
		ptr [index] = ((double) value) * normfact ;
		index ++ ;
		} ;
} /* bes2d_array */

static
void	les2d_array (short *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	short	value ;
	for (k = 0 ; k < count ; k++)
	{	value = LE2H_SHORT (buffer [k]) ;
		ptr [index] = ((double) value) * normfact ;
		index ++ ;
		} ;
} /* les2d_array */

static
void	bet2d_array (tribyte *buffer, unsigned int count, double *ptr, int index, double normfact)
{	unsigned char	*cptr ;
	int		k ;
	int 	value;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = (cptr [0] << 24) | (cptr [1] << 16) | (cptr [2] << 8) ;
		ptr [index] = ((double) (value / 256)) * normfact ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* bet2d_array */

static
void	let2d_array (tribyte *buffer, unsigned int count, double *ptr, int index, double normfact)
{	unsigned char	*cptr ;
	int		k ;
	int 	value;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = (cptr [0] << 8) | (cptr [1] << 16) | (cptr [2] << 24) ;
		ptr [index] = ((double) (value / 256)) * normfact ;
		index ++ ;
		cptr += 3 ; 
		} ;
} /* let2d_array */

static
void	bei2d_array (int *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	int		value ;
	for (k = 0 ; k < count ; k++)
	{	value = BE2H_INT (buffer [k]) ;
		ptr [index] = ((double) value) * normfact ;
		index ++ ;
		} ;
} /* bei2d_array */

static
void	lei2d_array (int *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	int		value ;
	for (k = 0 ; k < count ; k++)
	{	value = LE2H_INT (buffer [k]) ;
		ptr [index] = ((double) value) * normfact ;
		index ++ ;
		} ;
} /* lei2d_array */

static
void	f2d_array (float *buffer, unsigned int count, double *ptr, int index, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((double) buffer [k]) * normfact ;
		index ++ ;
		} ;
} /* f2d_array */


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

static	
void	s2sc_array	(short *ptr, int index, signed char *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (signed char) (ptr [index]) ;
		index ++ ;
		} ;
} /* s2sc_array */

static	
void	s2uc_array	(short *ptr, int index, unsigned char *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (unsigned char) (ptr [index] + 128) ;
		index ++ ;
		} ;
} /* s2uc_array */

static 
void	s2bet_array (short *ptr, int index, tribyte *buffer, unsigned int count)
{	unsigned char	*cptr ;
	int		k, value ;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = ptr [index] << 8 ;
		cptr [2] = (unsigned char) (value & 0xFF) ;
		cptr [1] = (unsigned char) ((value >> 8) & 0xFF) ;
		cptr [0] = (unsigned char) ((value >> 16) & 0xFF) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* s2bet_array */

static 
void	s2let_array (short *ptr, int index, tribyte *buffer, unsigned int count)
{	unsigned char	*cptr ;
	int		k, value ;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = ptr [index] << 8 ;
		cptr [0] = (unsigned char) (value & 0xFF) ;
		cptr [1] = (unsigned char) ((value >> 8) & 0xFF) ;
		cptr [2] = (unsigned char) ((value >> 16) & 0xFF) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* s2let_array */

static 
void	s2bei_array (short *ptr, int index, int *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2BE_INT (ptr [index] << 16) ;
		index ++ ;
		} ;
} /* s2lei_array */

static 
void	s2lei_array (short *ptr, int index, int *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2LE_INT (ptr [index] << 16) ;
		index ++ ;
		} ;
} /* s2lei_array */

static 
void	s2f_array (short *ptr, int index, float *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (float) (ptr [index]) ;
		index ++ ;
		} ;
} /* s2f_array */


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

static	
void	i2sc_array	(int *ptr, int index, signed char *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (signed char) (ptr [index]) ;
		index ++ ;
		} ;
} /* i2sc_array */

static	
void	i2uc_array	(int *ptr, int index, unsigned char *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (unsigned char) (ptr [index] + 128) ;
		index ++ ;
		} ;
} /* i2uc_array */

static 
void	i2bes_array (int *ptr, int index, short *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2BE_SHORT (ptr [index]) ;
		index ++ ;
		} ;
} /* i2bes_array */

static 
void	i2les_array (int *ptr, int index, short *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2LE_SHORT (ptr [index]) ;
		index ++ ;
		} ;
} /* i2les_array */

static 
void	i2bet_array (int *ptr, int index, tribyte *buffer, unsigned int count)
{	unsigned char	*cptr ;
	int		k, value ;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = ptr [index] ;
		cptr [0] = (unsigned char) ((value & 0xFF0000) >> 16) ;
		cptr [1] = (unsigned char) ((value >> 8) & 0xFF) ;
		cptr [2] = (unsigned char) (value & 0xFF) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* i2bet_array */

static 
void	i2let_array (int *ptr, int index, tribyte *buffer, unsigned int count)
{	unsigned char	*cptr ;
	int		k, value ;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = ptr [index] ;
		cptr [0] = (unsigned char) (value & 0xFF) ;
		cptr [1] = (unsigned char) ((value >> 8) & 0xFF) ;
		cptr [2] = (unsigned char) ((value >> 16) & 0xFF) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* i2let_array */

static 
void	i2f_array (int *ptr, int index, float *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (float) (ptr [index]) ;
		index ++ ;
		} ;
} /* i2f_array */


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

static	
void	d2sc_array	(double *ptr, int index, signed char *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (signed char) (ptr [index] * normfact) ;
		index ++ ;
		} ;
} /* d2sc_array */

static	
void	d2uc_array	(double *ptr, int index, unsigned char *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (unsigned char) ((ptr [index] * normfact) + 128) ;
		index ++ ;
		} ;
} /* d2uc_array */

static 
void	d2bes_array (double *ptr, int index, short *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2BE_SHORT ((int) (ptr [index] * normfact)) ;
		index ++ ;
		} ;
} /* d2bes_array */

static 
void	d2les_array (double *ptr, int index, short *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2LE_SHORT ((int) (ptr [index] * normfact)) ;
		index ++ ;
		} ;
} /* d2les_array */

static 
void	d2bet_array (double *ptr, int index, tribyte *buffer, unsigned int count, double normfact)
{	unsigned char	*cptr ;
	int		k, value ;
	cptr = (unsigned char*) buffer ;
	for (k = 0 ; k < count ; k++)
	{	value = (int) (ptr [index] * normfact) ;
		cptr [2] = (unsigned char) (value & 0xFF) ;
		cptr [1] = (unsigned char) ((value >> 8) & 0xFF) ;
		cptr [0] = (unsigned char) ((value >> 16) & 0xFF) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* d2bet_array */

static 
void	d2let_array (double *ptr, int index, tribyte *buffer, unsigned int count, double normfact)
{	unsigned char	*cptr ;
	int		k, value ;
	cptr = (unsigned char*) buffer ;	
	for (k = 0 ; k < count ; k++)
	{	value = (int) (ptr [index] * normfact) ;
		cptr [0] = (unsigned char) (value & 0xFF) ;
		cptr [1] = (unsigned char) ((value >> 8) & 0xFF) ;
		cptr [2] = (unsigned char) ((value >> 16) & 0xFF) ;
		index ++ ;
		cptr += 3 ;
		} ;
} /* d2let_array */

static 
void	d2bei_array (double *ptr, int index, int *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2BE_INT ((int) (ptr [index] * normfact)) ;
		index ++ ;
		} ;
} /* d2bei_array */

static 
void	d2lei_array (double *ptr, int index, int *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = H2LE_INT ((int) (ptr [index] * normfact)) ;
		index ++ ;
		} ;
} /* d2lei_array */

static 
void	d2f_array (double *ptr, int index, float *buffer, unsigned int count, double normfact)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (float) (ptr [index] * normfact) ;
		index ++ ;
		} ;
} /* d2f_array */