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

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

Audio

开发平台：

Unix_Linux

write_read_test.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2009 Erik de Castro Lopo <erikd@mega-nerd.com>
  3. **
  4. ** This program is free software; you can redistribute it and/or modify
  5. ** it under the terms of the GNU General Public License as published by
  6. ** the Free Software Foundation; either version 2 of the License, or
  7. ** (at your option) any later version.
  8. **
  9. ** This program is distributed in the hope that it will be useful,
  10. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. ** GNU General Public License for more details.
  13. **
  14. ** You should have received a copy of the GNU General Public License
  15. ** along with this program; if not, write to the Free Software
  16. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. */
  19. #include "sfconfig.h"
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  25. #if HAVE_UNISTD_H
  26. #include <unistd.h>
  27. #endif
  29. #include <math.h>
  31. #if (defined (WIN32) || defined (_WIN32))
  32. #include <fcntl.h>
  33. static int truncate (const char *filename, int ignored) ;
  34. #endif
  36. #include <sndfile.h>
  38. #include "utils.h"
  39. #include "generate.h"
  41. #define SAMPLE_RATE 11025
  42. #define DATA_LENGTH (1<<12)
  44. #define SILLY_WRITE_COUNT (234)
  46. static void pcm_test_char (const char *str, int format, int long_file_okz) ;
  47. static void pcm_test_short (const char *str, int format, int long_file_okz) ;
  48. static void pcm_test_24bit (const char *str, int format, int long_file_okz) ;
  49. static void pcm_test_int (const char *str, int format, int long_file_okz) ;
  50. static void pcm_test_float (const char *str, int format, int long_file_okz) ;
  51. static void pcm_test_double (const char *str, int format, int long_file_okz) ;
  53. static void empty_file_test (const char *filename, int format) ;
  55. typedef union
  56. { double d [DATA_LENGTH] ;
  57. float f [DATA_LENGTH] ;
  58. int i [DATA_LENGTH] ;
  59. short s [DATA_LENGTH] ;
  60. char c [DATA_LENGTH] ;
  61. } BUFFER ;
  63. static BUFFER orig_data ;
  64. static BUFFER test_data ;
  66. int
  67. main (int argc, char **argv)
  68. { int do_all = 0 ;
  69. int test_count = 0 ;
  71. count_open_files () ;
  73. if (argc != 2)
  74. { printf ("Usage : %s <test>n", argv [0]) ;
  75. printf ("    Where <test> is one of the following:n") ;
  76. printf ("           wav   - test WAV file functions (little endian)n") ;
  77. printf ("           aiff  - test AIFF file functions (big endian)n") ;
  78. printf ("           au    - test AU file functionsn") ;
  79. printf ("           avr   - test AVR file functionsn") ;
  80. printf ("           caf   - test CAF file functionsn") ;
  81. printf ("           raw   - test RAW header-less PCM file functionsn") ;
  82. printf ("           paf   - test PAF file functionsn") ;
  83. printf ("           svx   - test 8SVX/16SV file functionsn") ;
  84. printf ("           nist  - test NIST Sphere file functionsn") ;
  85. printf ("           ircam - test IRCAM file functionsn") ;
  86. printf ("           voc   - Create Voice file functionsn") ;
  87. printf ("           w64   - Sonic Foundry's W64 file functionsn") ;
  88. printf ("           flac  - test FLAC file functionsn") ;
  89. printf ("           mpc2k - test MPC 2000 file functionsn") ;
  90. printf ("           rf64  - test RF64 file functionsn") ;
  91. printf ("           all   - perform all testsn") ;
  92. exit (1) ;
  93. } ;
  95. do_all = !strcmp (argv [1], "all") ;
  97. if (do_all || ! strcmp (argv [1], "wav"))
  98. { pcm_test_char ("char.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_U8, SF_FALSE) ;
  99. pcm_test_short ("short.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_16, SF_FALSE) ;
  100. pcm_test_24bit ("24bit.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_24, SF_FALSE) ;
  101. pcm_test_int ("int.wav" , SF_FORMAT_WAV | SF_FORMAT_PCM_32, SF_FALSE) ;
  103. pcm_test_char ("char.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_U8, SF_FALSE) ;
  104. pcm_test_short ("short.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_16, SF_FALSE) ;
  105. pcm_test_24bit ("24bit.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_24, SF_FALSE) ;
  106. pcm_test_int ("int.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_32, SF_FALSE) ;
  108. pcm_test_24bit ("24bit.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_PCM_24, SF_FALSE) ;
  109. pcm_test_int ("int.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_PCM_32, SF_FALSE) ;
  111. /* Lite remove start */
  112. pcm_test_float ("float.wav" , SF_FORMAT_WAV | SF_FORMAT_FLOAT , SF_FALSE) ;
  113. pcm_test_double ("double.wav" , SF_FORMAT_WAV | SF_FORMAT_DOUBLE, SF_FALSE) ;
  115. pcm_test_float ("float.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_FLOAT , SF_FALSE) ;
  116. pcm_test_double ("double.rifx" , SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_DOUBLE, SF_FALSE) ;
  118. pcm_test_float ("float.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_FLOAT , SF_FALSE) ;
  119. pcm_test_double ("double.wavex" , SF_FORMAT_WAVEX | SF_FORMAT_DOUBLE, SF_FALSE) ;
  120. /* Lite remove end */
  122. empty_file_test ("empty_char.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8) ;
  123. empty_file_test ("empty_short.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
  124. empty_file_test ("empty_float.wav", SF_FORMAT_WAV | SF_FORMAT_FLOAT) ;
  126. test_count++ ;
  127. } ;
  129. if (do_all || ! strcmp (argv [1], "aiff"))
  130. { pcm_test_char ("char_u8.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_U8, SF_FALSE) ;
  131. pcm_test_char ("char_s8.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  132. pcm_test_short ("short.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_16, SF_FALSE) ;
  133. pcm_test_24bit ("24bit.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_24, SF_FALSE) ;
  134. pcm_test_int ("int.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_32, SF_FALSE) ;
  136. pcm_test_short ("short_sowt.aifc" , SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | SF_FORMAT_PCM_16, SF_FALSE) ;
  137. pcm_test_24bit ("24bit_sowt.aifc" , SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | SF_FORMAT_PCM_24, SF_FALSE) ;
  138. pcm_test_int ("int_sowt.aifc" , SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | SF_FORMAT_PCM_32, SF_FALSE) ;
  140. pcm_test_short ("short_twos.aifc" , SF_ENDIAN_BIG | SF_FORMAT_AIFF | SF_FORMAT_PCM_16, SF_FALSE) ;
  141. pcm_test_24bit ("24bit_twos.aifc" , SF_ENDIAN_BIG | SF_FORMAT_AIFF | SF_FORMAT_PCM_24, SF_FALSE) ;
  142. pcm_test_int ("int_twos.aifc" , SF_ENDIAN_BIG | SF_FORMAT_AIFF | SF_FORMAT_PCM_32, SF_FALSE) ;
  144. /* Lite remove start */
  145. pcm_test_short ("dwvw16.aifc", SF_FORMAT_AIFF | SF_FORMAT_DWVW_16, SF_TRUE) ;
  146. pcm_test_24bit ("dwvw24.aifc", SF_FORMAT_AIFF | SF_FORMAT_DWVW_24, SF_TRUE) ;
  148. pcm_test_float ("float.aifc" , SF_FORMAT_AIFF | SF_FORMAT_FLOAT , SF_FALSE) ;
  149. pcm_test_double ("double.aifc" , SF_FORMAT_AIFF | SF_FORMAT_DOUBLE, SF_FALSE) ;
  150. /* Lite remove end */
  152. empty_file_test ("empty_char.aiff", SF_FORMAT_AIFF | SF_FORMAT_PCM_U8) ;
  153. empty_file_test ("empty_short.aiff", SF_FORMAT_AIFF | SF_FORMAT_PCM_16) ;
  154. empty_file_test ("empty_float.aiff", SF_FORMAT_AIFF | SF_FORMAT_FLOAT) ;
  156. test_count++ ;
  157. } ;
  159. if (do_all || ! strcmp (argv [1], "au"))
  160. { pcm_test_char ("char.au" , SF_FORMAT_AU | SF_FORMAT_PCM_S8, SF_FALSE) ;
  161. pcm_test_short ("short.au" , SF_FORMAT_AU | SF_FORMAT_PCM_16, SF_FALSE) ;
  162. pcm_test_24bit ("24bit.au" , SF_FORMAT_AU | SF_FORMAT_PCM_24, SF_FALSE) ;
  163. pcm_test_int ("int.au" , SF_FORMAT_AU | SF_FORMAT_PCM_32, SF_FALSE) ;
  164. /* Lite remove start */
  165. pcm_test_float ("float.au" , SF_FORMAT_AU | SF_FORMAT_FLOAT , SF_FALSE) ;
  166. pcm_test_double ("double.au", SF_FORMAT_AU | SF_FORMAT_DOUBLE, SF_FALSE) ;
  167. /* Lite remove end */
  169. pcm_test_char ("char_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_S8, SF_FALSE) ;
  170. pcm_test_short ("short_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_16, SF_FALSE) ;
  171. pcm_test_24bit ("24bit_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_24, SF_FALSE) ;
  172. pcm_test_int ("int_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_32, SF_FALSE) ;
  173. /* Lite remove start */
  174. pcm_test_float ("float_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT , SF_FALSE) ;
  175. pcm_test_double ("double_le.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE, SF_FALSE) ;
  176. /* Lite remove end */
  177. test_count++ ;
  178. } ;
  180. if (do_all || ! strcmp (argv [1], "caf"))
  181. { pcm_test_char ("char.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  182. pcm_test_short ("short.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  183. pcm_test_24bit ("24bit.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_24, SF_FALSE) ;
  184. pcm_test_int ("int.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_32, SF_FALSE) ;
  185. /* Lite remove start */
  186. pcm_test_float ("float.caf" , SF_FORMAT_CAF | SF_FORMAT_FLOAT , SF_FALSE) ;
  187. pcm_test_double ("double.caf" , SF_FORMAT_CAF | SF_FORMAT_DOUBLE, SF_FALSE) ;
  188. /* Lite remove end */
  190. pcm_test_short ("short_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  191. pcm_test_24bit ("24bit_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_PCM_24, SF_FALSE) ;
  192. pcm_test_int ("int_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_PCM_32, SF_FALSE) ;
  193. /* Lite remove start */
  194. pcm_test_float ("float_le.caf" , SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_FLOAT , SF_FALSE) ;
  195. pcm_test_double ("double_le.caf", SF_ENDIAN_LITTLE | SF_FORMAT_CAF | SF_FORMAT_DOUBLE, SF_FALSE) ;
  196. /* Lite remove end */
  197. test_count++ ;
  198. } ;
  200. if (do_all || ! strcmp (argv [1], "raw"))
  201. { pcm_test_char ("char_s8.raw" , SF_FORMAT_RAW | SF_FORMAT_PCM_S8, SF_FALSE) ;
  202. pcm_test_char ("char_u8.raw" , SF_FORMAT_RAW | SF_FORMAT_PCM_U8, SF_FALSE) ;
  204. pcm_test_short ("short_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_16, SF_FALSE) ;
  205. pcm_test_short ("short_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_16, SF_FALSE) ;
  206. pcm_test_24bit ("24bit_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_24, SF_FALSE) ;
  207. pcm_test_24bit ("24bit_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_24, SF_FALSE) ;
  208. pcm_test_int ("int_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_32, SF_FALSE) ;
  209. pcm_test_int ("int_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_PCM_32, SF_FALSE) ;
  211. /* Lite remove start */
  212. pcm_test_float ("float_le.raw" , SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_FLOAT , SF_FALSE) ;
  213. pcm_test_float ("float_be.raw" , SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_FLOAT , SF_FALSE) ;
  215. pcm_test_double ("double_le.raw", SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, SF_FALSE) ;
  216. pcm_test_double ("double_be.raw", SF_ENDIAN_BIG | SF_FORMAT_RAW | SF_FORMAT_DOUBLE, SF_FALSE) ;
  217. /* Lite remove end */
  218. test_count++ ;
  219. } ;
  221. /* Lite remove start */
  222. if (do_all || ! strcmp (argv [1], "paf"))
  223. { pcm_test_char ("char_le.paf", SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  224. pcm_test_char ("char_be.paf", SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  225. pcm_test_short ("short_le.paf", SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  226. pcm_test_short ("short_be.paf", SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_16, SF_FALSE) ;
  227. pcm_test_24bit ("24bit_le.paf", SF_ENDIAN_LITTLE | SF_FORMAT_PAF | SF_FORMAT_PCM_24, SF_TRUE) ;
  228. pcm_test_24bit ("24bit_be.paf", SF_ENDIAN_BIG | SF_FORMAT_PAF | SF_FORMAT_PCM_24, SF_TRUE) ;
  229. test_count++ ;
  230. } ;
  232. if (do_all || ! strcmp (argv [1], "svx"))
  233. { pcm_test_char ("char.svx" , SF_FORMAT_SVX | SF_FORMAT_PCM_S8, SF_FALSE) ;
  234. pcm_test_short ("short.svx", SF_FORMAT_SVX | SF_FORMAT_PCM_16, SF_FALSE) ;
  236. empty_file_test ("empty_char.svx", SF_FORMAT_SVX | SF_FORMAT_PCM_S8) ;
  237. empty_file_test ("empty_short.svx", SF_FORMAT_SVX | SF_FORMAT_PCM_16) ;
  239. test_count++ ;
  240. } ;
  242. if (do_all || ! strcmp (argv [1], "nist"))
  243. { pcm_test_short ("short_le.nist", SF_ENDIAN_LITTLE | SF_FORMAT_NIST | SF_FORMAT_PCM_16, SF_FALSE) ;
  244. pcm_test_short ("short_be.nist", SF_ENDIAN_BIG | SF_FORMAT_NIST | SF_FORMAT_PCM_16, SF_FALSE) ;
  245. pcm_test_24bit ("24bit_le.nist", SF_ENDIAN_LITTLE | SF_FORMAT_NIST | SF_FORMAT_PCM_24, SF_FALSE) ;
  246. pcm_test_24bit ("24bit_be.nist", SF_ENDIAN_BIG | SF_FORMAT_NIST | SF_FORMAT_PCM_24, SF_FALSE) ;
  247. pcm_test_int ("int_le.nist" , SF_ENDIAN_LITTLE | SF_FORMAT_NIST | SF_FORMAT_PCM_32, SF_FALSE) ;
  248. pcm_test_int  ("int_be.nist" , SF_ENDIAN_BIG | SF_FORMAT_NIST | SF_FORMAT_PCM_32, SF_FALSE) ;
  250. test_count++ ;
  251. } ;
  253. if (do_all || ! strcmp (argv [1], "ircam"))
  254. { pcm_test_short ("short_be.ircam" , SF_ENDIAN_BIG | SF_FORMAT_IRCAM | SF_FORMAT_PCM_16, SF_FALSE) ;
  255. pcm_test_short ("short_le.ircam" , SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_PCM_16, SF_FALSE) ;
  256. pcm_test_int ("int_be.ircam" , SF_ENDIAN_BIG | SF_FORMAT_IRCAM | SF_FORMAT_PCM_32, SF_FALSE) ;
  257. pcm_test_int  ("int_le.ircam" , SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_PCM_32, SF_FALSE) ;
  258. pcm_test_float ("float_be.ircam" , SF_ENDIAN_BIG | SF_FORMAT_IRCAM | SF_FORMAT_FLOAT , SF_FALSE) ;
  259. pcm_test_float ("float_le.ircam" , SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_FLOAT , SF_FALSE) ;
  261. test_count++ ;
  262. } ;
  264. if (do_all || ! strcmp (argv [1], "voc"))
  265. { pcm_test_char  ("char.voc" , SF_FORMAT_VOC | SF_FORMAT_PCM_U8, SF_FALSE) ;
  266. pcm_test_short ("short.voc", SF_FORMAT_VOC | SF_FORMAT_PCM_16, SF_FALSE) ;
  268. test_count++ ;
  269. } ;
  271. if (do_all || ! strcmp (argv [1], "mat4"))
  272. { pcm_test_short ("short_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_PCM_16, SF_FALSE) ;
  273. pcm_test_short ("short_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_PCM_16, SF_FALSE) ;
  274. pcm_test_int ("int_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_PCM_32, SF_FALSE) ;
  275. pcm_test_int  ("int_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_PCM_32, SF_FALSE) ;
  276. pcm_test_float ("float_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_FLOAT , SF_FALSE) ;
  277. pcm_test_float ("float_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_FLOAT , SF_FALSE) ;
  278. pcm_test_double ("double_be.mat4" , SF_ENDIAN_BIG | SF_FORMAT_MAT4 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  279. pcm_test_double ("double_le.mat4" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT4 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  281. empty_file_test ("empty_short.mat4", SF_FORMAT_MAT4 | SF_FORMAT_PCM_16) ;
  282. empty_file_test ("empty_float.mat4", SF_FORMAT_MAT4 | SF_FORMAT_FLOAT) ;
  283. test_count++ ;
  284. } ;
  286. if (do_all || ! strcmp (argv [1], "mat5"))
  287. { pcm_test_char  ("char_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  288. pcm_test_char  ("char_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  289. pcm_test_short ("short_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_PCM_16, SF_FALSE) ;
  290. pcm_test_short ("short_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_PCM_16, SF_FALSE) ;
  291. pcm_test_int ("int_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_PCM_32, SF_FALSE) ;
  292. pcm_test_int  ("int_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_PCM_32, SF_FALSE) ;
  293. pcm_test_float ("float_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_FLOAT , SF_FALSE) ;
  294. pcm_test_float ("float_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_FLOAT , SF_FALSE) ;
  295. pcm_test_double ("double_be.mat5" , SF_ENDIAN_BIG | SF_FORMAT_MAT5 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  296. pcm_test_double ("double_le.mat5" , SF_ENDIAN_LITTLE | SF_FORMAT_MAT5 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  298. increment_open_file_count () ;
  300. empty_file_test ("empty_char.mat5", SF_FORMAT_MAT5 | SF_FORMAT_PCM_U8) ;
  301. empty_file_test ("empty_short.mat5", SF_FORMAT_MAT5 | SF_FORMAT_PCM_16) ;
  302. empty_file_test ("empty_float.mat5", SF_FORMAT_MAT5 | SF_FORMAT_FLOAT) ;
  304. test_count++ ;
  305. } ;
  307. if (do_all || ! strcmp (argv [1], "pvf"))
  308. { pcm_test_char  ("char.pvf" , SF_FORMAT_PVF | SF_FORMAT_PCM_S8, SF_FALSE) ;
  309. pcm_test_short ("short.pvf", SF_FORMAT_PVF | SF_FORMAT_PCM_16, SF_FALSE) ;
  310. pcm_test_int ("int.pvf" , SF_FORMAT_PVF | SF_FORMAT_PCM_32, SF_FALSE) ;
  311. test_count++ ;
  312. } ;
  314. if (do_all || ! strcmp (argv [1], "htk"))
  315. { pcm_test_short ("short.htk", SF_FORMAT_HTK | SF_FORMAT_PCM_16, SF_FALSE) ;
  316. test_count++ ;
  317. } ;
  319. if (do_all || ! strcmp (argv [1], "mpc2k"))
  320. { pcm_test_short ("short.mpc", SF_FORMAT_MPC2K | SF_FORMAT_PCM_16, SF_FALSE) ;
  321. test_count++ ;
  322. } ;
  324. if (do_all || ! strcmp (argv [1], "avr"))
  325. { pcm_test_char  ("char_u8.avr" , SF_FORMAT_AVR | SF_FORMAT_PCM_U8, SF_FALSE) ;
  326. pcm_test_char  ("char_s8.avr" , SF_FORMAT_AVR | SF_FORMAT_PCM_S8, SF_FALSE) ;
  327. pcm_test_short ("short.avr" , SF_FORMAT_AVR | SF_FORMAT_PCM_16, SF_FALSE) ;
  328. test_count++ ;
  329. } ;
  330. /* Lite remove end */
  332. if (do_all || ! strcmp (argv [1], "w64"))
  333. { pcm_test_char ("char.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  334. pcm_test_short ("short.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_16, SF_FALSE) ;
  335. pcm_test_24bit ("24bit.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_24, SF_FALSE) ;
  336. pcm_test_int ("int.w64" , SF_FORMAT_W64 | SF_FORMAT_PCM_32, SF_FALSE) ;
  337. /* Lite remove start */
  338. pcm_test_float ("float.w64" , SF_FORMAT_W64 | SF_FORMAT_FLOAT , SF_FALSE) ;
  339. pcm_test_double ("double.w64" , SF_FORMAT_W64 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  340. /* Lite remove end */
  342. empty_file_test ("empty_char.w64", SF_FORMAT_W64 | SF_FORMAT_PCM_U8) ;
  343. empty_file_test ("empty_short.w64", SF_FORMAT_W64 | SF_FORMAT_PCM_16) ;
  344. empty_file_test ("empty_float.w64", SF_FORMAT_W64 | SF_FORMAT_FLOAT) ;
  346. test_count++ ;
  347. } ;
  349. if (do_all || ! strcmp (argv [1], "sds"))
  350. { pcm_test_char ("char.sds" , SF_FORMAT_SDS | SF_FORMAT_PCM_S8, SF_TRUE) ;
  351. pcm_test_short ("short.sds" , SF_FORMAT_SDS | SF_FORMAT_PCM_16, SF_TRUE) ;
  352. pcm_test_24bit ("24bit.sds" , SF_FORMAT_SDS | SF_FORMAT_PCM_24, SF_TRUE) ;
  354. empty_file_test ("empty_char.sds", SF_FORMAT_SDS | SF_FORMAT_PCM_S8) ;
  355. empty_file_test ("empty_short.sds", SF_FORMAT_SDS | SF_FORMAT_PCM_16) ;
  357. test_count++ ;
  358. } ;
  360. if (do_all || ! strcmp (argv [1], "sd2"))
  361. { pcm_test_char ("char.sd2" , SF_FORMAT_SD2 | SF_FORMAT_PCM_S8, SF_TRUE) ;
  362. pcm_test_short ("short.sd2" , SF_FORMAT_SD2 | SF_FORMAT_PCM_16, SF_TRUE) ;
  363. pcm_test_24bit ("24bit.sd2" , SF_FORMAT_SD2 | SF_FORMAT_PCM_24, SF_TRUE) ;
  364. test_count++ ;
  365. } ;
  367. if (do_all || ! strcmp (argv [1], "flac"))
  368. { if (HAVE_EXTERNAL_LIBS)
  369. { pcm_test_char ("char.flac" , SF_FORMAT_FLAC | SF_FORMAT_PCM_S8, SF_TRUE) ;
  370. pcm_test_short ("short.flac" , SF_FORMAT_FLAC | SF_FORMAT_PCM_16, SF_TRUE) ;
  371. pcm_test_24bit ("24bit.flac" , SF_FORMAT_FLAC | SF_FORMAT_PCM_24, SF_TRUE) ;
  372. }
  373. else
  374. puts ("    No FLAC tests because FLAC support was not compiled in.") ;
  375. test_count++ ;
  376. } ;
  378. if (do_all || ! strcmp (argv [1], "rf64"))
  379. { pcm_test_char ("char.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_U8, SF_FALSE) ;
  380. pcm_test_short ("short.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_16, SF_FALSE) ;
  381. pcm_test_24bit ("24bit.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_24, SF_FALSE) ;
  382. pcm_test_int ("int.rf64" , SF_FORMAT_RF64 | SF_FORMAT_PCM_32, SF_FALSE) ;
  384. /* Lite remove start */
  385. pcm_test_float ("float.rf64" , SF_FORMAT_RF64 | SF_FORMAT_FLOAT , SF_FALSE) ;
  386. pcm_test_double ("double.rf64" , SF_FORMAT_RF64 | SF_FORMAT_DOUBLE, SF_FALSE) ;
  387. empty_file_test ("empty_char.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_U8) ;
  388. empty_file_test ("empty_short.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_16) ;
  389. empty_file_test ("empty_float.rf64", SF_FORMAT_RF64 | SF_FORMAT_FLOAT) ;
  390. /* Lite remove end */
  392. test_count++ ;
  393. } ;
  395. if (test_count == 0)
  396. { printf ("Mono : ************************************n") ;
  397. printf ("Mono : *  No '%s' test defined.n", argv [1]) ;
  398. printf ("Mono : ************************************n") ;
  399. return 1 ;
  400. } ;
  402. /* Only open file descriptors should be stdin, stdout and stderr. */
  403. check_open_file_count_or_die (__LINE__) ;
  405. return 0 ;
  406. } /* main */
  408. /*============================================================================================
  409. ** Helper functions and macros.
  410. */
  412. static void create_short_file (const char *filename) ;
  414. #define CHAR_ERROR(x,y) (abs ((x) - (y)) > 255)
  415. #define INT_ERROR(x,y) (((x) - (y)) != 0)
  416. #define TRIBYTE_ERROR(x,y) (abs ((x) - (y)) > 255)
  417. #define FLOAT_ERROR(x,y) (fabs ((x) - (y)) > 1e-5)
  419. #define CONVERT_DATA(k,len,new,orig)
  420. { for ((k) = 0 ; (k) < (len) ; (k) ++)
  421. (new) [k] = (orig) [k] ;
  422. }
  425. /*======================================================================================
  426. */
  428. static void mono_char_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  429. static void stereo_char_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  430. static void mono_rdwr_char_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  431. static void new_rdwr_char_test (const char *filename, int format, int allow_fd) ;
  432. static void multi_seek_test (const char * filename, int format) ;
  433. static void write_seek_extend_test (const char * filename, int format) ;
  435. static void
  436. pcm_test_char (const char *filename, int format, int long_file_ok)
  437. { SF_INFO sfinfo ;
  438. short *orig, *test ;
  439. int k, items, allow_fd ;
  441. /* Sd2 files cannot be opened from an existing file descriptor. */
  442. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  444. print_test_name ("pcm_test_char", filename) ;
  446. sfinfo.samplerate = 44100 ;
  447. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  448. sfinfo.channels = 1 ;
  449. sfinfo.format = format ;
  451. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 32000.0) ;
  453. orig = orig_data.s ;
  454. test = test_data.s ;
  456. /* Make this a macro so gdb steps over it in one go. */
  457. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  459. items = DATA_LENGTH ;
  461. /* Some test broken out here. */
  463. mono_char_test (filename, format, long_file_ok, allow_fd) ;
  465. /* Sub format DWVW does not allow seeking. */
  466. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  467. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  468. { unlink (filename) ;
  469. printf ("no seek : okn") ;
  470. return ;
  471. } ;
  473. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  474. mono_rdwr_char_test (filename, format, long_file_ok, allow_fd) ;
  476. /* If the format doesn't support stereo we're done. */
  477. sfinfo.channels = 2 ;
  478. if (sf_format_check (&sfinfo) == 0)
  479. { unlink (filename) ;
  480. puts ("no stereo : ok") ;
  481. return ;
  482. } ;
  484. stereo_char_test (filename, format, long_file_ok, allow_fd) ;
  486. /* New read/write test. Not sure if this is needed yet. */
  488. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  489. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  490. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  491. new_rdwr_char_test (filename, format, allow_fd) ;
  493. delete_file (format, filename) ;
  495. puts ("ok") ;
  496. return ;
  497. } /* pcm_test_char */
  499. static void
  500. mono_char_test (const char *filename, int format, int long_file_ok, int allow_fd)
  501. { SNDFILE *file ;
  502. SF_INFO sfinfo ;
  503. short *orig, *test ;
  504. sf_count_t count ;
  505. int k, items ;
  507. sfinfo.samplerate = 44100 ;
  508. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  509. sfinfo.channels = 1 ;
  510. sfinfo.format = format ;
  512. orig = orig_data.s ;
  513. test = test_data.s ;
  515. items = DATA_LENGTH ;
  517. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  519. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  521. test_write_short_or_die (file, 0, orig, items, __LINE__) ;
  522. sf_write_sync (file) ;
  523. test_write_short_or_die (file, 0, orig, items, __LINE__) ;
  524. sf_write_sync (file) ;
  526. /* Add non-audio data after the audio. */
  527. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  529. sf_close (file) ;
  531. memset (test, 0, items * sizeof (short)) ;
  533. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  534. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  536. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  538. if (sfinfo.format != format)
  539. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  540. exit (1) ;
  541. } ;
  543. if (sfinfo.frames < 2 * items)
  544. { 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) ;
  545. exit (1) ;
  546. } ;
  548. if (! long_file_ok && sfinfo.frames > 2 * items)
  549. { 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) ;
  550. exit (1) ;
  551. } ;
  553. if (sfinfo.channels != 1)
  554. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  555. exit (1) ;
  556. } ;
  558. check_log_buffer_or_die (file, __LINE__) ;
  560. test_read_short_or_die (file, 0, test, items, __LINE__) ;
  561. for (k = 0 ; k < items ; k++)
  562. if (CHAR_ERROR (orig [k], test [k]))
  563. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  564. oct_save_short (orig, test, items) ;
  565. exit (1) ;
  566. } ;
  568. /* Seek to start of file. */
  569. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  571. test_read_short_or_die (file, 0, test, 4, __LINE__) ;
  572. for (k = 0 ; k < 4 ; k++)
  573. if (CHAR_ERROR (orig [k], test [k]))
  574. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  575. exit (1) ;
  576. } ;
  578. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  579. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  580. { sf_close (file) ;
  581. unlink (filename) ;
  582. printf ("no seek : ") ;
  583. return ;
  584. } ;
  586. /* Seek to offset from start of file. */
  587. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  589. test_read_short_or_die (file, 0, test + 10, 4, __LINE__) ;
  590. for (k = 10 ; k < 14 ; k++)
  591. if (CHAR_ERROR (orig [k], test [k]))
  592. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  593. exit (1) ;
  594. } ;
  596. /* Seek to offset from current position. */
  597. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  599. test_read_short_or_die (file, 0, test + 20, 4, __LINE__) ;
  600. for (k = 20 ; k < 24 ; k++)
  601. if (CHAR_ERROR (orig [k], test [k]))
  602. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  603. exit (1) ;
  604. } ;
  606. /* Seek to offset from end of file. */
  607. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  609. test_read_short_or_die (file, 0, test + 10, 4, __LINE__) ;
  610. for (k = 10 ; k < 14 ; k++)
  611. if (CHAR_ERROR (orig [k], test [k]))
  612. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  613. exit (1) ;
  614. } ;
  616. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  617. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  619. count = 0 ;
  620. while (count < sfinfo.frames)
  621. count += sf_read_short (file, test, 311) ;
  623. /* Check that no error has occurred. */
  624. if (sf_error (file))
  625. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  626. puts (sf_strerror (file)) ;
  627. exit (1) ;
  628. } ;
  630. /* Check that we haven't read beyond EOF. */
  631. if (count > sfinfo.frames)
  632. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  633. exit (1) ;
  634. } ;
  636. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  638. sf_close (file) ;
  640. multi_seek_test (filename, format) ;
  641. write_seek_extend_test (filename, format) ;
  643. } /* mono_char_test */
  645. static void
  646. stereo_char_test (const char *filename, int format, int long_file_ok, int allow_fd)
  647. { SNDFILE *file ;
  648. SF_INFO sfinfo ;
  649. short *orig, *test ;
  650. int k, items, frames ;
  652. sfinfo.samplerate = 44100 ;
  653. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  654. sfinfo.channels = 2 ;
  655. sfinfo.format = format ;
  657. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 32000.0) ;
  659. orig = orig_data.s ;
  660. test = test_data.s ;
  662. /* Make this a macro so gdb steps over it in one go. */
  663. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  665. items = DATA_LENGTH ;
  666. frames = items / sfinfo.channels ;
  668. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  670. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  672. test_writef_short_or_die (file, 0, orig, frames, __LINE__) ;
  674. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  676. sf_close (file) ;
  678. memset (test, 0, items * sizeof (short)) ;
  680. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  681. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  683. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  685. if (sfinfo.format != format)
  686. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  687. __LINE__, format, sfinfo.format) ;
  688. exit (1) ;
  689. } ;
  691. if (sfinfo.frames < frames)
  692. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  693. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  694. exit (1) ;
  695. } ;
  697. if (! long_file_ok && sfinfo.frames > frames)
  698. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  699. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  700. exit (1) ;
  701. } ;
  703. if (sfinfo.channels != 2)
  704. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  705. exit (1) ;
  706. } ;
  708. check_log_buffer_or_die (file, __LINE__) ;
  710. test_readf_short_or_die (file, 0, test, frames, __LINE__) ;
  711. for (k = 0 ; k < items ; k++)
  712. if (CHAR_ERROR (test [k], orig [k]))
  713. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  714. exit (1) ;
  715. } ;
  717. /* Seek to start of file. */
  718. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  720. test_readf_short_or_die (file, 0, test, 2, __LINE__) ;
  721. for (k = 0 ; k < 4 ; k++)
  722. if (CHAR_ERROR (test [k], orig [k]))
  723. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  724. exit (1) ;
  725. } ;
  727. /* Seek to offset from start of file. */
  728. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  730. /* Check for errors here. */
  731. if (sf_error (file))
  732. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  733. puts (sf_strerror (file)) ;
  734. exit (1) ;
  735. } ;
  737. if (sf_read_short (file, test, 1) > 0)
  738. { printf ("Line %d: Should return 0.n", __LINE__) ;
  739. exit (1) ;
  740. } ;
  742. if (! sf_error (file))
  743. { printf ("Line %d: Should return an error.n", __LINE__) ;
  744. exit (1) ;
  745. } ;
  746. /*-----------------------*/
  748. test_readf_short_or_die (file, 0, test + 10, 2, __LINE__) ;
  749. for (k = 20 ; k < 24 ; k++)
  750. if (CHAR_ERROR (test [k], orig [k]))
  751. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  752. exit (1) ;
  753. } ;
  755. /* Seek to offset from current position. */
  756. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  758. test_readf_short_or_die (file, 0, test + 20, 2, __LINE__) ;
  759. for (k = 40 ; k < 44 ; k++)
  760. if (CHAR_ERROR (test [k], orig [k]))
  761. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  762. exit (1) ;
  763. } ;
  765. /* Seek to offset from end of file. */
  766. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  768. test_readf_short_or_die (file, 0, test + 20, 2, __LINE__) ;
  769. for (k = 20 ; k < 24 ; k++)
  770. if (CHAR_ERROR (test [k], orig [k]))
  771. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  772. exit (1) ;
  773. } ;
  775. sf_close (file) ;
  776. } /* stereo_char_test */
  778. static void
  779. mono_rdwr_char_test (const char *filename, int format, int long_file_ok, int allow_fd)
  780. { SNDFILE *file ;
  781. SF_INFO sfinfo ;
  782. short *orig, *test ;
  783. int k, pass ;
  785. orig = orig_data.s ;
  786. test = test_data.s ;
  788. sfinfo.samplerate = SAMPLE_RATE ;
  789. sfinfo.frames = DATA_LENGTH ;
  790. sfinfo.channels = 1 ;
  791. sfinfo.format = format ;
  793. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  794. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  795. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  796. unlink (filename) ;
  797. else
  798. { /* Create a short file. */
  799. create_short_file (filename) ;
  801. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  802. ** If this returns a valif pointer sf_open() screwed up.
  803. */
  804. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  805. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  806. exit (1) ;
  807. } ;
  809. /* Truncate the file to zero bytes. */
  810. if (truncate (filename, 0) < 0)
  811. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  812. perror (NULL) ;
  813. exit (1) ;
  814. } ;
  815. } ;
  817. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  818. ** all the usual data required when opening the file in WRITE mode.
  819. */
  820. sfinfo.samplerate = SAMPLE_RATE ;
  821. sfinfo.frames = DATA_LENGTH ;
  822. sfinfo.channels = 1 ;
  823. sfinfo.format = format ;
  825. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  827. /* Do 3 writes followed by reads. After each, check the data and the current
  828. ** read and write offsets.
  829. */
  830. for (pass = 1 ; pass <= 3 ; pass ++)
  831. { orig [20] = pass * 2 ;
  833. /* Write some data. */
  834. test_write_short_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  836. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  838. /* Read what we just wrote. */
  839. test_read_short_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  841. /* Check the data. */
  842. for (k = 0 ; k < DATA_LENGTH ; k++)
  843. if (CHAR_ERROR (orig [k], test [k]))
  844. { printf ("nnLine %d (pass %d) A : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  845. oct_save_short (orig, test, DATA_LENGTH) ;
  846. exit (1) ;
  847. } ;
  849. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  850. } ; /* for (pass ...) */
  852. sf_close (file) ;
  854. /* Open the file again to check the data. */
  855. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  857. if (sfinfo.format != format)
  858. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  859. exit (1) ;
  860. } ;
  862. if (sfinfo.frames < 3 * DATA_LENGTH)
  863. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  864. exit (1) ;
  865. }
  867. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  868. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  869. exit (1) ;
  870. } ;
  872. if (sfinfo.channels != 1)
  873. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  874. exit (1) ;
  875. } ;
  877. if (! long_file_ok)
  878. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  879. else
  880. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  882. for (pass = 1 ; pass <= 3 ; pass ++)
  883. { orig [20] = pass * 2 ;
  885. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  887. /* Read what we just wrote. */
  888. test_read_short_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  890. /* Check the data. */
  891. for (k = 0 ; k < DATA_LENGTH ; k++)
  892. if (CHAR_ERROR (orig [k], test [k]))
  893. { printf ("nnLine %d (pass %d) B : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  894. oct_save_short (orig, test, DATA_LENGTH) ;
  895. exit (1) ;
  896. } ;
  898. } ; /* for (pass ...) */
  900. sf_close (file) ;
  901. } /* mono_rdwr_short_test */
  903. static void
  904. new_rdwr_char_test (const char *filename, int format, int allow_fd)
  905. { SNDFILE *wfile, *rwfile ;
  906. SF_INFO sfinfo ;
  907. short *orig, *test ;
  908. int items, frames ;
  910. orig = orig_data.s ;
  911. test = test_data.s ;
  913. sfinfo.samplerate = 44100 ;
  914. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  915. sfinfo.channels = 2 ;
  916. sfinfo.format = format ;
  918. items = DATA_LENGTH ;
  919. frames = items / sfinfo.channels ;
  921. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  922. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  923. test_writef_short_or_die (wfile, 1, orig, frames, __LINE__) ;
  924. sf_write_sync (wfile) ;
  925. test_writef_short_or_die (wfile, 2, orig, frames, __LINE__) ;
  926. sf_write_sync (wfile) ;
  928. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  929. if (sfinfo.frames != 2 * frames)
  930. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  931. exit (1) ;
  932. } ;
  934. test_writef_short_or_die (wfile, 3, orig, frames, __LINE__) ;
  936. test_readf_short_or_die (rwfile, 1, test, frames, __LINE__) ;
  937. test_readf_short_or_die (rwfile, 2, test, frames, __LINE__) ;
  939. sf_close (wfile) ;
  940. sf_close (rwfile) ;
  941. } /* new_rdwr_char_test */
  944. /*======================================================================================
  945. */
  947. static void mono_short_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  948. static void stereo_short_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  949. static void mono_rdwr_short_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  950. static void new_rdwr_short_test (const char *filename, int format, int allow_fd) ;
  951. static void multi_seek_test (const char * filename, int format) ;
  952. static void write_seek_extend_test (const char * filename, int format) ;
  954. static void
  955. pcm_test_short (const char *filename, int format, int long_file_ok)
  956. { SF_INFO sfinfo ;
  957. short *orig, *test ;
  958. int k, items, allow_fd ;
  960. /* Sd2 files cannot be opened from an existing file descriptor. */
  961. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  963. print_test_name ("pcm_test_short", filename) ;
  965. sfinfo.samplerate = 44100 ;
  966. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  967. sfinfo.channels = 1 ;
  968. sfinfo.format = format ;
  970. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 32000.0) ;
  972. orig = orig_data.s ;
  973. test = test_data.s ;
  975. /* Make this a macro so gdb steps over it in one go. */
  976. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  978. items = DATA_LENGTH ;
  980. /* Some test broken out here. */
  982. mono_short_test (filename, format, long_file_ok, allow_fd) ;
  984. /* Sub format DWVW does not allow seeking. */
  985. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  986. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  987. { unlink (filename) ;
  988. printf ("no seek : okn") ;
  989. return ;
  990. } ;
  992. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  993. mono_rdwr_short_test (filename, format, long_file_ok, allow_fd) ;
  995. /* If the format doesn't support stereo we're done. */
  996. sfinfo.channels = 2 ;
  997. if (sf_format_check (&sfinfo) == 0)
  998. { unlink (filename) ;
  999. puts ("no stereo : ok") ;
  1000. return ;
  1001. } ;
  1003. stereo_short_test (filename, format, long_file_ok, allow_fd) ;
  1005. /* New read/write test. Not sure if this is needed yet. */
  1007. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  1008. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  1009. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  1010. new_rdwr_short_test (filename, format, allow_fd) ;
  1012. delete_file (format, filename) ;
  1014. puts ("ok") ;
  1015. return ;
  1016. } /* pcm_test_short */
  1018. static void
  1019. mono_short_test (const char *filename, int format, int long_file_ok, int allow_fd)
  1020. { SNDFILE *file ;
  1021. SF_INFO sfinfo ;
  1022. short *orig, *test ;
  1023. sf_count_t count ;
  1024. int k, items ;
  1026. sfinfo.samplerate = 44100 ;
  1027. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1028. sfinfo.channels = 1 ;
  1029. sfinfo.format = format ;
  1031. orig = orig_data.s ;
  1032. test = test_data.s ;
  1034. items = DATA_LENGTH ;
  1036. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  1038. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  1040. test_write_short_or_die (file, 0, orig, items, __LINE__) ;
  1041. sf_write_sync (file) ;
  1042. test_write_short_or_die (file, 0, orig, items, __LINE__) ;
  1043. sf_write_sync (file) ;
  1045. /* Add non-audio data after the audio. */
  1046. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  1048. sf_close (file) ;
  1050. memset (test, 0, items * sizeof (short)) ;
  1052. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1053. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1055. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  1057. if (sfinfo.format != format)
  1058. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  1059. exit (1) ;
  1060. } ;
  1062. if (sfinfo.frames < 2 * items)
  1063. { 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) ;
  1064. exit (1) ;
  1065. } ;
  1067. if (! long_file_ok && sfinfo.frames > 2 * items)
  1068. { 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) ;
  1069. exit (1) ;
  1070. } ;
  1072. if (sfinfo.channels != 1)
  1073. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  1074. exit (1) ;
  1075. } ;
  1077. check_log_buffer_or_die (file, __LINE__) ;
  1079. test_read_short_or_die (file, 0, test, items, __LINE__) ;
  1080. for (k = 0 ; k < items ; k++)
  1081. if (INT_ERROR (orig [k], test [k]))
  1082. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1083. oct_save_short (orig, test, items) ;
  1084. exit (1) ;
  1085. } ;
  1087. /* Seek to start of file. */
  1088. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  1090. test_read_short_or_die (file, 0, test, 4, __LINE__) ;
  1091. for (k = 0 ; k < 4 ; k++)
  1092. if (INT_ERROR (orig [k], test [k]))
  1093. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1094. exit (1) ;
  1095. } ;
  1097. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  1098. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  1099. { sf_close (file) ;
  1100. unlink (filename) ;
  1101. printf ("no seek : ") ;
  1102. return ;
  1103. } ;
  1105. /* Seek to offset from start of file. */
  1106. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  1108. test_read_short_or_die (file, 0, test + 10, 4, __LINE__) ;
  1109. for (k = 10 ; k < 14 ; k++)
  1110. if (INT_ERROR (orig [k], test [k]))
  1111. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  1112. exit (1) ;
  1113. } ;
  1115. /* Seek to offset from current position. */
  1116. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  1118. test_read_short_or_die (file, 0, test + 20, 4, __LINE__) ;
  1119. for (k = 20 ; k < 24 ; k++)
  1120. if (INT_ERROR (orig [k], test [k]))
  1121. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  1122. exit (1) ;
  1123. } ;
  1125. /* Seek to offset from end of file. */
  1126. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  1128. test_read_short_or_die (file, 0, test + 10, 4, __LINE__) ;
  1129. for (k = 10 ; k < 14 ; k++)
  1130. if (INT_ERROR (orig [k], test [k]))
  1131. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  1132. exit (1) ;
  1133. } ;
  1135. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  1136. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  1138. count = 0 ;
  1139. while (count < sfinfo.frames)
  1140. count += sf_read_short (file, test, 311) ;
  1142. /* Check that no error has occurred. */
  1143. if (sf_error (file))
  1144. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  1145. puts (sf_strerror (file)) ;
  1146. exit (1) ;
  1147. } ;
  1149. /* Check that we haven't read beyond EOF. */
  1150. if (count > sfinfo.frames)
  1151. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  1152. exit (1) ;
  1153. } ;
  1155. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  1157. sf_close (file) ;
  1159. multi_seek_test (filename, format) ;
  1160. write_seek_extend_test (filename, format) ;
  1162. } /* mono_short_test */
  1164. static void
  1165. stereo_short_test (const char *filename, int format, int long_file_ok, int allow_fd)
  1166. { SNDFILE *file ;
  1167. SF_INFO sfinfo ;
  1168. short *orig, *test ;
  1169. int k, items, frames ;
  1171. sfinfo.samplerate = 44100 ;
  1172. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1173. sfinfo.channels = 2 ;
  1174. sfinfo.format = format ;
  1176. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 32000.0) ;
  1178. orig = orig_data.s ;
  1179. test = test_data.s ;
  1181. /* Make this a macro so gdb steps over it in one go. */
  1182. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  1184. items = DATA_LENGTH ;
  1185. frames = items / sfinfo.channels ;
  1187. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  1189. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  1191. test_writef_short_or_die (file, 0, orig, frames, __LINE__) ;
  1193. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  1195. sf_close (file) ;
  1197. memset (test, 0, items * sizeof (short)) ;
  1199. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1200. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1202. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  1204. if (sfinfo.format != format)
  1205. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  1206. __LINE__, format, sfinfo.format) ;
  1207. exit (1) ;
  1208. } ;
  1210. if (sfinfo.frames < frames)
  1211. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  1212. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  1213. exit (1) ;
  1214. } ;
  1216. if (! long_file_ok && sfinfo.frames > frames)
  1217. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  1218. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  1219. exit (1) ;
  1220. } ;
  1222. if (sfinfo.channels != 2)
  1223. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  1224. exit (1) ;
  1225. } ;
  1227. check_log_buffer_or_die (file, __LINE__) ;
  1229. test_readf_short_or_die (file, 0, test, frames, __LINE__) ;
  1230. for (k = 0 ; k < items ; k++)
  1231. if (INT_ERROR (test [k], orig [k]))
  1232. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1233. exit (1) ;
  1234. } ;
  1236. /* Seek to start of file. */
  1237. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  1239. test_readf_short_or_die (file, 0, test, 2, __LINE__) ;
  1240. for (k = 0 ; k < 4 ; k++)
  1241. if (INT_ERROR (test [k], orig [k]))
  1242. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1243. exit (1) ;
  1244. } ;
  1246. /* Seek to offset from start of file. */
  1247. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  1249. /* Check for errors here. */
  1250. if (sf_error (file))
  1251. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  1252. puts (sf_strerror (file)) ;
  1253. exit (1) ;
  1254. } ;
  1256. if (sf_read_short (file, test, 1) > 0)
  1257. { printf ("Line %d: Should return 0.n", __LINE__) ;
  1258. exit (1) ;
  1259. } ;
  1261. if (! sf_error (file))
  1262. { printf ("Line %d: Should return an error.n", __LINE__) ;
  1263. exit (1) ;
  1264. } ;
  1265. /*-----------------------*/
  1267. test_readf_short_or_die (file, 0, test + 10, 2, __LINE__) ;
  1268. for (k = 20 ; k < 24 ; k++)
  1269. if (INT_ERROR (test [k], orig [k]))
  1270. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1271. exit (1) ;
  1272. } ;
  1274. /* Seek to offset from current position. */
  1275. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  1277. test_readf_short_or_die (file, 0, test + 20, 2, __LINE__) ;
  1278. for (k = 40 ; k < 44 ; k++)
  1279. if (INT_ERROR (test [k], orig [k]))
  1280. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1281. exit (1) ;
  1282. } ;
  1284. /* Seek to offset from end of file. */
  1285. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  1287. test_readf_short_or_die (file, 0, test + 20, 2, __LINE__) ;
  1288. for (k = 20 ; k < 24 ; k++)
  1289. if (INT_ERROR (test [k], orig [k]))
  1290. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1291. exit (1) ;
  1292. } ;
  1294. sf_close (file) ;
  1295. } /* stereo_short_test */
  1297. static void
  1298. mono_rdwr_short_test (const char *filename, int format, int long_file_ok, int allow_fd)
  1299. { SNDFILE *file ;
  1300. SF_INFO sfinfo ;
  1301. short *orig, *test ;
  1302. int k, pass ;
  1304. orig = orig_data.s ;
  1305. test = test_data.s ;
  1307. sfinfo.samplerate = SAMPLE_RATE ;
  1308. sfinfo.frames = DATA_LENGTH ;
  1309. sfinfo.channels = 1 ;
  1310. sfinfo.format = format ;
  1312. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  1313. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  1314. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  1315. unlink (filename) ;
  1316. else
  1317. { /* Create a short file. */
  1318. create_short_file (filename) ;
  1320. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  1321. ** If this returns a valif pointer sf_open() screwed up.
  1322. */
  1323. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  1324. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  1325. exit (1) ;
  1326. } ;
  1328. /* Truncate the file to zero bytes. */
  1329. if (truncate (filename, 0) < 0)
  1330. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  1331. perror (NULL) ;
  1332. exit (1) ;
  1333. } ;
  1334. } ;
  1336. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  1337. ** all the usual data required when opening the file in WRITE mode.
  1338. */
  1339. sfinfo.samplerate = SAMPLE_RATE ;
  1340. sfinfo.frames = DATA_LENGTH ;
  1341. sfinfo.channels = 1 ;
  1342. sfinfo.format = format ;
  1344. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  1346. /* Do 3 writes followed by reads. After each, check the data and the current
  1347. ** read and write offsets.
  1348. */
  1349. for (pass = 1 ; pass <= 3 ; pass ++)
  1350. { orig [20] = pass * 2 ;
  1352. /* Write some data. */
  1353. test_write_short_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  1355. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  1357. /* Read what we just wrote. */
  1358. test_read_short_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  1360. /* Check the data. */
  1361. for (k = 0 ; k < DATA_LENGTH ; k++)
  1362. if (INT_ERROR (orig [k], test [k]))
  1363. { printf ("nnLine %d (pass %d) A : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  1364. oct_save_short (orig, test, DATA_LENGTH) ;
  1365. exit (1) ;
  1366. } ;
  1368. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  1369. } ; /* for (pass ...) */
  1371. sf_close (file) ;
  1373. /* Open the file again to check the data. */
  1374. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  1376. if (sfinfo.format != format)
  1377. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  1378. exit (1) ;
  1379. } ;
  1381. if (sfinfo.frames < 3 * DATA_LENGTH)
  1382. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  1383. exit (1) ;
  1384. }
  1386. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  1387. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  1388. exit (1) ;
  1389. } ;
  1391. if (sfinfo.channels != 1)
  1392. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  1393. exit (1) ;
  1394. } ;
  1396. if (! long_file_ok)
  1397. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  1398. else
  1399. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  1401. for (pass = 1 ; pass <= 3 ; pass ++)
  1402. { orig [20] = pass * 2 ;
  1404. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  1406. /* Read what we just wrote. */
  1407. test_read_short_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  1409. /* Check the data. */
  1410. for (k = 0 ; k < DATA_LENGTH ; k++)
  1411. if (INT_ERROR (orig [k], test [k]))
  1412. { printf ("nnLine %d (pass %d) B : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  1413. oct_save_short (orig, test, DATA_LENGTH) ;
  1414. exit (1) ;
  1415. } ;
  1417. } ; /* for (pass ...) */
  1419. sf_close (file) ;
  1420. } /* mono_rdwr_short_test */
  1422. static void
  1423. new_rdwr_short_test (const char *filename, int format, int allow_fd)
  1424. { SNDFILE *wfile, *rwfile ;
  1425. SF_INFO sfinfo ;
  1426. short *orig, *test ;
  1427. int items, frames ;
  1429. orig = orig_data.s ;
  1430. test = test_data.s ;
  1432. sfinfo.samplerate = 44100 ;
  1433. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1434. sfinfo.channels = 2 ;
  1435. sfinfo.format = format ;
  1437. items = DATA_LENGTH ;
  1438. frames = items / sfinfo.channels ;
  1440. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  1441. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  1442. test_writef_short_or_die (wfile, 1, orig, frames, __LINE__) ;
  1443. sf_write_sync (wfile) ;
  1444. test_writef_short_or_die (wfile, 2, orig, frames, __LINE__) ;
  1445. sf_write_sync (wfile) ;
  1447. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  1448. if (sfinfo.frames != 2 * frames)
  1449. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  1450. exit (1) ;
  1451. } ;
  1453. test_writef_short_or_die (wfile, 3, orig, frames, __LINE__) ;
  1455. test_readf_short_or_die (rwfile, 1, test, frames, __LINE__) ;
  1456. test_readf_short_or_die (rwfile, 2, test, frames, __LINE__) ;
  1458. sf_close (wfile) ;
  1459. sf_close (rwfile) ;
  1460. } /* new_rdwr_short_test */
  1463. /*======================================================================================
  1464. */
  1466. static void mono_24bit_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  1467. static void stereo_24bit_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  1468. static void mono_rdwr_24bit_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  1469. static void new_rdwr_24bit_test (const char *filename, int format, int allow_fd) ;
  1470. static void multi_seek_test (const char * filename, int format) ;
  1471. static void write_seek_extend_test (const char * filename, int format) ;
  1473. static void
  1474. pcm_test_24bit (const char *filename, int format, int long_file_ok)
  1475. { SF_INFO sfinfo ;
  1476. int *orig, *test ;
  1477. int k, items, allow_fd ;
  1479. /* Sd2 files cannot be opened from an existing file descriptor. */
  1480. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  1482. print_test_name ("pcm_test_24bit", filename) ;
  1484. sfinfo.samplerate = 44100 ;
  1485. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1486. sfinfo.channels = 1 ;
  1487. sfinfo.format = format ;
  1489. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, (1.0 * 0x7F000000)) ;
  1491. orig = orig_data.i ;
  1492. test = test_data.i ;
  1494. /* Make this a macro so gdb steps over it in one go. */
  1495. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  1497. items = DATA_LENGTH ;
  1499. /* Some test broken out here. */
  1501. mono_24bit_test (filename, format, long_file_ok, allow_fd) ;
  1503. /* Sub format DWVW does not allow seeking. */
  1504. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  1505. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  1506. { unlink (filename) ;
  1507. printf ("no seek : okn") ;
  1508. return ;
  1509. } ;
  1511. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  1512. mono_rdwr_24bit_test (filename, format, long_file_ok, allow_fd) ;
  1514. /* If the format doesn't support stereo we're done. */
  1515. sfinfo.channels = 2 ;
  1516. if (sf_format_check (&sfinfo) == 0)
  1517. { unlink (filename) ;
  1518. puts ("no stereo : ok") ;
  1519. return ;
  1520. } ;
  1522. stereo_24bit_test (filename, format, long_file_ok, allow_fd) ;
  1524. /* New read/write test. Not sure if this is needed yet. */
  1526. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  1527. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  1528. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  1529. new_rdwr_24bit_test (filename, format, allow_fd) ;
  1531. delete_file (format, filename) ;
  1533. puts ("ok") ;
  1534. return ;
  1535. } /* pcm_test_24bit */
  1537. static void
  1538. mono_24bit_test (const char *filename, int format, int long_file_ok, int allow_fd)
  1539. { SNDFILE *file ;
  1540. SF_INFO sfinfo ;
  1541. int *orig, *test ;
  1542. sf_count_t count ;
  1543. int k, items ;
  1545. sfinfo.samplerate = 44100 ;
  1546. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1547. sfinfo.channels = 1 ;
  1548. sfinfo.format = format ;
  1550. orig = orig_data.i ;
  1551. test = test_data.i ;
  1553. items = DATA_LENGTH ;
  1555. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  1557. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  1559. test_write_int_or_die (file, 0, orig, items, __LINE__) ;
  1560. sf_write_sync (file) ;
  1561. test_write_int_or_die (file, 0, orig, items, __LINE__) ;
  1562. sf_write_sync (file) ;
  1564. /* Add non-audio data after the audio. */
  1565. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  1567. sf_close (file) ;
  1569. memset (test, 0, items * sizeof (int)) ;
  1571. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1572. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1574. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  1576. if (sfinfo.format != format)
  1577. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  1578. exit (1) ;
  1579. } ;
  1581. if (sfinfo.frames < 2 * items)
  1582. { 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) ;
  1583. exit (1) ;
  1584. } ;
  1586. if (! long_file_ok && sfinfo.frames > 2 * items)
  1587. { 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) ;
  1588. exit (1) ;
  1589. } ;
  1591. if (sfinfo.channels != 1)
  1592. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  1593. exit (1) ;
  1594. } ;
  1596. check_log_buffer_or_die (file, __LINE__) ;
  1598. test_read_int_or_die (file, 0, test, items, __LINE__) ;
  1599. for (k = 0 ; k < items ; k++)
  1600. if (TRIBYTE_ERROR (orig [k], test [k]))
  1601. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1602. oct_save_int (orig, test, items) ;
  1603. exit (1) ;
  1604. } ;
  1606. /* Seek to start of file. */
  1607. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  1609. test_read_int_or_die (file, 0, test, 4, __LINE__) ;
  1610. for (k = 0 ; k < 4 ; k++)
  1611. if (TRIBYTE_ERROR (orig [k], test [k]))
  1612. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1613. exit (1) ;
  1614. } ;
  1616. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  1617. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  1618. { sf_close (file) ;
  1619. unlink (filename) ;
  1620. printf ("no seek : ") ;
  1621. return ;
  1622. } ;
  1624. /* Seek to offset from start of file. */
  1625. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  1627. test_read_int_or_die (file, 0, test + 10, 4, __LINE__) ;
  1628. for (k = 10 ; k < 14 ; k++)
  1629. if (TRIBYTE_ERROR (orig [k], test [k]))
  1630. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  1631. exit (1) ;
  1632. } ;
  1634. /* Seek to offset from current position. */
  1635. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  1637. test_read_int_or_die (file, 0, test + 20, 4, __LINE__) ;
  1638. for (k = 20 ; k < 24 ; k++)
  1639. if (TRIBYTE_ERROR (orig [k], test [k]))
  1640. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  1641. exit (1) ;
  1642. } ;
  1644. /* Seek to offset from end of file. */
  1645. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  1647. test_read_int_or_die (file, 0, test + 10, 4, __LINE__) ;
  1648. for (k = 10 ; k < 14 ; k++)
  1649. if (TRIBYTE_ERROR (orig [k], test [k]))
  1650. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  1651. exit (1) ;
  1652. } ;
  1654. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  1655. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  1657. count = 0 ;
  1658. while (count < sfinfo.frames)
  1659. count += sf_read_int (file, test, 311) ;
  1661. /* Check that no error has occurred. */
  1662. if (sf_error (file))
  1663. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  1664. puts (sf_strerror (file)) ;
  1665. exit (1) ;
  1666. } ;
  1668. /* Check that we haven't read beyond EOF. */
  1669. if (count > sfinfo.frames)
  1670. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  1671. exit (1) ;
  1672. } ;
  1674. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  1676. sf_close (file) ;
  1678. multi_seek_test (filename, format) ;
  1679. write_seek_extend_test (filename, format) ;
  1681. } /* mono_24bit_test */
  1683. static void
  1684. stereo_24bit_test (const char *filename, int format, int long_file_ok, int allow_fd)
  1685. { SNDFILE *file ;
  1686. SF_INFO sfinfo ;
  1687. int *orig, *test ;
  1688. int k, items, frames ;
  1690. sfinfo.samplerate = 44100 ;
  1691. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1692. sfinfo.channels = 2 ;
  1693. sfinfo.format = format ;
  1695. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, (1.0 * 0x7F000000)) ;
  1697. orig = orig_data.i ;
  1698. test = test_data.i ;
  1700. /* Make this a macro so gdb steps over it in one go. */
  1701. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  1703. items = DATA_LENGTH ;
  1704. frames = items / sfinfo.channels ;
  1706. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  1708. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  1710. test_writef_int_or_die (file, 0, orig, frames, __LINE__) ;
  1712. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  1714. sf_close (file) ;
  1716. memset (test, 0, items * sizeof (int)) ;
  1718. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  1719. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  1721. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  1723. if (sfinfo.format != format)
  1724. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  1725. __LINE__, format, sfinfo.format) ;
  1726. exit (1) ;
  1727. } ;
  1729. if (sfinfo.frames < frames)
  1730. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  1731. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  1732. exit (1) ;
  1733. } ;
  1735. if (! long_file_ok && sfinfo.frames > frames)
  1736. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  1737. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  1738. exit (1) ;
  1739. } ;
  1741. if (sfinfo.channels != 2)
  1742. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  1743. exit (1) ;
  1744. } ;
  1746. check_log_buffer_or_die (file, __LINE__) ;
  1748. test_readf_int_or_die (file, 0, test, frames, __LINE__) ;
  1749. for (k = 0 ; k < items ; k++)
  1750. if (TRIBYTE_ERROR (test [k], orig [k]))
  1751. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1752. exit (1) ;
  1753. } ;
  1755. /* Seek to start of file. */
  1756. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  1758. test_readf_int_or_die (file, 0, test, 2, __LINE__) ;
  1759. for (k = 0 ; k < 4 ; k++)
  1760. if (TRIBYTE_ERROR (test [k], orig [k]))
  1761. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1762. exit (1) ;
  1763. } ;
  1765. /* Seek to offset from start of file. */
  1766. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  1768. /* Check for errors here. */
  1769. if (sf_error (file))
  1770. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  1771. puts (sf_strerror (file)) ;
  1772. exit (1) ;
  1773. } ;
  1775. if (sf_read_int (file, test, 1) > 0)
  1776. { printf ("Line %d: Should return 0.n", __LINE__) ;
  1777. exit (1) ;
  1778. } ;
  1780. if (! sf_error (file))
  1781. { printf ("Line %d: Should return an error.n", __LINE__) ;
  1782. exit (1) ;
  1783. } ;
  1784. /*-----------------------*/
  1786. test_readf_int_or_die (file, 0, test + 10, 2, __LINE__) ;
  1787. for (k = 20 ; k < 24 ; k++)
  1788. if (TRIBYTE_ERROR (test [k], orig [k]))
  1789. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1790. exit (1) ;
  1791. } ;
  1793. /* Seek to offset from current position. */
  1794. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  1796. test_readf_int_or_die (file, 0, test + 20, 2, __LINE__) ;
  1797. for (k = 40 ; k < 44 ; k++)
  1798. if (TRIBYTE_ERROR (test [k], orig [k]))
  1799. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1800. exit (1) ;
  1801. } ;
  1803. /* Seek to offset from end of file. */
  1804. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  1806. test_readf_int_or_die (file, 0, test + 20, 2, __LINE__) ;
  1807. for (k = 20 ; k < 24 ; k++)
  1808. if (TRIBYTE_ERROR (test [k], orig [k]))
  1809. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  1810. exit (1) ;
  1811. } ;
  1813. sf_close (file) ;
  1814. } /* stereo_24bit_test */
  1816. static void
  1817. mono_rdwr_24bit_test (const char *filename, int format, int long_file_ok, int allow_fd)
  1818. { SNDFILE *file ;
  1819. SF_INFO sfinfo ;
  1820. int *orig, *test ;
  1821. int k, pass ;
  1823. orig = orig_data.i ;
  1824. test = test_data.i ;
  1826. sfinfo.samplerate = SAMPLE_RATE ;
  1827. sfinfo.frames = DATA_LENGTH ;
  1828. sfinfo.channels = 1 ;
  1829. sfinfo.format = format ;
  1831. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  1832. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  1833. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  1834. unlink (filename) ;
  1835. else
  1836. { /* Create a short file. */
  1837. create_short_file (filename) ;
  1839. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  1840. ** If this returns a valif pointer sf_open() screwed up.
  1841. */
  1842. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  1843. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  1844. exit (1) ;
  1845. } ;
  1847. /* Truncate the file to zero bytes. */
  1848. if (truncate (filename, 0) < 0)
  1849. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  1850. perror (NULL) ;
  1851. exit (1) ;
  1852. } ;
  1853. } ;
  1855. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  1856. ** all the usual data required when opening the file in WRITE mode.
  1857. */
  1858. sfinfo.samplerate = SAMPLE_RATE ;
  1859. sfinfo.frames = DATA_LENGTH ;
  1860. sfinfo.channels = 1 ;
  1861. sfinfo.format = format ;
  1863. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  1865. /* Do 3 writes followed by reads. After each, check the data and the current
  1866. ** read and write offsets.
  1867. */
  1868. for (pass = 1 ; pass <= 3 ; pass ++)
  1869. { orig [20] = pass * 2 ;
  1871. /* Write some data. */
  1872. test_write_int_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  1874. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  1876. /* Read what we just wrote. */
  1877. test_read_int_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  1879. /* Check the data. */
  1880. for (k = 0 ; k < DATA_LENGTH ; k++)
  1881. if (TRIBYTE_ERROR (orig [k], test [k]))
  1882. { printf ("nnLine %d (pass %d) A : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  1883. oct_save_int (orig, test, DATA_LENGTH) ;
  1884. exit (1) ;
  1885. } ;
  1887. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  1888. } ; /* for (pass ...) */
  1890. sf_close (file) ;
  1892. /* Open the file again to check the data. */
  1893. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  1895. if (sfinfo.format != format)
  1896. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  1897. exit (1) ;
  1898. } ;
  1900. if (sfinfo.frames < 3 * DATA_LENGTH)
  1901. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  1902. exit (1) ;
  1903. }
  1905. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  1906. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  1907. exit (1) ;
  1908. } ;
  1910. if (sfinfo.channels != 1)
  1911. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  1912. exit (1) ;
  1913. } ;
  1915. if (! long_file_ok)
  1916. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  1917. else
  1918. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  1920. for (pass = 1 ; pass <= 3 ; pass ++)
  1921. { orig [20] = pass * 2 ;
  1923. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  1925. /* Read what we just wrote. */
  1926. test_read_int_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  1928. /* Check the data. */
  1929. for (k = 0 ; k < DATA_LENGTH ; k++)
  1930. if (TRIBYTE_ERROR (orig [k], test [k]))
  1931. { printf ("nnLine %d (pass %d) B : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  1932. oct_save_int (orig, test, DATA_LENGTH) ;
  1933. exit (1) ;
  1934. } ;
  1936. } ; /* for (pass ...) */
  1938. sf_close (file) ;
  1939. } /* mono_rdwr_int_test */
  1941. static void
  1942. new_rdwr_24bit_test (const char *filename, int format, int allow_fd)
  1943. { SNDFILE *wfile, *rwfile ;
  1944. SF_INFO sfinfo ;
  1945. int *orig, *test ;
  1946. int items, frames ;
  1948. orig = orig_data.i ;
  1949. test = test_data.i ;
  1951. sfinfo.samplerate = 44100 ;
  1952. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  1953. sfinfo.channels = 2 ;
  1954. sfinfo.format = format ;
  1956. items = DATA_LENGTH ;
  1957. frames = items / sfinfo.channels ;
  1959. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  1960. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  1961. test_writef_int_or_die (wfile, 1, orig, frames, __LINE__) ;
  1962. sf_write_sync (wfile) ;
  1963. test_writef_int_or_die (wfile, 2, orig, frames, __LINE__) ;
  1964. sf_write_sync (wfile) ;
  1966. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  1967. if (sfinfo.frames != 2 * frames)
  1968. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  1969. exit (1) ;
  1970. } ;
  1972. test_writef_int_or_die (wfile, 3, orig, frames, __LINE__) ;
  1974. test_readf_int_or_die (rwfile, 1, test, frames, __LINE__) ;
  1975. test_readf_int_or_die (rwfile, 2, test, frames, __LINE__) ;
  1977. sf_close (wfile) ;
  1978. sf_close (rwfile) ;
  1979. } /* new_rdwr_24bit_test */
  1982. /*======================================================================================
  1983. */
  1985. static void mono_int_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  1986. static void stereo_int_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  1987. static void mono_rdwr_int_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  1988. static void new_rdwr_int_test (const char *filename, int format, int allow_fd) ;
  1989. static void multi_seek_test (const char * filename, int format) ;
  1990. static void write_seek_extend_test (const char * filename, int format) ;
  1992. static void
  1993. pcm_test_int (const char *filename, int format, int long_file_ok)
  1994. { SF_INFO sfinfo ;
  1995. int *orig, *test ;
  1996. int k, items, allow_fd ;
  1998. /* Sd2 files cannot be opened from an existing file descriptor. */
  1999. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  2001. print_test_name ("pcm_test_int", filename) ;
  2003. sfinfo.samplerate = 44100 ;
  2004. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2005. sfinfo.channels = 1 ;
  2006. sfinfo.format = format ;
  2008. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, (1.0 * 0x7F000000)) ;
  2010. orig = orig_data.i ;
  2011. test = test_data.i ;
  2013. /* Make this a macro so gdb steps over it in one go. */
  2014. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  2016. items = DATA_LENGTH ;
  2018. /* Some test broken out here. */
  2020. mono_int_test (filename, format, long_file_ok, allow_fd) ;
  2022. /* Sub format DWVW does not allow seeking. */
  2023. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  2024. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  2025. { unlink (filename) ;
  2026. printf ("no seek : okn") ;
  2027. return ;
  2028. } ;
  2030. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  2031. mono_rdwr_int_test (filename, format, long_file_ok, allow_fd) ;
  2033. /* If the format doesn't support stereo we're done. */
  2034. sfinfo.channels = 2 ;
  2035. if (sf_format_check (&sfinfo) == 0)
  2036. { unlink (filename) ;
  2037. puts ("no stereo : ok") ;
  2038. return ;
  2039. } ;
  2041. stereo_int_test (filename, format, long_file_ok, allow_fd) ;
  2043. /* New read/write test. Not sure if this is needed yet. */
  2045. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  2046. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  2047. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  2048. new_rdwr_int_test (filename, format, allow_fd) ;
  2050. delete_file (format, filename) ;
  2052. puts ("ok") ;
  2053. return ;
  2054. } /* pcm_test_int */
  2056. static void
  2057. mono_int_test (const char *filename, int format, int long_file_ok, int allow_fd)
  2058. { SNDFILE *file ;
  2059. SF_INFO sfinfo ;
  2060. int *orig, *test ;
  2061. sf_count_t count ;
  2062. int k, items ;
  2064. sfinfo.samplerate = 44100 ;
  2065. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2066. sfinfo.channels = 1 ;
  2067. sfinfo.format = format ;
  2069. orig = orig_data.i ;
  2070. test = test_data.i ;
  2072. items = DATA_LENGTH ;
  2074. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  2076. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  2078. test_write_int_or_die (file, 0, orig, items, __LINE__) ;
  2079. sf_write_sync (file) ;
  2080. test_write_int_or_die (file, 0, orig, items, __LINE__) ;
  2081. sf_write_sync (file) ;
  2083. /* Add non-audio data after the audio. */
  2084. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  2086. sf_close (file) ;
  2088. memset (test, 0, items * sizeof (int)) ;
  2090. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  2091. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  2093. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  2095. if (sfinfo.format != format)
  2096. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  2097. exit (1) ;
  2098. } ;
  2100. if (sfinfo.frames < 2 * items)
  2101. { 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) ;
  2102. exit (1) ;
  2103. } ;
  2105. if (! long_file_ok && sfinfo.frames > 2 * items)
  2106. { 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) ;
  2107. exit (1) ;
  2108. } ;
  2110. if (sfinfo.channels != 1)
  2111. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  2112. exit (1) ;
  2113. } ;
  2115. check_log_buffer_or_die (file, __LINE__) ;
  2117. test_read_int_or_die (file, 0, test, items, __LINE__) ;
  2118. for (k = 0 ; k < items ; k++)
  2119. if (INT_ERROR (orig [k], test [k]))
  2120. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2121. oct_save_int (orig, test, items) ;
  2122. exit (1) ;
  2123. } ;
  2125. /* Seek to start of file. */
  2126. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  2128. test_read_int_or_die (file, 0, test, 4, __LINE__) ;
  2129. for (k = 0 ; k < 4 ; k++)
  2130. if (INT_ERROR (orig [k], test [k]))
  2131. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2132. exit (1) ;
  2133. } ;
  2135. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  2136. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  2137. { sf_close (file) ;
  2138. unlink (filename) ;
  2139. printf ("no seek : ") ;
  2140. return ;
  2141. } ;
  2143. /* Seek to offset from start of file. */
  2144. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  2146. test_read_int_or_die (file, 0, test + 10, 4, __LINE__) ;
  2147. for (k = 10 ; k < 14 ; k++)
  2148. if (INT_ERROR (orig [k], test [k]))
  2149. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  2150. exit (1) ;
  2151. } ;
  2153. /* Seek to offset from current position. */
  2154. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  2156. test_read_int_or_die (file, 0, test + 20, 4, __LINE__) ;
  2157. for (k = 20 ; k < 24 ; k++)
  2158. if (INT_ERROR (orig [k], test [k]))
  2159. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  2160. exit (1) ;
  2161. } ;
  2163. /* Seek to offset from end of file. */
  2164. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  2166. test_read_int_or_die (file, 0, test + 10, 4, __LINE__) ;
  2167. for (k = 10 ; k < 14 ; k++)
  2168. if (INT_ERROR (orig [k], test [k]))
  2169. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : 0x%X => 0x%X).n", __LINE__, k, test [k], orig [k]) ;
  2170. exit (1) ;
  2171. } ;
  2173. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  2174. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  2176. count = 0 ;
  2177. while (count < sfinfo.frames)
  2178. count += sf_read_int (file, test, 311) ;
  2180. /* Check that no error has occurred. */
  2181. if (sf_error (file))
  2182. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  2183. puts (sf_strerror (file)) ;
  2184. exit (1) ;
  2185. } ;
  2187. /* Check that we haven't read beyond EOF. */
  2188. if (count > sfinfo.frames)
  2189. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  2190. exit (1) ;
  2191. } ;
  2193. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  2195. sf_close (file) ;
  2197. multi_seek_test (filename, format) ;
  2198. write_seek_extend_test (filename, format) ;
  2200. } /* mono_int_test */
  2202. static void
  2203. stereo_int_test (const char *filename, int format, int long_file_ok, int allow_fd)
  2204. { SNDFILE *file ;
  2205. SF_INFO sfinfo ;
  2206. int *orig, *test ;
  2207. int k, items, frames ;
  2209. sfinfo.samplerate = 44100 ;
  2210. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2211. sfinfo.channels = 2 ;
  2212. sfinfo.format = format ;
  2214. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, (1.0 * 0x7F000000)) ;
  2216. orig = orig_data.i ;
  2217. test = test_data.i ;
  2219. /* Make this a macro so gdb steps over it in one go. */
  2220. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  2222. items = DATA_LENGTH ;
  2223. frames = items / sfinfo.channels ;
  2225. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  2227. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  2229. test_writef_int_or_die (file, 0, orig, frames, __LINE__) ;
  2231. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  2233. sf_close (file) ;
  2235. memset (test, 0, items * sizeof (int)) ;
  2237. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  2238. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  2240. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  2242. if (sfinfo.format != format)
  2243. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  2244. __LINE__, format, sfinfo.format) ;
  2245. exit (1) ;
  2246. } ;
  2248. if (sfinfo.frames < frames)
  2249. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  2250. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  2251. exit (1) ;
  2252. } ;
  2254. if (! long_file_ok && sfinfo.frames > frames)
  2255. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  2256. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  2257. exit (1) ;
  2258. } ;
  2260. if (sfinfo.channels != 2)
  2261. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  2262. exit (1) ;
  2263. } ;
  2265. check_log_buffer_or_die (file, __LINE__) ;
  2267. test_readf_int_or_die (file, 0, test, frames, __LINE__) ;
  2268. for (k = 0 ; k < items ; k++)
  2269. if (INT_ERROR (test [k], orig [k]))
  2270. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2271. exit (1) ;
  2272. } ;
  2274. /* Seek to start of file. */
  2275. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  2277. test_readf_int_or_die (file, 0, test, 2, __LINE__) ;
  2278. for (k = 0 ; k < 4 ; k++)
  2279. if (INT_ERROR (test [k], orig [k]))
  2280. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2281. exit (1) ;
  2282. } ;
  2284. /* Seek to offset from start of file. */
  2285. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  2287. /* Check for errors here. */
  2288. if (sf_error (file))
  2289. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  2290. puts (sf_strerror (file)) ;
  2291. exit (1) ;
  2292. } ;
  2294. if (sf_read_int (file, test, 1) > 0)
  2295. { printf ("Line %d: Should return 0.n", __LINE__) ;
  2296. exit (1) ;
  2297. } ;
  2299. if (! sf_error (file))
  2300. { printf ("Line %d: Should return an error.n", __LINE__) ;
  2301. exit (1) ;
  2302. } ;
  2303. /*-----------------------*/
  2305. test_readf_int_or_die (file, 0, test + 10, 2, __LINE__) ;
  2306. for (k = 20 ; k < 24 ; k++)
  2307. if (INT_ERROR (test [k], orig [k]))
  2308. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2309. exit (1) ;
  2310. } ;
  2312. /* Seek to offset from current position. */
  2313. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  2315. test_readf_int_or_die (file, 0, test + 20, 2, __LINE__) ;
  2316. for (k = 40 ; k < 44 ; k++)
  2317. if (INT_ERROR (test [k], orig [k]))
  2318. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2319. exit (1) ;
  2320. } ;
  2322. /* Seek to offset from end of file. */
  2323. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  2325. test_readf_int_or_die (file, 0, test + 20, 2, __LINE__) ;
  2326. for (k = 20 ; k < 24 ; k++)
  2327. if (INT_ERROR (test [k], orig [k]))
  2328. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : 0x%X => 0x%X).n", __LINE__, k, orig [k], test [k]) ;
  2329. exit (1) ;
  2330. } ;
  2332. sf_close (file) ;
  2333. } /* stereo_int_test */
  2335. static void
  2336. mono_rdwr_int_test (const char *filename, int format, int long_file_ok, int allow_fd)
  2337. { SNDFILE *file ;
  2338. SF_INFO sfinfo ;
  2339. int *orig, *test ;
  2340. int k, pass ;
  2342. orig = orig_data.i ;
  2343. test = test_data.i ;
  2345. sfinfo.samplerate = SAMPLE_RATE ;
  2346. sfinfo.frames = DATA_LENGTH ;
  2347. sfinfo.channels = 1 ;
  2348. sfinfo.format = format ;
  2350. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  2351. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  2352. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  2353. unlink (filename) ;
  2354. else
  2355. { /* Create a short file. */
  2356. create_short_file (filename) ;
  2358. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  2359. ** If this returns a valif pointer sf_open() screwed up.
  2360. */
  2361. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  2362. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  2363. exit (1) ;
  2364. } ;
  2366. /* Truncate the file to zero bytes. */
  2367. if (truncate (filename, 0) < 0)
  2368. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  2369. perror (NULL) ;
  2370. exit (1) ;
  2371. } ;
  2372. } ;
  2374. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  2375. ** all the usual data required when opening the file in WRITE mode.
  2376. */
  2377. sfinfo.samplerate = SAMPLE_RATE ;
  2378. sfinfo.frames = DATA_LENGTH ;
  2379. sfinfo.channels = 1 ;
  2380. sfinfo.format = format ;
  2382. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  2384. /* Do 3 writes followed by reads. After each, check the data and the current
  2385. ** read and write offsets.
  2386. */
  2387. for (pass = 1 ; pass <= 3 ; pass ++)
  2388. { orig [20] = pass * 2 ;
  2390. /* Write some data. */
  2391. test_write_int_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  2393. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  2395. /* Read what we just wrote. */
  2396. test_read_int_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  2398. /* Check the data. */
  2399. for (k = 0 ; k < DATA_LENGTH ; k++)
  2400. if (INT_ERROR (orig [k], test [k]))
  2401. { printf ("nnLine %d (pass %d) A : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  2402. oct_save_int (orig, test, DATA_LENGTH) ;
  2403. exit (1) ;
  2404. } ;
  2406. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  2407. } ; /* for (pass ...) */
  2409. sf_close (file) ;
  2411. /* Open the file again to check the data. */
  2412. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  2414. if (sfinfo.format != format)
  2415. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  2416. exit (1) ;
  2417. } ;
  2419. if (sfinfo.frames < 3 * DATA_LENGTH)
  2420. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  2421. exit (1) ;
  2422. }
  2424. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  2425. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  2426. exit (1) ;
  2427. } ;
  2429. if (sfinfo.channels != 1)
  2430. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  2431. exit (1) ;
  2432. } ;
  2434. if (! long_file_ok)
  2435. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  2436. else
  2437. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  2439. for (pass = 1 ; pass <= 3 ; pass ++)
  2440. { orig [20] = pass * 2 ;
  2442. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  2444. /* Read what we just wrote. */
  2445. test_read_int_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  2447. /* Check the data. */
  2448. for (k = 0 ; k < DATA_LENGTH ; k++)
  2449. if (INT_ERROR (orig [k], test [k]))
  2450. { printf ("nnLine %d (pass %d) B : Error at sample %d (0x%X => 0x%X).n", __LINE__, pass, k, orig [k], test [k]) ;
  2451. oct_save_int (orig, test, DATA_LENGTH) ;
  2452. exit (1) ;
  2453. } ;
  2455. } ; /* for (pass ...) */
  2457. sf_close (file) ;
  2458. } /* mono_rdwr_int_test */
  2460. static void
  2461. new_rdwr_int_test (const char *filename, int format, int allow_fd)
  2462. { SNDFILE *wfile, *rwfile ;
  2463. SF_INFO sfinfo ;
  2464. int *orig, *test ;
  2465. int items, frames ;
  2467. orig = orig_data.i ;
  2468. test = test_data.i ;
  2470. sfinfo.samplerate = 44100 ;
  2471. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2472. sfinfo.channels = 2 ;
  2473. sfinfo.format = format ;
  2475. items = DATA_LENGTH ;
  2476. frames = items / sfinfo.channels ;
  2478. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  2479. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  2480. test_writef_int_or_die (wfile, 1, orig, frames, __LINE__) ;
  2481. sf_write_sync (wfile) ;
  2482. test_writef_int_or_die (wfile, 2, orig, frames, __LINE__) ;
  2483. sf_write_sync (wfile) ;
  2485. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  2486. if (sfinfo.frames != 2 * frames)
  2487. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  2488. exit (1) ;
  2489. } ;
  2491. test_writef_int_or_die (wfile, 3, orig, frames, __LINE__) ;
  2493. test_readf_int_or_die (rwfile, 1, test, frames, __LINE__) ;
  2494. test_readf_int_or_die (rwfile, 2, test, frames, __LINE__) ;
  2496. sf_close (wfile) ;
  2497. sf_close (rwfile) ;
  2498. } /* new_rdwr_int_test */
  2501. /*======================================================================================
  2502. */
  2504. static void mono_float_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  2505. static void stereo_float_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  2506. static void mono_rdwr_float_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  2507. static void new_rdwr_float_test (const char *filename, int format, int allow_fd) ;
  2508. static void multi_seek_test (const char * filename, int format) ;
  2509. static void write_seek_extend_test (const char * filename, int format) ;
  2511. static void
  2512. pcm_test_float (const char *filename, int format, int long_file_ok)
  2513. { SF_INFO sfinfo ;
  2514. float *orig, *test ;
  2515. int k, items, allow_fd ;
  2517. /* Sd2 files cannot be opened from an existing file descriptor. */
  2518. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  2520. print_test_name ("pcm_test_float", filename) ;
  2522. sfinfo.samplerate = 44100 ;
  2523. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2524. sfinfo.channels = 1 ;
  2525. sfinfo.format = format ;
  2527. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 1.0) ;
  2529. orig = orig_data.f ;
  2530. test = test_data.f ;
  2532. /* Make this a macro so gdb steps over it in one go. */
  2533. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  2535. items = DATA_LENGTH ;
  2537. /* Some test broken out here. */
  2539. mono_float_test (filename, format, long_file_ok, allow_fd) ;
  2541. /* Sub format DWVW does not allow seeking. */
  2542. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  2543. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  2544. { unlink (filename) ;
  2545. printf ("no seek : okn") ;
  2546. return ;
  2547. } ;
  2549. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  2550. mono_rdwr_float_test (filename, format, long_file_ok, allow_fd) ;
  2552. /* If the format doesn't support stereo we're done. */
  2553. sfinfo.channels = 2 ;
  2554. if (sf_format_check (&sfinfo) == 0)
  2555. { unlink (filename) ;
  2556. puts ("no stereo : ok") ;
  2557. return ;
  2558. } ;
  2560. stereo_float_test (filename, format, long_file_ok, allow_fd) ;
  2562. /* New read/write test. Not sure if this is needed yet. */
  2564. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  2565. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  2566. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  2567. new_rdwr_float_test (filename, format, allow_fd) ;
  2569. delete_file (format, filename) ;
  2571. puts ("ok") ;
  2572. return ;
  2573. } /* pcm_test_float */
  2575. static void
  2576. mono_float_test (const char *filename, int format, int long_file_ok, int allow_fd)
  2577. { SNDFILE *file ;
  2578. SF_INFO sfinfo ;
  2579. float *orig, *test ;
  2580. sf_count_t count ;
  2581. int k, items ;
  2583. sfinfo.samplerate = 44100 ;
  2584. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2585. sfinfo.channels = 1 ;
  2586. sfinfo.format = format ;
  2588. orig = orig_data.f ;
  2589. test = test_data.f ;
  2591. items = DATA_LENGTH ;
  2593. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  2595. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  2597. test_write_float_or_die (file, 0, orig, items, __LINE__) ;
  2598. sf_write_sync (file) ;
  2599. test_write_float_or_die (file, 0, orig, items, __LINE__) ;
  2600. sf_write_sync (file) ;
  2602. /* Add non-audio data after the audio. */
  2603. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  2605. sf_close (file) ;
  2607. memset (test, 0, items * sizeof (float)) ;
  2609. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  2610. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  2612. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  2614. if (sfinfo.format != format)
  2615. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  2616. exit (1) ;
  2617. } ;
  2619. if (sfinfo.frames < 2 * items)
  2620. { 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) ;
  2621. exit (1) ;
  2622. } ;
  2624. if (! long_file_ok && sfinfo.frames > 2 * items)
  2625. { 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) ;
  2626. exit (1) ;
  2627. } ;
  2629. if (sfinfo.channels != 1)
  2630. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  2631. exit (1) ;
  2632. } ;
  2634. check_log_buffer_or_die (file, __LINE__) ;
  2636. test_read_float_or_die (file, 0, test, items, __LINE__) ;
  2637. for (k = 0 ; k < items ; k++)
  2638. if (FLOAT_ERROR (orig [k], test [k]))
  2639. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2640. oct_save_float (orig, test, items) ;
  2641. exit (1) ;
  2642. } ;
  2644. /* Seek to start of file. */
  2645. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  2647. test_read_float_or_die (file, 0, test, 4, __LINE__) ;
  2648. for (k = 0 ; k < 4 ; k++)
  2649. if (FLOAT_ERROR (orig [k], test [k]))
  2650. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2651. exit (1) ;
  2652. } ;
  2654. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  2655. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  2656. { sf_close (file) ;
  2657. unlink (filename) ;
  2658. printf ("no seek : ") ;
  2659. return ;
  2660. } ;
  2662. /* Seek to offset from start of file. */
  2663. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  2665. test_read_float_or_die (file, 0, test + 10, 4, __LINE__) ;
  2666. for (k = 10 ; k < 14 ; k++)
  2667. if (FLOAT_ERROR (orig [k], test [k]))
  2668. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, test [k], orig [k]) ;
  2669. exit (1) ;
  2670. } ;
  2672. /* Seek to offset from current position. */
  2673. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  2675. test_read_float_or_die (file, 0, test + 20, 4, __LINE__) ;
  2676. for (k = 20 ; k < 24 ; k++)
  2677. if (FLOAT_ERROR (orig [k], test [k]))
  2678. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, test [k], orig [k]) ;
  2679. exit (1) ;
  2680. } ;
  2682. /* Seek to offset from end of file. */
  2683. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  2685. test_read_float_or_die (file, 0, test + 10, 4, __LINE__) ;
  2686. for (k = 10 ; k < 14 ; k++)
  2687. if (FLOAT_ERROR (orig [k], test [k]))
  2688. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : %g => %g).n", __LINE__, k, test [k], orig [k]) ;
  2689. exit (1) ;
  2690. } ;
  2692. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  2693. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  2695. count = 0 ;
  2696. while (count < sfinfo.frames)
  2697. count += sf_read_float (file, test, 311) ;
  2699. /* Check that no error has occurred. */
  2700. if (sf_error (file))
  2701. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  2702. puts (sf_strerror (file)) ;
  2703. exit (1) ;
  2704. } ;
  2706. /* Check that we haven't read beyond EOF. */
  2707. if (count > sfinfo.frames)
  2708. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  2709. exit (1) ;
  2710. } ;
  2712. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  2714. sf_close (file) ;
  2716. multi_seek_test (filename, format) ;
  2717. write_seek_extend_test (filename, format) ;
  2719. } /* mono_float_test */
  2721. static void
  2722. stereo_float_test (const char *filename, int format, int long_file_ok, int allow_fd)
  2723. { SNDFILE *file ;
  2724. SF_INFO sfinfo ;
  2725. float *orig, *test ;
  2726. int k, items, frames ;
  2728. sfinfo.samplerate = 44100 ;
  2729. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2730. sfinfo.channels = 2 ;
  2731. sfinfo.format = format ;
  2733. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 1.0) ;
  2735. orig = orig_data.f ;
  2736. test = test_data.f ;
  2738. /* Make this a macro so gdb steps over it in one go. */
  2739. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  2741. items = DATA_LENGTH ;
  2742. frames = items / sfinfo.channels ;
  2744. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  2746. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  2748. test_writef_float_or_die (file, 0, orig, frames, __LINE__) ;
  2750. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  2752. sf_close (file) ;
  2754. memset (test, 0, items * sizeof (float)) ;
  2756. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  2757. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  2759. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  2761. if (sfinfo.format != format)
  2762. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  2763. __LINE__, format, sfinfo.format) ;
  2764. exit (1) ;
  2765. } ;
  2767. if (sfinfo.frames < frames)
  2768. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  2769. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  2770. exit (1) ;
  2771. } ;
  2773. if (! long_file_ok && sfinfo.frames > frames)
  2774. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  2775. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  2776. exit (1) ;
  2777. } ;
  2779. if (sfinfo.channels != 2)
  2780. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  2781. exit (1) ;
  2782. } ;
  2784. check_log_buffer_or_die (file, __LINE__) ;
  2786. test_readf_float_or_die (file, 0, test, frames, __LINE__) ;
  2787. for (k = 0 ; k < items ; k++)
  2788. if (FLOAT_ERROR (test [k], orig [k]))
  2789. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2790. exit (1) ;
  2791. } ;
  2793. /* Seek to start of file. */
  2794. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  2796. test_readf_float_or_die (file, 0, test, 2, __LINE__) ;
  2797. for (k = 0 ; k < 4 ; k++)
  2798. if (FLOAT_ERROR (test [k], orig [k]))
  2799. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2800. exit (1) ;
  2801. } ;
  2803. /* Seek to offset from start of file. */
  2804. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  2806. /* Check for errors here. */
  2807. if (sf_error (file))
  2808. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  2809. puts (sf_strerror (file)) ;
  2810. exit (1) ;
  2811. } ;
  2813. if (sf_read_float (file, test, 1) > 0)
  2814. { printf ("Line %d: Should return 0.n", __LINE__) ;
  2815. exit (1) ;
  2816. } ;
  2818. if (! sf_error (file))
  2819. { printf ("Line %d: Should return an error.n", __LINE__) ;
  2820. exit (1) ;
  2821. } ;
  2822. /*-----------------------*/
  2824. test_readf_float_or_die (file, 0, test + 10, 2, __LINE__) ;
  2825. for (k = 20 ; k < 24 ; k++)
  2826. if (FLOAT_ERROR (test [k], orig [k]))
  2827. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2828. exit (1) ;
  2829. } ;
  2831. /* Seek to offset from current position. */
  2832. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  2834. test_readf_float_or_die (file, 0, test + 20, 2, __LINE__) ;
  2835. for (k = 40 ; k < 44 ; k++)
  2836. if (FLOAT_ERROR (test [k], orig [k]))
  2837. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2838. exit (1) ;
  2839. } ;
  2841. /* Seek to offset from end of file. */
  2842. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  2844. test_readf_float_or_die (file, 0, test + 20, 2, __LINE__) ;
  2845. for (k = 20 ; k < 24 ; k++)
  2846. if (FLOAT_ERROR (test [k], orig [k]))
  2847. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  2848. exit (1) ;
  2849. } ;
  2851. sf_close (file) ;
  2852. } /* stereo_float_test */
  2854. static void
  2855. mono_rdwr_float_test (const char *filename, int format, int long_file_ok, int allow_fd)
  2856. { SNDFILE *file ;
  2857. SF_INFO sfinfo ;
  2858. float *orig, *test ;
  2859. int k, pass ;
  2861. orig = orig_data.f ;
  2862. test = test_data.f ;
  2864. sfinfo.samplerate = SAMPLE_RATE ;
  2865. sfinfo.frames = DATA_LENGTH ;
  2866. sfinfo.channels = 1 ;
  2867. sfinfo.format = format ;
  2869. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  2870. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  2871. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  2872. unlink (filename) ;
  2873. else
  2874. { /* Create a short file. */
  2875. create_short_file (filename) ;
  2877. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  2878. ** If this returns a valif pointer sf_open() screwed up.
  2879. */
  2880. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  2881. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  2882. exit (1) ;
  2883. } ;
  2885. /* Truncate the file to zero bytes. */
  2886. if (truncate (filename, 0) < 0)
  2887. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  2888. perror (NULL) ;
  2889. exit (1) ;
  2890. } ;
  2891. } ;
  2893. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  2894. ** all the usual data required when opening the file in WRITE mode.
  2895. */
  2896. sfinfo.samplerate = SAMPLE_RATE ;
  2897. sfinfo.frames = DATA_LENGTH ;
  2898. sfinfo.channels = 1 ;
  2899. sfinfo.format = format ;
  2901. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  2903. /* Do 3 writes followed by reads. After each, check the data and the current
  2904. ** read and write offsets.
  2905. */
  2906. for (pass = 1 ; pass <= 3 ; pass ++)
  2907. { orig [20] = pass * 2 ;
  2909. /* Write some data. */
  2910. test_write_float_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  2912. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  2914. /* Read what we just wrote. */
  2915. test_read_float_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  2917. /* Check the data. */
  2918. for (k = 0 ; k < DATA_LENGTH ; k++)
  2919. if (FLOAT_ERROR (orig [k], test [k]))
  2920. { printf ("nnLine %d (pass %d) A : Error at sample %d (%g => %g).n", __LINE__, pass, k, orig [k], test [k]) ;
  2921. oct_save_float (orig, test, DATA_LENGTH) ;
  2922. exit (1) ;
  2923. } ;
  2925. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  2926. } ; /* for (pass ...) */
  2928. sf_close (file) ;
  2930. /* Open the file again to check the data. */
  2931. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  2933. if (sfinfo.format != format)
  2934. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  2935. exit (1) ;
  2936. } ;
  2938. if (sfinfo.frames < 3 * DATA_LENGTH)
  2939. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  2940. exit (1) ;
  2941. }
  2943. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  2944. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  2945. exit (1) ;
  2946. } ;
  2948. if (sfinfo.channels != 1)
  2949. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  2950. exit (1) ;
  2951. } ;
  2953. if (! long_file_ok)
  2954. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  2955. else
  2956. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  2958. for (pass = 1 ; pass <= 3 ; pass ++)
  2959. { orig [20] = pass * 2 ;
  2961. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  2963. /* Read what we just wrote. */
  2964. test_read_float_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  2966. /* Check the data. */
  2967. for (k = 0 ; k < DATA_LENGTH ; k++)
  2968. if (FLOAT_ERROR (orig [k], test [k]))
  2969. { printf ("nnLine %d (pass %d) B : Error at sample %d (%g => %g).n", __LINE__, pass, k, orig [k], test [k]) ;
  2970. oct_save_float (orig, test, DATA_LENGTH) ;
  2971. exit (1) ;
  2972. } ;
  2974. } ; /* for (pass ...) */
  2976. sf_close (file) ;
  2977. } /* mono_rdwr_float_test */
  2979. static void
  2980. new_rdwr_float_test (const char *filename, int format, int allow_fd)
  2981. { SNDFILE *wfile, *rwfile ;
  2982. SF_INFO sfinfo ;
  2983. float *orig, *test ;
  2984. int items, frames ;
  2986. orig = orig_data.f ;
  2987. test = test_data.f ;
  2989. sfinfo.samplerate = 44100 ;
  2990. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  2991. sfinfo.channels = 2 ;
  2992. sfinfo.format = format ;
  2994. items = DATA_LENGTH ;
  2995. frames = items / sfinfo.channels ;
  2997. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  2998. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  2999. test_writef_float_or_die (wfile, 1, orig, frames, __LINE__) ;
  3000. sf_write_sync (wfile) ;
  3001. test_writef_float_or_die (wfile, 2, orig, frames, __LINE__) ;
  3002. sf_write_sync (wfile) ;
  3004. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  3005. if (sfinfo.frames != 2 * frames)
  3006. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  3007. exit (1) ;
  3008. } ;
  3010. test_writef_float_or_die (wfile, 3, orig, frames, __LINE__) ;
  3012. test_readf_float_or_die (rwfile, 1, test, frames, __LINE__) ;
  3013. test_readf_float_or_die (rwfile, 2, test, frames, __LINE__) ;
  3015. sf_close (wfile) ;
  3016. sf_close (rwfile) ;
  3017. } /* new_rdwr_float_test */
  3020. /*======================================================================================
  3021. */
  3023. static void mono_double_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  3024. static void stereo_double_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  3025. static void mono_rdwr_double_test (const char *filename, int format, int long_file_ok, int allow_fd) ;
  3026. static void new_rdwr_double_test (const char *filename, int format, int allow_fd) ;
  3027. static void multi_seek_test (const char * filename, int format) ;
  3028. static void write_seek_extend_test (const char * filename, int format) ;
  3030. static void
  3031. pcm_test_double (const char *filename, int format, int long_file_ok)
  3032. { SF_INFO sfinfo ;
  3033. double *orig, *test ;
  3034. int k, items, allow_fd ;
  3036. /* Sd2 files cannot be opened from an existing file descriptor. */
  3037. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  3039. print_test_name ("pcm_test_double", filename) ;
  3041. sfinfo.samplerate = 44100 ;
  3042. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  3043. sfinfo.channels = 1 ;
  3044. sfinfo.format = format ;
  3046. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 1.0) ;
  3048. orig = orig_data.d ;
  3049. test = test_data.d ;
  3051. /* Make this a macro so gdb steps over it in one go. */
  3052. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  3054. items = DATA_LENGTH ;
  3056. /* Some test broken out here. */
  3058. mono_double_test (filename, format, long_file_ok, allow_fd) ;
  3060. /* Sub format DWVW does not allow seeking. */
  3061. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  3062. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  3063. { unlink (filename) ;
  3064. printf ("no seek : okn") ;
  3065. return ;
  3066. } ;
  3068. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  3069. mono_rdwr_double_test (filename, format, long_file_ok, allow_fd) ;
  3071. /* If the format doesn't support stereo we're done. */
  3072. sfinfo.channels = 2 ;
  3073. if (sf_format_check (&sfinfo) == 0)
  3074. { unlink (filename) ;
  3075. puts ("no stereo : ok") ;
  3076. return ;
  3077. } ;
  3079. stereo_double_test (filename, format, long_file_ok, allow_fd) ;
  3081. /* New read/write test. Not sure if this is needed yet. */
  3083. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_PAF &&
  3084. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_VOC &&
  3085. (format & SF_FORMAT_TYPEMASK) != SF_FORMAT_FLAC)
  3086. new_rdwr_double_test (filename, format, allow_fd) ;
  3088. delete_file (format, filename) ;
  3090. puts ("ok") ;
  3091. return ;
  3092. } /* pcm_test_double */
  3094. static void
  3095. mono_double_test (const char *filename, int format, int long_file_ok, int allow_fd)
  3096. { SNDFILE *file ;
  3097. SF_INFO sfinfo ;
  3098. double *orig, *test ;
  3099. sf_count_t count ;
  3100. int k, items ;
  3102. sfinfo.samplerate = 44100 ;
  3103. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  3104. sfinfo.channels = 1 ;
  3105. sfinfo.format = format ;
  3107. orig = orig_data.d ;
  3108. test = test_data.d ;
  3110. items = DATA_LENGTH ;
  3112. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  3114. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  3116. test_write_double_or_die (file, 0, orig, items, __LINE__) ;
  3117. sf_write_sync (file) ;
  3118. test_write_double_or_die (file, 0, orig, items, __LINE__) ;
  3119. sf_write_sync (file) ;
  3121. /* Add non-audio data after the audio. */
  3122. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  3124. sf_close (file) ;
  3126. memset (test, 0, items * sizeof (double)) ;
  3128. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  3129. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  3131. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  3133. if (sfinfo.format != format)
  3134. { printf ("nnLine %d : Mono : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  3135. exit (1) ;
  3136. } ;
  3138. if (sfinfo.frames < 2 * items)
  3139. { 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) ;
  3140. exit (1) ;
  3141. } ;
  3143. if (! long_file_ok && sfinfo.frames > 2 * items)
  3144. { 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) ;
  3145. exit (1) ;
  3146. } ;
  3148. if (sfinfo.channels != 1)
  3149. { printf ("nnLine %d : Mono : Incorrect number of channels in file.n", __LINE__) ;
  3150. exit (1) ;
  3151. } ;
  3153. check_log_buffer_or_die (file, __LINE__) ;
  3155. test_read_double_or_die (file, 0, test, items, __LINE__) ;
  3156. for (k = 0 ; k < items ; k++)
  3157. if (FLOAT_ERROR (orig [k], test [k]))
  3158. { printf ("nnLine %d: Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3159. oct_save_double (orig, test, items) ;
  3160. exit (1) ;
  3161. } ;
  3163. /* Seek to start of file. */
  3164. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  3166. test_read_double_or_die (file, 0, test, 4, __LINE__) ;
  3167. for (k = 0 ; k < 4 ; k++)
  3168. if (FLOAT_ERROR (orig [k], test [k]))
  3169. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3170. exit (1) ;
  3171. } ;
  3173. if ((format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_16 ||
  3174. (format & SF_FORMAT_SUBMASK) == SF_FORMAT_DWVW_24)
  3175. { sf_close (file) ;
  3176. unlink (filename) ;
  3177. printf ("no seek : ") ;
  3178. return ;
  3179. } ;
  3181. /* Seek to offset from start of file. */
  3182. test_seek_or_die (file, items + 10, SEEK_SET, items + 10, sfinfo.channels, __LINE__) ;
  3184. test_read_double_or_die (file, 0, test + 10, 4, __LINE__) ;
  3185. for (k = 10 ; k < 14 ; k++)
  3186. if (FLOAT_ERROR (orig [k], test [k]))
  3187. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, test [k], orig [k]) ;
  3188. exit (1) ;
  3189. } ;
  3191. /* Seek to offset from current position. */
  3192. test_seek_or_die (file, 6, SEEK_CUR, items + 20, sfinfo.channels, __LINE__) ;
  3194. test_read_double_or_die (file, 0, test + 20, 4, __LINE__) ;
  3195. for (k = 20 ; k < 24 ; k++)
  3196. if (FLOAT_ERROR (orig [k], test [k]))
  3197. { printf ("nnLine %d : Mono : Incorrect sample A (#%d : %g => %g).n", __LINE__, k, test [k], orig [k]) ;
  3198. exit (1) ;
  3199. } ;
  3201. /* Seek to offset from end of file. */
  3202. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  3204. test_read_double_or_die (file, 0, test + 10, 4, __LINE__) ;
  3205. for (k = 10 ; k < 14 ; k++)
  3206. if (FLOAT_ERROR (orig [k], test [k]))
  3207. { printf ("nnLine %d : Mono : Incorrect sample D (#%d : %g => %g).n", __LINE__, k, test [k], orig [k]) ;
  3208. exit (1) ;
  3209. } ;
  3211. /* Check read past end of file followed by sf_seek (sndfile, 0, SEEK_CUR). */
  3212. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  3214. count = 0 ;
  3215. while (count < sfinfo.frames)
  3216. count += sf_read_double (file, test, 311) ;
  3218. /* Check that no error has occurred. */
  3219. if (sf_error (file))
  3220. { printf ("nnLine %d : Mono : error where there shouldn't have been one.n", __LINE__) ;
  3221. puts (sf_strerror (file)) ;
  3222. exit (1) ;
  3223. } ;
  3225. /* Check that we haven't read beyond EOF. */
  3226. if (count > sfinfo.frames)
  3227. { printf ("nnLines %d : read past end of file (%ld should be %ld)n", __LINE__, (long) count, (long) sfinfo.frames) ;
  3228. exit (1) ;
  3229. } ;
  3231. test_seek_or_die (file, 0, SEEK_CUR, sfinfo.frames, sfinfo.channels, __LINE__) ;
  3233. sf_close (file) ;
  3235. multi_seek_test (filename, format) ;
  3236. write_seek_extend_test (filename, format) ;
  3238. } /* mono_double_test */
  3240. static void
  3241. stereo_double_test (const char *filename, int format, int long_file_ok, int allow_fd)
  3242. { SNDFILE *file ;
  3243. SF_INFO sfinfo ;
  3244. double *orig, *test ;
  3245. int k, items, frames ;
  3247. sfinfo.samplerate = 44100 ;
  3248. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  3249. sfinfo.channels = 2 ;
  3250. sfinfo.format = format ;
  3252. gen_windowed_sine_double (orig_data.d, DATA_LENGTH, 1.0) ;
  3254. orig = orig_data.d ;
  3255. test = test_data.d ;
  3257. /* Make this a macro so gdb steps over it in one go. */
  3258. CONVERT_DATA (k, DATA_LENGTH, orig, orig_data.d) ;
  3260. items = DATA_LENGTH ;
  3261. frames = items / sfinfo.channels ;
  3263. file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  3265. sf_set_string (file, SF_STR_ARTIST, "Your name here") ;
  3267. test_writef_double_or_die (file, 0, orig, frames, __LINE__) ;
  3269. sf_set_string (file, SF_STR_COPYRIGHT, "Copyright (c) 2003") ;
  3271. sf_close (file) ;
  3273. memset (test, 0, items * sizeof (double)) ;
  3275. if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
  3276. memset (&sfinfo, 0, sizeof (sfinfo)) ;
  3278. file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
  3280. if (sfinfo.format != format)
  3281. { printf ("nnLine %d : Stereo : Returned format incorrect (0x%08X => 0x%08X).n",
  3282. __LINE__, format, sfinfo.format) ;
  3283. exit (1) ;
  3284. } ;
  3286. if (sfinfo.frames < frames)
  3287. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too short). (%ld should be %d)n",
  3288. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  3289. exit (1) ;
  3290. } ;
  3292. if (! long_file_ok && sfinfo.frames > frames)
  3293. { printf ("nnLine %d : Stereo : Incorrect number of frames in file (too long). (%ld should be %d)n",
  3294. __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), frames) ;
  3295. exit (1) ;
  3296. } ;
  3298. if (sfinfo.channels != 2)
  3299. { printf ("nnLine %d : Stereo : Incorrect number of channels in file.n", __LINE__) ;
  3300. exit (1) ;
  3301. } ;
  3303. check_log_buffer_or_die (file, __LINE__) ;
  3305. test_readf_double_or_die (file, 0, test, frames, __LINE__) ;
  3306. for (k = 0 ; k < items ; k++)
  3307. if (FLOAT_ERROR (test [k], orig [k]))
  3308. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3309. exit (1) ;
  3310. } ;
  3312. /* Seek to start of file. */
  3313. test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
  3315. test_readf_double_or_die (file, 0, test, 2, __LINE__) ;
  3316. for (k = 0 ; k < 4 ; k++)
  3317. if (FLOAT_ERROR (test [k], orig [k]))
  3318. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3319. exit (1) ;
  3320. } ;
  3322. /* Seek to offset from start of file. */
  3323. test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
  3325. /* Check for errors here. */
  3326. if (sf_error (file))
  3327. { printf ("Line %d: Should NOT return an error.n", __LINE__) ;
  3328. puts (sf_strerror (file)) ;
  3329. exit (1) ;
  3330. } ;
  3332. if (sf_read_double (file, test, 1) > 0)
  3333. { printf ("Line %d: Should return 0.n", __LINE__) ;
  3334. exit (1) ;
  3335. } ;
  3337. if (! sf_error (file))
  3338. { printf ("Line %d: Should return an error.n", __LINE__) ;
  3339. exit (1) ;
  3340. } ;
  3341. /*-----------------------*/
  3343. test_readf_double_or_die (file, 0, test + 10, 2, __LINE__) ;
  3344. for (k = 20 ; k < 24 ; k++)
  3345. if (FLOAT_ERROR (test [k], orig [k]))
  3346. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3347. exit (1) ;
  3348. } ;
  3350. /* Seek to offset from current position. */
  3351. test_seek_or_die (file, 8, SEEK_CUR, 20, sfinfo.channels, __LINE__) ;
  3353. test_readf_double_or_die (file, 0, test + 20, 2, __LINE__) ;
  3354. for (k = 40 ; k < 44 ; k++)
  3355. if (FLOAT_ERROR (test [k], orig [k]))
  3356. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3357. exit (1) ;
  3358. } ;
  3360. /* Seek to offset from end of file. */
  3361. test_seek_or_die (file, -1 * (sfinfo.frames - 10), SEEK_END, 10, sfinfo.channels, __LINE__) ;
  3363. test_readf_double_or_die (file, 0, test + 20, 2, __LINE__) ;
  3364. for (k = 20 ; k < 24 ; k++)
  3365. if (FLOAT_ERROR (test [k], orig [k]))
  3366. { printf ("nnLine %d : Stereo : Incorrect sample (#%d : %g => %g).n", __LINE__, k, orig [k], test [k]) ;
  3367. exit (1) ;
  3368. } ;
  3370. sf_close (file) ;
  3371. } /* stereo_double_test */
  3373. static void
  3374. mono_rdwr_double_test (const char *filename, int format, int long_file_ok, int allow_fd)
  3375. { SNDFILE *file ;
  3376. SF_INFO sfinfo ;
  3377. double *orig, *test ;
  3378. int k, pass ;
  3380. orig = orig_data.d ;
  3381. test = test_data.d ;
  3383. sfinfo.samplerate = SAMPLE_RATE ;
  3384. sfinfo.frames = DATA_LENGTH ;
  3385. sfinfo.channels = 1 ;
  3386. sfinfo.format = format ;
  3388. if ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW
  3389. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AU
  3390. || (format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
  3391. unlink (filename) ;
  3392. else
  3393. { /* Create a short file. */
  3394. create_short_file (filename) ;
  3396. /* Opening a already existing short file (ie invalid header) RDWR is disallowed.
  3397. ** If this returns a valif pointer sf_open() screwed up.
  3398. */
  3399. if ((file = sf_open (filename, SFM_RDWR, &sfinfo)))
  3400. { printf ("nnLine %d: sf_open should (SFM_RDWR) have failed but didn't.n", __LINE__) ;
  3401. exit (1) ;
  3402. } ;
  3404. /* Truncate the file to zero bytes. */
  3405. if (truncate (filename, 0) < 0)
  3406. { printf ("nnLine %d: truncate (%s) failed", __LINE__, filename) ;
  3407. perror (NULL) ;
  3408. exit (1) ;
  3409. } ;
  3410. } ;
  3412. /* Opening a zero length file RDWR is allowed, but the SF_INFO struct must contain
  3413. ** all the usual data required when opening the file in WRITE mode.
  3414. */
  3415. sfinfo.samplerate = SAMPLE_RATE ;
  3416. sfinfo.frames = DATA_LENGTH ;
  3417. sfinfo.channels = 1 ;
  3418. sfinfo.format = format ;
  3420. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  3422. /* Do 3 writes followed by reads. After each, check the data and the current
  3423. ** read and write offsets.
  3424. */
  3425. for (pass = 1 ; pass <= 3 ; pass ++)
  3426. { orig [20] = pass * 2 ;
  3428. /* Write some data. */
  3429. test_write_double_or_die (file, pass, orig, DATA_LENGTH, __LINE__) ;
  3431. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, pass * DATA_LENGTH) ;
  3433. /* Read what we just wrote. */
  3434. test_read_double_or_die (file, 0, test, DATA_LENGTH, __LINE__) ;
  3436. /* Check the data. */
  3437. for (k = 0 ; k < DATA_LENGTH ; k++)
  3438. if (FLOAT_ERROR (orig [k], test [k]))
  3439. { printf ("nnLine %d (pass %d) A : Error at sample %d (%g => %g).n", __LINE__, pass, k, orig [k], test [k]) ;
  3440. oct_save_double (orig, test, DATA_LENGTH) ;
  3441. exit (1) ;
  3442. } ;
  3444. test_read_write_position_or_die (file, __LINE__, pass, pass * DATA_LENGTH, pass * DATA_LENGTH) ;
  3445. } ; /* for (pass ...) */
  3447. sf_close (file) ;
  3449. /* Open the file again to check the data. */
  3450. file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  3452. if (sfinfo.format != format)
  3453. { printf ("nnLine %d : Returned format incorrect (0x%08X => 0x%08X).n", __LINE__, format, sfinfo.format) ;
  3454. exit (1) ;
  3455. } ;
  3457. if (sfinfo.frames < 3 * DATA_LENGTH)
  3458. { printf ("nnLine %d : Not enough frames in file. (%ld < %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  3459. exit (1) ;
  3460. }
  3462. if (! long_file_ok && sfinfo.frames != 3 * DATA_LENGTH)
  3463. { printf ("nnLine %d : Incorrect number of frames in file. (%ld should be %d)n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 3 * DATA_LENGTH ) ;
  3464. exit (1) ;
  3465. } ;
  3467. if (sfinfo.channels != 1)
  3468. { printf ("nnLine %d : Incorrect number of channels in file.n", __LINE__) ;
  3469. exit (1) ;
  3470. } ;
  3472. if (! long_file_ok)
  3473. test_read_write_position_or_die (file, __LINE__, 0, 0, 3 * DATA_LENGTH) ;
  3474. else
  3475. test_seek_or_die (file, 3 * DATA_LENGTH, SFM_WRITE | SEEK_SET, 3 * DATA_LENGTH, sfinfo.channels, __LINE__) ;
  3477. for (pass = 1 ; pass <= 3 ; pass ++)
  3478. { orig [20] = pass * 2 ;
  3480. test_read_write_position_or_die (file, __LINE__, pass, (pass - 1) * DATA_LENGTH, 3 * DATA_LENGTH) ;
  3482. /* Read what we just wrote. */
  3483. test_read_double_or_die (file, pass, test, DATA_LENGTH, __LINE__) ;
  3485. /* Check the data. */
  3486. for (k = 0 ; k < DATA_LENGTH ; k++)
  3487. if (FLOAT_ERROR (orig [k], test [k]))
  3488. { printf ("nnLine %d (pass %d) B : Error at sample %d (%g => %g).n", __LINE__, pass, k, orig [k], test [k]) ;
  3489. oct_save_double (orig, test, DATA_LENGTH) ;
  3490. exit (1) ;
  3491. } ;
  3493. } ; /* for (pass ...) */
  3495. sf_close (file) ;
  3496. } /* mono_rdwr_double_test */
  3498. static void
  3499. new_rdwr_double_test (const char *filename, int format, int allow_fd)
  3500. { SNDFILE *wfile, *rwfile ;
  3501. SF_INFO sfinfo ;
  3502. double *orig, *test ;
  3503. int items, frames ;
  3505. orig = orig_data.d ;
  3506. test = test_data.d ;
  3508. sfinfo.samplerate = 44100 ;
  3509. sfinfo.frames = SILLY_WRITE_COUNT ; /* Wrong length. Library should correct this on sf_close. */
  3510. sfinfo.channels = 2 ;
  3511. sfinfo.format = format ;
  3513. items = DATA_LENGTH ;
  3514. frames = items / sfinfo.channels ;
  3516. wfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
  3517. sf_command (wfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
  3518. test_writef_double_or_die (wfile, 1, orig, frames, __LINE__) ;
  3519. sf_write_sync (wfile) ;
  3520. test_writef_double_or_die (wfile, 2, orig, frames, __LINE__) ;
  3521. sf_write_sync (wfile) ;
  3523. rwfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, allow_fd, __LINE__) ;
  3524. if (sfinfo.frames != 2 * frames)
  3525. { printf ("nnLine %d : incorrect number of frames in file (%ld should be %d)nn", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * frames) ;
  3526. exit (1) ;
  3527. } ;
  3529. test_writef_double_or_die (wfile, 3, orig, frames, __LINE__) ;
  3531. test_readf_double_or_die (rwfile, 1, test, frames, __LINE__) ;
  3532. test_readf_double_or_die (rwfile, 2, test, frames, __LINE__) ;
  3534. sf_close (wfile) ;
  3535. sf_close (rwfile) ;
  3536. } /* new_rdwr_double_test */
  3540. /*----------------------------------------------------------------------------------------
  3541. */
  3543. static void
  3544. empty_file_test (const char *filename, int format)
  3545. { SNDFILE *file ;
  3546. SF_INFO info ;
  3547. int allow_fd ;
  3549. /* Sd2 files cannot be opened from an existing file descriptor. */
  3550. allow_fd = ((format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2) ? SF_FALSE : SF_TRUE ;
  3552. print_test_name ("empty_file_test", filename) ;
  3554. unlink (filename) ;
  3556. info.samplerate = 48000 ;
  3557. info.channels = 2 ;
  3558. info.format = format ;
  3560. if (sf_format_check (&info) == SF_FALSE)
  3561. { info.channels = 1 ;
  3562. if (sf_format_check (&info) == SF_FALSE)
  3563. { puts ("invalid file format") ;
  3564. return ;
  3565. } ;
  3566. } ;
  3568. /* Create an empty file. */
  3569. file = test_open_file_or_die (filename, SFM_WRITE, &info, allow_fd, __LINE__) ;
  3570. sf_close (file) ;
  3572. /* Open for read and check the length. */
  3573. file = test_open_file_or_die (filename, SFM_READ, &info, allow_fd, __LINE__) ;
  3575. if (SF_COUNT_TO_LONG (info.frames) != 0)
  3576. { printf ("nnError : frame count (%ld) should be zero.n", SF_COUNT_TO_LONG (info.frames)) ;
  3577. exit (1) ;
  3578. } ;
  3580. sf_close (file) ;
  3582. /* Open for read/write and check the length. */
  3583. file = test_open_file_or_die (filename, SFM_RDWR, &info, allow_fd, __LINE__) ;
  3585. if (SF_COUNT_TO_LONG (info.frames) != 0)
  3586. { printf ("nnError : frame count (%ld) should be zero.n", SF_COUNT_TO_LONG (info.frames)) ;
  3587. exit (1) ;
  3588. } ;
  3590. sf_close (file) ;
  3592. /* Open for read and check the length. */
  3593. file = test_open_file_or_die (filename, SFM_READ, &info, allow_fd, __LINE__) ;
  3595. if (SF_COUNT_TO_LONG (info.frames) != 0)
  3596. { printf ("nnError : frame count (%ld) should be zero.n", SF_COUNT_TO_LONG (info.frames)) ;
  3597. exit (1) ;
  3598. } ;
  3600. sf_close (file) ;
  3602. check_open_file_count_or_die (__LINE__) ;
  3604. unlink (filename) ;
  3605. puts ("ok") ;
  3607. return ;
  3608. } /* empty_file_test */
  3611. /*----------------------------------------------------------------------------------------
  3612. */
  3614. static void
  3615. create_short_file (const char *filename)
  3616. { FILE *file ;
  3618. if (! (file = fopen (filename, "w")))
  3619. { printf ("create_short_file : fopen (%s, "w") failed.", filename) ;
  3620. fflush (stdout) ;
  3621. perror (NULL) ;
  3622. exit (1) ;
  3623. } ;
  3625. fprintf (file, "This is the file data.n") ;
  3627. fclose (file) ;
  3628. } /* create_short_file */
  3630. #if (defined (WIN32) || defined (__WIN32))
  3632. /* Win32 does not have truncate (nor does it have the POSIX function ftruncate).
  3633. ** Hack somethng up here to over come this. This function can only truncate to a
  3634. ** length of zero.
  3635. */
  3637. static int
  3638. truncate (const char *filename, int ignored)
  3639. { int fd ;
  3641. ignored = 0 ;
  3643. if ((fd = open (filename, O_RDWR | O_TRUNC | O_BINARY)) < 0)
  3644. return 0 ;
  3646. close (fd) ;
  3648. return 0 ;
  3649. } /* truncate */
  3651. #endif
  3653. static void
  3654. multi_seek_test (const char * filename, int format)
  3655. { SNDFILE * file ;
  3656. SF_INFO info ;
  3657. sf_count_t pos ;
  3658. int k ;
  3660. /* This test doesn't work on the following. */
  3661. switch (format & SF_FORMAT_TYPEMASK)
  3662. { case SF_FORMAT_RAW :
  3663. return ;
  3665. default :
  3666. break ;
  3667. } ;
  3669. memset (&info, 0, sizeof (info)) ;
  3671. generate_file (filename, format, 88200) ;
  3673. file = test_open_file_or_die (filename, SFM_READ, &info, SF_FALSE, __LINE__) ;
  3675. for (k = 0 ; k < 10 ; k++)
  3676. { pos = info.frames / (k + 2) ;
  3677. test_seek_or_die (file, pos, SEEK_SET, pos, info.channels, __LINE__) ;
  3678. } ;
  3680. sf_close (file) ;
  3681. } /* multi_seek_test */
  3683. static void
  3684. write_seek_extend_test (const char * filename, int format)
  3685. { SNDFILE * file ;
  3686. SF_INFO info ;
  3687. short *orig, *test ;
  3688. unsigned items, k ;
  3690. /* This test doesn't work on the following. */
  3691. switch (format & SF_FORMAT_TYPEMASK)
  3692. { case SF_FORMAT_FLAC :
  3693. case SF_FORMAT_HTK :
  3694. case SF_FORMAT_PAF :
  3695. case SF_FORMAT_SDS :
  3696. case SF_FORMAT_SVX :
  3697. return ;
  3699. default :
  3700. break ;
  3701. } ;
  3703. memset (&info, 0, sizeof (info)) ;
  3705. info.samplerate = 48000 ;
  3706. info.channels = 1 ;
  3707. info.format = format ;
  3709. items = 512 ;
  3710. exit_if_true (items > ARRAY_LEN (orig_data.s), "Line %d : Bad assumption.n", __LINE__) ;
  3712. orig = orig_data.s ;
  3713. test = test_data.s ;
  3715. for (k = 0 ; k < ARRAY_LEN (orig_data.s) ; k++)
  3716. orig [k] = 0x3fff ;
  3718. file = test_open_file_or_die (filename, SFM_WRITE, &info, SF_FALSE, __LINE__) ;
  3719. test_write_short_or_die (file, 0, orig, items, __LINE__) ;
  3721. /* Extend the file using a seek. */
  3722. test_seek_or_die (file, 2 * items, SEEK_SET, 2 * items, info.channels, __LINE__) ;
  3724. test_writef_short_or_die (file, 0, orig, items, __LINE__) ;
  3725. sf_close (file) ;
  3727. file = test_open_file_or_die (filename, SFM_READ, &info, SF_FALSE, __LINE__) ;
  3728. test_read_short_or_die (file, 0, test, 3 * items, __LINE__) ;
  3729. sf_close (file) ;
  3731. /* Can't do these formats due to scaling. */
  3732. switch (format & SF_FORMAT_SUBMASK)
  3733. { case SF_FORMAT_PCM_S8 :
  3734. case SF_FORMAT_PCM_U8 :
  3735. return ;
  3736. default :
  3737. break ;
  3738. } ;
  3740. for (k = 0 ; k < items ; k++)
  3741. { exit_if_true (test [k] != 0x3fff, "Line %d : test [%d] == %d, should be 0x3fff.n", __LINE__, k, test [k]) ;
  3742. exit_if_true (test [items + k] != 0, "Line %d : test [%d] == %d, should be 0.n", __LINE__, items + k, test [items + k]) ;
  3743. 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]) ;
  3744. } ;
  3746. return ;
  3747. } /* write_seek_extend_test */