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

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

Audio

开发平台：

Unix_Linux

scale_clip_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>
  25. #if HAVE_UNISTD_H
  26. #include <unistd.h>
  27. #endif
  29. #include <math.h>
  31. #include <sndfile.h>
  33. #include "utils.h"
  35. #ifndef M_PI
  36. #define M_PI 3.14159265358979323846264338
  37. #endif
  39. #define HALF_BUFFER_SIZE (1 << 12)
  40. #define BUFFER_SIZE (2 * HALF_BUFFER_SIZE)
  42. #define SINE_AMP 1.1
  43. #define MAX_ERROR 0.0202
  46. static void flt_scale_clip_test_16 (const char *filename, int filetype, float maxval) ;
  47. static void flt_scale_clip_test_24 (const char *filename, int filetype, float maxval) ;
  48. static void flt_scale_clip_test_32 (const char *filename, int filetype, float maxval) ;
  49. static void flt_scale_clip_test_08 (const char *filename, int filetype, float maxval) ;
  51. static void dbl_scale_clip_test_16 (const char *filename, int filetype, float maxval) ;
  52. static void dbl_scale_clip_test_24 (const char *filename, int filetype, float maxval) ;
  53. static void dbl_scale_clip_test_32 (const char *filename, int filetype, float maxval) ;
  54. static void dbl_scale_clip_test_08 (const char *filename, int filetype, float maxval) ;
  58. static void flt_short_clip_read_test (const char *filename, int filetype) ;
  59. static void flt_int_clip_read_test (const char *filename, int filetype) ;
  61. static void dbl_short_clip_read_test (const char *filename, int filetype) ;
  62. static void dbl_int_clip_read_test (const char *filename, int filetype) ;
  66. static void short_flt_scale_write_test (const char *filename, int filetype) ;
  67. static void short_dbl_scale_write_test (const char *filename, int filetype) ;
  69. static void int_flt_scale_write_test (const char *filename, int filetype) ;
  70. static void int_dbl_scale_write_test (const char *filename, int filetype) ;
  73. typedef union
  74. { double dbl [BUFFER_SIZE] ;
  75. float flt [BUFFER_SIZE] ;
  76. int i [BUFFER_SIZE] ;
  77. short s [BUFFER_SIZE] ;
  78. } BUFFER ;
  80. /* Data buffer. */
  81. static BUFFER buffer_out ;
  82. static BUFFER buffer_in ;
  84. int
  85. main (void)
  86. {
  87. flt_scale_clip_test_08 ("scale_clip_s8.au", SF_FORMAT_AU | SF_FORMAT_PCM_S8, 1.0 * 0x80) ;
  88. flt_scale_clip_test_08 ("scale_clip_u8.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8, 1.0 * 0x80) ;
  90. dbl_scale_clip_test_08 ("scale_clip_s8.au", SF_FORMAT_AU | SF_FORMAT_PCM_S8, 1.0 * 0x80) ;
  91. dbl_scale_clip_test_08 ("scale_clip_u8.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8, 1.0 * 0x80) ;
  93. /*
  94. ** Now use SF_FORMAT_AU where possible because it allows both
  95. ** big and little endian files.
  96. */
  98. flt_scale_clip_test_16 ("scale_clip_be16.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
  99. flt_scale_clip_test_16 ("scale_clip_le16.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
  100. flt_scale_clip_test_24 ("scale_clip_be24.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
  101. flt_scale_clip_test_24 ("scale_clip_le24.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
  102. flt_scale_clip_test_32 ("scale_clip_be32.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
  103. flt_scale_clip_test_32 ("scale_clip_le32.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
  105. dbl_scale_clip_test_16 ("scale_clip_be16.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
  106. dbl_scale_clip_test_16 ("scale_clip_le16.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
  107. dbl_scale_clip_test_24 ("scale_clip_be24.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
  108. dbl_scale_clip_test_24 ("scale_clip_le24.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
  109. dbl_scale_clip_test_32 ("scale_clip_be32.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
  110. dbl_scale_clip_test_32 ("scale_clip_le32.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
  112. flt_short_clip_read_test ("flt_short.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
  113. flt_int_clip_read_test ("flt_int.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
  114. dbl_short_clip_read_test ("dbl_short.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
  115. dbl_int_clip_read_test ("dbl_int.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
  117. short_flt_scale_write_test ("short_flt.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
  118. int_flt_scale_write_test ("int_flt.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
  119. short_dbl_scale_write_test ("short_dbl.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
  120. int_dbl_scale_write_test ("int_dbl.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
  122. return 0 ;
  123. } /* main */
  125. /*============================================================================================
  126. ** Here are the test functions.
  127. */
  130. static void
  131. flt_scale_clip_test_16 (const char *filename, int filetype, float maxval)
  132. { SNDFILE *file ;
  133. SF_INFO sfinfo ;
  134. int k ;
  135. float *data_out, *data_in ;
  136. double diff, clip_max_diff ;
  138. print_test_name ("flt_scale_clip_test_16", filename) ;
  140. data_out = buffer_out.flt ;
  141. data_in = buffer_in.flt ;
  143. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  144. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  145. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  146. } ;
  148. sfinfo.samplerate = 44100 ;
  149. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  150. sfinfo.channels = 1 ;
  151. sfinfo.format = filetype ;
  153. /*
  154. ** Write two versions of the data:
  155. ** normalized and clipped
  156. ** un-normalized and clipped.
  157. */
  159. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  160. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  161. test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  162. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  163. test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  164. sf_close (file) ;
  166. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  168. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  170. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  172. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  173. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  174. exit (1) ;
  175. } ;
  177. if (sfinfo.frames != BUFFER_SIZE)
  178. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  179. exit (1) ;
  180. } ;
  182. if (sfinfo.channels != 1)
  183. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  184. exit (1) ;
  185. } ;
  187. check_log_buffer_or_die (file, __LINE__) ;
  189. test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  190. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  191. test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  192. sf_close (file) ;
  194. /* Check normalized version. */
  195. clip_max_diff = 0.0 ;
  196. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  197. { if (fabs (data_in [k]) > 1.0)
  198. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  199. exit (1) ;
  200. } ;
  202. if (data_out [k] * data_in [k] < 0.0)
  203. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  204. exit (1) ;
  205. } ;
  207. if (fabs (data_out [k]) > 1.0)
  208. continue ;
  210. diff = fabs (data_out [k] - data_in [k]) ;
  211. if (diff > clip_max_diff)
  212. clip_max_diff = diff ;
  213. } ;
  215. if (clip_max_diff < 1e-20)
  216. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  217. exit (1) ;
  218. } ;
  220. if (clip_max_diff > 1.0 / 0x8000)
  221. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  222. exit (1) ;
  223. } ;
  225. /* Check the un-normalized data. */
  226. clip_max_diff = 0.0 ;
  227. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  228. { if (fabs (data_in [k]) > maxval)
  229. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  230. exit (1) ;
  231. } ;
  233. if (data_out [k] * data_in [k] < 0.0)
  234. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  235. exit (1) ;
  236. } ;
  238. if (fabs (data_out [k]) > maxval)
  239. continue ;
  241. diff = fabs (data_out [k] - data_in [k]) ;
  242. if (diff > clip_max_diff)
  243. clip_max_diff = diff ;
  244. } ;
  246. if (clip_max_diff < 1e-20)
  247. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  248. exit (1) ;
  249. } ;
  251. if (clip_max_diff > 1.0)
  252. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  253. exit (1) ;
  254. } ;
  256. printf ("okn") ;
  257. unlink (filename) ;
  258. } /* flt_scale_clip_test_16 */
  260. static void
  261. flt_scale_clip_test_24 (const char *filename, int filetype, float maxval)
  262. { SNDFILE *file ;
  263. SF_INFO sfinfo ;
  264. int k ;
  265. float *data_out, *data_in ;
  266. double diff, clip_max_diff ;
  268. print_test_name ("flt_scale_clip_test_24", filename) ;
  270. data_out = buffer_out.flt ;
  271. data_in = buffer_in.flt ;
  273. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  274. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  275. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  276. } ;
  278. sfinfo.samplerate = 44100 ;
  279. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  280. sfinfo.channels = 1 ;
  281. sfinfo.format = filetype ;
  283. /*
  284. ** Write two versions of the data:
  285. ** normalized and clipped
  286. ** un-normalized and clipped.
  287. */
  289. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  290. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  291. test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  292. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  293. test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  294. sf_close (file) ;
  296. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  298. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  300. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  302. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  303. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  304. exit (1) ;
  305. } ;
  307. if (sfinfo.frames != BUFFER_SIZE)
  308. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  309. exit (1) ;
  310. } ;
  312. if (sfinfo.channels != 1)
  313. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  314. exit (1) ;
  315. } ;
  317. check_log_buffer_or_die (file, __LINE__) ;
  319. test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  320. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  321. test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  322. sf_close (file) ;
  324. /* Check normalized version. */
  325. clip_max_diff = 0.0 ;
  326. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  327. { if (fabs (data_in [k]) > 1.0)
  328. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  329. exit (1) ;
  330. } ;
  332. if (data_out [k] * data_in [k] < 0.0)
  333. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  334. exit (1) ;
  335. } ;
  337. if (fabs (data_out [k]) > 1.0)
  338. continue ;
  340. diff = fabs (data_out [k] - data_in [k]) ;
  341. if (diff > clip_max_diff)
  342. clip_max_diff = diff ;
  343. } ;
  345. if (clip_max_diff < 1e-20)
  346. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  347. exit (1) ;
  348. } ;
  350. if (clip_max_diff > 1.0 / 0x800000)
  351. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  352. exit (1) ;
  353. } ;
  355. /* Check the un-normalized data. */
  356. clip_max_diff = 0.0 ;
  357. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  358. { if (fabs (data_in [k]) > maxval)
  359. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  360. exit (1) ;
  361. } ;
  363. if (data_out [k] * data_in [k] < 0.0)
  364. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  365. exit (1) ;
  366. } ;
  368. if (fabs (data_out [k]) > maxval)
  369. continue ;
  371. diff = fabs (data_out [k] - data_in [k]) ;
  372. if (diff > clip_max_diff)
  373. clip_max_diff = diff ;
  374. } ;
  376. if (clip_max_diff < 1e-20)
  377. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  378. exit (1) ;
  379. } ;
  381. if (clip_max_diff > 1.0)
  382. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  383. exit (1) ;
  384. } ;
  386. printf ("okn") ;
  387. unlink (filename) ;
  388. } /* flt_scale_clip_test_24 */
  390. static void
  391. flt_scale_clip_test_32 (const char *filename, int filetype, float maxval)
  392. { SNDFILE *file ;
  393. SF_INFO sfinfo ;
  394. int k ;
  395. float *data_out, *data_in ;
  396. double diff, clip_max_diff ;
  398. print_test_name ("flt_scale_clip_test_32", filename) ;
  400. data_out = buffer_out.flt ;
  401. data_in = buffer_in.flt ;
  403. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  404. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  405. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  406. } ;
  408. sfinfo.samplerate = 44100 ;
  409. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  410. sfinfo.channels = 1 ;
  411. sfinfo.format = filetype ;
  413. /*
  414. ** Write two versions of the data:
  415. ** normalized and clipped
  416. ** un-normalized and clipped.
  417. */
  419. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  420. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  421. test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  422. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  423. test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  424. sf_close (file) ;
  426. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  428. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  430. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  432. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  433. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  434. exit (1) ;
  435. } ;
  437. if (sfinfo.frames != BUFFER_SIZE)
  438. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  439. exit (1) ;
  440. } ;
  442. if (sfinfo.channels != 1)
  443. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  444. exit (1) ;
  445. } ;
  447. check_log_buffer_or_die (file, __LINE__) ;
  449. test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  450. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  451. test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  452. sf_close (file) ;
  454. /* Check normalized version. */
  455. clip_max_diff = 0.0 ;
  456. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  457. { if (fabs (data_in [k]) > 1.0)
  458. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  459. exit (1) ;
  460. } ;
  462. if (data_out [k] * data_in [k] < 0.0)
  463. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  464. exit (1) ;
  465. } ;
  467. if (fabs (data_out [k]) > 1.0)
  468. continue ;
  470. diff = fabs (data_out [k] - data_in [k]) ;
  471. if (diff > clip_max_diff)
  472. clip_max_diff = diff ;
  473. } ;
  475. if (clip_max_diff < 1e-20)
  476. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  477. exit (1) ;
  478. } ;
  480. if (clip_max_diff > 1.0 / 0x80000000)
  481. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  482. exit (1) ;
  483. } ;
  485. /* Check the un-normalized data. */
  486. clip_max_diff = 0.0 ;
  487. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  488. { if (fabs (data_in [k]) > maxval)
  489. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  490. exit (1) ;
  491. } ;
  493. if (data_out [k] * data_in [k] < 0.0)
  494. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  495. exit (1) ;
  496. } ;
  498. if (fabs (data_out [k]) > maxval)
  499. continue ;
  501. diff = fabs (data_out [k] - data_in [k]) ;
  502. if (diff > clip_max_diff)
  503. clip_max_diff = diff ;
  504. } ;
  506. if (clip_max_diff < 1e-20)
  507. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  508. exit (1) ;
  509. } ;
  511. if (clip_max_diff > 1.0)
  512. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  513. exit (1) ;
  514. } ;
  516. printf ("okn") ;
  517. unlink (filename) ;
  518. } /* flt_scale_clip_test_32 */
  520. static void
  521. flt_scale_clip_test_08 (const char *filename, int filetype, float maxval)
  522. { SNDFILE *file ;
  523. SF_INFO sfinfo ;
  524. int k ;
  525. float *data_out, *data_in ;
  526. double diff, clip_max_diff ;
  528. print_test_name ("flt_scale_clip_test_08", filename) ;
  530. data_out = buffer_out.flt ;
  531. data_in = buffer_in.flt ;
  533. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  534. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  535. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  536. } ;
  538. sfinfo.samplerate = 44100 ;
  539. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  540. sfinfo.channels = 1 ;
  541. sfinfo.format = filetype ;
  543. /*
  544. ** Write two versions of the data:
  545. ** normalized and clipped
  546. ** un-normalized and clipped.
  547. */
  549. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  550. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  551. test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  552. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  553. test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  554. sf_close (file) ;
  556. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  558. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  560. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  562. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  563. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  564. exit (1) ;
  565. } ;
  567. if (sfinfo.frames != BUFFER_SIZE)
  568. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  569. exit (1) ;
  570. } ;
  572. if (sfinfo.channels != 1)
  573. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  574. exit (1) ;
  575. } ;
  577. check_log_buffer_or_die (file, __LINE__) ;
  579. test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  580. sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
  581. test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  582. sf_close (file) ;
  584. /* Check normalized version. */
  585. clip_max_diff = 0.0 ;
  586. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  587. { if (fabs (data_in [k]) > 1.0)
  588. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  589. exit (1) ;
  590. } ;
  592. if (data_out [k] * data_in [k] < 0.0)
  593. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  594. exit (1) ;
  595. } ;
  597. if (fabs (data_out [k]) > 1.0)
  598. continue ;
  600. diff = fabs (data_out [k] - data_in [k]) ;
  601. if (diff > clip_max_diff)
  602. clip_max_diff = diff ;
  603. } ;
  605. if (clip_max_diff < 1e-20)
  606. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  607. exit (1) ;
  608. } ;
  610. if (clip_max_diff > 1.0 / 0x80)
  611. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  612. exit (1) ;
  613. } ;
  615. /* Check the un-normalized data. */
  616. clip_max_diff = 0.0 ;
  617. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  618. { if (fabs (data_in [k]) > maxval)
  619. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  620. exit (1) ;
  621. } ;
  623. if (data_out [k] * data_in [k] < 0.0)
  624. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  625. exit (1) ;
  626. } ;
  628. if (fabs (data_out [k]) > maxval)
  629. continue ;
  631. diff = fabs (data_out [k] - data_in [k]) ;
  632. if (diff > clip_max_diff)
  633. clip_max_diff = diff ;
  634. } ;
  636. if (clip_max_diff < 1e-20)
  637. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  638. exit (1) ;
  639. } ;
  641. if (clip_max_diff > 1.0)
  642. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  643. exit (1) ;
  644. } ;
  646. printf ("okn") ;
  647. unlink (filename) ;
  648. } /* flt_scale_clip_test_08 */
  652. static void
  653. dbl_scale_clip_test_16 (const char *filename, int filetype, float maxval)
  654. { SNDFILE *file ;
  655. SF_INFO sfinfo ;
  656. int k ;
  657. double *data_out, *data_in ;
  658. double diff, clip_max_diff ;
  660. print_test_name ("dbl_scale_clip_test_16", filename) ;
  662. data_out = buffer_out.dbl ;
  663. data_in = buffer_in.dbl ;
  665. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  666. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  667. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  668. } ;
  670. sfinfo.samplerate = 44100 ;
  671. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  672. sfinfo.channels = 1 ;
  673. sfinfo.format = filetype ;
  675. /*
  676. ** Write two versions of the data:
  677. ** normalized and clipped
  678. ** un-normalized and clipped.
  679. */
  681. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  682. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  683. test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  684. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  685. test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  686. sf_close (file) ;
  688. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  690. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  692. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  694. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  695. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  696. exit (1) ;
  697. } ;
  699. if (sfinfo.frames != BUFFER_SIZE)
  700. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  701. exit (1) ;
  702. } ;
  704. if (sfinfo.channels != 1)
  705. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  706. exit (1) ;
  707. } ;
  709. check_log_buffer_or_die (file, __LINE__) ;
  711. test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  712. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  713. test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  714. sf_close (file) ;
  716. /* Check normalized version. */
  717. clip_max_diff = 0.0 ;
  718. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  719. { if (fabs (data_in [k]) > 1.0)
  720. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  721. exit (1) ;
  722. } ;
  724. if (data_out [k] * data_in [k] < 0.0)
  725. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  726. exit (1) ;
  727. } ;
  729. if (fabs (data_out [k]) > 1.0)
  730. continue ;
  732. diff = fabs (data_out [k] - data_in [k]) ;
  733. if (diff > clip_max_diff)
  734. clip_max_diff = diff ;
  735. } ;
  737. if (clip_max_diff < 1e-20)
  738. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  739. exit (1) ;
  740. } ;
  742. if (clip_max_diff > 1.0 / 0x8000)
  743. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  744. exit (1) ;
  745. } ;
  747. /* Check the un-normalized data. */
  748. clip_max_diff = 0.0 ;
  749. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  750. { if (fabs (data_in [k]) > maxval)
  751. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  752. exit (1) ;
  753. } ;
  755. if (data_out [k] * data_in [k] < 0.0)
  756. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  757. exit (1) ;
  758. } ;
  760. if (fabs (data_out [k]) > maxval)
  761. continue ;
  763. diff = fabs (data_out [k] - data_in [k]) ;
  764. if (diff > clip_max_diff)
  765. clip_max_diff = diff ;
  766. } ;
  768. if (clip_max_diff < 1e-20)
  769. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  770. exit (1) ;
  771. } ;
  773. if (clip_max_diff > 1.0)
  774. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  775. exit (1) ;
  776. } ;
  778. printf ("okn") ;
  779. unlink (filename) ;
  780. } /* dbl_scale_clip_test_16 */
  782. static void
  783. dbl_scale_clip_test_24 (const char *filename, int filetype, float maxval)
  784. { SNDFILE *file ;
  785. SF_INFO sfinfo ;
  786. int k ;
  787. double *data_out, *data_in ;
  788. double diff, clip_max_diff ;
  790. print_test_name ("dbl_scale_clip_test_24", filename) ;
  792. data_out = buffer_out.dbl ;
  793. data_in = buffer_in.dbl ;
  795. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  796. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  797. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  798. } ;
  800. sfinfo.samplerate = 44100 ;
  801. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  802. sfinfo.channels = 1 ;
  803. sfinfo.format = filetype ;
  805. /*
  806. ** Write two versions of the data:
  807. ** normalized and clipped
  808. ** un-normalized and clipped.
  809. */
  811. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  812. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  813. test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  814. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  815. test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  816. sf_close (file) ;
  818. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  820. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  822. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  824. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  825. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  826. exit (1) ;
  827. } ;
  829. if (sfinfo.frames != BUFFER_SIZE)
  830. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  831. exit (1) ;
  832. } ;
  834. if (sfinfo.channels != 1)
  835. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  836. exit (1) ;
  837. } ;
  839. check_log_buffer_or_die (file, __LINE__) ;
  841. test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  842. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  843. test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  844. sf_close (file) ;
  846. /* Check normalized version. */
  847. clip_max_diff = 0.0 ;
  848. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  849. { if (fabs (data_in [k]) > 1.0)
  850. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  851. exit (1) ;
  852. } ;
  854. if (data_out [k] * data_in [k] < 0.0)
  855. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  856. exit (1) ;
  857. } ;
  859. if (fabs (data_out [k]) > 1.0)
  860. continue ;
  862. diff = fabs (data_out [k] - data_in [k]) ;
  863. if (diff > clip_max_diff)
  864. clip_max_diff = diff ;
  865. } ;
  867. if (clip_max_diff < 1e-20)
  868. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  869. exit (1) ;
  870. } ;
  872. if (clip_max_diff > 1.0 / 0x800000)
  873. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  874. exit (1) ;
  875. } ;
  877. /* Check the un-normalized data. */
  878. clip_max_diff = 0.0 ;
  879. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  880. { if (fabs (data_in [k]) > maxval)
  881. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  882. exit (1) ;
  883. } ;
  885. if (data_out [k] * data_in [k] < 0.0)
  886. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  887. exit (1) ;
  888. } ;
  890. if (fabs (data_out [k]) > maxval)
  891. continue ;
  893. diff = fabs (data_out [k] - data_in [k]) ;
  894. if (diff > clip_max_diff)
  895. clip_max_diff = diff ;
  896. } ;
  898. if (clip_max_diff < 1e-20)
  899. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  900. exit (1) ;
  901. } ;
  903. if (clip_max_diff > 1.0)
  904. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  905. exit (1) ;
  906. } ;
  908. printf ("okn") ;
  909. unlink (filename) ;
  910. } /* dbl_scale_clip_test_24 */
  912. static void
  913. dbl_scale_clip_test_32 (const char *filename, int filetype, float maxval)
  914. { SNDFILE *file ;
  915. SF_INFO sfinfo ;
  916. int k ;
  917. double *data_out, *data_in ;
  918. double diff, clip_max_diff ;
  920. print_test_name ("dbl_scale_clip_test_32", filename) ;
  922. data_out = buffer_out.dbl ;
  923. data_in = buffer_in.dbl ;
  925. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  926. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  927. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  928. } ;
  930. sfinfo.samplerate = 44100 ;
  931. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  932. sfinfo.channels = 1 ;
  933. sfinfo.format = filetype ;
  935. /*
  936. ** Write two versions of the data:
  937. ** normalized and clipped
  938. ** un-normalized and clipped.
  939. */
  941. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  942. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  943. test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  944. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  945. test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  946. sf_close (file) ;
  948. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  950. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  952. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  954. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  955. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  956. exit (1) ;
  957. } ;
  959. if (sfinfo.frames != BUFFER_SIZE)
  960. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  961. exit (1) ;
  962. } ;
  964. if (sfinfo.channels != 1)
  965. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  966. exit (1) ;
  967. } ;
  969. check_log_buffer_or_die (file, __LINE__) ;
  971. test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  972. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  973. test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  974. sf_close (file) ;
  976. /* Check normalized version. */
  977. clip_max_diff = 0.0 ;
  978. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  979. { if (fabs (data_in [k]) > 1.0)
  980. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  981. exit (1) ;
  982. } ;
  984. if (data_out [k] * data_in [k] < 0.0)
  985. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  986. exit (1) ;
  987. } ;
  989. if (fabs (data_out [k]) > 1.0)
  990. continue ;
  992. diff = fabs (data_out [k] - data_in [k]) ;
  993. if (diff > clip_max_diff)
  994. clip_max_diff = diff ;
  995. } ;
  997. if (clip_max_diff < 1e-20)
  998. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  999. exit (1) ;
  1000. } ;
  1002. if (clip_max_diff > 1.0 / 0x80000000)
  1003. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  1004. exit (1) ;
  1005. } ;
  1007. /* Check the un-normalized data. */
  1008. clip_max_diff = 0.0 ;
  1009. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  1010. { if (fabs (data_in [k]) > maxval)
  1011. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  1012. exit (1) ;
  1013. } ;
  1015. if (data_out [k] * data_in [k] < 0.0)
  1016. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  1017. exit (1) ;
  1018. } ;
  1020. if (fabs (data_out [k]) > maxval)
  1021. continue ;
  1023. diff = fabs (data_out [k] - data_in [k]) ;
  1024. if (diff > clip_max_diff)
  1025. clip_max_diff = diff ;
  1026. } ;
  1028. if (clip_max_diff < 1e-20)
  1029. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  1030. exit (1) ;
  1031. } ;
  1033. if (clip_max_diff > 1.0)
  1034. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  1035. exit (1) ;
  1036. } ;
  1038. printf ("okn") ;
  1039. unlink (filename) ;
  1040. } /* dbl_scale_clip_test_32 */
  1042. static void
  1043. dbl_scale_clip_test_08 (const char *filename, int filetype, float maxval)
  1044. { SNDFILE *file ;
  1045. SF_INFO sfinfo ;
  1046. int k ;
  1047. double *data_out, *data_in ;
  1048. double diff, clip_max_diff ;
  1050. print_test_name ("dbl_scale_clip_test_08", filename) ;
  1052. data_out = buffer_out.dbl ;
  1053. data_in = buffer_in.dbl ;
  1055. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  1056. { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
  1057. data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
  1058. } ;
  1060. sfinfo.samplerate = 44100 ;
  1061. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1062. sfinfo.channels = 1 ;
  1063. sfinfo.format = filetype ;
  1065. /*
  1066. ** Write two versions of the data:
  1067. ** normalized and clipped
  1068. ** un-normalized and clipped.
  1069. */
  1071. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1072. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  1073. test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
  1074. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  1075. test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  1076. sf_close (file) ;
  1078. memset (&buffer_in, 0, sizeof (buffer_in)) ;
  1080. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1082. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1084. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1085. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1086. exit (1) ;
  1087. } ;
  1089. if (sfinfo.frames != BUFFER_SIZE)
  1090. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1091. exit (1) ;
  1092. } ;
  1094. if (sfinfo.channels != 1)
  1095. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1096. exit (1) ;
  1097. } ;
  1099. check_log_buffer_or_die (file, __LINE__) ;
  1101. test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
  1102. sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
  1103. test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
  1104. sf_close (file) ;
  1106. /* Check normalized version. */
  1107. clip_max_diff = 0.0 ;
  1108. for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
  1109. { if (fabs (data_in [k]) > 1.0)
  1110. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  1111. exit (1) ;
  1112. } ;
  1114. if (data_out [k] * data_in [k] < 0.0)
  1115. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  1116. exit (1) ;
  1117. } ;
  1119. if (fabs (data_out [k]) > 1.0)
  1120. continue ;
  1122. diff = fabs (data_out [k] - data_in [k]) ;
  1123. if (diff > clip_max_diff)
  1124. clip_max_diff = diff ;
  1125. } ;
  1127. if (clip_max_diff < 1e-20)
  1128. { printf ("nnLine %d: Clipping difference (%e) too small (normalized).nn", __LINE__, clip_max_diff) ;
  1129. exit (1) ;
  1130. } ;
  1132. if (clip_max_diff > 1.0 / 0x80)
  1133. { printf ("nnLine %d: Clipping difference (%e) too large (normalized).nn", __LINE__, clip_max_diff) ;
  1134. exit (1) ;
  1135. } ;
  1137. /* Check the un-normalized data. */
  1138. clip_max_diff = 0.0 ;
  1139. for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
  1140. { if (fabs (data_in [k]) > maxval)
  1141. { printf ("nnLine %d: Input sample %d/%d (%f) has not been clipped.nn", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
  1142. exit (1) ;
  1143. } ;
  1145. if (data_out [k] * data_in [k] < 0.0)
  1146. { printf ("nnLine %d: Data wrap around at index %d/%d.nn", __LINE__, k, BUFFER_SIZE) ;
  1147. exit (1) ;
  1148. } ;
  1150. if (fabs (data_out [k]) > maxval)
  1151. continue ;
  1153. diff = fabs (data_out [k] - data_in [k]) ;
  1154. if (diff > clip_max_diff)
  1155. clip_max_diff = diff ;
  1156. } ;
  1158. if (clip_max_diff < 1e-20)
  1159. { printf ("nnLine %d: Clipping difference (%e) too small (un-normalized).nn", __LINE__, clip_max_diff) ;
  1160. exit (1) ;
  1161. } ;
  1163. if (clip_max_diff > 1.0)
  1164. { printf ("nnLine %d: Clipping difference (%e) too large (un-normalised).nn", __LINE__, clip_max_diff) ;
  1165. exit (1) ;
  1166. } ;
  1168. printf ("okn") ;
  1169. unlink (filename) ;
  1170. } /* dbl_scale_clip_test_08 */
  1175. /*==============================================================================
  1176. */
  1179. static void flt_short_clip_read_test (const char *filename, int filetype)
  1180. { SNDFILE *file ;
  1181. SF_INFO sfinfo ;
  1182. float *data_out ;
  1183. short *data_in, max_value ;
  1184. int k ;
  1186. print_test_name ("flt_short_clip_read_test", filename) ;
  1188. data_out = buffer_out.flt ;
  1189. data_in = buffer_in.s ;
  1191. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1192. data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
  1193. data_out [BUFFER_SIZE / 8] = 1.0 ;
  1194. data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
  1195. data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
  1196. data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
  1198. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1199. sfinfo.samplerate = 44100 ;
  1200. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1201. sfinfo.channels = 1 ;
  1202. sfinfo.format = filetype ;
  1204. /* Save unclipped data to the file. */
  1205. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1206. test_write_float_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1207. sf_close (file) ;
  1209. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1211. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1212. sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
  1214. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1216. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1217. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1218. exit (1) ;
  1219. } ;
  1221. if (sfinfo.frames != BUFFER_SIZE)
  1222. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1223. exit (1) ;
  1224. } ;
  1226. if (sfinfo.channels != 1)
  1227. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1228. exit (1) ;
  1229. } ;
  1231. check_log_buffer_or_die (file, __LINE__) ;
  1233. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  1234. test_read_short_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1235. /*-sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;-*/
  1236. sf_close (file) ;
  1238. /* Check the first half. */
  1239. max_value = 0 ;
  1240. for (k = 0 ; k < sfinfo.frames ; k++)
  1241. { /* Check if data_out has different sign from data_in. */
  1242. if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
  1243. { printf ("nnLine %d: Data wrap around at index %d/%d  (%f -> %d).nn", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
  1244. exit (1) ;
  1245. } ;
  1246. max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
  1247. } ;
  1249. unlink (filename) ;
  1250. puts ("ok") ;
  1251. } /* flt_short_clip_read_test */
  1252. static void flt_int_clip_read_test (const char *filename, int filetype)
  1253. { SNDFILE *file ;
  1254. SF_INFO sfinfo ;
  1255. float *data_out ;
  1256. int *data_in, max_value ;
  1257. int k ;
  1259. print_test_name ("flt_int_clip_read_test", filename) ;
  1261. data_out = buffer_out.flt ;
  1262. data_in = buffer_in.i ;
  1264. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1265. data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
  1266. data_out [BUFFER_SIZE / 8] = 1.0 ;
  1267. data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
  1268. data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
  1269. data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
  1271. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1272. sfinfo.samplerate = 44100 ;
  1273. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1274. sfinfo.channels = 1 ;
  1275. sfinfo.format = filetype ;
  1277. /* Save unclipped data to the file. */
  1278. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1279. test_write_float_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1280. sf_close (file) ;
  1282. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1284. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1285. sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
  1287. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1289. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1290. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1291. exit (1) ;
  1292. } ;
  1294. if (sfinfo.frames != BUFFER_SIZE)
  1295. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1296. exit (1) ;
  1297. } ;
  1299. if (sfinfo.channels != 1)
  1300. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1301. exit (1) ;
  1302. } ;
  1304. check_log_buffer_or_die (file, __LINE__) ;
  1306. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  1307. test_read_int_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1308. /*-sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;-*/
  1309. sf_close (file) ;
  1311. /* Check the first half. */
  1312. max_value = 0 ;
  1313. for (k = 0 ; k < sfinfo.frames ; k++)
  1314. { /* Check if data_out has different sign from data_in. */
  1315. if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
  1316. { printf ("nnLine %d: Data wrap around at index %d/%d  (%f -> %d).nn", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
  1317. exit (1) ;
  1318. } ;
  1319. max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
  1320. } ;
  1322. unlink (filename) ;
  1323. puts ("ok") ;
  1324. } /* flt_int_clip_read_test */
  1326. static void dbl_short_clip_read_test (const char *filename, int filetype)
  1327. { SNDFILE *file ;
  1328. SF_INFO sfinfo ;
  1329. double *data_out ;
  1330. short *data_in, max_value ;
  1331. int k ;
  1333. print_test_name ("dbl_short_clip_read_test", filename) ;
  1335. data_out = buffer_out.dbl ;
  1336. data_in = buffer_in.s ;
  1338. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1339. data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
  1340. data_out [BUFFER_SIZE / 8] = 1.0 ;
  1341. data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
  1342. data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
  1343. data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
  1345. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1346. sfinfo.samplerate = 44100 ;
  1347. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1348. sfinfo.channels = 1 ;
  1349. sfinfo.format = filetype ;
  1351. /* Save unclipped data to the file. */
  1352. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1353. test_write_double_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1354. sf_close (file) ;
  1356. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1358. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1359. sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
  1361. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1363. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1364. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1365. exit (1) ;
  1366. } ;
  1368. if (sfinfo.frames != BUFFER_SIZE)
  1369. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1370. exit (1) ;
  1371. } ;
  1373. if (sfinfo.channels != 1)
  1374. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1375. exit (1) ;
  1376. } ;
  1378. check_log_buffer_or_die (file, __LINE__) ;
  1380. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  1381. test_read_short_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1382. /*-sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;-*/
  1383. sf_close (file) ;
  1385. /* Check the first half. */
  1386. max_value = 0 ;
  1387. for (k = 0 ; k < sfinfo.frames ; k++)
  1388. { /* Check if data_out has different sign from data_in. */
  1389. if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
  1390. { printf ("nnLine %d: Data wrap around at index %d/%d  (%f -> %d).nn", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
  1391. exit (1) ;
  1392. } ;
  1393. max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
  1394. } ;
  1396. unlink (filename) ;
  1397. puts ("ok") ;
  1398. } /* dbl_short_clip_read_test */
  1399. static void dbl_int_clip_read_test (const char *filename, int filetype)
  1400. { SNDFILE *file ;
  1401. SF_INFO sfinfo ;
  1402. double *data_out ;
  1403. int *data_in, max_value ;
  1404. int k ;
  1406. print_test_name ("dbl_int_clip_read_test", filename) ;
  1408. data_out = buffer_out.dbl ;
  1409. data_in = buffer_in.i ;
  1411. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1412. data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
  1413. data_out [BUFFER_SIZE / 8] = 1.0 ;
  1414. data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
  1415. data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
  1416. data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
  1418. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1419. sfinfo.samplerate = 44100 ;
  1420. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1421. sfinfo.channels = 1 ;
  1422. sfinfo.format = filetype ;
  1424. /* Save unclipped data to the file. */
  1425. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1426. test_write_double_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1427. sf_close (file) ;
  1429. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1431. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1432. sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
  1434. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1436. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1437. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1438. exit (1) ;
  1439. } ;
  1441. if (sfinfo.frames != BUFFER_SIZE)
  1442. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1443. exit (1) ;
  1444. } ;
  1446. if (sfinfo.channels != 1)
  1447. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1448. exit (1) ;
  1449. } ;
  1451. check_log_buffer_or_die (file, __LINE__) ;
  1453. sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
  1454. test_read_int_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1455. /*-sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;-*/
  1456. sf_close (file) ;
  1458. /* Check the first half. */
  1459. max_value = 0 ;
  1460. for (k = 0 ; k < sfinfo.frames ; k++)
  1461. { /* Check if data_out has different sign from data_in. */
  1462. if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
  1463. { printf ("nnLine %d: Data wrap around at index %d/%d  (%f -> %d).nn", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
  1464. exit (1) ;
  1465. } ;
  1466. max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
  1467. } ;
  1469. unlink (filename) ;
  1470. puts ("ok") ;
  1471. } /* dbl_int_clip_read_test */
  1474. /*==============================================================================
  1475. */
  1478. static void short_flt_scale_write_test (const char *filename, int filetype)
  1479. { SNDFILE *file ;
  1480. SF_INFO sfinfo ;
  1481. short *data_out ;
  1482. float *data_in, max_value ;
  1483. int k ;
  1485. print_test_name ("short_flt_clip_write_test", filename) ;
  1487. data_out = buffer_out.s ;
  1488. data_in = buffer_in.flt ;
  1490. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1491. data_out [k] = lrintf (0x7FFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
  1493. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1494. sfinfo.samplerate = 44100 ;
  1495. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1496. sfinfo.channels = 1 ;
  1497. sfinfo.format = filetype ;
  1499. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1500. test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1501. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
  1502. test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1503. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
  1504. test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1505. sf_close (file) ;
  1507. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1509. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1511. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1513. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1514. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1515. exit (1) ;
  1516. } ;
  1518. if (sfinfo.frames != 3 * BUFFER_SIZE)
  1519. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1520. exit (1) ;
  1521. } ;
  1523. if (sfinfo.channels != 1)
  1524. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1525. exit (1) ;
  1526. } ;
  1528. check_log_buffer_or_die (file, __LINE__) ;
  1530. /* Check the first section. */
  1531. test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1533. max_value = 0.0 ;
  1534. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1535. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1537. if (max_value < 1000.0)
  1538. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1539. exit (1) ;
  1540. } ;
  1542. /* Check the second section. */
  1543. test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1545. max_value = 0.0 ;
  1546. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1547. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1549. if (max_value > 1.0)
  1550. { printf ("nnLine %d: Max value (%f) > 1.0.nn", __LINE__, max_value) ;
  1551. exit (1) ;
  1552. } ;
  1554. /* Check the third section. */
  1555. test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1557. max_value = 0.0 ;
  1558. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1559. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1561. if (max_value < 1000.0)
  1562. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1563. exit (1) ;
  1564. } ;
  1566. sf_close (file) ;
  1568. unlink (filename) ;
  1569. puts ("ok") ;
  1570. } /* short_flt_scale_write_test */
  1571. static void short_dbl_scale_write_test (const char *filename, int filetype)
  1572. { SNDFILE *file ;
  1573. SF_INFO sfinfo ;
  1574. short *data_out ;
  1575. double *data_in, max_value ;
  1576. int k ;
  1578. print_test_name ("short_dbl_clip_write_test", filename) ;
  1580. data_out = buffer_out.s ;
  1581. data_in = buffer_in.dbl ;
  1583. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1584. data_out [k] = lrint (0x7FFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
  1586. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1587. sfinfo.samplerate = 44100 ;
  1588. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1589. sfinfo.channels = 1 ;
  1590. sfinfo.format = filetype ;
  1592. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1593. test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1594. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
  1595. test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1596. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
  1597. test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1598. sf_close (file) ;
  1600. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1602. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1604. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1606. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1607. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1608. exit (1) ;
  1609. } ;
  1611. if (sfinfo.frames != 3 * BUFFER_SIZE)
  1612. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1613. exit (1) ;
  1614. } ;
  1616. if (sfinfo.channels != 1)
  1617. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1618. exit (1) ;
  1619. } ;
  1621. check_log_buffer_or_die (file, __LINE__) ;
  1623. /* Check the first section. */
  1624. test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1626. max_value = 0.0 ;
  1627. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1628. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1630. if (max_value < 1000.0)
  1631. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1632. exit (1) ;
  1633. } ;
  1635. /* Check the second section. */
  1636. test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1638. max_value = 0.0 ;
  1639. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1640. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1642. if (max_value > 1.0)
  1643. { printf ("nnLine %d: Max value (%f) > 1.0.nn", __LINE__, max_value) ;
  1644. exit (1) ;
  1645. } ;
  1647. /* Check the third section. */
  1648. test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1650. max_value = 0.0 ;
  1651. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1652. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1654. if (max_value < 1000.0)
  1655. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1656. exit (1) ;
  1657. } ;
  1659. sf_close (file) ;
  1661. unlink (filename) ;
  1662. puts ("ok") ;
  1663. } /* short_dbl_scale_write_test */
  1665. static void int_flt_scale_write_test (const char *filename, int filetype)
  1666. { SNDFILE *file ;
  1667. SF_INFO sfinfo ;
  1668. int *data_out ;
  1669. float *data_in, max_value ;
  1670. int k ;
  1672. print_test_name ("int_flt_clip_write_test", filename) ;
  1674. data_out = buffer_out.i ;
  1675. data_in = buffer_in.flt ;
  1677. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1678. data_out [k] = lrintf (0x7FFFFFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
  1680. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1681. sfinfo.samplerate = 44100 ;
  1682. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1683. sfinfo.channels = 1 ;
  1684. sfinfo.format = filetype ;
  1686. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1687. test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1688. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
  1689. test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1690. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
  1691. test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1692. sf_close (file) ;
  1694. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1696. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1698. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1700. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1701. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1702. exit (1) ;
  1703. } ;
  1705. if (sfinfo.frames != 3 * BUFFER_SIZE)
  1706. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1707. exit (1) ;
  1708. } ;
  1710. if (sfinfo.channels != 1)
  1711. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1712. exit (1) ;
  1713. } ;
  1715. check_log_buffer_or_die (file, __LINE__) ;
  1717. /* Check the first section. */
  1718. test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1720. max_value = 0.0 ;
  1721. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1722. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1724. if (max_value < 1000.0)
  1725. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1726. exit (1) ;
  1727. } ;
  1729. /* Check the second section. */
  1730. test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1732. max_value = 0.0 ;
  1733. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1734. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1736. if (max_value > 1.0)
  1737. { printf ("nnLine %d: Max value (%f) > 1.0.nn", __LINE__, max_value) ;
  1738. exit (1) ;
  1739. } ;
  1741. /* Check the third section. */
  1742. test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1744. max_value = 0.0 ;
  1745. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1746. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1748. if (max_value < 1000.0)
  1749. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1750. exit (1) ;
  1751. } ;
  1753. sf_close (file) ;
  1755. unlink (filename) ;
  1756. puts ("ok") ;
  1757. } /* int_flt_scale_write_test */
  1758. static void int_dbl_scale_write_test (const char *filename, int filetype)
  1759. { SNDFILE *file ;
  1760. SF_INFO sfinfo ;
  1761. int *data_out ;
  1762. double *data_in, max_value ;
  1763. int k ;
  1765. print_test_name ("int_dbl_clip_write_test", filename) ;
  1767. data_out = buffer_out.i ;
  1768. data_in = buffer_in.dbl ;
  1770. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1771. data_out [k] = lrint (0x7FFFFFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
  1773. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1774. sfinfo.samplerate = 44100 ;
  1775. sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  1776. sfinfo.channels = 1 ;
  1777. sfinfo.format = filetype ;
  1779. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
  1780. test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1781. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
  1782. test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1783. sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
  1784. test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
  1785. sf_close (file) ;
  1787. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1789. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
  1791. sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
  1793. if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
  1794. { printf ("nnLine %d: Returned format incorrect (0x%08X => 0x%08X).nn", __LINE__, filetype, sfinfo.format) ;
  1795. exit (1) ;
  1796. } ;
  1798. if (sfinfo.frames != 3 * BUFFER_SIZE)
  1799. { printf ("nnLine %d: Incorrect number of frames in file (%d => %ld).nn", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
  1800. exit (1) ;
  1801. } ;
  1803. if (sfinfo.channels != 1)
  1804. { printf ("nnLine %d: Incorrect number of channels in file.nn", __LINE__) ;
  1805. exit (1) ;
  1806. } ;
  1808. check_log_buffer_or_die (file, __LINE__) ;
  1810. /* Check the first section. */
  1811. test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1813. max_value = 0.0 ;
  1814. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1815. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1817. if (max_value < 1000.0)
  1818. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1819. exit (1) ;
  1820. } ;
  1822. /* Check the second section. */
  1823. test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1825. max_value = 0.0 ;
  1826. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1827. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1829. if (max_value > 1.0)
  1830. { printf ("nnLine %d: Max value (%f) > 1.0.nn", __LINE__, max_value) ;
  1831. exit (1) ;
  1832. } ;
  1834. /* Check the third section. */
  1835. test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
  1837. max_value = 0.0 ;
  1838. for (k = 0 ; k < BUFFER_SIZE ; k++)
  1839. max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
  1841. if (max_value < 1000.0)
  1842. { printf ("nnLine %d: Max value (%f) < 1000.0.nn", __LINE__, max_value) ;
  1843. exit (1) ;
  1844. } ;
  1846. sf_close (file) ;
  1848. unlink (filename) ;
  1849. puts ("ok") ;
  1850. } /* int_dbl_scale_write_test */