Mercurial > hg > sv-dependency-builds

comparison src/libsndfile-1.0.25/tests/pcm_test.c @ 0:c7265573341e

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