cannam@125: [+ AutoGen5 template h c +]
cannam@125: /*
cannam@125: ** Copyright (C) 2002-2016 Erik de Castro Lopo <erikd@mega-nerd.com>
cannam@125: **
cannam@125: ** This program is free software; you can redistribute it and/or modify
cannam@125: ** it under the terms of the GNU General Public License as published by
cannam@125: ** the Free Software Foundation; either version 2 of the License, or
cannam@125: ** (at your option) any later version.
cannam@125: **
cannam@125: ** This program is distributed in the hope that it will be useful,
cannam@125: ** but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@125: ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
cannam@125: ** GNU General Public License for more details.
cannam@125: **
cannam@125: ** You should have received a copy of the GNU General Public License
cannam@125: ** along with this program; if not, write to the Free Software
cannam@125: ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cannam@125: */
cannam@125: 
cannam@125: /*
cannam@125: **	Utility functions to make writing the test suite easier.
cannam@125: **
cannam@125: **	The .c and .h files were generated automagically with Autogen from
cannam@125: **	the files utils.def and utils.tpl.
cannam@125: */
cannam@125: 
cannam@125: [+ CASE (suffix) +]
cannam@125: [+ ==  h  +]
cannam@125: 
cannam@125: #ifdef __cplusplus
cannam@125: extern "C" {
cannam@125: #endif	/* __cplusplus */
cannam@125: 
cannam@125: #include <stdint.h>
cannam@125: #include <stdarg.h>
cannam@125: 
cannam@125: #define	ARRAY_LEN(x)		((int) (sizeof (x)) / (sizeof ((x) [0])))
cannam@125: #define SIGNED_SIZEOF(x)	((int64_t) (sizeof (x)))
cannam@125: #define	NOT(x)				(! (x))
cannam@125: #define	ABS(x)				((x) >= 0 ? (x) : -(x))
cannam@125: 
cannam@125: #define	PIPE_INDEX(x)	((x) + 500)
cannam@125: #define	PIPE_TEST_LEN	12345
cannam@125: 
cannam@125: 
cannam@125: [+ FOR float_type
cannam@125: +]void gen_windowed_sine_[+ (get "name") +] ([+ (get "name") +] *data, int len, double maximum) ;
cannam@125: [+ ENDFOR float_type
cannam@125: +]
cannam@125: 
cannam@125: void	create_short_sndfile (const char *filename, int format, int channels) ;
cannam@125: 
cannam@125: void	check_file_hash_or_die	(const char *filename, uint64_t target_hash, int line_num) ;
cannam@125: 
cannam@125: void	print_test_name (const char *test, const char *filename) ;
cannam@125: 
cannam@125: void	dump_data_to_file (const char *filename, const void *data, unsigned int datalen) ;
cannam@125: 
cannam@125: void	write_mono_file (const char * filename, int format, int srate, float * output, int len) ;
cannam@125: 
cannam@125: #ifdef __GNUC__
cannam@125: static inline void
cannam@125: exit_if_true (int test, const char *format, ...)
cannam@125: #if (defined (__USE_MINGW_ANSI_STDIO) && __USE_MINGW_ANSI_STDIO)
cannam@125: 	__attribute__ ((format (gnu_printf, 2, 3))) ;
cannam@125: #else
cannam@125: 	__attribute__ ((format (printf, 2, 3))) ;
cannam@125: #endif
cannam@125: #endif
cannam@125: 
cannam@125: static inline void
cannam@125: exit_if_true (int test, const char *format, ...)
cannam@125: {	if (test)
cannam@125: 	{	va_list	argptr ;
cannam@125: 		va_start (argptr, format) ;
cannam@125: 		vprintf (format, argptr) ;
cannam@125: 		va_end (argptr) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: } /* exit_if_true */
cannam@125: 
cannam@125: static inline int32_t
cannam@125: arith_shift_left (int32_t x, int shift)
cannam@125: {	return (int32_t) (((uint32_t) x) << shift) ;
cannam@125: } /* arith_shift_left */
cannam@125: 
cannam@125: /*
cannam@125: **	Functions for saving two vectors of data in an ascii text file which
cannam@125: **	can then be loaded into GNU octave for comparison.
cannam@125: */
cannam@125: 
cannam@125: [+ FOR io_type
cannam@125: +]int	oct_save_[+ (get "io_element") +]	(const [+ (get "io_element") +] *a, const [+ (get "io_element") +] *b, int len) ;
cannam@125: [+ ENDFOR io_type
cannam@125: +]
cannam@125: 
cannam@125: void	delete_file (int format, const char *filename) ;
cannam@125: 
cannam@125: void	count_open_files (void) ;
cannam@125: void	increment_open_file_count (void) ;
cannam@125: void	check_open_file_count_or_die (int lineno) ;
cannam@125: 
cannam@125: #ifdef SNDFILE_H
cannam@125: 
cannam@125: static inline void
cannam@125: sf_info_clear (SF_INFO * info)
cannam@125: {	memset (info, 0, sizeof (SF_INFO)) ;
cannam@125: } /* sf_info_clear */
cannam@125: 
cannam@125: static inline void
cannam@125: sf_info_setup (SF_INFO * info, int format, int samplerate, int channels)
cannam@125: {	sf_info_clear (info) ;
cannam@125: 
cannam@125: 	info->format = format ;
cannam@125: 	info->samplerate = samplerate ;
cannam@125: 	info->channels = channels ;
cannam@125: } /* sf_info_setup */
cannam@125: 
cannam@125: 
cannam@125: void 	dump_log_buffer (SNDFILE *file) ;
cannam@125: void 	check_log_buffer_or_die (SNDFILE *file, int line_num) ;
cannam@125: int 	string_in_log_buffer (SNDFILE *file, const char *s) ;
cannam@125: void	hexdump_file (const char * filename, sf_count_t offset, sf_count_t length) ;
cannam@125: 
cannam@125: void	test_sf_format_or_die	(const SF_INFO *info, int line_num) ;
cannam@125: 
cannam@125: SNDFILE *test_open_file_or_die
cannam@125: 			(const char *filename, int mode, SF_INFO *sfinfo, int allow_fd, int line_num) ;
cannam@125: 
cannam@125: void 	test_read_write_position_or_die
cannam@125: 			(SNDFILE *file, int line_num, int pass, sf_count_t read_pos, sf_count_t write_pos) ;
cannam@125: 
cannam@125: void	test_seek_or_die
cannam@125: 			(SNDFILE *file, sf_count_t offset, int whence, sf_count_t new_pos, int channels, int line_num) ;
cannam@125: 
cannam@125: [+ FOR read_op +]
cannam@125: [+ FOR io_type
cannam@125: +]void 	test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die
cannam@125: 			(SNDFILE *file, int pass, [+ (get "io_element") +] *test, sf_count_t [+ (get "count_name") +], int line_num) ;
cannam@125: [+ ENDFOR io_type +][+ ENDFOR read_op +]
cannam@125: 
cannam@125: void
cannam@125: test_read_raw_or_die (SNDFILE *file, int pass, void *test, sf_count_t items, int line_num) ;
cannam@125: 
cannam@125: [+ FOR write_op +]
cannam@125: [+ FOR io_type
cannam@125: +]void 	test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die
cannam@125: 			(SNDFILE *file, int pass, const [+ (get "io_element") +] *test, sf_count_t [+ (get "count_name") +], int line_num) ;
cannam@125: [+ ENDFOR io_type +][+ ENDFOR write_op +]
cannam@125: 
cannam@125: void
cannam@125: test_write_raw_or_die (SNDFILE *file, int pass, const void *test, sf_count_t items, int line_num) ;
cannam@125: 
cannam@125: [+ FOR io_type
cannam@125: +]void compare_[+ (get "io_element") +]_or_die (const [+ (get "io_element") +] *expected, const [+ (get "io_element") +] *actual, unsigned count, int line_num) ;
cannam@125: [+ ENDFOR io_type +]
cannam@125: 
cannam@125: 
cannam@125: void	gen_lowpass_signal_float (float *data, int len) ;
cannam@125: 
cannam@125: sf_count_t		file_length (const char * fname) ;
cannam@125: sf_count_t		file_length_fd (int fd) ;
cannam@125: 
cannam@125: #endif
cannam@125: 
cannam@125: #ifdef __cplusplus
cannam@125: }		/* extern "C" */
cannam@125: #endif	/* __cplusplus */
cannam@125: 
cannam@125: [+  ==  c  +]
cannam@125: 
cannam@125: #include "sfconfig.h"
cannam@125: 
cannam@125: #include <stdio.h>
cannam@125: #include <stdlib.h>
cannam@125: #include <inttypes.h>
cannam@125: 
cannam@125: #if HAVE_UNISTD_H
cannam@125: #include <unistd.h>
cannam@125: #endif
cannam@125: 
cannam@125: #if (HAVE_DECL_S_IRGRP == 0)
cannam@125: #include <sf_unistd.h>
cannam@125: #endif
cannam@125: 
cannam@125: #include <errno.h>
cannam@125: #include <string.h>
cannam@125: #include <ctype.h>
cannam@125: #include <math.h>
cannam@125: #include <fcntl.h>
cannam@125: #include <sys/stat.h>
cannam@125: 
cannam@125: #include <sndfile.h>
cannam@125: 
cannam@125: #include "utils.h"
cannam@125: 
cannam@125: #ifndef	M_PI
cannam@125: #define	M_PI		3.14159265358979323846264338
cannam@125: #endif
cannam@125: 
cannam@125: #define	LOG_BUFFER_SIZE		2048
cannam@125: 
cannam@125: /*
cannam@125: **	Neat solution to the Win32/OS2 binary file flage requirement.
cannam@125: **	If O_BINARY isn't already defined by the inclusion of the system
cannam@125: **	headers, set it to zero.
cannam@125: */
cannam@125: #ifndef O_BINARY
cannam@125: #define O_BINARY 0
cannam@125: #endif
cannam@125: 
cannam@125: [+ FOR float_type +]
cannam@125: void
cannam@125: gen_windowed_sine_[+ (get "name") +] ([+ (get "name") +] *data, int len, double maximum)
cannam@125: {	int k ;
cannam@125: 
cannam@125: 	memset (data, 0, len * sizeof ([+ (get "name") +])) ;
cannam@125: 
cannam@125: 	len = (5 * len) / 6 ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < len ; k++)
cannam@125: 	{	data [k] = sin (2.0 * k * M_PI * 1.0 / 32.0 + 0.4) ;
cannam@125: 
cannam@125: 		/* Apply Hanning Window. */
cannam@125: 		data [k] *= maximum * (0.5 - 0.5 * cos (2.0 * M_PI * k / ((len) - 1))) ;
cannam@125: 		}
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* gen_windowed_sine_[+ (get "name") +] */
cannam@125: [+ ENDFOR float_type +]
cannam@125: 
cannam@125: void
cannam@125: create_short_sndfile (const char *filename, int format, int channels)
cannam@125: {	short data [2 * 3 * 4 * 5 * 6 * 7] = { 0, } ;
cannam@125: 	SNDFILE *file ;
cannam@125: 	SF_INFO sfinfo ;
cannam@125: 
cannam@125: 	sfinfo.samplerate = 44100 ;
cannam@125: 	sfinfo.channels = channels ;
cannam@125: 	sfinfo.format = format ;
cannam@125: 
cannam@125: 	if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
cannam@125: 	{	printf ("Error (%s, %d) : sf_open failed : %s\n", __FILE__, __LINE__, sf_strerror (file)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	sf_write_short (file, data, ARRAY_LEN (data)) ;
cannam@125: 
cannam@125: 	sf_close (file) ;
cannam@125: } /* create_short_sndfile */
cannam@125: 
cannam@125: void
cannam@125: check_file_hash_or_die (const char *filename, uint64_t target_hash, int line_num)
cannam@125: {	static unsigned char buf [4096] ;
cannam@125: 	uint64_t	cksum ;
cannam@125: 	FILE 		*file ;
cannam@125: 	int			k, read_count ;
cannam@125: 
cannam@125: 	memset (buf, 0, sizeof (buf)) ;
cannam@125: 
cannam@125: 	/* The 'b' in the mode string means binary for Win32. */
cannam@125: 	if ((file = fopen (filename, "rb")) == NULL)
cannam@125: 	{	printf ("\n\nLine %d: could not open file '%s'\n\n", line_num, filename) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	cksum = 0 ;
cannam@125: 
cannam@125: 	while ((read_count = fread (buf, 1, sizeof (buf), file)))
cannam@125: 		for (k = 0 ; k < read_count ; k++)
cannam@125: 			cksum = (cksum * 511 + buf [k]) & 0xfffffffffffff ;
cannam@125: 
cannam@125: 	fclose (file) ;
cannam@125: 
cannam@125: 	if (target_hash == 0)
cannam@125: 	{	printf (" 0x%" PRIx64 "\n", cksum) ;
cannam@125: 		return ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (cksum != target_hash)
cannam@125: 	{	printf ("\n\nLine %d: incorrect hash value 0x%" PRIx64 " should be 0x%" PRIx64 ".\n\n", line_num, cksum, target_hash) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* check_file_hash_or_die */
cannam@125: 
cannam@125: void
cannam@125: print_test_name (const char *test, const char *filename)
cannam@125: {	int count ;
cannam@125: 
cannam@125: 	if (test == NULL)
cannam@125: 	{	printf (__FILE__ ": bad test of filename parameter.\n") ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (filename == NULL || strlen (filename) == 0)
cannam@125: 	{	printf ("    %-30s : ", test) ;
cannam@125: 		count = 25 ;
cannam@125: 		}
cannam@125: 	else
cannam@125: 	{	printf ("    %-30s : %s ", test, filename) ;
cannam@125: 		count = 24 - strlen (filename) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	while (count -- > 0)
cannam@125: 		putchar ('.') ;
cannam@125: 	putchar (' ') ;
cannam@125: 
cannam@125: 	fflush (stdout) ;
cannam@125: } /* print_test_name */
cannam@125: 
cannam@125: void
cannam@125: dump_data_to_file (const char *filename, const void *data, unsigned int datalen)
cannam@125: {	FILE *file ;
cannam@125: 
cannam@125: 	if ((file = fopen (filename, "wb")) == NULL)
cannam@125: 	{	printf ("\n\nLine %d : could not open file : %s\n\n", __LINE__, filename) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (fwrite (data, 1, datalen, file) != datalen)
cannam@125: 	{	printf ("\n\nLine %d : fwrite failed.\n\n", __LINE__) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	fclose (file) ;
cannam@125: 
cannam@125: } /* dump_data_to_file */
cannam@125: 
cannam@125: /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
cannam@125: */
cannam@125: 
cannam@125: static char octfilename [] = "error.dat" ;
cannam@125: 
cannam@125: [+ FOR io_type
cannam@125: +]int
cannam@125: oct_save_[+ (get "io_element") +]	(const [+ (get "io_element") +] *a, const [+ (get "io_element") +] *b, int len)
cannam@125: {	FILE 	*file ;
cannam@125: 	int		k ;
cannam@125: 
cannam@125: 	if (! (file = fopen (octfilename, "w")))
cannam@125: 		return 1 ;
cannam@125: 
cannam@125: 	fprintf (file, "# Not created by Octave\n") ;
cannam@125: 
cannam@125: 	fprintf (file, "# name: a\n") ;
cannam@125: 	fprintf (file, "# type: matrix\n") ;
cannam@125: 	fprintf (file, "# rows: %d\n", len) ;
cannam@125: 	fprintf (file, "# columns: 1\n") ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < len ; k++)
cannam@125: 		fprintf (file, [+ (get "format_str") +] "\n", a [k]) ;
cannam@125: 
cannam@125: 	fprintf (file, "# name: b\n") ;
cannam@125: 	fprintf (file, "# type: matrix\n") ;
cannam@125: 	fprintf (file, "# rows: %d\n", len) ;
cannam@125: 	fprintf (file, "# columns: 1\n") ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < len ; k++)
cannam@125: 		fprintf (file, [+ (get "format_str") +] "\n", b [k]) ;
cannam@125: 
cannam@125: 	fclose (file) ;
cannam@125: 	return 0 ;
cannam@125: } /* oct_save_[+ (get "io_element") +] */
cannam@125: [+ ENDFOR io_type
cannam@125: +]
cannam@125: 
cannam@125: void
cannam@125: check_log_buffer_or_die (SNDFILE *file, int line_num)
cannam@125: {	static char	buffer [LOG_BUFFER_SIZE] ;
cannam@125: 	int			count ;
cannam@125: 
cannam@125: 	memset (buffer, 0, sizeof (buffer)) ;
cannam@125: 
cannam@125: 	/* Get the log buffer data. */
cannam@125: 	count = sf_command	(file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
cannam@125: 
cannam@125: 	if (LOG_BUFFER_SIZE - count < 2)
cannam@125: 	{	printf ("\n\nLine %d : Possible long log buffer.\n", line_num) ;
cannam@125: 		exit (1) ;
cannam@125: 		}
cannam@125: 
cannam@125: 	/* Look for "Should" */
cannam@125: 	if (strstr (buffer, "ould"))
cannam@125: 	{	printf ("\n\nLine %d : Log buffer contains `ould'. Dumping.\n", line_num) ;
cannam@125: 		puts (buffer) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	/* Look for "**" */
cannam@125: 	if (strstr (buffer, "*"))
cannam@125: 	{	printf ("\n\nLine %d : Log buffer contains `*'. Dumping.\n", line_num) ;
cannam@125: 		puts (buffer) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	/* Look for "Should" */
cannam@125: 	if (strstr (buffer, "nknown marker"))
cannam@125: 	{	printf ("\n\nLine %d : Log buffer contains `nknown marker'. Dumping.\n", line_num) ;
cannam@125: 		puts (buffer) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* check_log_buffer_or_die */
cannam@125: 
cannam@125: int
cannam@125: string_in_log_buffer (SNDFILE *file, const char *s)
cannam@125: {	static char	buffer [LOG_BUFFER_SIZE] ;
cannam@125: 	int			count ;
cannam@125: 
cannam@125: 	memset (buffer, 0, sizeof (buffer)) ;
cannam@125: 
cannam@125: 	/* Get the log buffer data. */
cannam@125: 	count = sf_command	(file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
cannam@125: 
cannam@125: 	if (LOG_BUFFER_SIZE - count < 2)
cannam@125: 	{	printf ("Possible long log buffer.\n") ;
cannam@125: 		exit (1) ;
cannam@125: 		}
cannam@125: 
cannam@125: 	/* Look for string */
cannam@125: 	return strstr (buffer, s) ? SF_TRUE : SF_FALSE ;
cannam@125: } /* string_in_log_buffer */
cannam@125: 
cannam@125: void
cannam@125: hexdump_file (const char * filename, sf_count_t offset, sf_count_t length)
cannam@125: {
cannam@125: 	FILE * file ;
cannam@125: 	char buffer [16] ;
cannam@125: 	int k, m, ch, readcount ;
cannam@125: 
cannam@125: 	if (length > 1000000)
cannam@125: 	{	printf ("\n\nError : length (%" PRId64 ") too long.\n\n", offset) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if ((file = fopen (filename, "r")) == NULL)
cannam@125: 	{	printf ("\n\nError : hexdump_file (%s) could not open file for read.\n\n", filename) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (fseek (file, offset, SEEK_SET) != 0)
cannam@125: 	{	printf ("\n\nError : fseek(file, %" PRId64 ", SEEK_SET) failed : %s\n\n", offset, strerror (errno)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	puts ("\n\n") ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < length ; k+= sizeof (buffer))
cannam@125: 	{	readcount = fread (buffer, 1, sizeof (buffer), file) ;
cannam@125: 
cannam@125: 		printf ("%08" PRIx64 " : ", offset + k) ;
cannam@125: 
cannam@125: 		for (m = 0 ; m < readcount ; m++)
cannam@125: 			printf ("%02x ", buffer [m] & 0xFF) ;
cannam@125: 
cannam@125: 		for (m = readcount ; m < SIGNED_SIZEOF (buffer) ; m++)
cannam@125: 			printf ("   ") ;
cannam@125: 
cannam@125: 		printf ("  ") ;
cannam@125: 		for (m = 0 ; m < readcount ; m++)
cannam@125: 		{	ch = isprint (buffer [m]) ? buffer [m] : '.' ;
cannam@125: 			putchar (ch) ;
cannam@125: 			} ;
cannam@125: 
cannam@125: 		if (readcount < SIGNED_SIZEOF (buffer))
cannam@125: 			break ;
cannam@125: 
cannam@125: 		putchar ('\n') ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	puts ("\n") ;
cannam@125: 
cannam@125: 	fclose (file) ;
cannam@125: } /* hexdump_file */
cannam@125: 
cannam@125: void
cannam@125: dump_log_buffer (SNDFILE *file)
cannam@125: {	static char	buffer [LOG_BUFFER_SIZE] ;
cannam@125: 
cannam@125: 	memset (buffer, 0, sizeof (buffer)) ;
cannam@125: 
cannam@125: 	/* Get the log buffer data. */
cannam@125: 	sf_command	(file, SFC_GET_LOG_INFO, buffer, LOG_BUFFER_SIZE) ;
cannam@125: 
cannam@125: 	if (strlen (buffer) < 1)
cannam@125: 		puts ("Log buffer empty.\n") ;
cannam@125: 	else
cannam@125: 		puts (buffer) ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* dump_log_buffer */
cannam@125: 
cannam@125: void
cannam@125: test_sf_format_or_die (const SF_INFO *info, int line_num)
cannam@125: {	int res ;
cannam@125: 
cannam@125: 	if ((res = sf_format_check (info)) != 1)
cannam@125: 	{	printf ("\n\nLine %d : sf_format_check returned error (%d)\n\n", line_num,res) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* test_sf_format_or_die */
cannam@125: 
cannam@125: SNDFILE *
cannam@125: test_open_file_or_die (const char *filename, int mode, SF_INFO *sfinfo, int allow_fd, int line_num)
cannam@125: {	static int count = 0 ;
cannam@125: 
cannam@125: 	SNDFILE *file ;
cannam@125: 	const char *modestr, *func_name ;
cannam@125: 	int oflags = 0, omode = 0, err ;
cannam@125: 
cannam@125: 	/*
cannam@125: 	** Need to test both sf_open() and sf_open_fd().
cannam@125: 	** Do so alternately.
cannam@125: 	*/
cannam@125: 	switch (mode)
cannam@125: 	{	case SFM_READ :
cannam@125: 				modestr = "SFM_READ" ;
cannam@125: 				oflags = O_RDONLY | O_BINARY ;
cannam@125: 				omode = 0 ;
cannam@125: 				break ;
cannam@125: 
cannam@125: 		case SFM_WRITE :
cannam@125: 				modestr = "SFM_WRITE" ;
cannam@125: 				oflags = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY ;
cannam@125: 				omode = S_IRUSR | S_IWUSR | S_IRGRP ;
cannam@125: 				break ;
cannam@125: 
cannam@125: 		case SFM_RDWR :
cannam@125: 				modestr = "SFM_RDWR" ;
cannam@125: 				oflags = O_RDWR | O_CREAT | O_BINARY ;
cannam@125: 				omode = S_IRUSR | S_IWUSR | S_IRGRP ;
cannam@125: 				break ;
cannam@125: 		default :
cannam@125: 				printf ("\n\nLine %d: Bad mode.\n", line_num) ;
cannam@125: 				fflush (stdout) ;
cannam@125: 				exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (OS_IS_WIN32)
cannam@125: 	{	/* Windows does not understand and ignores the S_IRGRP flag, but Wine
cannam@125: 		** gives a run time warning message, so just clear it.
cannam@125: 		*/
cannam@125: 		omode &= ~S_IRGRP ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (allow_fd && ((++count) & 1) == 1)
cannam@125: 	{	int fd ;
cannam@125: 
cannam@125: 		/* Only use the three argument open() function if omode != 0. */
cannam@125: 		fd = (omode == 0) ? open (filename, oflags) : open (filename, oflags, omode) ;
cannam@125: 
cannam@125: 		if (fd < 0)
cannam@125: 		{	printf ("\n\n%s : open failed : %s\n", __func__, strerror (errno)) ;
cannam@125: 			exit (1) ;
cannam@125: 			} ;
cannam@125: 
cannam@125: 		func_name = "sf_open_fd" ;
cannam@125: 		file = sf_open_fd (fd, mode, sfinfo, SF_TRUE) ;
cannam@125: 		}
cannam@125: 	else
cannam@125: 	{	func_name = "sf_open" ;
cannam@125: 		file = sf_open (filename, mode, sfinfo) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	if (file == NULL)
cannam@125: 	{	printf ("\n\nLine %d: %s (%s) failed : %s\n\n", line_num, func_name, modestr, sf_strerror (NULL)) ;
cannam@125: 		dump_log_buffer (file) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	err = sf_error (file) ;
cannam@125: 	if (err != SF_ERR_NO_ERROR)
cannam@125: 	{	printf ("\n\nLine %d : sf_error : %s\n\n", line_num, sf_error_number (err)) ;
cannam@125: 		dump_log_buffer (file) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return file ;
cannam@125: } /* test_open_file_or_die */
cannam@125: 
cannam@125: void
cannam@125: test_read_write_position_or_die (SNDFILE *file, int line_num, int pass, sf_count_t read_pos, sf_count_t write_pos)
cannam@125: {	sf_count_t pos ;
cannam@125: 
cannam@125: 	/* Check the current read position. */
cannam@125: 	if (read_pos >= 0 && (pos = sf_seek (file, 0, SEEK_CUR | SFM_READ)) != read_pos)
cannam@125: 	{	printf ("\n\nLine %d ", line_num) ;
cannam@125: 		if (pass > 0)
cannam@125: 			printf ("(pass %d): ", pass) ;
cannam@125: 		printf ("Read position (%" PRId64 ") should be %" PRId64 ".\n", pos, read_pos) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	/* Check the current write position. */
cannam@125: 	if (write_pos >= 0 && (pos = sf_seek (file, 0, SEEK_CUR | SFM_WRITE)) != write_pos)
cannam@125: 	{	printf ("\n\nLine %d", line_num) ;
cannam@125: 		if (pass > 0)
cannam@125: 			printf (" (pass %d)", pass) ;
cannam@125: 		printf (" : Write position (%" PRId64 ") should be %" PRId64 ".\n", pos, write_pos) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* test_read_write_position */
cannam@125: 
cannam@125: void
cannam@125: test_seek_or_die (SNDFILE *file, sf_count_t offset, int whence, sf_count_t new_pos, int channels, int line_num)
cannam@125: {	sf_count_t	position ;
cannam@125: 	const char	*channel_name, *whence_name ;
cannam@125: 
cannam@125: 	switch (whence)
cannam@125: 	{	case SEEK_SET :
cannam@125: 				whence_name = "SEEK_SET" ;
cannam@125: 				break ;
cannam@125: 		case SEEK_CUR :
cannam@125: 				whence_name = "SEEK_CUR" ;
cannam@125: 				break ;
cannam@125: 		case SEEK_END :
cannam@125: 				whence_name = "SEEK_END" ;
cannam@125: 				break ;
cannam@125: 
cannam@125: 		/* SFM_READ */
cannam@125: 		case SEEK_SET | SFM_READ :
cannam@125: 				whence_name = "SFM_READ | SEEK_SET" ;
cannam@125: 				break ;
cannam@125: 		case SEEK_CUR | SFM_READ :
cannam@125: 				whence_name = "SFM_READ | SEEK_CUR" ;
cannam@125: 				break ;
cannam@125: 		case SEEK_END | SFM_READ :
cannam@125: 				whence_name = "SFM_READ | SEEK_END" ;
cannam@125: 				break ;
cannam@125: 
cannam@125: 		/* SFM_WRITE */
cannam@125: 		case SEEK_SET | SFM_WRITE :
cannam@125: 				whence_name = "SFM_WRITE | SEEK_SET" ;
cannam@125: 				break ;
cannam@125: 		case SEEK_CUR | SFM_WRITE :
cannam@125: 				whence_name = "SFM_WRITE | SEEK_CUR" ;
cannam@125: 				break ;
cannam@125: 		case SEEK_END | SFM_WRITE :
cannam@125: 				whence_name = "SFM_WRITE | SEEK_END" ;
cannam@125: 				break ;
cannam@125: 
cannam@125: 		default :
cannam@125: 				printf ("\n\nLine %d: bad whence parameter.\n", line_num) ;
cannam@125: 				exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	channel_name = (channels == 1) ? "Mono" : "Stereo" ;
cannam@125: 
cannam@125: 	if ((position = sf_seek (file, offset, whence)) != new_pos)
cannam@125: 	{	printf ("\n\nLine %d : %s : sf_seek (file, %" PRId64 ", %s) returned %" PRId64 " (should be %" PRId64 ").\n\n",
cannam@125: 					line_num, channel_name, offset, whence_name, position, new_pos) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: } /* test_seek_or_die */
cannam@125: 
cannam@125: [+ FOR read_op +]
cannam@125: [+ FOR io_type +]
cannam@125: void
cannam@125: 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)
cannam@125: {	sf_count_t count ;
cannam@125: 
cannam@125: 	if ((count = sf_[+ (get "op_element") +]_[+ (get "io_element") +] (file, test, [+ (get "count_name") +])) != [+ (get "count_name") +])
cannam@125: 	{	printf ("\n\nLine %d", line_num) ;
cannam@125: 		if (pass > 0)
cannam@125: 			printf (" (pass %d)", pass) ;
cannam@125: 		printf (" : sf_[+ (get "op_element") +]_[+ (get "io_element") +] failed with short [+ (get "op_element") +] (%" PRId64 " => %" PRId64 ").\n",
cannam@125: 						[+ (get "count_name") +], count) ;
cannam@125: 		fflush (stdout) ;
cannam@125: 		puts (sf_strerror (file)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die */
cannam@125: [+ ENDFOR io_type +][+ ENDFOR read_op +]
cannam@125: 
cannam@125: void
cannam@125: test_read_raw_or_die (SNDFILE *file, int pass, void *test, sf_count_t items, int line_num)
cannam@125: {	sf_count_t count ;
cannam@125: 
cannam@125: 	if ((count = sf_read_raw (file, test, items)) != items)
cannam@125: 	{	printf ("\n\nLine %d", line_num) ;
cannam@125: 		if (pass > 0)
cannam@125: 			printf (" (pass %d)", pass) ;
cannam@125: 		printf (" : sf_read_raw failed with short read (%" PRId64 " => %" PRId64 ").\n", items, count) ;
cannam@125: 		fflush (stdout) ;
cannam@125: 		puts (sf_strerror (file)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* test_read_raw_or_die */
cannam@125: 
cannam@125: [+ FOR write_op +]
cannam@125: [+ FOR io_type +]
cannam@125: void
cannam@125: 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)
cannam@125: {	sf_count_t count ;
cannam@125: 
cannam@125: 	if ((count = sf_[+ (get "op_element") +]_[+ (get "io_element") +] (file, test, [+ (get "count_name") +])) != [+ (get "count_name") +])
cannam@125: 	{	printf ("\n\nLine %d", line_num) ;
cannam@125: 		if (pass > 0)
cannam@125: 			printf (" (pass %d)", pass) ;
cannam@125: 		printf (" : sf_[+ (get "op_element") +]_[+ (get "io_element") +] failed with short [+ (get "op_element") +] (%" PRId64 " => %" PRId64 ").\n",
cannam@125: 						[+ (get "count_name") +], count) ;
cannam@125: 		fflush (stdout) ;
cannam@125: 		puts (sf_strerror (file)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* test_[+ (get "op_element") +]_[+ (get "io_element") +]_or_die */
cannam@125: [+ ENDFOR io_type +][+ ENDFOR write_op +]
cannam@125: 
cannam@125: void
cannam@125: test_write_raw_or_die (SNDFILE *file, int pass, const void *test, sf_count_t items, int line_num)
cannam@125: {	sf_count_t count ;
cannam@125: 
cannam@125: 	if ((count = sf_write_raw (file, test, items)) != items)
cannam@125: 	{	printf ("\n\nLine %d", line_num) ;
cannam@125: 		if (pass > 0)
cannam@125: 			printf (" (pass %d)", pass) ;
cannam@125: 		printf (" : sf_write_raw failed with short write (%" PRId64 " => %" PRId64 ").\n", items, count) ;
cannam@125: 		fflush (stdout) ;
cannam@125: 		puts (sf_strerror (file)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* test_write_raw_or_die */
cannam@125: 
cannam@125: 
cannam@125: [+ FOR io_type
cannam@125: +]void
cannam@125: compare_[+ (get "io_element") +]_or_die (const [+ (get "io_element") +] *expected, const [+ (get "io_element") +] *actual, unsigned count, int line_num)
cannam@125: {
cannam@125: 	unsigned k ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < count ; k++)
cannam@125: 		if (expected [k] != actual [k])
cannam@125: 		{	printf ("\n\nLine %d : Error at index %d, got " [+ (get "format_str") +] ", should be " [+ (get "format_str") +] ".\n\n", line_num, k, actual [k], expected [k]) ;
cannam@125: 			exit (1) ;
cannam@125: 			} ;
cannam@125: 
cannam@125: 	return ;
cannam@125: } /* compare_[+ (get "io_element") +]_or_die */
cannam@125: [+ ENDFOR io_type +]
cannam@125: 
cannam@125: 
cannam@125: void
cannam@125: delete_file (int format, const char *filename)
cannam@125: {	char rsrc_name [512], *fname ;
cannam@125: 
cannam@125: 	unlink (filename) ;
cannam@125: 
cannam@125: 	if ((format & SF_FORMAT_TYPEMASK) != SF_FORMAT_SD2)
cannam@125: 		return ;
cannam@125: 
cannam@125: 	/*
cannam@125: 	** Now try for a resource fork stored as a separate file.
cannam@125: 	** Grab the un-adulterated filename again.
cannam@125: 	*/
cannam@125: 	snprintf (rsrc_name, sizeof (rsrc_name), "%s", filename) ;
cannam@125: 
cannam@125: 	if ((fname = strrchr (rsrc_name, '/')) != NULL)
cannam@125: 		fname ++ ;
cannam@125: 	else if ((fname = strrchr (rsrc_name, '\\')) != NULL)
cannam@125: 		fname ++ ;
cannam@125: 	else
cannam@125: 		fname = rsrc_name ;
cannam@125: 
cannam@125: 	memmove (fname + 2, fname, strlen (fname) + 1) ;
cannam@125: 	fname [0] = '.' ;
cannam@125: 	fname [1] = '_' ;
cannam@125: 
cannam@125: 	unlink (rsrc_name) ;
cannam@125: } /* delete_file */
cannam@125: 
cannam@125: static int allowed_open_files = -1 ;
cannam@125: 
cannam@125: void
cannam@125: count_open_files (void)
cannam@125: {
cannam@125: #if OS_IS_WIN32
cannam@125: 	return ;
cannam@125: #else
cannam@125: 	int k, count = 0 ;
cannam@125: 	struct stat statbuf ;
cannam@125: 
cannam@125: 	if (allowed_open_files > 0)
cannam@125: 		return ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < 1024 ; k++)
cannam@125: 		if (fstat (k, &statbuf) == 0)
cannam@125: 			count ++ ;
cannam@125: 
cannam@125: 	allowed_open_files = count ;
cannam@125: #endif
cannam@125: } /* count_open_files */
cannam@125: 
cannam@125: void
cannam@125: increment_open_file_count (void)
cannam@125: {	allowed_open_files ++ ;
cannam@125: } /* increment_open_file_count */
cannam@125: 
cannam@125: void
cannam@125: check_open_file_count_or_die (int lineno)
cannam@125: {
cannam@125: #if OS_IS_WIN32
cannam@125: 	(void) lineno ;
cannam@125: 	return ;
cannam@125: #else
cannam@125: 	int k, count = 0 ;
cannam@125: 	struct stat statbuf ;
cannam@125: 
cannam@125: 	if (allowed_open_files < 0)
cannam@125: 		count_open_files () ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < 1024 ; k++)
cannam@125: 		if (fstat (k, &statbuf) == 0)
cannam@125: 			count ++ ;
cannam@125: 
cannam@125: 	if (count > allowed_open_files)
cannam@125: 	{	printf ("\nLine %d : number of open files (%d) > allowed (%d).\n\n", lineno, count, allowed_open_files) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: #endif
cannam@125: } /* check_open_file_count_or_die */
cannam@125: 
cannam@125: void
cannam@125: write_mono_file (const char * filename, int format, int srate, float * output, int len)
cannam@125: {	SNDFILE * file ;
cannam@125: 	SF_INFO sfinfo ;
cannam@125: 
cannam@125: 	memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@125: 
cannam@125: 	sfinfo.samplerate = srate ;
cannam@125: 	sfinfo.channels = 1 ;
cannam@125: 	sfinfo.format = format ;
cannam@125: 
cannam@125: 	if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
cannam@125: 	{	printf ("sf_open (%s) : %s\n", filename, sf_strerror (NULL)) ;
cannam@125: 		exit (1) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: 	sf_write_float (file, output, len) ;
cannam@125: 
cannam@125: 	sf_close (file) ;
cannam@125: } /* write_mono_file */
cannam@125: 
cannam@125: void
cannam@125: gen_lowpass_signal_float (float *data, int len)
cannam@125: {	int64_t value = 0x1243456 ;
cannam@125: 	double sample, last_val = 0.0 ;
cannam@125: 	int k ;
cannam@125: 
cannam@125: 	for (k = 0 ; k < len ; k++)
cannam@125: 	{	/* Not a crypto quality RNG. */
cannam@125: 		value = (11117 * value + 211231) & 0xffffffff ;
cannam@125: 		value = (11117 * value + 211231) & 0xffffffff ;
cannam@125: 		value = (11117 * value + 211231) & 0xffffffff ;
cannam@125: 
cannam@125: 		sample = value / (0x7fffffff * 1.000001) ;
cannam@125: 		sample = 0.2 * sample - 0.9 * last_val ;
cannam@125: 
cannam@125: 		last_val = sample ;
cannam@125: 
cannam@125: 		data [k] = 0.5 * (sample + sin (2.0 * k * M_PI * 1.0 / 32.0)) ;
cannam@125: 		} ;
cannam@125: 
cannam@125: } /* gen_lowpass_signal_float */
cannam@125: 
cannam@125: 
cannam@125: /*
cannam@125: **	Windows is fucked.
cannam@125: **	If a file is opened R/W and data is written to it, then fstat will return
cannam@125: **	the correct file length, but stat will return zero.
cannam@125: */
cannam@125: 
cannam@125: sf_count_t
cannam@125: file_length (const char * fname)
cannam@125: {	struct stat data ;
cannam@125: 
cannam@125: 	if (stat (fname, &data) != 0)
cannam@125: 		return 0 ;
cannam@125: 
cannam@125: 	return (sf_count_t) data.st_size ;
cannam@125: } /* file_length */
cannam@125: 
cannam@125: sf_count_t
cannam@125: file_length_fd (int fd)
cannam@125: {	struct stat data ;
cannam@125: 
cannam@125: 	memset (&data, 0, sizeof (data)) ;
cannam@125: 	if (fstat (fd, &data) != 0)
cannam@125: 		return 0 ;
cannam@125: 
cannam@125: 	return (sf_count_t) data.st_size ;
cannam@125: } /* file_length_fd */
cannam@125: 
cannam@125: 
cannam@125: [+ ESAC +]
cannam@125: