ulaw.c

Audacity是一款用於錄音和編輯聲音的、免費的開放源碼軟體。它可以執行於Mac OS X、Microsoft Windows、GNU/Linux和其它作業系統

#ifdef WIN32 //vvv for compatibility with MSVC++ 6, 7, & 8beta compilers
   #define inline  
#endif

static inline void
ulaw2s_array (unsigned char *buffer, int count, short *ptr)
{	while (--count >= 0)
		ptr [count] = ulaw_decode [(int) buffer [count]] ;
} /* ulaw2s_array */

static inline void
ulaw2i_array (unsigned char *buffer, int count, int *ptr)
{	while (--count >= 0)
		ptr [count] = ulaw_decode [buffer [count]] << 16 ;
} /* ulaw2i_array */

static inline void
ulaw2f_array (unsigned char *buffer, int count, float *ptr, float normfact)
{	while (--count >= 0)
		ptr [count] = normfact * ulaw_decode [(int) buffer [count]] ;
} /* ulaw2f_array */

static inline void
ulaw2d_array (unsigned char *buffer, int count, double *ptr, double normfact)
{	while (--count >= 0)
		ptr [count] = normfact * ulaw_decode [(int) buffer [count]] ;
} /* ulaw2d_array */

static inline void
s2ulaw_array (short *ptr, int count, unsigned char *buffer)
{	while (--count >= 0)
	{	if (ptr [count] >= 0)
			buffer [count] = ulaw_encode [ptr [count] / 4] ;
		else
			buffer [count] = 0x7F & ulaw_encode [ptr [count] / -4] ;
		} ;
} /* s2ulaw_array */

static inline void
i2ulaw_array (int *ptr, int count, unsigned char *buffer)
{	while (--count >= 0)
	{	if (ptr [count] >= 0)
			buffer [count] = ulaw_encode [ptr [count] >> (16 + 2)] ;
		else
			buffer [count] = 0x7F & ulaw_encode [-ptr [count] >> (16 + 2)] ;
		} ;
} /* i2ulaw_array */

static inline void
f2ulaw_array (float *ptr, int count, unsigned char *buffer, float normfact)
{	while (--count >= 0)
	{	if (ptr [count] >= 0)
			buffer [count] = ulaw_encode [lrintf (normfact * ptr [count])] ;
		else
			buffer [count] = 0x7F & ulaw_encode [- lrintf (normfact * ptr [count])] ;
		} ;
} /* f2ulaw_array */

static inline void
d2ulaw_array (double *ptr, int count, unsigned char *buffer, double normfact)
{	while (--count >= 0)
	{	if (ptr [count] >= 0)
			buffer [count] = ulaw_encode [lrint (normfact * ptr [count])] ;
		else
			buffer [count] = 0x7F & ulaw_encode [- lrint (normfact * ptr [count])] ;
		} ;
} /* d2ulaw_array */

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

static sf_count_t
ulaw_read_ulaw2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
{	int			bufferlen, readcount ;
	sf_count_t	total = 0 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
		ulaw2s_array (psf->u.ucbuf, readcount, ptr + total) ;
		total += readcount ;
		if (readcount < bufferlen)
			break ;
		len -= readcount ;
		} ;

	return total ;
} /* ulaw_read_ulaw2s */

static sf_count_t
ulaw_read_ulaw2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
{	int			bufferlen, readcount ;
	sf_count_t	total = 0 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
		ulaw2i_array (psf->u.ucbuf, readcount, ptr + total) ;
		total += readcount ;
		if (readcount < bufferlen)
			break ;
		len -= readcount ;
		} ;

	return total ;
} /* ulaw_read_ulaw2i */

static sf_count_t
ulaw_read_ulaw2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
{	int			bufferlen, readcount ;
	sf_count_t	total = 0 ;
	float	normfact ;

	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
		ulaw2f_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
		total += readcount ;
		if (readcount < bufferlen)
			break ;
		len -= readcount ;
		} ;

	return total ;
} /* ulaw_read_ulaw2f */

static sf_count_t
ulaw_read_ulaw2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
{	int			bufferlen, readcount ;
	sf_count_t	total = 0 ;
	double	normfact ;

	normfact = (psf->norm_double) ? 1.0 / ((double) 0x8000) : 1.0 ;
	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
		ulaw2d_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
		total += readcount ;
		if (readcount < bufferlen)
			break ;
		len -= readcount ;
		} ;

	return total ;
} /* ulaw_read_ulaw2d */

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

static sf_count_t
ulaw_write_s2ulaw	(SF_PRIVATE *psf, short *ptr, sf_count_t len)
{	int			bufferlen, writecount ;
	sf_count_t	total = 0 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		s2ulaw_array (ptr + total, bufferlen, psf->u.ucbuf) ;
		writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
		total += writecount ;
		if (writecount < bufferlen)
			break ;
		len -= writecount ;
		} ;

	return total ;
} /* ulaw_write_s2ulaw */

static sf_count_t
ulaw_write_i2ulaw	(SF_PRIVATE *psf, int *ptr, sf_count_t len)
{	int			bufferlen, writecount ;
	sf_count_t	total = 0 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		i2ulaw_array (ptr + total, bufferlen, psf->u.ucbuf) ;
		writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
		total += writecount ;
		if (writecount < bufferlen)
			break ;
		len -= writecount ;
		} ;

	return total ;
} /* ulaw_write_i2ulaw */

static sf_count_t
ulaw_write_f2ulaw	(SF_PRIVATE *psf, float *ptr, sf_count_t len)
{	int			bufferlen, writecount ;
	sf_count_t	total = 0 ;
	float	normfact ;

	/* Factor in a divide by 4. */
	normfact = (psf->norm_float == SF_TRUE) ? (0.25 * 0x7FFF) : 0.25 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		f2ulaw_array (ptr + total, bufferlen, psf->u.ucbuf, normfact) ;
		writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
		total += writecount ;
		if (writecount < bufferlen)
			break ;
		len -= writecount ;
		} ;

	return total ;
} /* ulaw_write_f2ulaw */

static sf_count_t
ulaw_write_d2ulaw	(SF_PRIVATE *psf, double *ptr, sf_count_t len)
{	int			bufferlen, writecount ;
	sf_count_t	total = 0 ;
	double	normfact ;

	/* Factor in a divide by 4. */
	normfact = (psf->norm_double) ? (0.25 * 0x7FFF) : 0.25 ;

	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;

	while (len > 0)
	{	if (len < bufferlen)
			bufferlen = (int) len ;
		d2ulaw_array (ptr + total, bufferlen, psf->u.ucbuf, normfact) ;
		writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
		total += writecount ;
		if (writecount < bufferlen)
			break ;
		len -= writecount ;
		} ;

	return total ;
} /* ulaw_write_d2ulaw */

/*
** Do not edit or modify anything in this comment block.
** The arch-tag line is a file identity tag for the GNU Arch 
** revision control system.
**
** arch-tag: 655cc790-f058-45e8-89c9-86967cccc37e
*/