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

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

流媒体/Mpeg4/MP4

开发平台：

C/C++

read_seek_test.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2000 Erik de Castro Lopo <erikd@zip.com.au>
  3. **  
  4. ** This program is free software; you can redistribute it and/or modify
  5. ** it under the terms of the GNU General Public License as published by
  6. ** the Free Software Foundation; either version 2 of the License, or
  7. ** (at your option) any later version.
  8. ** 
  9. ** This program is distributed in the hope that it will be useful,
  10. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. ** GNU General Public License for more details.
  13. ** 
  14. ** You should have received a copy of the GNU General Public License
  15. ** along with this program; if not, write to the Free Software 
  16. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. */
  21. #include <stdio.h>
  22. #include <unistd.h>
  23. #include <sys/stat.h>
  24. #include <fcntl.h>
  26. #include <sndfile.h>
  28. static unsigned char  wav_ieee [] =
  29. { 0x52, 0x49, 0x46, 0x46, 0x64, 0x00, 0x00, 0x00, 
  30. 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20,
  31. 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 
  32. 0x34, 0x12, 0x00, 0x00, 0xD0, 0x48, 0x00, 0x00,
  33. 0x04, 0x00, 0x20, 0x00, 0x64, 0x61, 0x74, 0x61, 
  34. 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  35. 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x40, 
  36. 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x80, 0x40,
  37. 0x00, 0x00, 0xA0, 0x40, 0x00, 0x00, 0xC0, 0x40, 
  38. 0x00, 0x00, 0xE0, 0x40, 0x00, 0x00, 0x00, 0x41,
  39. 0x00, 0x00, 0x10, 0x41, 0x00, 0x00, 0x20, 0x41, 
  40. 0x00, 0x00, 0x30, 0x41, 0x00, 0x00, 0x40, 0x41,
  41. 0x00, 0x00, 0x50, 0x41, 0x00, 0x00, 0x60, 0x41, 
  42. 0x00, 0x00, 0x70, 0x41, 0x49, 0x4E, 0x46, 0x4F,
  43. 0x04, 0x00, 0x00, 0x00, 0xFE, 0xED, 0xC0, 0xDE
  44. } ; /* wav_ieee */
  46. static unsigned char  wav_pcm32 [] =
  47. { 0x52, 0x49, 0x46, 0x46, 0x64, 0x00, 0x00, 0x00, 
  48. 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20,
  49. 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 
  50. 0x34, 0x12, 0x00, 0x00, 0xD0, 0x48, 0x00, 0x00,
  51. 0x04, 0x00, 0x20, 0x00, 0x64, 0x61, 0x74, 0x61, 
  52. 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  53. 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
  54. 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
  55. 0x05, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 
  56. 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
  57. 0x09, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 
  58. 0x0B, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
  59. 0x0D, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 
  60. 0x0F, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x46, 0x4F,
  61. 0x04, 0x00, 0x00, 0x00, 0xFE, 0xED, 0xC0, 0xDE
  62. } ; /* wav_pcm32 */
  64. static unsigned char  wav_pcm24 [] =
  65. { 0x52, 0x49, 0x46, 0x46, 0x54, 0x00, 0x00, 0x00, 
  66. 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20,
  67. 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 
  68. 0x34, 0x12, 0x00, 0x00, 0x9C, 0x36, 0x00, 0x00, 
  69. 0x03, 0x00, 0x18, 0x00, 0x64, 0x61, 0x74, 0x61, 
  70. 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
  71. 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 
  72. 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x06, 0x00, 
  73. 0x00, 0x07, 0x00, 0x00, 0x08, 0x00, 0x00, 0x09, 
  74. 0x00, 0x00, 0x0A, 0x00, 0x00, 0x0B, 0x00, 0x00, 
  75. 0x0C, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x0E, 0x00, 
  76. 0x00, 0x0F, 0x00, 0x00, 0x49, 0x4E, 0x46, 0x4F,
  77. 0x04, 0x00, 0x00, 0x00, 0xFE, 0xED, 0xC0, 0xDE
  78. } ; /* wav_pcm24 */
  80. static unsigned char  wav_pcm16 [] =
  81. { 0x52, 0x49, 0x46, 0x46, 0x44, 0x00, 0x00, 0x00, 
  82. 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20, 
  83. 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 
  84. 0x34, 0x12, 0x00, 0x00, 0x24, 0x68, 0x00, 0x00, 
  85. 0x02, 0x00, 0x10, 0x00, 0x64, 0x61, 0x74, 0x61, 
  86. 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 
  87. 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 
  88. 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 
  89. 0x0A, 0x00, 0x0B, 0x00, 0x0C, 0x00, 0x0D, 0x00, 
  90. 0x0E, 0x00, 0x0F, 0x00, 0x49, 0x4E, 0x46, 0x4F,
  91. 0x04, 0x00, 0x00, 0x00, 0xFE, 0xED, 0xC0, 0xDE
  92. } ; /* wav_pcm16 */
  94. static unsigned char  wav_pcm8 [] =
  95. { 0x52, 0x49, 0x46, 0x46, 0x34, 0x00, 0x00, 0x00, 
  96. 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20, 
  97. 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 
  98. 0x34, 0x12, 0x00, 0x00, 0x34, 0x12, 0x00, 0x00, 
  99. 0x01, 0x00, 0x08, 0x00, 0x64, 0x61, 0x74, 0x61, 
  100. 0x10, 0x00, 0x00, 0x00, 0x80, 0x81, 0x82, 0x83, 
  101. 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 
  102. 0x8C, 0x8D, 0x8E, 0x8F, 0x49, 0x4E, 0x46, 0x4F,
  103. 0x04, 0x00, 0x00, 0x00, 0xFE, 0xED, 0xC0, 0xDE
  104. } ; /* wav_pcm8 */
  106. static unsigned char  aiff_pcm32 [] =
  107. { 0x46, 0x4F, 0x52, 0x4D, 0x00, 0x00, 0x00, 0x6E, 
  108. 0x41, 0x49, 0x46, 0x46, 0x43, 0x4F, 0x4D, 0x4D,
  109. 0x00, 0x00, 0x00, 0x12, 0x00, 0x01, 0x00, 0x00, 
  110. 0x00, 0x10, 0x00, 0x20, 0x40, 0x0B, 0x91, 0xA0,
  111. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x53, 
  112. 0x4E, 0x44, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
  113. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  114. 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
  115. 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
  116. 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
  117. 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 
  118. 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
  119. 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 
  120. 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00,
  121. 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0F
  122. } ; /* aiff_pcm32 */
  124. static unsigned char  aiff_pcm24 [] =
  125. { 0x46, 0x4F, 0x52, 0x4D, 0x00, 0x00, 0x00, 0x5E, 
  126. 0x41, 0x49, 0x46, 0x46, 0x43, 0x4F, 0x4D, 0x4D, 
  127. 0x00, 0x00, 0x00, 0x12, 0x00, 0x01, 0x00, 0x00, 
  128. 0x00, 0x10, 0x00, 0x18, 0x40, 0x0B, 0x91, 0xA0, 
  129. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x53, 
  130. 0x4E, 0x44, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 
  131. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  132. 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 
  133. 0x00, 0x03, 0x00, 0x00, 0x04, 0x00, 0x00, 0x05, 
  134. 0x00, 0x00, 0x06, 0x00, 0x00, 0x07, 0x00, 0x00, 
  135. 0x08, 0x00, 0x00, 0x09, 0x00, 0x00, 0x0A, 0x00, 
  136. 0x00, 0x0B, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0D, 
  137. 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0F
  138. } ; /* aiff_pcm24 */
  140. static unsigned char  aiff_pcm16 [] =
  141. { 0x46, 0x4F, 0x52, 0x4D, 0x00, 0x00, 0x00, 0x4E, 
  142. 0x41, 0x49, 0x46, 0x46, 0x43, 0x4F, 0x4D, 0x4D, 
  143. 0x00, 0x00, 0x00, 0x12, 0x00, 0x01, 0x00, 0x00, 
  144. 0x00, 0x10, 0x00, 0x10, 0x40, 0x0B, 0x91, 0xA0, 
  145. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x53, 
  146. 0x4E, 0x44, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 
  147. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  148. 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 
  149. 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 
  150. 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0B, 0x00, 0x0C, 
  151. 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x0F
  152. } ; /* aiff_pcm16 */
  155. static unsigned char  aiff_pcm8 [] =
  156. { 0x46, 0x4F, 0x52, 0x4D, 0x00, 0x00, 0x00, 0x3E, 
  157. 0x41, 0x49, 0x46, 0x46, 0x43, 0x4F, 0x4D, 0x4D, 
  158. 0x00, 0x00, 0x00, 0x12, 0x00, 0x01, 0x00, 0x00, 
  159. 0x00, 0x10, 0x00, 0x08, 0x40, 0x0B, 0x91, 0xA0, 
  160. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x53, 
  161. 0x4E, 0x44, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 
  162. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
  163. 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
  164. 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
  165. } ; /* aiff_pcm8 */
  168. static unsigned char  au_pcm32 [] =
  169. { 0x2E, 0x73, 0x6E, 0x64, 0x00, 0x00, 0x00, 0x18, 
  170. 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x05,
  171. 0x00, 0x00, 0x12, 0x34, 0x00, 0x00, 0x00, 0x01, 
  172. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
  173. 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
  174. 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
  175. 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07,
  176. 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09,
  177. 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0B,
  178. 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0D,
  179. 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0F
  180. } ; /* au_pcm32 */
  182. static unsigned char  au_pcm24 [] =
  183. { 0x2E, 0x73, 0x6E, 0x64, 0x00, 0x00, 0x00, 0x18, 
  184. 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x04,
  185. 0x00, 0x00, 0x12, 0x34, 0x00, 0x00, 0x00, 0x01,
  186. 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
  187. 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x04, 0x00,
  188. 0x00, 0x05, 0x00, 0x00, 0x06, 0x00, 0x00, 0x07,
  189. 0x00, 0x00, 0x08, 0x00, 0x00, 0x09, 0x00, 0x00,
  190. 0x0A, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x0C, 0x00,
  191. 0x00, 0x0D, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0F
  192. } ; /* au_pcm24 */
  194. static unsigned char  au_pcm16 [] =
  195. { 0x2E, 0x73, 0x6E, 0x64, 0x00, 0x00, 0x00, 0x18, 
  196. 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03,
  197. 0x00, 0x00, 0x12, 0x34, 0x00, 0x00, 0x00, 0x01, 
  198. 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03,
  199. 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 
  200. 0x00, 0x08, 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0B,
  201. 0x00, 0x0C, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x0F
  202. } ; /* au_pcm16 */
  204. static unsigned char  au_pcm8 [] =
  205. { 0x2E, 0x73, 0x6E, 0x64, 0x00, 0x00, 0x00, 0x18, 
  206. 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x02,
  207. 0x00, 0x00, 0x12, 0x34, 0x00, 0x00, 0x00, 0x01, 
  208. 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  209. 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
  210. } ; /* au_pcm8 */
  212. static
  213. void write_file (char *filename, unsigned char *data, size_t len)
  214. { FILE* fp = NULL ;
  216. fp = fopen (filename,"wb") ;
  218. if (fp == NULL)
  219. { printf ("Could not open file '%s' for writing.n", filename) ;
  220. sf_perror (NULL) ;
  221. exit (1) ;
  222. } ;
  224. if (fwrite (data, 1, len, fp) != len)
  225. { printf ("Write to file '%s' failed.n", filename) ;
  226. sf_perror (NULL) ;
  227. exit (1) ;
  228. } ;
  230. fclose (fp) ;
  231. } /* write_file */
  233. static
  234. void double_test (char *filename, int length)
  235. { int k, count ;
  236. SNDFILE *file ;
  237. SF_INFO sfinfo ;
  238. double *readdata ;
  240. printf ("    double_test (%s) ... ", filename) ;
  242. if (! (file = sf_open_read (filename, &sfinfo)))
  243. { printf ("Could not open file '%s' for read.n", filename) ;
  244. sf_perror (NULL) ;
  245. exit (1) ;
  246. } ;
  248. if (sfinfo.samples != length)
  249. { printf ("Expecting %d samples in file, found %d.n", length, sfinfo.samples) ;
  250. exit (1) ;
  251. } ;
  253. readdata = (double*) malloc (sfinfo.samples * sizeof (double)) ;
  255. if ((count = sf_read_double (file, readdata, sfinfo.samples, 0)) != sfinfo.samples)
  256. { printf ("sf_read_double failed (%d items read).n", count) ;
  257. exit (1) ;
  258. } ;
  260. for (k = 0 ; k < sfinfo.samples ; k++)
  261. if (readdata [k] != (double) (k))
  262. { printf ("Incorrect sample (#%d => %g).n", k, readdata [k]) ;
  263. exit (1) ;
  264. } ;
  266. /* Check seek from start of file. */
  267. k = sf_seek (file, 1, SEEK_SET) ;
  268. sf_read_double (file, readdata, 1, 0) ;
  269. if (readdata [0] != 1 || k != 1)
  270. { printf ("sf_seek (SEEK_SET) followed by sf_read_XXXX failed (%d, %d).n", ((int) readdata [0]), k) ;
  271. exit (1) ;
  272. } ;
  274. /* Check seek forward from current position. */
  275. k = sf_seek (file, 2, SEEK_CUR) ;
  276. sf_read_double (file, readdata, 1, 0) ;
  277. if (readdata [0] != 4 || k != 4)
  278. { printf ("sf_seek (SEEK_CUR) followed by sf_read_XXXX failed (%d, %d).n", ((int) readdata [0]), k) ;
  279. exit (1) ;
  280. } ;
  282. /* Check seek backward from current position. */
  283. k = sf_seek (file, -2, SEEK_CUR) ;
  284. sf_read_double (file, readdata, 1, 0) ;
  285. if (readdata [0] != 3 || k != 3)
  286. { printf ("sf_seek (SEEK_CUR) followed by sf_read_XXXX failed (%d, %d).n", ((int) readdata [0]), k) ;
  287. exit (1) ;
  288. } ;
  290. /* Check that read past end of file returns number of items. */
  291. if ((k = sf_read_double (file, readdata, sfinfo.samples, 0)) != 12)
  292. { printf ("Return value from short sf_read_XXXX incorrect (%d).n", k) ;
  293. exit (1) ;
  294. } ;
  296. /* Check seek backward from end. */
  297. k = sf_seek (file, -14, SEEK_END) ;
  298. sf_read_double (file, readdata, 1, 0) ;
  299. if (readdata [0] != 2 || k != 2)
  300. { printf ("sf_seek (SEEK_END) followed by sf_read_XXXX failed (%d, %d).n", ((int) readdata [0]), k) ;
  301. exit (1) ;
  302. } ;
  304. /* Check multiple reads. */
  305. k = sf_seek (file, 0, SEEK_SET) ;
  306. count = 0 ;
  307. while ((k = sf_read_double (file, readdata, 3, 0)))
  308. count += k ;
  309. if (count != sfinfo.samples)
  310. { printf ("failed multiple read test (%d, %d).n", count, sfinfo.samples) ;
  311. exit (1) ;
  312. } ;
  314. free (readdata) ;
  315. sf_close (file) ;
  317. printf ("okn") ;
  319. } /* double_test */
  322. static
  323. void int_test (char *filename, int length)
  324. { int count, k ;
  325. SNDFILE *file ;
  326. SF_INFO sfinfo ;
  327. int *readdata ;
  329. printf ("    int_test    (%s) ... ", filename) ;
  331. if (! (file = sf_open_read (filename, &sfinfo)))
  332. { printf ("Could not open file '%s' for read.n", filename) ;
  333. sf_perror (NULL) ;
  334. exit (1) ;
  335. } ;
  337. if (sfinfo.samples != length)
  338. { printf ("Expecting %d samples in file, found %d.n", length, sfinfo.samples) ;
  339. exit (1) ;
  340. } ;
  342. readdata = (int*) malloc (sfinfo.samples * sizeof (int)) ;
  344. if ((count = sf_read_int (file, readdata, sfinfo.samples)) != sfinfo.samples)
  345. { printf ("sf_read_int failed (%d items read).n", count) ;
  346. exit (1) ;
  347. } ;
  349. for (k = 0 ; k < sfinfo.samples ; k++)
  350. if (readdata [k] != (int) (k))
  351. { printf ("Incorrect sample (#%d => %d).n", k, readdata [k]) ;
  352. exit (1) ;
  353. } ;
  355. /* Check seek from start of file. */
  356. k = sf_seek (file, 1, SEEK_SET) ;
  357. sf_read_int (file, readdata, 1) ;
  358. if (readdata [0] != 1 || k != 1)
  359. { printf ("sf_seek (SEEK_SET) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  360. exit (1) ;
  361. } ;
  363. /* Check seek forward from current position. */
  364. k = sf_seek (file, 2, SEEK_CUR) ;
  365. sf_read_int (file, readdata, 1) ;
  366. if (readdata [0] != 4 || k != 4)
  367. { printf ("sf_seek (SEEK_CUR) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  368. exit (1) ;
  369. } ;
  371. /* Check seek backward from current position. */
  372. k = sf_seek (file, -2, SEEK_CUR) ;
  373. sf_read_int (file, readdata, 1) ;
  374. if (readdata [0] != 3 || k != 3)
  375. { printf ("sf_seek (SEEK_CUR) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  376. exit (1) ;
  377. } ;
  379. /* Check that read past end of file returns number of items. */
  380. if ((k = sf_read_int (file, readdata, sfinfo.samples)) != 12)
  381. { printf ("Return value from short sf_read_XXXX incorrect (%d).n", k) ;
  382. exit (1) ;
  383. } ;
  385. /* Check seek backward from end. */
  386. k = sf_seek (file, -14, SEEK_END) ;
  387. sf_read_int (file, readdata, 1) ;
  388. if (readdata [0] != 2 || k != 2)
  389. { printf ("sf_seek (SEEK_END) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  390. exit (1) ;
  391. } ;
  393. /* Check multiple reads. */
  394. k = sf_seek (file, 0, SEEK_SET) ;
  395. count = 0 ;
  396. while ((k = sf_read_int (file, readdata, 3)))
  397. count += k ;
  398. if (count != sfinfo.samples)
  399. { printf ("failed multiple read test (%d, %d).n", count, sfinfo.samples) ;
  400. exit (1) ;
  401. } ;
  403. free (readdata) ;
  404. sf_close (file) ;
  406. printf ("okn") ;
  408. } /* int_test */
  410. static
  411. void short_test (char *filename, int length)
  412. { int count, k ;
  413. SNDFILE *file ;
  414. SF_INFO sfinfo ;
  415. short *readdata ;
  417. printf ("    short_test  (%s) ... ", filename) ;
  419. if (! (file = sf_open_read (filename, &sfinfo)))
  420. { printf ("Could not open file '%s' for read.n", filename) ;
  421. sf_perror (NULL) ;
  422. exit (1) ;
  423. } ;
  425. if (sfinfo.samples != length)
  426. { printf ("Expecting %d samples in file, found %d.n", length, sfinfo.samples) ;
  427. exit (1) ;
  428. } ;
  430. readdata = (short*) malloc (sfinfo.samples * sizeof (short)) ;
  432. if ((count = sf_read_short (file, readdata, sfinfo.samples)) != sfinfo.samples)
  433. { printf ("sf_read_short failed (%d items read).n", count) ;
  434. exit (1) ;
  435. } ;
  437. for (k = 0 ; k < sfinfo.samples ; k++)
  438. if (readdata [k] != (short) (k))
  439. { printf ("Incorrect sample (#%d => %d).n", k, readdata [k]) ;
  440. exit (1) ;
  441. } ;
  443. /* Check seek from start of file. */
  444. k = sf_seek (file, 1, SEEK_SET) ;
  445. sf_read_short (file, readdata, 1) ;
  446. if (readdata [0] != 1 || k != 1)
  447. { printf ("sf_seek (SEEK_SET) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  448. exit (1) ;
  449. } ;
  451. /* Check seek forward from current position. */
  452. k = sf_seek (file, 2, SEEK_CUR) ;
  453. sf_read_short (file, readdata, 1) ;
  454. if (readdata [0] != 4 || k != 4)
  455. { printf ("sf_seek (SEEK_CUR) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  456. exit (1) ;
  457. } ;
  459. /* Check seek backward from current position. */
  460. k = sf_seek (file, -2, SEEK_CUR) ;
  461. sf_read_short (file, readdata, 1) ;
  462. if (readdata [0] != 3 || k != 3)
  463. { printf ("sf_seek (SEEK_CUR) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  464. exit (1) ;
  465. } ;
  467. /* Check that read past end of file returns number of items. */
  468. if ((k = sf_read_short (file, readdata, sfinfo.samples)) != 12)
  469. { printf ("Return value from short sf_read_XXXX incorrect (%d).n", k) ;
  470. exit (1) ;
  471. } ;
  473. /* Check seek backward from end. */
  474. k = sf_seek (file, -14, SEEK_END) ;
  475. sf_read_short (file, readdata, 1) ;
  476. if (readdata [0] != 2 || k != 2)
  477. { printf ("sf_seek (SEEK_END) followed by sf_read_XXXX failed (%d, %d).n", readdata [0], k) ;
  478. exit (1) ;
  479. } ;
  481. /* Check multiple reads. */
  482. k = sf_seek (file, 0, SEEK_SET) ;
  483. count = 0 ;
  484. while ((k = sf_read_short (file, readdata, 3)))
  485. count += k ;
  486. if (count != sfinfo.samples)
  487. { printf ("failed multiple read test (%d, %d).n", count, sfinfo.samples) ;
  488. exit (1) ;
  489. } ;
  491. free (readdata) ;
  492. sf_close (file) ;
  494. printf ("okn") ;
  496. } /* short_test */
  498. int main (int argc, char *argv [])
  499. { char *filename ;
  500. int bDoAll = 0 ;
  501. int nTests = 0 ;
  503. if (argc != 2)
  504. { printf ("Usage : %s <test>n", argv [0]) ;
  505. printf ("    Where <test> is one of the following:n") ;
  506. printf ("           wav      - test WAV file functions (little endian)n") ;
  507. printf ("           aiff     - test AIFF file functions (big endian)n") ;
  508. printf ("           au       - test AU file functions (big endian)n") ;
  509. /*
  510. ** printf ("           paf      - test PAF file functions (little endian)n") ;
  511. ** printf ("           svx      - test SVX file functions (big endian)n") ;
  512. ** printf ("           nist     - test NIST file functions (little endian)n") ;
  513. */
  514. printf ("           all      - perform all testsn") ;
  515. exit (1) ;
  516. } ;
  518. bDoAll = !strcmp (argv [1], "all") ;
  520. if (bDoAll || ! strcmp (argv [1], "wav"))
  521. { filename = "wav_pcm8.wav" ;
  522. write_file (filename, wav_pcm8, sizeof (wav_pcm8)) ;
  523.   short_test (filename, 16) ;
  524.   int_test (filename, 16) ;
  525.   double_test (filename, 16) ;
  526.   unlink (filename) ;
  528. filename = "wav_pcm16.wav" ;
  529. write_file (filename, wav_pcm16, sizeof (wav_pcm16)) ;
  530. short_test (filename, 16) ;
  531. int_test (filename, 16) ;
  532. double_test (filename, 16) ;
  533. unlink (filename) ;
  535. filename = "wav_pcm24.wav" ;
  536. write_file (filename, wav_pcm24, sizeof (wav_pcm24)) ;
  537. int_test (filename, 16) ;
  538. double_test (filename, 16) ;
  539. unlink (filename) ;
  541. filename = "wav_pcm32.wav" ;
  542. write_file (filename, wav_pcm32, sizeof (wav_pcm32)) ;
  543. int_test (filename, 16) ;
  544. double_test (filename, 16) ;
  545. unlink (filename) ;
  547. filename = "wav_ieee.wav" ;
  548. write_file (filename, wav_ieee, sizeof (wav_ieee)) ;
  549. short_test (filename, 16) ;
  550. int_test (filename, 16) ;
  551. double_test (filename, 16) ;
  552. unlink (filename) ;
  553. nTests++ ;
  554. } ;
  556. if (bDoAll || ! strcmp (argv [1], "aiff"))
  557. { filename = "aiff_pcm8.aiff" ;
  558.   write_file (filename, aiff_pcm8, sizeof (aiff_pcm8)) ;
  559.   short_test (filename, 16) ;
  560.   int_test (filename, 16) ;
  561.   double_test (filename, 16) ;
  562.   unlink (filename) ;
  564. filename = "aiff_pcm16.aiff" ;
  565. write_file (filename, aiff_pcm16, sizeof (aiff_pcm16)) ;
  566. short_test (filename, 16) ;
  567. int_test (filename, 16) ;
  568. double_test (filename, 16) ;
  569. unlink (filename) ;
  571. filename = "aiff_pcm24.aiff" ;
  572. write_file (filename, aiff_pcm24, sizeof (aiff_pcm24)) ;
  573. int_test (filename, 16) ;
  574. double_test (filename, 16) ;
  575. unlink (filename) ;
  577. filename = "aiff_pcm32.aiff" ;
  578. write_file (filename, aiff_pcm32, sizeof (aiff_pcm32)) ;
  579. int_test (filename, 16) ;
  580. double_test (filename, 16) ;
  581. unlink (filename) ;
  582. nTests++ ;
  583. } ;
  585. if (bDoAll || ! strcmp (argv [1], "au"))
  586. { filename = "au_pcm8.au" ;
  587.   write_file (filename, au_pcm8, sizeof (au_pcm8)) ;
  588.   short_test (filename, 16) ;
  589.   int_test (filename, 16) ;
  590.   double_test (filename, 16) ;
  591.   unlink (filename) ;
  593. filename = "au_pcm16.au" ;
  594. write_file (filename, au_pcm16, sizeof (au_pcm16)) ;
  595. short_test (filename, 16) ;
  596. int_test (filename, 16) ;
  597. double_test (filename, 16) ;
  598. unlink (filename) ;
  600. filename = "au_pcm24.au" ;
  601. write_file (filename, au_pcm24, sizeof (au_pcm24)) ;
  602. int_test (filename, 16) ;
  603. double_test (filename, 16) ;
  604. unlink (filename) ;
  606. filename = "au_pcm32.au" ;
  607. write_file (filename, au_pcm32, sizeof (au_pcm32)) ;
  608. int_test (filename, 16) ;
  609. double_test (filename, 16) ;
  610. unlink (filename) ;
  611. nTests++ ;
  612. } ;
  614. if (nTests == 0)
  615. { printf ("************************************n") ;
  616. printf ("*  No '%s' test defined.n", argv [1]) ;
  617. printf ("************************************n") ;
  618. return 1 ;
  619. }
  621. return 0;
  622. } /* main */
  624. /*============================================================================================
  625.  * Here are the test functions.
  626.  */