common.c

Vovida 社区开源的 SIP 协议源码

					psf->headindex += size ;
					count += 4 + size ;
					break ;
					
			case 'B' :
					bindata = va_arg (argptr, void *) ;
					size    = va_arg (argptr, size_t) ;
					memcpy (&(psf->header [psf->headindex]), bindata, size) ;
					psf->headindex += size ;
					count += size ;
					break ;
					
			case 'z' :
					size    = va_arg (argptr, size_t) ;
					count += size ;
					while (size)
					{	psf->header [psf->headindex] = 0 ;
						psf->headindex ++ ;
						size -- ;
						} ;
					break ;
					
			default : break ;
			} ;
		} ;
	
	va_end(argptr);
	return count ;
} /* psf_binheader_writef */

/*-----------------------------------------------------------------------------------------------
**  Binary header reading functions. Returns number of bytes read.
**
**	Format specifiers are the same as for header write function above with the following
**	additions:
**
**		p   - jump a given number of position from start of file.
**
**	If format is NULL, psf_binheader_readf returns the current offset.
*/

#if (CPU_IS_BIG_ENDIAN == 1)
#define	GET_INT(psf)	( ((psf)->header [0] << 24) + ((psf)->header [1] << 16) +	\
						  ((psf)->header [2] <<  8) + ((psf)->header [3]) )

#define	GET_3BYTE(psf)	( ((psf)->header [0] << 16) + ((psf)->header [1] << 8) +	\
						  ((psf)->header [2]) )

#define	GET_SHORT(psf)	( ((psf)->header [0] <<  8) + ((psf)->header [1]) )

#elif (CPU_IS_LITTLE_ENDIAN == 1)
#define	GET_INT(psf)	( ((psf)->header [0]      ) + ((psf)->header [1] <<  8) +	\
						  ((psf)->header [2] << 16) + ((psf)->header [3] << 24) )

#define	GET_3BYTE(psf)	( ((psf)->header [0]      ) + ((psf)->header [1] <<  8) +	\
						  ((psf)->header [2] << 16) )

#define	GET_SHORT(psf)	( ((psf)->header [0]) + ((psf)->header [1] <<  8) )

#else
#       error "Cannot determine endian-ness of processor."
#endif

#define	GET_BYTE(psf)	( (psf)->header [0] )

int
psf_binheader_readf (SF_PRIVATE *psf, char const *format, ...)
{	va_list	argptr ;
	unsigned int 	*longptr, longdata ;
	unsigned short	*wordptr, worddata ;
	char    		*charptr ;
	int				position ;
	float			*floatptr ;
	size_t			size ;
	char			c ;
	int				count = 0 ;
	
	if (! format)
		return ftell (psf->file) ;
			
	va_start(argptr, format);
	
	while ((c = *format++))
	{	switch (c)
		{	case 'm' : 
					longptr = va_arg (argptr, unsigned int*) ;
					fread (psf->header, 1, sizeof (int), psf->file) ;
					*longptr = GET_INT (psf) ;
					count += 4 ;
					break ;
					
			case 'b' :
					charptr = va_arg (argptr, char*) ;
					fread (psf->header, 1, sizeof (char), psf->file) ;
					*charptr = GET_BYTE (psf) ;
					count += 1 ;
					break ;
					
			case 'w' :
					wordptr = va_arg (argptr, unsigned short*) ;
					fread (psf->header, 1, sizeof (short), psf->file) ;
					worddata = GET_SHORT (psf) ;
					*wordptr = H2LE_SHORT (worddata) ;
					count += 2 ;
					break ;

			case 'W' :
					wordptr = va_arg (argptr, unsigned short*) ;
					fread (psf->header, 1, sizeof (short), psf->file) ;
					worddata = GET_SHORT (psf) ;
					*wordptr = H2BE_SHORT (worddata) ;
					count += 2 ;
					break ;
					
			case 'l' :
					longptr = va_arg (argptr, unsigned int*) ;
					fread (psf->header, 1, sizeof (int), psf->file) ;
					longdata = GET_INT (psf) ;
					*longptr = H2LE_INT (longdata) ;
					count += 4 ;
					break ;

			case 'L' :
					longptr = va_arg (argptr, unsigned int*) ;
					fread (psf->header, 1, sizeof (int), psf->file) ;
					longdata = GET_INT (psf) ;
					*longptr = H2BE_INT (longdata) ;
					count += 4 ;
					break ;

			case 't' :
					longptr = va_arg (argptr, unsigned int*) ;
					fread (psf->header, 1, 3, psf->file) ;
					longdata = GET_3BYTE (psf) ;
					*longptr = H2LE_INT (longdata) ;
					count += 3 ;
					break ;

			case 'T' :
					longptr = va_arg (argptr, unsigned int*) ;
					fread (psf->header, 1, 3, psf->file) ;
					longdata = GET_3BYTE (psf) ;
					*longptr = H2BE_INT (longdata) ;
					count += 3 ;
					break ;

			case 'f' :
					floatptr = va_arg (argptr, float *) ;
					fread (psf->header, 1, sizeof (float), psf->file) ;
					longdata = GET_INT (psf) ;
					longdata = H2LE_INT (longdata) ;
					*floatptr = float32_read ((unsigned char*) &longdata) ;
					count += 4 ;
					break ;

			case 'F' :
					floatptr = va_arg (argptr, float *) ;
					fread (psf->header, 1, sizeof (float), psf->file) ;
					longdata = GET_INT (psf) ;
					longdata = H2BE_INT (longdata) ;
					*floatptr = float32_read ((unsigned char*) &longdata) ;
					count += 4 ;
					break ;

			case 's' :
					printf ("Format conversion not implemented yet.\n") ;
					/*
					strptr = va_arg (argptr, char *) ;
					size   = strlen (strptr) + 1 ;
					size  += (size & 1) ;
					longdata = H2LE_INT (size) ;
					get_int (psf, longdata) ;
					memcpy (&(psf->header [psf->headindex]), strptr, size) ;
					psf->headindex += size ;
					*/
					break ;
					
			case 'S' :
					printf ("Format conversion not implemented yet.\n") ;
					/*
					strptr = va_arg (argptr, char *) ;
					size   = strlen (strptr) + 1 ;
					size  += (size & 1) ;
					longdata = H2BE_INT (size) ;
					get_int (psf, longdata) ;
					memcpy (&(psf->header [psf->headindex]), strptr, size) ;
					psf->headindex += size ;
					*/
					break ;
					
			case 'B' :
					charptr = va_arg (argptr, char*) ;
					size = va_arg (argptr, size_t) ;
					memset (charptr, 0, size) ;
					fread (charptr, 1, size, psf->file) ;
					count += size ;
					break ;
					
			case 'z' :
					printf ("Format conversion not implemented yet.\n") ;
					/*
					size    = va_arg (argptr, size_t) ;
					while (size)
					{	psf->header [psf->headindex] = 0 ;
						psf->headindex ++ ;
						size -- ;
						} ;
					*/
					break ;
					
			case 'p' :
					/* Get the seek position first. */ 
					position = va_arg (argptr, int) ;
					fseek (psf->file, position, SEEK_SET) ;
					count = 0 ;
					break ;

			case 'j' :
					/* Get the seek position first. */ 
					position = va_arg (argptr, int) ;
					fseek (psf->file, position, SEEK_CUR) ;
					count = 0 ;
					break ;

			default :
				psf_log_printf (psf, "Invalid format specifier `%c'\n", c) ;
				psf->error = SFE_INTERNAL ; 
				break ;
			} ;
		} ;
	
	va_end (argptr);
	
	return count ;
} /* psf_binheader_readf */

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

