float32.c

SIP（Session Initiation Protocol）是由IETF定义

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_READ ;
	
	return total ;
} /* host_read_f2d */

static int
host_write_s2f	(SF_PRIVATE *psf, short *ptr, int len)
{	unsigned int	writecount, thiswrite ;
	int	bytecount, bufferlen ;
	int		index = 0, total = 0 ;

	bufferlen = SF_BUFFER_LEN - (SF_BUFFER_LEN % psf->blockwidth) ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		s2f_array (ptr, index, (float*) (psf->buffer), writecount / psf->bytewidth) ;
		
		float32_peak_update (psf, (float *) (psf->buffer), writecount / psf->bytewidth, index / psf->sf.channels) ;
		
		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;
			
		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* host_write_s2f */

static int
host_write_i2f	(SF_PRIVATE *psf, int *ptr, int len)
{	unsigned int	writecount, thiswrite ;
	int	bytecount, bufferlen ;
	int		index = 0, total = 0 ;

	bufferlen = SF_BUFFER_LEN - (SF_BUFFER_LEN % psf->blockwidth) ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		i2f_array (ptr, index, (float*) (psf->buffer), writecount / psf->bytewidth) ;
		
		float32_peak_update (psf, (float *) (psf->buffer), writecount / psf->bytewidth, index / psf->sf.channels) ;
		
		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;
			
		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* host_write_i2f */

static int
host_write_f (SF_PRIVATE *psf, float *ptr, int len)
{	unsigned int	writecount, thiswrite ;
	int	bytecount, bufferlen ;
	int		index = 0, total = 0 ;

	float32_peak_update (psf, ptr, len, 0) ;
			
	if (psf->fl32_endswap != SF_TRUE)
		return fwrite (ptr, sizeof (float), len, psf->file) ;

	bufferlen = SF_BUFFER_LEN - (SF_BUFFER_LEN % psf->blockwidth) ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;

		memcpy (psf->buffer, ptr + index, writecount) ;
		
		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;
			
		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* host_write_f */

static int
host_write_d2f	(SF_PRIVATE *psf, double *ptr, int len, int normalize)
{	unsigned int	writecount, thiswrite ;
	int	bytecount, bufferlen ;
	int		index = 0, total = 0 ;

	bufferlen = SF_BUFFER_LEN - (SF_BUFFER_LEN % psf->blockwidth) ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		d2f_array (ptr, index, (float*) (psf->buffer), writecount / psf->bytewidth) ;
		
		float32_peak_update (psf, (float *) (psf->buffer), writecount / psf->bytewidth, index / psf->sf.channels) ;
		
		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;
			
		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* host_write_d2f */

/*=======================================================================================
*/

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	
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	
f2d_array (float *buffer, unsigned int count, double *ptr, int index)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	ptr [index] = ((double) buffer [k]) ;
		index ++ ;
		} ;
} /* f2d_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	
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	
d2f_array (double *ptr, int index, float *buffer, unsigned int count)
{	int	k ;
	for (k = 0 ; k < count ; k++)
	{	buffer [k] = (float) (ptr [index]) ;
		index ++ ;
		} ;
} /* d2f_array */

/*=======================================================================================
*/

static int		
broken_read_f2s (SF_PRIVATE *psf, short *ptr, int len)
{	unsigned int	bytecount, readcount, bufferlen, thisread ;
	int				index = 0, total = 0 ;
		
	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	readcount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		thisread = fread (psf->buffer, 1, readcount, psf->file) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, readcount / sizeof (int)) ;

		bf2f_array ((float *) (psf->buffer), readcount / psf->bytewidth) ;

		f2s_array ((float*) (psf->buffer), thisread / psf->bytewidth, ptr, index) ;
		total += thisread ;
		if (thisread < readcount)
			break ;
		index += thisread / psf->bytewidth ;
		bytecount -= thisread ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_READ ;
	
	return total ;
} /* broken_read_f2s */

static int		
broken_read_f2i (SF_PRIVATE *psf, int *ptr, int len)
{	unsigned int	bytecount, readcount, bufferlen, thisread ;
	int				index = 0, total = 0 ;

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	readcount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		thisread = fread (psf->buffer, 1, readcount, psf->file) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, readcount / sizeof (int)) ;

		bf2f_array ((float *) (psf->buffer), readcount / psf->bytewidth) ;

		f2i_array ((float*) (psf->buffer), thisread / psf->bytewidth, ptr, index) ;
		total += thisread ;
		if (thisread < readcount)
			break ;
		index += thisread / psf->bytewidth ;
		bytecount -= thisread ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_READ ;
	
	return total ;
} /* broken_read_f2i */

