PageRenderTime 214ms CodeModel.GetById 18ms app.highlight 181ms RepoModel.GetById 2ms app.codeStats 0ms

/project/jni/sndfile/src/pcm.c

https://github.com/aichunyu/FFPlayer
C | 2901 lines | 2296 code | 518 blank | 87 comment | 395 complexity | 98344d59715f9dffedd871eba32ed2a2 MD5 | raw file
   1/*
   2** Copyright (C) 1999-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
   3**
   4** This program is free software; you can redistribute it and/or modify
   5** it under the terms of the GNU Lesser General Public License as published by
   6** the Free Software Foundation; either version 2.1 of the License, or
   7** (at your option) any later version.
   8**
   9** This program is distributed in the hope that it will be useful,
  10** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12** GNU Lesser General Public License for more details.
  13**
  14** You should have received a copy of the GNU Lesser General Public License
  15** along with this program; if not, write to the Free Software
  16** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17*/
  18
  19#include	"sfconfig.h"
  20
  21#include <math.h>
  22
  23#include	"sndfile.h"
  24#include	"sfendian.h"
  25#include	"common.h"
  26
  27/* Need to be able to handle 3 byte (24 bit) integers. So defined a
  28** type and use SIZEOF_TRIBYTE instead of (tribyte).
  29*/
  30
  31typedef	void	tribyte ;
  32
  33#define	SIZEOF_TRIBYTE	3
  34
  35static sf_count_t	pcm_read_sc2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  36static sf_count_t	pcm_read_uc2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  37static sf_count_t	pcm_read_bes2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  38static sf_count_t	pcm_read_les2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  39static sf_count_t	pcm_read_bet2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  40static sf_count_t	pcm_read_let2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  41static sf_count_t	pcm_read_bei2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  42static sf_count_t	pcm_read_lei2s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  43
  44static sf_count_t	pcm_read_sc2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  45static sf_count_t	pcm_read_uc2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  46static sf_count_t	pcm_read_bes2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  47static sf_count_t	pcm_read_les2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  48static sf_count_t	pcm_read_bet2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  49static sf_count_t	pcm_read_let2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  50static sf_count_t	pcm_read_bei2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  51static sf_count_t	pcm_read_lei2i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  52
  53static sf_count_t	pcm_read_sc2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  54static sf_count_t	pcm_read_uc2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  55static sf_count_t	pcm_read_bes2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  56static sf_count_t	pcm_read_les2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  57static sf_count_t	pcm_read_bet2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  58static sf_count_t	pcm_read_let2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  59static sf_count_t	pcm_read_bei2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  60static sf_count_t	pcm_read_lei2f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  61
  62static sf_count_t	pcm_read_sc2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  63static sf_count_t	pcm_read_uc2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  64static sf_count_t	pcm_read_bes2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  65static sf_count_t	pcm_read_les2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  66static sf_count_t	pcm_read_bet2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  67static sf_count_t	pcm_read_let2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  68static sf_count_t	pcm_read_bei2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  69static sf_count_t	pcm_read_lei2d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  70
  71static sf_count_t	pcm_write_s2sc	(SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  72static sf_count_t	pcm_write_s2uc	(SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  73static sf_count_t	pcm_write_s2bes (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  74static sf_count_t	pcm_write_s2les (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  75static sf_count_t	pcm_write_s2bet (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  76static sf_count_t	pcm_write_s2let (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  77static sf_count_t	pcm_write_s2bei (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  78static sf_count_t	pcm_write_s2lei (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  79
  80static sf_count_t	pcm_write_i2sc	(SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  81static sf_count_t	pcm_write_i2uc	(SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  82static sf_count_t	pcm_write_i2bes (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  83static sf_count_t	pcm_write_i2les (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  84static sf_count_t	pcm_write_i2bet (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  85static sf_count_t	pcm_write_i2let (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  86static sf_count_t	pcm_write_i2bei (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  87static sf_count_t	pcm_write_i2lei (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  88
  89static sf_count_t	pcm_write_f2sc	(SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  90static sf_count_t	pcm_write_f2uc	(SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  91static sf_count_t	pcm_write_f2bes (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  92static sf_count_t	pcm_write_f2les (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  93static sf_count_t	pcm_write_f2bet (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  94static sf_count_t	pcm_write_f2let (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  95static sf_count_t	pcm_write_f2bei (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  96static sf_count_t	pcm_write_f2lei (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  97
  98static sf_count_t	pcm_write_d2sc	(SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
  99static sf_count_t	pcm_write_d2uc	(SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 100static sf_count_t	pcm_write_d2bes (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 101static sf_count_t	pcm_write_d2les (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 102static sf_count_t	pcm_write_d2bet (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 103static sf_count_t	pcm_write_d2let (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 104static sf_count_t	pcm_write_d2bei (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 105static sf_count_t	pcm_write_d2lei (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 106
 107/*-----------------------------------------------------------------------------------------------
 108*/
 109
 110enum
 111{	/* Char type for 8 bit files. */
 112	SF_CHARS_SIGNED		= 200,
 113	SF_CHARS_UNSIGNED	= 201
 114} ;
 115
 116/*-----------------------------------------------------------------------------------------------
 117*/
 118
 119int
 120pcm_init (SF_PRIVATE *psf)
 121{	int chars = 0 ;
 122
 123	if (psf->bytewidth == 0 || psf->sf.channels == 0)
 124	{	psf_log_printf (psf, "pcm_init : internal error : bytewitdh = %d, channels = %d\n", psf->bytewidth, psf->sf.channels) ;
 125		return SFE_INTERNAL ;
 126		} ;
 127
 128	psf->blockwidth = psf->bytewidth * psf->sf.channels ;
 129
 130	if ((SF_CODEC (psf->sf.format)) == SF_FORMAT_PCM_S8)
 131		chars = SF_CHARS_SIGNED ;
 132	else if ((SF_CODEC (psf->sf.format)) == SF_FORMAT_PCM_U8)
 133		chars = SF_CHARS_UNSIGNED ;
 134
 135	if (CPU_IS_BIG_ENDIAN)
 136		psf->data_endswap = (psf->endian == SF_ENDIAN_BIG) ? SF_FALSE : SF_TRUE ;
 137	else
 138		psf->data_endswap = (psf->endian == SF_ENDIAN_LITTLE) ? SF_FALSE : SF_TRUE ;
 139
 140	if (psf->file.mode == SFM_READ || psf->file.mode == SFM_RDWR)
 141	{	switch (psf->bytewidth * 0x10000 + psf->endian + chars)
 142		{	case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_SIGNED) :
 143			case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_SIGNED) :
 144					psf->read_short		= pcm_read_sc2s ;
 145					psf->read_int		= pcm_read_sc2i ;
 146					psf->read_float		= pcm_read_sc2f ;
 147					psf->read_double	= pcm_read_sc2d ;
 148					break ;
 149			case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_UNSIGNED) :
 150			case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_UNSIGNED) :
 151					psf->read_short		= pcm_read_uc2s ;
 152					psf->read_int		= pcm_read_uc2i ;
 153					psf->read_float		= pcm_read_uc2f ;
 154					psf->read_double	= pcm_read_uc2d ;
 155					break ;
 156
 157			case (2 * 0x10000 + SF_ENDIAN_BIG) :
 158					psf->read_short		= pcm_read_bes2s ;
 159					psf->read_int		= pcm_read_bes2i ;
 160					psf->read_float		= pcm_read_bes2f ;
 161					psf->read_double	= pcm_read_bes2d ;
 162					break ;
 163			case (3 * 0x10000 + SF_ENDIAN_BIG) :
 164					psf->read_short		= pcm_read_bet2s ;
 165					psf->read_int		= pcm_read_bet2i ;
 166					psf->read_float		= pcm_read_bet2f ;
 167					psf->read_double	= pcm_read_bet2d ;
 168					break ;
 169			case (4 * 0x10000 + SF_ENDIAN_BIG) :
 170
 171					psf->read_short		= pcm_read_bei2s ;
 172					psf->read_int		= pcm_read_bei2i ;
 173					psf->read_float		= pcm_read_bei2f ;
 174					psf->read_double	= pcm_read_bei2d ;
 175					break ;
 176
 177			case (2 * 0x10000 + SF_ENDIAN_LITTLE) :
 178					psf->read_short		= pcm_read_les2s ;
 179					psf->read_int		= pcm_read_les2i ;
 180					psf->read_float		= pcm_read_les2f ;
 181					psf->read_double	= pcm_read_les2d ;
 182					break ;
 183			case (3 * 0x10000 + SF_ENDIAN_LITTLE) :
 184					psf->read_short		= pcm_read_let2s ;
 185					psf->read_int		= pcm_read_let2i ;
 186					psf->read_float		= pcm_read_let2f ;
 187					psf->read_double	= pcm_read_let2d ;
 188					break ;
 189			case (4 * 0x10000 + SF_ENDIAN_LITTLE) :
 190					psf->read_short		= pcm_read_lei2s ;
 191					psf->read_int		= pcm_read_lei2i ;
 192					psf->read_float		= pcm_read_lei2f ;
 193					psf->read_double	= pcm_read_lei2d ;
 194					break ;
 195			default :
 196				psf_log_printf (psf, "pcm.c returning SFE_UNIMPLEMENTED\nbytewidth %d    endian %d\n", psf->bytewidth, psf->endian) ;
 197				return SFE_UNIMPLEMENTED ;
 198			} ;
 199		} ;
 200
 201	if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
 202	{	switch (psf->bytewidth * 0x10000 + psf->endian + chars)
 203		{	case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_SIGNED) :
 204			case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_SIGNED) :
 205					psf->write_short	= pcm_write_s2sc ;
 206					psf->write_int		= pcm_write_i2sc ;
 207					psf->write_float	= pcm_write_f2sc ;
 208					psf->write_double	= pcm_write_d2sc ;
 209					break ;
 210			case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_UNSIGNED) :
 211			case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_UNSIGNED) :
 212					psf->write_short	= pcm_write_s2uc ;
 213					psf->write_int		= pcm_write_i2uc ;
 214					psf->write_float	= pcm_write_f2uc ;
 215					psf->write_double	= pcm_write_d2uc ;
 216					break ;
 217
 218			case (2 * 0x10000 + SF_ENDIAN_BIG) :
 219					psf->write_short	= pcm_write_s2bes ;
 220					psf->write_int		= pcm_write_i2bes ;
 221					psf->write_float	= pcm_write_f2bes ;
 222					psf->write_double	= pcm_write_d2bes ;
 223					break ;
 224
 225			case (3 * 0x10000 + SF_ENDIAN_BIG) :
 226					psf->write_short	= pcm_write_s2bet ;
 227					psf->write_int		= pcm_write_i2bet ;
 228					psf->write_float	= pcm_write_f2bet ;
 229					psf->write_double	= pcm_write_d2bet ;
 230					break ;
 231
 232			case (4 * 0x10000 + SF_ENDIAN_BIG) :
 233					psf->write_short	= pcm_write_s2bei ;
 234					psf->write_int		= pcm_write_i2bei ;
 235					psf->write_float	= pcm_write_f2bei ;
 236					psf->write_double	= pcm_write_d2bei ;
 237					break ;
 238
 239			case (2 * 0x10000 + SF_ENDIAN_LITTLE) :
 240					psf->write_short	= pcm_write_s2les ;
 241					psf->write_int		= pcm_write_i2les ;
 242					psf->write_float	= pcm_write_f2les ;
 243					psf->write_double	= pcm_write_d2les ;
 244					break ;
 245
 246			case (3 * 0x10000 + SF_ENDIAN_LITTLE) :
 247					psf->write_short	= pcm_write_s2let ;
 248					psf->write_int		= pcm_write_i2let ;
 249					psf->write_float	= pcm_write_f2let ;
 250					psf->write_double	= pcm_write_d2let ;
 251					break ;
 252
 253			case (4 * 0x10000 + SF_ENDIAN_LITTLE) :
 254					psf->write_short	= pcm_write_s2lei ;
 255					psf->write_int		= pcm_write_i2lei ;
 256					psf->write_float	= pcm_write_f2lei ;
 257					psf->write_double	= pcm_write_d2lei ;
 258					break ;
 259
 260			default :
 261				psf_log_printf (psf, "pcm.c returning SFE_UNIMPLEMENTED\nbytewidth %s    endian %d\n", psf->bytewidth, psf->endian) ;
 262				return SFE_UNIMPLEMENTED ;
 263			} ;
 264
 265		} ;
 266
 267	if (psf->filelength > psf->dataoffset)
 268	{	psf->datalength = (psf->dataend > 0) ? psf->dataend - psf->dataoffset :
 269							psf->filelength - psf->dataoffset ;
 270		}
 271	else
 272		psf->datalength = 0 ;
 273
 274	psf->sf.frames = psf->blockwidth > 0 ? psf->datalength / psf->blockwidth : 0 ;
 275
 276	return 0 ;
 277} /* pcm_init */
 278
 279/*==============================================================================
 280*/
 281
 282static inline void
 283sc2s_array	(signed char *src, int count, short *dest)
 284{	while (--count >= 0)
 285	{	dest [count] = src [count] << 8 ;
 286		} ;
 287} /* sc2s_array */
 288
 289static inline void
 290uc2s_array	(unsigned char *src, int count, short *dest)
 291{	while (--count >= 0)
 292	{	dest [count] = (((short) src [count]) - 0x80) << 8 ;
 293		} ;
 294} /* uc2s_array */
 295
 296static inline void
 297let2s_array (tribyte *src, int count, short *dest)
 298{	unsigned char	*ucptr ;
 299
 300	ucptr = ((unsigned char*) src) + 3 * count ;
 301	while (--count >= 0)
 302	{	ucptr -= 3 ;
 303		dest [count] = LET2H_SHORT_PTR (ucptr) ;
 304		} ;
 305} /* let2s_array */
 306
 307static inline void
 308bet2s_array (tribyte *src, int count, short *dest)
 309{	unsigned char	*ucptr ;
 310
 311	ucptr = ((unsigned char*) src) + 3 * count ;
 312	while (--count >= 0)
 313	{	ucptr -= 3 ;
 314		dest [count] = BET2H_SHORT_PTR (ucptr) ;
 315			} ;
 316} /* bet2s_array */
 317
 318static inline void
 319lei2s_array (int *src, int count, short *dest)
 320{	int value ;
 321
 322	while (--count >= 0)
 323	{	value = LEI2H_INT (src [count]) ;
 324		dest [count] = value >> 16 ;
 325		} ;
 326} /* lei2s_array */
 327
 328static inline void
 329bei2s_array (int *src, int count, short *dest)
 330{	int value ;
 331
 332	while (--count >= 0)
 333	{	value = BEI2H_INT (src [count]) ;
 334		dest [count] = value >> 16 ;
 335		} ;
 336} /* bei2s_array */
 337
 338/*--------------------------------------------------------------------------
 339*/
 340
 341static inline void
 342sc2i_array	(signed char *src, int count, int *dest)
 343{	while (--count >= 0)
 344	{	dest [count] = ((int) src [count]) << 24 ;
 345		} ;
 346} /* sc2i_array */
 347
 348static inline void
 349uc2i_array	(unsigned char *src, int count, int *dest)
 350{	while (--count >= 0)
 351	{	dest [count] = (((int) src [count]) - 128) << 24 ;
 352		} ;
 353} /* uc2i_array */
 354
 355static inline void
 356bes2i_array (short *src, int count, int *dest)
 357{	short value ;
 358
 359	while (--count >= 0)
 360	{	value = BES2H_SHORT (src [count]) ;
 361		dest [count] = value << 16 ;
 362		} ;
 363} /* bes2i_array */
 364
 365static inline void
 366les2i_array (short *src, int count, int *dest)
 367{	short value ;
 368
 369	while (--count >= 0)
 370	{	value = LES2H_SHORT (src [count]) ;
 371		dest [count] = value << 16 ;
 372		} ;
 373} /* les2i_array */
 374
 375static inline void
 376bet2i_array (tribyte *src, int count, int *dest)
 377{	unsigned char	*ucptr ;
 378
 379	ucptr = ((unsigned char*) src) + 3 * count ;
 380	while (--count >= 0)
 381	{	ucptr -= 3 ;
 382		dest [count] = BET2H_INT_PTR (ucptr) ;
 383			} ;
 384} /* bet2i_array */
 385
 386static inline void
 387let2i_array (tribyte *src, int count, int *dest)
 388{	unsigned char	*ucptr ;
 389
 390	ucptr = ((unsigned char*) src) + 3 * count ;
 391	while (--count >= 0)
 392	{	ucptr -= 3 ;
 393		dest [count] = LET2H_INT_PTR (ucptr) ;
 394		} ;
 395} /* let2i_array */
 396
 397/*--------------------------------------------------------------------------
 398*/
 399
 400static inline void
 401sc2f_array	(signed char *src, int count, float *dest, float normfact)
 402{	while (--count >= 0)
 403		dest [count] = ((float) src [count]) * normfact ;
 404} /* sc2f_array */
 405
 406static inline void
 407uc2f_array	(unsigned char *src, int count, float *dest, float normfact)
 408{	while (--count >= 0)
 409		dest [count] = (((int) src [count]) - 128) * normfact ;
 410} /* uc2f_array */
 411
 412static inline void
 413les2f_array (short *src, int count, float *dest, float normfact)
 414{	short	value ;
 415
 416	while (--count >= 0)
 417	{	value = src [count] ;
 418		value = LES2H_SHORT (value) ;
 419		dest [count] = ((float) value) * normfact ;
 420		} ;
 421} /* les2f_array */
 422
 423static inline void
 424bes2f_array (short *src, int count, float *dest, float normfact)
 425{	short			value ;
 426
 427	while (--count >= 0)
 428	{	value = src [count] ;
 429		value = BES2H_SHORT (value) ;
 430		dest [count] = ((float) value) * normfact ;
 431		} ;
 432} /* bes2f_array */
 433
 434static inline void
 435let2f_array (tribyte *src, int count, float *dest, float normfact)
 436{	unsigned char	*ucptr ;
 437	int 			value ;
 438
 439	ucptr = ((unsigned char*) src) + 3 * count ;
 440	while (--count >= 0)
 441	{	ucptr -= 3 ;
 442		value = LET2H_INT_PTR (ucptr) ;
 443		dest [count] = ((float) value) * normfact ;
 444		} ;
 445} /* let2f_array */
 446
 447static inline void
 448bet2f_array (tribyte *src, int count, float *dest, float normfact)
 449{	unsigned char	*ucptr ;
 450	int				value ;
 451
 452	ucptr = ((unsigned char*) src) + 3 * count ;
 453	while (--count >= 0)
 454	{	ucptr -= 3 ;
 455		value = BET2H_INT_PTR (ucptr) ;
 456		dest [count] = ((float) value) * normfact ;
 457			} ;
 458} /* bet2f_array */
 459
 460static inline void
 461lei2f_array (int *src, int count, float *dest, float normfact)
 462{	int 			value ;
 463
 464	while (--count >= 0)
 465	{	value = src [count] ;
 466		value = LEI2H_INT (value) ;
 467		dest [count] = ((float) value) * normfact ;
 468		} ;
 469} /* lei2f_array */
 470
 471static inline void
 472bei2f_array (int *src, int count, float *dest, float normfact)
 473{	int 			value ;
 474
 475	while (--count >= 0)
 476	{	value = src [count] ;
 477		value = BEI2H_INT (value) ;
 478		dest [count] = ((float) value) * normfact ;
 479		} ;
 480} /* bei2f_array */
 481
 482/*--------------------------------------------------------------------------
 483*/
 484
 485static inline void
 486sc2d_array	(signed char *src, int count, double *dest, double normfact)
 487{	while (--count >= 0)
 488		dest [count] = ((double) src [count]) * normfact ;
 489} /* sc2d_array */
 490
 491static inline void
 492uc2d_array	(unsigned char *src, int count, double *dest, double normfact)
 493{	while (--count >= 0)
 494		dest [count] = (((int) src [count]) - 128) * normfact ;
 495} /* uc2d_array */
 496
 497static inline void
 498les2d_array (short *src, int count, double *dest, double normfact)
 499{	short	value ;
 500
 501	while (--count >= 0)
 502	{	value = src [count] ;
 503		value = LES2H_SHORT (value) ;
 504		dest [count] = ((double) value) * normfact ;
 505		} ;
 506} /* les2d_array */
 507
 508static inline void
 509bes2d_array (short *src, int count, double *dest, double normfact)
 510{	short	value ;
 511
 512	while (--count >= 0)
 513	{	value = src [count] ;
 514		value = BES2H_SHORT (value) ;
 515		dest [count] = ((double) value) * normfact ;
 516		} ;
 517} /* bes2d_array */
 518
 519static inline void
 520let2d_array (tribyte *src, int count, double *dest, double normfact)
 521{	unsigned char	*ucptr ;
 522	int				value ;
 523
 524	ucptr = ((unsigned char*) src) + 3 * count ;
 525	while (--count >= 0)
 526	{	ucptr -= 3 ;
 527		value = LET2H_INT_PTR (ucptr) ;
 528		dest [count] = ((double) value) * normfact ;
 529		} ;
 530} /* let2d_array */
 531
 532static inline void
 533bet2d_array (tribyte *src, int count, double *dest, double normfact)
 534{	unsigned char	*ucptr ;
 535	int				value ;
 536
 537	ucptr = ((unsigned char*) src) + 3 * count ;
 538	while (--count >= 0)
 539	{	ucptr -= 3 ;
 540		value = (ucptr [0] << 24) | (ucptr [1] << 16) | (ucptr [2] << 8) ;
 541		dest [count] = ((double) value) * normfact ;
 542		} ;
 543} /* bet2d_array */
 544
 545static inline void
 546lei2d_array (int *src, int count, double *dest, double normfact)
 547{	int 	value ;
 548
 549	while (--count >= 0)
 550	{	value = src [count] ;
 551		value = LEI2H_INT (value) ;
 552		dest [count] = ((double) value) * normfact ;
 553		} ;
 554} /* lei2d_array */
 555
 556static inline void
 557bei2d_array (int *src, int count, double *dest, double normfact)
 558{	int 	value ;
 559
 560	while (--count >= 0)
 561	{	value = src [count] ;
 562		value = BEI2H_INT (value) ;
 563		dest [count] = ((double) value) * normfact ;
 564		} ;
 565} /* bei2d_array */
 566
 567/*--------------------------------------------------------------------------
 568*/
 569
 570static inline void
 571s2sc_array	(const short *src, signed char *dest, int count)
 572{	while (--count >= 0)
 573		dest [count] = src [count] >> 8 ;
 574} /* s2sc_array */
 575
 576static inline void
 577s2uc_array	(const short *src, unsigned char *dest, int count)
 578{	while (--count >= 0)
 579		dest [count] = (src [count] >> 8) + 0x80 ;
 580} /* s2uc_array */
 581
 582static inline void
 583s2let_array (const short *src, tribyte *dest, int count)
 584{	unsigned char	*ucptr ;
 585
 586	ucptr = ((unsigned char*) dest) + 3 * count ;
 587	while (--count >= 0)
 588	{	ucptr -= 3 ;
 589		ucptr [0] = 0 ;
 590		ucptr [1] = src [count] ;
 591		ucptr [2] = src [count] >> 8 ;
 592		} ;
 593} /* s2let_array */
 594
 595static inline void
 596s2bet_array (const short *src, tribyte *dest, int count)
 597{	unsigned char	*ucptr ;
 598
 599	ucptr = ((unsigned char*) dest) + 3 * count ;
 600	while (--count >= 0)
 601	{	ucptr -= 3 ;
 602		ucptr [2] = 0 ;
 603		ucptr [1] = src [count] ;
 604		ucptr [0] = src [count] >> 8 ;
 605		} ;
 606} /* s2bet_array */
 607
 608static inline void
 609s2lei_array (const short *src, int *dest, int count)
 610{	unsigned char	*ucptr ;
 611
 612	ucptr = ((unsigned char*) dest) + 4 * count ;
 613	while (--count >= 0)
 614	{	ucptr -= 4 ;
 615		ucptr [0] = 0 ;
 616		ucptr [1] = 0 ;
 617		ucptr [2] = src [count] ;
 618		ucptr [3] = src [count] >> 8 ;
 619		} ;
 620} /* s2lei_array */
 621
 622static inline void
 623s2bei_array (const short *src, int *dest, int count)
 624{	unsigned char	*ucptr ;
 625
 626	ucptr = ((unsigned char*) dest) + 4 * count ;
 627	while (--count >= 0)
 628	{	ucptr -= 4 ;
 629		ucptr [0] = src [count] >> 8 ;
 630		ucptr [1] = src [count] ;
 631		ucptr [2] = 0 ;
 632		ucptr [3] = 0 ;
 633		} ;
 634} /* s2bei_array */
 635
 636/*--------------------------------------------------------------------------
 637*/
 638
 639static inline void
 640i2sc_array	(const int *src, signed char *dest, int count)
 641{	while (--count >= 0)
 642		dest [count] = (src [count] >> 24) ;
 643} /* i2sc_array */
 644
 645static inline void
 646i2uc_array	(const int *src, unsigned char *dest, int count)
 647{	while (--count >= 0)
 648		dest [count] = ((src [count] >> 24) + 128) ;
 649} /* i2uc_array */
 650
 651static inline void
 652i2bes_array (const int *src, short *dest, int count)
 653{	unsigned char	*ucptr ;
 654
 655	ucptr = ((unsigned char*) dest) + 2 * count ;
 656	while (--count >= 0)
 657	{	ucptr -= 2 ;
 658		ucptr [0] = src [count] >> 24 ;
 659		ucptr [1] = src [count] >> 16 ;
 660		} ;
 661} /* i2bes_array */
 662
 663static inline void
 664i2les_array (const int *src, short *dest, int count)
 665{	unsigned char	*ucptr ;
 666
 667	ucptr = ((unsigned char*) dest) + 2 * count ;
 668	while (--count >= 0)
 669	{	ucptr -= 2 ;
 670		ucptr [0] = src [count] >> 16 ;
 671		ucptr [1] = src [count] >> 24 ;
 672		} ;
 673} /* i2les_array */
 674
 675static inline void
 676i2let_array (const int *src, tribyte *dest, int count)
 677{	unsigned char	*ucptr ;
 678	int				value ;
 679
 680	ucptr = ((unsigned char*) dest) + 3 * count ;
 681	while (--count >= 0)
 682	{	ucptr -= 3 ;
 683		value = src [count] >> 8 ;
 684		ucptr [0] = value ;
 685		ucptr [1] = value >> 8 ;
 686		ucptr [2] = value >> 16 ;
 687		} ;
 688} /* i2let_array */
 689
 690static inline void
 691i2bet_array (const int *src, tribyte *dest, int count)
 692{	unsigned char	*ucptr ;
 693	int				value ;
 694
 695	ucptr = ((unsigned char*) dest) + 3 * count ;
 696	while (--count >= 0)
 697	{	ucptr -= 3 ;
 698		value = src [count] >> 8 ;
 699		ucptr [2] = value ;
 700		ucptr [1] = value >> 8 ;
 701		ucptr [0] = value >> 16 ;
 702		} ;
 703} /* i2bet_array */
 704
 705/*===============================================================================================
 706*/
 707
 708static sf_count_t
 709pcm_read_sc2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 710{	int			bufferlen, readcount ;
 711	sf_count_t	total = 0 ;
 712
 713	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
 714
 715	while (len > 0)
 716	{	if (len < bufferlen)
 717			bufferlen = (int) len ;
 718		readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
 719		sc2s_array (psf->u.scbuf, readcount, ptr + total) ;
 720		total += readcount ;
 721		if (readcount < bufferlen)
 722			break ;
 723		len -= readcount ;
 724		} ;
 725
 726	return total ;
 727} /* pcm_read_sc2s */
 728
 729static sf_count_t
 730pcm_read_uc2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 731{	int			bufferlen, readcount ;
 732	sf_count_t	total = 0 ;
 733
 734	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
 735
 736	while (len > 0)
 737	{	if (len < bufferlen)
 738			bufferlen = (int) len ;
 739		readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
 740		uc2s_array (psf->u.ucbuf, readcount, ptr + total) ;
 741		total += readcount ;
 742		if (readcount < bufferlen)
 743			break ;
 744		len -= readcount ;
 745		} ;
 746
 747	return total ;
 748} /* pcm_read_uc2s */
 749
 750static sf_count_t
 751pcm_read_bes2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 752{	int		total ;
 753
 754	total = psf_fread (ptr, sizeof (short), len, psf) ;
 755	if (CPU_IS_LITTLE_ENDIAN)
 756		endswap_short_array (ptr, len) ;
 757
 758	return total ;
 759} /* pcm_read_bes2s */
 760
 761static sf_count_t
 762pcm_read_les2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 763{	int		total ;
 764
 765	total = psf_fread (ptr, sizeof (short), len, psf) ;
 766	if (CPU_IS_BIG_ENDIAN)
 767		endswap_short_array (ptr, len) ;
 768
 769	return total ;
 770} /* pcm_read_les2s */
 771
 772static sf_count_t
 773pcm_read_bet2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 774{	int			bufferlen, readcount ;
 775	sf_count_t	total = 0 ;
 776
 777	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
 778
 779	while (len > 0)
 780	{	if (len < bufferlen)
 781			bufferlen = (int) len ;
 782		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
 783		bet2s_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
 784		total += readcount ;
 785		if (readcount < bufferlen)
 786			break ;
 787		len -= readcount ;
 788		} ;
 789
 790	return total ;
 791} /* pcm_read_bet2s */
 792
 793static sf_count_t
 794pcm_read_let2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 795{	int			bufferlen, readcount ;
 796	sf_count_t	total = 0 ;
 797
 798	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
 799
 800	while (len > 0)
 801	{	if (len < bufferlen)
 802			bufferlen = (int) len ;
 803		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
 804		let2s_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
 805		total += readcount ;
 806		if (readcount < bufferlen)
 807			break ;
 808		len -= readcount ;
 809		} ;
 810
 811	return total ;
 812} /* pcm_read_let2s */
 813
 814static sf_count_t
 815pcm_read_bei2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 816{	int			bufferlen, readcount ;
 817	sf_count_t	total = 0 ;
 818
 819	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
 820
 821	while (len > 0)
 822	{	if (len < bufferlen)
 823			bufferlen = (int) len ;
 824		readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
 825		bei2s_array (psf->u.ibuf, readcount, ptr + total) ;
 826		total += readcount ;
 827		if (readcount < bufferlen)
 828			break ;
 829		len -= readcount ;
 830		} ;
 831
 832	return total ;
 833} /* pcm_read_bei2s */
 834
 835static sf_count_t
 836pcm_read_lei2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
 837{	int			bufferlen, readcount ;
 838	sf_count_t	total = 0 ;
 839
 840	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
 841
 842	while (len > 0)
 843	{	if (len < bufferlen)
 844			bufferlen = (int) len ;
 845		readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
 846		lei2s_array (psf->u.ibuf, readcount, ptr + total) ;
 847		total += readcount ;
 848		if (readcount < bufferlen)
 849			break ;
 850		len -= readcount ;
 851		} ;
 852
 853	return total ;
 854} /* pcm_read_lei2s */
 855
 856/*-----------------------------------------------------------------------------------------------
 857*/
 858
 859static sf_count_t
 860pcm_read_sc2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 861{	int			bufferlen, readcount ;
 862	sf_count_t	total = 0 ;
 863
 864	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
 865
 866	while (len > 0)
 867	{	if (len < bufferlen)
 868			bufferlen = (int) len ;
 869		readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
 870		sc2i_array (psf->u.scbuf, readcount, ptr + total) ;
 871		total += readcount ;
 872		if (readcount < bufferlen)
 873			break ;
 874		len -= readcount ;
 875		} ;
 876
 877	return total ;
 878} /* pcm_read_sc2i */
 879
 880static sf_count_t
 881pcm_read_uc2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 882{	int			bufferlen, readcount ;
 883	sf_count_t	total = 0 ;
 884
 885	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
 886
 887	while (len > 0)
 888	{	if (len < bufferlen)
 889			bufferlen = (int) len ;
 890		readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
 891		uc2i_array (psf->u.ucbuf, readcount, ptr + total) ;
 892		total += readcount ;
 893		if (readcount < bufferlen)
 894			break ;
 895		len -= readcount ;
 896		} ;
 897
 898	return total ;
 899} /* pcm_read_uc2i */
 900
 901static sf_count_t
 902pcm_read_bes2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 903{	int			bufferlen, readcount ;
 904	sf_count_t	total = 0 ;
 905
 906	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
 907
 908	while (len > 0)
 909	{	if (len < bufferlen)
 910			bufferlen = (int) len ;
 911		readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
 912		bes2i_array (psf->u.sbuf, readcount, ptr + total) ;
 913		total += readcount ;
 914		if (readcount < bufferlen)
 915			break ;
 916		len -= readcount ;
 917		} ;
 918
 919	return total ;
 920} /* pcm_read_bes2i */
 921
 922static sf_count_t
 923pcm_read_les2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 924{	int			bufferlen, readcount ;
 925	sf_count_t	total = 0 ;
 926
 927	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
 928
 929	while (len > 0)
 930	{	if (len < bufferlen)
 931			bufferlen = (int) len ;
 932		readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
 933		les2i_array (psf->u.sbuf, readcount, ptr + total) ;
 934		total += readcount ;
 935		if (readcount < bufferlen)
 936			break ;
 937		len -= readcount ;
 938		} ;
 939
 940	return total ;
 941} /* pcm_read_les2i */
 942
 943static sf_count_t
 944pcm_read_bet2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 945{	int			bufferlen, readcount ;
 946	sf_count_t	total = 0 ;
 947
 948	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
 949
 950	while (len > 0)
 951	{	if (len < bufferlen)
 952			bufferlen = (int) len ;
 953		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
 954		bet2i_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
 955		total += readcount ;
 956		if (readcount < bufferlen)
 957			break ;
 958		len -= readcount ;
 959		} ;
 960
 961	return total ;
 962} /* pcm_read_bet2i */
 963
 964static sf_count_t
 965pcm_read_let2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 966{	int			bufferlen, readcount ;
 967	sf_count_t	total = 0 ;
 968
 969	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
 970
 971	while (len > 0)
 972	{	if (len < bufferlen)
 973			bufferlen = (int) len ;
 974		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
 975		let2i_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
 976		total += readcount ;
 977		if (readcount < bufferlen)
 978			break ;
 979		len -= readcount ;
 980		} ;
 981
 982	return total ;
 983} /* pcm_read_let2i */
 984
 985static sf_count_t
 986pcm_read_bei2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 987{	int		total ;
 988
 989	total = psf_fread (ptr, sizeof (int), len, psf) ;
 990	if (CPU_IS_LITTLE_ENDIAN)
 991		endswap_int_array	(ptr, len) ;
 992
 993	return total ;
 994} /* pcm_read_bei2i */
 995
 996static sf_count_t
 997pcm_read_lei2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
 998{	int		total ;
 999
1000	total = psf_fread (ptr, sizeof (int), len, psf) ;
1001	if (CPU_IS_BIG_ENDIAN)
1002		endswap_int_array	(ptr, len) ;
1003
1004	return total ;
1005} /* pcm_read_lei2i */
1006
1007/*-----------------------------------------------------------------------------------------------
1008*/
1009
1010static sf_count_t
1011pcm_read_sc2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1012{	int			bufferlen, readcount ;
1013	sf_count_t	total = 0 ;
1014	float	normfact ;
1015
1016	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80) : 1.0 ;
1017
1018	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1019
1020	while (len > 0)
1021	{	if (len < bufferlen)
1022			bufferlen = (int) len ;
1023		readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1024		sc2f_array (psf->u.scbuf, readcount, ptr + total, normfact) ;
1025		total += readcount ;
1026		if (readcount < bufferlen)
1027			break ;
1028		len -= readcount ;
1029		} ;
1030
1031	return total ;
1032} /* pcm_read_sc2f */
1033
1034static sf_count_t
1035pcm_read_uc2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1036{	int			bufferlen, readcount ;
1037	sf_count_t	total = 0 ;
1038	float	normfact ;
1039
1040	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80) : 1.0 ;
1041
1042	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1043
1044	while (len > 0)
1045	{	if (len < bufferlen)
1046			bufferlen = (int) len ;
1047		readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1048		uc2f_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
1049		total += readcount ;
1050		if (readcount < bufferlen)
1051			break ;
1052		len -= readcount ;
1053		} ;
1054
1055	return total ;
1056} /* pcm_read_uc2f */
1057
1058static sf_count_t
1059pcm_read_bes2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1060{	int			bufferlen, readcount ;
1061	sf_count_t	total = 0 ;
1062	float	normfact ;
1063
1064	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
1065
1066	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1067
1068	while (len > 0)
1069	{	if (len < bufferlen)
1070			bufferlen = (int) len ;
1071		readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1072		bes2f_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1073		total += readcount ;
1074		if (readcount < bufferlen)
1075			break ;
1076		len -= readcount ;
1077		} ;
1078
1079	return total ;
1080} /* pcm_read_bes2f */
1081
1082static sf_count_t
1083pcm_read_les2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1084{	int			bufferlen, readcount ;
1085	sf_count_t	total = 0 ;
1086	float	normfact ;
1087
1088	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
1089
1090	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1091
1092	while (len > 0)
1093	{	if (len < bufferlen)
1094			bufferlen = (int) len ;
1095		readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1096		les2f_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1097		total += readcount ;
1098		if (readcount < bufferlen)
1099			break ;
1100		len -= readcount ;
1101		} ;
1102
1103	return total ;
1104} /* pcm_read_les2f */
1105
1106static sf_count_t
1107pcm_read_bet2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1108{	int			bufferlen, readcount ;
1109	sf_count_t	total = 0 ;
1110	float	normfact ;
1111
1112	/* Special normfactor because tribyte value is read into an int. */
1113	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 / 256.0 ;
1114
1115	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1116
1117	while (len > 0)
1118	{	if (len < bufferlen)
1119			bufferlen = (int) len ;
1120		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1121		bet2f_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1122		total += readcount ;
1123		if (readcount < bufferlen)
1124			break ;
1125		len -= readcount ;
1126		} ;
1127
1128	return total ;
1129} /* pcm_read_bet2f */
1130
1131static sf_count_t
1132pcm_read_let2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1133{	int			bufferlen, readcount ;
1134	sf_count_t	total = 0 ;
1135	float	normfact ;
1136
1137	/* Special normfactor because tribyte value is read into an int. */
1138	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 / 256.0 ;
1139
1140	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1141
1142	while (len > 0)
1143	{	if (len < bufferlen)
1144			bufferlen = (int) len ;
1145		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1146		let2f_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1147		total += readcount ;
1148		if (readcount < bufferlen)
1149			break ;
1150		len -= readcount ;
1151		} ;
1152
1153	return total ;
1154} /* pcm_read_let2f */
1155
1156static sf_count_t
1157pcm_read_bei2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1158{	int			bufferlen, readcount ;
1159	sf_count_t	total = 0 ;
1160	float	normfact ;
1161
1162	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
1163
1164	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1165
1166	while (len > 0)
1167	{	if (len < bufferlen)
1168			bufferlen = (int) len ;
1169		readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1170		bei2f_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1171		total += readcount ;
1172		if (readcount < bufferlen)
1173			break ;
1174		len -= readcount ;
1175		} ;
1176
1177	return total ;
1178} /* pcm_read_bei2f */
1179
1180static sf_count_t
1181pcm_read_lei2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1182{	int			bufferlen, readcount ;
1183	sf_count_t	total = 0 ;
1184	float	normfact ;
1185
1186	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
1187
1188	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1189
1190	while (len > 0)
1191	{	if (len < bufferlen)
1192			bufferlen = (int) len ;
1193		readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1194		lei2f_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1195		total += readcount ;
1196		if (readcount < bufferlen)
1197			break ;
1198		len -= readcount ;
1199		} ;
1200
1201	return total ;
1202} /* pcm_read_lei2f */
1203
1204/*-----------------------------------------------------------------------------------------------
1205*/
1206
1207static sf_count_t
1208pcm_read_sc2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1209{	int			bufferlen, readcount ;
1210	sf_count_t	total = 0 ;
1211	double		normfact ;
1212
1213	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80) : 1.0 ;
1214
1215	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1216
1217	while (len > 0)
1218	{	if (len < bufferlen)
1219			bufferlen = (int) len ;
1220		readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1221		sc2d_array (psf->u.scbuf, readcount, ptr + total, normfact) ;
1222		total += readcount ;
1223		if (readcount < bufferlen)
1224			break ;
1225		len -= readcount ;
1226		} ;
1227
1228	return total ;
1229} /* pcm_read_sc2d */
1230
1231static sf_count_t
1232pcm_read_uc2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1233{	int			bufferlen, readcount ;
1234	sf_count_t	total = 0 ;
1235	double		normfact ;
1236
1237	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80) : 1.0 ;
1238
1239	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1240
1241	while (len > 0)
1242	{	if (len < bufferlen)
1243			bufferlen = (int) len ;
1244		readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1245		uc2d_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
1246		total += readcount ;
1247		if (readcount < bufferlen)
1248			break ;
1249		len -= readcount ;
1250		} ;
1251
1252	return total ;
1253} /* pcm_read_uc2d */
1254
1255static sf_count_t
1256pcm_read_bes2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1257{	int			bufferlen, readcount ;
1258	sf_count_t	total = 0 ;
1259	double		normfact ;
1260
1261	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;
1262
1263	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1264
1265	while (len > 0)
1266	{	if (len < bufferlen)
1267			bufferlen = (int) len ;
1268		readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1269		bes2d_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1270		total += readcount ;
1271		if (readcount < bufferlen)
1272			break ;
1273		len -= readcount ;
1274		} ;
1275
1276	return total ;
1277} /* pcm_read_bes2d */
1278
1279static sf_count_t
1280pcm_read_les2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1281{	int			bufferlen, readcount ;
1282	sf_count_t	total = 0 ;
1283	double		normfact ;
1284
1285	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;
1286
1287	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1288
1289	while (len > 0)
1290	{	if (len < bufferlen)
1291			bufferlen = (int) len ;
1292		readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1293		les2d_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1294		total += readcount ;
1295		if (readcount < bufferlen)
1296			break ;
1297		len -= readcount ;
1298		} ;
1299
1300	return total ;
1301} /* pcm_read_les2d */
1302
1303static sf_count_t
1304pcm_read_bet2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1305{	int			bufferlen, readcount ;
1306	sf_count_t	total = 0 ;
1307	double		normfact ;
1308
1309	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 / 256.0 ;
1310
1311	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1312
1313	while (len > 0)
1314	{	if (len < bufferlen)
1315			bufferlen = (int) len ;
1316		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1317		bet2d_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1318		total += readcount ;
1319		if (readcount < bufferlen)
1320			break ;
1321		len -= readcount ;
1322		} ;
1323
1324	return total ;
1325} /* pcm_read_bet2d */
1326
1327static sf_count_t
1328pcm_read_let2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1329{	int			bufferlen, readcount ;
1330	sf_count_t	total = 0 ;
1331	double		normfact ;
1332
1333	/* Special normfactor because tribyte value is read into an int. */
1334	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 / 256.0 ;
1335
1336	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1337
1338	while (len > 0)
1339	{	if (len < bufferlen)
1340			bufferlen = (int) len ;
1341		readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1342		let2d_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1343		total += readcount ;
1344		if (readcount < bufferlen)
1345			break ;
1346		len -= readcount ;
1347		} ;
1348
1349	return total ;
1350} /* pcm_read_let2d */
1351
1352static sf_count_t
1353pcm_read_bei2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1354{	int			bufferlen, readcount ;
1355	sf_count_t	total = 0 ;
1356	double		normfact ;
1357
1358	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 ;
1359
1360	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1361
1362	while (len > 0)
1363	{	if (len < bufferlen)
1364			bufferlen = (int) len ;
1365		readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1366		bei2d_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1367		total += readcount ;
1368		if (readcount < bufferlen)
1369			break ;
1370		len -= readcount ;
1371		} ;
1372
1373	return total ;
1374} /* pcm_read_bei2d */
1375
1376static sf_count_t
1377pcm_read_lei2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1378{	int			bufferlen, readcount ;
1379	sf_count_t	total = 0 ;
1380	double		normfact ;
1381
1382	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 ;
1383
1384	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1385
1386	while (len > 0)
1387	{	if (len < bufferlen)
1388			bufferlen = (int) len ;
1389		readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1390		lei2d_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1391		total += readcount ;
1392		if (readcount < bufferlen)
1393			break ;
1394		len -= readcount ;
1395		} ;
1396
1397	return total ;
1398} /* pcm_read_lei2d */
1399
1400/*===============================================================================================
1401**-----------------------------------------------------------------------------------------------
1402**===============================================================================================
1403*/
1404
1405static sf_count_t
1406pcm_write_s2sc	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1407{	int			bufferlen, writecount ;
1408	sf_count_t	total = 0 ;
1409
1410	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1411
1412	while (len > 0)
1413	{	if (len < bufferlen)
1414			bufferlen = (int) len ;
1415		s2sc_array (ptr + total, psf->u.scbuf, bufferlen) ;
1416		writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1417		total += writecount ;
1418		if (writecount < bufferlen)
1419			break ;
1420		len -= writecount ;
1421		} ;
1422
1423	return total ;
1424} /* pcm_write_s2sc */
1425
1426static sf_count_t
1427pcm_write_s2uc	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1428{	int			bufferlen, writecount ;
1429	sf_count_t	total = 0 ;
1430
1431	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1432
1433	while (len > 0)
1434	{	if (len < bufferlen)
1435			bufferlen = (int) len ;
1436		s2uc_array (ptr + total, psf->u.ucbuf, bufferlen) ;
1437		writecount = psf_fwrite (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1438		total += writecount ;
1439		if (writecount < bufferlen)
1440			break ;
1441		len -= writecount ;
1442		} ;
1443
1444	return total ;
1445} /* pcm_write_s2uc */
1446
1447static sf_count_t
1448pcm_write_s2bes	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1449{	int			bufferlen, writecount ;
1450	sf_count_t	total = 0 ;
1451
1452	if (CPU_IS_BIG_ENDIAN)
1453		return psf_fwrite (ptr, sizeof (short), len, psf) ;
1454	else
1455
1456	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1457
1458	while (len > 0)
1459	{	if (len < bufferlen)
1460			bufferlen = (int) len ;
1461		endswap_short_copy (psf->u.sbuf, ptr + total, bufferlen) ;
1462		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1463		total += writecount ;
1464		if (writecount < bufferlen)
1465			break ;
1466		len -= writecount ;
1467		} ;
1468
1469	return total ;
1470} /* pcm_write_s2bes */
1471
1472static sf_count_t
1473pcm_write_s2les	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1474{	int			bufferlen, writecount ;
1475	sf_count_t	total = 0 ;
1476
1477	if (CPU_IS_LITTLE_ENDIAN)
1478		return psf_fwrite (ptr, sizeof (short), len, psf) ;
1479
1480	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1481
1482	while (len > 0)
1483	{	if (len < bufferlen)
1484			bufferlen = (int) len ;
1485		endswap_short_copy (psf->u.sbuf, ptr + total, bufferlen) ;
1486		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1487		total += writecount ;
1488		if (writecount < bufferlen)
1489			break ;
1490		len -= writecount ;
1491		} ;
1492
1493	return total ;
1494} /* pcm_write_s2les */
1495
1496static sf_count_t
1497pcm_write_s2bet	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1498{	int			bufferlen, writecount ;
1499	sf_count_t	total = 0 ;
1500
1501	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1502
1503	while (len > 0)
1504	{	if (len < bufferlen)
1505			bufferlen = (int) len ;
1506		s2bet_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1507		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1508		total += writecount ;
1509		if (writecount < bufferlen)
1510			break ;
1511		len -= writecount ;
1512		} ;
1513
1514	return total ;
1515} /* pcm_write_s2bet */
1516
1517static sf_count_t
1518pcm_write_s2let	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1519{	int			bufferlen, writecount ;
1520	sf_count_t	total = 0 ;
1521
1522	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1523
1524	while (len > 0)
1525	{	if (len < bufferlen)
1526			bufferlen = (int) len ;
1527		s2let_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1528		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1529		total += writecount ;
1530		if (writecount < bufferlen)
1531			break ;
1532		len -= writecount ;
1533		} ;
1534
1535	return total ;
1536} /* pcm_write_s2let */
1537
1538static sf_count_t
1539pcm_write_s2bei	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1540{	int			bufferlen, writecount ;
1541	sf_count_t	total = 0 ;
1542
1543	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1544
1545	while (len > 0)
1546	{	if (len < bufferlen)
1547			bufferlen = (int) len ;
1548		s2bei_array (ptr + total, psf->u.ibuf, bufferlen) ;
1549		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1550		total += writecount ;
1551		if (writecount < bufferlen)
1552			break ;
1553		len -= writecount ;
1554		} ;
1555
1556	return total ;
1557} /* pcm_write_s2bei */
1558
1559static sf_count_t
1560pcm_write_s2lei	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1561{	int			bufferlen, writecount ;
1562	sf_count_t	total = 0 ;
1563
1564	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1565
1566	while (len > 0)
1567	{	if (len < bufferlen)
1568			bufferlen = (int) len ;
1569		s2lei_array (ptr + total, psf->u.ibuf, bufferlen) ;
1570		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1571		total += writecount ;
1572		if (writecount < bufferlen)
1573			break ;
1574		len -= writecount ;
1575		} ;
1576
1577	return total ;
1578} /* pcm_write_s2lei */
1579
1580/*-----------------------------------------------------------------------------------------------
1581*/
1582
1583static sf_count_t
1584pcm_write_i2sc	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1585{	int			bufferlen, writecount ;
1586	sf_count_t	total = 0 ;
1587
1588	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1589
1590	while (len > 0)
1591	{	if (len < bufferlen)
1592			bufferlen = (int) len ;
1593		i2sc_array (ptr + total, psf->u.scbuf, bufferlen) ;
1594		writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1595		total += writecount ;
1596		if (writecount < bufferlen)
1597			break ;
1598		len -= writecount ;
1599		} ;
1600
1601	return total ;
1602} /* pcm_write_i2sc */
1603
1604static sf_count_t
1605pcm_write_i2uc	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1606{	int			bufferlen, writecount ;
1607	sf_count_t	total = 0 ;
1608
1609	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1610
1611	while (len > 0)
1612	{	if (len < bufferlen)
1613			bufferlen = (int) len ;
1614		i2uc_array (ptr + total, psf->u.ucbuf, bufferlen) ;
1615		writecount = psf_fwrite (psf->u.ucbuf, sizeof (signed char), bufferlen, psf) ;
1616		total += writecount ;
1617		if (writecount < bufferlen)
1618			break ;
1619		len -= writecount ;
1620		} ;
1621
1622	return total ;
1623} /* pcm_write_i2uc */
1624
1625static sf_count_t
1626pcm_write_i2bes	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1627{	int			bufferlen, writecount ;
1628	sf_count_t	total = 0 ;
1629
1630	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1631
1632	while (len > 0)
1633	{	if (len < bufferlen)
1634			bufferlen = (int) len ;
1635		i2bes_array (ptr + total, psf->u.sbuf, bufferlen) ;
1636		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1637		total += writecount ;
1638		if (writecount < bufferlen)
1639			break ;
1640		len -= writecount ;
1641		} ;
1642
1643	return total ;
1644} /* pcm_write_i2bes */
1645
1646static sf_count_t
1647pcm_write_i2les	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1648{	int			bufferlen, writecount ;
1649	sf_count_t	total = 0 ;
1650
1651	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1652
1653	while (len > 0)
1654	{	if (len < bufferlen)
1655			bufferlen = (int) len ;
1656		i2les_array (ptr + total, psf->u.sbuf, bufferlen) ;
1657		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1658		total += writecount ;
1659		if (writecount < bufferlen)
1660			break ;
1661		len -= writecount ;
1662		} ;
1663
1664	return total ;
1665} /* pcm_write_i2les */
1666
1667static sf_count_t
1668pcm_write_i2bet	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1669{	int			bufferlen, writecount ;
1670	sf_count_t	total = 0 ;
1671
1672	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1673
1674	while (len > 0)
1675	{	if (len < bufferlen)
1676			bufferlen = (int) len ;
1677		i2bet_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1678		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1679		total += writecount ;
1680		if (writecount < bufferlen)
1681			break ;
1682		len -= writecount ;
1683		} ;
1684
1685	return total ;
1686} /* pcm_write_i2bet */
1687
1688static sf_count_t
1689pcm_write_i2let	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1690{	int			bufferlen, writecount ;
1691	sf_count_t	total = 0 ;
1692
1693	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1694
1695	while (len > 0)
1696	{	if (len < bufferlen)
1697			bufferlen = (int) len ;
1698		i2let_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1699		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1700		total += writecount ;
1701		if (writecount < bufferlen)
1702			break ;
1703		len -= writecount ;
1704		} ;
1705
1706	return total ;
1707} /* pcm_write_i2les */
1708
1709static sf_count_t
1710pcm_write_i2bei	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1711{	int			bufferlen, writecount ;
1712	sf_count_t	total = 0 ;
1713
1714	if (CPU_IS_BIG_ENDIAN)
1715		return psf_fwrite (ptr, sizeof (int), len, psf) ;
1716
1717	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1718
1719	while (len > 0)
1720	{	if (len < bufferlen)
1721			bufferlen = (int) len ;
1722		endswap_int_copy (psf->u.ibuf, ptr + total, bufferlen) ;
1723		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1724		total += writecount ;
1725		if (writecount < bufferlen)
1726			break ;
1727		len -= writecount ;
1728		} ;
1729
1730	return total ;
1731} /* pcm_write_i2bei */
1732
1733static sf_count_t
1734pcm_write_i2lei	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1735{	int			bufferlen, writecount ;
1736	sf_count_t	total = 0 ;
1737
1738	if (CPU_IS_LITTLE_ENDIAN)
1739		return psf_fwrite (ptr, sizeof (int), len, psf) ;
1740
1741	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1742
1743	while (len > 0)
1744	{	if (len < bufferlen)
1745			bufferlen = (int) len ;
1746		endswap_int_copy (psf->u.ibuf, ptr + total, bufferlen) ;
1747		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1748		total += writecount ;
1749		if (writecount < bufferlen)
1750			break ;
1751		len -= writecount ;
1752		} ;
1753
1754	return total ;
1755} /* pcm_write_i2lei */
1756
1757/*------------------------------------------------------------------------------
1758**==============================================================================
1759**------------------------------------------------------------------------------
1760*/
1761
1762static void
1763f2sc_array (const float *src, signed char *dest, int count, int normalize)
1764{	float normfact ;
1765
1766	normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
1767
1768	while (--count >= 0)
1769	{	dest [count] = lrintf (src [count] * normfact) ;
1770		} ;
1771} /* f2sc_array */
1772
1773static void
1774f2sc_clip_array (const float *src, signed char *dest, int count, int normalize)
1775{	float	normfact, scaled_value ;
1776
1777	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
1778
1779	while (--count >= 0)
1780	{	scaled_value = src [count] * normfact ;
1781		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1782		{	dest [count] = 127 ;
1783			continue ;
1784			} ;
1785		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1786		{	dest [count] = -128 ;
1787			continue ;
1788			} ;
1789
1790		dest [count] = lrintf (scaled_value) >> 24 ;
1791		} ;
1792} /* f2sc_clip_array */
1793
1794static sf_count_t
1795pcm_write_f2sc	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1796{	void		(*convert) (const float *, signed char *, int, int) ;
1797	int			bufferlen, writecount ;
1798	sf_count_t	total = 0 ;
1799
1800	convert = (psf->add_clipping) ? f2sc_clip_array : f2sc_array ;
1801	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1802
1803	while (len > 0)
1804	{	if (len < bufferlen)
1805			bufferlen = (int) len ;
1806		convert (ptr + total, psf->u.scbuf, bufferlen, psf->norm_float) ;
1807		writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1808		total += writecount ;
1809		if (writecount < bufferlen)
1810			break ;
1811		len -= writecount ;
1812		} ;
1813
1814	return total ;
1815} /* pcm_write_f2sc */
1816
1817/*==============================================================================
1818*/
1819
1820static	void
1821f2uc_array	(const float *src, unsigned char *dest, int count, int normalize)
1822{	float normfact ;
1823
1824	normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
1825
1826	while (--count >= 0)
1827	{	dest [count] = lrintf (src [count] * normfact) + 128 ;
1828		} ;
1829} /* f2uc_array */
1830
1831static	void
1832f2uc_clip_array	(const float *src, unsigned char *dest, int count, int normalize)
1833{	float	normfact, scaled_value ;
1834
1835	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
1836
1837	while (--count >= 0)
1838	{	scaled_value = src [count] * normfact ;
1839		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1840		{	dest [count] = 0xFF ;
1841			continue ;
1842			} ;
1843		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1844		{	dest [count] = 0 ;
1845			continue ;
1846			} ;
1847
1848		dest [count] = (lrintf (scaled_value) >> 24) + 128 ;
1849		} ;
1850} /* f2uc_clip_array */
1851
1852static sf_count_t
1853pcm_write_f2uc	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1854{	void		(*convert) (const float *, unsigned char *, int, int) ;
1855	int			bufferlen, writecount ;
1856	sf_count_t	total = 0 ;
1857
1858	convert = (psf->add_clipping) ? f2uc_clip_array : f2uc_array ;
1859	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1860
1861	while (len > 0)
1862	{	if (len < bufferlen)
1863			bufferlen = (int) len ;
1864		convert (ptr + total, psf->u.ucbuf, bufferlen, psf->norm_float) ;
1865		writecount = psf_fwrite (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1866		total += writecount ;
1867		if (writecount < bufferlen)
1868			break ;
1869		len -= writecount ;
1870		} ;
1871
1872	return total ;
1873} /* pcm_write_f2uc */
1874
1875/*==============================================================================
1876*/
1877
1878static void
1879f2bes_array (const float *src, short *dest, int count, int normalize)
1880{	unsigned char	*ucptr ;
1881	float 			normfact ;
1882	short			value ;
1883
1884	normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
1885	ucptr = ((unsigned char*) dest) + 2 * count ;
1886
1887	while (--count >= 0)
1888	{	ucptr -= 2 ;
1889		value = lrintf (src [count] * normfact) ;
1890		ucptr [1] = value ;
1891		ucptr [0] = value >> 8 ;
1892			} ;
1893} /* f2bes_array */
1894
1895static void
1896f2bes_clip_array (const float *src, short *dest, int count, int normalize)
1897{	unsigned char	*ucptr ;
1898	float			normfact, scaled_value ;
1899	int				value ;
1900
1901	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
1902	ucptr = ((unsigned char*) dest) + 2 * count ;
1903
1904	while (--count >= 0)
1905	{	ucptr -= 2 ;
1906		scaled_value = src [count] * normfact ;
1907		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1908		{	ucptr [1] = 0xFF ;
1909			ucptr [0] = 0x7F ;
1910			continue ;
1911		} ;
1912		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1913		{	ucptr [1] = 0x00 ;
1914			ucptr [0] = 0x80 ;
1915			continue ;
1916			} ;
1917
1918		value = lrintf (scaled_value) ;
1919		ucptr [1] = value >> 16 ;
1920		ucptr [0] = value >> 24 ;
1921		} ;
1922} /* f2bes_clip_array */
1923
1924static sf_count_t
1925pcm_write_f2bes	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1926{	void		(*convert) (const float *, short *t, int, int) ;
1927	int			bufferlen, writecount ;
1928	sf_count_t	total = 0 ;
1929
1930	convert = (psf->add_clipping) ? f2bes_clip_array : f2bes_array ;
1931	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1932
1933	while (len > 0)
1934	{	if (len < bufferlen)
1935			bufferlen = (int) len ;
1936		convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_float) ;
1937		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1938		total += writecount ;
1939		if (writecount < bufferlen)
1940				break ;
1941		len -= writecount ;
1942		} ;
1943
1944	return total ;
1945} /* pcm_write_f2bes */
1946
1947/*==============================================================================
1948*/
1949
1950static void
1951f2les_array (const float *src, short *dest, int count, int normalize)
1952{	unsigned char	*ucptr ;
1953	float			normfact ;
1954	int				value ;
1955
1956	normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
1957	ucptr = ((unsigned char*) dest) + 2 * count ;
1958
1959	while (--count >= 0)
1960	{	ucptr -= 2 ;
1961		value = lrintf (src [count] * normfact) ;
1962		ucptr [0] = value ;
1963		ucptr [1] = value >> 8 ;
1964		} ;
1965} /* f2les_array */
1966
1967static void
1968f2les_clip_array (const float *src, short *dest, int count, int normalize)
1969{	unsigned char	*ucptr ;
1970	float			normfact, scaled_value ;
1971	int				value ;
1972
1973	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
1974	ucptr = ((unsigned char*) dest) + 2 * count ;
1975
1976	while (--count >= 0)
1977	{	ucptr -= 2 ;
1978		scaled_value = src [count] * normfact ;
1979		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1980		{	ucptr [0] = 0xFF ;
1981			ucptr [1] = 0x7F ;
1982			continue ;
1983			} ;
1984		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1985		{	ucptr [0] = 0x00 ;
1986			ucptr [1] = 0x80 ;
1987			continue ;
1988			} ;
1989
1990		value = lrintf (scaled_value) ;
1991		ucptr [0] = value >> 16 ;
1992		ucptr [1] = value >> 24 ;
1993		} ;
1994} /* f2les_clip_array */
1995
1996static sf_count_t
1997pcm_write_f2les	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1998{	void		(*convert) (const float *, short *t, int, int) ;
1999	int			bufferlen, writecount ;
2000	sf_count_t	total = 0 ;
2001
2002	convert = (psf->add_clipping) ? f2les_clip_array : f2les_array ;
2003	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
2004
2005	while (len > 0)
2006	{	if (len < bufferlen)
2007			bufferlen = (int) len ;
2008		convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_float) ;
2009		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
2010		total += writecount ;
2011		if (writecount < bufferlen)
2012			break ;
2013		len -= writecount ;
2014		} ;
2015
2016	return total ;
2017} /* pcm_write_f2les */
2018
2019/*==============================================================================
2020*/
2021
2022static void
2023f2let_array (const float *src, tribyte *dest, int count, int normalize)
2024{	unsigned char	*ucptr ;
2025	float 			normfact ;
2026	int				value ;
2027
2028	normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2029	ucptr = ((unsigned char*) dest) + 3 * count ;
2030
2031	while (--count >= 0)
2032	{	ucptr -= 3 ;
2033		value = lrintf (src [count] * normfact) ;
2034		ucptr [0] = value ;
2035		ucptr [1] = value >> 8 ;
2036		ucptr [2] = value >> 16 ;
2037		} ;
2038} /* f2let_array */
2039
2040static void
2041f2let_clip_array (const float *src, tribyte *dest, int count, int normalize)
2042{	unsigned char	*ucptr ;
2043	float			normfact, scaled_value ;
2044	int				value ;
2045
2046	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2047	ucptr = ((unsigned char*) dest) + 3 * count ;
2048
2049	while (--count >= 0)
2050	{	ucptr -= 3 ;
2051		scaled_value = src [count] * normfact ;
2052		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2053		{	ucptr [0] = 0xFF ;
2054			ucptr [1] = 0xFF ;
2055			ucptr [2] = 0x7F ;
2056			continue ;
2057			} ;
2058		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2059		{	ucptr [0] = 0x00 ;
2060			ucptr [1] = 0x00 ;
2061			ucptr [2] = 0x80 ;
2062			continue ;
2063		} ;
2064
2065		value = lrintf (scaled_value) ;
2066		ucptr [0] = value >> 8 ;
2067		ucptr [1] = value >> 16 ;
2068		ucptr [2] = value >> 24 ;
2069		} ;
2070} /* f2let_clip_array */
2071
2072static sf_count_t
2073pcm_write_f2let	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2074{	void		(*convert) (const float *, tribyte *, int, int) ;
2075	int			bufferlen, writecount ;
2076	sf_count_t	total = 0 ;
2077
2078	convert = (psf->add_clipping) ? f2let_clip_array : f2let_array ;
2079	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2080
2081	while (len > 0)
2082	{	if (len < bufferlen)
2083			bufferlen = (int) len ;
2084		convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_float) ;
2085		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2086		total += writecount ;
2087		if (writecount < bufferlen)
2088			break ;
2089		len -= writecount ;
2090		} ;
2091
2092	return total ;
2093} /* pcm_write_f2let */
2094
2095/*==============================================================================
2096*/
2097
2098static void
2099f2bet_array (const float *src, tribyte *dest, int count, int normalize)
2100{	unsigned char	*ucptr ;
2101	float 			normfact ;
2102	int				value ;
2103
2104	normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2105	ucptr = ((unsigned char*) dest) + 3 * count ;
2106
2107	while (--count >= 0)
2108	{	ucptr -= 3 ;
2109		value = lrintf (src [count] * normfact) ;
2110		ucptr [0] = value >> 16 ;
2111		ucptr [1] = value >> 8 ;
2112		ucptr [2] = value ;
2113		} ;
2114} /* f2bet_array */
2115
2116static void
2117f2bet_clip_array (const float *src, tribyte *dest, int count, int normalize)
2118{	unsigned char	*ucptr ;
2119	float			normfact, scaled_value ;
2120	int				value ;
2121
2122	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2123	ucptr = ((unsigned char*) dest) + 3 * count ;
2124
2125	while (--count >= 0)
2126	{	ucptr -= 3 ;
2127		scaled_value = src [count] * normfact ;
2128		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2129		{	ucptr [0] = 0x7F ;
2130			ucptr [1] = 0xFF ;
2131			ucptr [2] = 0xFF ;
2132			continue ;
2133			} ;
2134		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2135		{	ucptr [0] = 0x80 ;
2136			ucptr [1] = 0x00 ;
2137			ucptr [2] = 0x00 ;
2138			continue ;
2139		} ;
2140
2141		value = lrint (scaled_value) ;
2142		ucptr [0] = value >> 24 ;
2143		ucptr [1] = value >> 16 ;
2144		ucptr [2] = value >> 8 ;
2145		} ;
2146} /* f2bet_clip_array */
2147
2148static sf_count_t
2149pcm_write_f2bet	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2150{	void		(*convert) (const float *, tribyte *, int, int) ;
2151	int			bufferlen, writecount ;
2152	sf_count_t	total = 0 ;
2153
2154	convert = (psf->add_clipping) ? f2bet_clip_array : f2bet_array ;
2155	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2156
2157	while (len > 0)
2158	{	if (len < bufferlen)
2159			bufferlen = (int) len ;
2160		convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_float) ;
2161		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2162		total += writecount ;
2163		if (writecount < bufferlen)
2164			break ;
2165		len -= writecount ;
2166		} ;
2167
2168	return total ;
2169} /* pcm_write_f2bet */
2170
2171/*==============================================================================
2172*/
2173
2174static void
2175f2bei_array (const float *src, int *dest, int count, int normalize)
2176{	unsigned char	*ucptr ;
2177	float			normfact ;
2178	int				value ;
2179
2180	normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2181	ucptr = ((unsigned char*) dest) + 4 * count ;
2182	while (--count >= 0)
2183	{	ucptr -= 4 ;
2184		value = lrintf (src [count] * normfact) ;
2185		ucptr [0] = value >> 24 ;
2186		ucptr [1] = value >> 16 ;
2187		ucptr [2] = value >> 8 ;
2188		ucptr [3] = value ;
2189		} ;
2190} /* f2bei_array */
2191
2192static void
2193f2bei_clip_array (const float *src, int *dest, int count, int normalize)
2194{	unsigned char	*ucptr ;
2195	float			normfact, scaled_value ;
2196	int				value ;
2197
2198	normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2199	ucptr = ((unsigned char*) dest) + 4 * count ;
2200
2201	while (--count >= 0)
2202	{	ucptr -= 4 ;
2203		scaled_value = src [count] * normfact ;
2204		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= 1.0 * 0x7FFFFFFF)
2205		{	ucptr [0] = 0x7F ;
2206			ucptr [1] = 0xFF ;
2207			ucptr [2] = 0xFF ;
2208			ucptr [3] = 0xFF ;
2209			continue ;
2210			} ;
2211		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2212		{	ucptr [0] = 0x80 ;
2213			ucptr [1] = 0x00 ;
2214			ucptr [2] = 0x00 ;
2215			ucptr [3] = 0x00 ;
2216			continue ;
2217		} ;
2218
2219		value = lrintf (scaled_value) ;
2220		ucptr [0] = value >> 24 ;
2221		ucptr [1] = value >> 16 ;
2222		ucptr [2] = value >> 8 ;
2223		ucptr [3] = value ;
2224		} ;
2225} /* f2bei_clip_array */
2226
2227static sf_count_t
2228pcm_write_f2bei	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2229{	void		(*convert) (const float *, int *, int, int) ;
2230	int			bufferlen, writecount ;
2231	sf_count_t	total = 0 ;
2232
2233	convert = (psf->add_clipping) ? f2bei_clip_array : f2bei_array ;
2234	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2235
2236	while (len > 0)
2237	{	if (len < bufferlen)
2238			bufferlen = (int) len ;
2239		convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_float) ;
2240		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2241		total += writecount ;
2242		if (writecount < bufferlen)
2243			break ;
2244		len -= writecount ;
2245		} ;
2246
2247	return total ;
2248} /* pcm_write_f2bei */
2249
2250/*==============================================================================
2251*/
2252
2253static void
2254f2lei_array (const float *src, int *dest, int count, int normalize)
2255{	unsigned char	*ucptr ;
2256	float			normfact ;
2257	int				value ;
2258
2259	normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2260	ucptr = ((unsigned char*) dest) + 4 * count ;
2261
2262	while (--count >= 0)
2263	{	ucptr -= 4 ;
2264		value = lrintf (src [count] * normfact) ;
2265		ucptr [0] = value ;
2266		ucptr [1] = value >> 8 ;
2267		ucptr [2] = value >> 16 ;
2268		ucptr [3] = value >> 24 ;
2269		} ;
2270} /* f2lei_array */
2271
2272static void
2273f2lei_clip_array (const float *src, int *dest, int count, int normalize)
2274{	unsigned char	*ucptr ;
2275	float			normfact, scaled_value ;
2276	int				value ;
2277
2278	normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2279	ucptr = ((unsigned char*) dest) + 4 * count ;
2280
2281	while (--count >= 0)
2282	{	ucptr -= 4 ;
2283		scaled_value = src [count] * normfact ;
2284		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2285		{	ucptr [0] = 0xFF ;
2286			ucptr [1] = 0xFF ;
2287			ucptr [2] = 0xFF ;
2288			ucptr [3] = 0x7F ;
2289			continue ;
2290			} ;
2291		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2292		{	ucptr [0] = 0x00 ;
2293			ucptr [1] = 0x00 ;
2294			ucptr [2] = 0x00 ;
2295			ucptr [3] = 0x80 ;
2296			continue ;
2297			} ;
2298
2299		value = lrintf (scaled_value) ;
2300		ucptr [0] = value ;
2301		ucptr [1] = value >> 8 ;
2302		ucptr [2] = value >> 16 ;
2303		ucptr [3] = value >> 24 ;
2304		} ;
2305} /* f2lei_clip_array */
2306
2307static sf_count_t
2308pcm_write_f2lei	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2309{	void		(*convert) (const float *, int *, int, int) ;
2310	int			bufferlen, writecount ;
2311	sf_count_t	total = 0 ;
2312
2313	convert = (psf->add_clipping) ? f2lei_clip_array : f2lei_array ;
2314	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2315
2316	while (len > 0)
2317	{	if (len < bufferlen)
2318			bufferlen = (int) len ;
2319		convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_float) ;
2320		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2321		total += writecount ;
2322		if (writecount < bufferlen)
2323			break ;
2324		len -= writecount ;
2325		} ;
2326
2327	return total ;
2328} /* pcm_write_f2lei */
2329
2330/*==============================================================================
2331*/
2332
2333static void
2334d2sc_array	(const double *src, signed char *dest, int count, int normalize)
2335{	double	normfact ;
2336
2337	normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
2338
2339	while (--count >= 0)
2340	{	dest [count] = lrint (src [count] * normfact) ;
2341		} ;
2342} /* d2sc_array */
2343
2344static void
2345d2sc_clip_array	(const double *src, signed char *dest, int count, int normalize)
2346{	double	normfact, scaled_value ;
2347
2348	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
2349
2350	while (--count >= 0)
2351	{	scaled_value = src [count] * normfact ;
2352		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2353		{	dest [count] = 127 ;
2354			continue ;
2355			} ;
2356		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2357		{	dest [count] = -128 ;
2358			continue ;
2359			} ;
2360
2361		dest [count] = lrintf (scaled_value) >> 24 ;
2362		} ;
2363} /* d2sc_clip_array */
2364
2365static sf_count_t
2366pcm_write_d2sc	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2367{	void		(*convert) (const double *, signed char *, int, int) ;
2368	int			bufferlen, writecount ;
2369	sf_count_t	total = 0 ;
2370
2371	convert = (psf->add_clipping) ? d2sc_clip_array : d2sc_array ;
2372	bufferlen = ARRAY_LEN (psf->u.scbuf) ;
2373
2374	while (len > 0)
2375	{	if (len < bufferlen)
2376			bufferlen = (int) len ;
2377		convert (ptr + total, psf->u.scbuf, bufferlen, psf->norm_double) ;
2378		writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
2379		total += writecount ;
2380		if (writecount < bufferlen)
2381			break ;
2382		len -= writecount ;
2383		} ;
2384
2385	return total ;
2386} /* pcm_write_d2sc */
2387
2388/*==============================================================================
2389*/
2390
2391static	void
2392d2uc_array	(const double *src, unsigned char *dest, int count, int normalize)
2393{	double normfact ;
2394
2395	normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
2396
2397	while (--count >= 0)
2398	{	dest [count] = lrint (src [count] * normfact) + 128 ;
2399		} ;
2400} /* d2uc_array */
2401
2402static	void
2403d2uc_clip_array	(const double *src, unsigned char *dest, int count, int normalize)
2404{	double	normfact, scaled_value ;
2405
2406	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
2407
2408	while (--count >= 0)
2409	{	scaled_value = src [count] * normfact ;
2410		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2411		{	dest [count] = 255 ;
2412			continue ;
2413			} ;
2414		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2415		{	dest [count] = 0 ;
2416			continue ;
2417			} ;
2418
2419		dest [count] = (lrint (src [count] * normfact) >> 24) + 128 ;
2420		} ;
2421} /* d2uc_clip_array */
2422
2423static sf_count_t
2424pcm_write_d2uc	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2425{	void		(*convert) (const double *, unsigned char *, int, int) ;
2426	int			bufferlen, writecount ;
2427	sf_count_t	total = 0 ;
2428
2429	convert = (psf->add_clipping) ? d2uc_clip_array : d2uc_array ;
2430	bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
2431
2432	while (len > 0)
2433	{	if (len < bufferlen)
2434			bufferlen = (int) len ;
2435		convert (ptr + total, psf->u.ucbuf, bufferlen, psf->norm_double) ;
2436		writecount = psf_fwrite (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
2437		total += writecount ;
2438		if (writecount < bufferlen)
2439			break ;
2440		len -= writecount ;
2441		} ;
2442
2443	return total ;
2444} /* pcm_write_d2uc */
2445
2446/*==============================================================================
2447*/
2448
2449static void
2450d2bes_array (const double *src, short *dest, int count, int normalize)
2451{	unsigned char	*ucptr ;
2452	short			value ;
2453	double			normfact ;
2454
2455	normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
2456	ucptr = ((unsigned char*) dest) + 2 * count ;
2457
2458	while (--count >= 0)
2459	{	ucptr -= 2 ;
2460		value = lrint (src [count] * normfact) ;
2461		ucptr [1] = value ;
2462		ucptr [0] = value >> 8 ;
2463		} ;
2464} /* d2bes_array */
2465
2466static void
2467d2bes_clip_array (const double *src, short *dest, int count, int normalize)
2468{	unsigned char	*ucptr ;
2469	double			normfact, scaled_value ;
2470	int				value ;
2471
2472	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
2473	ucptr = ((unsigned char*) dest) + 2 * count ;
2474
2475	while (--count >= 0)
2476	{	ucptr -= 2 ;
2477		scaled_value = src [count] * normfact ;
2478		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2479		{	ucptr [1] = 0xFF ;
2480			ucptr [0] = 0x7F ;
2481			continue ;
2482			} ;
2483		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2484		{	ucptr [1] = 0x00 ;
2485			ucptr [0] = 0x80 ;
2486			continue ;
2487			} ;
2488
2489		value = lrint (scaled_value) ;
2490		ucptr [1] = value >> 16 ;
2491		ucptr [0] = value >> 24 ;
2492		} ;
2493} /* d2bes_clip_array */
2494
2495static sf_count_t
2496pcm_write_d2bes	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2497{	void		(*convert) (const double *, short *, int, int) ;
2498	int			bufferlen, writecount ;
2499	sf_count_t	total = 0 ;
2500
2501	convert = (psf->add_clipping) ? d2bes_clip_array : d2bes_array ;
2502	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
2503
2504	while (len > 0)
2505	{	if (len < bufferlen)
2506			bufferlen = (int) len ;
2507		convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_double) ;
2508		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
2509		total += writecount ;
2510		if (writecount < bufferlen)
2511			break ;
2512		len -= writecount ;
2513		} ;
2514
2515	return total ;
2516} /* pcm_write_d2bes */
2517
2518/*==============================================================================
2519*/
2520
2521static void
2522d2les_array (const double *src, short *dest, int count, int normalize)
2523{	unsigned char	*ucptr ;
2524	short			value ;
2525	double			normfact ;
2526
2527	normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
2528	ucptr = ((unsigned char*) dest) + 2 * count ;
2529
2530	while (--count >= 0)
2531	{	ucptr -= 2 ;
2532		value = lrint (src [count] * normfact) ;
2533		ucptr [0] = value ;
2534		ucptr [1] = value >> 8 ;
2535		} ;
2536} /* d2les_array */
2537
2538static void
2539d2les_clip_array (const double *src, short *dest, int count, int normalize)
2540{	unsigned char	*ucptr ;
2541	int				value ;
2542	double			normfact, scaled_value ;
2543
2544	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
2545	ucptr = ((unsigned char*) dest) + 2 * count ;
2546
2547	while (--count >= 0)
2548	{	ucptr -= 2 ;
2549		scaled_value = src [count] * normfact ;
2550		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2551		{	ucptr [0] = 0xFF ;
2552			ucptr [1] = 0x7F ;
2553			continue ;
2554			} ;
2555		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2556		{	ucptr [0] = 0x00 ;
2557			ucptr [1] = 0x80 ;
2558			continue ;
2559			} ;
2560
2561		value = lrint (scaled_value) ;
2562		ucptr [0] = value >> 16 ;
2563		ucptr [1] = value >> 24 ;
2564		} ;
2565} /* d2les_clip_array */
2566
2567static sf_count_t
2568pcm_write_d2les	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2569{	void		(*convert) (const double *, short *, int, int) ;
2570	int			bufferlen, writecount ;
2571	sf_count_t	total = 0 ;
2572
2573	convert = (psf->add_clipping) ? d2les_clip_array : d2les_array ;
2574	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
2575
2576	while (len > 0)
2577	{	if (len < bufferlen)
2578			bufferlen = (int) len ;
2579		convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_double) ;
2580		writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
2581		total += writecount ;
2582		if (writecount < bufferlen)
2583			break ;
2584		len -= writecount ;
2585		} ;
2586
2587	return total ;
2588} /* pcm_write_d2les */
2589
2590/*==============================================================================
2591*/
2592
2593static void
2594d2let_array (const double *src, tribyte *dest, int count, int normalize)
2595{	unsigned char	*ucptr ;
2596	int				value ;
2597	double			normfact ;
2598
2599	normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2600	ucptr = ((unsigned char*) dest) + 3 * count ;
2601
2602	while (--count >= 0)
2603	{	ucptr -= 3 ;
2604		value = lrint (src [count] * normfact) ;
2605		ucptr [0] = value ;
2606		ucptr [1] = value >> 8 ;
2607		ucptr [2] = value >> 16 ;
2608		} ;
2609} /* d2let_array */
2610
2611static void
2612d2let_clip_array (const double *src, tribyte *dest, int count, int normalize)
2613{	unsigned char	*ucptr ;
2614	int				value ;
2615	double			normfact, scaled_value ;
2616
2617	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2618	ucptr = ((unsigned char*) dest) + 3 * count ;
2619
2620	while (--count >= 0)
2621	{	ucptr -= 3 ;
2622		scaled_value = src [count] * normfact ;
2623		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2624		{	ucptr [0] = 0xFF ;
2625			ucptr [1] = 0xFF ;
2626			ucptr [2] = 0x7F ;
2627			continue ;
2628			} ;
2629		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2630		{	ucptr [0] = 0x00 ;
2631			ucptr [1] = 0x00 ;
2632			ucptr [2] = 0x80 ;
2633			continue ;
2634			} ;
2635
2636		value = lrint (scaled_value) ;
2637		ucptr [0] = value >> 8 ;
2638		ucptr [1] = value >> 16 ;
2639		ucptr [2] = value >> 24 ;
2640		} ;
2641} /* d2let_clip_array */
2642
2643static sf_count_t
2644pcm_write_d2let	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2645{	void		(*convert) (const double *, tribyte *, int, int) ;
2646	int			bufferlen, writecount ;
2647	sf_count_t	total = 0 ;
2648
2649	convert = (psf->add_clipping) ? d2let_clip_array : d2let_array ;
2650	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2651
2652	while (len > 0)
2653	{	if (len < bufferlen)
2654			bufferlen = (int) len ;
2655		convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_double) ;
2656		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2657		total += writecount ;
2658		if (writecount < bufferlen)
2659			break ;
2660		len -= writecount ;
2661		} ;
2662
2663	return total ;
2664} /* pcm_write_d2let */
2665
2666/*==============================================================================
2667*/
2668
2669static void
2670d2bet_array (const double *src, tribyte *dest, int count, int normalize)
2671{	unsigned char	*ucptr ;
2672	int				value ;
2673	double			normfact ;
2674
2675	normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2676	ucptr = ((unsigned char*) dest) + 3 * count ;
2677
2678	while (--count >= 0)
2679	{	ucptr -= 3 ;
2680		value = lrint (src [count] * normfact) ;
2681		ucptr [2] = value ;
2682		ucptr [1] = value >> 8 ;
2683		ucptr [0] = value >> 16 ;
2684		} ;
2685} /* d2bet_array */
2686
2687static void
2688d2bet_clip_array (const double *src, tribyte *dest, int count, int normalize)
2689{	unsigned char	*ucptr ;
2690	int				value ;
2691	double			normfact, scaled_value ;
2692
2693	normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2694	ucptr = ((unsigned char*) dest) + 3 * count ;
2695
2696	while (--count >= 0)
2697	{	ucptr -= 3 ;
2698		scaled_value = src [count] * normfact ;
2699		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2700		{	ucptr [2] = 0xFF ;
2701			ucptr [1] = 0xFF ;
2702			ucptr [0] = 0x7F ;
2703			continue ;
2704			} ;
2705		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2706		{	ucptr [2] = 0x00 ;
2707			ucptr [1] = 0x00 ;
2708			ucptr [0] = 0x80 ;
2709			continue ;
2710			} ;
2711
2712		value = lrint (scaled_value) ;
2713		ucptr [2] = value >> 8 ;
2714		ucptr [1] = value >> 16 ;
2715		ucptr [0] = value >> 24 ;
2716		} ;
2717} /* d2bet_clip_array */
2718
2719static sf_count_t
2720pcm_write_d2bet	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2721{	void		(*convert) (const double *, tribyte *, int, int) ;
2722	int			bufferlen, writecount ;
2723	sf_count_t	total = 0 ;
2724
2725	convert = (psf->add_clipping) ? d2bet_clip_array : d2bet_array ;
2726	bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2727
2728	while (len > 0)
2729	{	if (len < bufferlen)
2730			bufferlen = (int) len ;
2731		convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_double) ;
2732		writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2733		total += writecount ;
2734		if (writecount < bufferlen)
2735			break ;
2736		len -= writecount ;
2737		} ;
2738
2739	return total ;
2740} /* pcm_write_d2bet */
2741
2742/*==============================================================================
2743*/
2744
2745static void
2746d2bei_array (const double *src, int *dest, int count, int normalize)
2747{	unsigned char	*ucptr ;
2748	int				value ;
2749	double			normfact ;
2750
2751	normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2752	ucptr = ((unsigned char*) dest) + 4 * count ;
2753
2754	while (--count >= 0)
2755	{	ucptr -= 4 ;
2756		value = lrint (src [count] * normfact) ;
2757		ucptr [0] = value >> 24 ;
2758		ucptr [1] = value >> 16 ;
2759		ucptr [2] = value >> 8 ;
2760		ucptr [3] = value ;
2761		} ;
2762} /* d2bei_array */
2763
2764static void
2765d2bei_clip_array (const double *src, int *dest, int count, int normalize)
2766{	unsigned char	*ucptr ;
2767	int				value ;
2768	double			normfact, scaled_value ;
2769
2770	normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2771	ucptr = ((unsigned char*) dest) + 4 * count ;
2772
2773	while (--count >= 0)
2774	{	ucptr -= 4 ;
2775		scaled_value = src [count] * normfact ;
2776		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2777		{	ucptr [3] = 0xFF ;
2778			ucptr [2] = 0xFF ;
2779			ucptr [1] = 0xFF ;
2780			ucptr [0] = 0x7F ;
2781			continue ;
2782			} ;
2783		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2784		{	ucptr [3] = 0x00 ;
2785			ucptr [2] = 0x00 ;
2786			ucptr [1] = 0x00 ;
2787			ucptr [0] = 0x80 ;
2788			continue ;
2789			} ;
2790
2791		value = lrint (scaled_value) ;
2792		ucptr [0] = value >> 24 ;
2793		ucptr [1] = value >> 16 ;
2794		ucptr [2] = value >> 8 ;
2795		ucptr [3] = value ;
2796		} ;
2797} /* d2bei_clip_array */
2798
2799static sf_count_t
2800pcm_write_d2bei	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2801{	void		(*convert) (const double *, int *, int, int) ;
2802	int			bufferlen, writecount ;
2803	sf_count_t	total = 0 ;
2804
2805	convert = (psf->add_clipping) ? d2bei_clip_array : d2bei_array ;
2806	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2807
2808	while (len > 0)
2809	{	if (len < bufferlen)
2810			bufferlen = (int) len ;
2811		convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_double) ;
2812		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2813		total += writecount ;
2814		if (writecount < bufferlen)
2815			break ;
2816		len -= writecount ;
2817		} ;
2818
2819	return total ;
2820} /* pcm_write_d2bei */
2821
2822/*==============================================================================
2823*/
2824
2825static void
2826d2lei_array (const double *src, int *dest, int count, int normalize)
2827{	unsigned char	*ucptr ;
2828	int				value ;
2829	double			normfact ;
2830
2831	normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2832	ucptr = ((unsigned char*) dest) + 4 * count ;
2833
2834	while (--count >= 0)
2835	{	ucptr -= 4 ;
2836		value = lrint (src [count] * normfact) ;
2837		ucptr [0] = value ;
2838		ucptr [1] = value >> 8 ;
2839		ucptr [2] = value >> 16 ;
2840		ucptr [3] = value >> 24 ;
2841		} ;
2842} /* d2lei_array */
2843
2844static void
2845d2lei_clip_array (const double *src, int *dest, int count, int normalize)
2846{	unsigned char	*ucptr ;
2847	int				value ;
2848	double			normfact, scaled_value ;
2849
2850	normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2851	ucptr = ((unsigned char*) dest) + 4 * count ;
2852
2853	while (--count >= 0)
2854	{	ucptr -= 4 ;
2855		scaled_value = src [count] * normfact ;
2856		if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2857		{	ucptr [0] = 0xFF ;
2858			ucptr [1] = 0xFF ;
2859			ucptr [2] = 0xFF ;
2860			ucptr [3] = 0x7F ;
2861			continue ;
2862			} ;
2863		if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2864		{	ucptr [0] = 0x00 ;
2865			ucptr [1] = 0x00 ;
2866			ucptr [2] = 0x00 ;
2867			ucptr [3] = 0x80 ;
2868			continue ;
2869			} ;
2870
2871		value = lrint (scaled_value) ;
2872		ucptr [0] = value ;
2873		ucptr [1] = value >> 8 ;
2874		ucptr [2] = value >> 16 ;
2875		ucptr [3] = value >> 24 ;
2876		} ;
2877} /* d2lei_clip_array */
2878
2879static sf_count_t
2880pcm_write_d2lei	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2881{	void		(*convert) (const double *, int *, int, int) ;
2882	int			bufferlen, writecount ;
2883	sf_count_t	total = 0 ;
2884
2885	convert = (psf->add_clipping) ? d2lei_clip_array : d2lei_array ;
2886	bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2887
2888	while (len > 0)
2889	{	if (len < bufferlen)
2890			bufferlen = (int) len ;
2891		convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_double) ;
2892		writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2893		total += writecount ;
2894		if (writecount < bufferlen)
2895			break ;
2896		len -= writecount ;
2897		} ;
2898
2899	return total ;
2900} /* pcm_write_d2lei */
2901