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

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

Audio

开发平台：

Unix_Linux

write_read_test.tpl：源码内容
  1. [+ AutoGen5 template c +]
  2. /*
  3. ** Copyright (C) 1999-2009 Erik de Castro Lopo <erikd@mega-nerd.com>
  4. **
  5. ** This program is free software; you can redistribute it and/or modify
  6. ** it under the terms of the GNU General Public License as published by
  7. ** the Free Software Foundation; either version 2 of the License, or
  8. ** (at your option) any later version.
  9. **
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ** GNU General Public License for more details.
  14. **
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  20. #include "sfconfig.h"
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  26. #if HAVE_UNISTD_H
  27. #include <unistd.h>
  28. #endif
  30. #include <math.h>
  32. #if (defined (WIN32) || defined (_WIN32))
  33. #include <fcntl.h>
  34. static int truncate (const char *filename, int ignored) ;
  35. #endif
  37. #include <sndfile.h>
  39. #include "utils.h"
  40. #include "generate.h"
  42. #define SAMPLE_RATE 11025
  43. #define DATA_LENGTH (1<<12)
  45. #define SILLY_WRITE_COUNT (234)
  47. [+ FOR data_type
  48. +]static void pcm_test_[+ (get "type_name") +] (const char *str, int format, int long_file_okz) ;
  49. [+ ENDFOR data_type
  50. +]
  51. static void empty_file_test (const char *filename, int format) ;
  53. typedef union
  54. { double d [DATA_LENGTH] ;
  55. float f [DATA_LENGTH] ;
  56. int i [DATA_LENGTH] ;
  57. short s [DATA_LENGTH] ;
  58. char c [DATA_LENGTH] ;
  59. } BUFFER ;
  61. static BUFFER orig_data ;
  62. static BUFFER test_data ;
  64. int
  65. main (int argc, char **argv)
  66. { int do_all = 0 ;
  67. int test_count = 0 ;
  69. count_open_files () ;
  71. if (argc != 2)
  72. { printf ("Usage : %s <test>n", argv [0]) ;
  73. printf ("    Where <test> is one of the following:n") ;
  74. printf ("           wav   - test WAV file functions (little endian)n") ;
  75. printf ("           aiff  - test AIFF file functions (big endian)n") ;
  76. printf ("           au    - test AU file functionsn") ;
  77. printf ("           avr   - test AVR file functionsn") ;
  78. printf ("           caf   - test CAF file functionsn") ;
  79. printf ("           raw   - test RAW header-less PCM file functionsn") ;
  80. printf ("           paf   - test PAF file functionsn") ;
  81. printf ("           svx   - test 8SVX/16SV file functionsn") ;
  82. printf ("           nist  - test NIST Sphere file functionsn") ;
  83. printf ("           ircam - test IRCAM file functionsn") ;
  84. printf ("           voc   - Create Voice file functionsn") ;
  85. printf ("           w64   - Sonic Foundry's W64 file functionsn") ;
  86. printf ("           flac  - test FLAC file functionsn") ;
  87. printf ("           mpc2k - test MPC 2000 file functionsn") ;
  88. printf ("           rf64  - test RF64 file functionsn") ;
  89. printf ("           all   - perform all testsn") ;
  90. exit (1) ;
  91. } ;
  93. do_all = !strcmp (argv [1], "all") ;
  95. if (do_all || ! strcmp (argv [1], "wav"))
  96. { pcm_test_char ("char.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_U8, SF_FALSE) ;
  97. pcm_test_short ("short.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_16, SF_FALSE) ;
  98. pcm_test_24bit ("24bit.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_24, SF_FALSE) ;
  99. pcm_test_int ("int.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_32, SF_FALSE) ;
  101. pcm_test_char ("char.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_U8, SF_FALSE) ;
  102. pcm_test_short ("short.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_16, SF_FALSE) ;
  103. pcm_test_24bit ("24bit.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_24, SF_FALSE) ;
  104. pcm_test_int ("int.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_32, SF_FALSE) ;
  106. pcm_test_24bit ("24bit.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_PCM_24, SF_FALSE) ;
  107. pcm_test_int ("int.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_PCM_32, SF_FALSE) ;
  109. /* Lite remove start */
  110. pcm_test_float ("float.wav" , SF_FORMAT_WAV | SF_FORMAT_FLOAT , SF_FALSE) ;
  111. pcm_test_double ("double.wav" , SF_FORMAT_WAV | SF_FORMAT_DOUBLE, SF_FALSE) ;
  113. pcm_test_float ("float.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_FLOAT , SF_FALSE) ;
  114. pcm_test_double ("double.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_DOUBLE, SF_FALSE) ;
  116. pcm_test_float ("float.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_FLOAT , SF_FALSE) ;
  117. pcm_test_double ("double.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_DOUBLE, SF_FALSE) ;
  118. /* Lite remove end */
  120. empty_file_test ("empty_char.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8) ;
  121. empty_file_test ("empty_short.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
  122. empty_file_test ("empty_float.wav", SF_FORMAT_WAV | SF_FORMAT_FLOAT) ;
  124. test_count++ ;
  125. } ;
  127. if (do_all || ! strcmp (argv [1], "aiff"))
  128. { pcm_test_char ("char_u8.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_U8, SF_FALSE) ;
  129. pcm_test_char ("char_s8.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  130. pcm_test_short ("short.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_16, SF_FALSE) ;
  131. pcm_test_24bit ("24bit.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_24, SF_FALSE) ;
  132. pcm_test_int ("int.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_32, SF_FALSE) ;
  134. pcm_test_short ("short_sowt.aifc" , SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | SF_FORMAT_PCM_16, SF_FALSE) ;
  135. pcm_test_24bit ("24bit_sowt.aifc" , SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | SF_FORMAT_PCM_24, SF_FALSE) ;
  136. pcm_test_int ("int_sowt.aifc" , SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | SF_FORMAT_PCM_32, SF_FALSE) ;
  138. pcm_test_short ("short_twos.aifc" , SF_ENDIAN_BIG | SF_FORMAT_AIFF | SF_FORMAT_PCM_16, SF_FALSE) ;
  139. pcm_test_24bit ("24bit_twos.aifc" , SF_ENDIAN_BIG | SF_FORMAT_AIFF | SF_FORMAT_PCM_24, SF_FALSE) ;
  140. pcm_test_int ("int_twos.aifc" , SF_ENDIAN_BIG | SF_FORMAT_AIFF | SF_FORMAT_PCM_32, SF_FALSE) ;
  142. /* Lite remove start */
  143. pcm_test_short ("dwvw16.aifc", SF_FORMAT_AIFF | SF_FORMAT_DWVW_16, SF_TRUE) ;
  144. pcm_test_24bit ("dwvw24.aifc", SF_FORMAT_AIFF | SF_FORMAT_DWVW_24, SF_TRUE) ;
  146. pcm_test_float ("float.aifc" , SF_FORMAT_AIFF | SF_FORMAT_FLOAT , SF_FALSE) ;
  147. pcm_test_double ("double.aifc" , SF_FORMAT_AIFF | SF_FORMAT_DOUBLE, SF_FALSE) ;
  148. /* Lite remove end */
  150. empty_file_test ("empty_char.aiff", SF_FORMAT_AIFF | SF_FORMAT_PCM_U8) ;
  151. empty_file_test ("empty_short.aiff", SF_FORMAT_AIFF | SF_FORMAT_PCM_16) ;
  152. empty_file_test ("empty_float.aiff", SF_FORMAT_AIFF | SF_FORMAT_FLOAT) ;
  154. test_count++ ;
  155. } ;
  157. if (do_all || ! strcmp (argv [1], "au"))
  158. { pcm_test_char ("char.au" , SF_FORMAT_AU | SF_FORMAT_PCM_S8, SF_FALSE) ;
  159. pcm_test_short ("short.au" , SF_FORMAT_AU | SF_FORMAT_PCM_16, SF_FALSE) ;
  160. pcm_test_24bit ("24bit.au" , SF_FORMAT_AU | SF_FORMAT_PCM_24, SF_FALSE) ;
  161. pcm_test_int ("int.au" , SF_FORMAT_AU | SF_FORMAT_PCM_32, SF_FALSE) ;
  162. /* Lite remove start */
  163. pcm_test_float ("float.au" , SF_FORMAT_AU | SF_FORMAT_FLOAT , SF_FALSE) ;
  164. pcm_test_double ("double.au", SF_FORMAT_AU | SF_FORMAT_DOUBLE, SF_FALSE) ;
  165. /* Lite remove end */
  167. pcm_test_char ("char_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_S8, SF_FALSE) ;
  168. pcm_test_short ("short_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_16, SF_FALSE) ;
  169. pcm_test_24bit ("24bit_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_24, SF_FALSE) ;
  170. pcm_test_int ("int_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_32, SF_FALSE) ;
  171. /* Lite remove start */
  172. pcm_test_float ("float_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT , SF_FALSE) ;
  173. pcm_test_double ("double_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE, SF_FALSE) ;
  174. /* Lite remove end */
  175. test_count++ ;
  176. } ;
  178. if (do_all || ! strcmp (argv [1], "caf"))
  179. { pcm_test_char ("char.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  180. pcm_test_short ("short.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  181. pcm_test_24bit ("24bit.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_24, SF_FALSE) ;
  182. pcm_test_int ("int.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_32, SF_FALSE) ;
  183. /* Lite remove start */
  184. pcm_test_float ("float.caf" , SF_FORMAT_CAF | SF_FORMAT_FLOAT , SF_FALSE) ;
  185. pcm_test_double ("double.caf" , SF_FORMAT_CAF | SF_FORMAT_DOUBLE, SF_FALSE) ;
  186. /* Lite remove end */
  188. pcm_test_short ("short_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  189. pcm_test_24bit ("24bit_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_PCM_24, SF_FALSE) ;
  190. pcm_test_int ("int_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_PCM_32, SF_FALSE) ;
  191. /* Lite remove start */
  192. pcm_test_float ("float_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_FLOAT , SF_FALSE) ;
  193. pcm_test_double ("double_le.caf", SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_DOUBLE, SF_FALSE) ;
  194. /* Lite remove end */
  195. test_count++ ;
  196. } ;
  198. if (do_all || ! strcmp (argv [1], "raw"))
  199. { pcm_test_char ("char_s8.raw" , SF_FORMAT_RAW | SF_FORMAT_PCM_S8, SF_FALSE) ;
  200. pcm_test_char ("char_u8.raw" , SF_FORMAT_RAW | SF_FORMAT_PCM_U8, SF_FALSE) ;
  202. pcm_test_short ("short_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_16, SF_FALSE) ;
  203. pcm_test_short ("short_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_16, SF_FALSE) ;
  204. pcm_test_24bit ("24bit_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_24, SF_FALSE) ;
  205. pcm_test_24bit ("24bit_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_24, SF_FALSE) ;
  206. pcm_test_int ("int_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_32, SF_FALSE) ;
  207. pcm_test_int ("int_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_32, SF_FALSE) ;
  209. /* Lite remove start */
  210. pcm_test_float ("float_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_FLOAT , SF_FALSE) ;
  211. pcm_test_float ("float_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_FLOAT , SF_FALSE) ;
  213. pcm_test_double ("double_le.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, SF_FALSE) ;
  214. pcm_test_double ("double_be.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, SF_FALSE) ;
  215. /* Lite remove end */
  216. test_count++ ;
  217. } ;
  219. /* Lite remove start */
  220. if (do_all || ! strcmp (argv [1], "paf"))
  221. { pcm_test_char ("char_le.paf", SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  222. pcm_test_char ("char_be.paf", SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  223. pcm_test_short ("short_le.paf", SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  224. pcm_test_short ("short_be.paf", SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  225. pcm_test_24bit ("24bit_le.paf", SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_24, SF_TRUE) ;
  226. pcm_test_24bit ("24bit_be.paf", SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_24, SF_TRUE) ;
  227. test_count++ ;
  228. } ;
  230. if (do_all || ! strcmp (argv [1], "svx"))
  231. { pcm_test_char ("char.svx" , SF_FORMAT_SVX | SF_FORMAT_PCM_S8, SF_FALSE) ;
  232. pcm_test_short ("short.svx", SF_FORMAT_SVX | SF_FORMAT_PCM_16, SF_FALSE) ;
  234. empty_file_test ("empty_char.svx", SF_FORMAT_SVX | SF_FORMAT_PCM_S8) ;
  235. empty_file_test ("empty_short.svx", SF_FORMAT_SVX | SF_FORMAT_PCM_16) ;
  237. test_count++ ;
  238. } ;
  240. if (do_all || ! strcmp (argv [1], "nist"))
  241. { pcm_test_short ("short_le.nist", SF_ENDIAN_LITTLE | SF_FORMAT_NIST | SF_FORMAT_PCM_16, SF_FALSE) ;
  242. pcm_test_short ("short_be.nist", SF_ENDIAN_BIG | SF_FORMAT_NIST | SF_FORMAT_PCM_16, SF_FALSE) ;
  243. pcm_test_24bit ("24bit_le.nist", SF_ENDIAN_LITTLE | SF_FORMAT_NIST | SF_FORMAT_PCM_24, SF_FALSE) ;
  244. pcm_test_24bit ("24bit_be.nist", SF_ENDIAN_BIG | SF_FORMAT_NIST | SF_FORMAT_PCM_24, SF_FALSE) ;
  245. pcm_test_int ("int_le.nist" , SF_ENDIAN_LITTLE | SF_FORMAT_NIST | SF_FORMAT_PCM_32, SF_FALSE) ;
  246. pcm_test_int  ("int_be.nist" , SF_ENDIAN_BIG | SF_FORMAT_NIST | SF_FORMAT_PCM_32, SF_FALSE) ;
  248. test_count++ ;
  249. } ;
  251. if (do_all || ! strcmp (argv [1], "ircam"))
  252. { pcm_test_short ("short_be.ircam" , SF_ENDIAN_BIG | SF_FORMAT_IRCAM | SF_FORMAT_PCM_16, SF_FALSE) ;
  253. pcm_test_short ("short_le.ircam" , SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_PCM_16, SF_FALSE) ;
  254. pcm_test_int ("int_be.ircam" , SF_ENDIAN_BIG | SF_FORMAT_IRCAM | SF_FORMAT_PCM_32, SF_FALSE) ;
  255. pcm_test_int  ("int_le.ircam" , SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_PCM_32, SF_FALSE) ;
  256. pcm_test_float ("float_be.ircam" , SF_ENDIAN_BIG | SF_FORMAT_IRCAM | SF_FORMAT_FLOAT , SF_FALSE) ;
  257. pcm_test_float ("float_le.ircam" , SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_FLOAT , SF_FALSE) ;
  259. test_count++ ;
  260. } ;
  262. if (do_all || ! strcmp (argv [1], "voc"))
  263. { pcm_test_char  ("char.voc" , SF_FORMAT_VOC | SF_FORMAT_PCM_U8, SF_FALSE) ;
  264. pcm_test_short ("short.voc", SF_FORMAT_VOC | SF_FORMAT_PCM_16, SF_FALSE) ;
  266. test_count++ ;
  267. } ;
  269. if (do_all || ! strcmp (argv [1], "mat4"))
  270. { pcm_test_short ("short_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_PCM_16, SF_FALSE) ;
  271. pcm_test_short ("short_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_PCM_16, SF_FALSE) ;
  272. pcm_test_int ("int_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_PCM_32, SF_FALSE) ;
  273. pcm_test_int  ("int_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_PCM_32, SF_FALSE) ;
  274. pcm_test_float ("float_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_FLOAT , SF_FALSE) ;
  275. pcm_test_float ("float_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_FLOAT , SF_FALSE) ;
  276. pcm_test_double ("double_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  277. pcm_test_double ("double_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  279. empty_file_test ("empty_short.mat4", SF_FORMAT_MAT4 | SF_FORMAT_PCM_16) ;
  280. empty_file_test ("empty_float.mat4", SF_FORMAT_MAT4 | SF_FORMAT_FLOAT) ;
  281. test_count++ ;
  282. } ;
  284. if (do_all || ! strcmp (argv [1], "mat5"))
  285. { pcm_test_char  ("char_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  286. pcm_test_char  ("char_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  287. pcm_test_short ("short_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_PCM_16, SF_FALSE) ;
  288. pcm_test_short ("short_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_PCM_16, SF_FALSE) ;
  289. pcm_test_int ("int_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_PCM_32, SF_FALSE) ;
  290. pcm_test_int  ("int_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_PCM_32, SF_FALSE) ;
  291. pcm_test_float ("float_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_FLOAT , SF_FALSE) ;
  292. pcm_test_float ("float_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_FLOAT , SF_FALSE) ;
  293. pcm_test_double ("double_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  294. pcm_test_double ("double_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  296. increment_open_file_count () ;
  298. empty_file_test ("empty_char.mat5", SF_FORMAT_MAT5 | SF_FORMAT_PCM_U8) ;
  299. empty_file_test ("empty_short.mat5", SF_FORMAT_MAT5 | SF_FORMAT_PCM_16) ;
  300. empty_file_test ("empty_float.mat5", SF_FORMAT_MAT5 | SF_FORMAT_FLOAT) ;
  302. test_count++ ;
  303. } ;
  305. if (do_all || ! strcmp (argv [1], "pvf"))
  306. { pcm_test_char  ("char.pvf" , SF_FORMAT_PVF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  307. pcm_test_short ("short.pvf", SF_FORMAT_PVF | SF_FORMAT_PCM_16, SF_FALSE) ;
  308. pcm_test_int ("int.pvf" , SF_FORMAT_PVF | SF_FORMAT_PCM_32, SF_FALSE) ;
  309. test_count++ ;
  310. } ;
  312. if (do_all || ! strcmp (argv [1], "htk"))
  313. { pcm_test_short ("short.htk", SF_FORMAT_HTK | SF_FORMAT_PCM_16, SF_FALSE) ;
  314. test_count++ ;
  315. } ;
  317. if (do_all || ! strcmp (argv [1], "mpc2k"))
  318. { pcm_test_short ("short.mpc", SF_FORMAT_MPC2K | SF_FORMAT_PCM_16, SF_FALSE) ;
  319. test_count++ ;
  320. } ;
  322. if (do_all || ! strcmp (argv [1], "avr"))
  323. { pcm_test_char  ("char_u8.avr" , SF_FORMAT_AVR | SF_FORMAT_PCM_U8, SF_FALSE) ;
  324. pcm_test_char  ("char_s8.avr" , SF_FORMAT_AVR | SF_FORMAT_PCM_S8, SF_FALSE) ;
  325. pcm_test_short ("short.avr" , SF_FORMAT_AVR | SF_FORMAT_PCM_16, SF_FALSE) ;
  326. test_count++ ;
  327. } ;
  328. /* Lite remove end */
  330. if (do_all || ! strcmp (argv [1], "w64"))
  331. { pcm_test_char ("char.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  332. pcm_test_short ("short.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_16, SF_FALSE) ;
  333. pcm_test_24bit ("24bit.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_24, SF_FALSE) ;
  334. pcm_test_int ("int.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_32, SF_FALSE) ;
  335. /* Lite remove start */
  336. pcm_test_float ("float.w64" , SF_FORMAT_W64 | SF_FORMAT_FLOAT , SF_FALSE) ;
  337. pcm_test_double ("double.w64" , SF_FORMAT_W64 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  338. /* Lite remove end */
  340. empty_file_test ("empty_char.w64", SF_FORMAT_W64 | SF_FORMAT_PCM_U8) ;
  341. empty_file_test ("empty_short.w64", SF_FORMAT_W64 | SF_FORMAT_PCM_16) ;
  342. empty_file_test ("empty_float.w64", SF_FORMAT_W64 | SF_FORMAT_FLOAT) ;
  344. test_count++ ;
  345. } ;
  347. if (do_all || ! strcmp (argv [1], "sds"))
  348. { pcm_test_char ("char.sds" , SF_FORMAT_SDS | SF_FORMAT_PCM_S8, SF_TRUE) ;
  349. pcm_test_short ("short.sds" , SF_FORMAT_SDS | SF_FORMAT_PCM_16, SF_TRUE) ;
  350. pcm_test_24bit ("24bit.sds" , SF_FORMAT_SDS | SF_FORMAT_PCM_24, SF_TRUE) ;
  352. empty_file_test ("empty_char.sds", SF_FORMAT_SDS | SF_FORMAT_PCM_S8) ;
  353. empty_file_test ("empty_short.sds", SF_FORMAT_SDS | SF_FORMAT_PCM_16) ;
  355. test_count++ ;
  356. } ;
  358. if (do_all || ! strcmp (argv [1], "sd2"))
  359. { pcm_test_char ("char.sd2" , SF_FORMAT_SD2 | SF_FORMAT_PCM_S8, SF_TRUE) ;
  360. pcm_test_short ("short.sd2" , SF_FORMAT_SD2 | SF_FORMAT_PCM_16, SF_TRUE) ;
  361. pcm_test_24bit ("24bit.sd2" , SF_FORMAT_SD2 | SF_FORMAT_PCM_24, SF_TRUE) ;
  362. test_count++ ;
  363. } ;
  365. if (do_all || ! strcmp (argv [1], "flac"))
  366. { if (HAVE_EXTERNAL_LIBS)
  367. { pcm_test_char ("char.flac" , SF_FORMAT_FLAC | SF_FORMAT_PCM_S8, SF_TRUE) ;
  368. pcm_test_short ("short.flac" , SF_FORMAT_FLAC | SF_FORMAT_PCM_16, SF_TRUE) ;
  369. pcm_test_24bit ("24bit.flac" , SF_FORMAT_FLAC | SF_FORMAT_PCM_24, SF_TRUE) ;
  370. }
  371. else
  372. puts ("    No FLAC tests because FLAC support was not compiled in.") ;
  373. test_count++ ;
  374. } ;
  376. if (do_all || ! strcmp (argv [1], "rf64"))
  377. { pcm_test_char ("char.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  378. pcm_test_short ("short.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_16, SF_FALSE) ;
  379. pcm_test_24bit ("24bit.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_24, SF_FALSE) ;
  380. pcm_test_int ("int.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_32, SF_FALSE) ;
  382. /* Lite remove start */
  383. pcm_test_float ("float.rf64" , SF_FORMAT_RF64 | SF_FORMAT_FLOAT , SF_FALSE) ;
  384. pcm_test_double ("double.rf64" , SF_FORMAT_RF64 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  385. empty_file_test ("empty_char.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_U8) ;
  386. empty_file_test ("empty_short.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_16) ;
  387. empty_file_test ("empty_float.rf64", SF_FORMAT_RF64 | SF_FORMAT_FLOAT) ;
  388. /* Lite remove end */
  390. test_count++ ;
  391. } ;
  393. if (test_count == 0)
  394. { printf ("Mono : ************************************n") ;
  395. printf ("Mono : *  No '%s' test defined.n", argv [1]) ;
  396. printf ("Mono : ************************************n") ;
  397. return 1 ;
  398. } ;
  400. /* Only open file descriptors should be stdin, stdout and stderr. */
  401. check_open_file_count_or_die (__LINE__) ;
  403. return 0 ;
  404. } /* main */
  406. /*============================================================================================
  407. ** Helper functions and macros.
  408. */
  410. static void create_short_file (const char *filename) ;
  412. #define CHAR_ERROR(x,y) (abs ((x) - (y)) > 255)
  413. #define INT_ERROR(x,y) (((x) - (y)) != 0)
  414. #define TRIBYTE_ERROR(x,y) (abs ((x) - (y)) > 255)
  415. #define FLOAT_ERROR(x,y) (fabs ((x) - (y)) > 1e-5)
  417. #define CONVERT_DATA(k,len,new,orig)
  418. { for ((k) = 0 ; (k) < (len) ; (k) ++)
  419. (new) [k] = (orig) [k] ;
  420. }
  422. [+ FOR data_type
  423. +]
  424. /*======================================================================================
  425. */
  427. static void mono_[+ (get "type_name") +]_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  428. static void stereo_[+ (get "type_name") +]_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  429. static void mono_rdwr_[+ (get "type_name") +]_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  430. static void new_rdwr_[+ (get "type_name") +]_test (const char *filename, int format, int allow_fd) ;
  431. static void multi_seek_test (const char * filename, int format) ;
  432. static void write_seek_extend_test (const char * filename, int format) ;
  434. static void
  435. pcm_test_[+ (get "type_name") +] (const char *filename, int format, int long_file_ok)
  436. { SF_INFO sfinfo ;
  437. [+ (get "data_type") +] *orig, *test ;
  438. int k, items, allow_fd ;
  440. /* Sd2 files cannot be opened from an existing file descriptor. */
  441. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  443. print_test_name ("pcm_test_[+ (get "type_name") +]", filename) ;
  445. sfinfo.samplerate = 44100 ;
  446. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  447. sfinfo.channels = 1 ;
  448. sfinfo.format = format ;
  450. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, [+ (get "max_val") +]) ;
  452. orig = orig_data.[+ (get "data_field") +] ;
  453. test = test_data.[+ (get "data_field") +] ;
  455. /* Make this a macro so gdb steps over it in one go. */
  456. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  458. items = DATA_LENGTH ;
  460. /* Some test broken out here. */
  462. mono_[+ (get "type_name") +]_test (filename, format, long_file_ok, allow_fd) ;
  464. /* Sub format DWVW does not allow seeking. */
  465. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  466. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  467. { unlink (filename) ;
  468. printf ("no seek : okn") ;
  469. return ;
  470. } ;
  472. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  473. mono_rdwr_[+ (get "type_name") +]_test (filename, format, long_file_ok, allow_fd) ;
  475. /* If the format doesn't support stereo we're done. */
  476. sfinfo.channels = 2 ;
  477. if (sf_format_check (&sfinfo) == 0)
  478. { unlink (filename) ;
  479. puts ("no stereo : ok") ;
  480. return ;
  481. } ;
  483. stereo_[+ (get "type_name") +]_test (filename, format, long_file_ok, allow_fd) ;
  485. /* New read/write test. Not sure if this is needed yet. */
  487. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  488. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  489. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  490. new_rdwr_[+ (get "type_name") +]_test (filename, format, allow_fd) ;
  492. delete_file (format, filename) ;
  494. puts ("ok") ;
  495. return ;
  496. } /* pcm_test_[+ (get "type_name") +] */
  498. static void
  499. mono_[+ (get "type_name") +]_test (const char *filename, int format, int long_file_ok, int allow_fd)
  500. { SNDFILE *file ;
  501. SF_INFO sfinfo ;
  502. [+ (get "data_type") +] *orig, *test ;
  503. sf_count_t count ;
  504. int k, items ;
  506. sfinfo.samplerate = 44100 ;
  507. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  508. sfinfo.channels = 1 ;
  509. sfinfo.format = format ;
  511. orig = orig_data.[+ (get "data_field") +] ;
  512. test = test_data.[+ (get "data_field") +] ;
  514. items = DATA_LENGTH ;
  516. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  518. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  520. test_write_[+ (get "data_type") +]_or_die (file, 0, orig, items, __LINE__) ;
  521. sf_write_sync (file) ;
  522. test_write_[+ (get "data_type") +]_or_die (file, 0, orig, items, __LINE__) ;
  523. sf_write_sync (file) ;
  525. /* Add non-audio data after the audio. */
  526. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  528. sf_close (file) ;
  530. memset (test, 0, items * sizeof ([+ (get "data_type") +])) ;
  532. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  533. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  535. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  537. if (sfinfo.format != format)
  538. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  539. exit (1) ;
  540. } ;
  542. if (sfinfo.frames < 2 * items)
  543. { printf ("nnLine %d : Mono : Incorrect number of frames in file (too short). (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), items) ;
  544. exit (1) ;
  545. } ;
  547. if (! long_file_ok && sfinfo.frames > 2 * items)
  548. { printf ("nnLine %d : Mono : Incorrect number of frames in file (too long). (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), items) ;
  549. exit (1) ;
  550. } ;
  552. if (sfinfo.channels != 1)
  553. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  554. exit (1) ;
  555. } ;
  557. check_log_buffer_or_die (file, __LINE__) ;
  559. test_read_[+ (get "data_type") +]_or_die (file, 0, test, items, __LINE__) ;
  560. for (k = 0 ; k < items ; k++)
  561. if ([+ (get "error_func") +] (orig [k], test [k]))
  562. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  563. oct_save_[+ (get "data_type") +] (orig, test, items) ;
  564. exit (1) ;
  565. } ;
  567. /* Seek to start of file. */
  568. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  570. test_read_[+ (get "data_type") +]_or_die (file, 0, test, 4, __LINE__) ;
  571. for (k = 0 ; k < 4 ; k++)
  572. if ([+ (get "error_func") +] (orig [k], test [k]))
  573. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  574. exit (1) ;
  575. } ;
  577. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  578. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  579. { sf_close (file) ;
  580. unlink (filename) ;
  581. printf ("no seek : ") ;
  582. return ;
  583. } ;
  585. /* Seek to offset from start of file. */
  586. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  588. test_read_[+ (get "data_type") +]_or_die (file, 0, test + 10, 4, __LINE__) ;
  589. for (k = 10 ; k < 14 ; k++)
  590. if ([+ (get "error_func") +] (orig [k], test [k]))
  591. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, test [k], orig [k]) ;
  592. exit (1) ;
  593. } ;
  595. /* Seek to offset from current position. */
  596. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  598. test_read_[+ (get "data_type") +]_or_die (file, 0, test + 20, 4, __LINE__) ;
  599. for (k = 20 ; k < 24 ; k++)
  600. if ([+ (get "error_func") +] (orig [k], test [k]))
  601. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, test [k], orig [k]) ;
  602. exit (1) ;
  603. } ;
  605. /* Seek to offset from end of file. */
  606. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  608. test_read_[+ (get "data_type") +]_or_die (file, 0, test + 10, 4, __LINE__) ;
  609. for (k = 10 ; k < 14 ; k++)
  610. if ([+ (get "error_func") +] (orig [k], test [k]))
  611. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, test [k], orig [k]) ;
  612. exit (1) ;
  613. } ;
  615. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  616. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  618. count = 0 ;
  619. while (count < sfinfo.frames)
  620. count += sf_read_[+ (get "data_type") +] (file, test, 311) ;
  622. /* Check that no error has occurred. */
  623. if (sf_error (file))
  624. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  625. puts (sf_strerror (file)) ;
  626. exit (1) ;
  627. } ;
  629. /* Check that we haven't read beyond EOF. */
  630. if (count > sfinfo.frames)
  631. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  632. exit (1) ;
  633. } ;
  635. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  637. sf_close (file) ;
  639. multi_seek_test (filename, format) ;
  640. write_seek_extend_test (filename, format) ;
  642. } /* mono_[+ (get "type_name") +]_test */
  644. static void
  645. stereo_[+ (get "type_name") +]_test (const char *filename, int format, int long_file_ok, int allow_fd)
  646. { SNDFILE *file ;
  647. SF_INFO sfinfo ;
  648. [+ (get "data_type") +] *orig, *test ;
  649. int k, items, frames ;
  651. sfinfo.samplerate = 44100 ;
  652. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  653. sfinfo.channels = 2 ;
  654. sfinfo.format = format ;
  656. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, [+ (get "max_val") +]) ;
  658. orig = orig_data.[+ (get "data_field") +] ;
  659. test = test_data.[+ (get "data_field") +] ;
  661. /* Make this a macro so gdb steps over it in one go. */
  662. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  664. items = DATA_LENGTH ;
  665. frames = items / sfinfo.channels ;
  667. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  669. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  671. test_writef_[+ (get "data_type") +]_or_die (file, 0, orig, frames, __LINE__) ;
  673. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  675. sf_close (file) ;
  677. memset (test, 0, items * sizeof ([+ (get "data_type") +])) ;
  679. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  680. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  682. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  684. if (sfinfo.format != format)
  685. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  686. __LINE__, format, sfinfo.format) ;
  687. exit (1) ;
  688. } ;
  690. if (sfinfo.frames < frames)
  691. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  692. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  693. exit (1) ;
  694. } ;
  696. if (! long_file_ok && sfinfo.frames > frames)
  697. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  698. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  699. exit (1) ;
  700. } ;
  702. if (sfinfo.channels != 2)
  703. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  704. exit (1) ;
  705. } ;
  707. check_log_buffer_or_die (file, __LINE__) ;
  709. test_readf_[+ (get "data_type") +]_or_die (file, 0, test, frames, __LINE__) ;
  710. for (k = 0 ; k < items ; k++)
  711. if ([+ (get "error_func") +] (test [k], orig [k]))
  712. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  713. exit (1) ;
  714. } ;
  716. /* Seek to start of file. */
  717. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  719. test_readf_[+ (get "data_type") +]_or_die (file, 0, test, 2, __LINE__) ;
  720. for (k = 0 ; k < 4 ; k++)
  721. if ([+ (get "error_func") +] (test [k], orig [k]))
  722. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  723. exit (1) ;
  724. } ;
  726. /* Seek to offset from start of file. */
  727. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  729. /* Check for errors here. */
  730. if (sf_error (file))
  731. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  732. puts (sf_strerror (file)) ;
  733. exit (1) ;
  734. } ;
  736. if (sf_read_[+ (get "data_type") +] (file, test, 1) > 0)
  737. { printf ("Line %d: Should return 0.n", __LINE__) ;
  738. exit (1) ;
  739. } ;
  741. if (! sf_error (file))
  742. { printf ("Line %d: Should return an error.n", __LINE__) ;
  743. exit (1) ;
  744. } ;
  745. /*-----------------------*/
  747. test_readf_[+ (get "data_type") +]_or_die (file, 0, test + 10, 2, __LINE__) ;
  748. for (k = 20 ; k < 24 ; k++)
  749. if ([+ (get "error_func") +] (test [k], orig [k]))
  750. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  751. exit (1) ;
  752. } ;
  754. /* Seek to offset from current position. */
  755. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  757. test_readf_[+ (get "data_type") +]_or_die (file, 0, test + 20, 2, __LINE__) ;
  758. for (k = 40 ; k < 44 ; k++)
  759. if ([+ (get "error_func") +] (test [k], orig [k]))
  760. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  761. exit (1) ;
  762. } ;
  764. /* Seek to offset from end of file. */
  765. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  767. test_readf_[+ (get "data_type") +]_or_die (file, 0, test + 20, 2, __LINE__) ;
  768. for (k = 20 ; k < 24 ; k++)
  769. if ([+ (get "error_func") +] (test [k], orig [k]))
  770. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : [+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, k, orig [k], test [k]) ;
  771. exit (1) ;
  772. } ;
  774. sf_close (file) ;
  775. } /* stereo_[+ (get "type_name") +]_test */
  777. static void
  778. mono_rdwr_[+ (get "type_name") +]_test (const char *filename, int format, int long_file_ok, int allow_fd)
  779. { SNDFILE *file ;
  780. SF_INFO sfinfo ;
  781. [+ (get "data_type") +] *orig, *test ;
  782. int k, pass ;
  784. orig = orig_data.[+ (get "data_field") +] ;
  785. test = test_data.[+ (get "data_field") +] ;
  787. sfinfo.samplerate = SAMPLE_RATE ;
  788. sfinfo.frames = DATA_LENGTH ;
  789. sfinfo.channels = 1 ;
  790. sfinfo.format = format ;
  792. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  793. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  794. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  795. unlink (filename) ;
  796. else
  797. { /* Create a short file. */
  798. create_short_file (filename) ;
  800. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  801. ** If this returns a valif pointer sf_open() screwed up.
  802. */
  803. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  804. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  805. exit (1) ;
  806. } ;
  808. /* Truncate the file to zero bytes. */
  809. if (truncate (filename, 0) < 0)
  810. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  811. perror (NULL) ;
  812. exit (1) ;
  813. } ;
  814. } ;
  816. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  817. ** all the usual data required when opening the file in WRITE mode.
  818. */
  819. sfinfo.samplerate = SAMPLE_RATE ;
  820. sfinfo.frames = DATA_LENGTH ;
  821. sfinfo.channels = 1 ;
  822. sfinfo.format = format ;
  824. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  826. /* Do 3 writes followed by reads. After each, check the data and the current
  827. ** read and write offsets.
  828. */
  829. for (pass = 1 ; pass <= 3 ; pass ++)
  830. { orig [20] = pass * 2 ;
  832. /* Write some data. */
  833. test_write_[+ (get "data_type") +]_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  835. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  837. /* Read what we just wrote. */
  838. test_read_[+ (get "data_type") +]_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  840. /* Check the data. */
  841. for (k = 0 ; k < DATA_LENGTH ; k++)
  842. if ([+ (get "error_func") +] (orig [k], test [k]))
  843. { printf ("nnLine %d (pass %d) A : Error at sample %d ([+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, pass, k, orig [k], test [k]) ;
  844. oct_save_[+ (get "data_type") +] (orig, test, DATA_LENGTH) ;
  845. exit (1) ;
  846. } ;
  848. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  849. } ; /* for (pass ...) */
  851. sf_close (file) ;
  853. /* Open the file again to check the data. */
  854. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  856. if (sfinfo.format != format)
  857. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  858. exit (1) ;
  859. } ;
  861. if (sfinfo.frames < 3 * DATA_LENGTH)
  862. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  863. exit (1) ;
  864. }
  866. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  867. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  868. exit (1) ;
  869. } ;
  871. if (sfinfo.channels != 1)
  872. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  873. exit (1) ;
  874. } ;
  876. if (! long_file_ok)
  877. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  878. else
  879. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  881. for (pass = 1 ; pass <= 3 ; pass ++)
  882. { orig [20] = pass * 2 ;
  884. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  886. /* Read what we just wrote. */
  887. test_read_[+ (get "data_type") +]_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  889. /* Check the data. */
  890. for (k = 0 ; k < DATA_LENGTH ; k++)
  891. if ([+ (get "error_func") +] (orig [k], test [k]))
  892. { printf ("nnLine %d (pass %d) B : Error at sample %d ([+ (get "format_char") +] => [+ (get "format_char") +]).n", __LINE__, pass, k, orig [k], test [k]) ;
  893. oct_save_[+ (get "data_type") +] (orig, test, DATA_LENGTH) ;
  894. exit (1) ;
  895. } ;
  897. } ; /* for (pass ...) */
  899. sf_close (file) ;
  900. } /* mono_rdwr_[+ (get "data_type") +]_test */
  902. static void
  903. new_rdwr_[+ (get "type_name") +]_test (const char *filename, int format, int allow_fd)
  904. { SNDFILE *wfile, *rwfile ;
  905. SF_INFO sfinfo ;
  906. [+ (get "data_type") +] *orig, *test ;
  907. int items, frames ;
  909. orig = orig_data.[+ (get "data_field") +] ;
  910. test = test_data.[+ (get "data_field") +] ;
  912. sfinfo.samplerate = 44100 ;
  913. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  914. sfinfo.channels = 2 ;
  915. sfinfo.format = format ;
  917. items = DATA_LENGTH ;
  918. frames = items / sfinfo.channels ;
  920. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  921. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  922. test_writef_[+ (get "data_type") +]_or_die (wfile, 1, orig, frames, __LINE__) ;
  923. sf_write_sync (wfile) ;
  924. test_writef_[+ (get "data_type") +]_or_die (wfile, 2, orig, frames, __LINE__) ;
  925. sf_write_sync (wfile) ;
  927. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  928. if (sfinfo.frames != 2 * frames)
  929. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  930. exit (1) ;
  931. } ;
  933. test_writef_[+ (get "data_type") +]_or_die (wfile, 3, orig, frames, __LINE__) ;
  935. test_readf_[+ (get "data_type") +]_or_die (rwfile, 1, test, frames, __LINE__) ;
  936. test_readf_[+ (get "data_type") +]_or_die (rwfile, 2, test, frames, __LINE__) ;
  938. sf_close (wfile) ;
  939. sf_close (rwfile) ;
  940. } /* new_rdwr_[+ (get "type_name") +]_test */
  942. [+ ENDFOR data_type +]
  944. /*----------------------------------------------------------------------------------------
  945. */
  947. static void
  948. empty_file_test (const char *filename, int format)
  949. { SNDFILE *file ;
  950. SF_INFO info ;
  951. int allow_fd ;
  953. /* Sd2 files cannot be opened from an existing file descriptor. */
  954. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  956. print_test_name ("empty_file_test", filename) ;
  958. unlink (filename) ;
  960. info.samplerate = 48000 ;
  961. info.channels = 2 ;
  962. info.format = format ;
  964. if (sf_format_check (&info) == SF_FALSE)
  965. { info.channels = 1 ;
  966. if (sf_format_check (&info) == SF_FALSE)
  967. { puts ("invalid file format") ;
  968. return ;
  969. } ;
  970. } ;
  972. /* Create an empty file. */
  973. file = test_open_file_or_die (filename, SFM_WRITE, &info, allow_fd, __LINE__) ;
  974. sf_close (file) ;
  976. /* Open for read and check the length. */
  977. file = test_open_file_or_die (filename, SFM_READ, &info, allow_fd, __LINE__) ;
  979. if (SF_COUNT_TO_LONG (info.frames) != 0)
  980. { printf ("nnError : frame count (%ld) should be zero.n", SF_COUNT_TO_LONG (info.frames)) ;
  981. exit (1) ;
  982. } ;
  984. sf_close (file) ;
  986. /* Open for read/write and check the length. */
  987. file = test_open_file_or_die (filename, SFM_RDWR, &info, allow_fd, __LINE__) ;
  989. if (SF_COUNT_TO_LONG (info.frames) != 0)
  990. { printf ("nnError : frame count (%ld) should be zero.n", SF_COUNT_TO_LONG (info.frames)) ;
  991. exit (1) ;
  992. } ;
  994. sf_close (file) ;
  996. /* Open for read and check the length. */
  997. file = test_open_file_or_die (filename, SFM_READ, &info, allow_fd, __LINE__) ;
  999. if (SF_COUNT_TO_LONG (info.frames) != 0)
  1000. { printf ("nnError : frame count (%ld) should be zero.n", SF_COUNT_TO_LONG (info.frames)) ;
  1001. exit (1) ;
  1002. } ;
  1004. sf_close (file) ;
  1006. check_open_file_count_or_die (__LINE__) ;
  1008. unlink (filename) ;
  1009. puts ("ok") ;
  1011. return ;
  1012. } /* empty_file_test */
  1015. /*----------------------------------------------------------------------------------------
  1016. */
  1018. static void
  1019. create_short_file (const char *filename)
  1020. { FILE *file ;
  1022. if (! (file = fopen (filename, "w")))
  1023. { printf ("create_short_file : fopen (%s, "w") failed.", filename) ;
  1024. fflush (stdout) ;
  1025. perror (NULL) ;
  1026. exit (1) ;
  1027. } ;
  1029. fprintf (file, "This is the file data.n") ;
  1031. fclose (file) ;
  1032. } /* create_short_file */
  1034. #if (defined (WIN32) || defined (__WIN32))
  1036. /* Win32 does not have truncate (nor does it have the POSIX function ftruncate).
  1037. ** Hack somethng up here to over come this. This function can only truncate to a
  1038. ** length of zero.
  1039. */
  1041. static int
  1042. truncate (const char *filename, int ignored)
  1043. { int fd ;
  1045. ignored = 0 ;
  1047. if ((fd = open (filename, O_RDWR | O_TRUNC | O_BINARY)) < 0)
  1048. return 0 ;
  1050. close (fd) ;
  1052. return 0 ;
  1053. } /* truncate */
  1055. #endif
  1057. static void
  1058. multi_seek_test (const char * filename, int format)
  1059. { SNDFILE * file ;
  1060. SF_INFO info ;
  1061. sf_count_t pos ;
  1062. int k ;
  1064. /* This test doesn't work on the following. */
  1065. switch (format & SF_FORMAT_TYPEMASK)
  1066. { case SF_FORMAT_RAW :
  1067. return ;
  1069. default :
  1070. break ;
  1071. } ;
  1073. memset (&info, 0, sizeof (info)) ;
  1075. generate_file (filename, format, 88200) ;
  1077. file = test_open_file_or_die (filename, SFM_READ, &info, SF_FALSE, __LINE__) ;
  1079. for (k = 0 ; k < 10 ; k++)
  1080. { pos = info.frames / (k + 2) ;
  1081. test_seek_or_die (file, pos, SEEK_SET, pos, info.channels, __LINE__) ;
  1082. } ;
  1084. sf_close (file) ;
  1085. } /* multi_seek_test */
  1087. static void
  1088. write_seek_extend_test (const char * filename, int format)
  1089. { SNDFILE * file ;
  1090. SF_INFO info ;
  1091. short *orig, *test ;
  1092. unsigned items, k ;
  1094. /* This test doesn't work on the following. */
  1095. switch (format & SF_FORMAT_TYPEMASK)
  1096. { case SF_FORMAT_FLAC :
  1097. case SF_FORMAT_HTK :
  1098. case SF_FORMAT_PAF :
  1099. case SF_FORMAT_SDS :
  1100. case SF_FORMAT_SVX :
  1101. return ;
  1103. default :
  1104. break ;
  1105. } ;
  1107. memset (&info, 0, sizeof (info)) ;
  1109. info.samplerate = 48000 ;
  1110. info.channels = 1 ;
  1111. info.format = format ;
  1113. items = 512 ;
  1114. exit_if_true (items > ARRAY_LEN (orig_data.s), "Line %d : Bad assumption.n", __LINE__) ;
  1116. orig = orig_data.s ;
  1117. test = test_data.s ;
  1119. for (k = 0 ; k < ARRAY_LEN (orig_data.s) ; k++)
  1120. orig [k] = 0x3fff ;
  1122. file = test_open_file_or_die (filename, SFM_WRITE, &info, SF_FALSE, __LINE__) ;
  1123. test_write_short_or_die (file, 0, orig, items, __LINE__) ;
  1125. /* Extend the file using a seek. */
  1126. test_seek_or_die (file, 2 * items, SEEK_SET, 2 * items, info.channels, __LINE__) ;
  1128. test_writef_short_or_die (file, 0, orig, items, __LINE__) ;
  1129. sf_close (file) ;
  1131. file = test_open_file_or_die (filename, SFM_READ, &info, SF_FALSE, __LINE__) ;
  1132. test_read_short_or_die (file, 0, test, 3 * items, __LINE__) ;
  1133. sf_close (file) ;
  1135. /* Can't do these formats due to scaling. */
  1136. switch (format & SF_FORMAT_SUBMASK)
  1137. { case SF_FORMAT_PCM_S8 :
  1138. case SF_FORMAT_PCM_U8 :
  1139. return ;
  1140. default :
  1141. break ;
  1142. } ;
  1144. for (k = 0 ; k < items ; k++)
  1145. { exit_if_true (test [k] != 0x3fff, "Line %d : test [%d] == %d, should be 0x3fff.n", __LINE__, k, test [k]) ;
  1146. exit_if_true (test [items + k] != 0, "Line %d : test [%d] == %d, should be 0.n", __LINE__, items + k, test [items + k]) ;
  1147. exit_if_true (test [2 * items + k] != 0x3fff, "Line %d : test [%d] == %d, should be 0x3fff.n", __LINE__, 2 * items + k, test [2 * items + k]) ;
  1148. } ;
  1150. return ;
  1151. } /* write_seek_extend_test */