projects / Faustine.git / blob
? search:


882c969ab192f3e97fd338bf639f89b95f2a7192
[Faustine.git] / interpretor / libsndfile-1.0.25 / tests / utils.c
1 /*
2 ** Copyright (C) 2002-2011 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 /*
20 ** Utility functions to make writing the test suite easier.
21 **
22 ** The .c and .h files were generated automagically with Autogen from
23 ** the files utils.def and utils.tpl.
24 */
25
26
27
28 #include "sfconfig.h"
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <inttypes.h>
33
34 #if HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #if (HAVE_DECL_S_IRGRP == 0)
39 #include <sf_unistd.h>
40 #endif
41
42 #include <errno.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <math.h>
46 #include <fcntl.h>
47 #include <sys/stat.h>
48
49 #include <sndfile.h>
50
51 #include "utils.h"
52
53 #ifndef M_PI
54 #define M_PI 3.14159265358979323846264338
55 #endif
56
57 #define LOG_BUFFER_SIZE 2048
58
59 /*
60 ** Neat solution to the Win32/OS2 binary file flage requirement.
61 ** If O_BINARY isn't already defined by the inclusion of the system
62 ** headers, set it to zero.
63 */
64 #ifndef O_BINARY
65 #define O_BINARY 0
66 #endif
67
68
69 void
70 gen_windowed_sine_float (float *data, int len, double maximum)
71 { int k ;
72
73 memset (data, 0, len * sizeof (float)) ;
74 /*
75 ** Choose a frequency of 1/32 so that it aligns perfectly with a DFT
76 ** bucket to minimise spreading of energy over more than one bucket.
77 ** Also do not want to make the frequency too high as some of the
78 ** codecs (ie gsm610) have a quite severe high frequency roll off.
79 */
80 len /= 2 ;
81
82 for (k = 0 ; k < len ; k++)
83 { data [k] = sin (2.0 * k * M_PI * 1.0 / 32.0 + 0.4) ;
84
85 /* Apply Hanning Window. */
86 data [k] *= maximum * (0.5 - 0.5 * cos (2.0 * M_PI * k / ((len) - 1))) ;
87 }
88
89 return ;
90 } /* gen_windowed_sine_float */
91
92 void
93 gen_windowed_sine_double (double *data, int len, double maximum)
94 { int k ;
95
96 memset (data, 0, len * sizeof (double)) ;
97 /*
98 ** Choose a frequency of 1/32 so that it aligns perfectly with a DFT
99 ** bucket to minimise spreading of energy over more than one bucket.
100 ** Also do not want to make the frequency too high as some of the
101 ** codecs (ie gsm610) have a quite severe high frequency roll off.
102 */
103 len /= 2 ;
104
105 for (k = 0 ; k < len ; k++)
106 { data [k] = sin (2.0 * k * M_PI * 1.0 / 32.0 + 0.4) ;
107
108 /* Apply Hanning Window. */
109 data [k] *= maximum * (0.5 - 0.5 * cos (2.0 * M_PI * k / ((len) - 1))) ;
110 }
111
112 return ;
113 } /* gen_windowed_sine_double */
114
115
116 void
117 create_short_sndfile (const char *filename, int format, int channels)
118 { short data [2 * 3 * 4 * 5 * 6 * 7] = { 0, } ;
119 SNDFILE *file ;
120 SF_INFO sfinfo ;
121
122 sfinfo.samplerate = 44100 ;
123 sfinfo.channels = channels ;
124 sfinfo.format = format ;
125
126 if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
127 { printf ("Error (%s, %d) : sf_open failed : %s\n", __FILE__, __LINE__, sf_strerror (file)) ;
128 exit (1) ;
129 } ;
130
131 sf_write_short (file, data, ARRAY_LEN (data)) ;
132
133 sf_close (file) ;
134 } /* create_short_sndfile */
135
136 void
137 check_file_hash_or_die (const char *filename, uint64_t target_hash, int line_num)
138 { static unsigned char buf [4096] ;
139 uint64_t cksum ;
140 FILE *file ;
141 int k, read_count ;
142
143 memset (buf, 0, sizeof (buf)) ;
144
145 /* The 'b' in the mode string means binary for Win32. */
146 if ((file = fopen (filename, "rb")) == NULL)
147 { printf ("\n\nLine %d: could not open file '%s'\n\n", line_num, filename) ;
148 exit (1) ;
149 } ;
150
151 cksum = 0 ;
152
153 while ((read_count = fread (buf, 1, sizeof (buf), file)))
154 for (k = 0 ; k < read_count ; k++)
155 cksum = cksum * 511 + buf [k] ;
156
157 fclose (file) ;
158
159 if (target_hash == 0)
160 { printf (" 0x%016" PRIx64 "\n", cksum) ;
161 return ;
162 } ;
163
164 if (cksum != target_hash)
165 { printf ("\n\nLine %d: incorrect hash value 0x%016" PRIx64 " should be 0x%016" PRIx64 ".\n\n", line_num, cksum, target_hash) ;
166 exit (1) ;
167 } ;
168
169 return ;
170 } /* check_file_hash_or_die */
171
172 void
173 print_test_name (const char *test, const char *filename)
174 { int count ;
175
176 if (test == NULL)
177 { printf (__FILE__ ": bad test of filename parameter.\n") ;
178 exit (1) ;
179 } ;
180
181 if (filename == NULL || strlen (filename) == 0)
182 { printf (" %-30s : ", test) ;
183 count = 25 ;
184 }
185 else
186 { printf (" %-30s : %s ", test, filename) ;
187 count = 24 - strlen (filename) ;
188 } ;
189
190 while (count -- > 0)
191 putchar ('.') ;
192 putchar (' ') ;
193
194 fflush (stdout) ;
195 } /* print_test_name */
196
197 void
198 dump_data_to_file (const char *filename, const void *data, unsigned int datalen)
199 { FILE *file ;
200
201 if ((file = fopen (filename, "wb")) == NULL)
202 { printf ("\n\nLine %d : could not open file : %s\n\n", __LINE__, filename) ;
203 exit (1) ;
204 } ;
205
206 if (fwrite (data, 1, datalen, file) != datalen)
207 { printf ("\n\nLine %d : fwrite failed.\n\n", __LINE__) ;
208 exit (1) ;
209 } ;
210
211 fclose (file) ;
212
213 } /* dump_data_to_file */
214
215 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
216 */
217
218 static char octfilename [] = "error.dat" ;
219
220 int
221 oct_save_short (const short *a, const short *b, int len)
222 { FILE *file ;
223 int k ;
224
225 if (! (file = fopen (octfilename, "w")))
226 return 1 ;
227
228 fprintf (file, "# Not created by Octave\n") ;
229
230 fprintf (file, "# name: a\n") ;
231 fprintf (file, "# type: matrix\n") ;
232 fprintf (file, "# rows: %d\n", len) ;
233 fprintf (file, "# columns: 1\n") ;
234
235 for (k = 0 ; k < len ; k++)
236 fprintf (file, "% d" "\n", a [k]) ;
237
238 fprintf (file, "# name: b\n") ;
239 fprintf (file, "# type: matrix\n") ;
240 fprintf (file, "# rows: %d\n", len) ;
241 fprintf (file, "# columns: 1\n") ;
242
243 for (k = 0 ; k < len ; k++)
244 fprintf (file, "% d" "\n", b [k]) ;
245
246 fclose (file) ;
247 return 0 ;
248 } /* oct_save_short */
249 int
250 oct_save_int (const int *a, const int *b, int len)
251 { FILE *file ;
252 int k ;
253
254 if (! (file = fopen (octfilename, "w")))
255 return 1 ;
256
257 fprintf (file, "# Not created by Octave\n") ;
258
259 fprintf (file, "# name: a\n") ;
260 fprintf (file, "# type: matrix\n") ;
261 fprintf (file, "# rows: %d\n", len) ;
262 fprintf (file, "# columns: 1\n") ;
263
264 for (k = 0 ; k < len ; k++)
265 fprintf (file, "% d" "\n", a [k]) ;
266
267 fprintf (file, "# name: b\n") ;
268 fprintf (file, "# type: matrix\n") ;
269 fprintf (file, "# rows: %d\n", len) ;
270 fprintf (file, "# columns: 1\n") ;
271
272 for (k = 0 ; k < len ; k++)
273 fprintf (file, "% d" "\n", b [k]) ;
274
275 fclose (file) ;
276 return 0 ;
277 } /* oct_save_int */
278 int
279 oct_save_float (const float *a, const float *b, int len)
280 { FILE *file ;
281 int k ;
282
283 if (! (file = fopen (octfilename, "w")))
284 return 1 ;
285
286 fprintf (file, "# Not created by Octave\n") ;
287
288 fprintf (file, "# name: a\n") ;
289 fprintf (file, "# type: matrix\n") ;
290 fprintf (file, "# rows: %d\n", len) ;
291 fprintf (file, "# columns: 1\n") ;
292
293 for (k = 0 ; k < len ; k++)
294 fprintf (file, "% g" "\n", a [k]) ;
295
296 fprintf (file, "# name: b\n") ;
297 fprintf (file, "# type: matrix\n") ;
298 fprintf (file, "# rows: %d\n", len) ;
299 fprintf (file, "# columns: 1\n") ;
300
301 for (k = 0 ; k < len ; k++)
302 fprintf (file, "% g" "\n", b [k]) ;
303
304 fclose (file) ;
305 return 0 ;
306 } /* oct_save_float */
307 int
308 oct_save_double (const double *a, const double *b, int len)
309 { FILE *file ;
310 int k ;
311
312 if (! (file = fopen (octfilename, "w")))
313 return 1 ;
314
315 fprintf (file, "# Not created by Octave\n") ;
316
317 fprintf (file, "# name: a\n") ;
318 fprintf (file, "# type: matrix\n") ;
319 fprintf (file, "# rows: %d\n", len) ;
320 fprintf (file, "# columns: 1\n") ;
321
322 for (k = 0 ; k < len ; k++)
323 fprintf (file, "% g" "\n", a [k]) ;
324
325 fprintf (file, "# name: b\n") ;
326 fprintf (file, "# type: matrix\n") ;
327 fprintf (file, "# rows: %d\n", len) ;
328 fprintf (file, "# columns: 1\n") ;
329
330 for (k = 0 ; k < len ; k++)
331 fprintf (file, "% g" "\n", b [k]) ;
332
333 fclose (file) ;
334 return 0 ;
335 } /* oct_save_double */
336
337
338 void
339 check_log_buffer_or_die (SNDFILE *file, int line_num)
340 { static char buffer [LOG_BUFFER_SIZE] ;
341 int count ;
342
343 memset (buffer, 0, sizeof (buffer)) ;
344
345 /* Get the log buffer data. */
346 count = sf_command (file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
347
348 if (LOG_BUFFER_SIZE - count < 2)
349 { printf ("\n\nLine %d : Possible long log buffer.\n", line_num) ;
350 exit (1) ;
351 }
352
353 /* Look for "Should" */
354 if (strstr (buffer, "ould"))
355 { printf ("\n\nLine %d : Log buffer contains `ould'. Dumping.\n", line_num) ;
356 puts (buffer) ;
357 exit (1) ;
358 } ;
359
360 /* Look for "**" */
361 if (strstr (buffer, "*"))
362 { printf ("\n\nLine %d : Log buffer contains `*'. Dumping.\n", line_num) ;
363 puts (buffer) ;
364 exit (1) ;
365 } ;
366
367 /* Look for "Should" */
368 if (strstr (buffer, "nknown marker"))
369 { printf ("\n\nLine %d : Log buffer contains `nknown marker'. Dumping.\n", line_num) ;
370 puts (buffer) ;
371 exit (1) ;
372 } ;
373
374 return ;
375 } /* check_log_buffer_or_die */
376
377 int
378 string_in_log_buffer (SNDFILE *file, const char *s)
379 { static char buffer [LOG_BUFFER_SIZE] ;
380 int count ;
381
382 memset (buffer, 0, sizeof (buffer)) ;
383
384 /* Get the log buffer data. */
385 count = sf_command (file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
386
387 if (LOG_BUFFER_SIZE - count < 2)
388 { printf ("Possible long log buffer.\n") ;
389 exit (1) ;
390 }
391
392 /* Look for string */
393 return strstr (buffer, s) ? SF_TRUE : SF_FALSE ;
394 } /* string_in_log_buffer */
395
396 void
397 hexdump_file (const char * filename, sf_count_t offset, sf_count_t length)
398 {
399 FILE * file ;
400 char buffer [16] ;
401 int k, m, ch, readcount ;
402
403 if (length > 1000000)
404 { printf ("\n\nError : length (%ld) too long.\n\n", SF_COUNT_TO_LONG (offset)) ;
405 exit (1) ;
406 } ;
407
408 if ((file = fopen (filename, "r")) == NULL)
409 { printf ("\n\nError : hexdump_file (%s) could not open file for read.\n\n", filename) ;
410 exit (1) ;
411 } ;
412
413 if (fseek (file, offset, SEEK_SET) != 0)
414 { printf ("\n\nError : fseek(file, %ld, SEEK_SET) failed : %s\n\n", SF_COUNT_TO_LONG (offset), strerror (errno)) ;
415 exit (1) ;
416 } ;
417
418 puts ("\n\n") ;
419
420 for (k = 0 ; k < length ; k+= sizeof (buffer))
421 { readcount = fread (buffer, 1, sizeof (buffer), file) ;
422
423 printf ("%08lx : ", SF_COUNT_TO_LONG (offset + k)) ;
424
425 for (m = 0 ; m < readcount ; m++)
426 printf ("%02x ", buffer [m] & 0xFF) ;
427
428 for (m = readcount ; m < SIGNED_SIZEOF (buffer) ; m++)
429 printf (" ") ;
430
431 printf (" ") ;
432 for (m = 0 ; m < readcount ; m++)
433 { ch = isprint (buffer [m]) ? buffer [m] : '.' ;
434 putchar (ch) ;
435 } ;
436
437 if (readcount < SIGNED_SIZEOF (buffer))
438 break ;
439
440 putchar ('\n') ;
441 } ;
442
443 puts ("\n") ;
444
445 fclose (file) ;
446 } /* hexdump_file */
447
448 void
449 dump_log_buffer (SNDFILE *file)
450 { static char buffer [LOG_BUFFER_SIZE] ;
451
452 memset (buffer, 0, sizeof (buffer)) ;
453
454 /* Get the log buffer data. */
455 sf_command (file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
456
457 if (strlen (buffer) < 1)
458 puts ("Log buffer empty.\n") ;
459 else
460 puts (buffer) ;
461
462 return ;
463 } /* dump_log_buffer */
464
465 SNDFILE *
466 test_open_file_or_die (const char *filename, int mode, SF_INFO *sfinfo, int allow_fd, int line_num)
467 { static int count = 0 ;
468
469 SNDFILE *file ;
470 const char *modestr, *func_name ;
471 int oflags = 0, omode = 0, err ;
472
473 /*
474 ** Need to test both sf_open() and sf_open_fd().
475 ** Do so alternately.
476 */
477 switch (mode)
478 { case SFM_READ :
479 modestr = "SFM_READ" ;
480 oflags = O_RDONLY | O_BINARY ;
481 omode = 0 ;
482 break ;
483
484 case SFM_WRITE :
485 modestr = "SFM_WRITE" ;
486 oflags = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY ;
487 omode = S_IRUSR | S_IWUSR | S_IRGRP ;
488 break ;
489
490 case SFM_RDWR :
491 modestr = "SFM_RDWR" ;
492 oflags = O_RDWR | O_CREAT | O_BINARY ;
493 omode = S_IRUSR | S_IWUSR | S_IRGRP ;
494 break ;
495 default :
496 printf ("\n\nLine %d: Bad mode.\n", line_num) ;
497 fflush (stdout) ;
498 exit (1) ;
499 } ;
500
501 if (OS_IS_WIN32)
502 { /* Windows does not understand and ignores the S_IRGRP flag, but Wine
503 ** gives a run time warning message, so just clear it.
504 */
505 omode &= ~S_IRGRP ;
506 } ;
507
508 if (allow_fd && ((++count) & 1) == 1)
509 { int fd ;
510
511 /* Only use the three argument open() function if omode != 0. */
512 fd = (omode == 0) ? open (filename, oflags) : open (filename, oflags, omode) ;
513
514 if (fd < 0)
515 { printf ("\n\n%s : open failed : %s\n", __func__, strerror (errno)) ;
516 exit (1) ;
517 } ;
518
519 func_name = "sf_open_fd" ;
520 file = sf_open_fd (fd, mode, sfinfo, SF_TRUE) ;
521 }
522 else
523 { func_name = "sf_open" ;
524 file = sf_open (filename, mode, sfinfo) ;
525 } ;
526
527 if (file == NULL)
528 { printf ("\n\nLine %d: %s (%s) failed : %s\n\n", line_num, func_name, modestr, sf_strerror (NULL)) ;
529 dump_log_buffer (file) ;
530 exit (1) ;
531 } ;
532
533 err = sf_error (file) ;
534 if (err != SF_ERR_NO_ERROR)
535 { printf ("\n\nLine %d : sf_error : %s\n\n", line_num, sf_error_number (err)) ;
536 dump_log_buffer (file) ;
537 exit (1) ;
538 } ;
539
540 return file ;
541 } /* test_open_file_or_die */
542
543 void
544 test_read_write_position_or_die (SNDFILE *file, int line_num, int pass, sf_count_t read_pos, sf_count_t write_pos)
545 { sf_count_t pos ;
546
547 /* Check the current read position. */
548 if (read_pos >= 0 && (pos = sf_seek (file, 0, SEEK_CUR | SFM_READ)) != read_pos)
549 { printf ("\n\nLine %d ", line_num) ;
550 if (pass > 0)
551 printf ("(pass %d): ", pass) ;
552 printf ("Read position (%ld) should be %ld.\n", SF_COUNT_TO_LONG (pos), SF_COUNT_TO_LONG (read_pos)) ;
553 exit (1) ;
554 } ;
555
556 /* Check the current write position. */
557 if (write_pos >= 0 && (pos = sf_seek (file, 0, SEEK_CUR | SFM_WRITE)) != write_pos)
558 { printf ("\n\nLine %d", line_num) ;
559 if (pass > 0)
560 printf (" (pass %d)", pass) ;
561 printf (" : Write position (%ld) should be %ld.\n",
562 SF_COUNT_TO_LONG (pos), SF_COUNT_TO_LONG (write_pos)) ;
563 exit (1) ;
564 } ;
565
566 return ;
567 } /* test_read_write_position */
568
569 void
570 test_seek_or_die (SNDFILE *file, sf_count_t offset, int whence, sf_count_t new_pos, int channels, int line_num)
571 { sf_count_t position ;
572 const char *channel_name, *whence_name ;
573
574 switch (whence)
575 { case SEEK_SET :
576 whence_name = "SEEK_SET" ;
577 break ;
578 case SEEK_CUR :
579 whence_name = "SEEK_CUR" ;
580 break ;
581 case SEEK_END :
582 whence_name = "SEEK_END" ;
583 break ;
584
585 /* SFM_READ */
586 case SEEK_SET | SFM_READ :
587 whence_name = "SFM_READ | SEEK_SET" ;
588 break ;
589 case SEEK_CUR | SFM_READ :
590 whence_name = "SFM_READ | SEEK_CUR" ;
591 break ;
592 case SEEK_END | SFM_READ :
593 whence_name = "SFM_READ | SEEK_END" ;
594 break ;
595
596 /* SFM_WRITE */
597 case SEEK_SET | SFM_WRITE :
598 whence_name = "SFM_WRITE | SEEK_SET" ;
599 break ;
600 case SEEK_CUR | SFM_WRITE :
601 whence_name = "SFM_WRITE | SEEK_CUR" ;
602 break ;
603 case SEEK_END | SFM_WRITE :
604 whence_name = "SFM_WRITE | SEEK_END" ;
605 break ;
606
607 default :
608 printf ("\n\nLine %d: bad whence parameter.\n", line_num) ;
609 exit (1) ;
610 } ;
611
612 channel_name = (channels == 1) ? "Mono" : "Stereo" ;
613
614 if ((position = sf_seek (file, offset, whence)) != new_pos)
615 { printf ("\n\nLine %d : %s : sf_seek (file, %ld, %s) returned %ld (should be %ld).\n\n",
616 line_num, channel_name, SF_COUNT_TO_LONG (offset), whence_name,
617 SF_COUNT_TO_LONG (position), SF_COUNT_TO_LONG (new_pos)) ;
618 exit (1) ;
619 } ;
620
621 } /* test_seek_or_die */
622
623
624
625 void
626 test_read_short_or_die (SNDFILE *file, int pass, short *test, sf_count_t items, int line_num)
627 { sf_count_t count ;
628
629 if ((count = sf_read_short (file, test, items)) != items)
630 { printf ("\n\nLine %d", line_num) ;
631 if (pass > 0)
632 printf (" (pass %d)", pass) ;
633 printf (" : sf_read_short failed with short read (%ld => %ld).\n",
634 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
635 fflush (stdout) ;
636 puts (sf_strerror (file)) ;
637 exit (1) ;
638 } ;
639
640 return ;
641 } /* test_read_short_or_die */
642
643 void
644 test_read_int_or_die (SNDFILE *file, int pass, int *test, sf_count_t items, int line_num)
645 { sf_count_t count ;
646
647 if ((count = sf_read_int (file, test, items)) != items)
648 { printf ("\n\nLine %d", line_num) ;
649 if (pass > 0)
650 printf (" (pass %d)", pass) ;
651 printf (" : sf_read_int failed with short read (%ld => %ld).\n",
652 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
653 fflush (stdout) ;
654 puts (sf_strerror (file)) ;
655 exit (1) ;
656 } ;
657
658 return ;
659 } /* test_read_int_or_die */
660
661 void
662 test_read_float_or_die (SNDFILE *file, int pass, float *test, sf_count_t items, int line_num)
663 { sf_count_t count ;
664
665 if ((count = sf_read_float (file, test, items)) != items)
666 { printf ("\n\nLine %d", line_num) ;
667 if (pass > 0)
668 printf (" (pass %d)", pass) ;
669 printf (" : sf_read_float failed with short read (%ld => %ld).\n",
670 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
671 fflush (stdout) ;
672 puts (sf_strerror (file)) ;
673 exit (1) ;
674 } ;
675
676 return ;
677 } /* test_read_float_or_die */
678
679 void
680 test_read_double_or_die (SNDFILE *file, int pass, double *test, sf_count_t items, int line_num)
681 { sf_count_t count ;
682
683 if ((count = sf_read_double (file, test, items)) != items)
684 { printf ("\n\nLine %d", line_num) ;
685 if (pass > 0)
686 printf (" (pass %d)", pass) ;
687 printf (" : sf_read_double failed with short read (%ld => %ld).\n",
688 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
689 fflush (stdout) ;
690 puts (sf_strerror (file)) ;
691 exit (1) ;
692 } ;
693
694 return ;
695 } /* test_read_double_or_die */
696
697
698 void
699 test_readf_short_or_die (SNDFILE *file, int pass, short *test, sf_count_t frames, int line_num)
700 { sf_count_t count ;
701
702 if ((count = sf_readf_short (file, test, frames)) != frames)
703 { printf ("\n\nLine %d", line_num) ;
704 if (pass > 0)
705 printf (" (pass %d)", pass) ;
706 printf (" : sf_readf_short failed with short readf (%ld => %ld).\n",
707 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
708 fflush (stdout) ;
709 puts (sf_strerror (file)) ;
710 exit (1) ;
711 } ;
712
713 return ;
714 } /* test_readf_short_or_die */
715
716 void
717 test_readf_int_or_die (SNDFILE *file, int pass, int *test, sf_count_t frames, int line_num)
718 { sf_count_t count ;
719
720 if ((count = sf_readf_int (file, test, frames)) != frames)
721 { printf ("\n\nLine %d", line_num) ;
722 if (pass > 0)
723 printf (" (pass %d)", pass) ;
724 printf (" : sf_readf_int failed with short readf (%ld => %ld).\n",
725 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
726 fflush (stdout) ;
727 puts (sf_strerror (file)) ;
728 exit (1) ;
729 } ;
730
731 return ;
732 } /* test_readf_int_or_die */
733
734 void
735 test_readf_float_or_die (SNDFILE *file, int pass, float *test, sf_count_t frames, int line_num)
736 { sf_count_t count ;
737
738 if ((count = sf_readf_float (file, test, frames)) != frames)
739 { printf ("\n\nLine %d", line_num) ;
740 if (pass > 0)
741 printf (" (pass %d)", pass) ;
742 printf (" : sf_readf_float failed with short readf (%ld => %ld).\n",
743 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
744 fflush (stdout) ;
745 puts (sf_strerror (file)) ;
746 exit (1) ;
747 } ;
748
749 return ;
750 } /* test_readf_float_or_die */
751
752 void
753 test_readf_double_or_die (SNDFILE *file, int pass, double *test, sf_count_t frames, int line_num)
754 { sf_count_t count ;
755
756 if ((count = sf_readf_double (file, test, frames)) != frames)
757 { printf ("\n\nLine %d", line_num) ;
758 if (pass > 0)
759 printf (" (pass %d)", pass) ;
760 printf (" : sf_readf_double failed with short readf (%ld => %ld).\n",
761 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
762 fflush (stdout) ;
763 puts (sf_strerror (file)) ;
764 exit (1) ;
765 } ;
766
767 return ;
768 } /* test_readf_double_or_die */
769
770
771 void
772 test_read_raw_or_die (SNDFILE *file, int pass, void *test, sf_count_t items, int line_num)
773 { sf_count_t count ;
774
775 if ((count = sf_read_raw (file, test, items)) != items)
776 { printf ("\n\nLine %d", line_num) ;
777 if (pass > 0)
778 printf (" (pass %d)", pass) ;
779 printf (" : sf_read_raw failed with short read (%ld => %ld).\n",
780 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
781 fflush (stdout) ;
782 puts (sf_strerror (file)) ;
783 exit (1) ;
784 } ;
785
786 return ;
787 } /* test_read_raw_or_die */
788
789
790
791 void
792 test_write_short_or_die (SNDFILE *file, int pass, const short *test, sf_count_t items, int line_num)
793 { sf_count_t count ;
794
795 if ((count = sf_write_short (file, test, items)) != items)
796 { printf ("\n\nLine %d", line_num) ;
797 if (pass > 0)
798 printf (" (pass %d)", pass) ;
799 printf (" : sf_write_short failed with short write (%ld => %ld).\n",
800 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
801 fflush (stdout) ;
802 puts (sf_strerror (file)) ;
803 exit (1) ;
804 } ;
805
806 return ;
807 } /* test_write_short_or_die */
808
809 void
810 test_write_int_or_die (SNDFILE *file, int pass, const int *test, sf_count_t items, int line_num)
811 { sf_count_t count ;
812
813 if ((count = sf_write_int (file, test, items)) != items)
814 { printf ("\n\nLine %d", line_num) ;
815 if (pass > 0)
816 printf (" (pass %d)", pass) ;
817 printf (" : sf_write_int failed with short write (%ld => %ld).\n",
818 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
819 fflush (stdout) ;
820 puts (sf_strerror (file)) ;
821 exit (1) ;
822 } ;
823
824 return ;
825 } /* test_write_int_or_die */
826
827 void
828 test_write_float_or_die (SNDFILE *file, int pass, const float *test, sf_count_t items, int line_num)
829 { sf_count_t count ;
830
831 if ((count = sf_write_float (file, test, items)) != items)
832 { printf ("\n\nLine %d", line_num) ;
833 if (pass > 0)
834 printf (" (pass %d)", pass) ;
835 printf (" : sf_write_float failed with short write (%ld => %ld).\n",
836 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
837 fflush (stdout) ;
838 puts (sf_strerror (file)) ;
839 exit (1) ;
840 } ;
841
842 return ;
843 } /* test_write_float_or_die */
844
845 void
846 test_write_double_or_die (SNDFILE *file, int pass, const double *test, sf_count_t items, int line_num)
847 { sf_count_t count ;
848
849 if ((count = sf_write_double (file, test, items)) != items)
850 { printf ("\n\nLine %d", line_num) ;
851 if (pass > 0)
852 printf (" (pass %d)", pass) ;
853 printf (" : sf_write_double failed with short write (%ld => %ld).\n",
854 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
855 fflush (stdout) ;
856 puts (sf_strerror (file)) ;
857 exit (1) ;
858 } ;
859
860 return ;
861 } /* test_write_double_or_die */
862
863
864 void
865 test_writef_short_or_die (SNDFILE *file, int pass, const short *test, sf_count_t frames, int line_num)
866 { sf_count_t count ;
867
868 if ((count = sf_writef_short (file, test, frames)) != frames)
869 { printf ("\n\nLine %d", line_num) ;
870 if (pass > 0)
871 printf (" (pass %d)", pass) ;
872 printf (" : sf_writef_short failed with short writef (%ld => %ld).\n",
873 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
874 fflush (stdout) ;
875 puts (sf_strerror (file)) ;
876 exit (1) ;
877 } ;
878
879 return ;
880 } /* test_writef_short_or_die */
881
882 void
883 test_writef_int_or_die (SNDFILE *file, int pass, const int *test, sf_count_t frames, int line_num)
884 { sf_count_t count ;
885
886 if ((count = sf_writef_int (file, test, frames)) != frames)
887 { printf ("\n\nLine %d", line_num) ;
888 if (pass > 0)
889 printf (" (pass %d)", pass) ;
890 printf (" : sf_writef_int failed with short writef (%ld => %ld).\n",
891 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
892 fflush (stdout) ;
893 puts (sf_strerror (file)) ;
894 exit (1) ;
895 } ;
896
897 return ;
898 } /* test_writef_int_or_die */
899
900 void
901 test_writef_float_or_die (SNDFILE *file, int pass, const float *test, sf_count_t frames, int line_num)
902 { sf_count_t count ;
903
904 if ((count = sf_writef_float (file, test, frames)) != frames)
905 { printf ("\n\nLine %d", line_num) ;
906 if (pass > 0)
907 printf (" (pass %d)", pass) ;
908 printf (" : sf_writef_float failed with short writef (%ld => %ld).\n",
909 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
910 fflush (stdout) ;
911 puts (sf_strerror (file)) ;
912 exit (1) ;
913 } ;
914
915 return ;
916 } /* test_writef_float_or_die */
917
918 void
919 test_writef_double_or_die (SNDFILE *file, int pass, const double *test, sf_count_t frames, int line_num)
920 { sf_count_t count ;
921
922 if ((count = sf_writef_double (file, test, frames)) != frames)
923 { printf ("\n\nLine %d", line_num) ;
924 if (pass > 0)
925 printf (" (pass %d)", pass) ;
926 printf (" : sf_writef_double failed with short writef (%ld => %ld).\n",
927 SF_COUNT_TO_LONG (frames), SF_COUNT_TO_LONG (count)) ;
928 fflush (stdout) ;
929 puts (sf_strerror (file)) ;
930 exit (1) ;
931 } ;
932
933 return ;
934 } /* test_writef_double_or_die */
935
936
937 void
938 test_write_raw_or_die (SNDFILE *file, int pass, const void *test, sf_count_t items, int line_num)
939 { sf_count_t count ;
940
941 if ((count = sf_write_raw (file, test, items)) != items)
942 { printf ("\n\nLine %d", line_num) ;
943 if (pass > 0)
944 printf (" (pass %d)", pass) ;
945 printf (" : sf_write_raw failed with short write (%ld => %ld).\n",
946 SF_COUNT_TO_LONG (items), SF_COUNT_TO_LONG (count)) ;
947 fflush (stdout) ;
948 puts (sf_strerror (file)) ;
949 exit (1) ;
950 } ;
951
952 return ;
953 } /* test_write_raw_or_die */
954
955
956 void
957 compare_short_or_die (const short *left, const short *right, unsigned count, int line_num)
958 {
959 unsigned k ;
960
961 for (k = 0 ; k < count ;k++)
962 if (left [k] != right [k])
963 { printf ("\n\nLine %d : Error at index %d, " "% d" " should be " "% d" ".\n\n", line_num, k, left [k], right [k]) ;
964 exit (1) ;
965 } ;
966
967 return ;
968 } /* compare_short_or_die */
969 void
970 compare_int_or_die (const int *left, const int *right, unsigned count, int line_num)
971 {
972 unsigned k ;
973
974 for (k = 0 ; k < count ;k++)
975 if (left [k] != right [k])
976 { printf ("\n\nLine %d : Error at index %d, " "% d" " should be " "% d" ".\n\n", line_num, k, left [k], right [k]) ;
977 exit (1) ;
978 } ;
979
980 return ;
981 } /* compare_int_or_die */
982 void
983 compare_float_or_die (const float *left, const float *right, unsigned count, int line_num)
984 {
985 unsigned k ;
986
987 for (k = 0 ; k < count ;k++)
988 if (left [k] != right [k])
989 { printf ("\n\nLine %d : Error at index %d, " "% g" " should be " "% g" ".\n\n", line_num, k, left [k], right [k]) ;
990 exit (1) ;
991 } ;
992
993 return ;
994 } /* compare_float_or_die */
995 void
996 compare_double_or_die (const double *left, const double *right, unsigned count, int line_num)
997 {
998 unsigned k ;
999
1000 for (k = 0 ; k < count ;k++)
1001 if (left [k] != right [k])
1002 { printf ("\n\nLine %d : Error at index %d, " "% g" " should be " "% g" ".\n\n", line_num, k, left [k], right [k]) ;
1003 exit (1) ;
1004 } ;
1005
1006 return ;
1007 } /* compare_double_or_die */
1008
1009
1010
1011 void
1012 delete_file (int format, const char *filename)
1013 { char rsrc_name [512], *fname ;
1014
1015 unlink (filename) ;
1016
1017 if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_SD2)
1018 return ;
1019
1020 /*
1021 ** Now try for a resource fork stored as a separate file.
1022 ** Grab the un-adulterated filename again.
1023 */
1024 snprintf (rsrc_name, sizeof (rsrc_name), "%s", filename) ;
1025
1026 if ((fname = strrchr (rsrc_name, '/')) != NULL)
1027 fname ++ ;
1028 else if ((fname = strrchr (rsrc_name, '\\')) != NULL)
1029 fname ++ ;
1030 else
1031 fname = rsrc_name ;
1032
1033 memmove (fname + 2, fname, strlen (fname) + 1) ;
1034 fname [0] = '.' ;
1035 fname [1] = '_' ;
1036
1037 unlink (rsrc_name) ;
1038 } /* delete_file */
1039
1040 static int allowed_open_files = -1 ;
1041
1042 void
1043 count_open_files (void)
1044 {
1045 #if OS_IS_WIN32
1046 return ;
1047 #else
1048 int k, count = 0 ;
1049 struct stat statbuf ;
1050
1051 if (allowed_open_files > 0)
1052 return ;
1053
1054 for (k = 0 ; k < 1024 ; k++)
1055 if (fstat (k, &statbuf) == 0)
1056 count ++ ;
1057
1058 allowed_open_files = count ;
1059 #endif
1060 } /* count_open_files */
1061
1062 void
1063 increment_open_file_count (void)
1064 { allowed_open_files ++ ;
1065 } /* increment_open_file_count */
1066
1067 void
1068 check_open_file_count_or_die (int lineno)
1069 {
1070 #if OS_IS_WIN32
1071 lineno = 0 ;
1072 return ;
1073 #else
1074 int k, count = 0 ;
1075 struct stat statbuf ;
1076
1077 if (allowed_open_files < 0)
1078 count_open_files () ;
1079
1080 for (k = 0 ; k < 1024 ; k++)
1081 if (fstat (k, &statbuf) == 0)
1082 count ++ ;
1083
1084 if (count > allowed_open_files)
1085 { printf ("\nLine %d : number of open files (%d) > allowed (%d).\n\n", lineno, count, allowed_open_files) ;
1086 exit (1) ;
1087 } ;
1088 #endif
1089 } /* check_open_file_count_or_die */
1090
1091 void
1092 write_mono_file (const char * filename, int format, int srate, float * output, int len)
1093 { SNDFILE * file ;
1094 SF_INFO sfinfo ;
1095
1096 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1097
1098 sfinfo.samplerate = srate ;
1099 sfinfo.channels = 1 ;
1100 sfinfo.format = format ;
1101
1102 if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
1103 { printf ("sf_open (%s) : %s\n", filename, sf_strerror (NULL)) ;
1104 exit (1) ;
1105 } ;
1106
1107 sf_write_float (file, output, len) ;
1108
1109 sf_close (file) ;
1110 } /* write_mono_file */
1111
1112 void
1113 gen_lowpass_noise_float (float *data, int len)
1114 { int32_t value = 0x1243456 ;
1115 double sample, last_val = 0.0 ;
1116 int k ;
1117
1118 for (k = 0 ; k < len ; k++)
1119 { /* Not a crypto quality RNG. */
1120 value = 11117 * value + 211231 ;
1121 value = 11117 * value + 211231 ;
1122 value = 11117 * value + 211231 ;
1123
1124 sample = value / (0x7fffffff * 1.000001) ;
1125 sample = 0.2 * sample - 0.9 * last_val ;
1126
1127 data [k] = last_val = sample ;
1128 } ;
1129
1130 } /* gen_lowpass_noise_float */
1131
1132
1133 /*
1134 ** Windows is fucked.
1135 ** If a file is opened R/W and data is written to it, then fstat will return
1136 ** the correct file length, but stat will return zero.
1137 */
1138
1139 sf_count_t
1140 file_length (const char * fname)
1141 { struct stat data ;
1142
1143 if (stat (fname, &data) != 0)
1144 return 0 ;
1145
1146 return (sf_count_t) data.st_size ;
1147 } /* file_length */
1148
1149 sf_count_t
1150 file_length_fd (int fd)
1151 { struct stat data ;
1152
1153 memset (&data, 0, sizeof (data)) ;
1154 if (fstat (fd, &data) != 0)
1155 return 0 ;
1156
1157 return (sf_count_t) data.st_size ;
1158 } /* file_length_fd */
1159
1160
1161
1162
An OCaml-based interpreter for Faust and its vector extension