Mercurial > hg > sv-dependency-builds

comparison src/libsndfile-1.0.25/tests/write_read_test.tpl @ 0:c7265573341e

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