1 /*
2 ** Copyright (C) 2003-2016 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 */
18
19 #include "sfconfig.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <math.h>
25
26 #if HAVE_UNISTD_H
27 #include <unistd.h>
28 #else
29 #include "sf_unistd.h"
30 #endif
31
32 #include <sndfile.h>
33
34 #include "sfendian.h"
35 #include "utils.h"
36
37 #define BUFFER_LEN (1 << 10)
38 #define LOG_BUFFER_SIZE 1024
39
40 static void chunk_test (const char *filename, int format) ;
41 static void wav_subchunk_test (size_t chunk_size) ;
42 static void large_free_test (const char *filename, int format, size_t chunk_size) ;
43
44 int
main(int argc,char * argv[])45 main (int argc, char *argv [])
46 { int do_all = 0 ;
47 int test_count = 0, k ;
48
49 if (argc != 2)
50 { printf ("Usage : %s <test>\n", argv [0]) ;
51 printf (" Where <test> is one of the following:\n") ;
52 printf (" wav - test adding chunks to WAV files\n") ;
53 printf (" aiff - test adding chunks to AIFF files\n") ;
54 printf (" caf - test adding chunks to CAF files\n") ;
55 printf (" rf64 - test adding chunks to RF64 files\n") ;
56 printf (" all - perform all tests\n") ;
57 exit (1) ;
58 } ;
59
60 do_all = ! strcmp (argv [1], "all") ;
61
62 if (do_all || ! strcmp (argv [1], "wav"))
63 { chunk_test ("chunks_pcm16.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
64 chunk_test ("chunks_pcm16.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
65 chunk_test ("chunks_pcm16.wavex", SF_FORMAT_WAVEX | SF_FORMAT_PCM_16) ;
66
67 for (k = 100 ; k < 10000 ; k *= 4)
68 wav_subchunk_test (k) ;
69
70 test_count++ ;
71 } ;
72
73 if (do_all || ! strcmp (argv [1], "aiff"))
74 { chunk_test ("chunks_pcm16.aiff", SF_FORMAT_AIFF | SF_FORMAT_PCM_16) ;
75 test_count++ ;
76 } ;
77
78 if (do_all || ! strcmp (argv [1], "caf"))
79 { chunk_test ("chunks_pcm16.caf", SF_FORMAT_CAF | SF_FORMAT_PCM_16) ;
80 chunk_test ("chunks_alac.caf", SF_FORMAT_CAF | SF_FORMAT_ALAC_16) ;
81 large_free_test ("large_free.caf", SF_FORMAT_CAF | SF_FORMAT_PCM_16, 100) ;
82 large_free_test ("large_free.caf", SF_FORMAT_CAF | SF_FORMAT_PCM_16, 20000) ;
83 test_count++ ;
84 } ;
85
86 if (do_all || ! strcmp (argv [1], "rf64"))
87 { chunk_test ("chunks_pcm16.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_16) ;
88 test_count++ ;
89 } ;
90
91 if (test_count == 0)
92 { printf ("Mono : ************************************\n") ;
93 printf ("Mono : * No '%s' test defined.\n", argv [1]) ;
94 printf ("Mono : ************************************\n") ;
95 return 1 ;
96 } ;
97
98 return 0 ;
99 } /* main */
100
101
102 /*============================================================================================
103 ** Here are the test functions.
104 */
105
106 static void
chunk_test_helper(const char * filename,int format,const char * testdata)107 chunk_test_helper (const char *filename, int format, const char * testdata)
108 { SNDFILE *file ;
109 SF_INFO sfinfo ;
110 SF_CHUNK_INFO chunk_info ;
111 SF_CHUNK_ITERATOR * iterator ;
112 uint32_t length_before ;
113 int err, allow_fd ;
114
115 switch (format & SF_FORMAT_SUBMASK)
116 { case SF_FORMAT_ALAC_16 :
117 allow_fd = SF_FALSE ;
118 break ;
119 default :
120 allow_fd = SF_TRUE ;
121 break ;
122 } ;
123
124 sfinfo.samplerate = 44100 ;
125 sfinfo.channels = 1 ;
126 sfinfo.frames = 0 ;
127 sfinfo.format = format ;
128
129 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
130
131 /* Set up the chunk to write. */
132 memset (&chunk_info, 0, sizeof (chunk_info)) ;
133 snprintf (chunk_info.id, sizeof (chunk_info.id), "Test") ;
134 chunk_info.id_size = 4 ;
135 chunk_info.data = strdup (testdata) ;
136 chunk_info.datalen = strlen (chunk_info.data) ;
137
138 length_before = chunk_info.datalen ;
139
140 err = sf_set_chunk (file, &chunk_info) ;
141 exit_if_true (
142 err != SF_ERR_NO_ERROR,
143 "\n\nLine %d : sf_set_chunk returned for testdata '%s' : %s\n\n", __LINE__, testdata, sf_error_number (err)
144 ) ;
145
146 memset (chunk_info.data, 0, chunk_info.datalen) ;
147 free (chunk_info.data) ;
148
149 sf_close (file) ;
150
151 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
152
153 memset (&chunk_info, 0, sizeof (chunk_info)) ;
154 snprintf (chunk_info.id, sizeof (chunk_info.id), "Test") ;
155 chunk_info.id_size = 4 ;
156
157 iterator = sf_get_chunk_iterator (file, &chunk_info) ;
158 err = sf_get_chunk_size (iterator, &chunk_info) ;
159 exit_if_true (
160 err != SF_ERR_NO_ERROR,
161 "\n\nLine %d : sf_get_chunk_size returned for testdata '%s' : %s\n\n", __LINE__, testdata, sf_error_number (err)
162 ) ;
163
164 exit_if_true (
165 length_before > chunk_info.datalen || chunk_info.datalen - length_before > 4,
166 "\n\nLine %d : testdata '%s' : Bad chunk length %u (previous length %u)\n\n", __LINE__, testdata, chunk_info.datalen, length_before
167 ) ;
168
169 chunk_info.data = malloc (chunk_info.datalen) ;
170 err = sf_get_chunk_data (iterator, &chunk_info) ;
171 exit_if_true (
172 err != SF_ERR_NO_ERROR,
173 "\n\nLine %d : sf_get_chunk_size returned for testdata '%s' : %s\n\n", __LINE__, testdata, sf_error_number (err)
174 ) ;
175
176 exit_if_true (
177 memcmp (testdata, chunk_info.data, length_before),
178 "\n\nLine %d : Data compare failed.\n %s\n %s\n\n", __LINE__, testdata, (char*) chunk_info.data
179 ) ;
180
181 free (chunk_info.data) ;
182
183 sf_close (file) ;
184 unlink (filename) ;
185 } /* chunk_test_helper */
186
187 static void
multichunk_test_helper(const char * filename,int format,const char * testdata[],size_t testdata_len)188 multichunk_test_helper (const char *filename, int format, const char * testdata [], size_t testdata_len)
189 { SNDFILE *file ;
190 SF_INFO sfinfo ;
191 SF_CHUNK_INFO chunk_info ;
192 SF_CHUNK_ITERATOR * iterator ;
193 uint32_t length_before [16] ;
194 int err, allow_fd ;
195 size_t i ;
196
197
198 exit_if_true (
199 ARRAY_LEN (length_before) < testdata_len,
200 "\n\nLine %d : Bad array length.\n\n", __LINE__
201 ) ;
202
203
204 sfinfo.samplerate = 44100 ;
205 sfinfo.channels = 1 ;
206 sfinfo.frames = 0 ;
207 sfinfo.format = format ;
208
209 switch (format & SF_FORMAT_SUBMASK)
210 { case SF_FORMAT_ALAC_16 :
211 allow_fd = SF_FALSE ;
212 break ;
213 default :
214 allow_fd = SF_TRUE ;
215 break ;
216 } ;
217
218 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, allow_fd, __LINE__) ;
219
220 /* Set up the chunk to write. */
221 for (i = 0 ; i < testdata_len ; i++)
222 { memset (&chunk_info, 0, sizeof (chunk_info)) ;
223 snprintf (chunk_info.id, sizeof (chunk_info.id), "Test") ;
224 chunk_info.id_size = 4 ;
225
226 chunk_info.data = strdup (testdata [i]) ;
227 chunk_info.datalen = strlen (chunk_info.data) ;
228
229 length_before [i] = chunk_info.datalen ;
230
231 err = sf_set_chunk (file, &chunk_info) ;
232 exit_if_true (
233 err != SF_ERR_NO_ERROR,
234 "\n\nLine %d : sf_set_chunk returned for testdata[%d] '%s' : %s\n\n", __LINE__, (int) i, testdata [i], sf_error_number (err)
235 ) ;
236
237 memset (chunk_info.data, 0, chunk_info.datalen) ;
238 free (chunk_info.data) ;
239 }
240
241 sf_close (file) ;
242
243 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, allow_fd, __LINE__) ;
244
245 memset (&chunk_info, 0, sizeof (chunk_info)) ;
246 snprintf (chunk_info.id, sizeof (chunk_info.id), "Test") ;
247 chunk_info.id_size = 4 ;
248
249 iterator = sf_get_chunk_iterator (file, &chunk_info) ;
250
251 i = 0 ;
252 while (iterator)
253 { memset (&chunk_info, 0, sizeof (chunk_info)) ;
254 err = sf_get_chunk_size (iterator, &chunk_info) ;
255 exit_if_true (
256 i > testdata_len,
257 "\n\nLine %d : iterated to chunk #%d, but only %d chunks have been written\n\n", __LINE__, (int) i, (int) testdata_len
258 ) ;
259
260 exit_if_true (
261 err != SF_ERR_NO_ERROR,
262 "\n\nLine %d : sf_get_chunk_size returned for testdata[%d] '%s' : %s\n\n", __LINE__, (int) i, testdata [i], sf_error_number (err)
263 ) ;
264
265 exit_if_true (
266 length_before [i] > chunk_info.datalen || chunk_info.datalen - length_before [i] > 4,
267 "\n\nLine %d : testdata[%d] '%s' : Bad chunk length %u (previous length %u)\n\n", __LINE__, (int) i, testdata [i], chunk_info.datalen, length_before [i]
268 ) ;
269
270 chunk_info.data = malloc (chunk_info.datalen) ;
271 err = sf_get_chunk_data (iterator, &chunk_info) ;
272 exit_if_true (
273 err != SF_ERR_NO_ERROR,
274 "\n\nLine %d : sf_get_chunk_size returned for testdata[%d] '%s' : %s\n\n", __LINE__, (int) i, testdata [i], sf_error_number (err)
275 ) ;
276
277 exit_if_true (
278 4 != chunk_info.id_size,
279 "\n\nLine %d : testdata[%d] : Bad ID length %u (previous length %u)\n\n", __LINE__, (int) i, chunk_info.id_size, 4
280 ) ;
281 exit_if_true (
282 memcmp ("Test", chunk_info.id, 4),
283 "\n\nLine %d : ID compare failed at %d.\n %s\n %s\n\n", __LINE__, (int) i, "Test", (char*) chunk_info.id
284 ) ;
285
286 exit_if_true (
287 memcmp (testdata [i], chunk_info.data, length_before [i]),
288 "\n\nLine %d : Data compare failed at %d.\n %s\n %s\n\n", __LINE__, (int) i, testdata [i], (char*) chunk_info.data
289 ) ;
290
291 free (chunk_info.data) ;
292 iterator = sf_next_chunk_iterator (iterator) ;
293 i++ ;
294 }
295
296 sf_close (file) ;
297 unlink (filename) ;
298 } /* multichunk_test_helper */
299
300
301 static void
chunk_test(const char * filename,int format)302 chunk_test (const char *filename, int format)
303 { const char* testdata [] =
304 { "There can be only one.", "", "A", "AB", "ABC", "ABCD", "ABCDE" } ;
305 uint32_t k ;
306
307 print_test_name (__func__, filename) ;
308
309 for (k = 0 ; k < ARRAY_LEN (testdata) ; k++)
310 chunk_test_helper (filename, format, testdata [k]) ;
311
312 multichunk_test_helper (filename, format, testdata, ARRAY_LEN (testdata)) ;
313
314 puts ("ok") ;
315 } /* chunk_test */
316
317
318 static void
wav_subchunk_test(size_t chunk_size)319 wav_subchunk_test (size_t chunk_size)
320 { SNDFILE * file ;
321 SF_INFO sfinfo ;
322 SF_CHUNK_INFO chunk_info ;
323 char filename [256] ;
324 char chunk_data [10240] ;
325 short audio [16] ;
326 int err, value ;
327
328 snprintf (filename, sizeof (filename), "subchunk_%04d.wav", (int) chunk_size) ;
329 print_test_name (__func__, filename) ;
330
331 exit_if_true (sizeof (chunk_data) < chunk_size, "\n\nLine %d : sizeof (data) < chunk_size\n\n", __LINE__) ;
332
333 memset (chunk_data, 53, sizeof (chunk_data)) ;
334 chunk_data [chunk_size] = 0 ;
335
336 /* Fill in the chunk data. */
337 value = MAKE_MARKER ('a', 'd', 't', 'l') ;
338 memcpy (chunk_data, &value, sizeof (value)) ;
339 value = MAKE_MARKER ('n', 'o', 't', 'e') ;
340 memcpy (chunk_data + 4, &value, sizeof (value)) ;
341 value = H2LE_32 (chunk_size - 12) ;
342 memcpy (chunk_data + 8, &value, sizeof (value)) ;
343
344 sfinfo.samplerate = 44100 ;
345 sfinfo.channels = 1 ;
346 sfinfo.frames = 0 ;
347 sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16 ;
348
349 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
350
351 /* Set up the chunk to write. */
352 memset (&chunk_info, 0, sizeof (chunk_info)) ;
353 snprintf (chunk_info.id, sizeof (chunk_info.id), "LIST") ;
354 chunk_info.id_size = 4 ;
355 chunk_info.data = chunk_data ;
356 chunk_info.datalen = chunk_size ;
357
358 err = sf_set_chunk (file, &chunk_info) ;
359 exit_if_true (
360 err != SF_ERR_NO_ERROR,
361 "\n\nLine %d : sf_set_chunk returned for testdata : %s\n\n", __LINE__, sf_error_number (err)
362 ) ;
363
364 memset (chunk_info.data, 0, chunk_info.datalen) ;
365
366 /* Add some audio data. */
367 memset (audio, 0, sizeof (audio)) ;
368 sf_write_short (file, audio, ARRAY_LEN (audio)) ;
369
370 sf_close (file) ;
371
372 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
373
374 exit_if_true (
375 sfinfo.frames != ARRAY_LEN (audio),
376 "\n\nLine %d : Incorrect sample count (%d should be %d)\n", __LINE__, (int) sfinfo.frames, (int) ARRAY_LEN (audio)
377 ) ;
378
379 if (chunk_size < 512)
380 check_log_buffer_or_die (file, __LINE__) ;
381
382 sf_close (file) ;
383
384 unlink (filename) ;
385 puts ("ok") ;
386 } /* wav_subchunk_test */
387
388 static void
large_free_test(const char * filename,int format,size_t chunk_size)389 large_free_test (const char *filename, int format, size_t chunk_size)
390 { SNDFILE * file ;
391 SF_INFO sfinfo ;
392 SF_CHUNK_INFO chunk_info ;
393 char chunk_data [20002] ;
394 short audio [16] ;
395 int err ;
396
397 print_test_name (__func__, filename) ;
398
399 exit_if_true (sizeof (chunk_data) <= chunk_size, "\n\nLine %d : sizeof (data) < chunk_size\n\n", __LINE__) ;
400
401 memset (chunk_data, 53, sizeof (chunk_data)) ;
402 chunk_data [chunk_size] = 0 ;
403
404 sfinfo.samplerate = 44100 ;
405 sfinfo.channels = 1 ;
406 sfinfo.frames = 0 ;
407 sfinfo.format = format ;
408
409 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
410
411 /* Set up the chunk to write. */
412 memset (&chunk_info, 0, sizeof (chunk_info)) ;
413 snprintf (chunk_info.id, sizeof (chunk_info.id), "free") ;
414 chunk_info.id_size = 4 ;
415 chunk_info.data = chunk_data ;
416 chunk_info.datalen = chunk_size ;
417
418 err = sf_set_chunk (file, &chunk_info) ;
419 exit_if_true (
420 err != SF_ERR_NO_ERROR,
421 "\n\nLine %d : sf_set_chunk returned for testdata : %s\n\n", __LINE__, sf_error_number (err)
422 ) ;
423
424 memset (chunk_info.data, 0, chunk_info.datalen) ;
425
426 /* Add some audio data. */
427 memset (audio, 0, sizeof (audio)) ;
428 sf_write_short (file, audio, ARRAY_LEN (audio)) ;
429
430 sf_close (file) ;
431
432 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
433
434 exit_if_true (
435 sfinfo.frames != ARRAY_LEN (audio),
436 "\n\nLine %d : Incorrect sample count (%d should be %d)\n", __LINE__, (int) sfinfo.frames, (int) ARRAY_LEN (audio)
437 ) ;
438
439 if (chunk_size < 512)
440 check_log_buffer_or_die (file, __LINE__) ;
441
442 sf_close (file) ;
443
444 unlink (filename) ;
445 puts ("ok") ;
446 } /* large_free_test */
447