Mercurial > hg > sv-dependency-builds

comparison src/libsndfile-1.0.27/tests/floating_point_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-2016 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 "dft_cmp.h"
34 #include "utils.h"
35
36 #define SAMPLE_RATE 16000
37
38 static void float_scaled_test (const char *filename, int allow_exit, int replace_float, int filetype, double target_snr) ;
39 static void double_scaled_test (const char *filename, int allow_exit, int replace_float, int filetype, double target_snr) ;
40
41 static void float_short_little_test (const char * filename) ;
42 static void float_short_big_test (const char * filename) ;
43 static void float_int_little_test (const char * filename) ;
44 static void float_int_big_test (const char * filename) ;
45 static void double_short_little_test (const char * filename) ;
46 static void double_short_big_test (const char * filename) ;
47 static void double_int_little_test (const char * filename) ;
48 static void double_int_big_test (const char * filename) ;
49
50
51 static double double_data [DFT_DATA_LENGTH] ;
52 static double double_test [DFT_DATA_LENGTH] ;
53
54 static float float_data [DFT_DATA_LENGTH] ;
55 static float float_test [DFT_DATA_LENGTH] ;
56
57 static double double_data [DFT_DATA_LENGTH] ;
58 static short short_data [DFT_DATA_LENGTH] ;
59 static int int_data [DFT_DATA_LENGTH] ;
60
61 int
62 main (int argc, char *argv [])
63 { int allow_exit = 1 ;
64
65 if (argc == 2 && ! strstr (argv [1], "no-exit"))
66 allow_exit = 0 ;
67
68 #if (HAVE_LRINTF == 0)
69 puts ("*** Cannot run this test on this platform because it lacks lrintf().") ;
70 exit (0) ;
71 #endif
72
73 /* Float tests. */
74 float_scaled_test ("float.raw", allow_exit, SF_FALSE, SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_FLOAT,
75 OS_IS_OPENBSD ? -98.0 : -163.0) ;
76
77 /* Test both signed and unsigned 8 bit files. */
78 float_scaled_test ("pcm_s8.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_S8, -39.0) ;
79 float_scaled_test ("pcm_u8.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_U8, -39.0) ;
80
81 float_scaled_test ("pcm_16.raw", allow_exit, SF_FALSE, SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_16, -87.0) ;
82 float_scaled_test ("pcm_24.raw", allow_exit, SF_FALSE, SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_24, -138.0) ;
83 float_scaled_test ("pcm_32.raw", allow_exit, SF_FALSE, SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_32, -163.0) ;
84
85 float_scaled_test ("ulaw.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_ULAW, -50.0) ;
86 float_scaled_test ("alaw.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_ALAW, -49.0) ;
87
88 float_scaled_test ("ima_adpcm.wav", allow_exit, SF_FALSE, SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, -47.0) ;
89 float_scaled_test ("ms_adpcm.wav" , allow_exit, SF_FALSE, SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, -40.0) ;
90 float_scaled_test ("gsm610.raw" , allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_GSM610, -33.0) ;
91
92 float_scaled_test ("g721_32.au", allow_exit, SF_FALSE, SF_FORMAT_AU | SF_FORMAT_G721_32, -32.3) ;
93 float_scaled_test ("g723_24.au", allow_exit, SF_FALSE, SF_FORMAT_AU | SF_FORMAT_G723_24, -32.3) ;
94 float_scaled_test ("g723_40.au", allow_exit, SF_FALSE, SF_FORMAT_AU | SF_FORMAT_G723_40, -40.0) ;
95
96 /* PAF files do not use the same encoding method for 24 bit PCM data as other file
97 ** formats so we need to explicitly test it here.
98 */
99 float_scaled_test ("le_paf_24.paf", allow_exit, SF_FALSE, SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_24, -149.0) ;
100 float_scaled_test ("be_paf_24.paf", allow_exit, SF_FALSE, SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_24, -149.0) ;
101
102 float_scaled_test ("dwvw_12.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DWVW_12, -64.0) ;
103 float_scaled_test ("dwvw_16.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DWVW_16, -92.0) ;
104 float_scaled_test ("dwvw_24.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DWVW_24, -151.0) ;
105
106 float_scaled_test ("adpcm.vox", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, -40.0) ;
107
108 float_scaled_test ("dpcm_16.xi", allow_exit, SF_FALSE, SF_FORMAT_XI | SF_FORMAT_DPCM_16, -90.0) ;
109 float_scaled_test ("dpcm_8.xi" , allow_exit, SF_FALSE, SF_FORMAT_XI | SF_FORMAT_DPCM_8 , -41.0) ;
110
111 float_scaled_test ("pcm_s8.sds", allow_exit, SF_FALSE, SF_FORMAT_SDS | SF_FORMAT_PCM_S8, -89.0) ;
112 float_scaled_test ("pcm_16.sds", allow_exit, SF_FALSE, SF_FORMAT_SDS | SF_FORMAT_PCM_16, -132.0) ;
113 float_scaled_test ("pcm_24.sds", allow_exit, SF_FALSE, SF_FORMAT_SDS | SF_FORMAT_PCM_24, -170.0) ;
114
115 float_scaled_test ("alac_16.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_16, -90.0) ;
116 float_scaled_test ("alac_32.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_32, -76.0) ;
117 float_scaled_test ("alac_24.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_24, -153.0) ;
118 float_scaled_test ("alac_20.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_20, -125.0) ;
119
120 #if HAVE_EXTERNAL_XIPH_LIBS
121 float_scaled_test ("flac_8.flac", allow_exit, SF_FALSE, SF_FORMAT_FLAC | SF_FORMAT_PCM_S8, -39.0) ;
122 float_scaled_test ("flac_16.flac", allow_exit, SF_FALSE, SF_FORMAT_FLAC | SF_FORMAT_PCM_16, -87.0) ;
123 float_scaled_test ("flac_24.flac", allow_exit, SF_FALSE, SF_FORMAT_FLAC | SF_FORMAT_PCM_24, -138.0) ;
124
125 float_scaled_test ("vorbis.oga", allow_exit, SF_FALSE, SF_FORMAT_OGG | SF_FORMAT_VORBIS, -31.0) ;
126 #endif
127
128 float_scaled_test ("replace_float.raw", allow_exit, SF_TRUE, SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_FLOAT, -163.0) ;
129
130 /*==============================================================================
131 ** Double tests.
132 */
133
134 double_scaled_test ("double.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DOUBLE, -201.0) ;
135
136 /* Test both signed (AIFF) and unsigned (WAV) 8 bit files. */
137 double_scaled_test ("pcm_s8.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_S8, -39.0) ;
138 double_scaled_test ("pcm_u8.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_U8, -39.0) ;
139
140 double_scaled_test ("pcm_16.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_16, -87.0) ;
141 double_scaled_test ("pcm_24.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_24, -135.0) ;
142 double_scaled_test ("pcm_32.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_PCM_32, -184.0) ;
143
144 double_scaled_test ("ulaw.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_ULAW, -50.0) ;
145 double_scaled_test ("alaw.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_ALAW, -49.0) ;
146
147 double_scaled_test ("ima_adpcm.wav", allow_exit, SF_FALSE, SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, -47.0) ;
148 double_scaled_test ("ms_adpcm.wav" , allow_exit, SF_FALSE, SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, -40.0) ;
149 double_scaled_test ("gsm610.raw" , allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_GSM610, -33.0) ;
150
151 double_scaled_test ("g721_32.au", allow_exit, SF_FALSE, SF_FORMAT_AU | SF_FORMAT_G721_32, -32.3) ;
152 double_scaled_test ("g723_24.au", allow_exit, SF_FALSE, SF_FORMAT_AU | SF_FORMAT_G723_24, -32.3) ;
153 double_scaled_test ("g723_40.au", allow_exit, SF_FALSE, SF_FORMAT_AU | SF_FORMAT_G723_40, -40.0) ;
154
155 /* 24 bit PCM PAF files tested here. */
156 double_scaled_test ("be_paf_24.paf", allow_exit, SF_FALSE, SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_24, -151.0) ;
157 double_scaled_test ("le_paf_24.paf", allow_exit, SF_FALSE, SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_24, -151.0) ;
158
159 double_scaled_test ("dwvw_12.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DWVW_12, -64.0) ;
160 double_scaled_test ("dwvw_16.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DWVW_16, -92.0) ;
161 double_scaled_test ("dwvw_24.raw", allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_DWVW_24, -151.0) ;
162
163 double_scaled_test ("adpcm.vox" , allow_exit, SF_FALSE, SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, -40.0) ;
164
165 double_scaled_test ("dpcm_16.xi", allow_exit, SF_FALSE, SF_FORMAT_XI | SF_FORMAT_DPCM_16, -90.0) ;
166 double_scaled_test ("dpcm_8.xi" , allow_exit, SF_FALSE, SF_FORMAT_XI | SF_FORMAT_DPCM_8 , -41.0) ;
167
168 double_scaled_test ("pcm_s8.sds", allow_exit, SF_FALSE, SF_FORMAT_SDS | SF_FORMAT_PCM_S8, -89.0) ;
169 double_scaled_test ("pcm_16.sds", allow_exit, SF_FALSE, SF_FORMAT_SDS | SF_FORMAT_PCM_16, -132.0) ;
170 double_scaled_test ("pcm_24.sds", allow_exit, SF_FALSE, SF_FORMAT_SDS | SF_FORMAT_PCM_24, -180.0) ;
171
172 double_scaled_test ("alac_16.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_16, -90.0) ;
173 double_scaled_test ("alac_20.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_20, -125.0) ;
174 double_scaled_test ("alac_24.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_24, -153.0) ;
175 double_scaled_test ("alac_32.caf", allow_exit, SF_FALSE, SF_FORMAT_CAF | SF_FORMAT_ALAC_32, -186.0) ;
176
177 #if HAVE_EXTERNAL_XIPH_LIBS
178 double_scaled_test ("flac_8.flac", allow_exit, SF_FALSE, SF_FORMAT_FLAC | SF_FORMAT_PCM_S8, -39.0) ;
179 double_scaled_test ("flac_16.flac", allow_exit, SF_FALSE, SF_FORMAT_FLAC | SF_FORMAT_PCM_16, -87.0) ;
180 double_scaled_test ("flac_24.flac", allow_exit, SF_FALSE, SF_FORMAT_FLAC | SF_FORMAT_PCM_24, -138.0) ;
181
182 double_scaled_test ("vorbis.oga", allow_exit, SF_FALSE, SF_FORMAT_OGG | SF_FORMAT_VORBIS, -29.0) ;
183 #endif
184
185 double_scaled_test ("replace_double.raw", allow_exit, SF_TRUE, SF_FORMAT_RAW | SF_FORMAT_DOUBLE, -201.0) ;
186
187 putchar ('\n') ;
188 /* Float int tests. */
189 float_short_little_test ("float_short_little.au") ;
190 float_short_big_test ("float_short_big.au") ;
191 float_int_little_test ("float_int_little.au") ;
192 float_int_big_test ("float_int_big.au") ;
193 double_short_little_test ("double_short_little.au") ;
194 double_short_big_test ("double_short_big.au") ;
195 double_int_little_test ("double_int_little.au") ;
196 double_int_big_test ("double_int_big.au") ;
197
198
199 return 0 ;
200 } /* main */
201
202 /*============================================================================================
203 * Here are the test functions.
204 */
205
206 static void
207 float_scaled_test (const char *filename, int allow_exit, int replace_float, int filetype, double target_snr)
208 { SNDFILE *file ;
209 SF_INFO sfinfo ;
210 double snr ;
211 int byterate ;
212
213 print_test_name ("float_scaled_test", filename) ;
214
215 gen_windowed_sine_float (float_data, DFT_DATA_LENGTH, 0.9999) ;
216
217 sfinfo.samplerate = SAMPLE_RATE ;
218 sfinfo.frames = DFT_DATA_LENGTH ;
219 sfinfo.channels = 1 ;
220 sfinfo.format = filetype ;
221
222 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
223 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
224
225 test_write_float_or_die (file, 0, float_data, DFT_DATA_LENGTH, __LINE__) ;
226
227 sf_close (file) ;
228
229 memset (float_test, 0, sizeof (float_test)) ;
230
231 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
232 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
233
234 exit_if_true (sfinfo.format != filetype, "\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
235 exit_if_true (sfinfo.frames < DFT_DATA_LENGTH, "\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
236 exit_if_true (sfinfo.channels != 1, "\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
237
238 check_log_buffer_or_die (file, __LINE__) ;
239
240 test_read_float_or_die (file, 0, float_test, DFT_DATA_LENGTH, __LINE__) ;
241
242 byterate = sf_current_byterate (file) ;
243 exit_if_true (byterate <= 0, "\n\nLine %d: byterate is zero.\n", __LINE__) ;
244
245 sf_close (file) ;
246
247 snr = dft_cmp_float (__LINE__, float_data, float_test, DFT_DATA_LENGTH, target_snr, allow_exit) ;
248
249 exit_if_true (snr > target_snr, "% 6.1fdB SNR\n\n Error : should be better than % 6.1fdB\n\n", snr, target_snr) ;
250
251 printf ("% 6.1fdB SNR ... ok\n", snr) ;
252
253 unlink (filename) ;
254
255 return ;
256 } /* float_scaled_test */
257
258 static void
259 double_scaled_test (const char *filename, int allow_exit, int replace_float, int filetype, double target_snr)
260 { SNDFILE *file ;
261 SF_INFO sfinfo ;
262 double snr ;
263 int byterate ;
264
265 print_test_name ("double_scaled_test", filename) ;
266
267 gen_windowed_sine_double (double_data, DFT_DATA_LENGTH, 0.9999) ;
268
269 sfinfo.samplerate = SAMPLE_RATE ;
270 sfinfo.frames = DFT_DATA_LENGTH ;
271 sfinfo.channels = 1 ;
272 sfinfo.format = filetype ;
273
274 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
275 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
276
277 test_write_double_or_die (file, 0, double_data, DFT_DATA_LENGTH, __LINE__) ;
278
279 sf_close (file) ;
280
281 memset (double_test, 0, sizeof (double_test)) ;
282
283 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
284 sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
285
286 exit_if_true (sfinfo.format != filetype, "\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
287 exit_if_true (sfinfo.frames < DFT_DATA_LENGTH, "\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
288 exit_if_true (sfinfo.channels != 1, "\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
289
290 check_log_buffer_or_die (file, __LINE__) ;
291
292 test_read_double_or_die (file, 0, double_test, DFT_DATA_LENGTH, __LINE__) ;
293
294 byterate = sf_current_byterate (file) ;
295 exit_if_true (byterate <= 0, "\n\nLine %d: byterate is zero.\n", __LINE__) ;
296
297 sf_close (file) ;
298
299 snr = dft_cmp_double (__LINE__, double_data, double_test, DFT_DATA_LENGTH, target_snr, allow_exit) ;
300
301 exit_if_true (snr > target_snr, "% 6.1fdB SNR\n\n Error : should be better than % 6.1fdB\n\n", snr, target_snr) ;
302
303 printf ("% 6.1fdB SNR ... ok\n", snr) ;
304
305 unlink (filename) ;
306
307 return ;
308 } /* double_scaled_test */
309
310 /*==============================================================================
311 */
312
313
314 static void
315 float_short_little_test (const char * filename)
316 { SNDFILE *file ;
317 SF_INFO sfinfo ;
318 int max ;
319 unsigned k ;
320
321 print_test_name ("float_short_little_test", filename) ;
322
323 gen_windowed_sine_float (float_data, ARRAY_LEN (float_data), 0.9999) ;
324
325 sfinfo.samplerate = SAMPLE_RATE ;
326 sfinfo.frames = ARRAY_LEN (short_data) ;
327 sfinfo.channels = 1 ;
328 sfinfo.format = SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT ;
329
330 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
331 test_write_float_or_die (file, 0, float_data, ARRAY_LEN (float_data), __LINE__) ;
332 sf_close (file) ;
333
334 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
335
336 if (sfinfo.frames != ARRAY_LEN (float_data))
337 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
338 exit (1) ;
339 } ;
340
341 if (sfinfo.channels != 1)
342 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
343 exit (1) ;
344 } ;
345
346 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
347
348 test_read_short_or_die (file, 0, short_data, ARRAY_LEN (short_data), __LINE__) ;
349 sf_close (file) ;
350
351 max = 0 ;
352 for (k = 0 ; k < ARRAY_LEN (short_data) ; k++)
353 if (abs (short_data [k]) > max)
354 max = abs (short_data [k]) ;
355
356 if (1.0 * abs (max - 0x7FFF) / 0x7FFF > 0.01)
357 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFF) ;
358 exit (1) ;
359 } ;
360
361 unlink (filename) ;
362 puts ("ok") ;
363 } /* float_short_little_test */
364
365 static void
366 float_short_big_test (const char * filename)
367 { SNDFILE *file ;
368 SF_INFO sfinfo ;
369 int max ;
370 unsigned k ;
371
372 print_test_name ("float_short_big_test", filename) ;
373
374 gen_windowed_sine_float (float_data, ARRAY_LEN (float_data), 0.9999) ;
375
376 sfinfo.samplerate = SAMPLE_RATE ;
377 sfinfo.frames = ARRAY_LEN (short_data) ;
378 sfinfo.channels = 1 ;
379 sfinfo.format = SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_FLOAT ;
380
381 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
382 test_write_float_or_die (file, 0, float_data, ARRAY_LEN (float_data), __LINE__) ;
383 sf_close (file) ;
384
385 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
386
387 if (sfinfo.frames != ARRAY_LEN (float_data))
388 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
389 exit (1) ;
390 } ;
391
392 if (sfinfo.channels != 1)
393 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
394 exit (1) ;
395 } ;
396
397 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
398
399 test_read_short_or_die (file, 0, short_data, ARRAY_LEN (short_data), __LINE__) ;
400 sf_close (file) ;
401
402 max = 0 ;
403 for (k = 0 ; k < ARRAY_LEN (short_data) ; k++)
404 if (abs (short_data [k]) > max)
405 max = abs (short_data [k]) ;
406
407 if (1.0 * abs (max - 0x7FFF) / 0x7FFF > 0.01)
408 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFF) ;
409 exit (1) ;
410 } ;
411
412 unlink (filename) ;
413 puts ("ok") ;
414 } /* float_short_big_test */
415
416 static void
417 float_int_little_test (const char * filename)
418 { SNDFILE *file ;
419 SF_INFO sfinfo ;
420 int max ;
421 unsigned k ;
422
423 print_test_name ("float_int_little_test", filename) ;
424
425 gen_windowed_sine_float (float_data, ARRAY_LEN (float_data), 0.9999) ;
426
427 sfinfo.samplerate = SAMPLE_RATE ;
428 sfinfo.frames = ARRAY_LEN (int_data) ;
429 sfinfo.channels = 1 ;
430 sfinfo.format = SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT ;
431
432 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
433 test_write_float_or_die (file, 0, float_data, ARRAY_LEN (float_data), __LINE__) ;
434 sf_close (file) ;
435
436 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
437
438 if (sfinfo.frames != ARRAY_LEN (float_data))
439 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
440 exit (1) ;
441 } ;
442
443 if (sfinfo.channels != 1)
444 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
445 exit (1) ;
446 } ;
447
448 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
449
450 test_read_int_or_die (file, 0, int_data, ARRAY_LEN (int_data), __LINE__) ;
451 sf_close (file) ;
452
453 max = 0 ;
454 for (k = 0 ; k < ARRAY_LEN (int_data) ; k++)
455 if (abs (int_data [k]) > max)
456 max = abs (int_data [k]) ;
457
458 if (1.0 * abs (max - 0x7FFFFFFF) / 0x7FFFFFFF > 0.01)
459 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFFFFFF) ;
460 exit (1) ;
461 } ;
462
463 unlink (filename) ;
464 puts ("ok") ;
465 } /* float_int_little_test */
466
467 static void
468 float_int_big_test (const char * filename)
469 { SNDFILE *file ;
470 SF_INFO sfinfo ;
471 int max ;
472 unsigned k ;
473
474 print_test_name ("float_int_big_test", filename) ;
475
476 gen_windowed_sine_float (float_data, ARRAY_LEN (float_data), 0.9999) ;
477
478 sfinfo.samplerate = SAMPLE_RATE ;
479 sfinfo.frames = ARRAY_LEN (int_data) ;
480 sfinfo.channels = 1 ;
481 sfinfo.format = SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_FLOAT ;
482
483 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
484 test_write_float_or_die (file, 0, float_data, ARRAY_LEN (float_data), __LINE__) ;
485 sf_close (file) ;
486
487 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
488
489 if (sfinfo.frames != ARRAY_LEN (float_data))
490 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
491 exit (1) ;
492 } ;
493
494 if (sfinfo.channels != 1)
495 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
496 exit (1) ;
497 } ;
498
499 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
500
501 test_read_int_or_die (file, 0, int_data, ARRAY_LEN (int_data), __LINE__) ;
502 sf_close (file) ;
503
504 max = 0 ;
505 for (k = 0 ; k < ARRAY_LEN (int_data) ; k++)
506 if (abs (int_data [k]) > max)
507 max = abs (int_data [k]) ;
508
509 if (1.0 * abs (max - 0x7FFFFFFF) / 0x7FFFFFFF > 0.01)
510 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFFFFFF) ;
511 exit (1) ;
512 } ;
513
514 unlink (filename) ;
515 puts ("ok") ;
516 } /* float_int_big_test */
517
518 static void
519 double_short_little_test (const char * filename)
520 { SNDFILE *file ;
521 SF_INFO sfinfo ;
522 int max ;
523 unsigned k ;
524
525 print_test_name ("double_short_little_test", filename) ;
526
527 gen_windowed_sine_double (double_data, ARRAY_LEN (double_data), 0.9999) ;
528
529 sfinfo.samplerate = SAMPLE_RATE ;
530 sfinfo.frames = ARRAY_LEN (short_data) ;
531 sfinfo.channels = 1 ;
532 sfinfo.format = SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE ;
533
534 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
535 test_write_double_or_die (file, 0, double_data, ARRAY_LEN (double_data), __LINE__) ;
536 sf_close (file) ;
537
538 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
539
540 if (sfinfo.frames != ARRAY_LEN (double_data))
541 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
542 exit (1) ;
543 } ;
544
545 if (sfinfo.channels != 1)
546 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
547 exit (1) ;
548 } ;
549
550 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
551
552 test_read_short_or_die (file, 0, short_data, ARRAY_LEN (short_data), __LINE__) ;
553 sf_close (file) ;
554
555 max = 0 ;
556 for (k = 0 ; k < ARRAY_LEN (short_data) ; k++)
557 if (abs (short_data [k]) > max)
558 max = abs (short_data [k]) ;
559
560 if (1.0 * abs (max - 0x7FFF) / 0x7FFF > 0.01)
561 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFF) ;
562 exit (1) ;
563 } ;
564
565 unlink (filename) ;
566 puts ("ok") ;
567 } /* double_short_little_test */
568
569 static void
570 double_short_big_test (const char * filename)
571 { SNDFILE *file ;
572 SF_INFO sfinfo ;
573 int max ;
574 unsigned k ;
575
576 print_test_name ("double_short_big_test", filename) ;
577
578 gen_windowed_sine_double (double_data, ARRAY_LEN (double_data), 0.9999) ;
579
580 sfinfo.samplerate = SAMPLE_RATE ;
581 sfinfo.frames = ARRAY_LEN (short_data) ;
582 sfinfo.channels = 1 ;
583 sfinfo.format = SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_DOUBLE ;
584
585 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
586 test_write_double_or_die (file, 0, double_data, ARRAY_LEN (double_data), __LINE__) ;
587 sf_close (file) ;
588
589 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
590
591 if (sfinfo.frames != ARRAY_LEN (double_data))
592 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
593 exit (1) ;
594 } ;
595
596 if (sfinfo.channels != 1)
597 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
598 exit (1) ;
599 } ;
600
601 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
602
603 test_read_short_or_die (file, 0, short_data, ARRAY_LEN (short_data), __LINE__) ;
604 sf_close (file) ;
605
606 max = 0 ;
607 for (k = 0 ; k < ARRAY_LEN (short_data) ; k++)
608 if (abs (short_data [k]) > max)
609 max = abs (short_data [k]) ;
610
611 if (1.0 * abs (max - 0x7FFF) / 0x7FFF > 0.01)
612 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFF) ;
613 exit (1) ;
614 } ;
615
616 unlink (filename) ;
617 puts ("ok") ;
618 } /* double_short_big_test */
619
620 static void
621 double_int_little_test (const char * filename)
622 { SNDFILE *file ;
623 SF_INFO sfinfo ;
624 int max ;
625 unsigned k ;
626
627 print_test_name ("double_int_little_test", filename) ;
628
629 gen_windowed_sine_double (double_data, ARRAY_LEN (double_data), 0.9999) ;
630
631 sfinfo.samplerate = SAMPLE_RATE ;
632 sfinfo.frames = ARRAY_LEN (int_data) ;
633 sfinfo.channels = 1 ;
634 sfinfo.format = SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE ;
635
636 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
637 test_write_double_or_die (file, 0, double_data, ARRAY_LEN (double_data), __LINE__) ;
638 sf_close (file) ;
639
640 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
641
642 if (sfinfo.frames != ARRAY_LEN (double_data))
643 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
644 exit (1) ;
645 } ;
646
647 if (sfinfo.channels != 1)
648 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
649 exit (1) ;
650 } ;
651
652 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
653
654 test_read_int_or_die (file, 0, int_data, ARRAY_LEN (int_data), __LINE__) ;
655 sf_close (file) ;
656
657 max = 0 ;
658 for (k = 0 ; k < ARRAY_LEN (int_data) ; k++)
659 if (abs (int_data [k]) > max)
660 max = abs (int_data [k]) ;
661
662 if (1.0 * abs (max - 0x7FFFFFFF) / 0x7FFFFFFF > 0.01)
663 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFFFFFF) ;
664 exit (1) ;
665 } ;
666
667 unlink (filename) ;
668 puts ("ok") ;
669 } /* double_int_little_test */
670
671 static void
672 double_int_big_test (const char * filename)
673 { SNDFILE *file ;
674 SF_INFO sfinfo ;
675 int max ;
676 unsigned k ;
677
678 print_test_name ("double_int_big_test", filename) ;
679
680 gen_windowed_sine_double (double_data, ARRAY_LEN (double_data), 0.9999) ;
681
682 sfinfo.samplerate = SAMPLE_RATE ;
683 sfinfo.frames = ARRAY_LEN (int_data) ;
684 sfinfo.channels = 1 ;
685 sfinfo.format = SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_DOUBLE ;
686
687 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
688 test_write_double_or_die (file, 0, double_data, ARRAY_LEN (double_data), __LINE__) ;
689 sf_close (file) ;
690
691 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
692
693 if (sfinfo.frames != ARRAY_LEN (double_data))
694 { printf ("\n\nLine %d: Incorrect number of frames in file (too short). (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, DFT_DATA_LENGTH) ;
695 exit (1) ;
696 } ;
697
698 if (sfinfo.channels != 1)
699 { printf ("\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
700 exit (1) ;
701 } ;
702
703 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
704
705 test_read_int_or_die (file, 0, int_data, ARRAY_LEN (int_data), __LINE__) ;
706 sf_close (file) ;
707
708 max = 0 ;
709 for (k = 0 ; k < ARRAY_LEN (int_data) ; k++)
710 if (abs (int_data [k]) > max)
711 max = abs (int_data [k]) ;
712
713 if (1.0 * abs (max - 0x7FFFFFFF) / 0x7FFFFFFF > 0.01)
714 { printf ("\n\nLine %d: Bad maximum (%d should be %d).\n\n", __LINE__, max, 0x7FFFFFFF) ;
715 exit (1) ;
716 } ;
717
718 unlink (filename) ;
719 puts ("ok") ;
720 } /* double_int_big_test */
721
722