Merge branch 'libsndfile'
[Faustine.git] / interpretor / lib / src / libsndfile-1.0.25 / tests / utils.tpl
1 [+ AutoGen5 template h c +]
2 /*
3 ** Copyright (C) 2002-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 /*
21 ** Utility functions to make writing the test suite easier.
22 **
23 ** The .c and .h files were generated automagically with Autogen from
24 ** the files utils.def and utils.tpl.
25 */
26
27 [+ CASE (suffix) +]
28 [+ == h +]
29
30 #ifdef __cplusplus
31 extern "C" {
32 #endif /* __cplusplus */
33
34 #include <stdint.h>
35 #include <stdarg.h>
36
37 #define SF_COUNT_TO_LONG(x) ((long) (x))
38 #define ARRAY_LEN(x) ((int) (sizeof (x)) / (sizeof ((x) [0])))
39 #define SIGNED_SIZEOF(x) ((int64_t) (sizeof (x)))
40 #define NOT(x) (! (x))
41
42 #define PIPE_INDEX(x) ((x) + 500)
43 #define PIPE_TEST_LEN 12345
44
45
46 [+ FOR float_type
47 +]void gen_windowed_sine_[+ (get "name") +] ([+ (get "name") +] *data, int len, double maximum) ;
48 [+ ENDFOR float_type
49 +]
50
51 void create_short_sndfile (const char *filename, int format, int channels) ;
52
53 void check_file_hash_or_die (const char *filename, uint64_t target_hash, int line_num) ;
54
55 void print_test_name (const char *test, const char *filename) ;
56
57 void dump_data_to_file (const char *filename, const void *data, unsigned int datalen) ;
58
59 void write_mono_file (const char * filename, int format, int srate, float * output, int len) ;
60
61 static inline void
62 exit_if_true (int test, const char *format, ...)
63 { if (test)
64 { va_list argptr ;
65 va_start (argptr, format) ;
66 vprintf (format, argptr) ;
67 va_end (argptr) ;
68 exit (1) ;
69 } ;
70 } /* exit_if_true */
71
72 /*
73 ** Functions for saving two vectors of data in an ascii text file which
74 ** can then be loaded into GNU octave for comparison.
75 */
76
77 [+ FOR io_type
78 +]int oct_save_[+ (get "io_element") +] (const [+ (get "io_element") +] *a, const [+ (get "io_element") +] *b, int len) ;
79 [+ ENDFOR io_type
80 +]
81
82 void delete_file (int format, const char *filename) ;
83
84 void count_open_files (void) ;
85 void increment_open_file_count (void) ;
86 void check_open_file_count_or_die (int lineno) ;
87
88 #ifdef SNDFILE_H
89
90 static inline void
91 sf_info_clear (SF_INFO * info)
92 { memset (info, 0, sizeof (SF_INFO)) ;
93 } /* sf_info_clear */
94
95 static inline void
96 sf_info_setup (SF_INFO * info, int format, int samplerate, int channels)
97 { sf_info_clear (info) ;
98
99 info->format = format ;
100 info->samplerate = samplerate ;
101 info->channels = channels ;
102 } /* sf_info_setup */
103
104
105 void dump_log_buffer (SNDFILE *file) ;
106 void check_log_buffer_or_die (SNDFILE *file, int line_num) ;
107 int string_in_log_buffer (SNDFILE *file, const char *s) ;
108 void hexdump_file (const char * filename, sf_count_t offset, sf_count_t length) ;
109
110
111 SNDFILE *test_open_file_or_die
112 (const char *filename, int mode, SF_INFO *sfinfo, int allow_fd, int line_num) ;
113
114 void test_read_write_position_or_die
115 (SNDFILE *file, int line_num, int pass, sf_count_t read_pos, sf_count_t write_pos) ;
116
117 void test_seek_or_die
118 (SNDFILE *file, sf_count_t offset, int whence, sf_count_t new_pos, int channels, int line_num) ;
119
120 [+ FOR read_op +]
121 [+ FOR io_type
122 +]void test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die
123 (SNDFILE *file, int pass, [+ (get "io_element") +] *test, sf_count_t [+ (get "count_name") +], int line_num) ;
124 [+ ENDFOR io_type +][+ ENDFOR read_op +]
125
126 void
127 test_read_raw_or_die (SNDFILE *file, int pass, void *test, sf_count_t items, int line_num) ;
128
129 [+ FOR write_op +]
130 [+ FOR io_type
131 +]void test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die
132 (SNDFILE *file, int pass, const [+ (get "io_element") +] *test, sf_count_t [+ (get "count_name") +], int line_num) ;
133 [+ ENDFOR io_type +][+ ENDFOR write_op +]
134
135 void
136 test_write_raw_or_die (SNDFILE *file, int pass, const void *test, sf_count_t items, int line_num) ;
137
138 [+ FOR io_type
139 +]void compare_[+ (get "io_element") +]_or_die (const [+ (get "io_element") +] *left, const [+ (get "io_element") +] *right, unsigned count, int line_num) ;
140 [+ ENDFOR io_type +]
141
142
143 void gen_lowpass_noise_float (float *data, int len) ;
144
145 sf_count_t file_length (const char * fname) ;
146 sf_count_t file_length_fd (int fd) ;
147
148 #endif
149
150 #ifdef __cplusplus
151 } /* extern "C" */
152 #endif /* __cplusplus */
153
154 [+ == c +]
155
156 #include "sfconfig.h"
157
158 #include <stdio.h>
159 #include <stdlib.h>
160 #include <inttypes.h>
161
162 #if HAVE_UNISTD_H
163 #include <unistd.h>
164 #endif
165
166 #if (HAVE_DECL_S_IRGRP == 0)
167 #include <sf_unistd.h>
168 #endif
169
170 #include <errno.h>
171 #include <string.h>
172 #include <ctype.h>
173 #include <math.h>
174 #include <fcntl.h>
175 #include <sys/stat.h>
176
177 #include <sndfile.h>
178
179 #include "utils.h"
180
181 #ifndef M_PI
182 #define M_PI 3.14159265358979323846264338
183 #endif
184
185 #define LOG_BUFFER_SIZE 2048
186
187 /*
188 ** Neat solution to the Win32/OS2 binary file flage requirement.
189 ** If O_BINARY isn't already defined by the inclusion of the system
190 ** headers, set it to zero.
191 */
192 #ifndef O_BINARY
193 #define O_BINARY 0
194 #endif
195
196 [+ FOR float_type +]
197 void
198 gen_windowed_sine_[+ (get "name") +] ([+ (get "name") +] *data, int len, double maximum)
199 { int k ;
200
201 memset (data, 0, len * sizeof ([+ (get "name") +])) ;
202 /*
203 ** Choose a frequency of 1/32 so that it aligns perfectly with a DFT
204 ** bucket to minimise spreading of energy over more than one bucket.
205 ** Also do not want to make the frequency too high as some of the
206 ** codecs (ie gsm610) have a quite severe high frequency roll off.
207 */
208 len /= 2 ;
209
210 for (k = 0 ; k < len ; k++)
211 { data [k] = sin (2.0 * k * M_PI * 1.0 / 32.0 + 0.4) ;
212
213 /* Apply Hanning Window. */
214 data [k] *= maximum * (0.5 - 0.5 * cos (2.0 * M_PI * k / ((len) - 1))) ;
215 }
216
217 return ;
218 } /* gen_windowed_sine_[+ (get "name") +] */
219 [+ ENDFOR float_type +]
220
221 void
222 create_short_sndfile (const char *filename, int format, int channels)
223 { short data [2 * 3 * 4 * 5 * 6 * 7] = { 0, } ;
224 SNDFILE *file ;
225 SF_INFO sfinfo ;
226
227 sfinfo.samplerate = 44100 ;
228 sfinfo.channels = channels ;
229 sfinfo.format = format ;
230
231 if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
232 { printf ("Error (%s, %d) : sf_open failed : %s\n", __FILE__, __LINE__, sf_strerror (file)) ;
233 exit (1) ;
234 } ;
235
236 sf_write_short (file, data, ARRAY_LEN (data)) ;
237
238 sf_close (file) ;
239 } /* create_short_sndfile */
240
241 void
242 check_file_hash_or_die (const char *filename, uint64_t target_hash, int line_num)
243 { static unsigned char buf [4096] ;
244 uint64_t cksum ;
245 FILE *file ;
246 int k, read_count ;
247
248 memset (buf, 0, sizeof (buf)) ;
249
250 /* The 'b' in the mode string means binary for Win32. */
251 if ((file = fopen (filename, "rb")) == NULL)
252 { printf ("\n\nLine %d: could not open file '%s'\n\n", line_num, filename) ;
253 exit (1) ;
254 } ;
255
256 cksum = 0 ;
257
258 while ((read_count = fread (buf, 1, sizeof (buf), file)))
259 for (k = 0 ; k < read_count ; k++)
260 cksum = cksum * 511 + buf [k] ;
261
262 fclose (file) ;
263
264 if (target_hash == 0)
265 { printf (" 0x%016" PRIx64 "\n", cksum) ;
266 return ;
267 } ;
268
269 if (cksum != target_hash)
270 { printf ("\n\nLine %d: incorrect hash value 0x%016" PRIx64 " should be 0x%016" PRIx64 ".\n\n", line_num, cksum, target_hash) ;
271 exit (1) ;
272 } ;
273
274 return ;
275 } /* check_file_hash_or_die */
276
277 void
278 print_test_name (const char *test, const char *filename)
279 { int count ;
280
281 if (test == NULL)
282 { printf (__FILE__ ": bad test of filename parameter.\n") ;
283 exit (1) ;
284 } ;
285
286 if (filename == NULL || strlen (filename) == 0)
287 { printf (" %-30s : ", test) ;
288 count = 25 ;
289 }
290 else
291 { printf (" %-30s : %s ", test, filename) ;
292 count = 24 - strlen (filename) ;
293 } ;
294
295 while (count -- > 0)
296 putchar ('.') ;
297 putchar (' ') ;
298
299 fflush (stdout) ;
300 } /* print_test_name */
301
302 void
303 dump_data_to_file (const char *filename, const void *data, unsigned int datalen)
304 { FILE *file ;
305
306 if ((file = fopen (filename, "wb")) == NULL)
307 { printf ("\n\nLine %d : could not open file : %s\n\n", __LINE__, filename) ;
308 exit (1) ;
309 } ;
310
311 if (fwrite (data, 1, datalen, file) != datalen)
312 { printf ("\n\nLine %d : fwrite failed.\n\n", __LINE__) ;
313 exit (1) ;
314 } ;
315
316 fclose (file) ;
317
318 } /* dump_data_to_file */
319
320 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
321 */
322
323 static char octfilename [] = "error.dat" ;
324
325 [+ FOR io_type
326 +]int
327 oct_save_[+ (get "io_element") +] (const [+ (get "io_element") +] *a, const [+ (get "io_element") +] *b, int len)
328 { FILE *file ;
329 int k ;
330
331 if (! (file = fopen (octfilename, "w")))
332 return 1 ;
333
334 fprintf (file, "# Not created by Octave\n") ;
335
336 fprintf (file, "# name: a\n") ;
337 fprintf (file, "# type: matrix\n") ;
338 fprintf (file, "# rows: %d\n", len) ;
339 fprintf (file, "# columns: 1\n") ;
340
341 for (k = 0 ; k < len ; k++)
342 fprintf (file, [+ (get "format_str") +] "\n", a [k]) ;
343
344 fprintf (file, "# name: b\n") ;
345 fprintf (file, "# type: matrix\n") ;
346 fprintf (file, "# rows: %d\n", len) ;
347 fprintf (file, "# columns: 1\n") ;
348
349 for (k = 0 ; k < len ; k++)
350 fprintf (file, [+ (get "format_str") +] "\n", b [k]) ;
351
352 fclose (file) ;
353 return 0 ;
354 } /* oct_save_[+ (get "io_element") +] */
355 [+ ENDFOR io_type
356 +]
357
358 void
359 check_log_buffer_or_die (SNDFILE *file, int line_num)
360 { static char buffer [LOG_BUFFER_SIZE] ;
361 int count ;
362
363 memset (buffer, 0, sizeof (buffer)) ;
364
365 /* Get the log buffer data. */
366 count = sf_command (file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
367
368 if (LOG_BUFFER_SIZE - count < 2)
369 { printf ("\n\nLine %d : Possible long log buffer.\n", line_num) ;
370 exit (1) ;
371 }
372
373 /* Look for "Should" */
374 if (strstr (buffer, "ould"))
375 { printf ("\n\nLine %d : Log buffer contains `ould'. Dumping.\n", line_num) ;
376 puts (buffer) ;
377 exit (1) ;
378 } ;
379
380 /* Look for "**" */
381 if (strstr (buffer, "*"))
382 { printf ("\n\nLine %d : Log buffer contains `*'. Dumping.\n", line_num) ;
383 puts (buffer) ;
384 exit (1) ;
385 } ;
386
387 /* Look for "Should" */
388 if (strstr (buffer, "nknown marker"))
389 { printf ("\n\nLine %d : Log buffer contains `nknown marker'. Dumping.\n", line_num) ;
390 puts (buffer) ;
391 exit (1) ;
392 } ;
393
394 return ;
395 } /* check_log_buffer_or_die */
396
397 int
398 string_in_log_buffer (SNDFILE *file, const char *s)
399 { static char buffer [LOG_BUFFER_SIZE] ;
400 int count ;
401
402 memset (buffer, 0, sizeof (buffer)) ;
403
404 /* Get the log buffer data. */
405 count = sf_command (file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
406
407 if (LOG_BUFFER_SIZE - count < 2)
408 { printf ("Possible long log buffer.\n") ;
409 exit (1) ;
410 }
411
412 /* Look for string */
413 return strstr (buffer, s) ? SF_TRUE : SF_FALSE ;
414 } /* string_in_log_buffer */
415
416 void
417 hexdump_file (const char * filename, sf_count_t offset, sf_count_t length)
418 {
419 FILE * file ;
420 char buffer [16] ;
421 int k, m, ch, readcount ;
422
423 if (length > 1000000)
424 { printf ("\n\nError : length (%ld) too long.\n\n", SF_COUNT_TO_LONG (offset)) ;
425 exit (1) ;
426 } ;
427
428 if ((file = fopen (filename, "r")) == NULL)
429 { printf ("\n\nError : hexdump_file (%s) could not open file for read.\n\n", filename) ;
430 exit (1) ;
431 } ;
432
433 if (fseek (file, offset, SEEK_SET) != 0)
434 { printf ("\n\nError : fseek(file, %ld, SEEK_SET) failed : %s\n\n", SF_COUNT_TO_LONG (offset), strerror (errno)) ;
435 exit (1) ;
436 } ;
437
438 puts ("\n\n") ;
439
440 for (k = 0 ; k < length ; k+= sizeof (buffer))
441 { readcount = fread (buffer, 1, sizeof (buffer), file) ;
442
443 printf ("%08lx : ", SF_COUNT_TO_LONG (offset + k)) ;
444
445 for (m = 0 ; m < readcount ; m++)
446 printf ("%02x ", buffer [m] & 0xFF) ;
447
448 for (m = readcount ; m < SIGNED_SIZEOF (buffer) ; m++)
449 printf (" ") ;
450
451 printf (" ") ;
452 for (m = 0 ; m < readcount ; m++)
453 { ch = isprint (buffer [m]) ? buffer [m] : '.' ;
454 putchar (ch) ;
455 } ;
456
457 if (readcount < SIGNED_SIZEOF (buffer))
458 break ;
459
460 putchar ('\n') ;
461 } ;
462
463 puts ("\n") ;
464
465 fclose (file) ;
466 } /* hexdump_file */
467
468 void
469 dump_log_buffer (SNDFILE *file)
470 { static char buffer [LOG_BUFFER_SIZE] ;
471
472 memset (buffer, 0, sizeof (buffer)) ;
473
474 /* Get the log buffer data. */
475 sf_command (file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
476
477 if (strlen (buffer) < 1)
478 puts ("Log buffer empty.\n") ;
479 else
480 puts (buffer) ;
481
482 return ;
483 } /* dump_log_buffer */
484
485 SNDFILE *
486 test_open_file_or_die (const char *filename, int mode, SF_INFO *sfinfo, int allow_fd, int line_num)
487 { static int count = 0 ;
488
489 SNDFILE *file ;
490 const char *modestr, *func_name ;
491 int oflags = 0, omode = 0, err ;
492
493 /*
494 ** Need to test both sf_open() and sf_open_fd().
495 ** Do so alternately.
496 */
497 switch (mode)
498 { case SFM_READ :
499 modestr = "SFM_READ" ;
500 oflags = O_RDONLY | O_BINARY ;
501 omode = 0 ;
502 break ;
503
504 case SFM_WRITE :
505 modestr = "SFM_WRITE" ;
506 oflags = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY ;
507 omode = S_IRUSR | S_IWUSR | S_IRGRP ;
508 break ;
509
510 case SFM_RDWR :
511 modestr = "SFM_RDWR" ;
512 oflags = O_RDWR | O_CREAT | O_BINARY ;
513 omode = S_IRUSR | S_IWUSR | S_IRGRP ;
514 break ;
515 default :
516 printf ("\n\nLine %d: Bad mode.\n", line_num) ;
517 fflush (stdout) ;
518 exit (1) ;
519 } ;
520
521 if (OS_IS_WIN32)
522 { /* Windows does not understand and ignores the S_IRGRP flag, but Wine
523 ** gives a run time warning message, so just clear it.
524 */
525 omode &= ~S_IRGRP ;
526 } ;
527
528 if (allow_fd && ((++count) & 1) == 1)
529 { int fd ;
530
531 /* Only use the three argument open() function if omode != 0. */
532 fd = (omode == 0) ? open (filename, oflags) : open (filename, oflags, omode) ;
533
534 if (fd < 0)
535 { printf ("\n\n%s : open failed : %s\n", __func__, strerror (errno)) ;
536 exit (1) ;
537 } ;
538
539 func_name = "sf_open_fd" ;
540 file = sf_open_fd (fd, mode, sfinfo, SF_TRUE) ;
541 }
542 else
543 { func_name = "sf_open" ;
544 file = sf_open (filename, mode, sfinfo) ;
545 } ;
546
547 if (file == NULL)
548 { printf ("\n\nLine %d: %s (%s) failed : %s\n\n", line_num, func_name, modestr, sf_strerror (NULL)) ;
549 dump_log_buffer (file) ;
550 exit (1) ;
551 } ;
552
553 err = sf_error (file) ;
554 if (err != SF_ERR_NO_ERROR)
555 { printf ("\n\nLine %d : sf_error : %s\n\n", line_num, sf_error_number (err)) ;
556 dump_log_buffer (file) ;
557 exit (1) ;
558 } ;
559
560 return file ;
561 } /* test_open_file_or_die */
562
563 void
564 test_read_write_position_or_die (SNDFILE *file, int line_num, int pass, sf_count_t read_pos, sf_count_t write_pos)
565 { sf_count_t pos ;
566
567 /* Check the current read position. */
568 if (read_pos >= 0 && (pos = sf_seek (file, 0, SEEK_CUR | SFM_READ)) != read_pos)
569 { printf ("\n\nLine %d ", line_num) ;
570 if (pass > 0)
571 printf ("(pass %d): ", pass) ;
572 printf ("Read position (%ld) should be %ld.\n", SF_COUNT_TO_LONG (pos), SF_COUNT_TO_LONG (read_pos)) ;
573 exit (1) ;
574 } ;
575
576 /* Check the current write position. */
577 if (write_pos >= 0 && (pos = sf_seek (file, 0, SEEK_CUR | SFM_WRITE)) != write_pos)
578 { printf ("\n\nLine %d", line_num) ;
579 if (pass > 0)
580 printf (" (pass %d)", pass) ;
581 printf (" : Write position (%ld) should be %ld.\n",
582 SF_COUNT_TO_LONG (pos), SF_COUNT_TO_LONG (write_pos)) ;
583 exit (1) ;
584 } ;
585
586 return ;
587 } /* test_read_write_position */
588
589 void
590 test_seek_or_die (SNDFILE *file, sf_count_t offset, int whence, sf_count_t new_pos, int channels, int line_num)
591 { sf_count_t position ;
592 const char *channel_name, *whence_name ;
593
594 switch (whence)
595 { case SEEK_SET :
596 whence_name = "SEEK_SET" ;
597 break ;
598 case SEEK_CUR :
599 whence_name = "SEEK_CUR" ;
600 break ;
601 case SEEK_END :
602 whence_name = "SEEK_END" ;
603 break ;
604
605 /* SFM_READ */
606 case SEEK_SET | SFM_READ :
607 whence_name = "SFM_READ | SEEK_SET" ;
608 break ;
609 case SEEK_CUR | SFM_READ :
610 whence_name = "SFM_READ | SEEK_CUR" ;
611 break ;
612 case SEEK_END | SFM_READ :
613 whence_name = "SFM_READ | SEEK_END" ;
614 break ;
615
616 /* SFM_WRITE */
617 case SEEK_SET | SFM_WRITE :
618 whence_name = "SFM_WRITE | SEEK_SET" ;
619 break ;
620 case SEEK_CUR | SFM_WRITE :
621 whence_name = "SFM_WRITE | SEEK_CUR" ;
622 break ;
623 case SEEK_END | SFM_WRITE :
624 whence_name = "SFM_WRITE | SEEK_END" ;
625 break ;
626
627 default :
628 printf ("\n\nLine %d: bad whence parameter.\n", line_num) ;
629 exit (1) ;
630 } ;
631
632 channel_name = (channels == 1) ? "Mono" : "Stereo" ;
633
634 if ((position = sf_seek (file, offset, whence)) != new_pos)
635 { printf ("\n\nLine %d : %s : sf_seek (file, %ld, %s) returned %ld (should be %ld).\n\n",
636 line_num, channel_name, SF_COUNT_TO_LONG (offset), whence_name,
637 SF_COUNT_TO_LONG (position), SF_COUNT_TO_LONG (new_pos)) ;
638 exit (1) ;
639 } ;
640
641 } /* test_seek_or_die */
642
643 [+ FOR read_op +]
644 [+ FOR io_type +]
645 void
646 test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die (SNDFILE *file, int pass, [+ (get "io_element") +] *test, sf_count_t [+ (get "count_name") +], int line_num)
647 { sf_count_t count ;
648
649 if ((count = sf_[+ (get "op_element") +]_[+ (get "io_element") +] (file, test, [+ (get "count_name") +])) != [+ (get "count_name") +])
650 { printf ("\n\nLine %d", line_num) ;
651 if (pass > 0)
652 printf (" (pass %d)", pass) ;
653 printf (" : sf_[+ (get "op_element") +]_[+ (get "io_element") +] failed with short [+ (get "op_element") +] (%ld => %ld).\n",
654 SF_COUNT_TO_LONG ([+ (get "count_name") +]), SF_COUNT_TO_LONG (count)) ;
655 fflush (stdout) ;
656 puts (sf_strerror (file)) ;
657 exit (1) ;
658 } ;
659
660 return ;
661 } /* test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die */
662 [+ ENDFOR io_type +][+ ENDFOR read_op +]
663
664 void
665 test_read_raw_or_die (SNDFILE *file, int pass, void *test, sf_count_t items, int line_num)
666 { sf_count_t count ;
667
668 if ((count = sf_read_raw (file, test, items)) != items)
669 { printf ("\n\nLine %d", line_num) ;
670 if (pass > 0)
671 printf (" (pass %d)", pass) ;
672 printf (" : sf_read_raw failed with short read (%ld => %ld).\n",
673 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
674 fflush (stdout) ;
675 puts (sf_strerror (file)) ;
676 exit (1) ;
677 } ;
678
679 return ;
680 } /* test_read_raw_or_die */
681
682 [+ FOR write_op +]
683 [+ FOR io_type +]
684 void
685 test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die (SNDFILE *file, int pass, const [+ (get "io_element") +] *test, sf_count_t [+ (get "count_name") +], int line_num)
686 { sf_count_t count ;
687
688 if ((count = sf_[+ (get "op_element") +]_[+ (get "io_element") +] (file, test, [+ (get "count_name") +])) != [+ (get "count_name") +])
689 { printf ("\n\nLine %d", line_num) ;
690 if (pass > 0)
691 printf (" (pass %d)", pass) ;
692 printf (" : sf_[+ (get "op_element") +]_[+ (get "io_element") +] failed with short [+ (get "op_element") +] (%ld => %ld).\n",
693 SF_COUNT_TO_LONG ([+ (get "count_name") +]), SF_COUNT_TO_LONG (count)) ;
694 fflush (stdout) ;
695 puts (sf_strerror (file)) ;
696 exit (1) ;
697 } ;
698
699 return ;
700 } /* test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die */
701 [+ ENDFOR io_type +][+ ENDFOR write_op +]
702
703 void
704 test_write_raw_or_die (SNDFILE *file, int pass, const void *test, sf_count_t items, int line_num)
705 { sf_count_t count ;
706
707 if ((count = sf_write_raw (file, test, items)) != items)
708 { printf ("\n\nLine %d", line_num) ;
709 if (pass > 0)
710 printf (" (pass %d)", pass) ;
711 printf (" : sf_write_raw failed with short write (%ld => %ld).\n",
712 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
713 fflush (stdout) ;
714 puts (sf_strerror (file)) ;
715 exit (1) ;
716 } ;
717
718 return ;
719 } /* test_write_raw_or_die */
720
721
722 [+ FOR io_type
723 +]void
724 compare_[+ (get "io_element") +]_or_die (const [+ (get "io_element") +] *left, const [+ (get "io_element") +] *right, unsigned count, int line_num)
725 {
726 unsigned k ;
727
728 for (k = 0 ; k < count ;k++)
729 if (left [k] != right [k])
730 { printf ("\n\nLine %d : Error at index %d, " [+ (get "format_str") +] " should be " [+ (get "format_str") +] ".\n\n", line_num, k, left [k], right [k]) ;
731 exit (1) ;
732 } ;
733
734 return ;
735 } /* compare_[+ (get "io_element") +]_or_die */
736 [+ ENDFOR io_type +]
737
738
739 void
740 delete_file (int format, const char *filename)
741 { char rsrc_name [512], *fname ;
742
743 unlink (filename) ;
744
745 if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_SD2)
746 return ;
747
748 /*
749 ** Now try for a resource fork stored as a separate file.
750 ** Grab the un-adulterated filename again.
751 */
752 snprintf (rsrc_name, sizeof (rsrc_name), "%s", filename) ;
753
754 if ((fname = strrchr (rsrc_name, '/')) != NULL)
755 fname ++ ;
756 else if ((fname = strrchr (rsrc_name, '\\')) != NULL)
757 fname ++ ;
758 else
759 fname = rsrc_name ;
760
761 memmove (fname + 2, fname, strlen (fname) + 1) ;
762 fname [0] = '.' ;
763 fname [1] = '_' ;
764
765 unlink (rsrc_name) ;
766 } /* delete_file */
767
768 static int allowed_open_files = -1 ;
769
770 void
771 count_open_files (void)
772 {
773 #if OS_IS_WIN32
774 return ;
775 #else
776 int k, count = 0 ;
777 struct stat statbuf ;
778
779 if (allowed_open_files > 0)
780 return ;
781
782 for (k = 0 ; k < 1024 ; k++)
783 if (fstat (k, &statbuf) == 0)
784 count ++ ;
785
786 allowed_open_files = count ;
787 #endif
788 } /* count_open_files */
789
790 void
791 increment_open_file_count (void)
792 { allowed_open_files ++ ;
793 } /* increment_open_file_count */
794
795 void
796 check_open_file_count_or_die (int lineno)
797 {
798 #if OS_IS_WIN32
799 lineno = 0 ;
800 return ;
801 #else
802 int k, count = 0 ;
803 struct stat statbuf ;
804
805 if (allowed_open_files < 0)
806 count_open_files () ;
807
808 for (k = 0 ; k < 1024 ; k++)
809 if (fstat (k, &statbuf) == 0)
810 count ++ ;
811
812 if (count > allowed_open_files)
813 { printf ("\nLine %d : number of open files (%d) > allowed (%d).\n\n", lineno, count, allowed_open_files) ;
814 exit (1) ;
815 } ;
816 #endif
817 } /* check_open_file_count_or_die */
818
819 void
820 write_mono_file (const char * filename, int format, int srate, float * output, int len)
821 { SNDFILE * file ;
822 SF_INFO sfinfo ;
823
824 memset (&sfinfo, 0, sizeof (sfinfo)) ;
825
826 sfinfo.samplerate = srate ;
827 sfinfo.channels = 1 ;
828 sfinfo.format = format ;
829
830 if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
831 { printf ("sf_open (%s) : %s\n", filename, sf_strerror (NULL)) ;
832 exit (1) ;
833 } ;
834
835 sf_write_float (file, output, len) ;
836
837 sf_close (file) ;
838 } /* write_mono_file */
839
840 void
841 gen_lowpass_noise_float (float *data, int len)
842 { int32_t value = 0x1243456 ;
843 double sample, last_val = 0.0 ;
844 int k ;
845
846 for (k = 0 ; k < len ; k++)
847 { /* Not a crypto quality RNG. */
848 value = 11117 * value + 211231 ;
849 value = 11117 * value + 211231 ;
850 value = 11117 * value + 211231 ;
851
852 sample = value / (0x7fffffff * 1.000001) ;
853 sample = 0.2 * sample - 0.9 * last_val ;
854
855 data [k] = last_val = sample ;
856 } ;
857
858 } /* gen_lowpass_noise_float */
859
860
861 /*
862 ** Windows is fucked.
863 ** If a file is opened R/W and data is written to it, then fstat will return
864 ** the correct file length, but stat will return zero.
865 */
866
867 sf_count_t
868 file_length (const char * fname)
869 { struct stat data ;
870
871 if (stat (fname, &data) != 0)
872 return 0 ;
873
874 return (sf_count_t) data.st_size ;
875 } /* file_length */
876
877 sf_count_t
878 file_length_fd (int fd)
879 { struct stat data ;
880
881 memset (&data, 0, sizeof (data)) ;
882 if (fstat (fd, &data) != 0)
883 return 0 ;
884
885 return (sf_count_t) data.st_size ;
886 } /* file_length_fd */
887
888
889 [+ ESAC +]
890