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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
lossy_comp_test.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：48k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

lossy_comp_test.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2000 Erik de Castro Lopo <erikd@zip.com.au>
  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 <stdio.h>
  20. #include <string.h>
  21. #include <unistd.h>
  22. #include <math.h>
  24. #include <sndfile.h>
  26. #ifndef M_PI
  27. #define M_PI 3.14159
  28. #endif
  30. #define BUFFER_SIZE (1<<14)
  31. #define SAMPLE_RATE 11025
  33. static void lcomp_test_short (char *str, char *filename, int typemajor, int typeminor, double margin) ;
  34. static void lcomp_test_int (char *str, char *filename, int typemajor, int typeminor, double margin) ;
  35. static void lcomp_test_double (char *str, char *filename, int typemajor, int typeminor, double margin) ;
  37. static void sdlcomp_test_short (char *str, char *filename, int typemajor, int typeminor, double margin) ;
  38. static void sdlcomp_test_int (char *str, char *filename, int typemajor, int typeminor, double margin) ;
  39. static void sdlcomp_test_double (char *str, char *filename, int typemajor, int typeminor, double margin) ;
  41. static int error_function (double data, double orig, double margin) ;
  42. static int decay_response (int k) ;
  43. static void gen_signal (double *data, unsigned int datalen) ;
  44. static void smoothed_diff_short (short *data, unsigned int datalen) ;
  45. static void smoothed_diff_int (int *data, unsigned int datalen) ;
  46. static void smoothed_diff_double (double *data, unsigned int datalen) ;
  48. /* Force the start of these buffers to be double aligned. Sparc-solaris will
  49. ** choke if they are not.
  50. */
  51. static double data_buffer [BUFFER_SIZE + 1] ;
  52. static double orig_buffer [BUFFER_SIZE + 1] ;
  53. static double smooth_buffer [BUFFER_SIZE + 1] ;
  55. int main (int argc, char *argv[])
  56. { char *filename ;
  57. int bDoAll = 0 ;
  58. int nTests = 0 ;
  60. if (argc != 2)
  61. { printf ("Usage : %s <test>n", argv [0]) ;
  62. printf ("    Where <test> is one of the following:n") ;
  63. printf ("           wav_ima     - test IMA ADPCM WAV file functionsn") ;
  64. printf ("           wav_msadpcm - test MS ADPCM WAV file functionsn") ;
  65. printf ("           wav_gsm610  - test GSM 6.10 WAV file functionsn") ;
  66. printf ("           wav_ulaw    - test u-law WAV file functionsn") ;
  67. printf ("           wav_alaw    - test A-law WAV file functionsn") ;
  68. printf ("           wav_pcm     - test PCM WAV file functionsn") ;
  69. printf ("           all         - perform all testsn") ;
  70. exit (1) ;
  71. } ;
  73. bDoAll = !strcmp (argv [1], "all") ;
  75. if (bDoAll || ! strcmp (argv [1], "wav_pcm"))
  76. { filename = "test.wav" ;
  77. lcomp_test_short ("wav_pcm", filename, SF_FORMAT_WAV, SF_FORMAT_PCM, 0.00001) ;
  78. lcomp_test_int ("wav_pcm", filename, SF_FORMAT_WAV, SF_FORMAT_PCM, 0.00001) ;
  79. lcomp_test_double ("wav_pcm", filename, SF_FORMAT_WAV, SF_FORMAT_PCM, 0.005) ;
  80. unlink (filename) ;
  81. nTests++ ;
  82. } ;
  84. if (bDoAll || ! strcmp (argv [1], "wav_ima"))
  85. { filename = "test.wav" ;
  86. lcomp_test_short ("wav_ima", filename, SF_FORMAT_WAV, SF_FORMAT_IMA_ADPCM, 0.17) ;
  87. lcomp_test_int ("wav_ima", filename, SF_FORMAT_WAV, SF_FORMAT_IMA_ADPCM, 0.17) ;
  88. lcomp_test_double ("wav_ima", filename, SF_FORMAT_WAV, SF_FORMAT_IMA_ADPCM, 0.17) ;
  90. sdlcomp_test_short ("wav_ima", filename, SF_FORMAT_WAV, SF_FORMAT_IMA_ADPCM, 0.17) ;
  91. sdlcomp_test_int ("wav_ima", filename, SF_FORMAT_WAV, SF_FORMAT_IMA_ADPCM, 0.17) ;
  92. sdlcomp_test_double ("wav_ima", filename, SF_FORMAT_WAV, SF_FORMAT_IMA_ADPCM, 0.17) ;
  93. unlink (filename) ;
  94. nTests++ ;
  95. } ;
  97. if (bDoAll || ! strcmp (argv [1], "wav_msadpcm"))
  98. { filename = "test.wav" ;
  99. lcomp_test_short ("wav_msadpcm", filename, SF_FORMAT_WAV, SF_FORMAT_MS_ADPCM, 0.36) ;
  100. lcomp_test_int ("wav_msadpcm", filename, SF_FORMAT_WAV, SF_FORMAT_MS_ADPCM, 0.36) ;
  101. lcomp_test_double ("wav_msadpcm", filename, SF_FORMAT_WAV, SF_FORMAT_MS_ADPCM, 0.36) ;
  103. sdlcomp_test_short ("wav_msadpcm", filename, SF_FORMAT_WAV, SF_FORMAT_MS_ADPCM, 0.36) ;
  104. sdlcomp_test_int ("wav_msadpcm", filename, SF_FORMAT_WAV, SF_FORMAT_MS_ADPCM, 0.36) ;
  105. sdlcomp_test_double ("wav_msadpcm", filename, SF_FORMAT_WAV, SF_FORMAT_MS_ADPCM, 0.36) ;
  107. unlink (filename) ;
  108. nTests++ ;
  109. } ;
  111. if (bDoAll || ! strcmp (argv [1], "wav_ulaw"))
  112. { filename = "test.wav" ;
  113. lcomp_test_short ("wav_ulaw", filename, SF_FORMAT_WAV, SF_FORMAT_ULAW, 0.04) ;
  114. lcomp_test_int ("wav_ulaw", filename, SF_FORMAT_WAV, SF_FORMAT_ULAW, 0.04) ;
  115. lcomp_test_double ("wav_ulaw", filename, SF_FORMAT_WAV, SF_FORMAT_ULAW, 0.04) ;
  116. unlink (filename) ;
  117. nTests++ ;
  118. } ;
  120. if (bDoAll || ! strcmp (argv [1], "wav_alaw"))
  121. { filename = "test.wav" ;
  122. lcomp_test_short ("wav_alaw", filename, SF_FORMAT_WAV, SF_FORMAT_ALAW, 0.04) ;
  123. lcomp_test_int ("wav_alaw", filename, SF_FORMAT_WAV, SF_FORMAT_ALAW, 0.04) ;
  124. lcomp_test_double ("wav_alaw", filename, SF_FORMAT_WAV, SF_FORMAT_ALAW, 0.04) ;
  125. unlink (filename) ;
  126. nTests++ ;
  127. } ;
  129. if (bDoAll || ! strcmp (argv [1], "wav_gsm610"))
  130. { filename = "test.wav" ;
  131. sdlcomp_test_short ("wav_gsm610", filename, SF_FORMAT_WAV, SF_FORMAT_GSM610, 0.2) ;
  132. sdlcomp_test_int ("wav_gsm610", filename, SF_FORMAT_WAV, SF_FORMAT_GSM610, 0.2) ;
  133. sdlcomp_test_double ("wav_gsm610", filename, SF_FORMAT_WAV, SF_FORMAT_GSM610, 0.2) ;
  134. unlink (filename) ;
  135. nTests++ ;
  136. } ;
  138. if (bDoAll || ! strcmp (argv [1], "au_ulaw"))
  139. { filename = "test.au" ;
  140. lcomp_test_short ("au_ulaw", filename, SF_FORMAT_AU, SF_FORMAT_ULAW, 0.04) ;
  141. lcomp_test_int ("au_ulaw", filename, SF_FORMAT_AU, SF_FORMAT_ULAW, 0.04) ;
  142. lcomp_test_double ("au_ulaw", filename, SF_FORMAT_AU, SF_FORMAT_ULAW, 0.04) ;
  143. unlink (filename) ;
  144. nTests++ ;
  145. } ;
  147. if (bDoAll || ! strcmp (argv [1], "au_alaw"))
  148. { filename = "test.au" ;
  149. lcomp_test_short ("au_alaw", filename, SF_FORMAT_AU, SF_FORMAT_ALAW, 0.04) ;
  150. lcomp_test_int ("au_alaw", filename, SF_FORMAT_AU, SF_FORMAT_ALAW, 0.04) ;
  151. lcomp_test_double ("au_alaw", filename, SF_FORMAT_AU, SF_FORMAT_ALAW, 0.04) ;
  152. unlink (filename) ;
  153. nTests++ ;
  154. } ;
  156. if (bDoAll || ! strcmp (argv [1], "aule_ulaw"))
  157. { filename = "test.au" ;
  158. lcomp_test_short ("aule_ulaw", filename, SF_FORMAT_AULE, SF_FORMAT_ULAW, 0.04) ;
  159. lcomp_test_int ("aule_ulaw", filename, SF_FORMAT_AULE, SF_FORMAT_ULAW, 0.04) ;
  160. lcomp_test_double ("aule_ulaw", filename, SF_FORMAT_AULE, SF_FORMAT_ULAW, 0.04) ;
  161. unlink (filename) ;
  162. nTests++ ;
  163. } ;
  165. if (bDoAll || ! strcmp (argv [1], "aule_alaw"))
  166. { filename = "test.au" ;
  167. lcomp_test_short ("aule_alaw", filename, SF_FORMAT_AULE, SF_FORMAT_ALAW, 0.04) ;
  168. lcomp_test_int ("aule_alaw", filename, SF_FORMAT_AULE, SF_FORMAT_ALAW, 0.04) ;
  169. lcomp_test_double ("aule_alaw", filename, SF_FORMAT_AULE, SF_FORMAT_ALAW, 0.04) ;
  170. unlink (filename) ;
  171. nTests++ ;
  172. } ;
  174. if (bDoAll || ! strcmp (argv [1], "au_g721"))
  175. { filename = "test.au" ;
  176. lcomp_test_short ("au_g721", filename, SF_FORMAT_AU, SF_FORMAT_G721_32, 0.05) ;
  177. lcomp_test_int ("au_g721", filename, SF_FORMAT_AU, SF_FORMAT_G721_32, 0.05) ;
  178. lcomp_test_double ("au_g721", filename, SF_FORMAT_AU, SF_FORMAT_G721_32, 0.05) ;
  180. sdlcomp_test_short ("au_g721", filename, SF_FORMAT_AU, SF_FORMAT_G721_32, 0.05) ;
  181. sdlcomp_test_int ("au_g721", filename, SF_FORMAT_AU, SF_FORMAT_G721_32, 0.05) ;
  182. sdlcomp_test_double ("au_g721", filename, SF_FORMAT_AU, SF_FORMAT_G721_32, 0.05) ;
  183. unlink (filename) ;
  184. nTests++ ;
  185. } ;
  187. if (bDoAll || ! strcmp (argv [1], "aule_g721"))
  188. { filename = "test.au" ;
  189. lcomp_test_short ("aule_g721", filename, SF_FORMAT_AULE, SF_FORMAT_G721_32, 0.05) ;
  190. lcomp_test_int ("aule_g721", filename, SF_FORMAT_AULE, SF_FORMAT_G721_32, 0.05) ;
  191. lcomp_test_double ("aule_g721", filename, SF_FORMAT_AULE, SF_FORMAT_G721_32, 0.05) ;
  193. sdlcomp_test_short ("aule_g721", filename, SF_FORMAT_AULE, SF_FORMAT_G721_32, 0.05) ;
  194. sdlcomp_test_int ("aule_g721", filename, SF_FORMAT_AULE, SF_FORMAT_G721_32, 0.05) ;
  195. sdlcomp_test_double ("aule_g721", filename, SF_FORMAT_AULE, SF_FORMAT_G721_32, 0.05) ;
  196. unlink (filename) ;
  197. nTests++ ;
  198. } ;
  200. if (bDoAll || ! strcmp (argv [1], "au_g723"))
  201. { filename = "test.au" ;
  202. lcomp_test_short ("au_g723", filename, SF_FORMAT_AU, SF_FORMAT_G723_24, 0.15) ;
  203. lcomp_test_int ("au_g723", filename, SF_FORMAT_AU, SF_FORMAT_G723_24, 0.15) ;
  204. lcomp_test_double ("au_g723", filename, SF_FORMAT_AU, SF_FORMAT_G723_24, 0.15) ;
  206. sdlcomp_test_short ("au_g723", filename, SF_FORMAT_AU, SF_FORMAT_G723_24, 0.15) ;
  207. sdlcomp_test_int ("au_g723", filename, SF_FORMAT_AU, SF_FORMAT_G723_24, 0.15) ;
  208. sdlcomp_test_double ("au_g723", filename, SF_FORMAT_AU, SF_FORMAT_G723_24, 0.15) ;
  209. unlink (filename) ;
  210. nTests++ ;
  211. } ;
  213. if (bDoAll || ! strcmp (argv [1], "aule_g723"))
  214. { filename = "test.au" ;
  215. lcomp_test_short ("aule_g723", filename, SF_FORMAT_AULE, SF_FORMAT_G723_24, 0.15) ;
  216. lcomp_test_int ("aule_g723", filename, SF_FORMAT_AULE, SF_FORMAT_G723_24, 0.15) ;
  217. lcomp_test_double ("aule_g723", filename, SF_FORMAT_AULE, SF_FORMAT_G723_24, 0.15) ;
  219. sdlcomp_test_short ("aule_g723", filename, SF_FORMAT_AULE, SF_FORMAT_G723_24, 0.15) ;
  220. sdlcomp_test_int ("aule_g723", filename, SF_FORMAT_AULE, SF_FORMAT_G723_24, 0.15) ;
  221. sdlcomp_test_double ("aule_g723", filename, SF_FORMAT_AULE, SF_FORMAT_G723_24, 0.15) ;
  222. unlink (filename) ;
  223. nTests++ ;
  224. } ;
  226. if (nTests == 0)
  227. { printf ("************************************n") ;
  228. printf ("*  No '%s' test defined.n", argv [1]) ;
  229. printf ("************************************n") ;
  230. return 1 ;
  231. } ;
  233. return 0;
  234. } /* main */
  236. /*============================================================================================
  237. ** Here are the test functions.
  238. */ 
  239.  
  240. static
  241. void lcomp_test_short (char *str, char *filename, int typemajor, int typeminor, double margin)
  242. { SNDFILE *file ;
  243. SF_INFO sfinfo ;
  244. int k, m, seekpos ;
  245. unsigned int datalen ;
  246. short *orig, *data ;
  248. printf ("    lcomp_test_short    : %s ... ", str) ;
  250. datalen = BUFFER_SIZE ;
  252. orig = (short*) orig_buffer ;
  253. data = (short*) data_buffer ;
  254. gen_signal (orig_buffer, datalen) ;
  255. for (k = 0 ; k < datalen ; k++)
  256. orig [k] = (short) (orig_buffer [k]) ;
  258. sfinfo.samplerate  = SAMPLE_RATE ;
  259. sfinfo.samples     = 123456789 ; /* Ridiculous value. */
  260. sfinfo.channels    = 1 ;
  261. sfinfo.pcmbitwidth = 16 ;
  262. sfinfo.format     = (typemajor | typeminor) ;
  264. if (! (file = sf_open_write (filename, &sfinfo)))
  265. { printf ("sf_open_write failed with error : ") ;
  266. sf_perror (NULL) ;
  267. exit (1) ;
  268. } ;
  270. if ((k = sf_write_short (file, orig, datalen)) != datalen)
  271. { printf ("sf_write_short failed with short write (%d => %d).n", datalen, k) ;
  272. exit (1) ;
  273. } ;
  274. sf_close (file) ;
  276. memset (data, 0, datalen * sizeof (short)) ;
  277. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  279. if (! (file = sf_open_read (filename, &sfinfo)))
  280. { printf ("sf_open_read failed with error : ") ;
  281. sf_perror (NULL) ;
  282. exit (1) ;
  283. } ;
  285. if (sfinfo.format != (typemajor | typeminor))
  286. { printf ("Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  287. exit (1) ;
  288. } ;
  290. if (sfinfo.samples < datalen)
  291. { printf ("Too few samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  292. exit (1) ;
  293. } ;
  295. if (sfinfo.samples > (datalen + datalen/2))
  296. { printf ("Too many samples in file. (%d should be a little more than %d)n", sfinfo.samples, datalen) ;
  297. exit (1) ;
  298. } ;
  300. if (sfinfo.channels != 1)
  301. { printf ("Incorrect number of channels in file.n") ;
  302. exit (1) ;
  303. } ;
  305. if (sfinfo.pcmbitwidth != 16)
  306. { printf ("Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  307. exit (1) ;
  308. } ;
  310. if ((k = sf_read_short (file, data, datalen)) < 0.99 * datalen)
  311. { printf ("short read (%d).n", k) ;
  312. exit (1) ;
  313. } ;
  315. for (k = 0 ; k < datalen ; k++)
  316. { if (error_function ((double) data [k], (double) orig [k], margin))
  317. { printf ("Incorrect sample A (#%d : %d should be %d).n", k, data [k], orig [k]) ;
  318. exit (1) ;
  319. } ;
  320. } ;
  322. if ((k = sf_read_short (file, data, datalen)) != sfinfo.samples - datalen)
  323. { printf ("Incorrect read length A (%d should be %d).n", sfinfo.samples - datalen, k) ;
  324. exit (1) ;
  325. } ;
  327. if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM)
  328. for (k = 0 ; k < sfinfo.samples - datalen ; k++)
  329. if (abs (data [k]) > decay_response (k))
  330. { printf ("Incorrect sample B (#%d : abs (%d) should be < %d).n", datalen + k, data [k], decay_response (k)) ;
  331. exit (1) ;
  332. } ;
  334. if (! sfinfo.seekable)
  335. { printf ("okn") ;
  336. return ;
  337. } ;
  339. /* Now test sf_seek function. */
  341. if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
  342. { printf ("Seek to start of file failed (%d).n", k) ;
  343. exit (1) ;
  344. } ;
  346. for (m = 0 ; m < 3 ; m++)
  347. { if ((k = sf_read_short (file, data, datalen/7)) != datalen / 7)
  348. { printf ("Incorrect read length B (%d => %d).n", datalen / 7, k) ;
  349. exit (1) ;
  350. } ;
  352. for (k = 0 ; k < datalen/7 ; k++)
  353. if (error_function ((double) data [k], (double) orig [k + m * (datalen / 7)], margin))
  354. { printf ("Incorrect sample C (#%d : %d => %d).n", k + m * (datalen / 7), orig [k + m * (datalen / 7)], data [k]) ;
  355. for (m = 0 ; m < 10 ; m++)
  356. printf ("%d ", data [k]) ;
  357. printf ("n") ;
  358. exit (1) ;
  359. } ;
  360. } ;
  362. seekpos = BUFFER_SIZE / 10 ;
  364. /* Check seek from start of file. */
  365. if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
  366. { printf ("Seek to start of file + %d failed (%d).n", seekpos, k) ;
  367. exit (1) ;
  368. } ;
  369. if ((k = sf_read_short (file, data, 1)) != 1)
  370. { printf ("sf_read_short (file, data, 1) returned %d.n", k) ;
  371. exit (1) ;
  372. } ;
  374. if (error_function ((double) data [0], (double) orig [seekpos], margin))
  375. { printf ("sf_seek (SEEK_SET) followed by sf_read_short failed (%d, %d).n", orig [1], data [0]) ;
  376. exit (1) ;
  377. } ;
  379. if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
  380. { printf ("sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)n", k, seekpos + 1) ;
  381. exit (1) ;
  382. } ;
  384. seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
  385. k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
  386. sf_read_short (file, data, 1) ;
  387. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  388. { printf ("sf_seek (forwards, SEEK_CUR) followed by sf_read_short failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos + 1) ;
  389. exit (1) ;
  390. } ;
  392. seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
  393. /* Check seek backward from current position. */
  394. k = sf_seek (file, -20, SEEK_CUR) ;
  395. sf_read_short (file, data, 1) ;
  396. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  397. { printf ("sf_seek (backwards, SEEK_CUR) followed by sf_read_short failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos) ;
  398. exit (1) ;
  399. } ;
  401. /* Check that read past end of file returns number of items. */
  402. sf_seek (file, (int) datalen, SEEK_SET) ;
  404.   if ((k = sf_read_short (file, data, datalen)) != sfinfo.samples - datalen)
  405.   { printf ("Return value from sf_read_short past end of file incorrect (%d).n", k) ;
  406.   exit (1) ;
  407.   } ;
  409. /* Check seek backward from end. */
  410. if ((k = sf_seek (file, 5 - (int) sfinfo.samples, SEEK_END)) != 5)
  411. { printf ("sf_seek (SEEK_END) returned %d instead of %d.n", k, 5) ;
  412. exit (1) ;
  413. } ;
  415. sf_read_short (file, data, 1) ;
  416. if (error_function ((double) data [0], (double) orig [5], margin))
  417. { printf ("sf_seek (SEEK_END) followed by sf_read_short failed (%d should be %d).n", data [0], orig [5]) ;
  418. exit (1) ;
  419. } ;
  421. sf_close (file) ;
  423. printf ("okn") ;
  424. } /* lcomp_test_short */
  426. /*--------------------------------------------------------------------------------------------
  427. */ 
  428.  
  429. static
  430. void lcomp_test_int (char *str, char *filename, int typemajor, int typeminor, double margin)
  431. { SNDFILE *file ;
  432. SF_INFO sfinfo ;
  433. int k, m, seekpos ;
  434. unsigned int datalen ;
  435. int *orig, *data ;
  437. printf ("    lcomp_test_int      : %s ... ", str) ;
  439. datalen = BUFFER_SIZE ;
  441. data = (int*) data_buffer ;
  442. orig = (int*) orig_buffer ;
  443. gen_signal (orig_buffer, datalen) ;
  444. for (k = 0 ; k < datalen ; k++)
  445. orig [k] = (int) (orig_buffer [k]) ;
  447. sfinfo.samplerate  = SAMPLE_RATE ;
  448. sfinfo.samples     = 123456789 ; /* Ridiculous value. */
  449. sfinfo.channels    = 1 ;
  450. sfinfo.pcmbitwidth = 16 ;
  451. sfinfo.format     = (typemajor | typeminor) ;
  453. if (! (file = sf_open_write (filename, &sfinfo)))
  454. { printf ("sf_open_write failed with error : ") ;
  455. sf_perror (NULL) ;
  456. exit (1) ;
  457. } ;
  459. if ((k = sf_write_int (file, orig, datalen)) != datalen)
  460. { printf ("sf_write_int failed with short write (%d => %d).n", datalen, k) ;
  461. exit (1) ;
  462. } ;
  463. sf_close (file) ;
  465. memset (data, 0, datalen * sizeof (short)) ;
  466. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  468. if (! (file = sf_open_read (filename, &sfinfo)))
  469. { printf ("sf_open_read failed with error : ") ;
  470. sf_perror (NULL) ;
  471. exit (1) ;
  472. } ;
  474. if (sfinfo.format != (typemajor | typeminor))
  475. { printf ("Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  476. exit (1) ;
  477. } ;
  479. if (sfinfo.samples < datalen)
  480. { printf ("Too few samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  481. exit (1) ;
  482. } ;
  484. if (sfinfo.samples > (datalen + datalen/2))
  485. { printf ("Too many samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  486. exit (1) ;
  487. } ;
  489. if (sfinfo.channels != 1)
  490. { printf ("Incorrect number of channels in file.n") ;
  491. exit (1) ;
  492. } ;
  494. if (sfinfo.pcmbitwidth != 16)
  495. { printf ("Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  496. exit (1) ;
  497. } ;
  499. if ((k = sf_read_int (file, data, datalen)) != datalen)
  500. { printf ("short read (%d).n", k) ;
  501. exit (1) ;
  502. } ;
  504. for (k = 0 ; k < datalen ; k++)
  505. { if (error_function ((double) data [k], (double) orig [k], margin))
  506. { printf ("Incorrect sample A (#%d : %d should be %d).n", k, data [k], orig [k]) ;
  507. exit (1) ;
  508. } ;
  509. } ;
  511. if ((k = sf_read_int (file, data, datalen)) != sfinfo.samples - datalen)
  512. { printf ("Incorrect read length A (%d should be %d).n", sfinfo.samples - datalen, k) ;
  513. exit (1) ;
  514. } ;
  516. if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM)
  517. for (k = 0 ; k < sfinfo.samples - datalen ; k++)
  518. if (abs (data [k]) > decay_response (k))
  519. { printf ("Incorrect sample B (#%d : abs (%d) should be < %d).n", datalen + k, data [k], decay_response (k)) ;
  520. exit (1) ;
  521. } ;
  523. if (! sfinfo.seekable)
  524. { printf ("okn") ;
  525. return ;
  526. } ;
  528. /* Now test sf_seek function. */
  530. if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
  531. { printf ("Seek to start of file failed (%d).n", k) ;
  532. exit (1) ;
  533. } ;
  535. for (m = 0 ; m < 3 ; m++)
  536. { if ((k = sf_read_int (file, data, datalen/7)) != datalen / 7)
  537. { printf ("Incorrect read length B (%d => %d).n", datalen / 7, k) ;
  538. exit (1) ;
  539. } ;
  541. for (k = 0 ; k < datalen/7 ; k++)
  542. if (error_function ((double) data [k], (double) orig [k + m * (datalen / 7)], margin))
  543. { printf ("Incorrect sample C (#%d : %d => %d).n", k + m * (datalen / 7), orig [k + m * (datalen / 7)], data [k]) ;
  544. for (m = 0 ; m < 10 ; m++)
  545. printf ("%d ", data [k]) ;
  546. printf ("n") ;
  547. exit (1) ;
  548. } ;
  549. } ;
  551. seekpos = BUFFER_SIZE / 10 ;
  553. /* Check seek from start of file. */
  554. if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
  555. { printf ("Seek to start of file + %d failed (%d).n", seekpos, k) ;
  556. exit (1) ;
  557. } ;
  558. if ((k = sf_read_int (file, data, 1)) != 1)
  559. { printf ("sf_read_int (file, data, 1) returned %d.n", k) ;
  560. exit (1) ;
  561. } ;
  563. if (error_function ((double) data [0], (double) orig [seekpos], margin))
  564. { printf ("sf_seek (SEEK_SET) followed by sf_read_int failed (%d, %d).n", orig [1], data [0]) ;
  565. exit (1) ;
  566. } ;
  568. if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
  569. { printf ("sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)n", k, seekpos + 1) ;
  570. exit (1) ;
  571. } ;
  573. seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
  574. k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
  575. sf_read_int (file, data, 1) ;
  576. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  577. { printf ("sf_seek (forwards, SEEK_CUR) followed by sf_read_int failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos + 1) ;
  578. exit (1) ;
  579. } ;
  581. seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
  582. /* Check seek backward from current position. */
  583. k = sf_seek (file, -20, SEEK_CUR) ;
  584. sf_read_int (file, data, 1) ;
  585. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  586. { printf ("sf_seek (backwards, SEEK_CUR) followed by sf_read_int failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos) ;
  587. exit (1) ;
  588. } ;
  590. /* Check that read past end of file returns number of items. */
  591. sf_seek (file, (int) datalen, SEEK_SET) ;
  593.   if ((k = sf_read_int (file, data, datalen)) != sfinfo.samples - datalen)
  594.   { printf ("Return value from sf_read_int past end of file incorrect (%d).n", k) ;
  595.   exit (1) ;
  596.   } ;
  598. /* Check seek backward from end. */
  599. if ((k = sf_seek (file, 5 - (int) sfinfo.samples, SEEK_END)) != 5)
  600. { printf ("sf_seek (SEEK_END) returned %d instead of %d.n", k, 5) ;
  601. exit (1) ;
  602. } ;
  604. sf_read_int (file, data, 1) ;
  605. if (error_function ((double) data [0], (double) orig [5], margin))
  606. { printf ("sf_seek (SEEK_END) followed by sf_read_short failed (%d should be %d).n", data [0], orig [5]) ;
  607. exit (1) ;
  608. } ;
  610. sf_close (file) ;
  612. printf ("okn") ;
  613. } /* lcomp_test_int */
  615. /*--------------------------------------------------------------------------------------------
  616. */ 
  618. static
  619. void lcomp_test_double (char *str, char *filename, int typemajor, int typeminor, double margin)
  620. { SNDFILE *file ;
  621. SF_INFO sfinfo ;
  622. int k, m, seekpos ;
  623. unsigned int datalen ;
  624. double *orig, *data ;
  626. printf ("    lcomp_test_double   : %s ... ", str) ;
  628. datalen = BUFFER_SIZE ;
  630. orig = (double*) orig_buffer ;
  631. data = (double*) data_buffer ;
  632. gen_signal (orig_buffer, datalen) ;
  634. sfinfo.samplerate  = SAMPLE_RATE ;
  635. sfinfo.samples     = 123456789 ; /* Ridiculous value. */
  636. sfinfo.channels    = 1 ;
  637. sfinfo.pcmbitwidth = 16 ;
  638. sfinfo.format     = (typemajor | typeminor) ;
  640. if (! (file = sf_open_write (filename, &sfinfo)))
  641. { printf ("sf_open_write failed with error : ") ;
  642. sf_perror (NULL) ;
  643. exit (1) ;
  644. } ;
  646. if ((k = sf_write_double (file, orig, datalen, 0)) != datalen)
  647. { printf ("sf_write_double failed with double write (%d => %d).n", datalen, k) ;
  648. exit (1) ;
  649. } ;
  650. sf_close (file) ;
  652. memset (data, 0, datalen * sizeof (double)) ;
  653. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  655. if (! (file = sf_open_read (filename, &sfinfo)))
  656. { printf ("sf_open_read failed with error : ") ;
  657. sf_perror (NULL) ;
  658. exit (1) ;
  659. } ;
  661. if (sfinfo.format != (typemajor | typeminor))
  662. { printf ("Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  663. exit (1) ;
  664. } ;
  666. if (sfinfo.samples < datalen)
  667. { printf ("Too few samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  668. exit (1) ;
  669. } ;
  671. if (sfinfo.samples > (datalen + datalen/2))
  672. { printf ("Too many samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  673. exit (1) ;
  674. } ;
  676. if (sfinfo.channels != 1)
  677. { printf ("Incorrect number of channels in file.n") ;
  678. exit (1) ;
  679. } ;
  681. if (sfinfo.pcmbitwidth != 16)
  682. { printf ("Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  683. exit (1) ;
  684. } ;
  686. if ((k = sf_read_double (file, data, datalen, 0)) != datalen)
  687. { printf ("double read (%d).n", k) ;
  688. exit (1) ;
  689. } ;
  691. for (k = 0 ; k < datalen ; k++)
  692. if (error_function (data [k], orig [k], margin))
  693. { printf ("Incorrect sample A (#%d : %f should be %f).n", k, data [k], orig [k]) ;
  694. exit (1) ;
  695. } ;
  697. if ((k = sf_read_double (file, data, datalen, 0)) != sfinfo.samples - datalen)
  698. { printf ("Incorrect read length A (%d should be %d).n", sfinfo.samples - datalen, k) ;
  699. exit (1) ;
  700. } ;
  702. if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM)
  703. for (k = 0 ; k < sfinfo.samples - datalen ; k++)
  704. if (abs ((int) data [k]) > decay_response (k))
  705. { printf ("Incorrect sample B (#%d : abs (%d) should be < %d).n", datalen + k, (int) data [k], decay_response (k)) ;
  706. exit (1) ;
  707. } ;
  709. if (! sfinfo.seekable)
  710. { printf ("okn") ;
  711. return ;
  712. } ;
  714. /* Now test sf_seek function. */
  716. if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
  717. { printf ("Seek to start of file failed (%d).n", k) ;
  718. exit (1) ;
  719. } ;
  721. for (m = 0 ; m < 3 ; m++)
  722. { if ((k = sf_read_double (file, data, datalen/7, 0)) != datalen / 7)
  723. { printf ("Incorrect read length B (%d => %d).n", datalen / 7, k) ;
  724. exit (1) ;
  725. } ;
  727. for (k = 0 ; k < datalen/7 ; k++)
  728. if (error_function (data [k], orig [k + m * (datalen / 7)], margin))
  729. { printf ("Incorrect sample C (#%d : %d => %d).n", k + m * (datalen / 7), (int) orig [k + m * (datalen / 7)], (int) data [k]) ;
  730. for (m = 0 ; m < 10 ; m++)
  731. printf ("%d ", (int) data [k]) ;
  732. printf ("n") ;
  733. exit (1) ;
  734. } ;
  735. } ;
  737. seekpos = BUFFER_SIZE / 10 ;
  739. /* Check seek from start of file. */
  740. if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
  741. { printf ("Seek to start of file + %d failed (%d).n", seekpos, k) ;
  742. exit (1) ;
  743. } ;
  744. if ((k = sf_read_double (file, data, 1, 0)) != 1)
  745. { printf ("sf_read_double (file, data, 1, 0) returned %d.n", k) ;
  746. exit (1) ;
  747. } ;
  749. if (error_function ((double) data [0], (double) orig [seekpos], margin))
  750. { printf ("sf_seek (SEEK_SET) followed by sf_read_double failed (%d, %d).n", (int) orig [1], (int) data [0]) ;
  751. exit (1) ;
  752. } ;
  754. if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
  755. { printf ("sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)n", k, seekpos + 1) ;
  756. exit (1) ;
  757. } ;
  759. seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
  760. k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
  761. sf_read_double (file, data, 1, 0) ;
  762. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  763. { printf ("sf_seek (forwards, SEEK_CUR) followed by sf_read_double failed (%d, %d) (%d, %d).n", (int) data [0], (int) orig [seekpos], k, seekpos + 1) ;
  764. exit (1) ;
  765. } ;
  767. seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
  768. /* Check seek backward from current position. */
  769. k = sf_seek (file, -20, SEEK_CUR) ;
  770. sf_read_double (file, data, 1, 0) ;
  771. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  772. { printf ("sf_seek (backwards, SEEK_CUR) followed by sf_read_double failed (%d, %d) (%d, %d).n", (int) data [0], (int) orig [seekpos], k, seekpos) ;
  773. exit (1) ;
  774. } ;
  776. /* Check that read past end of file returns number of items. */
  777. sf_seek (file, (int) datalen, SEEK_SET) ;
  779.   if ((k = sf_read_double (file, data, datalen, 0)) != sfinfo.samples - datalen)
  780.   { printf ("Return value from sf_read_double past end of file incorrect (%d).n", k) ;
  781.   exit (1) ;
  782.   } ;
  784. /* Check seek backward from end. */
  785. if ((k = sf_seek (file, 5 - (int) sfinfo.samples, SEEK_END)) != 5)
  786. { printf ("sf_seek (SEEK_END) returned %d instead of %d.n", k, 5) ;
  787. exit (1) ;
  788. } ;
  790. sf_read_double (file, data, 1, 0) ;
  791. if (error_function (data [0], orig [5], margin))
  792. { printf ("sf_seek (SEEK_END) followed by sf_read_double failed (%d, %d).n", (int) data [0], (int) orig [5]) ;
  793. exit (1) ;
  794. } ;
  796. sf_close (file) ;
  798. printf ("okn") ;
  799. } /* lcomp_test_double */
  801. /*========================================================================================
  802. ** Smoothed differential loss compression tests.
  803. */
  805. static
  806. void sdlcomp_test_short (char *str, char *filename, int typemajor, int typeminor, double margin)
  807. { SNDFILE *file ;
  808. SF_INFO sfinfo ;
  809. int k, m, seekpos ;
  810. unsigned int datalen ;
  811. short *orig, *data, *smooth ;
  813. printf ("    sdlcomp_test_short  : %s ... ", str) ;
  815. datalen = BUFFER_SIZE ;
  817. orig = (short*) orig_buffer ;
  818. data = (short*) data_buffer ;
  819. smooth = (short*) smooth_buffer ;
  821. gen_signal (orig_buffer, datalen) ;
  822. for (k = 0 ; k < datalen ; k++)
  823. orig [k] = (short) (orig_buffer [k]) ;
  825. sfinfo.samplerate  = SAMPLE_RATE ;
  826. sfinfo.samples     = 123456789 ; /* Ridiculous value. */
  827. sfinfo.channels    = 1 ;
  828. sfinfo.pcmbitwidth = 16 ;
  829. sfinfo.format     = (typemajor | typeminor) ;
  831. if (! (file = sf_open_write (filename, &sfinfo)))
  832. { printf ("sf_open_write failed with error : ") ;
  833. sf_perror (NULL) ;
  834. exit (1) ;
  835. } ;
  837. if ((k = sf_write_short (file, orig, datalen)) != datalen)
  838. { printf ("sf_write_short failed with short write (%d => %d).n", datalen, k) ;
  839. exit (1) ;
  840. } ;
  841. sf_close (file) ;
  843. memset (data, 0, datalen * sizeof (short)) ;
  844. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  846. if (! (file = sf_open_read (filename, &sfinfo)))
  847. { printf ("sf_open_read failed with error : ") ;
  848. sf_perror (NULL) ;
  849. exit (1) ;
  850. } ;
  852. if (sfinfo.format != (typemajor | typeminor))
  853. { printf ("Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  854. exit (1) ;
  855. } ;
  857. if (sfinfo.samples < datalen)
  858. { printf ("Too few samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  859. exit (1) ;
  860. } ;
  862. if (sfinfo.samples > (datalen + 400))
  863. { printf ("Too many samples in file. (%d should be a little more than %d)n", sfinfo.samples, datalen) ;
  864. exit (1) ;
  865. } ;
  867. if (sfinfo.channels != 1)
  868. { printf ("Incorrect number of channels in file.n") ;
  869. exit (1) ;
  870. } ;
  872. if (sfinfo.pcmbitwidth != 16)
  873. { printf ("Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  874. exit (1) ;
  875. } ;
  877. if ((k = sf_read_short (file, data, datalen)) != datalen)
  878. { printf ("short read (%d).n", k) ;
  879. exit (1) ;
  880. } ;
  882. memcpy (smooth, orig, datalen * sizeof (short)) ;
  883. smoothed_diff_short (data, datalen) ;
  884. smoothed_diff_short (smooth, datalen) ;
  886. for (k = 1 ; k < datalen ; k++)
  887. { if (error_function ((double) data [k], (double) smooth [k], margin))
  888. { printf ("Incorrect sample A (#%d : %d should be %d).n", k, data [k], smooth [k]) ;
  889. exit (1) ;
  890. } ;
  891. } ;
  893. if ((k = sf_read_short (file, data, datalen)) != sfinfo.samples - datalen)
  894. { printf ("Incorrect read length A (%d should be %d).n", k, sfinfo.samples - datalen) ;
  895. exit (1) ;
  896. } ;
  898. if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
  899. (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610)
  900. for (k = 0 ; k < sfinfo.samples - datalen ; k++)
  901. if (abs (data [k]) > decay_response (k))
  902. { printf ("Incorrect sample B (#%d : abs (%d) should be < %d).n", datalen + k, data [k], decay_response (k)) ;
  903. exit (1) ;
  904. } ;
  906. /* Now test sf_seek function. */
  907. if (sfinfo.seekable)
  908. { if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
  909. { printf ("Seek to start of file failed (%d).n", k) ;
  910. exit (1) ;
  911. } ;
  913. for (m = 0 ; m < 3 ; m++)
  914. { if ((k = sf_read_short (file, data, datalen/7)) != datalen / 7)
  915. { printf ("Incorrect read length B (%d => %d).n", datalen / 7, k) ;
  916. exit (1) ;
  917. } ;
  919. smoothed_diff_short (data, datalen/7) ;
  920. memcpy (smooth, orig + m * datalen/7, datalen/7 * sizeof (short)) ;
  921. smoothed_diff_short (smooth, datalen/7) ;
  923. for (k = 0 ; k < datalen/7 ; k++)
  924. if (error_function ((double) data [k], (double) smooth [k], margin))
  925. { printf ("Incorrect sample C (#%d (%d) : %d => %d).n", k, k + m * (datalen / 7), smooth [k], data [k]) ;
  926. for (m = 0 ; m < 10 ; m++)
  927. printf ("%d ", data [k]) ;
  928. printf ("n") ;
  929. exit (1) ;
  930. } ;
  931. } ; /* for (m = 0 ; m < 3 ; m++) */
  933. seekpos = BUFFER_SIZE / 10 ;
  935. /* Check seek from start of file. */
  936. if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
  937. { printf ("Seek to start of file + %d failed (%d).n", seekpos, k) ;
  938. exit (1) ;
  939. } ;
  940. if ((k = sf_read_short (file, data, 1)) != 1)
  941. { printf ("sf_read_short (file, data, 1) returned %d.n", k) ;
  942. exit (1) ;
  943. } ;
  945. if (error_function ((double) data [0], (double) orig [seekpos], margin))
  946. { printf ("sf_seek (SEEK_SET) followed by sf_read_short failed (%d, %d).n", orig [1], data [0]) ;
  947. exit (1) ;
  948. } ;
  950. if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
  951. { printf ("sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)n", k, seekpos + 1) ;
  952. exit (1) ;
  953. } ;
  955. seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
  956. k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
  957. sf_read_short (file, data, 1) ;
  958. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  959. { printf ("sf_seek (forwards, SEEK_CUR) followed by sf_read_short failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos + 1) ;
  960. exit (1) ;
  961. } ;
  963. seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
  964. /* Check seek backward from current position. */
  965. k = sf_seek (file, -20, SEEK_CUR) ;
  966. sf_read_short (file, data, 1) ;
  967. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  968. { printf ("sf_seek (backwards, SEEK_CUR) followed by sf_read_short failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos) ;
  969. exit (1) ;
  970. } ;
  972. /* Check that read past end of file returns number of items. */
  973. sf_seek (file, (int) datalen, SEEK_SET) ;
  975.   if ((k = sf_read_short (file, data, datalen)) != sfinfo.samples - datalen)
  976.   { printf ("Return value from sf_read_short past end of file incorrect (%d).n", k) ;
  977.   exit (1) ;
  978.   } ;
  980. /* Check seek backward from end. */
  982. if ((k = sf_seek (file, 5 - (int) sfinfo.samples, SEEK_END)) != 5)
  983. { printf ("sf_seek (SEEK_END) returned %d instead of %d.n", k, 5) ;
  984. exit (1) ;
  985. } ;
  987. sf_read_short (file, data, 1) ;
  988. if (error_function ((double) data [0], (double) orig [5], margin))
  989. { printf ("sf_seek (SEEK_END) followed by sf_read_short failed (%d should be %d).n", data [0], orig [5]) ;
  990. exit (1) ;
  991. } ;
  992. } /* if (sfinfo.seekable) */
  994. sf_close (file) ;
  996. printf ("okn") ;
  997. } /* sdlcomp_test_short */
  999. static
  1000. void sdlcomp_test_int (char *str, char *filename, int typemajor, int typeminor, double margin)
  1001. { SNDFILE *file ;
  1002. SF_INFO sfinfo ;
  1003. int k, m, seekpos ;
  1004. unsigned int datalen ;
  1005. int *orig, *data, *smooth ;
  1007. printf ("    sdlcomp_test_int    : %s ... ", str) ;
  1009. datalen = BUFFER_SIZE ;
  1011. orig = (int*) orig_buffer ;
  1012. data = (int*) data_buffer ;
  1013. smooth = (int*) smooth_buffer ;
  1015. gen_signal (orig_buffer, datalen) ;
  1016. for (k = 0 ; k < datalen ; k++)
  1017. orig [k] = (int) (orig_buffer [k]) ;
  1019. sfinfo.samplerate  = SAMPLE_RATE ;
  1020. sfinfo.samples     = 123456789 ; /* Ridiculous value. */
  1021. sfinfo.channels    = 1 ;
  1022. sfinfo.pcmbitwidth = 16 ;
  1023. sfinfo.format     = (typemajor | typeminor) ;
  1025. if (! (file = sf_open_write (filename, &sfinfo)))
  1026. { printf ("sf_open_write failed with error : ") ;
  1027. sf_perror (NULL) ;
  1028. exit (1) ;
  1029. } ;
  1031. if ((k = sf_write_int (file, orig, datalen)) != datalen)
  1032. { printf ("sf_write_int failed with int write (%d => %d).n", datalen, k) ;
  1033. exit (1) ;
  1034. } ;
  1035. sf_close (file) ;
  1037. memset (data, 0, datalen * sizeof (int)) ;
  1038. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1040. if (! (file = sf_open_read (filename, &sfinfo)))
  1041. { printf ("sf_open_read failed with error : ") ;
  1042. sf_perror (NULL) ;
  1043. exit (1) ;
  1044. } ;
  1046. if (sfinfo.format != (typemajor | typeminor))
  1047. { printf ("Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  1048. exit (1) ;
  1049. } ;
  1051. if (sfinfo.samples < datalen)
  1052. { printf ("Too few samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  1053. exit (1) ;
  1054. } ;
  1056. if (sfinfo.samples > (datalen + 400))
  1057. { printf ("Too many samples in file. (%d should be a little more than %d)n", sfinfo.samples, datalen) ;
  1058. exit (1) ;
  1059. } ;
  1061. if (sfinfo.channels != 1)
  1062. { printf ("Incorrect number of channels in file.n") ;
  1063. exit (1) ;
  1064. } ;
  1066. if (sfinfo.pcmbitwidth != 16)
  1067. { printf ("Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  1068. exit (1) ;
  1069. } ;
  1071. if ((k = sf_read_int (file, data, datalen)) != datalen)
  1072. { printf ("int read (%d).n", k) ;
  1073. exit (1) ;
  1074. } ;
  1076. memcpy (smooth, orig, datalen * sizeof (int)) ;
  1077. smoothed_diff_int (data, datalen) ;
  1078. smoothed_diff_int (smooth, datalen) ;
  1080. for (k = 1 ; k < datalen ; k++)
  1081. { if (error_function ((double) data [k], (double) smooth [k], margin))
  1082. { printf ("Incorrect sample A (#%d : %d should be %d).n", k, data [k], smooth [k]) ;
  1083. exit (1) ;
  1084. } ;
  1085. } ;
  1087. if ((k = sf_read_int (file, data, datalen)) != sfinfo.samples - datalen)
  1088. { printf ("Incorrect read length A (%d should be %d).n", k, sfinfo.samples - datalen) ;
  1089. exit (1) ;
  1090. } ;
  1092. if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
  1093. (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610)
  1094. for (k = 0 ; k < sfinfo.samples - datalen ; k++)
  1095. if (abs (data [k]) > decay_response (k))
  1096. { printf ("Incorrect sample B (#%d : abs (%d) should be < %d).n", datalen + k, data [k], decay_response (k)) ;
  1097. exit (1) ;
  1098. } ;
  1100. /* Now test sf_seek function. */
  1101. if (sfinfo.seekable)
  1102. { if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
  1103. { printf ("Seek to start of file failed (%d).n", k) ;
  1104. exit (1) ;
  1105. } ;
  1107. for (m = 0 ; m < 3 ; m++)
  1108. { if ((k = sf_read_int (file, data, datalen/7)) != datalen / 7)
  1109. { printf ("Incorrect read length B (%d => %d).n", datalen / 7, k) ;
  1110. exit (1) ;
  1111. } ;
  1113. smoothed_diff_int (data, datalen/7) ;
  1114. memcpy (smooth, orig + m * datalen/7, datalen/7 * sizeof (int)) ;
  1115. smoothed_diff_int (smooth, datalen/7) ;
  1117. for (k = 0 ; k < datalen/7 ; k++)
  1118. if (error_function ((double) data [k], (double) smooth [k], margin))
  1119. { printf ("Incorrect sample C (#%d (%d) : %d => %d).n", k, k + m * (datalen / 7), smooth [k], data [k]) ;
  1120. for (m = 0 ; m < 10 ; m++)
  1121. printf ("%d ", data [k]) ;
  1122. printf ("n") ;
  1123. exit (1) ;
  1124. } ;
  1125. } ; /* for (m = 0 ; m < 3 ; m++) */
  1127. seekpos = BUFFER_SIZE / 10 ;
  1129. /* Check seek from start of file. */
  1130. if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
  1131. { printf ("Seek to start of file + %d failed (%d).n", seekpos, k) ;
  1132. exit (1) ;
  1133. } ;
  1134. if ((k = sf_read_int (file, data, 1)) != 1)
  1135. { printf ("sf_read_int (file, data, 1) returned %d.n", k) ;
  1136. exit (1) ;
  1137. } ;
  1139. if (error_function ((double) data [0], (double) orig [seekpos], margin))
  1140. { printf ("sf_seek (SEEK_SET) followed by sf_read_int failed (%d, %d).n", orig [1], data [0]) ;
  1141. exit (1) ;
  1142. } ;
  1144. if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
  1145. { printf ("sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)n", k, seekpos + 1) ;
  1146. exit (1) ;
  1147. } ;
  1149. seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
  1150. k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
  1151. sf_read_int (file, data, 1) ;
  1152. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  1153. { printf ("sf_seek (forwards, SEEK_CUR) followed by sf_read_int failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos + 1) ;
  1154. exit (1) ;
  1155. } ;
  1157. seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
  1158. /* Check seek backward from current position. */
  1159. k = sf_seek (file, -20, SEEK_CUR) ;
  1160. sf_read_int (file, data, 1) ;
  1161. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  1162. { printf ("sf_seek (backwards, SEEK_CUR) followed by sf_read_int failed (%d, %d) (%d, %d).n", data [0], orig [seekpos], k, seekpos) ;
  1163. exit (1) ;
  1164. } ;
  1166. /* Check that read past end of file returns number of items. */
  1167. sf_seek (file, (int) datalen, SEEK_SET) ;
  1169.   if ((k = sf_read_int (file, data, datalen)) != sfinfo.samples - datalen)
  1170.   { printf ("Return value from sf_read_int past end of file incorrect (%d).n", k) ;
  1171.   exit (1) ;
  1172.   } ;
  1174. /* Check seek backward from end. */
  1176. if ((k = sf_seek (file, 5 - (int) sfinfo.samples, SEEK_END)) != 5)
  1177. { printf ("sf_seek (SEEK_END) returned %d instead of %d.n", k, 5) ;
  1178. exit (1) ;
  1179. } ;
  1181. sf_read_int (file, data, 1) ;
  1182. if (error_function ((double) data [0], (double) orig [5], margin))
  1183. { printf ("sf_seek (SEEK_END) followed by sf_read_int failed (%d should be %d).n", data [0], orig [5]) ;
  1184. exit (1) ;
  1185. } ;
  1186. } /* if (sfinfo.seekable) */
  1188. sf_close (file) ;
  1190. printf ("okn") ;
  1191. } /* sdlcomp_test_int */
  1193. static
  1194. void sdlcomp_test_double (char *str, char *filename, int typemajor, int typeminor, double margin)
  1195. { SNDFILE *file ;
  1196. SF_INFO sfinfo ;
  1197. int k, m, seekpos ;
  1198. unsigned int datalen ;
  1199. double *orig, *data, *smooth ;
  1201. printf ("    sdlcomp_test_double : %s ... ", str) ;
  1203. datalen = BUFFER_SIZE ;
  1205. orig = orig_buffer ;
  1206. data = data_buffer ;
  1207. smooth = smooth_buffer ;
  1209. gen_signal (orig_buffer, datalen) ;
  1211. sfinfo.samplerate  = SAMPLE_RATE ;
  1212. sfinfo.samples     = 123456789 ; /* Ridiculous value. */
  1213. sfinfo.channels    = 1 ;
  1214. sfinfo.pcmbitwidth = 16 ;
  1215. sfinfo.format     = (typemajor | typeminor) ;
  1217. if (! (file = sf_open_write (filename, &sfinfo)))
  1218. { printf ("sf_open_write failed with error : ") ;
  1219. sf_perror (NULL) ;
  1220. exit (1) ;
  1221. } ;
  1223. if ((k = sf_write_double (file, orig, datalen, 0)) != datalen)
  1224. { printf ("sf_write_double failed with int write (%d => %d).n", datalen, k) ;
  1225. exit (1) ;
  1226. } ;
  1227. sf_close (file) ;
  1229. memset (data, 0, datalen * sizeof (double)) ;
  1230. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1232. if (! (file = sf_open_read (filename, &sfinfo)))
  1233. { printf ("sf_open_read failed with error : ") ;
  1234. sf_perror (NULL) ;
  1235. exit (1) ;
  1236. } ;
  1238. if (sfinfo.format != (typemajor | typeminor))
  1239. { printf ("Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  1240. exit (1) ;
  1241. } ;
  1243. if (sfinfo.samples < datalen)
  1244. { printf ("Too few samples in file. (%d should be a little more than %d)n", datalen, sfinfo.samples) ;
  1245. exit (1) ;
  1246. } ;
  1248. if (sfinfo.samples > (datalen + 400))
  1249. { printf ("Too many samples in file. (%d should be a little more than %d)n", sfinfo.samples, datalen) ;
  1250. exit (1) ;
  1251. } ;
  1253. if (sfinfo.channels != 1)
  1254. { printf ("Incorrect number of channels in file.n") ;
  1255. exit (1) ;
  1256. } ;
  1258. if (sfinfo.pcmbitwidth != 16)
  1259. { printf ("Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  1260. exit (1) ;
  1261. } ;
  1263. if ((k = sf_read_double (file, data, datalen, 0)) != datalen)
  1264. { printf ("int read (%d).n", k) ;
  1265. exit (1) ;
  1266. } ;
  1268. memcpy (smooth, orig, datalen * sizeof (double)) ;
  1269. smoothed_diff_double (data, datalen) ;
  1270. smoothed_diff_double (smooth, datalen) ;
  1272. for (k = 1 ; k < datalen ; k++)
  1273. { if (error_function (data [k], smooth [k], margin))
  1274. { printf ("Incorrect sample A (#%d : %d should be %d).n", k, (int) data [k], (int) smooth [k]) ;
  1275. exit (1) ;
  1276. } ;
  1277. } ;
  1279. if ((k = sf_read_double (file, data, datalen, 0)) != sfinfo.samples - datalen)
  1280. { printf ("Incorrect read length A (%d should be %d).n", k, sfinfo.samples - datalen) ;
  1281. exit (1) ;
  1282. } ;
  1284. if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
  1285. (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610)
  1286. for (k = 0 ; k < sfinfo.samples - datalen ; k++)
  1287. if (abs (data [k]) > decay_response (k))
  1288. { printf ("Incorrect sample B (#%d : abs (%d) should be < %d).n", datalen + k, (int) data [k], (int) decay_response (k)) ;
  1289. exit (1) ;
  1290. } ;
  1292. /* Now test sf_seek function. */
  1293. if (sfinfo.seekable)
  1294. { if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
  1295. { printf ("Seek to start of file failed (%d).n", k) ;
  1296. exit (1) ;
  1297. } ;
  1299. for (m = 0 ; m < 3 ; m++)
  1300. { if ((k = sf_read_double (file, data, datalen/7, 0)) != datalen / 7)
  1301. { printf ("Incorrect read length B (%d => %d).n", datalen / 7, k) ;
  1302. exit (1) ;
  1303. } ;
  1305. smoothed_diff_double (data, datalen/7) ;
  1306. memcpy (smooth, orig + m * datalen/7, datalen/7 * sizeof (double)) ;
  1307. smoothed_diff_double (smooth, datalen/7) ;
  1309. for (k = 0 ; k < datalen/7 ; k++)
  1310. if (error_function ((double) data [k], (double) smooth [k], margin))
  1311. { printf ("Incorrect sample C (#%d (%d) : %d => %d).n", k, k + m * (datalen / 7), (int) smooth [k], (int) data [k]) ;
  1312. for (m = 0 ; m < 10 ; m++)
  1313. printf ("%d ", (int) data [k]) ;
  1314. printf ("n") ;
  1315. exit (1) ;
  1316. } ;
  1317. } ; /* for (m = 0 ; m < 3 ; m++) */
  1319. seekpos = BUFFER_SIZE / 10 ;
  1321. /* Check seek from start of file. */
  1322. if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
  1323. { printf ("Seek to start of file + %d failed (%d).n", seekpos, k) ;
  1324. exit (1) ;
  1325. } ;
  1326. if ((k = sf_read_double (file, data, 1, 0)) != 1)
  1327. { printf ("sf_read_double (file, data, 1) returned %d.n", k) ;
  1328. exit (1) ;
  1329. } ;
  1331. if (error_function ((double) data [0], (double) orig [seekpos], margin))
  1332. { printf ("sf_seek (SEEK_SET) followed by sf_read_double failed (%d, %d).n", (int) orig [1], (int) data [0]) ;
  1333. exit (1) ;
  1334. } ;
  1336. if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
  1337. { printf ("sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)n", k, seekpos + 1) ;
  1338. exit (1) ;
  1339. } ;
  1341. seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
  1342. k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
  1343. sf_read_double (file, data, 1, 0) ;
  1344. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  1345. { printf ("sf_seek (forwards, SEEK_CUR) followed by sf_read_double failed (%d, %d) (%d, %d).n", (int) data [0], (int) orig [seekpos], k, seekpos + 1) ;
  1346. exit (1) ;
  1347. } ;
  1349. seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
  1350. /* Check seek backward from current position. */
  1351. k = sf_seek (file, -20, SEEK_CUR) ;
  1352. sf_read_double (file, data, 1, 0) ;
  1353. if (error_function ((double) data [0], (double) orig [seekpos], margin) || k != seekpos)
  1354. { printf ("sf_seek (backwards, SEEK_CUR) followed by sf_read_double failed (%d, %d) (%d, %d).n", (int) data [0], (int) orig [seekpos], k, seekpos) ;
  1355. exit (1) ;
  1356. } ;
  1358. /* Check that read past end of file returns number of items. */
  1359. sf_seek (file, (int) datalen, SEEK_SET) ;
  1361.   if ((k = sf_read_double (file, data, datalen, 0)) != sfinfo.samples - datalen)
  1362.   { printf ("Return value from sf_read_double past end of file incorrect (%d).n", k) ;
  1363.   exit (1) ;
  1364.   } ;
  1366. /* Check seek backward from end. */
  1368. if ((k = sf_seek (file, 5 - (int) sfinfo.samples, SEEK_END)) != 5)
  1369. { printf ("sf_seek (SEEK_END) returned %d instead of %d.n", k, 5) ;
  1370. exit (1) ;
  1371. } ;
  1373. sf_read_double (file, data, 1, 0) ;
  1374. if (error_function ((double) data [0], (double) orig [5], margin))
  1375. { printf ("sf_seek (SEEK_END) followed by sf_read_double failed (%d should be %d).n", (int) data [0], (int) orig [5]) ;
  1376. exit (1) ;
  1377. } ;
  1378. } /* if (sfinfo.seekable) */
  1380. sf_close (file) ;
  1382. printf ("okn") ;
  1383. } /* sdlcomp_test_double */
  1385. /*========================================================================================
  1386. ** Auxiliary functions
  1387. */
  1389. static
  1390. int decay_response (int k)
  1391. { if (k < 1)
  1392. return ((int) 30000.0) ;
  1393. return (int) (30000.0 / (0.5 * k * k)) ;
  1394. } /* decay_response */
  1396. static
  1397. void gen_signal (double *data, unsigned int datalen)
  1398. { unsigned int k, ramplen ;
  1399. double amp = 0.0 ;
  1401. ramplen = datalen / 20 ;
  1403. for (k = 0 ; k < datalen ; k++)
  1404. { if (k <= ramplen)
  1405. amp = 30000.0 * k / ((double) ramplen) ;
  1406. else if (k > datalen - ramplen)
  1407. amp = 30000.0 * (datalen - k) / ((double) ramplen) ;
  1408. data [k] = amp * (0.4 * sin (33.3 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))
  1409. + 0.3 * cos (201.1 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))) ;
  1410. } ;
  1411. return ;
  1412. } /* gen_signal */
  1414. static
  1415. int error_function (double data, double orig, double margin)
  1416. { double error ;
  1418. if (fabs (orig) <= 500.0)
  1419. error = fabs (fabs (data) - fabs(orig)) / 2000.0 ;
  1420. else if (fabs (orig) <= 1000.0)
  1421. error = fabs (data - orig) / 3000.0 ;
  1422. else
  1423. error = fabs (data - orig) / fabs (orig) ;
  1425. if (error > margin)
  1426. { printf ("nn*******************nError : %fn", error) ;
  1427. return 1 ;
  1428. } ;
  1429. return 0 ;
  1430. } /* error_function */
  1432. static
  1433. void smoothed_diff_short (short *data, unsigned int datalen)
  1434. { unsigned int k ;
  1435. double memory = 0.0 ;
  1437. /* Calculate the smoothed sample-to-sample difference. */
  1438. for (k = 0 ; k < datalen - 1 ; k++)
  1439. { memory = 0.7 * memory + (1 - 0.7) * (double) (data [k+1] - data [k]) ;
  1440. data [k] = (short) memory ;
  1441. } ;
  1442. data [datalen-1] = data [datalen-2] ;
  1444. } /* smoothed_diff_short */
  1446. static
  1447. void smoothed_diff_int (int *data, unsigned int datalen)
  1448. { unsigned int k ;
  1449. double memory = 0.0 ;
  1451. /* Calculate the smoothed sample-to-sample difference. */
  1452. for (k = 0 ; k < datalen - 1 ; k++)
  1453. { memory = 0.7 * memory + (1 - 0.7) * (double) (data [k+1] - data [k]) ;
  1454. data [k] = (int) memory ;
  1455. } ;
  1456. data [datalen-1] = data [datalen-2] ;
  1458. } /* smoothed_diff_int */
  1460. static
  1461. void smoothed_diff_double (double *data, unsigned int datalen)
  1462. { unsigned int k ;
  1463. double memory = 0.0 ;
  1465. /* Calculate the smoothed sample-to-sample difference. */
  1466. for (k = 0 ; k < datalen - 1 ; k++)
  1467. { memory = 0.7 * memory + (1 - 0.7) * (data [k+1] - data [k]) ;
  1468. data [k] = memory ;
  1469. } ;
  1470. data [datalen-1] = data [datalen-2] ;
  1472. } /* smoothed_diff_double */