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

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

流媒体/Mpeg4/MP4

开发平台：

C/C++

write_read_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. */
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <unistd.h>
  24. #include <math.h>
  26. #include <sndfile.h>
  28. #define BUFFER_SIZE (1<<15)
  30. static void pcm_test_char (char *str, char *filename, int typemajor, int typeminor) ;
  31. static void pcm_test_short (char *str, char *filename, int typemajor, int typeminor) ;
  32. static void pcm_test_24bit (char *str, char *filename, int typemajor, int typeminor, int long_file_ok) ;
  33. static void pcm_test_int (char *str, char *filename, int typemajor, int typeminor) ;
  35. static void pcm_float_test (char *str, char *filename, int typemajor) ;
  37. /* Force the start of this buffer to be double aligned. Sparc-solaris will
  38. ** choke if its not.
  39. */
  40. static double test_buffer [(BUFFER_SIZE/sizeof(double))+1] ;
  42. int main (int argc, char *argv[])
  43. { char *filename ;
  44. int bDoAll = 0 ;
  45. int nTests = 0 ;
  47. if (argc != 2)
  48. { printf ("Usage : %s <test>n", argv [0]) ;
  49. printf ("    Where <test> is one of the following:n") ;
  50. printf ("           wav  - test WAV file functions (little endian)n") ;
  51. printf ("           aiff - test AIFF file functions (big endian)n") ;
  52. printf ("           au   - test AU file functions (big endian)n") ;
  53. printf ("           aule - test little endian AU file functionsn") ;
  54. printf ("           raw  - test RAW header-less PCM file functionsn") ;
  55. printf ("           paf  - test PAF file functionsn") ;
  56. printf ("           svx  - test 8SVX/16SV file functionsn") ;
  57. printf ("           all  - perform all testsn") ;
  58. exit (1) ;
  59. } ;
  61. bDoAll=!strcmp (argv [1], "all");
  63. if (bDoAll || ! strcmp (argv [1], "wav"))
  64. { filename = "test.wav" ;
  65. pcm_test_char  ("wav", filename, SF_FORMAT_WAV, SF_FORMAT_PCM) ;
  66. pcm_test_short ("wav", filename, SF_FORMAT_WAV, SF_FORMAT_PCM) ;
  67. pcm_test_24bit ("wav", filename, SF_FORMAT_WAV, SF_FORMAT_PCM, 0) ;
  68. pcm_test_int ("wav", filename, SF_FORMAT_WAV, SF_FORMAT_PCM) ;
  69. pcm_float_test ("wav", filename, SF_FORMAT_WAV) ;
  70. unlink (filename) ;
  71. nTests++ ;
  72. } ;
  74. if (bDoAll || ! strcmp (argv [1], "aiff"))
  75. { filename = "test.aiff" ;
  76. pcm_test_char  ("aiff", filename, SF_FORMAT_AIFF, SF_FORMAT_PCM) ;
  77. pcm_test_short ("aiff", filename, SF_FORMAT_AIFF, SF_FORMAT_PCM) ;
  78. pcm_test_24bit ("aiff", filename, SF_FORMAT_AIFF, SF_FORMAT_PCM, 0) ;
  79. pcm_test_int   ("aiff", filename, SF_FORMAT_AIFF, SF_FORMAT_PCM) ;
  80. unlink (filename) ;
  81. nTests++ ;
  82. } ;
  84. if (bDoAll || ! strcmp (argv [1], "au"))
  85. { filename = "test.au" ;
  86. pcm_test_char  ("au", filename, SF_FORMAT_AU, SF_FORMAT_PCM) ;
  87. pcm_test_short ("au", filename, SF_FORMAT_AU, SF_FORMAT_PCM) ;
  88. pcm_test_24bit ("au", filename, SF_FORMAT_AU, SF_FORMAT_PCM, 0) ;
  89. pcm_test_int   ("au", filename, SF_FORMAT_AU, SF_FORMAT_PCM) ;
  90. unlink (filename) ;
  91. nTests++ ;
  92. } ;
  94. if (bDoAll || ! strcmp (argv [1], "aule"))
  95. { filename = "test.au" ;
  96. pcm_test_char  ("aule", filename, SF_FORMAT_AULE, SF_FORMAT_PCM) ;
  97. pcm_test_short ("aule", filename, SF_FORMAT_AULE, SF_FORMAT_PCM) ;
  98. pcm_test_24bit ("aule", filename, SF_FORMAT_AULE, SF_FORMAT_PCM, 0) ;
  99. pcm_test_int   ("aule", filename, SF_FORMAT_AULE, SF_FORMAT_PCM) ;
  100. unlink (filename) ;
  101. nTests++ ;
  102. } ;
  104. if (bDoAll || ! strcmp (argv [1], "raw"))
  105. { filename = "test.raw" ;
  106. pcm_test_char  ("raw-s8", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_S8) ;
  107. pcm_test_char  ("raw-u8", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_U8) ;
  108. pcm_test_short ("raw-le", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_LE) ;
  109. pcm_test_short ("raw-be", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_BE) ;
  110. pcm_test_24bit ("raw-le", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_LE, 0) ;
  111. pcm_test_24bit ("raw-be", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_BE, 0) ;
  112. pcm_test_int   ("raw-le", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_LE) ;
  113. pcm_test_int   ("raw-be", filename, SF_FORMAT_RAW, SF_FORMAT_PCM_BE) ;
  114. unlink (filename) ;
  115. nTests++ ;
  116. } ;
  118. if (bDoAll || ! strcmp (argv [1], "paf"))
  119. { filename = "test.paf" ;
  120. pcm_test_short ("paf-le", filename, SF_FORMAT_PAF, SF_FORMAT_PCM_LE) ;
  121. pcm_test_short ("paf-be", filename, SF_FORMAT_PAF, SF_FORMAT_PCM_BE) ;
  122. pcm_test_24bit ("paf-le", filename, SF_FORMAT_PAF, SF_FORMAT_PCM_LE, 1) ;
  123. pcm_test_24bit ("paf-be", filename, SF_FORMAT_PAF, SF_FORMAT_PCM_BE, 1) ;
  124. unlink (filename) ;
  125. nTests++ ;
  126. } ;
  128. if (bDoAll || ! strcmp (argv [1], "svx"))
  129. { filename = "test.svx" ;
  130. pcm_test_char  ("svx", filename, SF_FORMAT_SVX, SF_FORMAT_PCM) ;
  131. pcm_test_short ("svx", filename, SF_FORMAT_SVX, SF_FORMAT_PCM) ;
  132. unlink (filename) ;
  133. nTests++ ;
  134. } ;
  136. if (nTests == 0)
  137. { printf ("Mono : ************************************n") ;
  138. printf ("Mono : *  No '%s' test defined.n", argv [1]) ;
  139. printf ("Mono : ************************************n") ;
  140. return 1 ;
  141. } ;
  143. return 0;
  144. } /* main */
  146. /*============================================================================================
  147.  * Here are the test functions.
  148.  */ 
  150. static
  151. void pcm_test_char (char *str, char *filename, int typemajor, int typeminor)
  152. { SNDFILE *file ;
  153. SF_INFO sfinfo ;
  154. unsigned int k, items, frames ;
  155. short *data ;
  157. printf ("    pcm_test_char  : %s ... ", str) ;
  159. items = 127 ;
  161. data = (short*) test_buffer ;
  162. for (k = 0 ; k < items ; k++)
  163. data [k] = k * ((k % 2) ? 1 : -1) ;
  165. sfinfo.samplerate  = 44100 ;
  166. sfinfo.samples     = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  167. sfinfo.channels    = 1 ;
  168. sfinfo.pcmbitwidth = 8 ;
  169. sfinfo.format     = (typemajor | typeminor) ;
  171. if (! (file = sf_open_write (filename, &sfinfo)))
  172. { printf ("Mono : sf_open_write failed with error : ") ;
  173. sf_perror (NULL) ;
  174. exit (1) ;
  175. } ;
  177. if ((k = sf_write_short (file, data, items)) != items)
  178. { printf ("Mono : sf_write_short failed with short write (%d => %d).n", items, k) ;
  179. sf_perror (file) ;
  180. exit (1) ;
  181. } ;
  182. sf_close (file) ;
  184. memset (data, 0, items * sizeof (short)) ;
  186. if (typemajor != SF_FORMAT_RAW)
  187. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  189. if (! (file = sf_open_read (filename, &sfinfo)))
  190. { printf ("Mono : sf_open_read failed with error : ") ;
  191. sf_perror (NULL) ;
  192. exit (1) ;
  193. } ;
  195. if (sfinfo.format != (typemajor | typeminor))
  196. { printf ("Mono : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  197. exit (1) ;
  198. } ;
  200. if (sfinfo.samples != items)
  201. { printf ("Mono : Incorrect number of samples in file. (%u => %u)n", items, sfinfo.samples) ;
  202. exit (1) ;
  203. } ;
  205. if (sfinfo.channels != 1)
  206. { printf ("Mono : Incorrect number of channels in file.n") ;
  207. exit (1) ;
  208. } ;
  210. if (sfinfo.pcmbitwidth != 8)
  211. { printf ("Mono : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  212. exit (1) ;
  213. } ;
  215. if ((k = sf_read_short (file, data, items)) != items)
  216. { printf ("Mono : short read (%d).n", k) ;
  217. exit (1) ;
  218. } ;
  220. for (k = 0 ; k < items ; k++)
  221. if (data [k] != k * ((k % 2) ? 1 : -1))
  222. { printf ("Mono : Incorrect sample (#%d : %d => %d).n", k, k * ((k % 2) ? 1 : -1), data [k]) ;
  223. exit (1) ;
  224. } ;
  225. sf_close (file) ;
  227. /* Now test Stereo. */
  229. if (typemajor == SF_FORMAT_SVX)
  230. { printf ("okn") ;
  231. return ;
  232. } ;
  234. items = 126 ;
  236. data = (short*) test_buffer ;
  237. for (k = 0 ; k < items ; k++)
  238. data [k] = k * ((k % 2) ? 1 : -1) ;
  240. sfinfo.samplerate  = 44100 ;
  241. sfinfo.samples     = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
  242. sfinfo.channels    = 2 ;
  243. sfinfo.pcmbitwidth = 8 ;
  244. sfinfo.format     = (typemajor | typeminor) ;
  246. frames = items / sfinfo.channels ;
  248. if (! (file = sf_open_write (filename, &sfinfo)))
  249. { printf ("Stereo : sf_open_write failed with error : ") ;
  250. sf_perror (NULL) ;
  251. exit (1) ;
  252. } ;
  254. if ((k = sf_writef_short (file, data, frames)) != frames)
  255. { printf ("Stereo : sf_writef_short failed with short write (%d => %d).n", frames, k) ;
  256. sf_perror (file) ;
  257. exit (1) ;
  258. } ;
  259. sf_close (file) ;
  261. memset (data, 0, items * sizeof (short)) ;
  263. if (typemajor != SF_FORMAT_RAW)
  264. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  266. if (! (file = sf_open_read (filename, &sfinfo)))
  267. { printf ("Stereo : sf_open_read failed with error : ") ;
  268. sf_perror (NULL) ;
  269. exit (1) ;
  270. } ;
  272. if (sfinfo.format != (typemajor | typeminor))
  273. { printf ("Stereo : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  274. exit (1) ;
  275. } ;
  277. if (sfinfo.samples != frames)
  278. { printf ("Stereo : Incorrect number of samples in file. (%u => %u)n", frames, sfinfo.samples) ;
  279. exit (1) ;
  280. } ;
  282. if (sfinfo.channels != 2)
  283. { printf ("Stereo : Incorrect number of channels in file.n") ;
  284. exit (1) ;
  285. } ;
  287. if (sfinfo.pcmbitwidth != 8)
  288. { printf ("Stereo : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  289. exit (1) ;
  290. } ;
  292. if ((k = sf_readf_short (file, data, frames)) != frames)
  293. { printf ("Stereo : short read (%d).n", k) ;
  294. exit (1) ;
  295. } ;
  296. sf_close (file) ;
  298. for (k = 0 ; k < items ; k++)
  299. if (data [k] != k * ((k % 2) ? 1 : -1))
  300. { printf ("Stereo : Incorrect sample (#%d : %d => %d).n", k, k * ((k % 2) ? 1 : -1), data [k]) ;
  301. exit (1) ;
  302. } ;
  304. printf ("okn") ;
  305. } /* pcm_test_char */
  307. static
  308. void pcm_test_short (char *str, char *filename, int typemajor, int typeminor)
  309. { SNDFILE *file ;
  310. SF_INFO sfinfo ;
  311. unsigned int k, items, frames ;
  312. short *data ;
  314. printf ("    pcm_test_short : %s ... ", str) ;
  316. items = BUFFER_SIZE / sizeof (short) ;
  318. data = (short*) test_buffer ;
  319. for (k = 0 ; k < items ; k++)
  320. data [k] = k * ((k % 2) ? 1 : -1) ;
  322. sfinfo.samplerate  = 44100 ;
  323. sfinfo.samples     = items ;
  324. sfinfo.channels    = 1 ;
  325. sfinfo.pcmbitwidth = 16 ;
  326. sfinfo.format     = (typemajor | typeminor) ;
  328. if (! (file = sf_open_write (filename, &sfinfo)))
  329. { printf ("Mono : sf_open_write failed with error : ") ;
  330. sf_perror (NULL) ;
  331. exit (1) ;
  332. } ;
  334. if ((k = sf_write_short (file, data, items)) != items)
  335. { printf ("Mono : sf_write_short failed with short write (%d => %d).n", items, k) ;
  336. sf_perror (file) ;
  337. exit (1) ;
  338. } ;
  339. sf_close (file) ;
  341. memset (data, 0, items * sizeof (short)) ;
  343. if (typemajor != SF_FORMAT_RAW)
  344. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  346. if (! (file = sf_open_read (filename, &sfinfo)))
  347. { printf ("Mono : sf_open_read failed with error : ") ;
  348. sf_perror (NULL) ;
  349. exit (1) ;
  350. } ;
  352. if (sfinfo.format != (typemajor | typeminor))
  353. { printf ("Mono : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  354. exit (1) ;
  355. } ;
  357. if (sfinfo.samples != items)
  358. { printf ("Mono : Incorrect number of samples in file. (%d => %d)n", items, sfinfo.samples) ;
  359. exit (1) ;
  360. } ;
  362. if (sfinfo.channels != 1)
  363. { printf ("Mono : Incorrect number of channels in file.n") ;
  364. exit (1) ;
  365. } ;
  367. if (sfinfo.pcmbitwidth != 16)
  368. { printf ("Mono : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  369. exit (1) ;
  370. } ;
  372. if ((k = sf_read_short (file, data, items)) != items)
  373. { printf ("Mono : short read (%d).n", k) ;
  374. exit (1) ;
  375. } ;
  377. for (k = 0 ; k < items ; k++)
  378. if (data [k] != k * ((k % 2) ? 1 : -1))
  379. { printf ("Mono : Incorrect sample (#%d : %d => %d).n", k, k * ((k % 2) ? 1 : -1), data [k]) ;
  380. exit (1) ;
  381. } ;
  382. sf_close (file) ;
  384. /* Now test Stereo. */
  386. if (typemajor == SF_FORMAT_SVX)
  387. { printf ("okn") ;
  388. return ;
  389. } ;
  391. items = BUFFER_SIZE / sizeof (short) ;
  393. data = (short*) test_buffer ;
  394. for (k = 0 ; k < items ; k++)
  395. data [k] = k * ((k % 2) ? 1 : -1) ;
  397. sfinfo.samplerate  = 44100 ;
  398. sfinfo.samples     = items ;
  399. sfinfo.channels    = 2 ;
  400. sfinfo.pcmbitwidth = 16 ;
  401. sfinfo.format     = (typemajor | typeminor) ;
  403. frames = items / sfinfo.channels ;
  405. if (! (file = sf_open_write (filename, &sfinfo)))
  406. { printf ("Stereo : sf_open_write failed with error : ") ;
  407. sf_perror (NULL) ;
  408. exit (1) ;
  409. } ;
  411. if ((k = sf_writef_short (file, data, frames)) != frames)
  412. { printf ("Stereo : sf_writef_short failed with short write (%d => %d).n", frames, k) ;
  413. sf_perror (file) ;
  414. exit (1) ;
  415. } ;
  416. sf_close (file) ;
  418. memset (data, 0, items * sizeof (short)) ;
  420. if (typemajor != SF_FORMAT_RAW)
  421. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  423. if (! (file = sf_open_read (filename, &sfinfo)))
  424. { printf ("Stereo : sf_open_read failed with error : ") ;
  425. sf_perror (NULL) ;
  426. exit (1) ;
  427. } ;
  429. if (sfinfo.format != (typemajor | typeminor))
  430. { printf ("Stereo : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  431. exit (1) ;
  432. } ;
  434. if (sfinfo.samples != frames)
  435. { printf ("Stereo : Incorrect number of samples in file. (%d => %d)n", frames, sfinfo.samples) ;
  436. exit (1) ;
  437. } ;
  439. if (sfinfo.channels != 2)
  440. { printf ("Stereo : Incorrect number of channels in file.n") ;
  441. exit (1) ;
  442. } ;
  444. if (sfinfo.pcmbitwidth != 16)
  445. { printf ("Stereo : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  446. exit (1) ;
  447. } ;
  449. if ((k = sf_readf_short (file, data, frames)) != frames)
  450. { printf ("Stereo : short read (%d).n", k) ;
  451. exit (1) ;
  452. } ;
  454. for (k = 0 ; k < items ; k++)
  455. if (data [k] != k * ((k % 2) ? 1 : -1))
  456. { printf ("Stereo : Incorrect sample (#%d : %d => %d).n", k, k * ((k % 2) ? 1 : -1), data [k]) ;
  457. exit (1) ;
  458. } ;
  459. sf_close (file) ;
  461. printf ("okn") ;
  462. } /* pcm_test_short */
  464. static
  465. void pcm_test_24bit (char *str, char *filename, int typemajor, int typeminor, int long_file_ok)
  466. { SNDFILE *file ;
  467. SF_INFO sfinfo ;
  468. unsigned int k, items, frames ;
  469. int *data ;
  471. printf ("    pcm_test_24bit : %s ... ", str) ;
  473. items = BUFFER_SIZE / sizeof (int) ;
  475. data = (int*) test_buffer ;
  476. for (k = 0 ; k < items ; k++)
  477. data [k] = k * 256 * ((k % 2) ? 1 : -1) ;
  479. sfinfo.samplerate  = 44100 ;
  480. sfinfo.samples     = items ;
  481. sfinfo.channels    = 1 ;
  482. sfinfo.pcmbitwidth = 24 ;
  483. sfinfo.format     = (typemajor | typeminor) ;
  485. if (! (file = sf_open_write (filename, &sfinfo)))
  486. { printf ("Mono : sf_open_write failed with error : ") ;
  487. sf_perror (NULL) ;
  488. exit (1) ;
  489. } ;
  491. if (sf_write_int (file, data, items) != items)
  492. { printf ("Mono : sf_write_int failed with error : ") ;
  493. sf_perror (file) ;
  494. exit (1) ;
  495. } ;
  497. sf_close (file) ;
  499. memset (data, 0, items * 3) ;
  501. if (typemajor != SF_FORMAT_RAW)
  502. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  504. if (! (file = sf_open_read (filename, &sfinfo)))
  505. { printf ("Mono : sf_open_read failed with error : ") ;
  506. sf_perror (NULL) ;
  507. exit (1) ;
  508. } ;
  510. if (sfinfo.format != (typemajor | typeminor))
  511. { printf ("Mono : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  512. exit (1) ;
  513. } ;
  515. if (sfinfo.samples < items)
  516. { printf ("Mono : Incorrect number of samples in file (too short). (%d should be %d)n", sfinfo.samples, items) ;
  517. exit (1) ;
  518. } ;
  520. if (! long_file_ok && sfinfo.samples > items)
  521. { printf ("Mono : Incorrect number of samples in file (too long). (%d should be %d)n", sfinfo.samples, items) ;
  522. exit (1) ;
  523. } ;
  525. if (sfinfo.channels != 1)
  526. { printf ("Mono : Incorrect number of channels in file.n") ;
  527. exit (1) ;
  528. } ;
  530. if (sfinfo.pcmbitwidth != 24)
  531. { printf ("Mono : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  532. exit (1) ;
  533. } ;
  535. if ((k = sf_read_int (file, data, items)) != items)
  536. { printf ("Mono : short read (%d).n", k) ;
  537. exit (1) ;
  538. } ;
  540. for (k = 0 ; k < items ; k++)
  541. if (data [k] != k * 256 * ((k % 2) ? 1 : -1))
  542. { printf ("Mono : Incorrect sample (#%d : %d => %d).n", k, k * 256 * ((k % 2) ? 1 : -1), data [k]) ;
  543. exit (1) ;
  544. } ;
  545. sf_close (file) ;
  547. /* Now test Stereo. */
  549. if (typemajor == SF_FORMAT_SVX)
  550. { printf ("okn") ;
  551. return ;
  552. } ;
  554. items = BUFFER_SIZE / sizeof (int) ;
  556. data = (int*) test_buffer ;
  557. for (k = 0 ; k < items ; k++)
  558. data [k] = k * 256 * ((k % 2) ? 1 : -1) ;
  560. sfinfo.samplerate  = 44100 ;
  561. sfinfo.samples     = items ;
  562. sfinfo.channels    = 2 ;
  563. sfinfo.pcmbitwidth = 24 ;
  564. sfinfo.format     = (typemajor | typeminor) ;
  566. frames = items / sfinfo.channels ;
  568. if (! (file = sf_open_write (filename, &sfinfo)))
  569. { printf ("Stereo : sf_open_write failed with error : ") ;
  570. sf_perror (NULL) ;
  571. exit (1) ;
  572. } ;
  574. if (sf_writef_int (file, data, frames) != frames)
  575. { printf ("Stereo : sf_writef_int failed with error : ") ;
  576. sf_perror (file) ;
  577. exit (1) ;
  578. } ;
  580. sf_close (file) ;
  582. memset (data, 0, items * 3) ;
  584. if (typemajor != SF_FORMAT_RAW)
  585. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  587. if (! (file = sf_open_read (filename, &sfinfo)))
  588. { printf ("Stereo : sf_open_read failed with error : ") ;
  589. sf_perror (NULL) ;
  590. exit (1) ;
  591. } ;
  593. if (sfinfo.format != (typemajor | typeminor))
  594. { printf ("Stereo : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  595. exit (1) ;
  596. } ;
  598. if (sfinfo.samples < frames)
  599. { printf ("Stereo : Incorrect number of samples in file (too short). (%d should be %d)n", sfinfo.samples, frames) ;
  600. exit (1) ;
  601. } ;
  603. if (! long_file_ok && sfinfo.samples > frames)
  604. { printf ("Stereo : Incorrect number of samples in file (too long). (%d should be %d)n", sfinfo.samples, frames) ;
  605. exit (1) ;
  606. } ;
  608. if (sfinfo.channels != 2)
  609. { printf ("Stereo : Incorrect number of channels in file.n") ;
  610. exit (1) ;
  611. } ;
  613. if (sfinfo.pcmbitwidth != 24)
  614. { printf ("Stereo : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  615. exit (1) ;
  616. } ;
  618. if ((k = sf_readf_int (file, data, frames)) != frames)
  619. { printf ("Stereo : short read (%d).n", k) ;
  620. exit (1) ;
  621. } ;
  623. for (k = 0 ; k < items ; k++)
  624. if (data [k] != k * 256 * ((k % 2) ? 1 : -1))
  625. { printf ("Stereo : Incorrect sample (#%d : %d => %d).n", k, k * 256 * ((k % 2) ? 1 : -1), data [k]) ;
  626. exit (1) ;
  627. } ;
  628. sf_close (file) ;
  630. printf ("okn") ;
  631. } /* pcm_test_24bit */
  633. static
  634. void pcm_test_int (char *str, char *filename, int typemajor, int typeminor)
  635. { SNDFILE *file ;
  636. SF_INFO sfinfo ;
  637. unsigned int k, items, frames ;
  638. int sign, *data ;
  640. printf ("    pcm_test_int   : %s ... ", str) ;
  642. items = BUFFER_SIZE / sizeof (int) ;
  644. data = (int*) test_buffer ;
  645. for (sign = 1, k = 0 ; k < items ; k++)
  646. data [k] = k * 200000 * ((k % 2) ? 1 : -1) ;
  648. sfinfo.samplerate  = 44100 ;
  649. sfinfo.samples     = items ;
  650. sfinfo.channels    = 1 ;
  651. sfinfo.pcmbitwidth = 32 ;
  652. sfinfo.format     = (typemajor | typeminor) ;
  654. if (! (file = sf_open_write (filename, &sfinfo)))
  655. { printf ("Mono : sf_open_write failed with error : ") ;
  656. sf_perror (NULL) ;
  657. exit (1) ;
  658. } ;
  660. if (sf_write_int (file, data, items) != items)
  661. { printf ("Mono : sf_write_int failed with error : ") ;
  662. sf_perror (file) ;
  663. exit (1) ;
  664. } ;
  665. sf_close (file) ;
  667. memset (data, 0, items * sizeof (short)) ;
  669. if (typemajor != SF_FORMAT_RAW)
  670. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  672. if (! (file = sf_open_read (filename, &sfinfo)))
  673. { printf ("Mono : sf_open_read failed with error : ") ;
  674. sf_perror (NULL) ;
  675. exit (1) ;
  676. } ;
  678. if (sfinfo.format != (typemajor | typeminor))
  679. { printf ("Mono : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  680. exit (1) ;
  681. } ;
  683. if (sfinfo.samples != items)
  684. { printf ("Mono : Incorrect number of samples in file. (%d => %d)n", items, sfinfo.samples) ;
  685. exit (1) ;
  686. } ;
  688. if (sfinfo.channels != 1)
  689. { printf ("Mono : Incorrect number of channels in file.n") ;
  690. exit (1) ;
  691. } ;
  693. if (sfinfo.pcmbitwidth != 32)
  694. { printf ("Mono : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  695. exit (1) ;
  696. } ;
  698. if ((k = sf_read_int (file, data, items)) != items)
  699. { printf ("Mono : short read (%d).n", k) ;
  700. exit (1) ;
  701. } ;
  703. for (sign = 1, k = 0 ; k < items ; k++)
  704. if (data [k] != k * 200000 * ((k % 2) ? 1 : -1))
  705. { printf ("Mono : Incorrect sample (#%d : %d => %d).n", k, (k % 2) ? 1 : -1, data [k]) ;
  706. exit (1) ;
  707. } ;
  708. sf_close (file) ;
  710. /* Now test Stereo. */
  712. if (typemajor == SF_FORMAT_SVX)
  713. { printf ("okn") ;
  714. return ;
  715. } ;
  717. items = BUFFER_SIZE / sizeof (int) ;
  719. data = (int*) test_buffer ;
  720. for (sign = 1, k = 0 ; k < items ; k++)
  721. data [k] = k * 200000 * ((k % 2) ? 1 : -1) ;
  723. sfinfo.samplerate  = 44100 ;
  724. sfinfo.samples     = items ;
  725. sfinfo.channels    = 2 ;
  726. sfinfo.pcmbitwidth = 32 ;
  727. sfinfo.format     = (typemajor | typeminor) ;
  729. frames = items / sfinfo.channels ;
  731. if (! (file = sf_open_write (filename, &sfinfo)))
  732. { printf ("Stereo : sf_open_write failed with error : ") ;
  733. sf_perror (NULL) ;
  734. exit (1) ;
  735. } ;
  737. if (sf_writef_int (file, data, frames) != frames)
  738. { printf ("Stereo : sf_writef_int failed with error : ") ;
  739. sf_perror (file) ;
  740. exit (1) ;
  741. } ;
  742. sf_close (file) ;
  744. memset (data, 0, items * sizeof (short)) ;
  746. if (typemajor != SF_FORMAT_RAW)
  747. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  749. if (! (file = sf_open_read (filename, &sfinfo)))
  750. { printf ("Stereo : sf_open_read failed with error : ") ;
  751. sf_perror (NULL) ;
  752. exit (1) ;
  753. } ;
  755. if (sfinfo.format != (typemajor | typeminor))
  756. { printf ("Stereo : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | typeminor), sfinfo.format) ;
  757. exit (1) ;
  758. } ;
  760. if (sfinfo.samples != frames)
  761. { printf ("Stereo : Incorrect number of samples in file. (%d => %d)n", frames, sfinfo.samples) ;
  762. exit (1) ;
  763. } ;
  765. if (sfinfo.channels != 2)
  766. { printf ("Stereo : Incorrect number of channels in file.n") ;
  767. exit (1) ;
  768. } ;
  770. if (sfinfo.pcmbitwidth != 32)
  771. { printf ("Stereo : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  772. exit (1) ;
  773. } ;
  775. if ((k = sf_readf_int (file, data, frames)) != frames)
  776. { printf ("Stereo : short read (%d).n", k) ;
  777. exit (1) ;
  778. } ;
  780. for (sign = 1, k = 0 ; k < items ; k++)
  781. if (data [k] != k * 200000 * ((k % 2) ? 1 : -1))
  782. { printf ("Stereo : Incorrect sample (#%d : %d => %d).n", k, (k % 2) ? 1 : -1, data [k]) ;
  783. exit (1) ;
  784. } ;
  785. sf_close (file) ;
  787. printf ("okn") ;
  788. } /* pcm_test_int */
  790. static
  791. void pcm_float_test (char *str, char *filename, int typemajor)
  792. { SNDFILE *file ;
  793. SF_INFO sfinfo ;
  794. unsigned int k, items, frames ;
  795. int sign ;
  796. double *data, error ;
  798. printf ("    pcm_float_test : %s ... ", str) ;
  800. items = BUFFER_SIZE / sizeof (double) ;
  802. data = (double*) test_buffer ;
  803. for (sign = 1, k = 0 ; k < items ; k++)
  804. data [k] = ((double) k) / 100.0 * (sign *= -1) ;
  806. sfinfo.samplerate = 44100 ;
  807. sfinfo.samples    = items ;
  808. sfinfo.channels   = 1 ;
  809. sfinfo.pcmbitwidth   = 32 ;
  810. sfinfo.format    = (typemajor | SF_FORMAT_FLOAT) ;
  812. if (! (file = sf_open_write (filename, &sfinfo)))
  813. { printf ("Mono : sf_open_write failed with error : ") ;
  814. sf_perror (NULL) ;
  815. exit (1) ;
  816. } ;
  818. if (sf_write_double (file, data, items, 0) != items)
  819. { printf ("Mono : sf_write_int failed with error : ") ;
  820. sf_perror (file) ;
  821. exit (1) ;
  822. } ;
  823. sf_close (file) ;
  825. memset (data, 0, items * sizeof (double)) ;
  826. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  828. if (! (file = sf_open_read (filename, &sfinfo)))
  829. { printf ("Mono : sf_open_read failed with error : ") ;
  830. sf_perror (NULL) ;
  831. exit (1) ;
  832. } ;
  834. if (sfinfo.format != (typemajor | SF_FORMAT_FLOAT))
  835. { printf ("Mono : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | SF_FORMAT_FLOAT), sfinfo.format) ;
  836. exit (1) ;
  837. } ;
  839. if (sfinfo.samples != items)
  840. { printf ("Mono : Incorrect number of samples in file. (%d => %d)n", items, sfinfo.samples) ;
  841. exit (1) ;
  842. } ;
  844. if (sfinfo.channels != 1)
  845. { printf ("Mono : Incorrect number of channels in file.n") ;
  846. exit (1) ;
  847. } ;
  849. if (sfinfo.pcmbitwidth != 32)
  850. { printf ("Mono : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  851. exit (1) ;
  852. } ;
  854. if ((k = sf_read_double (file, data, items, 0)) != items)
  855. { printf ("Mono : short read (%d).n", k) ;
  856. exit (1) ;
  857. } ;
  859. for (sign = 1, k = 0 ; k < items ; k++)
  860. { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
  861. if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
  862. { printf ("Mono : Incorrect sample (#%d : %f => %f).n", k, ((double) k) / 100.0, data [k]) ;
  863. exit (1) ;
  864. } ;
  865. } ;
  866. sf_close (file) ;
  868. /* Now test Stereo. */
  870. if (typemajor == SF_FORMAT_SVX)
  871. { printf ("okn") ;
  872. return ;
  873. } ;
  875. items = BUFFER_SIZE / sizeof (double) ;
  877. data = (double*) test_buffer ;
  878. for (sign = 1, k = 0 ; k < items ; k++)
  879. data [k] = ((double) k) / 100.0 * (sign *= -1) ;
  881. sfinfo.samplerate = 44100 ;
  882. sfinfo.samples    = items ;
  883. sfinfo.channels   = 2 ;
  884. sfinfo.pcmbitwidth   = 32 ;
  885. sfinfo.format    = (typemajor | SF_FORMAT_FLOAT) ;
  887. frames = items / sfinfo.channels ;
  889. if (! (file = sf_open_write (filename, &sfinfo)))
  890. { printf ("Stereo : sf_open_write failed with error : ") ;
  891. sf_perror (NULL) ;
  892. exit (1) ;
  893. } ;
  895. if (sf_writef_double (file, data, frames, 0) != frames)
  896. { printf ("Stereo : sf_writef_int failed with error : ") ;
  897. sf_perror (file) ;
  898. exit (1) ;
  899. } ;
  900. sf_close (file) ;
  902. memset (data, 0, items * sizeof (double)) ;
  903. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  905. if (! (file = sf_open_read (filename, &sfinfo)))
  906. { printf ("Stereo : sf_open_read failed with error : ") ;
  907. sf_perror (NULL) ;
  908. exit (1) ;
  909. } ;
  911. if (sfinfo.format != (typemajor | SF_FORMAT_FLOAT))
  912. { printf ("Stereo : Returned format incorrect (0x%08X => 0x%08X).n", (typemajor | SF_FORMAT_FLOAT), sfinfo.format) ;
  913. exit (1) ;
  914. } ;
  916. if (sfinfo.samples != frames)
  917. { printf ("Stereo : Incorrect number of samples in file. (%d => %d)n", frames, sfinfo.samples) ;
  918. exit (1) ;
  919. } ;
  921. if (sfinfo.channels != 2)
  922. { printf ("Stereo : Incorrect number of channels in file.n") ;
  923. exit (1) ;
  924. } ;
  926. if (sfinfo.pcmbitwidth != 32)
  927. { printf ("Stereo : Incorrect bit width (%d).n", sfinfo.pcmbitwidth) ;
  928. exit (1) ;
  929. } ;
  931. if ((k = sf_readf_double (file, data, frames, 0)) != frames)
  932. { printf ("Stereo : short read (%d).n", k) ;
  933. exit (1) ;
  934. } ;
  936. for (sign = 1, k = 0 ; k < items ; k++)
  937. { error = fabs (data [k] - ((double) k) / 100.0 * (sign *= -1)) ;
  938. if (fabs (data [k]) > 1e-100 && fabs (error / data [k]) > 1e-5)
  939. { printf ("Stereo : Incorrect sample (#%d : %f => %f).n", k, ((double) k) / 100.0, data [k]) ;
  940. exit (1) ;
  941. } ;
  942. } ;
  943. sf_close (file) ;
  945. printf ("okn") ;
  946. } /* pcm_float_test */