Blame - jni/libsndfile/src/pcm.c - jami-client-android

blob: ec450bcd37242e73874900587ea9d676c7e4f6cb [file] [log] [blame]

Alexandre Lision	7c6f4a6	2013-09-05 13:27:01 -0400	[diff] [blame]	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
				31	typedef void tribyte ;
				32
				33	#define SIZEOF_TRIBYTE 3
				34
				35	static sf_count_t pcm_read_sc2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				36	static sf_count_t pcm_read_uc2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				37	static sf_count_t pcm_read_bes2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				38	static sf_count_t pcm_read_les2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				39	static sf_count_t pcm_read_bet2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				40	static sf_count_t pcm_read_let2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				41	static sf_count_t pcm_read_bei2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				42	static sf_count_t pcm_read_lei2s (SF_PRIVATE psf, short ptr, sf_count_t len) ;
				43
				44	static sf_count_t pcm_read_sc2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				45	static sf_count_t pcm_read_uc2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				46	static sf_count_t pcm_read_bes2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				47	static sf_count_t pcm_read_les2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				48	static sf_count_t pcm_read_bet2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				49	static sf_count_t pcm_read_let2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				50	static sf_count_t pcm_read_bei2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				51	static sf_count_t pcm_read_lei2i (SF_PRIVATE psf, int ptr, sf_count_t len) ;
				52
				53	static sf_count_t pcm_read_sc2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				54	static sf_count_t pcm_read_uc2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				55	static sf_count_t pcm_read_bes2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				56	static sf_count_t pcm_read_les2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				57	static sf_count_t pcm_read_bet2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				58	static sf_count_t pcm_read_let2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				59	static sf_count_t pcm_read_bei2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				60	static sf_count_t pcm_read_lei2f (SF_PRIVATE psf, float ptr, sf_count_t len) ;
				61
				62	static sf_count_t pcm_read_sc2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				63	static sf_count_t pcm_read_uc2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				64	static sf_count_t pcm_read_bes2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				65	static sf_count_t pcm_read_les2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				66	static sf_count_t pcm_read_bet2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				67	static sf_count_t pcm_read_let2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				68	static sf_count_t pcm_read_bei2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				69	static sf_count_t pcm_read_lei2d (SF_PRIVATE psf, double ptr, sf_count_t len) ;
				70
				71	static sf_count_t pcm_write_s2sc (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				72	static sf_count_t pcm_write_s2uc (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				73	static sf_count_t pcm_write_s2bes (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				74	static sf_count_t pcm_write_s2les (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				75	static sf_count_t pcm_write_s2bet (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				76	static sf_count_t pcm_write_s2let (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				77	static sf_count_t pcm_write_s2bei (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				78	static sf_count_t pcm_write_s2lei (SF_PRIVATE psf, const short ptr, sf_count_t len) ;
				79
				80	static sf_count_t pcm_write_i2sc (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				81	static sf_count_t pcm_write_i2uc (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				82	static sf_count_t pcm_write_i2bes (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				83	static sf_count_t pcm_write_i2les (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				84	static sf_count_t pcm_write_i2bet (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				85	static sf_count_t pcm_write_i2let (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				86	static sf_count_t pcm_write_i2bei (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				87	static sf_count_t pcm_write_i2lei (SF_PRIVATE psf, const int ptr, sf_count_t len) ;
				88
				89	static sf_count_t pcm_write_f2sc (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				90	static sf_count_t pcm_write_f2uc (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				91	static sf_count_t pcm_write_f2bes (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				92	static sf_count_t pcm_write_f2les (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				93	static sf_count_t pcm_write_f2bet (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				94	static sf_count_t pcm_write_f2let (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				95	static sf_count_t pcm_write_f2bei (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				96	static sf_count_t pcm_write_f2lei (SF_PRIVATE psf, const float ptr, sf_count_t len) ;
				97
				98	static sf_count_t pcm_write_d2sc (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				99	static sf_count_t pcm_write_d2uc (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				100	static sf_count_t pcm_write_d2bes (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				101	static sf_count_t pcm_write_d2les (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				102	static sf_count_t pcm_write_d2bet (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				103	static sf_count_t pcm_write_d2let (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				104	static sf_count_t pcm_write_d2bei (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				105	static sf_count_t pcm_write_d2lei (SF_PRIVATE psf, const double ptr, sf_count_t len) ;
				106
				107	/*-----------------------------------------------------------------------------------------------
				108	*/
				109
				110	enum
				111	{ /* Char type for 8 bit files. */
				112	SF_CHARS_SIGNED = 200,
				113	SF_CHARS_UNSIGNED = 201
				114	} ;
				115
				116	/*-----------------------------------------------------------------------------------------------
				117	*/
				118
				119	int
				120	pcm_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
				282	static inline void
				283	sc2s_array (signed char src, int count, short dest)
				284	{ while (--count >= 0)
				285	{ dest [count] = src [count] << 8 ;
				286	} ;
				287	} /* sc2s_array */
				288
				289	static inline void
				290	uc2s_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
				296	static inline void
				297	let2s_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
				307	static inline void
				308	bet2s_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
				318	static inline void
				319	lei2s_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
				328	static inline void
				329	bei2s_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
				341	static inline void
				342	sc2i_array (signed char src, int count, int dest)
				343	{ while (--count >= 0)
				344	{ dest [count] = ((int) src [count]) << 24 ;
				345	} ;
				346	} /* sc2i_array */
				347
				348	static inline void
				349	uc2i_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
				355	static inline void
				356	bes2i_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
				365	static inline void
				366	les2i_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
				375	static inline void
				376	bet2i_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
				386	static inline void
				387	let2i_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
				400	static inline void
				401	sc2f_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
				406	static inline void
				407	uc2f_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
				412	static inline void
				413	les2f_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
				423	static inline void
				424	bes2f_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
				434	static inline void
				435	let2f_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
				447	static inline void
				448	bet2f_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
				460	static inline void
				461	lei2f_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
				471	static inline void
				472	bei2f_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
				485	static inline void
				486	sc2d_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
				491	static inline void
				492	uc2d_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
				497	static inline void
				498	les2d_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
				508	static inline void
				509	bes2d_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
				519	static inline void
				520	let2d_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
				532	static inline void
				533	bet2d_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
				545	static inline void
				546	lei2d_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
				556	static inline void
				557	bei2d_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
				570	static inline void
				571	s2sc_array (const short src, signed char dest, int count)
				572	{ while (--count >= 0)
				573	dest [count] = src [count] >> 8 ;
				574	} /* s2sc_array */
				575
				576	static inline void
				577	s2uc_array (const short src, unsigned char dest, int count)
				578	{ while (--count >= 0)
				579	dest [count] = (src [count] >> 8) + 0x80 ;
				580	} /* s2uc_array */
				581
				582	static inline void
				583	s2let_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
				595	static inline void
				596	s2bet_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
				608	static inline void
				609	s2lei_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
				622	static inline void
				623	s2bei_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
				639	static inline void
				640	i2sc_array (const int src, signed char dest, int count)
				641	{ while (--count >= 0)
				642	dest [count] = (src [count] >> 24) ;
				643	} /* i2sc_array */
				644
				645	static inline void
				646	i2uc_array (const int src, unsigned char dest, int count)
				647	{ while (--count >= 0)
				648	dest [count] = ((src [count] >> 24) + 128) ;
				649	} /* i2uc_array */
				650
				651	static inline void
				652	i2bes_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
				663	static inline void
				664	i2les_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
				675	static inline void
				676	i2let_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
				690	static inline void
				691	i2bet_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
				708	static sf_count_t
				709	pcm_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
				729	static sf_count_t
				730	pcm_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
				750	static sf_count_t
				751	pcm_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
				761	static sf_count_t
				762	pcm_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
				772	static sf_count_t
				773	pcm_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
				793	static sf_count_t
				794	pcm_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
				814	static sf_count_t
				815	pcm_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
				835	static sf_count_t
				836	pcm_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
				859	static sf_count_t
				860	pcm_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
				880	static sf_count_t
				881	pcm_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
				901	static sf_count_t
				902	pcm_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
				922	static sf_count_t
				923	pcm_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
				943	static sf_count_t
				944	pcm_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
				964	static sf_count_t
				965	pcm_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
				985	static sf_count_t
				986	pcm_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
				996	static sf_count_t
				997	pcm_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
				1010	static sf_count_t
				1011	pcm_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
				1034	static sf_count_t
				1035	pcm_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
				1058	static sf_count_t
				1059	pcm_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
				1082	static sf_count_t
				1083	pcm_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
				1106	static sf_count_t
				1107	pcm_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
				1131	static sf_count_t
				1132	pcm_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
				1156	static sf_count_t
				1157	pcm_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
				1180	static sf_count_t
				1181	pcm_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
				1207	static sf_count_t
				1208	pcm_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
				1231	static sf_count_t
				1232	pcm_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
				1255	static sf_count_t
				1256	pcm_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
				1279	static sf_count_t
				1280	pcm_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
				1303	static sf_count_t
				1304	pcm_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
				1327	static sf_count_t
				1328	pcm_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
				1352	static sf_count_t
				1353	pcm_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
				1376	static sf_count_t
				1377	pcm_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
				1405	static sf_count_t
				1406	pcm_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
				1426	static sf_count_t
				1427	pcm_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
				1447	static sf_count_t
				1448	pcm_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
				1472	static sf_count_t
				1473	pcm_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
				1496	static sf_count_t
				1497	pcm_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
				1517	static sf_count_t
				1518	pcm_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
				1538	static sf_count_t
				1539	pcm_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
				1559	static sf_count_t
				1560	pcm_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
				1583	static sf_count_t
				1584	pcm_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
				1604	static sf_count_t
				1605	pcm_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
				1625	static sf_count_t
				1626	pcm_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
				1646	static sf_count_t
				1647	pcm_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
				1667	static sf_count_t
				1668	pcm_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
				1688	static sf_count_t
				1689	pcm_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
				1709	static sf_count_t
				1710	pcm_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
				1733	static sf_count_t
				1734	pcm_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
				1762	static void
				1763	f2sc_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
				1773	static void
				1774	f2sc_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
				1794	static sf_count_t
				1795	pcm_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
				1820	static void
				1821	f2uc_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
				1831	static void
				1832	f2uc_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
				1852	static sf_count_t
				1853	pcm_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
				1878	static void
				1879	f2bes_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
				1895	static void
				1896	f2bes_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
				1924	static sf_count_t
				1925	pcm_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
				1950	static void
				1951	f2les_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
				1967	static void
				1968	f2les_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
				1996	static sf_count_t
				1997	pcm_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
				2022	static void
				2023	f2let_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
				2040	static void
				2041	f2let_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
				2072	static sf_count_t
				2073	pcm_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
				2098	static void
				2099	f2bet_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
				2116	static void
				2117	f2bet_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
				2148	static sf_count_t
				2149	pcm_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
				2174	static void
				2175	f2bei_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
				2192	static void
				2193	f2bei_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
				2227	static sf_count_t
				2228	pcm_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
				2253	static void
				2254	f2lei_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
				2272	static void
				2273	f2lei_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
				2307	static sf_count_t
				2308	pcm_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
				2333	static void
				2334	d2sc_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
				2344	static void
				2345	d2sc_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
				2365	static sf_count_t
				2366	pcm_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
				2391	static void
				2392	d2uc_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
				2402	static void
				2403	d2uc_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
				2423	static sf_count_t
				2424	pcm_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
				2449	static void
				2450	d2bes_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
				2466	static void
				2467	d2bes_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
				2495	static sf_count_t
				2496	pcm_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
				2521	static void
				2522	d2les_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
				2538	static void
				2539	d2les_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
				2567	static sf_count_t
				2568	pcm_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
				2593	static void
				2594	d2let_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
				2611	static void
				2612	d2let_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
				2643	static sf_count_t
				2644	pcm_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
				2669	static void
				2670	d2bet_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
				2687	static void
				2688	d2bet_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
				2719	static sf_count_t
				2720	pcm_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
				2745	static void
				2746	d2bei_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
				2764	static void
				2765	d2bei_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
				2799	static sf_count_t
				2800	pcm_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
				2825	static void
				2826	d2lei_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
				2844	static void
				2845	d2lei_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
				2879	static sf_count_t
				2880	pcm_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