开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
pcm_test.c
资源名称：libsndfile-1.0.21.tar.gz　[点击查看]
上传用户：shw771010
上传日期：2022-01-05
资源大小：991k
文件大小：53k
源码类别：

Audio

开发平台：

Unix_Linux

pcm_test.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2009 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. */
  19. #include "sfconfig.h"
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <math.h>
  26. #if HAVE_UNISTD_H
  27. #include <unistd.h>
  28. #endif
  30. #include <sndfile.h>
  32. #include "utils.h"
  34. #define BUFFER_SIZE (1<<12)
  36. static void lrintf_test (void) ;
  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) ;
  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) ;
  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 ;
  53. /* Data written to the file. */
  54. static BUFFER data_out ;
  56. /* Data read back from the file. */
  57. static BUFFER data_in ;
  59. int
  60. main (void)
  61. {
  62. lrintf_test () ;
  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) ;
  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) ;
  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) ;
  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) ;
  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) ;
  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) ;
  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) ;
  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 */
  90. return 0 ;
  91. } /* main */
  93. /*============================================================================================
  94. ** Here are the test functions.
  95. */
  97. static void
  98. lrintf_test (void)
  99. { int k, items ;
  100. float *float_data ;
  101. int *int_data ;
  103. print_test_name ("lrintf_test", "") ;
  105. items = 1024 ;
  107. float_data = data_out.f ;
  108. int_data = data_in.i ;
  110. for (k = 0 ; k < items ; k++)
  111. float_data [k] = (k * ((k % 2) ? 333333.0 : -333333.0)) ;
  113. for (k = 0 ; k < items ; k++)
  114. int_data [k] = lrintf (float_data [k]) ;
  116. for (k = 0 ; k < items ; k++)
  117. if (fabs (int_data [k] - float_data [k]) > 1.0)
  118. { printf ("nnLine %d: float : Incorrect sample (#%d : %f => %d).n", __LINE__, k, float_data [k], int_data [k]) ;
  119. exit (1) ;
  120. } ;
  122. printf ("okn") ;
  123. } /* lrintf_test */
  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 */
  137. print_test_name ("pcm_test_bits_8", filename) ;
  139. items = 127 ;
  141. short_out = data_out.s ;
  142. short_in = data_in.s ;
  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. } ;
  150. if (zero_count > items / 4)
  151. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  152. exit (1) ;
  153. } ;
  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 ;
  160. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  162. test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
  164. sf_close (file) ;
  166. memset (short_in, 0, items * sizeof (short)) ;
  168. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  170. if (sfinfo.format != filetype)
  171. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  172. exit (1) ;
  173. } ;
  175. if (sfinfo.frames != items)
  176. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  177. exit (1) ;
  178. } ;
  180. if (sfinfo.channels != 1)
  181. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  182. exit (1) ;
  183. } ;
  185. check_log_buffer_or_die (file, __LINE__) ;
  187. test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
  189. for (k = 0 ; k < items ; k++)
  190. if (short_out [k] != short_in [k])
  191. { printf ("nnLine %d: Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, short_out [k], short_in [k]) ;
  192. exit (1) ;
  193. } ;
  195. sf_close (file) ;
  197. /* Finally, check the file hash. */
  198. check_file_hash_or_die (filename, hash, __LINE__) ;
  200. /*--------------------------------------------------------------------------
  201. ** Test sf_read/write_int ()
  202. */
  203. zero_count = 0 ;
  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. } ;
  212. if (zero_count > items / 4)
  213. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  214. exit (1) ;
  215. } ;
  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 ;
  222. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  224. test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
  226. sf_close (file) ;
  228. memset (int_in, 0, items * sizeof (int)) ;
  230. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  232. if (sfinfo.format != filetype)
  233. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  234. exit (1) ;
  235. } ;
  237. if (sfinfo.frames != items)
  238. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  239. exit (1) ;
  240. } ;
  242. if (sfinfo.channels != 1)
  243. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  244. exit (1) ;
  245. } ;
  247. check_log_buffer_or_die (file, __LINE__) ;
  249. test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
  251. for (k = 0 ; k < items ; k++)
  252. if (int_out [k] != int_in [k])
  253. { printf ("nnLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, int_out [k], int_in [k]) ;
  254. exit (1) ;
  255. } ;
  257. sf_close (file) ;
  259. /* Lite remove start */
  260. /*--------------------------------------------------------------------------
  261. ** Test sf_read/write_float ()
  262. */
  263. zero_count = 0 ;
  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. } ;
  272. if (zero_count > items / 4)
  273. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  274. exit (1) ;
  275. } ;
  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 ;
  282. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  284. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  286. test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
  288. sf_close (file) ;
  290. memset (float_in, 0, items * sizeof (float)) ;
  292. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  294. if (sfinfo.format != filetype)
  295. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  296. exit (1) ;
  297. } ;
  299. if (sfinfo.frames != items)
  300. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  301. exit (1) ;
  302. } ;
  304. if (sfinfo.channels != 1)
  305. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  306. exit (1) ;
  307. } ;
  309. check_log_buffer_or_die (file, __LINE__) ;
  311. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  313. test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
  315. for (k = 0 ; k < items ; k++)
  316. if (fabs (float_out [k] - float_in [k]) > 1e-10)
  317. { printf ("nnLine %d: float : Incorrect sample (#%d : %f => %f).n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
  318. exit (1) ;
  319. break ;
  320. } ;
  322. sf_close (file) ;
  324. /*--------------------------------------------------------------------------
  325. ** Test sf_read/write_double ()
  326. */
  327. zero_count = 0 ;
  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. } ;
  336. if (zero_count > items / 4)
  337. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  338. exit (1) ;
  339. } ;
  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 ;
  346. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  348. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  350. test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
  352. sf_close (file) ;
  354. memset (double_in, 0, items * sizeof (double)) ;
  356. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  358. if (sfinfo.format != filetype)
  359. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  360. exit (1) ;
  361. } ;
  363. if (sfinfo.frames != items)
  364. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  365. exit (1) ;
  366. } ;
  368. if (sfinfo.channels != 1)
  369. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  370. exit (1) ;
  371. } ;
  373. check_log_buffer_or_die (file, __LINE__) ;
  375. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  377. test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
  379. for (k = 0 ; k < items ; k++)
  380. if (fabs (double_out [k] - double_in [k]) > 1e-10)
  381. { printf ("nnLine %d: double : Incorrect sample (#%d : %f => %f).n", __LINE__, k, double_out [k], double_in [k]) ;
  382. exit (1) ;
  383. } ;
  385. sf_close (file) ;
  386. /* Lite remove end */
  387. unlink (filename) ;
  389. puts ("ok") ;
  390. } /* pcm_test_bits_8 */
  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 */
  404. print_test_name ("pcm_test_bits_16", filename) ;
  406. items = 1024 ;
  408. short_out = data_out.s ;
  409. short_in = data_in.s ;
  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. } ;
  417. if (zero_count > items / 4)
  418. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  419. exit (1) ;
  420. } ;
  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 ;
  427. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  429. test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
  431. sf_close (file) ;
  433. memset (short_in, 0, items * sizeof (short)) ;
  435. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  437. if (sfinfo.format != filetype)
  438. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  439. exit (1) ;
  440. } ;
  442. if (sfinfo.frames != items)
  443. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  444. exit (1) ;
  445. } ;
  447. if (sfinfo.channels != 1)
  448. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  449. exit (1) ;
  450. } ;
  452. check_log_buffer_or_die (file, __LINE__) ;
  454. test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
  456. for (k = 0 ; k < items ; k++)
  457. if (short_out [k] != short_in [k])
  458. { printf ("nnLine %d: Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, short_out [k], short_in [k]) ;
  459. exit (1) ;
  460. } ;
  462. sf_close (file) ;
  464. /* Finally, check the file hash. */
  465. check_file_hash_or_die (filename, hash, __LINE__) ;
  467. /*--------------------------------------------------------------------------
  468. ** Test sf_read/write_int ()
  469. */
  470. zero_count = 0 ;
  472. int_out = data_out.i ;
  473. int_in = data_in.i ;
  474. for (k = 0 ; k < items ; k++)
  475. { int_out [k] = ((k * ((k % 2) ? 3 : -3)) << 16) ;
  476. zero_count = int_out [k] ? zero_count : zero_count + 1 ;
  477. } ;
  479. if (zero_count > items / 4)
  480. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  481. exit (1) ;
  482. } ;
  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 ;
  489. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  491. test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
  493. sf_close (file) ;
  495. memset (int_in, 0, items * sizeof (int)) ;
  497. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  499. if (sfinfo.format != filetype)
  500. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  501. exit (1) ;
  502. } ;
  504. if (sfinfo.frames != items)
  505. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  506. exit (1) ;
  507. } ;
  509. if (sfinfo.channels != 1)
  510. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  511. exit (1) ;
  512. } ;
  514. check_log_buffer_or_die (file, __LINE__) ;
  516. test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
  518. for (k = 0 ; k < items ; k++)
  519. if (int_out [k] != int_in [k])
  520. { printf ("nnLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, int_out [k], int_in [k]) ;
  521. exit (1) ;
  522. } ;
  524. sf_close (file) ;
  526. /* Lite remove start */
  527. /*--------------------------------------------------------------------------
  528. ** Test sf_read/write_float ()
  529. */
  530. zero_count = 0 ;
  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. } ;
  539. if (zero_count > items / 4)
  540. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  541. exit (1) ;
  542. } ;
  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 ;
  549. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  551. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  553. test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
  555. sf_close (file) ;
  557. memset (float_in, 0, items * sizeof (float)) ;
  559. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  561. if (sfinfo.format != filetype)
  562. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  563. exit (1) ;
  564. } ;
  566. if (sfinfo.frames != items)
  567. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  568. exit (1) ;
  569. } ;
  571. if (sfinfo.channels != 1)
  572. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  573. exit (1) ;
  574. } ;
  576. check_log_buffer_or_die (file, __LINE__) ;
  578. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  580. test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
  582. for (k = 0 ; k < items ; k++)
  583. if (fabs (float_out [k] - float_in [k]) > 1e-10)
  584. { printf ("nnLine %d: float : Incorrect sample (#%d : %f => %f).n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
  585. exit (1) ;
  586. break ;
  587. } ;
  589. sf_close (file) ;
  591. /*--------------------------------------------------------------------------
  592. ** Test sf_read/write_double ()
  593. */
  594. zero_count = 0 ;
  596. double_out = data_out.d ;
  597. double_in = data_in.d ;
  598. for (k = 0 ; k < items ; k++)
  599. { double_out [k] = (k * ((k % 2) ? 3 : -3)) ;
  600. zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
  601. } ;
  603. if (zero_count > items / 4)
  604. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  605. exit (1) ;
  606. } ;
  608. sfinfo.samplerate = 44100 ;
  609. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  610. sfinfo.channels = 1 ;
  611. sfinfo.format = filetype ;
  613. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  615. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  617. test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
  619. sf_close (file) ;
  621. memset (double_in, 0, items * sizeof (double)) ;
  623. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  625. if (sfinfo.format != filetype)
  626. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  627. exit (1) ;
  628. } ;
  630. if (sfinfo.frames != items)
  631. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  632. exit (1) ;
  633. } ;
  635. if (sfinfo.channels != 1)
  636. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  637. exit (1) ;
  638. } ;
  640. check_log_buffer_or_die (file, __LINE__) ;
  642. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  644. test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
  646. for (k = 0 ; k < items ; k++)
  647. if (fabs (double_out [k] - double_in [k]) > 1e-10)
  648. { printf ("nnLine %d: double : Incorrect sample (#%d : %f => %f).n", __LINE__, k, double_out [k], double_in [k]) ;
  649. exit (1) ;
  650. } ;
  652. sf_close (file) ;
  653. /* Lite remove end */
  654. unlink (filename) ;
  656. puts ("ok") ;
  657. } /* pcm_test_bits_16 */
  659. static void
  660. pcm_test_bits_24 (const char *filename, int filetype, uint64_t hash)
  661. { SNDFILE *file ;
  662. SF_INFO sfinfo ;
  663. int k, items, zero_count ;
  664. short *short_out, *short_in ;
  665. int *int_out, *int_in ;
  666. /* Lite remove start */
  667. float *float_out, *float_in ;
  668. double *double_out, *double_in ;
  669. /* Lite remove end */
  671. print_test_name ("pcm_test_bits_24", filename) ;
  673. items = 1024 ;
  675. short_out = data_out.s ;
  676. short_in = data_in.s ;
  678. zero_count = 0 ;
  679. for (k = 0 ; k < items ; k++)
  680. { short_out [k] = (k * ((k % 2) ? 3 : -3)) ;
  681. zero_count = short_out [k] ? zero_count : zero_count + 1 ;
  682. } ;
  684. if (zero_count > items / 4)
  685. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  686. exit (1) ;
  687. } ;
  689. sfinfo.samplerate = 44100 ;
  690. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  691. sfinfo.channels = 1 ;
  692. sfinfo.format = filetype ;
  694. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  696. test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
  698. sf_close (file) ;
  700. memset (short_in, 0, items * sizeof (short)) ;
  702. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  704. if (sfinfo.format != filetype)
  705. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  706. exit (1) ;
  707. } ;
  709. if (sfinfo.frames != items)
  710. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  711. exit (1) ;
  712. } ;
  714. if (sfinfo.channels != 1)
  715. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  716. exit (1) ;
  717. } ;
  719. check_log_buffer_or_die (file, __LINE__) ;
  721. test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
  723. for (k = 0 ; k < items ; k++)
  724. if (short_out [k] != short_in [k])
  725. { printf ("nnLine %d: Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, short_out [k], short_in [k]) ;
  726. exit (1) ;
  727. } ;
  729. sf_close (file) ;
  731. /* Finally, check the file hash. */
  732. check_file_hash_or_die (filename, hash, __LINE__) ;
  734. /*--------------------------------------------------------------------------
  735. ** Test sf_read/write_int ()
  736. */
  737. zero_count = 0 ;
  739. int_out = data_out.i ;
  740. int_in = data_in.i ;
  741. for (k = 0 ; k < items ; k++)
  742. { int_out [k] = ((k * ((k % 2) ? 3333 : -3333)) << 8) ;
  743. zero_count = int_out [k] ? zero_count : zero_count + 1 ;
  744. } ;
  746. if (zero_count > items / 4)
  747. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  748. exit (1) ;
  749. } ;
  751. sfinfo.samplerate = 44100 ;
  752. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  753. sfinfo.channels = 1 ;
  754. sfinfo.format = filetype ;
  756. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  758. test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
  760. sf_close (file) ;
  762. memset (int_in, 0, items * sizeof (int)) ;
  764. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  766. if (sfinfo.format != filetype)
  767. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  768. exit (1) ;
  769. } ;
  771. if (sfinfo.frames != items)
  772. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  773. exit (1) ;
  774. } ;
  776. if (sfinfo.channels != 1)
  777. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  778. exit (1) ;
  779. } ;
  781. check_log_buffer_or_die (file, __LINE__) ;
  783. test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
  785. for (k = 0 ; k < items ; k++)
  786. if (int_out [k] != int_in [k])
  787. { printf ("nnLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, int_out [k], int_in [k]) ;
  788. exit (1) ;
  789. } ;
  791. sf_close (file) ;
  793. /* Lite remove start */
  794. /*--------------------------------------------------------------------------
  795. ** Test sf_read/write_float ()
  796. */
  797. zero_count = 0 ;
  799. float_out = data_out.f ;
  800. float_in = data_in.f ;
  801. for (k = 0 ; k < items ; k++)
  802. { float_out [k] = (k * ((k % 2) ? 3333 : -3333)) ;
  803. zero_count = (fabs (float_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
  804. } ;
  806. if (zero_count > items / 4)
  807. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  808. exit (1) ;
  809. } ;
  811. sfinfo.samplerate = 44100 ;
  812. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  813. sfinfo.channels = 1 ;
  814. sfinfo.format = filetype ;
  816. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  818. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  820. test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
  822. sf_close (file) ;
  824. memset (float_in, 0, items * sizeof (float)) ;
  826. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  828. if (sfinfo.format != filetype)
  829. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  830. exit (1) ;
  831. } ;
  833. if (sfinfo.frames != items)
  834. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  835. exit (1) ;
  836. } ;
  838. if (sfinfo.channels != 1)
  839. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  840. exit (1) ;
  841. } ;
  843. check_log_buffer_or_die (file, __LINE__) ;
  845. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  847. test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
  849. for (k = 0 ; k < items ; k++)
  850. if (fabs (float_out [k] - float_in [k]) > 1e-10)
  851. { printf ("nnLine %d: float : Incorrect sample (#%d : %f => %f).n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
  852. exit (1) ;
  853. break ;
  854. } ;
  856. sf_close (file) ;
  858. /*--------------------------------------------------------------------------
  859. ** Test sf_read/write_double ()
  860. */
  861. zero_count = 0 ;
  863. double_out = data_out.d ;
  864. double_in = data_in.d ;
  865. for (k = 0 ; k < items ; k++)
  866. { double_out [k] = (k * ((k % 2) ? 3333 : -3333)) ;
  867. zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
  868. } ;
  870. if (zero_count > items / 4)
  871. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  872. exit (1) ;
  873. } ;
  875. sfinfo.samplerate = 44100 ;
  876. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  877. sfinfo.channels = 1 ;
  878. sfinfo.format = filetype ;
  880. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  882. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  884. test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
  886. sf_close (file) ;
  888. memset (double_in, 0, items * sizeof (double)) ;
  890. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  892. if (sfinfo.format != filetype)
  893. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  894. exit (1) ;
  895. } ;
  897. if (sfinfo.frames != items)
  898. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  899. exit (1) ;
  900. } ;
  902. if (sfinfo.channels != 1)
  903. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  904. exit (1) ;
  905. } ;
  907. check_log_buffer_or_die (file, __LINE__) ;
  909. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  911. test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
  913. for (k = 0 ; k < items ; k++)
  914. if (fabs (double_out [k] - double_in [k]) > 1e-10)
  915. { printf ("nnLine %d: double : Incorrect sample (#%d : %f => %f).n", __LINE__, k, double_out [k], double_in [k]) ;
  916. exit (1) ;
  917. } ;
  919. sf_close (file) ;
  920. /* Lite remove end */
  921. unlink (filename) ;
  923. puts ("ok") ;
  924. } /* pcm_test_bits_24 */
  926. static void
  927. pcm_test_bits_32 (const char *filename, int filetype, uint64_t hash)
  928. { SNDFILE *file ;
  929. SF_INFO sfinfo ;
  930. int k, items, zero_count ;
  931. short *short_out, *short_in ;
  932. int *int_out, *int_in ;
  933. /* Lite remove start */
  934. float *float_out, *float_in ;
  935. double *double_out, *double_in ;
  936. /* Lite remove end */
  938. print_test_name ("pcm_test_bits_32", filename) ;
  940. items = 1024 ;
  942. short_out = data_out.s ;
  943. short_in = data_in.s ;
  945. zero_count = 0 ;
  946. for (k = 0 ; k < items ; k++)
  947. { short_out [k] = (k * ((k % 2) ? 3 : -3)) ;
  948. zero_count = short_out [k] ? zero_count : zero_count + 1 ;
  949. } ;
  951. if (zero_count > items / 4)
  952. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  953. exit (1) ;
  954. } ;
  956. sfinfo.samplerate = 44100 ;
  957. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  958. sfinfo.channels = 1 ;
  959. sfinfo.format = filetype ;
  961. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  963. test_write_short_or_die (file, 0, short_out, items, __LINE__) ;
  965. sf_close (file) ;
  967. memset (short_in, 0, items * sizeof (short)) ;
  969. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  971. if (sfinfo.format != filetype)
  972. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  973. exit (1) ;
  974. } ;
  976. if (sfinfo.frames != items)
  977. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  978. exit (1) ;
  979. } ;
  981. if (sfinfo.channels != 1)
  982. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  983. exit (1) ;
  984. } ;
  986. check_log_buffer_or_die (file, __LINE__) ;
  988. test_read_short_or_die (file, 0, short_in, items, __LINE__) ;
  990. for (k = 0 ; k < items ; k++)
  991. if (short_out [k] != short_in [k])
  992. { printf ("nnLine %d: Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, short_out [k], short_in [k]) ;
  993. exit (1) ;
  994. } ;
  996. sf_close (file) ;
  998. /* Finally, check the file hash. */
  999. check_file_hash_or_die (filename, hash, __LINE__) ;
  1001. /*--------------------------------------------------------------------------
  1002. ** Test sf_read/write_int ()
  1003. */
  1004. zero_count = 0 ;
  1006. int_out = data_out.i ;
  1007. int_in = data_in.i ;
  1008. for (k = 0 ; k < items ; k++)
  1009. { int_out [k] = (k * ((k % 2) ? 333333 : -333333)) ;
  1010. zero_count = int_out [k] ? zero_count : zero_count + 1 ;
  1011. } ;
  1013. if (zero_count > items / 4)
  1014. { printf ("nnLine %d: too many zeros.n", __LINE__) ;
  1015. exit (1) ;
  1016. } ;
  1018. sfinfo.samplerate = 44100 ;
  1019. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1020. sfinfo.channels = 1 ;
  1021. sfinfo.format = filetype ;
  1023. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1025. test_write_int_or_die (file, 0, int_out, items, __LINE__) ;
  1027. sf_close (file) ;
  1029. memset (int_in, 0, items * sizeof (int)) ;
  1031. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1033. if (sfinfo.format != filetype)
  1034. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  1035. exit (1) ;
  1036. } ;
  1038. if (sfinfo.frames != items)
  1039. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1040. exit (1) ;
  1041. } ;
  1043. if (sfinfo.channels != 1)
  1044. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  1045. exit (1) ;
  1046. } ;
  1048. check_log_buffer_or_die (file, __LINE__) ;
  1050. test_read_int_or_die (file, 0, int_in, items, __LINE__) ;
  1052. for (k = 0 ; k < items ; k++)
  1053. if (int_out [k] != int_in [k])
  1054. { printf ("nnLine %d: int : Incorrect sample (#%d : 0x%x => 0x%x).n", __LINE__, k, int_out [k], int_in [k]) ;
  1055. exit (1) ;
  1056. } ;
  1058. sf_close (file) ;
  1060. /* Lite remove start */
  1061. /*--------------------------------------------------------------------------
  1062. ** Test sf_read/write_float ()
  1063. */
  1064. zero_count = 0 ;
  1066. float_out = data_out.f ;
  1067. float_in = data_in.f ;
  1068. for (k = 0 ; k < items ; k++)
  1069. { float_out [k] = (k * ((k % 2) ? 333333 : -333333)) ;
  1070. zero_count = (fabs (float_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
  1071. } ;
  1073. if (zero_count > items / 4)
  1074. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  1075. exit (1) ;
  1076. } ;
  1078. sfinfo.samplerate = 44100 ;
  1079. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1080. sfinfo.channels = 1 ;
  1081. sfinfo.format = filetype ;
  1083. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1085. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  1087. test_write_float_or_die (file, 0, float_out, items, __LINE__) ;
  1089. sf_close (file) ;
  1091. memset (float_in, 0, items * sizeof (float)) ;
  1093. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1095. if (sfinfo.format != filetype)
  1096. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  1097. exit (1) ;
  1098. } ;
  1100. if (sfinfo.frames != items)
  1101. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1102. exit (1) ;
  1103. } ;
  1105. if (sfinfo.channels != 1)
  1106. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  1107. exit (1) ;
  1108. } ;
  1110. check_log_buffer_or_die (file, __LINE__) ;
  1112. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  1114. test_read_float_or_die (file, 0, float_in, items, __LINE__) ;
  1116. for (k = 0 ; k < items ; k++)
  1117. if (fabs (float_out [k] - float_in [k]) > 1e-10)
  1118. { printf ("nnLine %d: float : Incorrect sample (#%d : %f => %f).n", __LINE__, k, (double) float_out [k], (double) float_in [k]) ;
  1119. exit (1) ;
  1120. break ;
  1121. } ;
  1123. sf_close (file) ;
  1125. /*--------------------------------------------------------------------------
  1126. ** Test sf_read/write_double ()
  1127. */
  1128. zero_count = 0 ;
  1130. double_out = data_out.d ;
  1131. double_in = data_in.d ;
  1132. for (k = 0 ; k < items ; k++)
  1133. { double_out [k] = (k * ((k % 2) ? 333333 : -333333)) ;
  1134. zero_count = (fabs (double_out [k]) > 1e-10) ? zero_count : zero_count + 1 ;
  1135. } ;
  1137. if (zero_count > items / 4)
  1138. { printf ("nnLine %d: too many zeros (%d/%d).n", __LINE__, zero_count, items) ;
  1139. exit (1) ;
  1140. } ;
  1142. sfinfo.samplerate = 44100 ;
  1143. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1144. sfinfo.channels = 1 ;
  1145. sfinfo.format = filetype ;
  1147. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1149. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  1151. test_write_double_or_die (file, 0, double_out, items, __LINE__) ;
  1153. sf_close (file) ;
  1155. memset (double_in, 0, items * sizeof (double)) ;
  1157. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1159. if (sfinfo.format != filetype)
  1160. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, filetype, sfinfo.format) ;
  1161. exit (1) ;
  1162. } ;
  1164. if (sfinfo.frames != items)
  1165. { printf ("nnLine %d: Incorrect number of frames in file. (%d => %ld)n", __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1166. exit (1) ;
  1167. } ;
  1169. if (sfinfo.channels != 1)
  1170. { printf ("nnLine %d: Incorrect number of channels in file.n", __LINE__) ;
  1171. exit (1) ;
  1172. } ;
  1174. check_log_buffer_or_die (file, __LINE__) ;
  1176. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  1178. test_read_double_or_die (file, 0, double_in, items, __LINE__) ;
  1180. for (k = 0 ; k < items ; k++)
  1181. if (fabs (double_out [k] - double_in [k]) > 1e-10)
  1182. { printf ("nnLine %d: double : Incorrect sample (#%d : %f => %f).n", __LINE__, k, double_out [k], double_in [k]) ;
  1183. exit (1) ;
  1184. } ;
  1186. sf_close (file) ;
  1187. /* Lite remove end */
  1188. unlink (filename) ;
  1190. puts ("ok") ;
  1191. } /* pcm_test_bits_32 */
  1195. /*==============================================================================
  1196. */
  1198. static void
  1199. pcm_test_float (const char *filename, int filetype, uint64_t hash, int replace_float)
  1200. { SNDFILE *file ;
  1201. SF_INFO sfinfo ;
  1202. int k, items, frames ;
  1203. int sign ;
  1204. double *data, error ;
  1206. print_test_name (replace_float ?  "pcm_test_float (replace)" : "pcm_test_float", filename) ;
  1208. items = BUFFER_SIZE ;
  1210. data = data_out.d ;
  1211. for (sign = 1, k = 0 ; k < items ; k++)
  1212. { data [k] = ((double) (k * sign)) / 100.0 ;
  1213. sign = (sign > 0) ? -1 : 1 ;
  1214. } ;
  1216. sfinfo.samplerate = 44100 ;
  1217. sfinfo.frames = items ;
  1218. sfinfo.channels = 1 ;
  1219. sfinfo.format = filetype ;
  1221. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1222. sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
  1223. if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
  1224. { printf ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1225. dump_log_buffer (file) ;
  1226. exit (1) ;
  1227. } ;
  1229. test_write_double_or_die (file, 0, data, items, __LINE__) ;
  1231. sf_close (file) ;
  1233. check_file_hash_or_die (filename, hash, __LINE__) ;
  1235. memset (data, 0, items * sizeof (double)) ;
  1237. if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1238. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1240. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1241. sf_command (file, SFC_TEST_IEEE_FLOAT_REPLACE, NULL, replace_float) ;
  1242. if (replace_float && string_in_log_buffer (file, "Using IEEE replacement") == 0)
  1243. { printf ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1244. dump_log_buffer (file) ;
  1245. exit (1) ;
  1246. } ;
  1248. if (sfinfo.format != filetype)
  1249. { printf ("nnError (%s:%d) Mono : Returned format incorrect (0x%08X => 0x%08X).n", __FILE__, __LINE__, filetype, sfinfo.format) ;
  1250. exit (1) ;
  1251. } ;
  1253. if (sfinfo.frames != items)
  1254. { printf ("nnError (%s:%d) Mono : Incorrect number of frames in file. (%d => %ld)n", __FILE__, __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1255. exit (1) ;
  1256. } ;
  1258. if (sfinfo.channels != 1)
  1259. { printf ("nnError (%s:%d) Mono : Incorrect number of channels in file.n", __FILE__, __LINE__) ;
  1260. exit (1) ;
  1261. } ;
  1263. check_log_buffer_or_die (file, __LINE__) ;
  1265. test_read_double_or_die (file, 0, data, items, __LINE__) ;
  1267. for (sign = -1, k = 0 ; k < items ; k++)
  1268. { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
  1269. if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
  1270. { printf ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1271. exit (1) ;
  1272. } ;
  1273. } ;
  1275. /* Seek to start of file. */
  1276. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1283. exit (1) ;
  1284. } ;
  1285. } ;
  1287. /* Seek to offset from start of file. */
  1288. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1295. exit (1) ;
  1296. } ;
  1297. } ;
  1299. /* Seek to offset from current position. */
  1300. test_seek_or_die (file, 6, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1307. exit (1) ;
  1308. } ;
  1309. } ;
  1311. /* Seek to offset from end of file. */
  1312. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1319. exit (1) ;
  1320. } ;
  1321. } ;
  1323. sf_close (file) ;
  1325. /* Now test Stereo. */
  1327. if ((filetype & SF_FORMAT_TYPEMASK) == SF_FORMAT_SVX) /* SVX is mono only */
  1328. { printf ("okn") ;
  1329. return ;
  1330. } ;
  1332. items = BUFFER_SIZE ;
  1334. data = data_out.d ;
  1335. for (sign = -1, k = 0 ; k < items ; k++)
  1336. data [k] = ((double) k) / 100.0 * (sign *= -1) ;
  1338. sfinfo.samplerate = 44100 ;
  1339. sfinfo.frames = items ;
  1340. sfinfo.channels = 2 ;
  1341. sfinfo.format = filetype ;
  1343. frames = items / sfinfo.channels ;
  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 ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1349. dump_log_buffer (file) ;
  1350. exit (1) ;
  1351. } ;
  1353. test_writef_double_or_die (file, 0, data, frames, __LINE__) ;
  1355. sf_close (file) ;
  1357. check_file_hash_or_die (filename, hash, __LINE__) ;
  1359. memset (data, 0, items * sizeof (double)) ;
  1361. if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1362. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  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 ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1368. dump_log_buffer (file) ;
  1369. exit (1) ;
  1370. } ;
  1372. if (sfinfo.format != filetype)
  1373. { printf ("nnError (%s:%d) Stereo : Returned format incorrect (0x%08X => 0x%08X).n", __FILE__, __LINE__, filetype, sfinfo.format) ;
  1374. exit (1) ;
  1375. } ;
  1377. if (sfinfo.frames != frames)
  1378. { printf ("nnError (%s:%d) Stereo : Incorrect number of frames in file. (%d => %ld)n", __FILE__, __LINE__, frames, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1379. exit (1) ;
  1380. } ;
  1382. if (sfinfo.channels != 2)
  1383. { printf ("nnError (%s:%d) Stereo : Incorrect number of channels in file.n", __FILE__, __LINE__) ;
  1384. exit (1) ;
  1385. } ;
  1387. check_log_buffer_or_die (file, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1394. exit (1) ;
  1395. } ;
  1396. } ;
  1398. /* Seek to start of file. */
  1399. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1406. exit (1) ;
  1407. } ;
  1408. } ;
  1410. /* Seek to offset from start of file. */
  1411. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1418. exit (1) ;
  1419. } ;
  1420. } ;
  1422. /* Seek to offset from current position. */
  1423. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1430. exit (1) ;
  1431. } ;
  1432. } ;
  1434. /* Seek to offset from end of file. */
  1435. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1442. exit (1) ;
  1443. } ;
  1444. } ;
  1446. sf_close (file) ;
  1448. printf ("okn") ;
  1449. unlink (filename) ;
  1450. } /* pcm_test_float */
  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 ;
  1460. /* This is the best test routine. Other should be brought up to this standard. */
  1462. print_test_name (replace_float ?  "pcm_test_double (replace)" : "pcm_test_double", filename) ;
  1464. items = BUFFER_SIZE ;
  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. } ;
  1472. sfinfo.samplerate = 44100 ;
  1473. sfinfo.frames = items ;
  1474. sfinfo.channels = 1 ;
  1475. sfinfo.format = filetype ;
  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 ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1481. dump_log_buffer (file) ;
  1482. exit (1) ;
  1483. } ;
  1485. test_write_double_or_die (file, 0, data, items, __LINE__) ;
  1487. sf_close (file) ;
  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
  1498. memset (data, 0, items * sizeof (double)) ;
  1500. if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1501. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  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 ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1507. dump_log_buffer (file) ;
  1508. exit (1) ;
  1509. } ;
  1511. if (sfinfo.format != filetype)
  1512. { printf ("nnError (%s:%d) Mono : Returned format incorrect (0x%08X => 0x%08X).n", __FILE__, __LINE__, filetype, sfinfo.format) ;
  1513. exit (1) ;
  1514. } ;
  1516. if (sfinfo.frames != items)
  1517. { printf ("nnError (%s:%d) Mono : Incorrect number of frames in file. (%d => %ld)n", __FILE__, __LINE__, items, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1518. exit (1) ;
  1519. } ;
  1521. if (sfinfo.channels != 1)
  1522. { printf ("nnError (%s:%d) Mono : Incorrect number of channels in file.n", __FILE__, __LINE__) ;
  1523. exit (1) ;
  1524. } ;
  1526. check_log_buffer_or_die (file, __LINE__) ;
  1528. test_read_double_or_die (file, 0, data, items, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1534. exit (1) ;
  1535. } ;
  1536. } ;
  1538. /* Seek to start of file. */
  1539. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1546. exit (1) ;
  1547. } ;
  1548. } ;
  1550. /* Seek to offset from start of file. */
  1551. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  1553. test_read_double_or_die (file, 0, data + 10, 4, __LINE__) ;
  1555. test_seek_or_die (file, 0, SEEK_CUR, 14, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1561. exit (1) ;
  1562. } ;
  1563. } ;
  1565. /* Seek to offset from current position. */
  1566. test_seek_or_die (file, 6, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1573. exit (1) ;
  1574. } ;
  1575. } ;
  1577. /* Seek to offset from end of file. */
  1578. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Mono : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1585. exit (1) ;
  1586. } ;
  1587. } ;
  1589. sf_close (file) ;
  1591. /* Now test Stereo. */
  1593. if ((filetype & SF_FORMAT_TYPEMASK) == SF_FORMAT_SVX) /* SVX is mono only */
  1594. { printf ("okn") ;
  1595. return ;
  1596. } ;
  1598. items = BUFFER_SIZE ;
  1600. data = data_out.d ;
  1601. for (sign = -1, k = 0 ; k < items ; k++)
  1602. data [k] = ((double) k) / 100.0 * (sign *= -1) ;
  1604. sfinfo.samplerate = 44100 ;
  1605. sfinfo.frames = items ;
  1606. sfinfo.channels = 2 ;
  1607. sfinfo.format = filetype ;
  1609. frames = items / sfinfo.channels ;
  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 ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1615. dump_log_buffer (file) ;
  1616. exit (1) ;
  1617. } ;
  1619. test_writef_double_or_die (file, 0, data, frames, __LINE__) ;
  1621. sf_close (file) ;
  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
  1632. memset (data, 0, items * sizeof (double)) ;
  1634. if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1635. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  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 ("nnLine %d : Float replacement code not working.nn", __LINE__) ;
  1641. dump_log_buffer (file) ;
  1642. exit (1) ;
  1643. } ;
  1645. if (sfinfo.format != filetype)
  1646. { printf ("nnError (%s:%d) Stereo : Returned format incorrect (0x%08X => 0x%08X).n", __FILE__, __LINE__, filetype, sfinfo.format) ;
  1647. exit (1) ;
  1648. } ;
  1650. if (sfinfo.frames != frames)
  1651. { printf ("nnError (%s:%d) Stereo : Incorrect number of frames in file. (%d => %ld)n", __FILE__, __LINE__, frames, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1652. exit (1) ;
  1653. } ;
  1655. if (sfinfo.channels != 2)
  1656. { printf ("nnError (%s:%d) Stereo : Incorrect number of channels in file.n", __FILE__, __LINE__) ;
  1657. exit (1) ;
  1658. } ;
  1660. check_log_buffer_or_die (file, __LINE__) ;
  1662. test_readf_double_or_die (file, 0, data, frames, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1668. exit (1) ;
  1669. } ;
  1670. } ;
  1672. /* Seek to start of file. */
  1673. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1680. exit (1) ;
  1681. } ;
  1682. } ;
  1684. /* Seek to offset from start of file. */
  1685. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1692. exit (1) ;
  1693. } ;
  1694. } ;
  1696. /* Seek to offset from current position. */
  1697. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1704. exit (1) ;
  1705. } ;
  1706. } ;
  1708. /* Seek to offset from end of file. */
  1709. test_seek_or_die (file, -1 * (sfinfo.frames -10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  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 ("nnError (%s:%d) Stereo : Incorrect sample (#%d : %f => %f).n", __FILE__, __LINE__, k, ((double) k) / 100.0, data [k]) ;
  1716. exit (1) ;
  1717. } ;
  1718. } ;
  1720. sf_close (file) ;
  1722. printf ("okn") ;
  1723. unlink (filename) ;
  1724. } /* pcm_test_double */
  1726. /*==============================================================================
  1727. */