src/pcm.c

   1 /*
   2 ** Copyright (C) 1999-2009 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