2
** Copyright (C) 1999-2005 Erik de Castro Lopo <erikd@mega-nerd.com>
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.
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.
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.
23
#include "float_cast.h"
26
/* Need to be able to handle 3 byte (24 bit) integers. So defined a
27
** type and use SIZEOF_TRIBYTE instead of (tribyte).
30
typedef void tribyte ;
32
#define SIZEOF_TRIBYTE 3
34
static sf_count_t pcm_read_sc2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
35
static sf_count_t pcm_read_uc2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
36
static sf_count_t pcm_read_bes2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
37
static sf_count_t pcm_read_les2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
38
static sf_count_t pcm_read_bet2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
39
static sf_count_t pcm_read_let2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
40
static sf_count_t pcm_read_bei2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
41
static sf_count_t pcm_read_lei2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
43
static sf_count_t pcm_read_sc2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
44
static sf_count_t pcm_read_uc2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
45
static sf_count_t pcm_read_bes2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
46
static sf_count_t pcm_read_les2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
47
static sf_count_t pcm_read_bet2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
48
static sf_count_t pcm_read_let2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
49
static sf_count_t pcm_read_bei2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
50
static sf_count_t pcm_read_lei2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
52
static sf_count_t pcm_read_sc2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
53
static sf_count_t pcm_read_uc2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
54
static sf_count_t pcm_read_bes2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
55
static sf_count_t pcm_read_les2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
56
static sf_count_t pcm_read_bet2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
57
static sf_count_t pcm_read_let2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
58
static sf_count_t pcm_read_bei2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
59
static sf_count_t pcm_read_lei2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
61
static sf_count_t pcm_read_sc2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
62
static sf_count_t pcm_read_uc2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
63
static sf_count_t pcm_read_bes2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
64
static sf_count_t pcm_read_les2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
65
static sf_count_t pcm_read_bet2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
66
static sf_count_t pcm_read_let2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
67
static sf_count_t pcm_read_bei2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
68
static sf_count_t pcm_read_lei2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
70
static sf_count_t pcm_write_s2sc (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
71
static sf_count_t pcm_write_s2uc (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
72
static sf_count_t pcm_write_s2bes (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
73
static sf_count_t pcm_write_s2les (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
74
static sf_count_t pcm_write_s2bet (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
75
static sf_count_t pcm_write_s2let (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
76
static sf_count_t pcm_write_s2bei (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
77
static sf_count_t pcm_write_s2lei (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
79
static sf_count_t pcm_write_i2sc (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
80
static sf_count_t pcm_write_i2uc (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
81
static sf_count_t pcm_write_i2bes (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
82
static sf_count_t pcm_write_i2les (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
83
static sf_count_t pcm_write_i2bet (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
84
static sf_count_t pcm_write_i2let (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
85
static sf_count_t pcm_write_i2bei (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
86
static sf_count_t pcm_write_i2lei (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
88
static sf_count_t pcm_write_f2sc (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
89
static sf_count_t pcm_write_f2uc (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
90
static sf_count_t pcm_write_f2bes (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
91
static sf_count_t pcm_write_f2les (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
92
static sf_count_t pcm_write_f2bet (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
93
static sf_count_t pcm_write_f2let (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
94
static sf_count_t pcm_write_f2bei (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
95
static sf_count_t pcm_write_f2lei (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
97
static sf_count_t pcm_write_d2sc (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
98
static sf_count_t pcm_write_d2uc (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
99
static sf_count_t pcm_write_d2bes (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
100
static sf_count_t pcm_write_d2les (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
101
static sf_count_t pcm_write_d2bet (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
102
static sf_count_t pcm_write_d2let (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
103
static sf_count_t pcm_write_d2bei (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
104
static sf_count_t pcm_write_d2lei (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
106
/*-----------------------------------------------------------------------------------------------
110
{ /* Char type for 8 bit files. */
111
SF_CHARS_SIGNED = 200,
112
SF_CHARS_UNSIGNED = 201
115
/*-----------------------------------------------------------------------------------------------
119
pcm_init (SF_PRIVATE *psf)
122
if (psf->bytewidth == 0 || psf->sf.channels == 0)
123
return SFE_INTERNAL ;
125
psf->blockwidth = psf->bytewidth * psf->sf.channels ;
127
if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_S8)
128
chars = SF_CHARS_SIGNED ;
129
else if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_U8)
130
chars = SF_CHARS_UNSIGNED ;
132
if (psf->mode == SFM_READ || psf->mode == SFM_RDWR)
133
{ switch (psf->bytewidth * 0x10000 + psf->endian + chars)
134
{ case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_SIGNED) :
135
case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_SIGNED) :
136
psf->read_short = pcm_read_sc2s ;
137
psf->read_int = pcm_read_sc2i ;
138
psf->read_float = pcm_read_sc2f ;
139
psf->read_double = pcm_read_sc2d ;
141
case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_UNSIGNED) :
142
case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_UNSIGNED) :
143
psf->read_short = pcm_read_uc2s ;
144
psf->read_int = pcm_read_uc2i ;
145
psf->read_float = pcm_read_uc2f ;
146
psf->read_double = pcm_read_uc2d ;
149
case (2 * 0x10000 + SF_ENDIAN_BIG) :
150
psf->read_short = pcm_read_bes2s ;
151
psf->read_int = pcm_read_bes2i ;
152
psf->read_float = pcm_read_bes2f ;
153
psf->read_double = pcm_read_bes2d ;
155
case (3 * 0x10000 + SF_ENDIAN_BIG) :
156
psf->read_short = pcm_read_bet2s ;
157
psf->read_int = pcm_read_bet2i ;
158
psf->read_float = pcm_read_bet2f ;
159
psf->read_double = pcm_read_bet2d ;
161
case (4 * 0x10000 + SF_ENDIAN_BIG) :
162
psf->read_short = pcm_read_bei2s ;
163
psf->read_int = pcm_read_bei2i ;
164
psf->read_float = pcm_read_bei2f ;
165
psf->read_double = pcm_read_bei2d ;
168
case (2 * 0x10000 + SF_ENDIAN_LITTLE) :
169
psf->read_short = pcm_read_les2s ;
170
psf->read_int = pcm_read_les2i ;
171
psf->read_float = pcm_read_les2f ;
172
psf->read_double = pcm_read_les2d ;
174
case (3 * 0x10000 + SF_ENDIAN_LITTLE) :
175
psf->read_short = pcm_read_let2s ;
176
psf->read_int = pcm_read_let2i ;
177
psf->read_float = pcm_read_let2f ;
178
psf->read_double = pcm_read_let2d ;
180
case (4 * 0x10000 + SF_ENDIAN_LITTLE) :
181
psf->read_short = pcm_read_lei2s ;
182
psf->read_int = pcm_read_lei2i ;
183
psf->read_float = pcm_read_lei2f ;
184
psf->read_double = pcm_read_lei2d ;
187
psf_log_printf (psf, "pcm.c returning SFE_UNIMPLEMENTED\n") ;
188
return SFE_UNIMPLEMENTED ;
192
if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
193
{ switch (psf->bytewidth * 0x10000 + psf->endian + chars)
194
{ case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_SIGNED) :
195
case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_SIGNED) :
196
psf->write_short = pcm_write_s2sc ;
197
psf->write_int = pcm_write_i2sc ;
198
psf->write_float = pcm_write_f2sc ;
199
psf->write_double = pcm_write_d2sc ;
201
case (0x10000 + SF_ENDIAN_BIG + SF_CHARS_UNSIGNED) :
202
case (0x10000 + SF_ENDIAN_LITTLE + SF_CHARS_UNSIGNED) :
203
psf->write_short = pcm_write_s2uc ;
204
psf->write_int = pcm_write_i2uc ;
205
psf->write_float = pcm_write_f2uc ;
206
psf->write_double = pcm_write_d2uc ;
209
case (2 * 0x10000 + SF_ENDIAN_BIG) :
210
psf->write_short = pcm_write_s2bes ;
211
psf->write_int = pcm_write_i2bes ;
212
psf->write_float = pcm_write_f2bes ;
213
psf->write_double = pcm_write_d2bes ;
216
case (3 * 0x10000 + SF_ENDIAN_BIG) :
217
psf->write_short = pcm_write_s2bet ;
218
psf->write_int = pcm_write_i2bet ;
219
psf->write_float = pcm_write_f2bet ;
220
psf->write_double = pcm_write_d2bet ;
223
case (4 * 0x10000 + SF_ENDIAN_BIG) :
224
psf->write_short = pcm_write_s2bei ;
225
psf->write_int = pcm_write_i2bei ;
226
psf->write_float = pcm_write_f2bei ;
227
psf->write_double = pcm_write_d2bei ;
230
case (2 * 0x10000 + SF_ENDIAN_LITTLE) :
231
psf->write_short = pcm_write_s2les ;
232
psf->write_int = pcm_write_i2les ;
233
psf->write_float = pcm_write_f2les ;
234
psf->write_double = pcm_write_d2les ;
237
case (3 * 0x10000 + SF_ENDIAN_LITTLE) :
238
psf->write_short = pcm_write_s2let ;
239
psf->write_int = pcm_write_i2let ;
240
psf->write_float = pcm_write_f2let ;
241
psf->write_double = pcm_write_d2let ;
244
case (4 * 0x10000 + SF_ENDIAN_LITTLE) :
245
psf->write_short = pcm_write_s2lei ;
246
psf->write_int = pcm_write_i2lei ;
247
psf->write_float = pcm_write_f2lei ;
248
psf->write_double = pcm_write_d2lei ;
252
psf_log_printf (psf, "pcm.c returning SFE_UNIMPLEMENTED\n") ;
253
return SFE_UNIMPLEMENTED ;
258
if (psf->filelength > psf->dataoffset)
259
{ psf->datalength = (psf->dataend > 0) ? psf->dataend - psf->dataoffset :
260
psf->filelength - psf->dataoffset ;
263
psf->datalength = 0 ;
265
psf->sf.frames = psf->datalength / psf->blockwidth ;
270
/*==============================================================================
274
sc2s_array (signed char *src, int count, short *dest)
275
{ while (--count >= 0)
276
{ dest [count] = src [count] << 8 ;
281
uc2s_array (unsigned char *src, int count, short *dest)
282
{ while (--count >= 0)
283
{ dest [count] = (((short) src [count]) - 0x80) << 8 ;
288
let2s_array (tribyte *src, int count, short *dest)
289
{ unsigned char *ucptr ;
291
ucptr = ((unsigned char*) src) + 3 * count ;
294
dest [count] = LET2H_SHORT_PTR (ucptr) ;
299
bet2s_array (tribyte *src, int count, short *dest)
300
{ unsigned char *ucptr ;
302
ucptr = ((unsigned char*) src) + 3 * count ;
305
dest [count] = BET2H_SHORT_PTR (ucptr) ;
310
lei2s_array (int *src, int count, short *dest)
314
{ value = LEI2H_INT (src [count]) ;
315
dest [count] = value >> 16 ;
320
bei2s_array (int *src, int count, short *dest)
324
{ value = BEI2H_INT (src [count]) ;
325
dest [count] = value >> 16 ;
329
/*--------------------------------------------------------------------------
333
sc2i_array (signed char *src, int count, int *dest)
334
{ while (--count >= 0)
335
{ dest [count] = ((int) src [count]) << 24 ;
340
uc2i_array (unsigned char *src, int count, int *dest)
341
{ while (--count >= 0)
342
{ dest [count] = (((int) src [count]) - 128) << 24 ;
347
bes2i_array (short *src, int count, int *dest)
351
{ value = BES2H_SHORT (src [count]) ;
352
dest [count] = value << 16 ;
357
les2i_array (short *src, int count, int *dest)
361
{ value = LES2H_SHORT (src [count]) ;
362
dest [count] = value << 16 ;
367
bet2i_array (tribyte *src, int count, int *dest)
368
{ unsigned char *ucptr ;
370
ucptr = ((unsigned char*) src) + 3 * count ;
373
dest [count] = BET2H_INT_PTR (ucptr) ;
378
let2i_array (tribyte *src, int count, int *dest)
379
{ unsigned char *ucptr ;
381
ucptr = ((unsigned char*) src) + 3 * count ;
384
dest [count] = LET2H_INT_PTR (ucptr) ;
388
/*--------------------------------------------------------------------------
392
sc2f_array (signed char *src, int count, float *dest, float normfact)
393
{ while (--count >= 0)
394
dest [count] = ((float) src [count]) * normfact ;
398
uc2f_array (unsigned char *src, int count, float *dest, float normfact)
399
{ while (--count >= 0)
400
dest [count] = (((int) src [count]) - 128) * normfact ;
404
les2f_array (short *src, int count, float *dest, float normfact)
408
{ value = src [count] ;
409
value = LES2H_SHORT (value) ;
410
dest [count] = ((float) value) * normfact ;
415
bes2f_array (short *src, int count, float *dest, float normfact)
419
{ value = src [count] ;
420
value = BES2H_SHORT (value) ;
421
dest [count] = ((float) value) * normfact ;
426
let2f_array (tribyte *src, int count, float *dest, float normfact)
427
{ unsigned char *ucptr ;
430
ucptr = ((unsigned char*) src) + 3 * count ;
433
value = LET2H_INT_PTR (ucptr) ;
434
dest [count] = ((float) value) * normfact ;
439
bet2f_array (tribyte *src, int count, float *dest, float normfact)
440
{ unsigned char *ucptr ;
443
ucptr = ((unsigned char*) src) + 3 * count ;
446
value = BET2H_INT_PTR (ucptr) ;
447
dest [count] = ((float) value) * normfact ;
452
lei2f_array (int *src, int count, float *dest, float normfact)
456
{ value = src [count] ;
457
value = LEI2H_INT (value) ;
458
dest [count] = ((float) value) * normfact ;
463
bei2f_array (int *src, int count, float *dest, float normfact)
467
{ value = src [count] ;
468
value = BEI2H_INT (value) ;
469
dest [count] = ((float) value) * normfact ;
473
/*--------------------------------------------------------------------------
477
sc2d_array (signed char *src, int count, double *dest, double normfact)
478
{ while (--count >= 0)
479
dest [count] = ((double) src [count]) * normfact ;
483
uc2d_array (unsigned char *src, int count, double *dest, double normfact)
484
{ while (--count >= 0)
485
dest [count] = (((int) src [count]) - 128) * normfact ;
489
les2d_array (short *src, int count, double *dest, double normfact)
493
{ value = src [count] ;
494
value = LES2H_SHORT (value) ;
495
dest [count] = ((double) value) * normfact ;
500
bes2d_array (short *src, int count, double *dest, double normfact)
504
{ value = src [count] ;
505
value = BES2H_SHORT (value) ;
506
dest [count] = ((double) value) * normfact ;
511
let2d_array (tribyte *src, int count, double *dest, double normfact)
512
{ unsigned char *ucptr ;
515
ucptr = ((unsigned char*) src) + 3 * count ;
518
value = LET2H_INT_PTR (ucptr) ;
519
dest [count] = ((double) value) * normfact ;
524
bet2d_array (tribyte *src, int count, double *dest, double normfact)
525
{ unsigned char *ucptr ;
528
ucptr = ((unsigned char*) src) + 3 * count ;
531
value = (ucptr [0] << 24) | (ucptr [1] << 16) | (ucptr [2] << 8) ;
532
dest [count] = ((double) value) * normfact ;
537
lei2d_array (int *src, int count, double *dest, double normfact)
541
{ value = src [count] ;
542
value = LEI2H_INT (value) ;
543
dest [count] = ((double) value) * normfact ;
548
bei2d_array (int *src, int count, double *dest, double normfact)
552
{ value = src [count] ;
553
value = BEI2H_INT (value) ;
554
dest [count] = ((double) value) * normfact ;
558
/*--------------------------------------------------------------------------
562
s2sc_array (const short *src, signed char *dest, int count)
563
{ while (--count >= 0)
564
dest [count] = src [count] >> 8 ;
568
s2uc_array (const short *src, unsigned char *dest, int count)
569
{ while (--count >= 0)
570
dest [count] = (src [count] >> 8) + 0x80 ;
574
s2let_array (const short *src, tribyte *dest, int count)
575
{ unsigned char *ucptr ;
577
ucptr = ((unsigned char*) dest) + 3 * count ;
581
ucptr [1] = src [count] ;
582
ucptr [2] = src [count] >> 8 ;
587
s2bet_array (const short *src, tribyte *dest, int count)
588
{ unsigned char *ucptr ;
590
ucptr = ((unsigned char*) dest) + 3 * count ;
594
ucptr [1] = src [count] ;
595
ucptr [0] = src [count] >> 8 ;
600
s2lei_array (const short *src, int *dest, int count)
601
{ unsigned char *ucptr ;
603
ucptr = ((unsigned char*) dest) + 4 * count ;
608
ucptr [2] = src [count] ;
609
ucptr [3] = src [count] >> 8 ;
614
s2bei_array (const short *src, int *dest, int count)
615
{ unsigned char *ucptr ;
617
ucptr = ((unsigned char*) dest) + 4 * count ;
620
ucptr [0] = src [count] >> 8 ;
621
ucptr [1] = src [count] ;
627
/*--------------------------------------------------------------------------
631
i2sc_array (const int *src, signed char *dest, int count)
632
{ while (--count >= 0)
633
dest [count] = (src [count] >> 24) ;
637
i2uc_array (const int *src, unsigned char *dest, int count)
638
{ while (--count >= 0)
639
dest [count] = ((src [count] >> 24) + 128) ;
643
i2bes_array (const int *src, short *dest, int count)
644
{ unsigned char *ucptr ;
646
ucptr = ((unsigned char*) dest) + 2 * count ;
649
ucptr [0] = src [count] >> 24 ;
650
ucptr [1] = src [count] >> 16 ;
655
i2les_array (const int *src, short *dest, int count)
656
{ unsigned char *ucptr ;
658
ucptr = ((unsigned char*) dest) + 2 * count ;
661
ucptr [0] = src [count] >> 16 ;
662
ucptr [1] = src [count] >> 24 ;
667
i2let_array (const int *src, tribyte *dest, int count)
668
{ unsigned char *ucptr ;
671
ucptr = ((unsigned char*) dest) + 3 * count ;
674
value = src [count] >> 8 ;
676
ucptr [1] = value >> 8 ;
677
ucptr [2] = value >> 16 ;
682
i2bet_array (const int *src, tribyte *dest, int count)
683
{ unsigned char *ucptr ;
686
ucptr = ((unsigned char*) dest) + 3 * count ;
689
value = src [count] >> 8 ;
691
ucptr [1] = value >> 8 ;
692
ucptr [0] = value >> 16 ;
696
/*===============================================================================================
700
pcm_read_sc2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
701
{ int bufferlen, readcount ;
702
sf_count_t total = 0 ;
704
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
707
{ if (len < bufferlen)
708
bufferlen = (int) len ;
709
readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
710
sc2s_array (psf->u.scbuf, readcount, ptr + total) ;
712
if (readcount < bufferlen)
718
} /* pcm_read_sc2s */
721
pcm_read_uc2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
722
{ int bufferlen, readcount ;
723
sf_count_t total = 0 ;
725
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
728
{ if (len < bufferlen)
729
bufferlen = (int) len ;
730
readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
731
uc2s_array (psf->u.ucbuf, readcount, ptr + total) ;
733
if (readcount < bufferlen)
739
} /* pcm_read_uc2s */
742
pcm_read_bes2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
745
total = psf_fread (ptr, sizeof (short), len, psf) ;
746
if (CPU_IS_LITTLE_ENDIAN)
747
endswap_short_array (ptr, len) ;
750
} /* pcm_read_bes2s */
753
pcm_read_les2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
756
total = psf_fread (ptr, sizeof (short), len, psf) ;
757
if (CPU_IS_BIG_ENDIAN)
758
endswap_short_array (ptr, len) ;
761
} /* pcm_read_les2s */
764
pcm_read_bet2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
765
{ int bufferlen, readcount ;
766
sf_count_t total = 0 ;
768
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
771
{ if (len < bufferlen)
772
bufferlen = (int) len ;
773
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
774
bet2s_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
776
if (readcount < bufferlen)
782
} /* pcm_read_bet2s */
785
pcm_read_let2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
786
{ int bufferlen, readcount ;
787
sf_count_t total = 0 ;
789
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
792
{ if (len < bufferlen)
793
bufferlen = (int) len ;
794
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
795
let2s_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
797
if (readcount < bufferlen)
803
} /* pcm_read_let2s */
806
pcm_read_bei2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
807
{ int bufferlen, readcount ;
808
sf_count_t total = 0 ;
810
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
813
{ if (len < bufferlen)
814
bufferlen = (int) len ;
815
readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
816
bei2s_array (psf->u.ibuf, readcount, ptr + total) ;
818
if (readcount < bufferlen)
824
} /* pcm_read_bei2s */
827
pcm_read_lei2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
828
{ int bufferlen, readcount ;
829
sf_count_t total = 0 ;
831
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
834
{ if (len < bufferlen)
835
bufferlen = (int) len ;
836
readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
837
lei2s_array (psf->u.ibuf, readcount, ptr + total) ;
839
if (readcount < bufferlen)
845
} /* pcm_read_lei2s */
847
/*-----------------------------------------------------------------------------------------------
851
pcm_read_sc2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
852
{ int bufferlen, readcount ;
853
sf_count_t total = 0 ;
855
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
858
{ if (len < bufferlen)
859
bufferlen = (int) len ;
860
readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
861
sc2i_array (psf->u.scbuf, readcount, ptr + total) ;
863
if (readcount < bufferlen)
869
} /* pcm_read_sc2i */
872
pcm_read_uc2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
873
{ int bufferlen, readcount ;
874
sf_count_t total = 0 ;
876
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
879
{ if (len < bufferlen)
880
bufferlen = (int) len ;
881
readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
882
uc2i_array (psf->u.ucbuf, readcount, ptr + total) ;
884
if (readcount < bufferlen)
890
} /* pcm_read_uc2i */
893
pcm_read_bes2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
894
{ int bufferlen, readcount ;
895
sf_count_t total = 0 ;
897
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
900
{ if (len < bufferlen)
901
bufferlen = (int) len ;
902
readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
903
bes2i_array (psf->u.sbuf, readcount, ptr + total) ;
905
if (readcount < bufferlen)
911
} /* pcm_read_bes2i */
914
pcm_read_les2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
915
{ int bufferlen, readcount ;
916
sf_count_t total = 0 ;
918
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
921
{ if (len < bufferlen)
922
bufferlen = (int) len ;
923
readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
924
les2i_array (psf->u.sbuf, readcount, ptr + total) ;
926
if (readcount < bufferlen)
932
} /* pcm_read_les2i */
935
pcm_read_bet2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
936
{ int bufferlen, readcount ;
937
sf_count_t total = 0 ;
939
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
942
{ if (len < bufferlen)
943
bufferlen = (int) len ;
944
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
945
bet2i_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
947
if (readcount < bufferlen)
953
} /* pcm_read_bet2i */
956
pcm_read_let2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
957
{ int bufferlen, readcount ;
958
sf_count_t total = 0 ;
960
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
963
{ if (len < bufferlen)
964
bufferlen = (int) len ;
965
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
966
let2i_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total) ;
968
if (readcount < bufferlen)
974
} /* pcm_read_let2i */
977
pcm_read_bei2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
980
total = psf_fread (ptr, sizeof (int), len, psf) ;
981
if (CPU_IS_LITTLE_ENDIAN)
982
endswap_int_array (ptr, len) ;
985
} /* pcm_read_bei2i */
988
pcm_read_lei2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
991
total = psf_fread (ptr, sizeof (int), len, psf) ;
992
if (CPU_IS_BIG_ENDIAN)
993
endswap_int_array (ptr, len) ;
996
} /* pcm_read_lei2i */
998
/*-----------------------------------------------------------------------------------------------
1002
pcm_read_sc2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1003
{ int bufferlen, readcount ;
1004
sf_count_t total = 0 ;
1007
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80) : 1.0 ;
1009
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1012
{ if (len < bufferlen)
1013
bufferlen = (int) len ;
1014
readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1015
sc2f_array (psf->u.scbuf, readcount, ptr + total, normfact) ;
1016
total += readcount ;
1017
if (readcount < bufferlen)
1023
} /* pcm_read_sc2f */
1026
pcm_read_uc2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1027
{ int bufferlen, readcount ;
1028
sf_count_t total = 0 ;
1031
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80) : 1.0 ;
1033
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1036
{ if (len < bufferlen)
1037
bufferlen = (int) len ;
1038
readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1039
uc2f_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
1040
total += readcount ;
1041
if (readcount < bufferlen)
1047
} /* pcm_read_uc2f */
1050
pcm_read_bes2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1051
{ int bufferlen, readcount ;
1052
sf_count_t total = 0 ;
1055
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
1057
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1060
{ if (len < bufferlen)
1061
bufferlen = (int) len ;
1062
readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1063
bes2f_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1064
total += readcount ;
1065
if (readcount < bufferlen)
1071
} /* pcm_read_bes2f */
1074
pcm_read_les2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1075
{ int bufferlen, readcount ;
1076
sf_count_t total = 0 ;
1079
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
1081
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1084
{ if (len < bufferlen)
1085
bufferlen = (int) len ;
1086
readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1087
les2f_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1088
total += readcount ;
1089
if (readcount < bufferlen)
1095
} /* pcm_read_les2f */
1098
pcm_read_bet2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1099
{ int bufferlen, readcount ;
1100
sf_count_t total = 0 ;
1103
/* Special normfactor because tribyte value is read into an int. */
1104
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 / 256.0 ;
1106
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1109
{ if (len < bufferlen)
1110
bufferlen = (int) len ;
1111
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1112
bet2f_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1113
total += readcount ;
1114
if (readcount < bufferlen)
1120
} /* pcm_read_bet2f */
1123
pcm_read_let2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1124
{ int bufferlen, readcount ;
1125
sf_count_t total = 0 ;
1128
/* Special normfactor because tribyte value is read into an int. */
1129
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 / 256.0 ;
1131
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1134
{ if (len < bufferlen)
1135
bufferlen = (int) len ;
1136
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1137
let2f_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1138
total += readcount ;
1139
if (readcount < bufferlen)
1145
} /* pcm_read_let2f */
1148
pcm_read_bei2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1149
{ int bufferlen, readcount ;
1150
sf_count_t total = 0 ;
1153
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
1155
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1158
{ if (len < bufferlen)
1159
bufferlen = (int) len ;
1160
readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1161
bei2f_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1162
total += readcount ;
1163
if (readcount < bufferlen)
1169
} /* pcm_read_bei2f */
1172
pcm_read_lei2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
1173
{ int bufferlen, readcount ;
1174
sf_count_t total = 0 ;
1177
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
1179
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1182
{ if (len < bufferlen)
1183
bufferlen = (int) len ;
1184
readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1185
lei2f_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1186
total += readcount ;
1187
if (readcount < bufferlen)
1193
} /* pcm_read_lei2f */
1195
/*-----------------------------------------------------------------------------------------------
1199
pcm_read_sc2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1200
{ int bufferlen, readcount ;
1201
sf_count_t total = 0 ;
1204
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80) : 1.0 ;
1206
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1209
{ if (len < bufferlen)
1210
bufferlen = (int) len ;
1211
readcount = psf_fread (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1212
sc2d_array (psf->u.scbuf, readcount, ptr + total, normfact) ;
1213
total += readcount ;
1214
if (readcount < bufferlen)
1220
} /* pcm_read_sc2d */
1223
pcm_read_uc2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1224
{ int bufferlen, readcount ;
1225
sf_count_t total = 0 ;
1228
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80) : 1.0 ;
1230
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1233
{ if (len < bufferlen)
1234
bufferlen = (int) len ;
1235
readcount = psf_fread (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1236
uc2d_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
1237
total += readcount ;
1238
if (readcount < bufferlen)
1244
} /* pcm_read_uc2d */
1247
pcm_read_bes2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1248
{ int bufferlen, readcount ;
1249
sf_count_t total = 0 ;
1252
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;
1254
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1257
{ if (len < bufferlen)
1258
bufferlen = (int) len ;
1259
readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1260
bes2d_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1261
total += readcount ;
1262
if (readcount < bufferlen)
1268
} /* pcm_read_bes2d */
1271
pcm_read_les2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1272
{ int bufferlen, readcount ;
1273
sf_count_t total = 0 ;
1276
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;
1278
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1281
{ if (len < bufferlen)
1282
bufferlen = (int) len ;
1283
readcount = psf_fread (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1284
les2d_array (psf->u.sbuf, readcount, ptr + total, normfact) ;
1285
total += readcount ;
1286
if (readcount < bufferlen)
1292
} /* pcm_read_les2d */
1295
pcm_read_bet2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1296
{ int bufferlen, readcount ;
1297
sf_count_t total = 0 ;
1300
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 / 256.0 ;
1302
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1305
{ if (len < bufferlen)
1306
bufferlen = (int) len ;
1307
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1308
bet2d_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1309
total += readcount ;
1310
if (readcount < bufferlen)
1316
} /* pcm_read_bet2d */
1319
pcm_read_let2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1320
{ int bufferlen, readcount ;
1321
sf_count_t total = 0 ;
1324
/* Special normfactor because tribyte value is read into an int. */
1325
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 / 256.0 ;
1327
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1330
{ if (len < bufferlen)
1331
bufferlen = (int) len ;
1332
readcount = psf_fread (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1333
let2d_array ((tribyte*) (psf->u.ucbuf), readcount, ptr + total, normfact) ;
1334
total += readcount ;
1335
if (readcount < bufferlen)
1341
} /* pcm_read_let2d */
1344
pcm_read_bei2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1345
{ int bufferlen, readcount ;
1346
sf_count_t total = 0 ;
1349
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 ;
1351
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1354
{ if (len < bufferlen)
1355
bufferlen = (int) len ;
1356
readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1357
bei2d_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1358
total += readcount ;
1359
if (readcount < bufferlen)
1365
} /* pcm_read_bei2d */
1368
pcm_read_lei2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
1369
{ int bufferlen, readcount ;
1370
sf_count_t total = 0 ;
1373
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 ;
1375
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1378
{ if (len < bufferlen)
1379
bufferlen = (int) len ;
1380
readcount = psf_fread (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1381
lei2d_array (psf->u.ibuf, readcount, ptr + total, normfact) ;
1382
total += readcount ;
1383
if (readcount < bufferlen)
1389
} /* pcm_read_lei2d */
1391
/*===============================================================================================
1392
**-----------------------------------------------------------------------------------------------
1393
**===============================================================================================
1397
pcm_write_s2sc (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1398
{ int bufferlen, writecount ;
1399
sf_count_t total = 0 ;
1401
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1404
{ if (len < bufferlen)
1405
bufferlen = (int) len ;
1406
s2sc_array (ptr + total, psf->u.scbuf, bufferlen) ;
1407
writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1408
total += writecount ;
1409
if (writecount < bufferlen)
1415
} /* pcm_write_s2sc */
1418
pcm_write_s2uc (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1419
{ int bufferlen, writecount ;
1420
sf_count_t total = 0 ;
1422
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1425
{ if (len < bufferlen)
1426
bufferlen = (int) len ;
1427
s2uc_array (ptr + total, psf->u.ucbuf, bufferlen) ;
1428
writecount = psf_fwrite (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1429
total += writecount ;
1430
if (writecount < bufferlen)
1436
} /* pcm_write_s2uc */
1439
pcm_write_s2bes (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1440
{ int bufferlen, writecount ;
1441
sf_count_t total = 0 ;
1443
if (CPU_IS_BIG_ENDIAN)
1444
return psf_fwrite (ptr, sizeof (short), len, psf) ;
1447
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1450
{ if (len < bufferlen)
1451
bufferlen = (int) len ;
1452
endswap_short_copy (psf->u.sbuf, ptr + total, bufferlen) ;
1453
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1454
total += writecount ;
1455
if (writecount < bufferlen)
1461
} /* pcm_write_s2bes */
1464
pcm_write_s2les (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1465
{ int bufferlen, writecount ;
1466
sf_count_t total = 0 ;
1468
if (CPU_IS_LITTLE_ENDIAN)
1469
return psf_fwrite (ptr, sizeof (short), len, psf) ;
1471
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1474
{ if (len < bufferlen)
1475
bufferlen = (int) len ;
1476
endswap_short_copy (psf->u.sbuf, ptr + total, bufferlen) ;
1477
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1478
total += writecount ;
1479
if (writecount < bufferlen)
1485
} /* pcm_write_s2les */
1488
pcm_write_s2bet (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1489
{ int bufferlen, writecount ;
1490
sf_count_t total = 0 ;
1492
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1495
{ if (len < bufferlen)
1496
bufferlen = (int) len ;
1497
s2bet_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1498
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1499
total += writecount ;
1500
if (writecount < bufferlen)
1506
} /* pcm_write_s2bet */
1509
pcm_write_s2let (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1510
{ int bufferlen, writecount ;
1511
sf_count_t total = 0 ;
1513
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1516
{ if (len < bufferlen)
1517
bufferlen = (int) len ;
1518
s2let_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1519
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1520
total += writecount ;
1521
if (writecount < bufferlen)
1527
} /* pcm_write_s2let */
1530
pcm_write_s2bei (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1531
{ int bufferlen, writecount ;
1532
sf_count_t total = 0 ;
1534
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1537
{ if (len < bufferlen)
1538
bufferlen = (int) len ;
1539
s2bei_array (ptr + total, psf->u.ibuf, bufferlen) ;
1540
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1541
total += writecount ;
1542
if (writecount < bufferlen)
1548
} /* pcm_write_s2bei */
1551
pcm_write_s2lei (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
1552
{ int bufferlen, writecount ;
1553
sf_count_t total = 0 ;
1555
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1558
{ if (len < bufferlen)
1559
bufferlen = (int) len ;
1560
s2lei_array (ptr + total, psf->u.ibuf, bufferlen) ;
1561
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1562
total += writecount ;
1563
if (writecount < bufferlen)
1569
} /* pcm_write_s2lei */
1571
/*-----------------------------------------------------------------------------------------------
1575
pcm_write_i2sc (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1576
{ int bufferlen, writecount ;
1577
sf_count_t total = 0 ;
1579
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1582
{ if (len < bufferlen)
1583
bufferlen = (int) len ;
1584
i2sc_array (ptr + total, psf->u.scbuf, bufferlen) ;
1585
writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1586
total += writecount ;
1587
if (writecount < bufferlen)
1593
} /* pcm_write_i2sc */
1596
pcm_write_i2uc (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1597
{ int bufferlen, writecount ;
1598
sf_count_t total = 0 ;
1600
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1603
{ if (len < bufferlen)
1604
bufferlen = (int) len ;
1605
i2uc_array (ptr + total, psf->u.ucbuf, bufferlen) ;
1606
writecount = psf_fwrite (psf->u.ucbuf, sizeof (signed char), bufferlen, psf) ;
1607
total += writecount ;
1608
if (writecount < bufferlen)
1614
} /* pcm_write_i2uc */
1617
pcm_write_i2bes (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1618
{ int bufferlen, writecount ;
1619
sf_count_t total = 0 ;
1621
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1624
{ if (len < bufferlen)
1625
bufferlen = (int) len ;
1626
i2bes_array (ptr + total, psf->u.sbuf, bufferlen) ;
1627
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1628
total += writecount ;
1629
if (writecount < bufferlen)
1635
} /* pcm_write_i2bes */
1638
pcm_write_i2les (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1639
{ int bufferlen, writecount ;
1640
sf_count_t total = 0 ;
1642
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1645
{ if (len < bufferlen)
1646
bufferlen = (int) len ;
1647
i2les_array (ptr + total, psf->u.sbuf, bufferlen) ;
1648
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1649
total += writecount ;
1650
if (writecount < bufferlen)
1656
} /* pcm_write_i2les */
1659
pcm_write_i2bet (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1660
{ int bufferlen, writecount ;
1661
sf_count_t total = 0 ;
1663
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1666
{ if (len < bufferlen)
1667
bufferlen = (int) len ;
1668
i2bet_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1669
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1670
total += writecount ;
1671
if (writecount < bufferlen)
1677
} /* pcm_write_i2bet */
1680
pcm_write_i2let (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1681
{ int bufferlen, writecount ;
1682
sf_count_t total = 0 ;
1684
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
1687
{ if (len < bufferlen)
1688
bufferlen = (int) len ;
1689
i2let_array (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen) ;
1690
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
1691
total += writecount ;
1692
if (writecount < bufferlen)
1698
} /* pcm_write_i2les */
1701
pcm_write_i2bei (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1702
{ int bufferlen, writecount ;
1703
sf_count_t total = 0 ;
1705
if (CPU_IS_BIG_ENDIAN)
1706
return psf_fwrite (ptr, sizeof (int), len, psf) ;
1708
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1711
{ if (len < bufferlen)
1712
bufferlen = (int) len ;
1713
endswap_int_copy (psf->u.ibuf, ptr + total, bufferlen) ;
1714
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1715
total += writecount ;
1716
if (writecount < bufferlen)
1722
} /* pcm_write_i2bei */
1725
pcm_write_i2lei (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
1726
{ int bufferlen, writecount ;
1727
sf_count_t total = 0 ;
1729
if (CPU_IS_LITTLE_ENDIAN)
1730
return psf_fwrite (ptr, sizeof (int), len, psf) ;
1732
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
1735
{ if (len < bufferlen)
1736
bufferlen = (int) len ;
1737
endswap_int_copy (psf->u.ibuf, ptr + total, bufferlen) ;
1738
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
1739
total += writecount ;
1740
if (writecount < bufferlen)
1746
} /* pcm_write_i2lei */
1748
/*------------------------------------------------------------------------------
1749
**==============================================================================
1750
**------------------------------------------------------------------------------
1754
f2sc_array (const float *src, signed char *dest, int count, int normalize)
1757
normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
1759
while (--count >= 0)
1760
{ dest [count] = lrintf (src [count] * normfact) ;
1765
f2sc_clip_array (const float *src, signed char *dest, int count, int normalize)
1766
{ float normfact, scaled_value ;
1768
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
1770
while (--count >= 0)
1771
{ scaled_value = src [count] * normfact ;
1772
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1773
{ dest [count] = 127 ;
1776
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1777
{ dest [count] = -128 ;
1781
dest [count] = lrintf (scaled_value) >> 24 ;
1783
} /* f2sc_clip_array */
1786
pcm_write_f2sc (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1787
{ void (*convert) (const float *, signed char *, int, int) ;
1788
int bufferlen, writecount ;
1789
sf_count_t total = 0 ;
1791
convert = (psf->add_clipping) ? f2sc_clip_array : f2sc_array ;
1792
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
1795
{ if (len < bufferlen)
1796
bufferlen = (int) len ;
1797
convert (ptr + total, psf->u.scbuf, bufferlen, psf->norm_float) ;
1798
writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
1799
total += writecount ;
1800
if (writecount < bufferlen)
1806
} /* pcm_write_f2sc */
1808
/*==============================================================================
1812
f2uc_array (const float *src, unsigned char *dest, int count, int normalize)
1815
normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
1817
while (--count >= 0)
1818
{ dest [count] = lrintf (src [count] * normfact) + 128 ;
1823
f2uc_clip_array (const float *src, unsigned char *dest, int count, int normalize)
1824
{ float normfact, scaled_value ;
1826
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
1828
while (--count >= 0)
1829
{ scaled_value = src [count] * normfact ;
1830
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1831
{ dest [count] = 0xFF ;
1834
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1835
{ dest [count] = 0 ;
1839
dest [count] = (lrintf (scaled_value) >> 24) + 128 ;
1841
} /* f2uc_clip_array */
1844
pcm_write_f2uc (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1845
{ void (*convert) (const float *, unsigned char *, int, int) ;
1846
int bufferlen, writecount ;
1847
sf_count_t total = 0 ;
1849
convert = (psf->add_clipping) ? f2uc_clip_array : f2uc_array ;
1850
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
1853
{ if (len < bufferlen)
1854
bufferlen = (int) len ;
1855
convert (ptr + total, psf->u.ucbuf, bufferlen, psf->norm_float) ;
1856
writecount = psf_fwrite (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
1857
total += writecount ;
1858
if (writecount < bufferlen)
1864
} /* pcm_write_f2uc */
1866
/*==============================================================================
1870
f2bes_array (const float *src, short *dest, int count, int normalize)
1871
{ unsigned char *ucptr ;
1875
normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
1876
ucptr = ((unsigned char*) dest) + 2 * count ;
1878
while (--count >= 0)
1880
value = lrintf (src [count] * normfact) ;
1882
ucptr [0] = value >> 8 ;
1887
f2bes_clip_array (const float *src, short *dest, int count, int normalize)
1888
{ unsigned char *ucptr ;
1889
float normfact, scaled_value ;
1892
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
1893
ucptr = ((unsigned char*) dest) + 2 * count ;
1895
while (--count >= 0)
1897
scaled_value = src [count] * normfact ;
1898
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1899
{ ucptr [1] = 0xFF ;
1903
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1904
{ ucptr [1] = 0x00 ;
1909
value = lrintf (scaled_value) ;
1910
ucptr [1] = value >> 16 ;
1911
ucptr [0] = value >> 24 ;
1913
} /* f2bes_clip_array */
1916
pcm_write_f2bes (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1917
{ void (*convert) (const float *, short *t, int, int) ;
1918
int bufferlen, writecount ;
1919
sf_count_t total = 0 ;
1921
convert = (psf->add_clipping) ? f2bes_clip_array : f2bes_array ;
1922
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1925
{ if (len < bufferlen)
1926
bufferlen = (int) len ;
1927
convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_float) ;
1928
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
1929
total += writecount ;
1930
if (writecount < bufferlen)
1936
} /* pcm_write_f2bes */
1938
/*==============================================================================
1942
f2les_array (const float *src, short *dest, int count, int normalize)
1943
{ unsigned char *ucptr ;
1947
normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
1948
ucptr = ((unsigned char*) dest) + 2 * count ;
1950
while (--count >= 0)
1952
value = lrintf (src [count] * normfact) ;
1954
ucptr [1] = value >> 8 ;
1959
f2les_clip_array (const float *src, short *dest, int count, int normalize)
1960
{ unsigned char *ucptr ;
1961
float normfact, scaled_value ;
1964
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
1965
ucptr = ((unsigned char*) dest) + 2 * count ;
1967
while (--count >= 0)
1969
scaled_value = src [count] * normfact ;
1970
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
1971
{ ucptr [0] = 0xFF ;
1975
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
1976
{ ucptr [0] = 0x00 ;
1981
value = lrintf (scaled_value) ;
1982
ucptr [0] = value >> 16 ;
1983
ucptr [1] = value >> 24 ;
1985
} /* f2les_clip_array */
1988
pcm_write_f2les (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
1989
{ void (*convert) (const float *, short *t, int, int) ;
1990
int bufferlen, writecount ;
1991
sf_count_t total = 0 ;
1993
convert = (psf->add_clipping) ? f2les_clip_array : f2les_array ;
1994
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
1997
{ if (len < bufferlen)
1998
bufferlen = (int) len ;
1999
convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_float) ;
2000
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
2001
total += writecount ;
2002
if (writecount < bufferlen)
2008
} /* pcm_write_f2les */
2010
/*==============================================================================
2014
f2let_array (const float *src, tribyte *dest, int count, int normalize)
2015
{ unsigned char *ucptr ;
2019
normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2020
ucptr = ((unsigned char*) dest) + 3 * count ;
2022
while (--count >= 0)
2024
value = lrintf (src [count] * normfact) ;
2026
ucptr [1] = value >> 8 ;
2027
ucptr [2] = value >> 16 ;
2032
f2let_clip_array (const float *src, tribyte *dest, int count, int normalize)
2033
{ unsigned char *ucptr ;
2034
float normfact, scaled_value ;
2037
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2038
ucptr = ((unsigned char*) dest) + 3 * count ;
2040
while (--count >= 0)
2042
scaled_value = src [count] * normfact ;
2043
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2044
{ ucptr [0] = 0xFF ;
2049
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2050
{ ucptr [0] = 0x00 ;
2056
value = lrintf (scaled_value) ;
2057
ucptr [0] = value >> 8 ;
2058
ucptr [1] = value >> 16 ;
2059
ucptr [2] = value >> 24 ;
2061
} /* f2let_clip_array */
2064
pcm_write_f2let (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2065
{ void (*convert) (const float *, tribyte *, int, int) ;
2066
int bufferlen, writecount ;
2067
sf_count_t total = 0 ;
2069
convert = (psf->add_clipping) ? f2let_clip_array : f2let_array ;
2070
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2073
{ if (len < bufferlen)
2074
bufferlen = (int) len ;
2075
convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_float) ;
2076
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2077
total += writecount ;
2078
if (writecount < bufferlen)
2084
} /* pcm_write_f2let */
2086
/*==============================================================================
2090
f2bet_array (const float *src, tribyte *dest, int count, int normalize)
2091
{ unsigned char *ucptr ;
2095
normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2096
ucptr = ((unsigned char*) dest) + 3 * count ;
2098
while (--count >= 0)
2100
value = lrintf (src [count] * normfact) ;
2101
ucptr [0] = value >> 16 ;
2102
ucptr [1] = value >> 8 ;
2108
f2bet_clip_array (const float *src, tribyte *dest, int count, int normalize)
2109
{ unsigned char *ucptr ;
2110
float normfact, scaled_value ;
2113
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2114
ucptr = ((unsigned char*) dest) + 3 * count ;
2116
while (--count >= 0)
2118
scaled_value = src [count] * normfact ;
2119
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2120
{ ucptr [0] = 0x7F ;
2125
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2126
{ ucptr [0] = 0x80 ;
2132
value = lrint (scaled_value) ;
2133
ucptr [0] = value >> 24 ;
2134
ucptr [1] = value >> 16 ;
2135
ucptr [2] = value >> 8 ;
2137
} /* f2bet_clip_array */
2140
pcm_write_f2bet (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2141
{ void (*convert) (const float *, tribyte *, int, int) ;
2142
int bufferlen, writecount ;
2143
sf_count_t total = 0 ;
2145
convert = (psf->add_clipping) ? f2bet_clip_array : f2bet_array ;
2146
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2149
{ if (len < bufferlen)
2150
bufferlen = (int) len ;
2151
convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_float) ;
2152
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2153
total += writecount ;
2154
if (writecount < bufferlen)
2160
} /* pcm_write_f2bet */
2162
/*==============================================================================
2166
f2bei_array (const float *src, int *dest, int count, int normalize)
2167
{ unsigned char *ucptr ;
2171
normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2172
ucptr = ((unsigned char*) dest) + 4 * count ;
2173
while (--count >= 0)
2175
value = lrintf (src [count] * normfact) ;
2176
ucptr [0] = value >> 24 ;
2177
ucptr [1] = value >> 16 ;
2178
ucptr [2] = value >> 8 ;
2184
f2bei_clip_array (const float *src, int *dest, int count, int normalize)
2185
{ unsigned char *ucptr ;
2186
float normfact, scaled_value ;
2189
normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2190
ucptr = ((unsigned char*) dest) + 4 * count ;
2192
while (--count >= 0)
2194
scaled_value = src [count] * normfact ;
2195
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= 1.0 * 0x7FFFFFFF)
2196
{ ucptr [0] = 0x7F ;
2202
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2203
{ ucptr [0] = 0x80 ;
2210
value = lrintf (scaled_value) ;
2211
ucptr [0] = value >> 24 ;
2212
ucptr [1] = value >> 16 ;
2213
ucptr [2] = value >> 8 ;
2216
} /* f2bei_clip_array */
2219
pcm_write_f2bei (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2220
{ void (*convert) (const float *, int *, int, int) ;
2221
int bufferlen, writecount ;
2222
sf_count_t total = 0 ;
2224
convert = (psf->add_clipping) ? f2bei_clip_array : f2bei_array ;
2225
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2228
{ if (len < bufferlen)
2229
bufferlen = (int) len ;
2230
convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_float) ;
2231
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2232
total += writecount ;
2233
if (writecount < bufferlen)
2239
} /* pcm_write_f2bei */
2241
/*==============================================================================
2245
f2lei_array (const float *src, int *dest, int count, int normalize)
2246
{ unsigned char *ucptr ;
2250
normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2251
ucptr = ((unsigned char*) dest) + 4 * count ;
2253
while (--count >= 0)
2255
value = lrintf (src [count] * normfact) ;
2257
ucptr [1] = value >> 8 ;
2258
ucptr [2] = value >> 16 ;
2259
ucptr [3] = value >> 24 ;
2264
f2lei_clip_array (const float *src, int *dest, int count, int normalize)
2265
{ unsigned char *ucptr ;
2266
float normfact, scaled_value ;
2269
normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2270
ucptr = ((unsigned char*) dest) + 4 * count ;
2272
while (--count >= 0)
2274
scaled_value = src [count] * normfact ;
2275
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2276
{ ucptr [0] = 0xFF ;
2282
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2283
{ ucptr [0] = 0x00 ;
2290
value = lrintf (scaled_value) ;
2292
ucptr [1] = value >> 8 ;
2293
ucptr [2] = value >> 16 ;
2294
ucptr [3] = value >> 24 ;
2296
} /* f2lei_clip_array */
2299
pcm_write_f2lei (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
2300
{ void (*convert) (const float *, int *, int, int) ;
2301
int bufferlen, writecount ;
2302
sf_count_t total = 0 ;
2304
convert = (psf->add_clipping) ? f2lei_clip_array : f2lei_array ;
2305
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2308
{ if (len < bufferlen)
2309
bufferlen = (int) len ;
2310
convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_float) ;
2311
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2312
total += writecount ;
2313
if (writecount < bufferlen)
2319
} /* pcm_write_f2lei */
2321
/*==============================================================================
2325
d2sc_array (const double *src, signed char *dest, int count, int normalize)
2328
normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
2330
while (--count >= 0)
2331
{ dest [count] = lrint (src [count] * normfact) ;
2336
d2sc_clip_array (const double *src, signed char *dest, int count, int normalize)
2337
{ double normfact, scaled_value ;
2339
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
2341
while (--count >= 0)
2342
{ scaled_value = src [count] * normfact ;
2343
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2344
{ dest [count] = 127 ;
2347
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2348
{ dest [count] = -128 ;
2352
dest [count] = lrintf (scaled_value) >> 24 ;
2354
} /* d2sc_clip_array */
2357
pcm_write_d2sc (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2358
{ void (*convert) (const double *, signed char *, int, int) ;
2359
int bufferlen, writecount ;
2360
sf_count_t total = 0 ;
2362
convert = (psf->add_clipping) ? d2sc_clip_array : d2sc_array ;
2363
bufferlen = ARRAY_LEN (psf->u.scbuf) ;
2366
{ if (len < bufferlen)
2367
bufferlen = (int) len ;
2368
convert (ptr + total, psf->u.scbuf, bufferlen, psf->norm_double) ;
2369
writecount = psf_fwrite (psf->u.scbuf, sizeof (signed char), bufferlen, psf) ;
2370
total += writecount ;
2371
if (writecount < bufferlen)
2377
} /* pcm_write_d2sc */
2379
/*==============================================================================
2383
d2uc_array (const double *src, unsigned char *dest, int count, int normalize)
2386
normfact = normalize ? (1.0 * 0x7F) : 1.0 ;
2388
while (--count >= 0)
2389
{ dest [count] = lrint (src [count] * normfact) + 128 ;
2394
d2uc_clip_array (const double *src, unsigned char *dest, int count, int normalize)
2395
{ double normfact, scaled_value ;
2397
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x1000000) ;
2399
while (--count >= 0)
2400
{ scaled_value = src [count] * normfact ;
2401
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2402
{ dest [count] = 255 ;
2405
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2406
{ dest [count] = 0 ;
2410
dest [count] = (lrint (src [count] * normfact) >> 24) + 128 ;
2412
} /* d2uc_clip_array */
2415
pcm_write_d2uc (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2416
{ void (*convert) (const double *, unsigned char *, int, int) ;
2417
int bufferlen, writecount ;
2418
sf_count_t total = 0 ;
2420
convert = (psf->add_clipping) ? d2uc_clip_array : d2uc_array ;
2421
bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
2424
{ if (len < bufferlen)
2425
bufferlen = (int) len ;
2426
convert (ptr + total, psf->u.ucbuf, bufferlen, psf->norm_double) ;
2427
writecount = psf_fwrite (psf->u.ucbuf, sizeof (unsigned char), bufferlen, psf) ;
2428
total += writecount ;
2429
if (writecount < bufferlen)
2435
} /* pcm_write_d2uc */
2437
/*==============================================================================
2441
d2bes_array (const double *src, short *dest, int count, int normalize)
2442
{ unsigned char *ucptr ;
2446
normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
2447
ucptr = ((unsigned char*) dest) + 2 * count ;
2449
while (--count >= 0)
2451
value = lrint (src [count] * normfact) ;
2453
ucptr [0] = value >> 8 ;
2458
d2bes_clip_array (const double *src, short *dest, int count, int normalize)
2459
{ unsigned char *ucptr ;
2460
double normfact, scaled_value ;
2463
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
2464
ucptr = ((unsigned char*) dest) + 2 * count ;
2466
while (--count >= 0)
2468
scaled_value = src [count] * normfact ;
2469
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2470
{ ucptr [1] = 0xFF ;
2474
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2475
{ ucptr [1] = 0x00 ;
2480
value = lrint (scaled_value) ;
2481
ucptr [1] = value >> 16 ;
2482
ucptr [0] = value >> 24 ;
2484
} /* d2bes_clip_array */
2487
pcm_write_d2bes (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2488
{ void (*convert) (const double *, short *, int, int) ;
2489
int bufferlen, writecount ;
2490
sf_count_t total = 0 ;
2492
convert = (psf->add_clipping) ? d2bes_clip_array : d2bes_array ;
2493
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
2496
{ if (len < bufferlen)
2497
bufferlen = (int) len ;
2498
convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_double) ;
2499
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
2500
total += writecount ;
2501
if (writecount < bufferlen)
2507
} /* pcm_write_d2bes */
2509
/*==============================================================================
2513
d2les_array (const double *src, short *dest, int count, int normalize)
2514
{ unsigned char *ucptr ;
2518
normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
2519
ucptr = ((unsigned char*) dest) + 2 * count ;
2521
while (--count >= 0)
2523
value = lrint (src [count] * normfact) ;
2525
ucptr [1] = value >> 8 ;
2530
d2les_clip_array (const double *src, short *dest, int count, int normalize)
2531
{ unsigned char *ucptr ;
2533
double normfact, scaled_value ;
2535
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x10000) ;
2536
ucptr = ((unsigned char*) dest) + 2 * count ;
2538
while (--count >= 0)
2540
scaled_value = src [count] * normfact ;
2541
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2542
{ ucptr [0] = 0xFF ;
2546
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2547
{ ucptr [0] = 0x00 ;
2552
value = lrint (scaled_value) ;
2553
ucptr [0] = value >> 16 ;
2554
ucptr [1] = value >> 24 ;
2556
} /* d2les_clip_array */
2559
pcm_write_d2les (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2560
{ void (*convert) (const double *, short *, int, int) ;
2561
int bufferlen, writecount ;
2562
sf_count_t total = 0 ;
2564
convert = (psf->add_clipping) ? d2les_clip_array : d2les_array ;
2565
bufferlen = ARRAY_LEN (psf->u.sbuf) ;
2568
{ if (len < bufferlen)
2569
bufferlen = (int) len ;
2570
convert (ptr + total, psf->u.sbuf, bufferlen, psf->norm_double) ;
2571
writecount = psf_fwrite (psf->u.sbuf, sizeof (short), bufferlen, psf) ;
2572
total += writecount ;
2573
if (writecount < bufferlen)
2579
} /* pcm_write_d2les */
2581
/*==============================================================================
2585
d2let_array (const double *src, tribyte *dest, int count, int normalize)
2586
{ unsigned char *ucptr ;
2590
normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2591
ucptr = ((unsigned char*) dest) + 3 * count ;
2593
while (--count >= 0)
2595
value = lrint (src [count] * normfact) ;
2597
ucptr [1] = value >> 8 ;
2598
ucptr [2] = value >> 16 ;
2603
d2let_clip_array (const double *src, tribyte *dest, int count, int normalize)
2604
{ unsigned char *ucptr ;
2606
double normfact, scaled_value ;
2608
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2609
ucptr = ((unsigned char*) dest) + 3 * count ;
2611
while (--count >= 0)
2613
scaled_value = src [count] * normfact ;
2614
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2615
{ ucptr [0] = 0xFF ;
2620
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2621
{ ucptr [0] = 0x00 ;
2627
value = lrint (scaled_value) ;
2628
ucptr [0] = value >> 8 ;
2629
ucptr [1] = value >> 16 ;
2630
ucptr [2] = value >> 24 ;
2632
} /* d2let_clip_array */
2635
pcm_write_d2let (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2636
{ void (*convert) (const double *, tribyte *, int, int) ;
2637
int bufferlen, writecount ;
2638
sf_count_t total = 0 ;
2640
convert = (psf->add_clipping) ? d2let_clip_array : d2let_array ;
2641
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2644
{ if (len < bufferlen)
2645
bufferlen = (int) len ;
2646
convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_double) ;
2647
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2648
total += writecount ;
2649
if (writecount < bufferlen)
2655
} /* pcm_write_d2let */
2657
/*==============================================================================
2661
d2bet_array (const double *src, tribyte *dest, int count, int normalize)
2662
{ unsigned char *ucptr ;
2666
normfact = normalize ? (1.0 * 0x7FFFFF) : 1.0 ;
2667
ucptr = ((unsigned char*) dest) + 3 * count ;
2669
while (--count >= 0)
2671
value = lrint (src [count] * normfact) ;
2673
ucptr [1] = value >> 8 ;
2674
ucptr [0] = value >> 16 ;
2679
d2bet_clip_array (const double *src, tribyte *dest, int count, int normalize)
2680
{ unsigned char *ucptr ;
2682
double normfact, scaled_value ;
2684
normfact = normalize ? (8.0 * 0x10000000) : (1.0 * 0x100) ;
2685
ucptr = ((unsigned char*) dest) + 3 * count ;
2687
while (--count >= 0)
2689
scaled_value = src [count] * normfact ;
2690
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2691
{ ucptr [2] = 0xFF ;
2696
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2697
{ ucptr [2] = 0x00 ;
2703
value = lrint (scaled_value) ;
2704
ucptr [2] = value >> 8 ;
2705
ucptr [1] = value >> 16 ;
2706
ucptr [0] = value >> 24 ;
2708
} /* d2bet_clip_array */
2711
pcm_write_d2bet (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2712
{ void (*convert) (const double *, tribyte *, int, int) ;
2713
int bufferlen, writecount ;
2714
sf_count_t total = 0 ;
2716
convert = (psf->add_clipping) ? d2bet_clip_array : d2bet_array ;
2717
bufferlen = sizeof (psf->u.ucbuf) / SIZEOF_TRIBYTE ;
2720
{ if (len < bufferlen)
2721
bufferlen = (int) len ;
2722
convert (ptr + total, (tribyte*) (psf->u.ucbuf), bufferlen, psf->norm_double) ;
2723
writecount = psf_fwrite (psf->u.ucbuf, SIZEOF_TRIBYTE, bufferlen, psf) ;
2724
total += writecount ;
2725
if (writecount < bufferlen)
2731
} /* pcm_write_d2bet */
2733
/*==============================================================================
2737
d2bei_array (const double *src, int *dest, int count, int normalize)
2738
{ unsigned char *ucptr ;
2742
normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2743
ucptr = ((unsigned char*) dest) + 4 * count ;
2745
while (--count >= 0)
2747
value = lrint (src [count] * normfact) ;
2748
ucptr [0] = value >> 24 ;
2749
ucptr [1] = value >> 16 ;
2750
ucptr [2] = value >> 8 ;
2756
d2bei_clip_array (const double *src, int *dest, int count, int normalize)
2757
{ unsigned char *ucptr ;
2759
double normfact, scaled_value ;
2761
normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2762
ucptr = ((unsigned char*) dest) + 4 * count ;
2764
while (--count >= 0)
2766
scaled_value = src [count] * normfact ;
2767
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2768
{ ucptr [3] = 0xFF ;
2774
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2775
{ ucptr [3] = 0x00 ;
2782
value = lrint (scaled_value) ;
2783
ucptr [0] = value >> 24 ;
2784
ucptr [1] = value >> 16 ;
2785
ucptr [2] = value >> 8 ;
2788
} /* d2bei_clip_array */
2791
pcm_write_d2bei (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2792
{ void (*convert) (const double *, int *, int, int) ;
2793
int bufferlen, writecount ;
2794
sf_count_t total = 0 ;
2796
convert = (psf->add_clipping) ? d2bei_clip_array : d2bei_array ;
2797
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2800
{ if (len < bufferlen)
2801
bufferlen = (int) len ;
2802
convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_double) ;
2803
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2804
total += writecount ;
2805
if (writecount < bufferlen)
2811
} /* pcm_write_d2bei */
2813
/*==============================================================================
2817
d2lei_array (const double *src, int *dest, int count, int normalize)
2818
{ unsigned char *ucptr ;
2822
normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
2823
ucptr = ((unsigned char*) dest) + 4 * count ;
2825
while (--count >= 0)
2827
value = lrint (src [count] * normfact) ;
2829
ucptr [1] = value >> 8 ;
2830
ucptr [2] = value >> 16 ;
2831
ucptr [3] = value >> 24 ;
2836
d2lei_clip_array (const double *src, int *dest, int count, int normalize)
2837
{ unsigned char *ucptr ;
2839
double normfact, scaled_value ;
2841
normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
2842
ucptr = ((unsigned char*) dest) + 4 * count ;
2844
while (--count >= 0)
2846
scaled_value = src [count] * normfact ;
2847
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
2848
{ ucptr [0] = 0xFF ;
2854
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
2855
{ ucptr [0] = 0x00 ;
2862
value = lrint (scaled_value) ;
2864
ucptr [1] = value >> 8 ;
2865
ucptr [2] = value >> 16 ;
2866
ucptr [3] = value >> 24 ;
2868
} /* d2lei_clip_array */
2871
pcm_write_d2lei (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
2872
{ void (*convert) (const double *, int *, int, int) ;
2873
int bufferlen, writecount ;
2874
sf_count_t total = 0 ;
2876
convert = (psf->add_clipping) ? d2lei_clip_array : d2lei_array ;
2877
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
2880
{ if (len < bufferlen)
2881
bufferlen = (int) len ;
2882
convert (ptr + total, psf->u.ibuf, bufferlen, psf->norm_double) ;
2883
writecount = psf_fwrite (psf->u.ibuf, sizeof (int), bufferlen, psf) ;
2884
total += writecount ;
2885
if (writecount < bufferlen)
2891
} /* pcm_write_d2lei */
2894
** Do not edit or modify anything in this comment block.
2895
** The arch-tag line is a file identity tag for the GNU Arch
2896
** revision control system.
2898
** arch-tag: d8bc7c0e-1e2f-4ff3-a28f-10ce1fbade3b
added
removed
lib-src/libsndfile/src/pcm.c
