projects / Faustine.git / blob
? search:


4a87cefc344e5188f2e3e1c4e5bfa22b300f5294
[Faustine.git] / interpretor / lib / src / libsndfile-1.0.25 / src / float32.c
1 /*
2 ** Copyright (C) 1999-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
3 **
4 ** This program is free software; you can redistribute it and/or modify
5 ** it under the terms of the GNU Lesser General Public License as published by
6 ** the Free Software Foundation; either version 2.1 of the License, or
7 ** (at your option) any later version.
8 **
9 ** This program is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 ** GNU Lesser General Public License for more details.
13 **
14 ** You should have received a copy of the GNU Lesser General Public License
15 ** along with this program; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 #include "sfconfig.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <limits.h>
25 #include <math.h>
26
27 #include "sndfile.h"
28 #include "sfendian.h"
29 #include "common.h"
30
31 #if CPU_IS_LITTLE_ENDIAN
32 #define FLOAT32_READ float32_le_read
33 #define FLOAT32_WRITE float32_le_write
34 #elif CPU_IS_BIG_ENDIAN
35 #define FLOAT32_READ float32_be_read
36 #define FLOAT32_WRITE float32_be_write
37 #endif
38
39 /*--------------------------------------------------------------------------------------------
40 ** Processor floating point capabilities. float32_get_capability () returns one of the
41 ** latter four values.
42 */
43
44 enum
45 { FLOAT_UNKNOWN = 0x00,
46 FLOAT_CAN_RW_LE = 0x12,
47 FLOAT_CAN_RW_BE = 0x23,
48 FLOAT_BROKEN_LE = 0x34,
49 FLOAT_BROKEN_BE = 0x45
50 } ;
51
52 /*--------------------------------------------------------------------------------------------
53 ** Prototypes for private functions.
54 */
55
56 static sf_count_t host_read_f2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
57 static sf_count_t host_read_f2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
58 static sf_count_t host_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
59 static sf_count_t host_read_f2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
60
61 static sf_count_t host_write_s2f (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
62 static sf_count_t host_write_i2f (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
63 static sf_count_t host_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
64 static sf_count_t host_write_d2f (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
65
66 static void float32_peak_update (SF_PRIVATE *psf, const float *buffer, int count, sf_count_t indx) ;
67
68 static sf_count_t replace_read_f2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
69 static sf_count_t replace_read_f2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
70 static sf_count_t replace_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
71 static sf_count_t replace_read_f2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
72
73 static sf_count_t replace_write_s2f (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
74 static sf_count_t replace_write_i2f (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
75 static sf_count_t replace_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
76 static sf_count_t replace_write_d2f (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
77
78 static void bf2f_array (float *buffer, int count) ;
79 static void f2bf_array (float *buffer, int count) ;
80
81 static int float32_get_capability (SF_PRIVATE *psf) ;
82
83 /*--------------------------------------------------------------------------------------------
84 ** Exported functions.
85 */
86
87 int
88 float32_init (SF_PRIVATE *psf)
89 { static int float_caps ;
90
91 float_caps = float32_get_capability (psf) ;
92
93 psf->blockwidth = sizeof (float) * psf->sf.channels ;
94
95 if (psf->file.mode == SFM_READ || psf->file.mode == SFM_RDWR)
96 { switch (psf->endian + float_caps)
97 { case (SF_ENDIAN_BIG + FLOAT_CAN_RW_BE) :
98 psf->data_endswap = SF_FALSE ;
99 psf->read_short = host_read_f2s ;
100 psf->read_int = host_read_f2i ;
101 psf->read_float = host_read_f ;
102 psf->read_double = host_read_f2d ;
103 break ;
104
105 case (SF_ENDIAN_LITTLE + FLOAT_CAN_RW_LE) :
106 psf->data_endswap = SF_FALSE ;
107 psf->read_short = host_read_f2s ;
108 psf->read_int = host_read_f2i ;
109 psf->read_float = host_read_f ;
110 psf->read_double = host_read_f2d ;
111 break ;
112
113 case (SF_ENDIAN_BIG + FLOAT_CAN_RW_LE) :
114 psf->data_endswap = SF_TRUE ;
115 psf->read_short = host_read_f2s ;
116 psf->read_int = host_read_f2i ;
117 psf->read_float = host_read_f ;
118 psf->read_double = host_read_f2d ;
119 break ;
120
121 case (SF_ENDIAN_LITTLE + FLOAT_CAN_RW_BE) :
122 psf->data_endswap = SF_TRUE ;
123 psf->read_short = host_read_f2s ;
124 psf->read_int = host_read_f2i ;
125 psf->read_float = host_read_f ;
126 psf->read_double = host_read_f2d ;
127 break ;
128
129 /* When the CPU is not IEEE compatible. */
130 case (SF_ENDIAN_BIG + FLOAT_BROKEN_LE) :
131 psf->data_endswap = SF_TRUE ;
132 psf->read_short = replace_read_f2s ;
133 psf->read_int = replace_read_f2i ;
134 psf->read_float = replace_read_f ;
135 psf->read_double = replace_read_f2d ;
136 break ;
137
138 case (SF_ENDIAN_LITTLE + FLOAT_BROKEN_LE) :
139 psf->data_endswap = SF_FALSE ;
140 psf->read_short = replace_read_f2s ;
141 psf->read_int = replace_read_f2i ;
142 psf->read_float = replace_read_f ;
143 psf->read_double = replace_read_f2d ;
144 break ;
145
146 case (SF_ENDIAN_BIG + FLOAT_BROKEN_BE) :
147 psf->data_endswap = SF_FALSE ;
148 psf->read_short = replace_read_f2s ;
149 psf->read_int = replace_read_f2i ;
150 psf->read_float = replace_read_f ;
151 psf->read_double = replace_read_f2d ;
152 break ;
153
154 case (SF_ENDIAN_LITTLE + FLOAT_BROKEN_BE) :
155 psf->data_endswap = SF_TRUE ;
156 psf->read_short = replace_read_f2s ;
157 psf->read_int = replace_read_f2i ;
158 psf->read_float = replace_read_f ;
159 psf->read_double = replace_read_f2d ;
160 break ;
161
162 default : break ;
163 } ;
164 } ;
165
166 if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
167 { switch (psf->endian + float_caps)
168 { case (SF_ENDIAN_LITTLE + FLOAT_CAN_RW_LE) :
169 psf->data_endswap = SF_FALSE ;
170 psf->write_short = host_write_s2f ;
171 psf->write_int = host_write_i2f ;
172 psf->write_float = host_write_f ;
173 psf->write_double = host_write_d2f ;
174 break ;
175
176 case (SF_ENDIAN_BIG + FLOAT_CAN_RW_BE) :
177 psf->data_endswap = SF_FALSE ;
178 psf->write_short = host_write_s2f ;
179 psf->write_int = host_write_i2f ;
180 psf->write_float = host_write_f ;
181 psf->write_double = host_write_d2f ;
182 break ;
183
184 case (SF_ENDIAN_BIG + FLOAT_CAN_RW_LE) :
185 psf->data_endswap = SF_TRUE ;
186 psf->write_short = host_write_s2f ;
187 psf->write_int = host_write_i2f ;
188 psf->write_float = host_write_f ;
189 psf->write_double = host_write_d2f ;
190 break ;
191
192 case (SF_ENDIAN_LITTLE + FLOAT_CAN_RW_BE) :
193 psf->data_endswap = SF_TRUE ;
194 psf->write_short = host_write_s2f ;
195 psf->write_int = host_write_i2f ;
196 psf->write_float = host_write_f ;
197 psf->write_double = host_write_d2f ;
198 break ;
199
200 /* When the CPU is not IEEE compatible. */
201 case (SF_ENDIAN_BIG + FLOAT_BROKEN_LE) :
202 psf->data_endswap = SF_TRUE ;
203 psf->write_short = replace_write_s2f ;
204 psf->write_int = replace_write_i2f ;
205 psf->write_float = replace_write_f ;
206 psf->write_double = replace_write_d2f ;
207 break ;
208
209 case (SF_ENDIAN_LITTLE + FLOAT_BROKEN_LE) :
210 psf->data_endswap = SF_FALSE ;
211 psf->write_short = replace_write_s2f ;
212 psf->write_int = replace_write_i2f ;
213 psf->write_float = replace_write_f ;
214 psf->write_double = replace_write_d2f ;
215 break ;
216
217 case (SF_ENDIAN_BIG + FLOAT_BROKEN_BE) :
218 psf->data_endswap = SF_FALSE ;
219 psf->write_short = replace_write_s2f ;
220 psf->write_int = replace_write_i2f ;
221 psf->write_float = replace_write_f ;
222 psf->write_double = replace_write_d2f ;
223 break ;
224
225 case (SF_ENDIAN_LITTLE + FLOAT_BROKEN_BE) :
226 psf->data_endswap = SF_TRUE ;
227 psf->write_short = replace_write_s2f ;
228 psf->write_int = replace_write_i2f ;
229 psf->write_float = replace_write_f ;
230 psf->write_double = replace_write_d2f ;
231 break ;
232
233 default : break ;
234 } ;
235 } ;
236
237 if (psf->filelength > psf->dataoffset)
238 { psf->datalength = (psf->dataend > 0) ? psf->dataend - psf->dataoffset :
239 psf->filelength - psf->dataoffset ;
240 }
241 else
242 psf->datalength = 0 ;
243
244 psf->sf.frames = psf->blockwidth > 0 ? psf->datalength / psf->blockwidth : 0 ;
245
246 return 0 ;
247 } /* float32_init */
248
249 float
250 float32_be_read (unsigned char *cptr)
251 { int exponent, mantissa, negative ;
252 float fvalue ;
253
254 negative = cptr [0] & 0x80 ;
255 exponent = ((cptr [0] & 0x7F) << 1) | ((cptr [1] & 0x80) ? 1 : 0) ;
256 mantissa = ((cptr [1] & 0x7F) << 16) | (cptr [2] << 8) | (cptr [3]) ;
257
258 if (! (exponent || mantissa))
259 return 0.0 ;
260
261 mantissa |= 0x800000 ;
262 exponent = exponent ? exponent - 127 : 0 ;
263
264 fvalue = mantissa ? ((float) mantissa) / ((float) 0x800000) : 0.0 ;
265
266 if (negative)
267 fvalue *= -1 ;
268
269 if (exponent > 0)
270 fvalue *= pow (2.0, exponent) ;
271 else if (exponent < 0)
272 fvalue /= pow (2.0, abs (exponent)) ;
273
274 return fvalue ;
275 } /* float32_be_read */
276
277 float
278 float32_le_read (unsigned char *cptr)
279 { int exponent, mantissa, negative ;
280 float fvalue ;
281
282 negative = cptr [3] & 0x80 ;
283 exponent = ((cptr [3] & 0x7F) << 1) | ((cptr [2] & 0x80) ? 1 : 0) ;
284 mantissa = ((cptr [2] & 0x7F) << 16) | (cptr [1] << 8) | (cptr [0]) ;
285
286 if (! (exponent || mantissa))
287 return 0.0 ;
288
289 mantissa |= 0x800000 ;
290 exponent = exponent ? exponent - 127 : 0 ;
291
292 fvalue = mantissa ? ((float) mantissa) / ((float) 0x800000) : 0.0 ;
293
294 if (negative)
295 fvalue *= -1 ;
296
297 if (exponent > 0)
298 fvalue *= pow (2.0, exponent) ;
299 else if (exponent < 0)
300 fvalue /= pow (2.0, abs (exponent)) ;
301
302 return fvalue ;
303 } /* float32_le_read */
304
305 void
306 float32_le_write (float in, unsigned char *out)
307 { int exponent, mantissa, negative = 0 ;
308
309 memset (out, 0, sizeof (int)) ;
310
311 if (fabs (in) < 1e-30)
312 return ;
313
314 if (in < 0.0)
315 { in *= -1.0 ;
316 negative = 1 ;
317 } ;
318
319 in = frexp (in, &exponent) ;
320
321 exponent += 126 ;
322
323 in *= (float) 0x1000000 ;
324 mantissa = (((int) in) & 0x7FFFFF) ;
325
326 if (negative)
327 out [3] |= 0x80 ;
328
329 if (exponent & 0x01)
330 out [2] |= 0x80 ;
331
332 out [0] = mantissa & 0xFF ;
333 out [1] = (mantissa >> 8) & 0xFF ;
334 out [2] |= (mantissa >> 16) & 0x7F ;
335 out [3] |= (exponent >> 1) & 0x7F ;
336
337 return ;
338 } /* float32_le_write */
339
340 void
341 float32_be_write (float in, unsigned char *out)
342 { int exponent, mantissa, negative = 0 ;
343
344 memset (out, 0, sizeof (int)) ;
345
346 if (fabs (in) < 1e-30)
347 return ;
348
349 if (in < 0.0)
350 { in *= -1.0 ;
351 negative = 1 ;
352 } ;
353
354 in = frexp (in, &exponent) ;
355
356 exponent += 126 ;
357
358 in *= (float) 0x1000000 ;
359 mantissa = (((int) in) & 0x7FFFFF) ;
360
361 if (negative)
362 out [0] |= 0x80 ;
363
364 if (exponent & 0x01)
365 out [1] |= 0x80 ;
366
367 out [3] = mantissa & 0xFF ;
368 out [2] = (mantissa >> 8) & 0xFF ;
369 out [1] |= (mantissa >> 16) & 0x7F ;
370 out [0] |= (exponent >> 1) & 0x7F ;
371
372 return ;
373 } /* float32_be_write */
374
375 /*==============================================================================================
376 ** Private functions.
377 */
378
379 static void
380 float32_peak_update (SF_PRIVATE *psf, const float *buffer, int count, sf_count_t indx)
381 { int chan ;
382 int k, position ;
383 float fmaxval ;
384
385 for (chan = 0 ; chan < psf->sf.channels ; chan++)
386 { fmaxval = fabs (buffer [chan]) ;
387 position = 0 ;
388 for (k = chan ; k < count ; k += psf->sf.channels)
389 if (fmaxval < fabs (buffer [k]))
390 { fmaxval = fabs (buffer [k]) ;
391 position = k ;
392 } ;
393
394 if (fmaxval > psf->peak_info->peaks [chan].value)
395 { psf->peak_info->peaks [chan].value = fmaxval ;
396 psf->peak_info->peaks [chan].position = psf->write_current + indx + (position / psf->sf.channels) ;
397 } ;
398 } ;
399
400 return ;
401 } /* float32_peak_update */
402
403 static int
404 float32_get_capability (SF_PRIVATE *psf)
405 { union
406 { float f ;
407 int i ;
408 unsigned char c [4] ;
409 } data ;
410
411 data.f = (float) 1.23456789 ; /* Some abitrary value. */
412
413 if (! psf->ieee_replace)
414 { /* If this test is true ints and floats are compatible and little endian. */
415 if (data.c [0] == 0x52 && data.c [1] == 0x06 && data.c [2] == 0x9e && data.c [3] == 0x3f)
416 return FLOAT_CAN_RW_LE ;
417
418 /* If this test is true ints and floats are compatible and big endian. */
419 if (data.c [3] == 0x52 && data.c [2] == 0x06 && data.c [1] == 0x9e && data.c [0] == 0x3f)
420 return FLOAT_CAN_RW_BE ;
421 } ;
422
423 /* Floats are broken. Don't expect reading or writing to be fast. */
424 psf_log_printf (psf, "Using IEEE replacement code for float.\n") ;
425
426 return (CPU_IS_LITTLE_ENDIAN) ? FLOAT_BROKEN_LE : FLOAT_BROKEN_BE ;
427 } /* float32_get_capability */
428
429 /*=======================================================================================
430 */
431
432 static void
433 f2s_array (const float *src, int count, short *dest, float scale)
434 {
435 while (--count >= 0)
436 { dest [count] = lrintf (scale * src [count]) ;
437 } ;
438 } /* f2s_array */
439
440 static void
441 f2s_clip_array (const float *src, int count, short *dest, float scale)
442 { while (--count >= 0)
443 { float tmp = scale * src [count] ;
444
445 if (CPU_CLIPS_POSITIVE == 0 && tmp > 32767.0)
446 dest [count] = SHRT_MAX ;
447 else if (CPU_CLIPS_NEGATIVE == 0 && tmp < -32768.0)
448 dest [count] = SHRT_MIN ;
449 else
450 dest [count] = lrintf (tmp) ;
451 } ;
452 } /* f2s_clip_array */
453
454 static inline void
455 f2i_array (const float *src, int count, int *dest, float scale)
456 { while (--count >= 0)
457 { dest [count] = lrintf (scale * src [count]) ;
458 } ;
459 } /* f2i_array */
460
461 static inline void
462 f2i_clip_array (const float *src, int count, int *dest, float scale)
463 { while (--count >= 0)
464 { float tmp = scale * src [count] ;
465
466 if (CPU_CLIPS_POSITIVE == 0 && tmp > (1.0 * INT_MAX))
467 dest [count] = INT_MAX ;
468 else if (CPU_CLIPS_NEGATIVE == 0 && tmp < (-1.0 * INT_MAX))
469 dest [count] = INT_MIN ;
470 else
471 dest [count] = lrintf (tmp) ;
472 } ;
473 } /* f2i_clip_array */
474
475 static inline void
476 f2d_array (const float *src, int count, double *dest)
477 { while (--count >= 0)
478 { dest [count] = src [count] ;
479 } ;
480 } /* f2d_array */
481
482 static inline void
483 s2f_array (const short *src, float *dest, int count, float scale)
484 { while (--count >= 0)
485 { dest [count] = scale * src [count] ;
486 } ;
487 } /* s2f_array */
488
489 static inline void
490 i2f_array (const int *src, float *dest, int count, float scale)
491 { while (--count >= 0)
492 { dest [count] = scale * src [count] ;
493 } ;
494 } /* i2f_array */
495
496 static inline void
497 d2f_array (const double *src, float *dest, int count)
498 { while (--count >= 0)
499 { dest [count] = src [count] ;
500 } ;
501 } /* d2f_array */
502
503 /*----------------------------------------------------------------------------------------------
504 */
505
506 static sf_count_t
507 host_read_f2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
508 { void (*convert) (const float *, int, short *, float) ;
509 int bufferlen, readcount ;
510 sf_count_t total = 0 ;
511 float scale ;
512
513 convert = (psf->add_clipping) ? f2s_clip_array : f2s_array ;
514 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
515 scale = (psf->float_int_mult == 0) ? 1.0 : 0x7FFF / psf->float_max ;
516
517 while (len > 0)
518 { if (len < bufferlen)
519 bufferlen = (int) len ;
520 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
521
522 /* Fix me : Need lef2s_array */
523 if (psf->data_endswap == SF_TRUE)
524 endswap_int_array (psf->u.ibuf, bufferlen) ;
525
526 convert (psf->u.fbuf, readcount, ptr + total, scale) ;
527 total += readcount ;
528 if (readcount < bufferlen)
529 break ;
530 len -= readcount ;
531 } ;
532
533 return total ;
534 } /* host_read_f2s */
535
536 static sf_count_t
537 host_read_f2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
538 { void (*convert) (const float *, int, int *, float) ;
539 int bufferlen, readcount ;
540 sf_count_t total = 0 ;
541 float scale ;
542
543 convert = (psf->add_clipping) ? f2i_clip_array : f2i_array ;
544 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
545 scale = (psf->float_int_mult == 0) ? 1.0 : 0x7FFFFFFF / psf->float_max ;
546
547 while (len > 0)
548 { if (len < bufferlen)
549 bufferlen = (int) len ;
550 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
551
552 if (psf->data_endswap == SF_TRUE)
553 endswap_int_array (psf->u.ibuf, bufferlen) ;
554
555 convert (psf->u.fbuf, readcount, ptr + total, scale) ;
556 total += readcount ;
557 if (readcount < bufferlen)
558 break ;
559 len -= readcount ;
560 } ;
561
562 return total ;
563 } /* host_read_f2i */
564
565 static sf_count_t
566 host_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
567 { int bufferlen, readcount ;
568 sf_count_t total = 0 ;
569
570 if (psf->data_endswap != SF_TRUE)
571 return psf_fread (ptr, sizeof (float), len, psf) ;
572
573 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
574
575 while (len > 0)
576 { if (len < bufferlen)
577 bufferlen = (int) len ;
578 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
579
580 endswap_int_copy ((int*) (ptr + total), psf->u.ibuf, readcount) ;
581
582 total += readcount ;
583 if (readcount < bufferlen)
584 break ;
585 len -= readcount ;
586 } ;
587
588 return total ;
589 } /* host_read_f */
590
591 static sf_count_t
592 host_read_f2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
593 { int bufferlen, readcount ;
594 sf_count_t total = 0 ;
595
596 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
597
598 while (len > 0)
599 { if (len < bufferlen)
600 bufferlen = (int) len ;
601 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
602
603 if (psf->data_endswap == SF_TRUE)
604 endswap_int_array (psf->u.ibuf, bufferlen) ;
605
606 /* Fix me : Need lef2d_array */
607 f2d_array (psf->u.fbuf, readcount, ptr + total) ;
608 total += readcount ;
609 if (readcount < bufferlen)
610 break ;
611 len -= readcount ;
612 } ;
613
614 return total ;
615 } /* host_read_f2d */
616
617 static sf_count_t
618 host_write_s2f (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
619 { int bufferlen, writecount ;
620 sf_count_t total = 0 ;
621 float scale ;
622
623 /* Erik */
624 scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / 0x8000 ;
625 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
626
627 while (len > 0)
628 { if (len < bufferlen)
629 bufferlen = (int) len ;
630 s2f_array (ptr + total, psf->u.fbuf, bufferlen, scale) ;
631
632 if (psf->peak_info)
633 float32_peak_update (psf, psf->u.fbuf, bufferlen, total / psf->sf.channels) ;
634
635 if (psf->data_endswap == SF_TRUE)
636 endswap_int_array (psf->u.ibuf, bufferlen) ;
637
638 writecount = psf_fwrite (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
639 total += writecount ;
640 if (writecount < bufferlen)
641 break ;
642 len -= writecount ;
643 } ;
644
645 return total ;
646 } /* host_write_s2f */
647
648 static sf_count_t
649 host_write_i2f (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
650 { int bufferlen, writecount ;
651 sf_count_t total = 0 ;
652 float scale ;
653
654 scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / (8.0 * 0x10000000) ;
655 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
656
657 while (len > 0)
658 { if (len < bufferlen)
659 bufferlen = (int) len ;
660 i2f_array (ptr + total, psf->u.fbuf, bufferlen, scale) ;
661
662 if (psf->peak_info)
663 float32_peak_update (psf, psf->u.fbuf, bufferlen, total / psf->sf.channels) ;
664
665 if (psf->data_endswap == SF_TRUE)
666 endswap_int_array (psf->u.ibuf, bufferlen) ;
667
668 writecount = psf_fwrite (psf->u.fbuf, sizeof (float) , bufferlen, psf) ;
669 total += writecount ;
670 if (writecount < bufferlen)
671 break ;
672 len -= writecount ;
673 } ;
674
675 return total ;
676 } /* host_write_i2f */
677
678 static sf_count_t
679 host_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
680 { int bufferlen, writecount ;
681 sf_count_t total = 0 ;
682
683 if (psf->peak_info)
684 float32_peak_update (psf, ptr, len, 0) ;
685
686 if (psf->data_endswap != SF_TRUE)
687 return psf_fwrite (ptr, sizeof (float), len, psf) ;
688
689 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
690
691 while (len > 0)
692 { if (len < bufferlen)
693 bufferlen = (int) len ;
694
695 endswap_int_copy (psf->u.ibuf, (const int*) (ptr + total), bufferlen) ;
696
697 writecount = psf_fwrite (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
698 total += writecount ;
699 if (writecount < bufferlen)
700 break ;
701 len -= writecount ;
702 } ;
703
704 return total ;
705 } /* host_write_f */
706
707 static sf_count_t
708 host_write_d2f (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
709 { int bufferlen, writecount ;
710 sf_count_t total = 0 ;
711
712 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
713
714 while (len > 0)
715 { if (len < bufferlen)
716 bufferlen = (int) len ;
717
718 d2f_array (ptr + total, psf->u.fbuf, bufferlen) ;
719
720 if (psf->peak_info)
721 float32_peak_update (psf, psf->u.fbuf, bufferlen, total / psf->sf.channels) ;
722
723 if (psf->data_endswap == SF_TRUE)
724 endswap_int_array (psf->u.ibuf, bufferlen) ;
725
726 writecount = psf_fwrite (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
727 total += writecount ;
728 if (writecount < bufferlen)
729 break ;
730 len -= writecount ;
731 } ;
732
733 return total ;
734 } /* host_write_d2f */
735
736 /*=======================================================================================
737 */
738
739 static sf_count_t
740 replace_read_f2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
741 { int bufferlen, readcount ;
742 sf_count_t total = 0 ;
743 float scale ;
744
745 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
746 scale = (psf->float_int_mult == 0) ? 1.0 : 0x7FFF / psf->float_max ;
747
748 while (len > 0)
749 { if (len < bufferlen)
750 bufferlen = (int) len ;
751 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
752
753 if (psf->data_endswap == SF_TRUE)
754 endswap_int_array (psf->u.ibuf, bufferlen) ;
755
756 bf2f_array (psf->u.fbuf, bufferlen) ;
757
758 f2s_array (psf->u.fbuf, readcount, ptr + total, scale) ;
759 total += readcount ;
760 if (readcount < bufferlen)
761 break ;
762 len -= readcount ;
763 } ;
764
765 return total ;
766 } /* replace_read_f2s */
767
768 static sf_count_t
769 replace_read_f2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
770 { int bufferlen, readcount ;
771 sf_count_t total = 0 ;
772 float scale ;
773
774 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
775 scale = (psf->float_int_mult == 0) ? 1.0 : 0x7FFF / psf->float_max ;
776
777 while (len > 0)
778 { if (len < bufferlen)
779 bufferlen = (int) len ;
780 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
781
782 if (psf->data_endswap == SF_TRUE)
783 endswap_int_array (psf->u.ibuf, bufferlen) ;
784
785 bf2f_array (psf->u.fbuf, bufferlen) ;
786
787 f2i_array (psf->u.fbuf, readcount, ptr + total, scale) ;
788 total += readcount ;
789 if (readcount < bufferlen)
790 break ;
791 len -= readcount ;
792 } ;
793
794 return total ;
795 } /* replace_read_f2i */
796
797 static sf_count_t
798 replace_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
799 { int bufferlen, readcount ;
800 sf_count_t total = 0 ;
801
802 /* FIX THIS */
803
804 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
805
806 while (len > 0)
807 { if (len < bufferlen)
808 bufferlen = (int) len ;
809 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
810
811 if (psf->data_endswap == SF_TRUE)
812 endswap_int_array (psf->u.ibuf, bufferlen) ;
813
814 bf2f_array (psf->u.fbuf, bufferlen) ;
815
816 memcpy (ptr + total, psf->u.fbuf, bufferlen * sizeof (float)) ;
817
818 total += readcount ;
819 if (readcount < bufferlen)
820 break ;
821 len -= readcount ;
822 } ;
823
824 return total ;
825 } /* replace_read_f */
826
827 static sf_count_t
828 replace_read_f2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
829 { int bufferlen, readcount ;
830 sf_count_t total = 0 ;
831
832 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
833
834 while (len > 0)
835 { if (len < bufferlen)
836 bufferlen = (int) len ;
837 readcount = psf_fread (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
838
839 if (psf->data_endswap == SF_TRUE)
840 endswap_int_array (psf->u.ibuf, bufferlen) ;
841
842 bf2f_array (psf->u.fbuf, bufferlen) ;
843
844 f2d_array (psf->u.fbuf, readcount, ptr + total) ;
845 total += readcount ;
846 if (readcount < bufferlen)
847 break ;
848 len -= readcount ;
849 } ;
850
851 return total ;
852 } /* replace_read_f2d */
853
854 static sf_count_t
855 replace_write_s2f (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
856 { int bufferlen, writecount ;
857 sf_count_t total = 0 ;
858 float scale ;
859
860 scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / 0x8000 ;
861 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
862
863 while (len > 0)
864 { if (len < bufferlen)
865 bufferlen = (int) len ;
866 s2f_array (ptr + total, psf->u.fbuf, bufferlen, scale) ;
867
868 if (psf->peak_info)
869 float32_peak_update (psf, psf->u.fbuf, bufferlen, total / psf->sf.channels) ;
870
871 f2bf_array (psf->u.fbuf, bufferlen) ;
872
873 if (psf->data_endswap == SF_TRUE)
874 endswap_int_array (psf->u.ibuf, bufferlen) ;
875
876 writecount = psf_fwrite (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
877 total += writecount ;
878 if (writecount < bufferlen)
879 break ;
880 len -= writecount ;
881 } ;
882
883 return total ;
884 } /* replace_write_s2f */
885
886 static sf_count_t
887 replace_write_i2f (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
888 { int bufferlen, writecount ;
889 sf_count_t total = 0 ;
890 float scale ;
891
892 scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / (8.0 * 0x10000000) ;
893 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
894
895 while (len > 0)
896 { if (len < bufferlen)
897 bufferlen = (int) len ;
898 i2f_array (ptr + total, psf->u.fbuf, bufferlen, scale) ;
899
900 if (psf->peak_info)
901 float32_peak_update (psf, psf->u.fbuf, bufferlen, total / psf->sf.channels) ;
902
903 f2bf_array (psf->u.fbuf, bufferlen) ;
904
905 if (psf->data_endswap == SF_TRUE)
906 endswap_int_array (psf->u.ibuf, bufferlen) ;
907
908 writecount = psf_fwrite (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
909 total += writecount ;
910 if (writecount < bufferlen)
911 break ;
912 len -= writecount ;
913 } ;
914
915 return total ;
916 } /* replace_write_i2f */
917
918 static sf_count_t
919 replace_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
920 { int bufferlen, writecount ;
921 sf_count_t total = 0 ;
922
923 /* FIX THIS */
924 if (psf->peak_info)
925 float32_peak_update (psf, ptr, len, 0) ;
926
927 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
928
929 while (len > 0)
930 { if (len < bufferlen)
931 bufferlen = (int) len ;
932
933 memcpy (psf->u.fbuf, ptr + total, bufferlen * sizeof (float)) ;
934
935 f2bf_array (psf->u.fbuf, bufferlen) ;
936
937 if (psf->data_endswap == SF_TRUE)
938 endswap_int_array (psf->u.ibuf, bufferlen) ;
939
940 writecount = psf_fwrite (psf->u.fbuf, sizeof (float) , bufferlen, psf) ;
941 total += writecount ;
942 if (writecount < bufferlen)
943 break ;
944 len -= writecount ;
945 } ;
946
947 return total ;
948 } /* replace_write_f */
949
950 static sf_count_t
951 replace_write_d2f (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
952 { int bufferlen, writecount ;
953 sf_count_t total = 0 ;
954
955 bufferlen = ARRAY_LEN (psf->u.fbuf) ;
956
957 while (len > 0)
958 { if (len < bufferlen)
959 bufferlen = (int) len ;
960 d2f_array (ptr + total, psf->u.fbuf, bufferlen) ;
961
962 if (psf->peak_info)
963 float32_peak_update (psf, psf->u.fbuf, bufferlen, total / psf->sf.channels) ;
964
965 f2bf_array (psf->u.fbuf, bufferlen) ;
966
967 if (psf->data_endswap == SF_TRUE)
968 endswap_int_array (psf->u.ibuf, bufferlen) ;
969
970 writecount = psf_fwrite (psf->u.fbuf, sizeof (float), bufferlen, psf) ;
971 total += writecount ;
972 if (writecount < bufferlen)
973 break ;
974 len -= writecount ;
975 } ;
976
977 return total ;
978 } /* replace_write_d2f */
979
980 /*----------------------------------------------------------------------------------------------
981 */
982
983 static void
984 bf2f_array (float *buffer, int count)
985 { while (--count >= 0)
986 { buffer [count] = FLOAT32_READ ((unsigned char *) (buffer + count)) ;
987 } ;
988 } /* bf2f_array */
989
990 static void
991 f2bf_array (float *buffer, int count)
992 { while (--count >= 0)
993 { FLOAT32_WRITE (buffer [count], (unsigned char*) (buffer + count)) ;
994 } ;
995 } /* f2bf_array */
996
An OCaml-based interpreter for Faust and its vector extension