au.c

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

				error = SFE_AU_UNKNOWN_FORMAT ;
				break ;
		} ;

	if (error)
		return error ;

	if (! psf->sf.samples && psf->blockwidth)
		psf->sf.samples = au_fmt.datasize / psf->blockwidth ;


	return 0 ;
} /* au_open_read */

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

int 	au_nh_open_read	(SF_PRIVATE *psf)
{	if (fseek (psf->file, psf->dataoffset, SEEK_SET))
		return SFE_BAD_SEEK ;

	psf_sprintf (psf, "Setting up for 8kHz, mono, u-law.\n") ;
	
	psf->sf.format = SF_FORMAT_AU | SF_FORMAT_ULAW ;

 	psf->dataoffset = 0 ;
 	psf->current  = 0 ;
	psf->endian   = 0 ;  /* Irrelevant but it must be something. */
	psf->sf.seekable = SF_TRUE ;
	psf->sf.samplerate	= 8000 ;
	psf->sf.channels 	= 1 ;
	psf->sf.sections 	= 1 ;
	psf->sf.pcmbitwidth = 16 ;	/* After decoding */
	psf->bytewidth   	= 1 ;	/* Before decoding */
					
	psf->read_short  = (func_short)  ulaw_read_ulaw2s ;
	psf->read_int    = (func_int)    ulaw_read_ulaw2i ;
	psf->read_double = (func_double) ulaw_read_ulaw2d ;
	psf->close 	     = (func_close)  au_close ;

	psf->blockwidth = 1 ;
	psf->sf.samples = psf->filelength ;
	psf->datalength = psf->filelength ;

	return 0 ;
} /* au_open_read */

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

int 	au_open_write	(SF_PRIVATE *psf)
{	AU_FMT			au_fmt ;
	unsigned int	dword, encoding, format, subformat, big_endian_file ;
	int				error = 0 ;
	
	format = psf->sf.format & SF_FORMAT_TYPEMASK ;
	subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
	if (format == SF_FORMAT_AU)
		big_endian_file = 1 ;
	else if (format == SF_FORMAT_AULE)
		big_endian_file = 0 ;
	else
		return	SFE_BAD_OPEN_FORMAT ;
		
	if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW || 
		subformat == SF_FORMAT_G721_32 || subformat == SF_FORMAT_G723_24)
		psf->bytewidth = 1 ;
	else
		psf->bytewidth = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
		
	psf->endian      = big_endian_file ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
	psf->sf.seekable = SF_TRUE ;
	psf->blockwidth  = psf->bytewidth * psf->sf.channels ;
 	psf->dataoffset  = 6 * sizeof (dword) ;
	psf->datalength  = psf->blockwidth * psf->sf.samples ;
	psf->filelength  = psf->datalength + psf->dataoffset ;
	psf->error       = 0 ;

	encoding = get_encoding (subformat, psf->bytewidth * 8) ;
	if (! encoding)
		return	SFE_BAD_OPEN_FORMAT ;

	au_fmt.dataoffset = 24 ;
	au_fmt.datasize   = psf->datalength ;
	au_fmt.encoding   = encoding ;
	au_fmt.samplerate = psf->sf.samplerate ;
	au_fmt.channels   = psf->sf.channels ;
	
	if (CPU_IS_LITTLE_ENDIAN && big_endian_file)
		endswap_au_fmt (&au_fmt) ;
	else if (CPU_IS_BIG_ENDIAN && ! big_endian_file)
		endswap_au_fmt (&au_fmt) ;
	
	dword = big_endian_file ? DOTSND_MARKER : DNSDOT_MARKER ;	/* Marker */
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	
	fwrite (&au_fmt, sizeof (AU_FMT), 1, psf->file) ;
	
	psf->close = (func_close) au_close ;
	
	switch (encoding)
	{	case  AU_ENCODING_ULAW_8 :	/* 8-bit Ulaw encoding. */
				psf->write_short  = (func_short)  ulaw_write_s2ulaw ;
				psf->write_int    = (func_int)    ulaw_write_i2ulaw ;
				psf->write_double = (func_double) ulaw_write_d2ulaw ;
				break ;
	
		case  AU_ENCODING_PCM_8 :	/* 8-bit linear PCM. */
				psf->write_short  = (func_short)  pcm_write_s2sc ;
				psf->write_int    = (func_int)    pcm_write_i2sc ;
				psf->write_double = (func_double) pcm_write_d2sc ;
				break ;

		case  AU_ENCODING_PCM_16 :	/* 16-bit linear PCM. */
				if (big_endian_file)
				{	psf->write_short  = (func_short)  pcm_write_s2bes ;
					psf->write_int    = (func_int)    pcm_write_i2bes ;
					psf->write_double = (func_double) pcm_write_d2bes ;
					}
				else
				{	psf->write_short  = (func_short)  pcm_write_s2les ;
					psf->write_int    = (func_int)    pcm_write_i2les ;
					psf->write_double = (func_double) pcm_write_d2les ;
					} ;
				break ;

		case  AU_ENCODING_PCM_24 :	/* 24-bit linear PCM */
				if (big_endian_file)
				{	psf->write_short  = (func_short)  pcm_write_s2bet ;
					psf->write_int    = (func_int)    pcm_write_i2bet ;
					psf->write_double = (func_double) pcm_write_d2bet ;
					}
				else
				{	psf->write_short  = (func_short)  pcm_write_s2let ;
					psf->write_int    = (func_int)    pcm_write_i2let ;
					psf->write_double = (func_double) pcm_write_d2let ;
					} ;
				break ;

		case  AU_ENCODING_PCM_32 :	/* 32-bit linear PCM. */
				if (big_endian_file)
				{	psf->write_short  = (func_short)  pcm_write_s2bei ;
					psf->write_int    = (func_int)    pcm_write_i2bei ;
					psf->write_double = (func_double) pcm_write_d2bei ;
					}
				else
				{	psf->write_short  = (func_short)  pcm_write_s2lei ;
					psf->write_int    = (func_int)    pcm_write_i2lei ;
					psf->write_double = (func_double) pcm_write_d2lei ;
					} ;
				break ;
				
		case  AU_ENCODING_ALAW_8 :	/* 8-bit Alaw encoding. */
				psf->write_short  = (func_short)  alaw_write_s2alaw ;
				psf->write_int    = (func_int)    alaw_write_i2alaw ;
				psf->write_double = (func_double) alaw_write_d2alaw ;
				break ;
	
		case  AU_ENCODING_ADPCM_G721_32 :  
				if (psf->sf.channels != 1)
				{	psf_sprintf (psf, "Channels != 1\n") ;
					break ;
					} ;
				psf->sf.pcmbitwidth = 16 ;	/* After decoding */
				psf->bytewidth   	= 0 ;
				psf->blockwidth = psf->sf.channels * psf->bytewidth ;
				
				psf->sf.format |= SF_FORMAT_G721_32 ;
				
				error = au_g72x_writer_init (psf, AU_H_G721_32) ;
				break ;

		case  AU_ENCODING_ADPCM_G723_24 :  
				if (psf->sf.channels != 1)
				{	psf_sprintf (psf, "Channels != 1\n") ;
					break ;
					} ;
				psf->sf.pcmbitwidth = 16 ;	/* After decoding */
				psf->bytewidth   	= 0 ;
				psf->blockwidth = psf->sf.channels * psf->bytewidth ;
				
				psf->sf.format |= SF_FORMAT_G721_32 ;
				
				error = au_g72x_writer_init (psf, AU_H_G723_24) ;
				break ;

		default :   break ;
		} ;
		
	return error ;
} /* au_open_write */

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

