Mercurial > hg > sv-dependency-builds

comparison src/libsndfile-1.0.27/tests/pcm_test.c @ 125:cd6cdf86811e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Current libsndfile source
author Chris Cannam <cannam@all-day-breakfast.com>
date Tue, 18 Oct 2016 13:22:47 +0100
parents
children
comparison
equal deleted inserted replaced
124:e3d5853d5918 125:cd6cdf86811e
1 /*
2 ** Copyright (C) 1999-2013 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 General Public License as published by
6 ** the Free Software Foundation; either version 2 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 General Public License for more details.
13 **
14 ** You should have received a copy of the GNU 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 <math.h>
25 #include <inttypes.h>
26
27 #if HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 #include <sndfile.h>
32
33 #include "utils.h"
34
35 #define BUFFER_SIZE (1 << 12)
36
37 static void lrintf_test (void) ;
38
39 static void pcm_test_bits_8 (const char *filename, int filetype, uint64_t hash) ;
40 static void pcm_test_bits_16 (const char *filename, int filetype, uint64_t hash) ;
41 static void pcm_test_bits_24 (const char *filename, int filetype, uint64_t hash) ;
42 static void pcm_test_bits_32 (const char *filename, int filetype, uint64_t hash) ;
43
44 static void pcm_test_float (const char *filename, int filetype, uint64_t hash, int replace_float) ;
45 static void pcm_test_double (const char *filename, int filetype, uint64_t hash, int replace_float) ;
46
47 typedef union
48 { double d [BUFFER_SIZE + 1] ;
49 float f [BUFFER_SIZE + 1] ;
50 int i [BUFFER_SIZE + 1] ;
51 short s [BUFFER_SIZE + 1] ;
52 } BUFFER ;
53
54 /* Data written to the file. */
55 static BUFFER data_out ;
56
57 /* Data read back from the file. */
58 static BUFFER data_in ;
59
60 int
61 main (void)
62 {
63 lrintf_test () ;
64
65 pcm_test_bits_8 ("pcm-s8.raw", SF_FORMAT_RAW | SF_FORMAT_PCM_S8, 0xa335091249dbfLL) ;
66 pcm_test_bits_8 ("pcm-u8.raw", SF_FORMAT_RAW | SF_FORMAT_PCM_U8, 0x48c433d695f3fLL) ;
67
68 pcm_test_bits_16 ("le-pcm16.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_16, 0xb956c881ebf08LL) ;
69 pcm_test_bits_16 ("be-pcm16.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_16, 0x2f840c55750f8LL) ;
70
71 pcm_test_bits_24 ("le-pcm24.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_24, 0xb6a759ab496f8LL) ;
72 pcm_test_bits_24 ("be-pcm24.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_24, 0xf3eaf9c30b6f8LL) ;
73
74 pcm_test_bits_32 ("le-pcm32.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_32, 0xaece1c1c17f08LL) ;
75 pcm_test_bits_32 ("be-pcm32.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_32, 0x9ddf142d0b0f8LL) ;
76
77 /* Lite remove start */
78 pcm_test_float ("le-float.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_FLOAT, 0xad04f7554267aLL, SF_FALSE) ;
79 pcm_test_float ("be-float.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_FLOAT, 0xde3e248fa9186LL, SF_FALSE) ;
80
81 pcm_test_double ("le-double.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, 0x2726f958f669cLL, SF_FALSE) ;
82 pcm_test_double ("be-double.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, 0x3583f8ee51164LL, SF_FALSE) ;
83
84 pcm_test_float ("le-float.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_FLOAT, 0xad04f7554267aLL, SF_TRUE) ;
85 pcm_test_float ("be-float.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_FLOAT, 0xde3e248fa9186LL, SF_TRUE) ;
86
87 pcm_test_double ("le-double.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, 0x2726f958f669cLL, SF_TRUE) ;
88 pcm_test_double ("be-double.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, 0x3583f8ee51164LL, SF_TRUE) ;
89 /* Lite remove end */
90
91 return 0 ;
92 } /* main */
93
94 /*============================================================================================
95 ** Here are the test functions.
96 */
97
98 static void
99 lrintf_test (void)
100 { int k, items ;
101 float *float_data ;
102 int *int_data ;
103
104 print_test_name ("lrintf_test", "") ;
105
106 items = 1024 ;
107
108 float_data = data_out.f ;
109 int_data = data_in.i ;
110
111 for (k = 0 ; k < items ; k++)
112 float_data [k] = (k * ((k % 2) ? 333333.0 : -333333.0)) ;
113
114 for (k = 0 ; k < items ; k++)
115 int_data [k] = lrintf (float_data [k]) ;
116
117 for (k = 0 ; k < items ; k++)
118 if (fabs (int_data [k] - float_data [k]) > 1.0)
119 { printf ("\n\nLine %d: float : Incorrect sample (#%d : %f => %d).\n", __LINE__, k, float_data [k], int_data [k]) ;
120 exit (1) ;
121 } ;
122
123 printf ("ok\n") ;
124 } /* lrintf_test */
125
126 static void
127 pcm_test_bits_8 (const char *filename, int filetype, uint64_t hash)
128 { SNDFILE *file ;
129 SF_INFO sfinfo ;
130 int k, items, zero_count ;
131 short *short_out, *short_in ;
132 int *int_out, *int_in ;
133 /* Lite remove start */
134 float *float_out, *float_in ;
135 double *double_out, *double_in ;
136 /* Lite remove end */
137
138 print_test_name ("pcm_test_bits_8", filename) ;
139
140 items = 127 ;
141
142 short_out = data_out.s ;
143 short_in = data_in.s ;
144
145 zero_count = 0 ;
146 for (k = 0 ; k < items ; k++)
147 { short_out [k] = arith_shift_left (k * ((k % 2) ? 1 : -1), 8) ;
148 zero_count = short_out [k] ? zero_count : zero_count + 1 ;
149 } ;
150
151 if (zero_count > items / 4)
152 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
153 exit (1) ;
154 } ;
155
156 sfinfo.samplerate = 44100 ;
157 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
158 sfinfo.channels = 1 ;
159 sfinfo.format = filetype ;
160
161 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
162
163 test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
164
165 sf_close (file) ;
166
167 memset (short_in, 0, items * sizeof (short)) ;
168
169 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
170
171 if (sfinfo.format != filetype)
172 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
173 exit (1) ;
174 } ;
175
176 if (sfinfo.frames != items)
177 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
178 exit (1) ;
179 } ;
180
181 if (sfinfo.channels != 1)
182 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
183 exit (1) ;
184 } ;
185
186 check_log_buffer_or_die (file, __LINE__) ;
187
188 test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
189
190 for (k = 0 ; k < items ; k++)
191 if (short_out [k] != short_in [k])
192 { printf ("\n\nLine %d: Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, short_out [k], short_in [k]) ;
193 exit (1) ;
194 } ;
195
196 sf_close (file) ;
197
198 /* Finally, check the file hash. */
199 check_file_hash_or_die (filename, hash, __LINE__) ;
200
201 /*--------------------------------------------------------------------------
202 ** Test sf_read/write_int ()
203 */
204 zero_count = 0 ;
205
206 int_out = data_out.i ;
207 int_in = data_in.i ;
208 for (k = 0 ; k < items ; k++)
209 { int_out [k] = arith_shift_left (k * ((k % 2) ? 1 : -1), 24) ;
210 zero_count = int_out [k] ? zero_count : zero_count + 1 ;
211 } ;
212
213 if (zero_count > items / 4)
214 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
215 exit (1) ;
216 } ;
217
218 sfinfo.samplerate = 44100 ;
219 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
220 sfinfo.channels = 1 ;
221 sfinfo.format = filetype ;
222
223 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
224
225 test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
226
227 sf_close (file) ;
228
229 memset (int_in, 0, items * sizeof (int)) ;
230
231 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
232
233 if (sfinfo.format != filetype)
234 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
235 exit (1) ;
236 } ;
237
238 if (sfinfo.frames != items)
239 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
240 exit (1) ;
241 } ;
242
243 if (sfinfo.channels != 1)
244 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
245 exit (1) ;
246 } ;
247
248 check_log_buffer_or_die (file, __LINE__) ;
249
250 test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
251
252 for (k = 0 ; k < items ; k++)
253 if (int_out [k] != int_in [k])
254 { printf ("\n\nLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, int_out [k], int_in [k]) ;
255 exit (1) ;
256 } ;
257
258 sf_close (file) ;
259
260 /* Lite remove start */
261 /*--------------------------------------------------------------------------
262 ** Test sf_read/write_float ()
263 */
264 zero_count = 0 ;
265
266 float_out = data_out.f ;
267 float_in = data_in.f ;
268 for (k = 0 ; k < items ; k++)
269 { float_out [k] = (k * ((k % 2) ? 1 : -1)) ;
270 zero_count = (fabs (float_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
271 } ;
272
273 if (zero_count > items / 4)
274 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
275 exit (1) ;
276 } ;
277
278 sfinfo.samplerate = 44100 ;
279 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
280 sfinfo.channels = 1 ;
281 sfinfo.format = filetype ;
282
283 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
284
285 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
286
287 test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
288
289 sf_close (file) ;
290
291 memset (float_in, 0, items * sizeof (float)) ;
292
293 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
294
295 if (sfinfo.format != filetype)
296 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
297 exit (1) ;
298 } ;
299
300 if (sfinfo.frames != items)
301 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
302 exit (1) ;
303 } ;
304
305 if (sfinfo.channels != 1)
306 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
307 exit (1) ;
308 } ;
309
310 check_log_buffer_or_die (file, __LINE__) ;
311
312 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
313
314 test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
315
316 for (k = 0 ; k < items ; k++)
317 if (fabs (float_out [k] - float_in [k]) > 1e-10)
318 { printf ("\n\nLine %d: float : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
319 exit (1) ;
320 } ;
321
322 sf_close (file) ;
323
324 /*--------------------------------------------------------------------------
325 ** Test sf_read/write_double ()
326 */
327 zero_count = 0 ;
328
329 double_out = data_out.d ;
330 double_in = data_in.d ;
331 for (k = 0 ; k < items ; k++)
332 { double_out [k] = (k * ((k % 2) ? 1 : -1)) ;
333 zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
334 } ;
335
336 if (zero_count > items / 4)
337 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
338 exit (1) ;
339 } ;
340
341 sfinfo.samplerate = 44100 ;
342 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
343 sfinfo.channels = 1 ;
344 sfinfo.format = filetype ;
345
346 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
347
348 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
349
350 test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
351
352 sf_close (file) ;
353
354 memset (double_in, 0, items * sizeof (double)) ;
355
356 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
357
358 if (sfinfo.format != filetype)
359 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
360 exit (1) ;
361 } ;
362
363 if (sfinfo.frames != items)
364 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
365 exit (1) ;
366 } ;
367
368 if (sfinfo.channels != 1)
369 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
370 exit (1) ;
371 } ;
372
373 check_log_buffer_or_die (file, __LINE__) ;
374
375 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
376
377 test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
378
379 for (k = 0 ; k < items ; k++)
380 if (fabs (double_out [k] - double_in [k]) > 1e-10)
381 { printf ("\n\nLine %d: double : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, double_out [k], double_in [k]) ;
382 exit (1) ;
383 } ;
384
385 sf_close (file) ;
386 /* Lite remove end */
387 unlink (filename) ;
388
389 puts ("ok") ;
390 } /* pcm_test_bits_8 */
391
392 static void
393 pcm_test_bits_16 (const char *filename, int filetype, uint64_t hash)
394 { SNDFILE *file ;
395 SF_INFO sfinfo ;
396 int k, items, zero_count ;
397 short *short_out, *short_in ;
398 int *int_out, *int_in ;
399 /* Lite remove start */
400 float *float_out, *float_in ;
401 double *double_out, *double_in ;
402 /* Lite remove end */
403
404 print_test_name ("pcm_test_bits_16", filename) ;
405
406 items = 1024 ;
407
408 short_out = data_out.s ;
409 short_in = data_in.s ;
410
411 zero_count = 0 ;
412 for (k = 0 ; k < items ; k++)
413 { short_out [k] = (k * ((k % 2) ? 3 : -3)) ;
414 zero_count = short_out [k] ? zero_count : zero_count + 1 ;
415 } ;
416
417 if (zero_count > items / 4)
418 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
419 exit (1) ;
420 } ;
421
422 sfinfo.samplerate = 44100 ;
423 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
424 sfinfo.channels = 1 ;
425 sfinfo.format = filetype ;
426
427 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
428
429 test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
430
431 sf_close (file) ;
432
433 memset (short_in, 0, items * sizeof (short)) ;
434
435 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
436
437 if (sfinfo.format != filetype)
438 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
439 exit (1) ;
440 } ;
441
442 if (sfinfo.frames != items)
443 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
444 exit (1) ;
445 } ;
446
447 if (sfinfo.channels != 1)
448 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
449 exit (1) ;
450 } ;
451
452 check_log_buffer_or_die (file, __LINE__) ;
453
454 test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
455
456 for (k = 0 ; k < items ; k++)
457 if (short_out [k] != short_in [k])
458 { printf ("\n\nLine %d: Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, short_out [k], short_in [k]) ;
459 exit (1) ;
460 } ;
461
462 sf_close (file) ;
463
464 /* Finally, check the file hash. */
465 check_file_hash_or_die (filename, hash, __LINE__) ;
466
467 /*--------------------------------------------------------------------------
468 ** Test sf_read/write_int ()
469 */
470 zero_count = 0 ;
471
472 int_out = data_out.i ;
473 int_in = data_in.i ;
474 for (k = 0 ; k < items ; k++)
475 { int_out [k] = arith_shift_left (k * ((k % 2) ? 3 : -3), 16) ;
476 zero_count = int_out [k] ? zero_count : zero_count + 1 ;
477 } ;
478
479 if (zero_count > items / 4)
480 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
481 exit (1) ;
482 } ;
483
484 sfinfo.samplerate = 44100 ;
485 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
486 sfinfo.channels = 1 ;
487 sfinfo.format = filetype ;
488
489 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
490
491 test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
492
493 sf_close (file) ;
494
495 memset (int_in, 0, items * sizeof (int)) ;
496
497 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
498
499 if (sfinfo.format != filetype)
500 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
501 exit (1) ;
502 } ;
503
504 if (sfinfo.frames != items)
505 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
506 exit (1) ;
507 } ;
508
509 if (sfinfo.channels != 1)
510 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
511 exit (1) ;
512 } ;
513
514 check_log_buffer_or_die (file, __LINE__) ;
515
516 test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
517
518 for (k = 0 ; k < items ; k++)
519 if (int_out [k] != int_in [k])
520 { printf ("\n\nLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, int_out [k], int_in [k]) ;
521 exit (1) ;
522 } ;
523
524 sf_close (file) ;
525
526 /* Lite remove start */
527 /*--------------------------------------------------------------------------
528 ** Test sf_read/write_float ()
529 */
530 zero_count = 0 ;
531
532 float_out = data_out.f ;
533 float_in = data_in.f ;
534 for (k = 0 ; k < items ; k++)
535 { float_out [k] = (k * ((k % 2) ? 3 : -3)) ;
536 zero_count = (fabs (float_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
537 } ;
538
539 if (zero_count > items / 4)
540 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
541 exit (1) ;
542 } ;
543
544 sfinfo.samplerate = 44100 ;
545 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
546 sfinfo.channels = 1 ;
547 sfinfo.format = filetype ;
548
549 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
550
551 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
552
553 test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
554
555 sf_close (file) ;
556
557 memset (float_in, 0, items * sizeof (float)) ;
558
559 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
560
561 if (sfinfo.format != filetype)
562 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
563 exit (1) ;
564 } ;
565
566 if (sfinfo.frames != items)
567 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
568 exit (1) ;
569 } ;
570
571 if (sfinfo.channels != 1)
572 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
573 exit (1) ;
574 } ;
575
576 check_log_buffer_or_die (file, __LINE__) ;
577
578 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
579
580 test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
581
582 for (k = 0 ; k < items ; k++)
583 if (fabs (float_out [k] - float_in [k]) > 1e-10)
584 { printf ("\n\nLine %d: float : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
585 exit (1) ;
586 } ;
587
588 sf_close (file) ;
589
590 /*--------------------------------------------------------------------------
591 ** Test sf_read/write_double ()
592 */
593 zero_count = 0 ;
594
595 double_out = data_out.d ;
596 double_in = data_in.d ;
597 for (k = 0 ; k < items ; k++)
598 { double_out [k] = (k * ((k % 2) ? 3 : -3)) ;
599 zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
600 } ;
601
602 if (zero_count > items / 4)
603 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
604 exit (1) ;
605 } ;
606
607 sfinfo.samplerate = 44100 ;
608 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
609 sfinfo.channels = 1 ;
610 sfinfo.format = filetype ;
611
612 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
613
614 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
615
616 test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
617
618 sf_close (file) ;
619
620 memset (double_in, 0, items * sizeof (double)) ;
621
622 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
623
624 if (sfinfo.format != filetype)
625 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
626 exit (1) ;
627 } ;
628
629 if (sfinfo.frames != items)
630 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
631 exit (1) ;
632 } ;
633
634 if (sfinfo.channels != 1)
635 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
636 exit (1) ;
637 } ;
638
639 check_log_buffer_or_die (file, __LINE__) ;
640
641 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
642
643 test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
644
645 for (k = 0 ; k < items ; k++)
646 if (fabs (double_out [k] - double_in [k]) > 1e-10)
647 { printf ("\n\nLine %d: double : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, double_out [k], double_in [k]) ;
648 exit (1) ;
649 } ;
650
651 sf_close (file) ;
652 /* Lite remove end */
653 unlink (filename) ;
654
655 puts ("ok") ;
656 } /* pcm_test_bits_16 */
657
658 static void
659 pcm_test_bits_24 (const char *filename, int filetype, uint64_t hash)
660 { SNDFILE *file ;
661 SF_INFO sfinfo ;
662 int k, items, zero_count ;
663 short *short_out, *short_in ;
664 int *int_out, *int_in ;
665 /* Lite remove start */
666 float *float_out, *float_in ;
667 double *double_out, *double_in ;
668 /* Lite remove end */
669
670 print_test_name ("pcm_test_bits_24", filename) ;
671
672 items = 1024 ;
673
674 short_out = data_out.s ;
675 short_in = data_in.s ;
676
677 zero_count = 0 ;
678 for (k = 0 ; k < items ; k++)
679 { short_out [k] = (k * ((k % 2) ? 3 : -3)) ;
680 zero_count = short_out [k] ? zero_count : zero_count + 1 ;
681 } ;
682
683 if (zero_count > items / 4)
684 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
685 exit (1) ;
686 } ;
687
688 sfinfo.samplerate = 44100 ;
689 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
690 sfinfo.channels = 1 ;
691 sfinfo.format = filetype ;
692
693 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
694
695 test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
696
697 sf_close (file) ;
698
699 memset (short_in, 0, items * sizeof (short)) ;
700
701 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
702
703 if (sfinfo.format != filetype)
704 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
705 exit (1) ;
706 } ;
707
708 if (sfinfo.frames != items)
709 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
710 exit (1) ;
711 } ;
712
713 if (sfinfo.channels != 1)
714 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
715 exit (1) ;
716 } ;
717
718 check_log_buffer_or_die (file, __LINE__) ;
719
720 test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
721
722 for (k = 0 ; k < items ; k++)
723 if (short_out [k] != short_in [k])
724 { printf ("\n\nLine %d: Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, short_out [k], short_in [k]) ;
725 exit (1) ;
726 } ;
727
728 sf_close (file) ;
729
730 /* Finally, check the file hash. */
731 check_file_hash_or_die (filename, hash, __LINE__) ;
732
733 /*--------------------------------------------------------------------------
734 ** Test sf_read/write_int ()
735 */
736 zero_count = 0 ;
737
738 int_out = data_out.i ;
739 int_in = data_in.i ;
740 for (k = 0 ; k < items ; k++)
741 { int_out [k] = arith_shift_left (k * ((k % 2) ? 3333 : -3333), 8) ;
742 zero_count = int_out [k] ? zero_count : zero_count + 1 ;
743 } ;
744
745 if (zero_count > items / 4)
746 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
747 exit (1) ;
748 } ;
749
750 sfinfo.samplerate = 44100 ;
751 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
752 sfinfo.channels = 1 ;
753 sfinfo.format = filetype ;
754
755 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
756
757 test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
758
759 sf_close (file) ;
760
761 memset (int_in, 0, items * sizeof (int)) ;
762
763 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
764
765 if (sfinfo.format != filetype)
766 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
767 exit (1) ;
768 } ;
769
770 if (sfinfo.frames != items)
771 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
772 exit (1) ;
773 } ;
774
775 if (sfinfo.channels != 1)
776 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
777 exit (1) ;
778 } ;
779
780 check_log_buffer_or_die (file, __LINE__) ;
781
782 test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
783
784 for (k = 0 ; k < items ; k++)
785 if (int_out [k] != int_in [k])
786 { printf ("\n\nLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, int_out [k], int_in [k]) ;
787 exit (1) ;
788 } ;
789
790 sf_close (file) ;
791
792 /* Lite remove start */
793 /*--------------------------------------------------------------------------
794 ** Test sf_read/write_float ()
795 */
796 zero_count = 0 ;
797
798 float_out = data_out.f ;
799 float_in = data_in.f ;
800 for (k = 0 ; k < items ; k++)
801 { float_out [k] = (k * ((k % 2) ? 3333 : -3333)) ;
802 zero_count = (fabs (float_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
803 } ;
804
805 if (zero_count > items / 4)
806 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
807 exit (1) ;
808 } ;
809
810 sfinfo.samplerate = 44100 ;
811 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
812 sfinfo.channels = 1 ;
813 sfinfo.format = filetype ;
814
815 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
816
817 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
818
819 test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
820
821 sf_close (file) ;
822
823 memset (float_in, 0, items * sizeof (float)) ;
824
825 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
826
827 if (sfinfo.format != filetype)
828 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
829 exit (1) ;
830 } ;
831
832 if (sfinfo.frames != items)
833 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
834 exit (1) ;
835 } ;
836
837 if (sfinfo.channels != 1)
838 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
839 exit (1) ;
840 } ;
841
842 check_log_buffer_or_die (file, __LINE__) ;
843
844 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
845
846 test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
847
848 for (k = 0 ; k < items ; k++)
849 if (fabs (float_out [k] - float_in [k]) > 1e-10)
850 { printf ("\n\nLine %d: float : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
851 exit (1) ;
852 } ;
853
854 sf_close (file) ;
855
856 /*--------------------------------------------------------------------------
857 ** Test sf_read/write_double ()
858 */
859 zero_count = 0 ;
860
861 double_out = data_out.d ;
862 double_in = data_in.d ;
863 for (k = 0 ; k < items ; k++)
864 { double_out [k] = (k * ((k % 2) ? 3333 : -3333)) ;
865 zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
866 } ;
867
868 if (zero_count > items / 4)
869 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
870 exit (1) ;
871 } ;
872
873 sfinfo.samplerate = 44100 ;
874 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
875 sfinfo.channels = 1 ;
876 sfinfo.format = filetype ;
877
878 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
879
880 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
881
882 test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
883
884 sf_close (file) ;
885
886 memset (double_in, 0, items * sizeof (double)) ;
887
888 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
889
890 if (sfinfo.format != filetype)
891 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
892 exit (1) ;
893 } ;
894
895 if (sfinfo.frames != items)
896 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
897 exit (1) ;
898 } ;
899
900 if (sfinfo.channels != 1)
901 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
902 exit (1) ;
903 } ;
904
905 check_log_buffer_or_die (file, __LINE__) ;
906
907 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
908
909 test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
910
911 for (k = 0 ; k < items ; k++)
912 if (fabs (double_out [k] - double_in [k]) > 1e-10)
913 { printf ("\n\nLine %d: double : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, double_out [k], double_in [k]) ;
914 exit (1) ;
915 } ;
916
917 sf_close (file) ;
918 /* Lite remove end */
919 unlink (filename) ;
920
921 puts ("ok") ;
922 } /* pcm_test_bits_24 */
923
924 static void
925 pcm_test_bits_32 (const char *filename, int filetype, uint64_t hash)
926 { SNDFILE *file ;
927 SF_INFO sfinfo ;
928 int k, items, zero_count ;
929 short *short_out, *short_in ;
930 int *int_out, *int_in ;
931 /* Lite remove start */
932 float *float_out, *float_in ;
933 double *double_out, *double_in ;
934 /* Lite remove end */
935
936 print_test_name ("pcm_test_bits_32", filename) ;
937
938 items = 1024 ;
939
940 short_out = data_out.s ;
941 short_in = data_in.s ;
942
943 zero_count = 0 ;
944 for (k = 0 ; k < items ; k++)
945 { short_out [k] = (k * ((k % 2) ? 3 : -3)) ;
946 zero_count = short_out [k] ? zero_count : zero_count + 1 ;
947 } ;
948
949 if (zero_count > items / 4)
950 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
951 exit (1) ;
952 } ;
953
954 sfinfo.samplerate = 44100 ;
955 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
956 sfinfo.channels = 1 ;
957 sfinfo.format = filetype ;
958
959 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
960
961 test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
962
963 sf_close (file) ;
964
965 memset (short_in, 0, items * sizeof (short)) ;
966
967 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
968
969 if (sfinfo.format != filetype)
970 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
971 exit (1) ;
972 } ;
973
974 if (sfinfo.frames != items)
975 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
976 exit (1) ;
977 } ;
978
979 if (sfinfo.channels != 1)
980 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
981 exit (1) ;
982 } ;
983
984 check_log_buffer_or_die (file, __LINE__) ;
985
986 test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
987
988 for (k = 0 ; k < items ; k++)
989 if (short_out [k] != short_in [k])
990 { printf ("\n\nLine %d: Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, short_out [k], short_in [k]) ;
991 exit (1) ;
992 } ;
993
994 sf_close (file) ;
995
996 /* Finally, check the file hash. */
997 check_file_hash_or_die (filename, hash, __LINE__) ;
998
999 /*--------------------------------------------------------------------------
1000 ** Test sf_read/write_int ()
1001 */
1002 zero_count = 0 ;
1003
1004 int_out = data_out.i ;
1005 int_in = data_in.i ;
1006 for (k = 0 ; k < items ; k++)
1007 { int_out [k] = (k * ((k % 2) ? 333333 : -333333)) ;
1008 zero_count = int_out [k] ? zero_count : zero_count + 1 ;
1009 } ;
1010
1011 if (zero_count > items / 4)
1012 { printf ("\n\nLine %d: too many zeros.\n", __LINE__) ;
1013 exit (1) ;
1014 } ;
1015
1016 sfinfo.samplerate = 44100 ;
1017 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
1018 sfinfo.channels = 1 ;
1019 sfinfo.format = filetype ;
1020
1021 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1022
1023 test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
1024
1025 sf_close (file) ;
1026
1027 memset (int_in, 0, items * sizeof (int)) ;
1028
1029 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1030
1031 if (sfinfo.format != filetype)
1032 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
1033 exit (1) ;
1034 } ;
1035
1036 if (sfinfo.frames != items)
1037 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
1038 exit (1) ;
1039 } ;
1040
1041 if (sfinfo.channels != 1)
1042 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
1043 exit (1) ;
1044 } ;
1045
1046 check_log_buffer_or_die (file, __LINE__) ;
1047
1048 test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
1049
1050 for (k = 0 ; k < items ; k++)
1051 if (int_out [k] != int_in [k])
1052 { printf ("\n\nLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, int_out [k], int_in [k]) ;
1053 exit (1) ;
1054 } ;
1055
1056 sf_close (file) ;
1057
1058 /* Lite remove start */
1059 /*--------------------------------------------------------------------------
1060 ** Test sf_read/write_float ()
1061 */
1062 zero_count = 0 ;
1063
1064 float_out = data_out.f ;
1065 float_in = data_in.f ;
1066 for (k = 0 ; k < items ; k++)
1067 { float_out [k] = (k * ((k % 2) ? 333333 : -333333)) ;
1068 zero_count = (fabs (float_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
1069 } ;
1070
1071 if (zero_count > items / 4)
1072 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
1073 exit (1) ;
1074 } ;
1075
1076 sfinfo.samplerate = 44100 ;
1077 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
1078 sfinfo.channels = 1 ;
1079 sfinfo.format = filetype ;
1080
1081 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1082
1083 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1084
1085 test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
1086
1087 sf_close (file) ;
1088
1089 memset (float_in, 0, items * sizeof (float)) ;
1090
1091 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1092
1093 if (sfinfo.format != filetype)
1094 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
1095 exit (1) ;
1096 } ;
1097
1098 if (sfinfo.frames != items)
1099 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
1100 exit (1) ;
1101 } ;
1102
1103 if (sfinfo.channels != 1)
1104 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
1105 exit (1) ;
1106 } ;
1107
1108 check_log_buffer_or_die (file, __LINE__) ;
1109
1110 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1111
1112 test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
1113
1114 for (k = 0 ; k < items ; k++)
1115 if (fabs (float_out [k] - float_in [k]) > 1e-10)
1116 { printf ("\n\nLine %d: float : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
1117 exit (1) ;
1118 } ;
1119
1120 sf_close (file) ;
1121
1122 /*--------------------------------------------------------------------------
1123 ** Test sf_read/write_double ()
1124 */
1125 zero_count = 0 ;
1126
1127 double_out = data_out.d ;
1128 double_in = data_in.d ;
1129 for (k = 0 ; k < items ; k++)
1130 { double_out [k] = (k * ((k % 2) ? 333333 : -333333)) ;
1131 zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
1132 } ;
1133
1134 if (zero_count > items / 4)
1135 { printf ("\n\nLine %d: too many zeros (%d/%d).\n", __LINE__, zero_count, items) ;
1136 exit (1) ;
1137 } ;
1138
1139 sfinfo.samplerate = 44100 ;
1140 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
1141 sfinfo.channels = 1 ;
1142 sfinfo.format = filetype ;
1143
1144 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1145
1146 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
1147
1148 test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
1149
1150 sf_close (file) ;
1151
1152 memset (double_in, 0, items * sizeof (double)) ;
1153
1154 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1155
1156 if (sfinfo.format != filetype)
1157 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
1158 exit (1) ;
1159 } ;
1160
1161 if (sfinfo.frames != items)
1162 { printf ("\n\nLine %d: Incorrect number of frames in file. (%d => %" PRId64 ")\n", __LINE__, items, sfinfo.frames) ;
1163 exit (1) ;
1164 } ;
1165
1166 if (sfinfo.channels != 1)
1167 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
1168 exit (1) ;
1169 } ;
1170
1171 check_log_buffer_or_die (file, __LINE__) ;
1172
1173 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
1174
1175 test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
1176
1177 for (k = 0 ; k < items ; k++)
1178 if (fabs (double_out [k] - double_in [k]) > 1e-10)
1179 { printf ("\n\nLine %d: double : Incorrect sample (#%d : %f => %f).\n", __LINE__, k, double_out [k], double_in [k]) ;
1180 exit (1) ;
1181 } ;
1182
1183 sf_close (file) ;
1184 /* Lite remove end */
1185 unlink (filename) ;
1186
1187 puts ("ok") ;
1188 } /* pcm_test_bits_32 */
1189
1190
1191
1192 /*==============================================================================
1193 */
1194
1195 static void
1196 pcm_test_float (const char *filename, int filetype, uint64_t hash, int replace_float)
1197 { SNDFILE *file ;
1198 SF_INFO sfinfo ;
1199 int k, items, frames ;
1200 int sign ;
1201 double *data, error ;
1202
1203 print_test_name (replace_float ? "pcm_test_float (replace)" : "pcm_test_float", filename) ;
1204
1205 items = BUFFER_SIZE ;
1206
1207 data = data_out.d ;
1208 for (sign = 1, k = 0 ; k < items ; k++)
1209 { data [k] = ((double) (k * sign)) / 100.0 ;
1210 sign = (sign > 0) ? -1 : 1 ;
1211 } ;
1212
1213 sfinfo.samplerate = 44100 ;
1214 sfinfo.frames = items ;
1215 sfinfo.channels = 1 ;
1216 sfinfo.format = filetype ;
1217
1218 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1219 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1220 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1221 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1222 dump_log_buffer (file) ;
1223 exit (1) ;
1224 } ;
1225
1226 test_write_double_or_die (file, 0, data, items, __LINE__) ;
1227
1228 sf_close (file) ;
1229
1230 check_file_hash_or_die (filename, hash, __LINE__) ;
1231
1232 memset (data, 0, items * sizeof (double)) ;
1233
1234 if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1235 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1236
1237 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1238 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1239 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1240 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1241 dump_log_buffer (file) ;
1242 exit (1) ;
1243 } ;
1244
1245 if (sfinfo.format != filetype)
1246 { printf ("\n\nError (%s:%d) Mono : Returned format incorrect (0x%08X => 0x%08X).\n", __FILE__, __LINE__, filetype, sfinfo.format) ;
1247 exit (1) ;
1248 } ;
1249
1250 if (sfinfo.frames != items)
1251 { printf ("\n\nError (%s:%d) Mono : Incorrect number of frames in file. (%d => %" PRId64 ")\n", __FILE__, __LINE__, items, sfinfo.frames) ;
1252 exit (1) ;
1253 } ;
1254
1255 if (sfinfo.channels != 1)
1256 { printf ("\n\nError (%s:%d) Mono : Incorrect number of channels in file.\n", __FILE__, __LINE__) ;
1257 exit (1) ;
1258 } ;
1259
1260 check_log_buffer_or_die (file, __LINE__) ;
1261
1262 test_read_double_or_die (file, 0, data, items, __LINE__) ;
1263
1264 for (sign = -1, k = 0 ; k < items ; k++)
1265 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1266 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1267 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1268 exit (1) ;
1269 } ;
1270 } ;
1271
1272 /* Seek to end of file. */
1273 test_seek_or_die (file, 0, SEEK_END, sfinfo.frames, sfinfo.channels, __LINE__) ;
1274
1275 /* Seek to start of file. */
1276 test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
1277
1278 test_read_double_or_die (file, 0, data, 4, __LINE__) ;
1279 for (k = 0 ; k < 4 ; k++)
1280 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1281 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1282 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1283 exit (1) ;
1284 } ;
1285 } ;
1286
1287 /* Seek to offset from start of file. */
1288 test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
1289
1290 test_read_double_or_die (file, 0, data + 10, 4, __LINE__) ;
1291 for (k = 10 ; k < 14 ; k++)
1292 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1293 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1294 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1295 exit (1) ;
1296 } ;
1297 } ;
1298
1299 /* Seek to offset from current position. */
1300 test_seek_or_die (file, 6, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
1301
1302 test_read_double_or_die (file, 0, data + 20, 4, __LINE__) ;
1303 for (k = 20 ; k < 24 ; k++)
1304 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1305 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1306 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1307 exit (1) ;
1308 } ;
1309 } ;
1310
1311 /* Seek to offset from end of file. */
1312 test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
1313
1314 test_read_double_or_die (file, 0, data + 10, 4, __LINE__) ;
1315 for (k = 10 ; k < 14 ; k++)
1316 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1317 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1318 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1319 exit (1) ;
1320 } ;
1321 } ;
1322
1323 sf_close (file) ;
1324
1325 /* Now test Stereo. */
1326
1327 if ((filetype & SF_FORMAT_TYPEMASK) == SF_FORMAT_SVX) /* SVX is mono only */
1328 { printf ("ok\n") ;
1329 return ;
1330 } ;
1331
1332 items = BUFFER_SIZE ;
1333
1334 data = data_out.d ;
1335 for (sign = -1, k = 0 ; k < items ; k++)
1336 data [k] = ((double) k) / 100.0 * (sign *= -1) ;
1337
1338 sfinfo.samplerate = 44100 ;
1339 sfinfo.frames = items ;
1340 sfinfo.channels = 2 ;
1341 sfinfo.format = filetype ;
1342
1343 frames = items / sfinfo.channels ;
1344
1345 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1346 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1347 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1348 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1349 dump_log_buffer (file) ;
1350 exit (1) ;
1351 } ;
1352
1353 test_writef_double_or_die (file, 0, data, frames, __LINE__) ;
1354
1355 sf_close (file) ;
1356
1357 check_file_hash_or_die (filename, hash, __LINE__) ;
1358
1359 memset (data, 0, items * sizeof (double)) ;
1360
1361 if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1362 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1363
1364 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1365 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1366 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1367 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1368 dump_log_buffer (file) ;
1369 exit (1) ;
1370 } ;
1371
1372 if (sfinfo.format != filetype)
1373 { printf ("\n\nError (%s:%d) Stereo : Returned format incorrect (0x%08X => 0x%08X).\n", __FILE__, __LINE__, filetype, sfinfo.format) ;
1374 exit (1) ;
1375 } ;
1376
1377 if (sfinfo.frames != frames)
1378 { printf ("\n\nError (%s:%d) Stereo : Incorrect number of frames in file. (%d => %" PRId64 ")\n", __FILE__, __LINE__, frames, sfinfo.frames) ;
1379 exit (1) ;
1380 } ;
1381
1382 if (sfinfo.channels != 2)
1383 { printf ("\n\nError (%s:%d) Stereo : Incorrect number of channels in file.\n", __FILE__, __LINE__) ;
1384 exit (1) ;
1385 } ;
1386
1387 check_log_buffer_or_die (file, __LINE__) ;
1388
1389 test_readf_double_or_die (file, 0, data, frames, __LINE__) ;
1390 for (sign = -1, k = 0 ; k < items ; k++)
1391 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1392 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1393 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1394 exit (1) ;
1395 } ;
1396 } ;
1397
1398 /* Seek to start of file. */
1399 test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
1400
1401 test_readf_double_or_die (file, 0, data, 4, __LINE__) ;
1402 for (k = 0 ; k < 4 ; k++)
1403 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1404 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1405 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1406 exit (1) ;
1407 } ;
1408 } ;
1409
1410 /* Seek to offset from start of file. */
1411 test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
1412
1413 test_readf_double_or_die (file, 0, data + 20, 2, __LINE__) ;
1414 for (k = 20 ; k < 24 ; k++)
1415 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1416 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1417 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1418 exit (1) ;
1419 } ;
1420 } ;
1421
1422 /* Seek to offset from current position. */
1423 test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
1424
1425 test_readf_double_or_die (file, 0, data + 40, 2, __LINE__) ;
1426 for (k = 40 ; k < 44 ; k++)
1427 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1428 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1429 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1430 exit (1) ;
1431 } ;
1432 } ;
1433
1434 /* Seek to offset from end of file. */
1435 test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
1436
1437 test_readf_double_or_die (file, 0, data + 20, 2, __LINE__) ;
1438 for (k = 20 ; k < 24 ; k++)
1439 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1440 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1441 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1442 exit (1) ;
1443 } ;
1444 } ;
1445
1446 sf_close (file) ;
1447
1448 printf ("ok\n") ;
1449 unlink (filename) ;
1450 } /* pcm_test_float */
1451
1452 static void
1453 pcm_test_double (const char *filename, int filetype, uint64_t hash, int replace_float)
1454 { SNDFILE *file ;
1455 SF_INFO sfinfo ;
1456 int k, items, frames ;
1457 int sign ;
1458 double *data, error ;
1459
1460 /* This is the best test routine. Other should be brought up to this standard. */
1461
1462 print_test_name (replace_float ? "pcm_test_double (replace)" : "pcm_test_double", filename) ;
1463
1464 items = BUFFER_SIZE ;
1465
1466 data = data_out.d ;
1467 for (sign = 1, k = 0 ; k < items ; k++)
1468 { data [k] = ((double) (k * sign)) / 100.0 ;
1469 sign = (sign > 0) ? -1 : 1 ;
1470 } ;
1471
1472 sfinfo.samplerate = 44100 ;
1473 sfinfo.frames = items ;
1474 sfinfo.channels = 1 ;
1475 sfinfo.format = filetype ;
1476
1477 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1478 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1479 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1480 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1481 dump_log_buffer (file) ;
1482 exit (1) ;
1483 } ;
1484
1485 test_write_double_or_die (file, 0, data, items, __LINE__) ;
1486
1487 sf_close (file) ;
1488
1489 #if (defined (WIN32) || defined (_WIN32))
1490 /* File hashing on Win32 fails due to slighty different
1491 ** calculated values of the sin() function.
1492 */
1493 hash = hash ; /* Avoid compiler warning. */
1494 #else
1495 check_file_hash_or_die (filename, hash, __LINE__) ;
1496 #endif
1497
1498 memset (data, 0, items * sizeof (double)) ;
1499
1500 if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1501 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1502
1503 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1504 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1505 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1506 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1507 dump_log_buffer (file) ;
1508 exit (1) ;
1509 } ;
1510
1511 if (sfinfo.format != filetype)
1512 { printf ("\n\nError (%s:%d) Mono : Returned format incorrect (0x%08X => 0x%08X).\n", __FILE__, __LINE__, filetype, sfinfo.format) ;
1513 exit (1) ;
1514 } ;
1515
1516 if (sfinfo.frames != items)
1517 { printf ("\n\nError (%s:%d) Mono : Incorrect number of frames in file. (%d => %" PRId64 ")\n", __FILE__, __LINE__, items, sfinfo.frames) ;
1518 exit (1) ;
1519 } ;
1520
1521 if (sfinfo.channels != 1)
1522 { printf ("\n\nError (%s:%d) Mono : Incorrect number of channels in file.\n", __FILE__, __LINE__) ;
1523 exit (1) ;
1524 } ;
1525
1526 check_log_buffer_or_die (file, __LINE__) ;
1527
1528 test_read_double_or_die (file, 0, data, items, __LINE__) ;
1529
1530 for (sign = -1, k = 0 ; k < items ; k++)
1531 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1532 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1533 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1534 exit (1) ;
1535 } ;
1536 } ;
1537
1538 /* Seek to start of file. */
1539 test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
1540
1541 test_read_double_or_die (file, 0, data, 4, __LINE__) ;
1542 for (k = 0 ; k < 4 ; k++)
1543 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1544 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1545 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1546 exit (1) ;
1547 } ;
1548 } ;
1549
1550 /* Seek to offset from start of file. */
1551 test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
1552
1553 test_read_double_or_die (file, 0, data + 10, 4, __LINE__) ;
1554
1555 test_seek_or_die (file, 0, SEEK_CUR, 14, sfinfo.channels, __LINE__) ;
1556
1557 for (k = 10 ; k < 14 ; k++)
1558 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1559 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1560 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1561 exit (1) ;
1562 } ;
1563 } ;
1564
1565 /* Seek to offset from current position. */
1566 test_seek_or_die (file, 6, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
1567
1568 test_read_double_or_die (file, 0, data + 20, 4, __LINE__) ;
1569 for (k = 20 ; k < 24 ; k++)
1570 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1571 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1572 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1573 exit (1) ;
1574 } ;
1575 } ;
1576
1577 /* Seek to offset from end of file. */
1578 test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
1579
1580 test_read_double_or_die (file, 0, data + 10, 4, __LINE__) ;
1581 for (k = 10 ; k < 14 ; k++)
1582 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1583 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1584 { printf ("\n\nError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1585 exit (1) ;
1586 } ;
1587 } ;
1588
1589 sf_close (file) ;
1590
1591 /* Now test Stereo. */
1592
1593 if ((filetype & SF_FORMAT_TYPEMASK) == SF_FORMAT_SVX) /* SVX is mono only */
1594 { printf ("ok\n") ;
1595 return ;
1596 } ;
1597
1598 items = BUFFER_SIZE ;
1599
1600 data = data_out.d ;
1601 for (sign = -1, k = 0 ; k < items ; k++)
1602 data [k] = ((double) k) / 100.0 * (sign *= -1) ;
1603
1604 sfinfo.samplerate = 44100 ;
1605 sfinfo.frames = items ;
1606 sfinfo.channels = 2 ;
1607 sfinfo.format = filetype ;
1608
1609 frames = items / sfinfo.channels ;
1610
1611 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1612 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1613 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1614 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1615 dump_log_buffer (file) ;
1616 exit (1) ;
1617 } ;
1618
1619 test_writef_double_or_die (file, 0, data, frames, __LINE__) ;
1620
1621 sf_close (file) ;
1622
1623 #if (defined (WIN32) || defined (_WIN32))
1624 /* File hashing on Win32 fails due to slighty different
1625 ** calculated values.
1626 */
1627 hash = hash ; /* Avoid compiler warning. */
1628 #else
1629 check_file_hash_or_die (filename, hash, __LINE__) ;
1630 #endif
1631
1632 memset (data, 0, items * sizeof (double)) ;
1633
1634 if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1635 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1636
1637 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
1638 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
1639 if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
1640 { printf ("\n\nLine %d : Float replacement code not working.\n\n", __LINE__) ;
1641 dump_log_buffer (file) ;
1642 exit (1) ;
1643 } ;
1644
1645 if (sfinfo.format != filetype)
1646 { printf ("\n\nError (%s:%d) Stereo : Returned format incorrect (0x%08X => 0x%08X).\n", __FILE__, __LINE__, filetype, sfinfo.format) ;
1647 exit (1) ;
1648 } ;
1649
1650 if (sfinfo.frames != frames)
1651 { printf ("\n\nError (%s:%d) Stereo : Incorrect number of frames in file. (%d => %" PRId64 ")\n", __FILE__, __LINE__, frames, sfinfo.frames) ;
1652 exit (1) ;
1653 } ;
1654
1655 if (sfinfo.channels != 2)
1656 { printf ("\n\nError (%s:%d) Stereo : Incorrect number of channels in file.\n", __FILE__, __LINE__) ;
1657 exit (1) ;
1658 } ;
1659
1660 check_log_buffer_or_die (file, __LINE__) ;
1661
1662 test_readf_double_or_die (file, 0, data, frames, __LINE__) ;
1663
1664 for (sign = -1, k = 0 ; k < items ; k++)
1665 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1666 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1667 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1668 exit (1) ;
1669 } ;
1670 } ;
1671
1672 /* Seek to start of file. */
1673 test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
1674
1675 test_read_double_or_die (file, 0, data, 4, __LINE__) ;
1676 for (k = 0 ; k < 4 ; k++)
1677 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1678 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1679 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1680 exit (1) ;
1681 } ;
1682 } ;
1683
1684 /* Seek to offset from start of file. */
1685 test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
1686
1687 test_read_double_or_die (file, 0, data + 10, 4, __LINE__) ;
1688 for (k = 20 ; k < 24 ; k++)
1689 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1690 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1691 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1692 exit (1) ;
1693 } ;
1694 } ;
1695
1696 /* Seek to offset from current position. */
1697 test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
1698
1699 test_readf_double_or_die (file, 0, data + 40, 4, __LINE__) ;
1700 for (k = 40 ; k < 44 ; k++)
1701 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1702 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1703 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1704 exit (1) ;
1705 } ;
1706 } ;
1707
1708 /* Seek to offset from end of file. */
1709 test_seek_or_die (file, -1 * (sfinfo.frames -10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
1710
1711 test_readf_double_or_die (file, 0, data + 20, 4, __LINE__) ;
1712 for (k = 20 ; k < 24 ; k++)
1713 { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
1714 if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
1715 { printf ("\n\nError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).\n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
1716 exit (1) ;
1717 } ;
1718 } ;
1719
1720 sf_close (file) ;
1721
1722 printf ("ok\n") ;
1723 unlink (filename) ;
1724 } /* pcm_test_double */
1725
1726 /*==============================================================================
1727 */