static int		
broken_read_f (SF_PRIVATE *psf, float *ptr, int len)
{	unsigned int	bytecount, readcount, bufferlen, thisread ;
	int				index = 0, total = 0 ;
	
	/* FIX THIS */

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	readcount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		thisread = fread (psf->buffer, 1, readcount, psf->file) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, readcount / sizeof (int)) ;

		bf2f_array ((float *) (psf->buffer), readcount / psf->bytewidth) ;

		memcpy (ptr + index, psf->buffer, readcount) ;
		
		total += thisread ;
		if (thisread < readcount)
			break ;
		index += thisread / psf->bytewidth ;
		bytecount -= thisread ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_READ ;
	
	return total ;
} /* broken_read_f */

static int		
broken_read_f2d (SF_PRIVATE *psf, double *ptr, int len, int normalize)
{	unsigned int	bytecount, readcount, bufferlen, thisread ;
	int				index = 0, total = 0 ;

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	readcount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		thisread = fread (psf->buffer, 1, readcount, psf->file) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, readcount / sizeof (int)) ;

		bf2f_array ((float *) (psf->buffer), readcount / psf->bytewidth) ;

		f2d_array ((float*) (psf->buffer), thisread / psf->bytewidth, ptr, index) ;
		total += thisread ;
		if (thisread < readcount)
			break ;
		index += thisread / psf->bytewidth ;
		bytecount -= thisread ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_READ ;
	
	return total ;
} /* broken_read_f2d */

static int	
broken_write_s2f (SF_PRIVATE *psf, short *ptr, int len)
{	unsigned int	bytecount, writecount, bufferlen, thiswrite ;
	int				index = 0, total = 0 ;

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		s2f_array (ptr, index, (float*) (psf->buffer), writecount / psf->bytewidth) ;

		float32_peak_update (psf, (float *) (psf->buffer), writecount / psf->bytewidth, index / psf->sf.channels) ;

		f2bf_array ((float *) (psf->buffer), writecount / psf->bytewidth) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;

		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* broken_write_s2f */

static int	
broken_write_i2f (SF_PRIVATE *psf, int *ptr, int len) 
{	unsigned int	bytecount, writecount, bufferlen, thiswrite ;
	int				index = 0, total = 0 ;

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		i2f_array (ptr, index, (float*) (psf->buffer), writecount / psf->bytewidth) ;

		float32_peak_update (psf, (float *) (psf->buffer), writecount / psf->bytewidth, index / psf->sf.channels) ;

		f2bf_array ((float *) (psf->buffer), writecount / psf->bytewidth) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;

		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* broken_write_i2f */

static int	
broken_write_f (SF_PRIVATE *psf, float *ptr, int len)
{	unsigned int	bytecount, writecount, bufferlen, thiswrite ;
	int				index = 0, total = 0 ;
	
	/* FIX THIS */
	float32_peak_update (psf, ptr, len, 0) ;

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;

		memcpy (psf->buffer, ptr + index, writecount) ;

		f2bf_array ((float *) (psf->buffer), writecount / psf->bytewidth) ;
		
		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;

		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* broken_write_f */

static int	
broken_write_d2f (SF_PRIVATE *psf, double *ptr, int len, int normalize)
{	unsigned int	bytecount, writecount, bufferlen, thiswrite ;
	int				index = 0, total = 0 ;

	bufferlen = (SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth ;
	bytecount = len * psf->bytewidth ;
	while (bytecount > 0)
	{	writecount = (bytecount >= bufferlen) ? bufferlen : bytecount ;
		d2f_array (ptr, index, (float*) (psf->buffer), writecount / psf->bytewidth) ;

		float32_peak_update (psf, (float *) (psf->buffer), writecount / psf->bytewidth, index / psf->sf.channels) ;

		f2bf_array ((float *) (psf->buffer), writecount / psf->bytewidth) ;

		if (psf->fl32_endswap == SF_TRUE)
			endswap_int_array ((int*) psf->buffer, writecount / sizeof (int)) ;

		thiswrite = fwrite (psf->buffer, 1, writecount, psf->file) ;
		total += thiswrite ;
		if (thiswrite < writecount)
			break ;
		index += thiswrite / psf->bytewidth ;
		bytecount -= thiswrite ;
		} ;

	total /= psf->bytewidth ;
	if (total < len)
		psf->error = SFE_SHORT_WRITE ;
	
	return total ;
} /* broken_write_d2f */

/*==============================================================================
*/

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

static void	
bf2f_array (float *buffer, unsigned int count)
{	int	k ;
	
	for (k = 0 ; k < count ; k++)
		buffer [k] = float32_read ((unsigned char *) (buffer + k)) ;
} /* bf2f_array */

static void	
f2bf_array (float *buffer, unsigned int count)
{	int	k ;
	
	for (k = 0 ; k < count ; k++)
		float32_write (buffer [k], (unsigned char*) (buffer + k)) ;
} /* f2bf_array */