int	au_close	(SF_PRIVATE  *psf)
{	unsigned int	dword ;

	if (psf->mode == SF_MODE_WRITE)
	{	/*  Now we know for certain the length of the file we can
		 *  re-write correct values for the datasize header element.
		 */

		fseek (psf->file, 0, SEEK_END) ;
		psf->filelength = ftell (psf->file) ;

		psf->datalength = psf->filelength - psf->dataoffset ;
		fseek (psf->file, 2 * sizeof (dword), SEEK_SET) ;
		
		if (psf->endian == SF_ENDIAN_BIG)
			dword = H2BE_INT (psf->datalength) ;
		else if (psf->endian == SF_ENDIAN_LITTLE)
			dword = H2LE_INT (psf->datalength) ;
		else
			dword = 0xFFFFFFFF ;
		fwrite (&dword, sizeof (dword), 1, psf->file) ;
		} ;

	if (psf->fdata)
		free (psf->fdata) ;
	psf->fdata = NULL ;
	
	return 0 ;
} /* au_close */

static	
int get_encoding (unsigned int format, unsigned int	bitwidth)
{	if (format == SF_FORMAT_ULAW)
		return AU_ENCODING_ULAW_8 ;
		
	if (format == SF_FORMAT_ALAW)
		return AU_ENCODING_ALAW_8 ;

	if (format == SF_FORMAT_G721_32)
		return AU_ENCODING_ADPCM_G721_32 ;

	if (format == SF_FORMAT_G723_24)
		return AU_ENCODING_ADPCM_G723_24 ;

	if (format != SF_FORMAT_PCM)
		return 0 ;

	/* For PCM encoding, the header encoding field depends on the bitwidth. */
	switch (bitwidth)
	{	case	8  : return AU_ENCODING_PCM_8 ;
		case	16 : return AU_ENCODING_PCM_16 ;
		case	24 : return AU_ENCODING_PCM_24 ;
		case	32 : return	AU_ENCODING_PCM_32 ;
		default : break ;
		} ;
	return 0 ;
} /* get encoding */

static
void	endswap_au_fmt (AU_FMT *pau_fmt)
{	pau_fmt->dataoffset = ENDSWAP_INT (pau_fmt->dataoffset) ;
	pau_fmt->datasize   = ENDSWAP_INT (pau_fmt->datasize) ;
	pau_fmt->encoding   = ENDSWAP_INT (pau_fmt->encoding) ;
    pau_fmt->samplerate = ENDSWAP_INT (pau_fmt->samplerate) ;
    pau_fmt->channels   = ENDSWAP_INT (pau_fmt->channels) ;
} /* endswap_au_fmt */

static	
char* get_encoding_str (int format)
{	switch (format)
	{	case  AU_ENCODING_ULAW_8 :	
				return "8-bit ISDN u-law" ;
										
		case  AU_ENCODING_PCM_8 :	
				return "8-bit linear PCM" ;

		case  AU_ENCODING_PCM_16 :	
				return "16-bit linear PCM" ;

		case  AU_ENCODING_PCM_24 :	
				return "24-bit linear PCM" ;

		case  AU_ENCODING_PCM_32 :	
				return "32-bit linear PCM" ;
					
		case  AU_ENCODING_ALAW_8 :
				return "8-bit ISDN A-law" ;
					
		case  AU_ENCODING_ADPCM_G721_32 :  
				return "G721 32kbs ADPCM" ;
										
		case  AU_ENCODING_ADPCM_G723_24 :  
				return "G723 24kbs ADPCM" ;
										
		case  AU_ENCODING_NEXT :	
				return "Weird NeXT encoding format (unsupported)" ;
		} ;
	return "Unknown!!" ;
} /* get_encoding_str */