void
psf_log_SF_INFO (SF_PRIVATE *psf)
{	psf_log_printf (psf, "---------------------------------\n") ;

	psf_log_printf (psf, " Sample rate :   %d\n", psf->sf.samplerate) ;
	psf_log_printf (psf, " Samples     :   %d\n", psf->sf.samples) ;
	psf_log_printf (psf, " Channels    :   %d\n", psf->sf.channels) ;

	psf_log_printf (psf, " Bit width   :   %d\n", psf->sf.pcmbitwidth) ;
	psf_log_printf (psf, " Format      :   0x%08x\n", psf->sf.format) ;
	psf_log_printf (psf, " Sections    :   %d\n", psf->sf.sections) ;
	psf_log_printf (psf, " Seekable    :   %s\n", psf->sf.seekable ? "TRUE" : "FALSE") ;
	
	psf_log_printf (psf, "---------------------------------\n") ;
} /* psf_dump_SFINFO */ 

/*========================================================================================
**	Functions used in the write function for updating the peak chunk. 
*/

/*-void	
peak_update_short	(SF_PRIVATE *psf, short *ptr, size_t items)
{	int		chan, k, position ;
	short	maxval ;
	float	fmaxval ;
	
	for (chan = 0 ; chan < psf->sf.channels ; chan++)
	{	maxval = abs (ptr [chan]) ;
		position = 0 ;
		for (k = chan ; k < items ; k += psf->sf.channels)
			if (maxval < abs (ptr [k]))
			{	maxval = abs (ptr [k]) ;
				position = k ;
				} ;
				
		fmaxval   = maxval / 32767.0 ;
		position /= psf->sf.channels ;
		
		if (fmaxval > psf->peak.peak[chan].value)
		{	psf->peak.peak[chan].value = fmaxval ;
			psf->peak.peak[chan].position = psf->current - position ;
			} ;
		} ;
	
	return ;		
} /+* peak_update_short *+/

void	
peak_update_int		(SF_PRIVATE *psf, int *ptr, size_t items)
{	int		chan, k, position ;
	int		maxval ;
	float	fmaxval ;
	
	for (chan = 0 ; chan < psf->sf.channels ; chan++)
	{	maxval = abs (ptr [chan]) ;
		position = 0 ;
		for (k = chan ; k < items ; k += psf->sf.channels)
			if (maxval < abs (ptr [k]))
			{	maxval = abs (ptr [k]) ;
				position = k ;
				} ;
				
		fmaxval   = maxval / 0x7FFFFFFF ;
		position /= psf->sf.channels ;
		
		if (fmaxval > psf->peak.peak[chan].value)
		{	psf->peak.peak[chan].value = fmaxval ;
			psf->peak.peak[chan].position = psf->current - position ;
			} ;
		} ;
	
	return ;		
} /+* peak_update_int *+/

void	
peak_update_double	(SF_PRIVATE *psf, double *ptr, size_t items)
{	int		chan, k, position ;
	double	fmaxval ;
	
	for (chan = 0 ; chan < psf->sf.channels ; chan++)
	{	fmaxval = fabs (ptr [chan]) ;
		position = 0 ;
		for (k = chan ; k < items ; k += psf->sf.channels)
			if (fmaxval < fabs (ptr [k]))
			{	fmaxval = fabs (ptr [k]) ;
				position = k ;
				} ;

		position /= psf->sf.channels ;
		
		if (fmaxval > psf->peak.peak[chan].value)
		{	psf->peak.peak[chan].value = fmaxval ;
			psf->peak.peak[chan].position = psf->current - position ;
			} ;
		} ;
	
	return ;		
} /+* peak_update_double *+/
-*/