static void
header_shrink_test (const char *filename, int filetype)
{ SNDFILE *outfile, *infile ;
SF_INFO sfinfo ;
sf_count_t frames ;
float buffer [8], bufferin [8] ;
print_test_name ("header_shrink_test", filename) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = filetype | SF_FORMAT_FLOAT ;
sfinfo.channels = 1 ;
memset (buffer, 0xA0, sizeof (buffer)) ;
/* Now write some frames. */
frames = ARRAY_LEN (buffer) / sfinfo.channels ;
/* Test the file with extra header data. */
outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
sf_command (outfile, SFC_SET_ADD_PEAK_CHUNK, NULL, SF_TRUE) ;
sf_command (outfile, SFC_UPDATE_HEADER_NOW, NULL, SF_FALSE) ;
sf_command (outfile, SFC_SET_ADD_PEAK_CHUNK, NULL, SF_FALSE) ;
test_writef_float_or_die (outfile, 0, buffer, frames, __LINE__) ;
sf_close (outfile) ;
/* Open again for read. */
infile = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
test_readf_float_or_die (infile, 0, bufferin, frames, __LINE__) ;
sf_close (infile) ;
compare_float_or_die (buffer, bufferin, frames, __LINE__) ;
unlink (filename) ;
puts ("ok") ;
return ;
} /* header_shrink_test */
void test_puts(void)
{
int orignal;
int homemade;
print_test_name("------------PUTS------------");
printf("\n\n");
test_simple();
printf("s: ");
printf(STRING);
printf("\n");
printf("Original: ");
orignal = puts(STRING);
fflush(stdout);
printf("Returned: ");
ft_putnbr(orignal);
printf("\n");
printf("Homemade: ");
fflush(stdout);
homemade = ft_puts(STRING);
printf("Returned: ");
ft_putnbr(homemade);
ok();
printf("s: ");
printf("NULL");
printf("\n");
printf("Original: ");
orignal = puts(STRINGNULL);
fflush(stdout);
printf("Returned: ");
ft_putnbr(orignal);
printf("\n");
printf("Homemade: ");
fflush(stdout);
homemade = ft_puts(STRINGNULL);
printf("Returned: ");
ft_putnbr(homemade);
ok();
printf("\n");
}
static void test_strcat(void)
{
int test[1], ctrl[1];
char *dst1, *dst2, src[]="test";
char tab1[100];
char tab2[100];
char *p1;
char *p2;
print_test_name("------------STRCAT------------");
printf("\n\n");
test_simple();
printf("s1: ");
printf("%s\n", STR);
printf("s2: ");
printf("%s\n", STR2);
printf("Original: ");
strcpy(tab1, STR);
p1 = strcpy(tab1, STR2);
printf("%s\n", p1);
printf("Homemade: ");
strcpy(tab1, STR);
p2 = ft_strcpy(tab2, STR2);
printf("%s", p2);
ok();
if (!(dst1 = malloc(sizeof(*dst1) * (strlen(src) + 1) * 3)) || !(dst2 = malloc(sizeof(*dst2) * (strlen(src) + 1) * 3)))
{
perror("malloc() failed");
exit(EXIT_FAILURE);
}
strcpy(dst1, src);
strcpy(dst2, src);
ctrl[0] = 0;
test[0] = cmp(strcat(dst1, src), ft_strcat(dst2, src));
free(dst1);
free(dst2);
test_hard();
print_test_results(test, ctrl, 1, NULL);
printf("\n");
}
int
main (void)
{ SNDFILE *sndfile ;
SF_INFO sfinfo ;
FILE *bad_file ;
const char *bad_wav = "bad_wav.wav" ;
const char bad_data [] = "RIFF WAVEfmt " ;
print_test_name ("open_fail_test", bad_wav) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sndfile = sf_open ("let's hope this file doesn't exist", SFM_READ, &sfinfo) ;
if (sndfile)
{ printf ("Line %d: should not have received a valid SNDFILE* pointer.\n", __LINE__) ;
exit (1) ;
} ;
if ((bad_file = fopen (bad_wav, "w")) == NULL)
{ printf ("Line %d: fopen returned NULL.\n", __LINE__) ;
exit (1) ;
} ;
fwrite (bad_data, sizeof (bad_data), 1, bad_file) ;
fclose (bad_file) ;
sndfile = sf_open (bad_wav, SFM_READ, &sfinfo) ;
if (sndfile)
{ printf ("Line %d: should not have received a valid SNDFILE* pointer.\n", __LINE__) ;
exit (1) ;
} ;
unlink (bad_wav) ;
puts ("ok") ;
return 0 ;
} /* main */
static void
stdio_test (const char *filetype)
{ static char buffer [256] ;
int file_size, retval ;
print_test_name ("stdio_test", filetype) ;
snprintf (buffer, sizeof (buffer), "./stdout_test %s > stdio.%s", filetype, filetype) ;
if ((retval = system (buffer)))
{ retval = WIFEXITED (retval) ? WEXITSTATUS (retval) : 1 ;
printf ("%s : %s", buffer, (strerror (retval))) ;
exit (1) ;
} ;
snprintf (buffer, sizeof (buffer), "stdio.%s", filetype) ;
if ((file_size = file_length (buffer)) < PIPE_TEST_LEN)
{ printf ("\n Error : test file '%s' too small (%d).\n\n", buffer, file_size) ;
exit (1) ;
} ;
snprintf (buffer, sizeof (buffer), "./stdin_test %s < stdio.%s", filetype, filetype) ;
if ((retval = system (buffer)))
{ retval = WIFEXITED (retval) ? WEXITSTATUS (retval) : 1 ;
printf ("%s : %s", buffer, (strerror (retval))) ;
exit (1) ;
} ;
snprintf (buffer, sizeof (buffer), "rm stdio.%s", filetype) ;
if ((retval = system (buffer)))
{ retval = WIFEXITED (retval) ? WEXITSTATUS (retval) : 1 ;
printf ("%s : %s", buffer, (strerror (retval))) ;
exit (1) ;
} ;
puts ("ok") ;
return ;
} /* stdio_test */
static void test_strcpy(void)
{
int test[2], ctrl[2];
char *dst1, *dst2, src1[]="\001test string\200", src2[]="test";
char tab1[100];
char tab2[100];
char *p1;
char *p2;
print_test_name("------------STRCPY------------");
printf("\n\n");
test_simple();
printf("s: ");
printf("%s\n", STRING);
printf("Original: ");
p1 = strcpy(tab1, STRING);
printf("%s\n", p1);
printf("Homemade: ");
p2 = ft_strcpy(tab2, STRING);
printf("%s", p2);
ok();
init(ctrl, 2, 0);
init(test, 2, 1);
if (!(dst1 = malloc(strlen(src1) + 1)) || !(dst2 = malloc(strlen(src1) + 1)))
{
perror("malloc() failed");
exit(EXIT_FAILURE);
}
test[0] = cmp(strcpy(dst1, src1), ft_strcpy(dst2, src1));
ft_strcpy(dst1, src2);
if (!dst1[strlen(src2)])
test[1] = 0;
free(dst1);
free(dst2);
test_hard();
print_test_results(test, ctrl, 2, NULL);
printf("\n");
}
static void
update_header_test (const char *filename, int typemajor)
{
print_test_name ("update_header_test", filename) ;
#if 0 /*-(OS_IS_WIN32 == 0)-*/
if (typemajor == SF_FORMAT_PAF)
{ /*
** I think this is a bug in the win32 file I/O code in src/file_io.c.
** I didn't write that code and I don't have the time to debug and
** fix it. Patches will gladly be accepted. Erik
*/
puts ("doesn't work on win32") ;
return ;
} ;
#endif
update_header_sub (filename, typemajor, SFM_WRITE) ;
update_header_sub (filename, typemajor, SFM_RDWR) ;
unlink (filename) ;
puts ("ok") ;
} /* update_header_test */
static void
zero_data_test (const char *filename, int format)
{ SNDFILE *file ;
SF_INFO sfinfo ;
int frames ;
switch (format & SF_FORMAT_TYPEMASK)
{ case SF_FORMAT_OGG :
if (HAVE_EXTERNAL_LIBS == 0)
return ;
break ;
default :
break ;
} ;
print_test_name ("zero_data_test", filename) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = format ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
frames = BUFFER_LEN / sfinfo.channels ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
sf_close (file) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
} /* zero_data_test */
static void
broadcast_rdwr_test (const char *filename, int filetype)
{ SF_BROADCAST_INFO binfo ;
SNDFILE *file ;
SF_INFO sfinfo ;
sf_count_t frames ;
print_test_name (__func__, filename) ;
create_short_sndfile (filename, filetype, 2) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
memset (&binfo, 0, sizeof (binfo)) ;
snprintf (binfo.description, sizeof (binfo.description), "Test description") ;
snprintf (binfo.originator, sizeof (binfo.originator), "Test originator") ;
snprintf (binfo.originator_reference, sizeof (binfo.originator_reference), "%08x-%08x", (unsigned int) time (NULL), (unsigned int) (~ time (NULL))) ;
snprintf (binfo.origination_date, sizeof (binfo.origination_date), "%d/%02d/%02d", 2006, 3, 30) ;
snprintf (binfo.origination_time, sizeof (binfo.origination_time), "%02d:%02d:%02d", 20, 27, 0) ;
snprintf (binfo.umid, sizeof (binfo.umid), "Some umid") ;
binfo.coding_history_size = 0 ;
file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
frames = sfinfo.frames ;
if (sf_command (file, SFC_SET_BROADCAST_INFO, &binfo, sizeof (binfo)) != SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) should have failed but didn't.\n\n", __LINE__) ;
exit (1) ;
} ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
sf_close (file) ;
exit_if_true (frames != sfinfo.frames, "\n\nLine %d : Frame count %lld should be %lld.\n", __LINE__, sfinfo.frames, frames) ;
unlink (filename) ;
puts ("ok") ;
} /* broadcast_rdwr_test */
static void
bad_raw_test (void)
{ FILE *textfile ;
SNDFILE *file ;
SF_INFO sfinfo ;
const char *errorstr, *filename = "bad.raw" ;
print_test_name ("bad_raw_test", filename) ;
if ((textfile = fopen (filename, "w")) == NULL)
{ printf ("\n\nLine %d : not able to open text file for write.\n", __LINE__) ;
exit (1) ;
} ;
fprintf (textfile, "This is not a valid file.\n") ;
fclose (textfile) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = SF_FORMAT_RAW | 0xABCD ;
sfinfo.channels = 1 ;
if ((file = sf_open (filename, SFM_READ, &sfinfo)) != NULL)
{ printf ("\n\nLine %d : Error, file should not have opened.\n", __LINE__ - 1) ;
exit (1) ;
} ;
errorstr = sf_strerror (file) ;
if (strstr (errorstr, "Bad format field in SF_INFO struct") == NULL)
{ printf ("\n\nLine %d : Error bad error string : %s.\n", __LINE__ - 1, errorstr) ;
exit (1) ;
} ;
unlink (filename) ;
puts ("ok") ;
} /* bad_raw_test */
static void
useek_pipe_rw_test (int filetype, const char *ext)
{ SF_INFO sfinfo_write ;
SF_INFO sfinfo_read ;
print_test_name ("useek_pipe_rw_test", ext) ;
/*
** Setup the INFO structures for the filetype we will be
** working with.
*/
sfinfo_write.format = filetype | SF_FORMAT_PCM_16 ;
sfinfo_write.channels = 1 ;
sfinfo_write.samplerate = 44100 ;
sfinfo_read.format = 0 ;
if (filetype == SF_FORMAT_RAW)
{ sfinfo_read.format = filetype | SF_FORMAT_PCM_16 ;
sfinfo_read.channels = 1 ;
sfinfo_read.samplerate = 44100 ;
} ;
useek_pipe_rw_short (ext, &sfinfo_write, &sfinfo_read) ;
sfinfo_read.format = sfinfo_write.format = filetype | SF_FORMAT_FLOAT ;
if (sf_format_check (&sfinfo_read) != 0)
useek_pipe_rw_float (ext, &sfinfo_write, &sfinfo_read) ;
sfinfo_read.format = sfinfo_write.format = filetype | SF_FORMAT_DOUBLE ;
if (sf_format_check (&sfinfo_read) != 0)
useek_pipe_rw_double (ext, &sfinfo_write, &sfinfo_read) ;
puts ("ok") ;
return ;
} /* useek_pipe_rw_test */
static void
subtype_format_test (void)
{ SF_FORMAT_INFO info ;
int have_vorbis = 0 ;
int s, subtype_count ;
print_test_name (__func__, NULL) ;
sf_command (NULL, SFC_GET_FORMAT_SUBTYPE_COUNT, &subtype_count, sizeof (int)) ;
for (s = 0 ; s < subtype_count ; s++)
{ info.format = s ;
sf_command (NULL, SFC_GET_FORMAT_SUBTYPE, &info, sizeof (info)) ;
have_vorbis = info.format == SF_FORMAT_VORBIS ? 1 : have_vorbis ;
} ;
if (HAVE_EXTERNAL_LIBS)
exit_if_true (have_vorbis == 0, "\n\nLine %d : Ogg/Vorbis should be available.\n\n", __LINE__) ;
else
exit_if_true (have_vorbis, "\n\nLine %d : Ogg/Vorbis should not be available.\n\n", __LINE__) ;
puts ("ok") ;
} /* subtype_format_test */
static void
largefile_test (int filetype, const char * filename)
{ static float data [BUFFER_LEN] ;
SNDFILE *file ;
SF_INFO sfinfo ;
int k ;
print_test_name ("largefile_test", filename) ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 2 ;
sfinfo.frames = 0 ;
sfinfo.format = (filetype | SF_FORMAT_PCM_32) ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
for (k = 0 ; k < BUFFER_COUNT ; k++)
test_write_float_or_die (file, k, data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if ((sfinfo.frames * sfinfo.channels) / BUFFER_LEN != BUFFER_COUNT)
{ printf ("\n\nLine %d : bad frame count.\n", __LINE__) ;
exit (1) ;
} ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
return ;
} /* largefile_test */
void
test_double_convert (void)
{ static double data [] =
{ 0.0, 1.0, -1.0, 1.0 * M_PI, -1.0 * M_PI,
1e9, -1e9, 1e-9, -1e-9, 1e-10, -1e-10,
1e-19, -1e-19, 1e19, -1e19, 1e-20, -1e-20,
} ;
int k ;
print_test_name (__func__) ;
for (k = 0 ; k < ARRAY_LEN (data) ; k++)
{ unsigned char bytes [8] ;
double test ;
double64_le_write (data [k], bytes) ;
test = double64_le_read (bytes) ;
if (fabs (data [k] - test) > 1e-20)
{ printf ("\n\nLine %d : Test %d, little endian error %.15g -> %.15g.\n\n", __LINE__, k, data [k], test) ;
exit (1) ;
} ;
double64_be_write (data [k], bytes) ;
test = double64_be_read (bytes) ;
if (fabs (data [k] - test) > 1e-20)
{ printf ("\n\nLine %d : Test %d, big endian error %.15g -> %.15g.\n\n", __LINE__, k, data [k], test) ;
exit (1) ;
} ;
} ;
puts ("ok") ;
} /* test_double_convert */
static void
pipe_read_test (int filetype, const char *ext)
{ static short data [PIPE_TEST_LEN] ;
static char buffer [256] ;
static char filename [256] ;
SNDFILE *outfile ;
SF_INFO sfinfo ;
int k, retval ;
snprintf (filename, sizeof (filename), "pipe_in.%s", ext) ;
print_test_name ("pipe_read_test", filename) ;
sfinfo.format = filetype | SF_FORMAT_PCM_16 ;
sfinfo.channels = 1 ;
sfinfo.samplerate = 44100 ;
for (k = 0 ; k < PIPE_TEST_LEN ; k++)
data [k] = PIPE_INDEX (k) ;
outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, __LINE__) ;
test_writef_short_or_die (outfile, 0, data, PIPE_TEST_LEN, __LINE__) ;
sf_close (outfile) ;
snprintf (buffer, sizeof (buffer), "cat %s | ./stdin_test %s ", filename, ext) ;
if ((retval = system (buffer)) != 0)
{ retval = WEXITSTATUS (retval) ;
printf ("\n\n Line %d : pipe test returned error for file type \"%s\".\n\n", __LINE__, ext) ;
exit (retval) ;
} ;
unlink (filename) ;
puts ("ok") ;
return ;
} /* pipe_read_test */
static void test_bzero(void)
{
int test[2], ctrl[2];
char str1[]="test string",
str2[]="test string",
str3[]="one test string",
str4[]="two test string";
print_test_name("------------BZERO------------");
init(ctrl, 2, 0);
init(test, 2, 0);
bzero(str1, 0);
ft_bzero(str2, 0);
test[0] = cmp(str1, str2);
bzero(str3, 10);
ft_bzero(str4, 10);
while (!(str3[ctrl[1]]))
++(ctrl[1]);
while (!(str4[test[1]]))
++(test[1]);
test_hard();
print_test_results(test, ctrl, 2, NULL);
printf("\n");
}
static void
broadcast_test (const char *filename, int filetype)
{ static SF_BROADCAST_INFO bc_write, bc_read ;
SNDFILE *file ;
SF_INFO sfinfo ;
int errors = 0 ;
print_test_name ("broadcast_test", filename) ;
sfinfo.samplerate = 11025 ;
sfinfo.format = filetype ;
sfinfo.channels = 1 ;
memset (&bc_write, 0, sizeof (bc_write)) ;
snprintf (bc_write.description, sizeof (bc_write.description), "Test description") ;
snprintf (bc_write.originator, sizeof (bc_write.originator), "Test originator") ;
snprintf (bc_write.originator_reference, sizeof (bc_write.originator_reference), "%08x-%08x", (unsigned int) time (NULL), (unsigned int) (~ time (NULL))) ;
snprintf (bc_write.origination_date, sizeof (bc_write.origination_date), "%d/%02d/%02d", 2006, 3, 30) ;
snprintf (bc_write.origination_time, sizeof (bc_write.origination_time), "%02d:%02d:%02d", 20, 27, 0) ;
snprintf (bc_write.umid, sizeof (bc_write.umid), "Some umid") ;
bc_write.coding_history_size = 0 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_SET_BROADCAST_INFO, &bc_write, sizeof (bc_write)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
memset (&bc_read, 0, sizeof (bc_read)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_GET_BROADCAST_INFO, &bc_read, sizeof (bc_read)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_GET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
return ;
} ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
if (bc_read.version != 1)
{ printf ("\n\nLine %d : Read bad version number %d.\n\n", __LINE__, bc_read.version) ;
exit (1) ;
return ;
} ;
bc_read.version = bc_write.version = 0 ;
if (memcmp (bc_write.description, bc_read.description, sizeof (bc_write.description)) != 0)
{ printf ("\n\nLine %d : description mismatch :\n\twrite : '%s'\n\tread : '%s'\n\n", __LINE__, bc_write.description, bc_read.description) ;
errors ++ ;
} ;
if (memcmp (bc_write.originator, bc_read.originator, sizeof (bc_write.originator)) != 0)
{ printf ("\n\nLine %d : originator mismatch :\n\twrite : '%s'\n\tread : '%s'\n\n", __LINE__, bc_write.originator, bc_read.originator) ;
errors ++ ;
} ;
if (memcmp (bc_write.originator_reference, bc_read.originator_reference, sizeof (bc_write.originator_reference)) != 0)
{ printf ("\n\nLine %d : originator_reference mismatch :\n\twrite : '%s'\n\tread : '%s'\n\n", __LINE__, bc_write.originator_reference, bc_read.originator_reference) ;
errors ++ ;
} ;
if (memcmp (bc_write.origination_date, bc_read.origination_date, sizeof (bc_write.origination_date)) != 0)
{ printf ("\n\nLine %d : origination_date mismatch :\n\twrite : '%s'\n\tread : '%s'\n\n", __LINE__, bc_write.origination_date, bc_read.origination_date) ;
errors ++ ;
} ;
if (memcmp (bc_write.origination_time, bc_read.origination_time, sizeof (bc_write.origination_time)) != 0)
{ printf ("\n\nLine %d : origination_time mismatch :\n\twrite : '%s'\n\tread : '%s'\n\n", __LINE__, bc_write.origination_time, bc_read.origination_time) ;
errors ++ ;
} ;
if (memcmp (bc_write.umid, bc_read.umid, sizeof (bc_write.umid)) != 0)
{ printf ("\n\nLine %d : umid mismatch :\n\twrite : '%s'\n\tread : '%s'\n\n", __LINE__, bc_write.umid, bc_read.umid) ;
errors ++ ;
} ;
if (errors)
exit (1) ;
unlink (filename) ;
puts ("ok") ;
} /* broadcast_test */
static void
instrument_test (const char *filename, int filetype)
{ static SF_INSTRUMENT write_inst =
{ 2, /* gain */
3, /* detune */
4, /* basenote */
5, 6, /* key low and high */
7, 8, /* velocity low and high */
2, /* loop_count */
{ { 801, 2, 3, 0 },
{ 801, 3, 4, 0 },
}
} ;
SF_INSTRUMENT read_inst ;
SNDFILE *file ;
SF_INFO sfinfo ;
print_test_name ("instrument_test", filename) ;
sfinfo.samplerate = 11025 ;
sfinfo.format = filetype ;
sfinfo.channels = 1 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_SET_INSTRUMENT, &write_inst, sizeof (write_inst)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_INSTRUMENT) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
memset (&read_inst, 0, sizeof (read_inst)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_GET_INSTRUMENT, &read_inst, sizeof (read_inst)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_GET_INSTRUMENT) failed.\n\n", __LINE__) ;
exit (1) ;
return ;
} ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
if ((filetype & SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV)
{ /*
** For all the fields that WAV doesn't support, modify the
** write_inst struct to hold the default value that the WAV
** module should hold.
*/
write_inst.detune = 0 ;
write_inst.key_lo = write_inst.velocity_lo = 0 ;
write_inst.key_hi = write_inst.velocity_hi = 127 ;
write_inst.gain = 1 ;
} ;
if ((filetype & SF_FORMAT_TYPEMASK) == SF_FORMAT_XI)
{ /*
** For all the fields that XI doesn't support, modify the
** write_inst struct to hold the default value that the XI
** module should hold.
*/
write_inst.basenote = 0 ;
write_inst.detune = 0 ;
write_inst.key_lo = write_inst.velocity_lo = 0 ;
write_inst.key_hi = write_inst.velocity_hi = 127 ;
write_inst.gain = 1 ;
} ;
if (memcmp (&write_inst, &read_inst, sizeof (write_inst)) != 0)
{ printf ("\n\nLine %d : instrument comparison failed.\n\n", __LINE__) ;
printf ("W Base Note : %u\n"
" Detune : %u\n"
" Low Note : %u\tHigh Note : %u\n"
" Low Vel. : %u\tHigh Vel. : %u\n"
" Gain : %d\tCount : %d\n"
" mode : %d\n"
" start : %d\tend : %d\tcount :%d\n"
" mode : %d\n"
" start : %d\tend : %d\tcount :%d\n\n",
write_inst.basenote,
write_inst.detune,
write_inst.key_lo, write_inst.key_hi,
write_inst.velocity_lo, write_inst.velocity_hi,
write_inst.gain, write_inst.loop_count,
write_inst.loops [0].mode, write_inst.loops [0].start,
write_inst.loops [0].end, write_inst.loops [0].count,
write_inst.loops [1].mode, write_inst.loops [1].start,
write_inst.loops [1].end, write_inst.loops [1].count) ;
printf ("R Base Note : %u\n"
" Detune : %u\n"
" Low Note : %u\tHigh Note : %u\n"
" Low Vel. : %u\tHigh Vel. : %u\n"
" Gain : %d\tCount : %d\n"
" mode : %d\n"
" start : %d\tend : %d\tcount :%d\n"
" mode : %d\n"
" start : %d\tend : %d\tcount :%d\n\n",
read_inst.basenote,
read_inst.detune,
read_inst.key_lo, read_inst.key_hi,
read_inst.velocity_lo, read_inst.velocity_hi,
read_inst.gain, read_inst.loop_count,
read_inst.loops [0].mode, read_inst.loops [0].start,
read_inst.loops [0].end, read_inst.loops [0].count,
read_inst.loops [1].mode, read_inst.loops [1].start,
read_inst.loops [1].end, read_inst.loops [1].count) ;
if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_XI)
exit (1) ;
} ;
if (0) instrumet_rw_test (filename) ;
unlink (filename) ;
puts ("ok") ;
} /* instrument_test */
int
main (int argc, char *argv [])
{ int do_all = 0 ;
int test_count = 0 ;
if (argc != 2)
{ printf ("Usage : %s <test>\n", argv [0]) ;
printf (" Where <test> is one of the following:\n") ;
printf (" ver - test sf_command (SFC_GETLIB_VERSION)\n") ;
printf (" norm - test floating point normalisation\n") ;
printf (" format - test format string commands\n") ;
printf (" peak - test peak calculation\n") ;
printf (" trunc - test file truncation\n") ;
printf (" inst - test set/get of SF_INSTRUMENT.\n") ;
printf (" chanmap - test set/get of channel map data..\n") ;
printf (" bext - test set/get of SF_BROADCAST_INFO.\n") ;
printf (" bextch - test set/get of SF_BROADCAST_INFO coding_history.\n") ;
printf (" rawend - test SFC_RAW_NEEDS_ENDSWAP.\n") ;
printf (" all - perform all tests\n") ;
exit (1) ;
} ;
do_all =! strcmp (argv [1], "all") ;
if (do_all || strcmp (argv [1], "ver") == 0)
{ char buffer [128] ;
print_test_name ("version_test", "(none)") ;
buffer [0] = 0 ;
sf_command (NULL, SFC_GET_LIB_VERSION, buffer, sizeof (buffer)) ;
if (strlen (buffer) < 1)
{ printf ("Line %d: could not retrieve lib version.\n", __LINE__) ;
exit (1) ;
} ;
puts ("ok") ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "norm") == 0)
{ /* Preliminary float/double normalisation tests. More testing
** is done in the program 'floating_point_test'.
*/
float_norm_test ("float.wav") ;
double_norm_test ("double.wav") ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "peak") == 0)
{ calc_peak_test (SF_ENDIAN_BIG | SF_FORMAT_RAW, "be-peak.raw") ;
calc_peak_test (SF_ENDIAN_LITTLE | SF_FORMAT_RAW, "le-peak.raw") ;
test_count ++ ;
} ;
if (do_all || ! strcmp (argv [1], "format"))
{ format_tests () ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "trunc") == 0)
{ truncate_test ("truncate.raw", SF_FORMAT_RAW | SF_FORMAT_PCM_32) ;
truncate_test ("truncate.au" , SF_FORMAT_AU | SF_FORMAT_PCM_16) ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "inst") == 0)
{ instrument_test ("instrument.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
instrument_test ("instrument.aiff" , SF_FORMAT_AIFF | SF_FORMAT_PCM_24) ;
/*-instrument_test ("instrument.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_16) ;-*/
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "current_sf_info") == 0)
{ current_sf_info_test ("current.wav") ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "bext") == 0)
{ broadcast_test ("broadcast.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
broadcast_rdwr_test ("broadcast.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16) ;
broadcast_test ("broadcast.wavex", SF_FORMAT_WAVEX | SF_FORMAT_PCM_16) ;
broadcast_rdwr_test ("broadcast.wavex", SF_FORMAT_WAVEX | SF_FORMAT_PCM_16) ;
broadcast_test ("broadcast.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_16) ;
broadcast_rdwr_test ("broadcast.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_16) ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "bextch") == 0)
{ broadcast_coding_history_test ("coding_history.wav") ;
broadcast_coding_history_size ("coding_hist_size.wav") ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "chanmap") == 0)
{ channel_map_test ("chanmap.wavex", SF_FORMAT_WAVEX | SF_FORMAT_PCM_16) ;
channel_map_test ("chanmap.rf64", SF_FORMAT_RF64 | SF_FORMAT_PCM_16) ;
channel_map_test ("chanmap.aifc" , SF_FORMAT_AIFF | SF_FORMAT_PCM_16) ;
channel_map_test ("chanmap.caf" , SF_FORMAT_CAF | SF_FORMAT_PCM_16) ;
test_count ++ ;
} ;
if (do_all || strcmp (argv [1], "rawend") == 0)
{ raw_needs_endswap_test ("raw_end.wav", SF_FORMAT_WAV) ;
raw_needs_endswap_test ("raw_end.wavex", SF_FORMAT_WAVEX) ;
raw_needs_endswap_test ("raw_end.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV) ;
raw_needs_endswap_test ("raw_end.aiff", SF_FORMAT_AIFF) ;
raw_needs_endswap_test ("raw_end.aiff_le", SF_ENDIAN_LITTLE | SF_FORMAT_AIFF) ;
test_count ++ ;
} ;
if (test_count == 0)
{ printf ("Mono : ************************************\n") ;
printf ("Mono : * No '%s' test defined.\n", argv [1]) ;
printf ("Mono : ************************************\n") ;
return 1 ;
} ;
return 0 ;
} /* main */
static void
calc_peak_test (int filetype, const char *filename)
{ SNDFILE *file ;
SF_INFO sfinfo ;
int k, format ;
double peak ;
print_test_name ("calc_peak_test", filename) ;
format = (filetype | SF_FORMAT_PCM_16) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = format ;
sfinfo.channels = 1 ;
sfinfo.frames = BUFFER_LEN ;
/* Create double_data with max value of 0.5. */
for (k = 0 ; k < BUFFER_LEN ; k++)
double_data [k] = (k + 1) / (2.0 * BUFFER_LEN) ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sfinfo.format != format)
{ printf ("Line %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, format, sfinfo.format) ;
exit (1) ;
} ;
if (sfinfo.frames != BUFFER_LEN)
{ printf ("\n\nLine %d: Incorrect number of.frames in file. (%d => %ld)\n", __LINE__, BUFFER_LEN, SF_COUNT_TO_LONG (sfinfo.frames)) ;
exit (1) ;
} ;
if (sfinfo.channels != 1)
{ printf ("Line %d: Incorrect number of channels in file.\n", __LINE__) ;
exit (1) ;
} ;
sf_command (file, SFC_CALC_SIGNAL_MAX, &peak, sizeof (peak)) ;
if (fabs (peak - (1 << 14)) > 1.0)
{ printf ("Line %d : Peak value should be %d (is %f).\n", __LINE__, (1 << 14), peak) ;
exit (1) ;
} ;
sf_command (file, SFC_CALC_NORM_SIGNAL_MAX, &peak, sizeof (peak)) ;
if (fabs (peak - 0.5) > 4e-5)
{ printf ("Line %d : Peak value should be %f (is %f).\n", __LINE__, 0.5, peak) ;
exit (1) ;
} ;
sf_close (file) ;
format = (filetype | SF_FORMAT_FLOAT) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = format ;
sfinfo.channels = 1 ;
sfinfo.frames = BUFFER_LEN ;
/* Create double_data with max value of 0.5. */
for (k = 0 ; k < BUFFER_LEN ; k++)
double_data [k] = (k + 1) / (2.0 * BUFFER_LEN) ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sfinfo.format != format)
{ printf ("Line %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, format, sfinfo.format) ;
exit (1) ;
} ;
if (sfinfo.frames != BUFFER_LEN)
{ printf ("\n\nLine %d: Incorrect number of.frames in file. (%d => %ld)\n", __LINE__, BUFFER_LEN, SF_COUNT_TO_LONG (sfinfo.frames)) ;
exit (1) ;
} ;
if (sfinfo.channels != 1)
{ printf ("Line %d: Incorrect number of channels in file.\n", __LINE__) ;
exit (1) ;
} ;
sf_command (file, SFC_CALC_SIGNAL_MAX, &peak, sizeof (peak)) ;
if (fabs (peak - 0.5) > 1e-5)
{ printf ("Line %d : Peak value should be %f (is %f).\n", __LINE__, 0.5, peak) ;
exit (1) ;
} ;
sf_command (file, SFC_CALC_NORM_SIGNAL_MAX, &peak, sizeof (peak)) ;
if (fabs (peak - 0.5) > 1e-5)
{ printf ("Line %d : Peak value should be %f (is %f).\n", __LINE__, 0.5, peak) ;
exit (1) ;
} ;
sf_close (file) ;
unlink (filename) ;
printf ("ok\n") ;
} /* calc_peak_test */
static void
update_seek_double_test (const char *filename, int filetype)
{ SNDFILE *outfile, *infile ;
SF_INFO sfinfo ;
sf_count_t frames ;
double buffer [8] ;
int k ;
print_test_name ("update_seek_double_test", filename) ;
memset (buffer, 0, sizeof (buffer)) ;
/* Create sound outfile with no data. */
sfinfo.format = filetype | SF_FORMAT_DOUBLE ;
sfinfo.samplerate = 48000 ;
sfinfo.channels = 2 ;
if (sf_format_check (&sfinfo) == SF_FALSE)
sfinfo.channels = 1 ;
outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
sf_close (outfile) ;
/* Open again for read/write. */
outfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
/*
** In auto header update mode, seeking to the end of the file with
** SEEK_SET will fail from the 2nd seek on. seeking to 0, SEEK_END
** will seek to 0 anyway
*/
if (sf_command (outfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) == 0)
{ printf ("\n\nError : sf_command (SFC_SET_UPDATE_HEADER_AUTO) return error : %s\n\n", sf_strerror (outfile)) ;
exit (1) ;
} ;
/* Now write some frames. */
frames = ARRAY_LEN (buffer) / sfinfo.channels ;
for (k = 0 ; k < 6 ; k++)
{ test_seek_or_die (outfile, k * frames, SEEK_SET, k * frames, sfinfo.channels, __LINE__) ;
test_seek_or_die (outfile, 0, SEEK_END, k * frames, sfinfo.channels, __LINE__) ;
/* Open file again and make sure no errors in log buffer. */
infile = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
check_log_buffer_or_die (infile, __LINE__) ;
sf_close (infile) ;
if (sfinfo.frames != k * frames)
{ printf ("\n\nLine %d : Incorrect sample count (%ld should be %ld)\n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), SF_COUNT_TO_LONG (k + frames)) ;
dump_log_buffer (infile) ;
exit (1) ;
} ;
if ((k & 1) == 0)
test_write_double_or_die (outfile, k, buffer, sfinfo.channels * frames, __LINE__) ;
else
test_writef_double_or_die (outfile, k, buffer, frames, __LINE__) ;
} ;
sf_close (outfile) ;
unlink (filename) ;
puts ("ok") ;
return ;
} /* update_seek_double_test */
static void
raw_needs_endswap_test (const char *filename, int filetype)
{ static int subtypes [] =
{ SF_FORMAT_FLOAT, SF_FORMAT_DOUBLE,
SF_FORMAT_PCM_16, SF_FORMAT_PCM_24, SF_FORMAT_PCM_32
} ;
SNDFILE *file ;
SF_INFO sfinfo ;
unsigned k ;
int needs_endswap ;
print_test_name (__func__, filename) ;
for (k = 0 ; k < ARRAY_LEN (subtypes) ; k++)
{
if (filetype == (SF_ENDIAN_LITTLE | SF_FORMAT_AIFF))
switch (subtypes [k])
{ /* Little endian AIFF does not AFAIK support fl32 and fl64. */
case SF_FORMAT_FLOAT :
case SF_FORMAT_DOUBLE :
continue ;
default :
break ;
} ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 11025 ;
sfinfo.format = filetype | subtypes [k] ;
sfinfo.channels = 1 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
needs_endswap = sf_command (file, SFC_RAW_DATA_NEEDS_ENDSWAP, NULL, 0) ;
switch (filetype)
{ case SF_FORMAT_WAV :
case SF_FORMAT_WAVEX :
case SF_FORMAT_AIFF | SF_ENDIAN_LITTLE :
exit_if_true (needs_endswap != CPU_IS_BIG_ENDIAN,
"\n\nLine %d : SFC_RAW_DATA_NEEDS_ENDSWAP failed for (%d | %d).\n\n", __LINE__, filetype, k) ;
break ;
case SF_FORMAT_AIFF :
case SF_FORMAT_WAV | SF_ENDIAN_BIG :
exit_if_true (needs_endswap != CPU_IS_LITTLE_ENDIAN,
"\n\nLine %d : SFC_RAW_DATA_NEEDS_ENDSWAP failed for (%d | %d).\n\n", __LINE__, filetype, k) ;
break ;
default :
printf ("\n\nLine %d : bad format value %d.\n\n", __LINE__, filetype) ;
exit (1) ;
break ;
} ;
sf_close (file) ;
} ;
unlink (filename) ;
puts ("ok") ;
} /* raw_needs_endswap_test */
static void
extra_header_test (const char *filename, int filetype)
{ SNDFILE *outfile ;
SF_INFO sfinfo ;
sf_count_t frames ;
short buffer [8] ;
int k = 0 ;
print_test_name ("extra_header_test", filename) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = (filetype | SF_FORMAT_PCM_16) ;
sfinfo.channels = 1 ;
memset (buffer, 0xA0, sizeof (buffer)) ;
/* Now write some frames. */
frames = ARRAY_LEN (buffer) / sfinfo.channels ;
/* Test the file with extra header data. */
outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, 464) ;
sf_set_string (outfile, SF_STR_TITLE, filename) ;
test_writef_short_or_die (outfile, k, buffer, frames, 466) ;
sf_set_string (outfile, SF_STR_COPYRIGHT, "(c) 1980 Erik") ;
sf_close (outfile) ;
#if 1
/*
** Erik de Castro Lopo <*****@*****.**> May 23 2004.
**
** This file has extra string data in the header and therefore cannot
** currently be opened in SFM_RDWR mode. This is fixable, but its in
** a part of the code I don't want to fiddle with until the Ogg/Vorbis
** integration is done.
*/
if (sf_open (filename, SFM_RDWR, &sfinfo) != NULL)
{ printf ("\n\nError : should not be able to open this file in SFM_RDWR.\n\n") ;
exit (1) ;
} ;
unlink (filename) ;
puts ("ok") ;
return ;
#else
hexdump_file (filename, 0, 100000) ;
/* Open again for read/write. */
outfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, 493) ;
/*
** In auto header update mode, seeking to the end of the file with
** SEEK_SET will fail from the 2nd seek on. seeking to 0, SEEK_END
** will seek to 0 anyway
*/
if (sf_command (outfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) == 0)
{ printf ("\n\nError : sf_command (SFC_SET_UPDATE_HEADER_AUTO) return error : %s\n\n", sf_strerror (outfile)) ;
exit (1) ;
} ;
/* Now write some frames. */
frames = ARRAY_LEN (buffer) / sfinfo.channels ;
for (k = 1 ; k < 6 ; k++)
{
printf ("\n*** pass %d\n", k) ;
memset (buffer, 0xA0 + k, sizeof (buffer)) ;
test_seek_or_die (outfile, k * frames, SEEK_SET, k * frames, sfinfo.channels, 514) ;
test_seek_or_die (outfile, 0, SEEK_END, k * frames, sfinfo.channels, 515) ;
/* Open file again and make sure no errors in log buffer. */
if (0)
{ infile = test_open_file_or_die (filename, SFM_READ, &sfinfo, 519) ;
check_log_buffer_or_die (infile, 520) ;
sf_close (infile) ;
} ;
if (sfinfo.frames != k * frames)
{ printf ("\n\nLine %d : Incorrect sample count (%ld should be %ld)\n", 525, SF_COUNT_TO_LONG (sfinfo.frames), SF_COUNT_TO_LONG (k + frames)) ;
dump_log_buffer (infile) ;
exit (1) ;
} ;
if ((k & 1) == 0)
test_write_short_or_die (outfile, k, buffer, sfinfo.channels * frames, 531) ;
else
test_writef_short_or_die (outfile, k, buffer, frames, 533) ;
hexdump_file (filename, 0, 100000) ;
} ;
sf_close (outfile) ;
unlink (filename) ;
puts ("ok") ;
return ;
#endif
} /* extra_header_test */
static void
broadcast_coding_history_test (const char *filename)
{ static SF_BROADCAST_INFO bc_write, bc_read ;
SNDFILE *file ;
SF_INFO sfinfo ;
const char *default_history = "A=PCM,F=22050,W=16,M=mono" ;
const char *supplied_history =
"A=PCM,F=44100,W=24,M=mono,T=other\r\n"
"A=PCM,F=22050,W=16,M=mono,T=yet_another\r\n" ;
print_test_name ("broadcast_coding_history_test", filename) ;
sfinfo.samplerate = 22050 ;
sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16 ;
sfinfo.channels = 1 ;
memset (&bc_write, 0, sizeof (bc_write)) ;
snprintf (bc_write.description, sizeof (bc_write.description), "Test description") ;
snprintf (bc_write.originator, sizeof (bc_write.originator), "Test originator") ;
snprintf (bc_write.originator_reference, sizeof (bc_write.originator_reference), "%08x-%08x", (unsigned int) time (NULL), (unsigned int) (~ time (NULL))) ;
snprintf (bc_write.origination_date, sizeof (bc_write.origination_date), "%d/%02d/%02d", 2006, 3, 30) ;
snprintf (bc_write.origination_time, sizeof (bc_write.origination_time), "%02d:%02d:%02d", 20, 27, 0) ;
snprintf (bc_write.umid, sizeof (bc_write.umid), "Some umid") ;
/* Coding history will be filled in by the library. */
bc_write.coding_history_size = 0 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_SET_BROADCAST_INFO, &bc_write, sizeof (bc_write)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
memset (&bc_read, 0, sizeof (bc_read)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_GET_BROADCAST_INFO, &bc_read, sizeof (bc_read)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
if (bc_read.coding_history_size == 0)
{ printf ("\n\nLine %d : missing coding history.\n\n", __LINE__) ;
exit (1) ;
} ;
if (bc_read.coding_history_size < strlen (default_history) || memcmp (bc_read.coding_history, default_history, strlen (default_history)) != 0)
{ printf ("\n\n"
"Line %d : unexpected coding history '%.*s',\n"
" should be '%s'\n\n", __LINE__, bc_read.coding_history_size, bc_read.coding_history, default_history) ;
exit (1) ;
} ;
bc_write.coding_history_size = strlen (supplied_history) ;
bc_write.coding_history_size = snprintf (bc_write.coding_history, sizeof (bc_write.coding_history), "%s", supplied_history) ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_SET_BROADCAST_INFO, &bc_write, sizeof (bc_write)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
memset (&bc_read, 0, sizeof (bc_read)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_GET_BROADCAST_INFO, &bc_read, sizeof (bc_read)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
if (strstr (bc_read.coding_history, supplied_history) != bc_read.coding_history)
{ printf ("\n\nLine %d : unexpected coding history :\n"
"----------------------------------------------------\n%s"
"----------------------------------------------------\n"
"should be this :\n"
"----------------------------------------------------\n%s"
"----------------------------------------------------\n"
"with one more line at the end.\n\n",
__LINE__, bc_read.coding_history, supplied_history) ;
exit (1) ;
} ;
check_coding_history_newlines (filename) ;
unlink (filename) ;
puts ("ok") ;
} /* broadcast_coding_history_test */
static void
raw_offset_test (const char *filename, int typeminor)
{ SNDFILE *sndfile ;
SF_INFO sfinfo ;
sf_count_t start ;
int k ;
print_test_name ("raw_offset_test", filename) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = SF_FORMAT_RAW | typeminor ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
sndfile = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
start = 0 ;
sf_command (sndfile, SFC_FILE_TRUNCATE, &start, sizeof (start)) ;
for (k = 0 ; k < BUFFER_LEN ; k++)
data [k] = k ;
test_write_short_or_die (sndfile, 0, data, BUFFER_LEN, __LINE__) ;
sf_close (sndfile) ;
sndfile = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
check_log_buffer_or_die (sndfile, __LINE__) ;
if (ABS (BUFFER_LEN - sfinfo.frames) > 1)
{ printf ("\n\nLine %d : Incorrect sample count (%" PRId64 " should be %d)\n", __LINE__, sfinfo.frames, BUFFER_LEN) ;
dump_log_buffer (sndfile) ;
exit (1) ;
} ;
memset (data, 0 , sizeof (data)) ;
test_read_short_or_die (sndfile, 0, data, BUFFER_LEN, __LINE__) ;
for (k = 0 ; k < BUFFER_LEN ; k++)
if (data [k] != k)
printf ("Error : line %d\n", __LINE__) ;
/* Set dataoffset to 2 bytes from beginning of file. */
start = 2 ;
sf_command (sndfile, SFC_SET_RAW_START_OFFSET, &start, sizeof (start)) ;
/* Seek to new start */
test_seek_or_die (sndfile, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
memset (data, 0 , sizeof (data)) ;
test_read_short_or_die (sndfile, 0, data, BUFFER_LEN - 1, __LINE__) ;
for (k = 0 ; k < BUFFER_LEN - 1 ; k++)
if (data [k] != k + 1)
{ printf ("Error : line %d\n", __LINE__) ;
exit (1) ;
} ;
/* Set dataoffset to 4 bytes from beginning of file. */
start = 4 ;
sf_command (sndfile, SFC_SET_RAW_START_OFFSET, &start, sizeof (start)) ;
/* Seek to new start */
test_seek_or_die (sndfile, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
memset (data, 0 , sizeof (data)) ;
test_read_short_or_die (sndfile, 0, data, BUFFER_LEN - 2, __LINE__) ;
for (k = 0 ; k < BUFFER_LEN - 2 ; k++)
if (data [k] != k + 2)
{ printf ("Error : line %d\n", __LINE__) ;
exit (1) ;
} ;
/* Set dataoffset back to 0 bytes from beginning of file. */
start = 0 ;
sf_command (sndfile, SFC_SET_RAW_START_OFFSET, &start, sizeof (start)) ;
/* Seek to new start */
test_seek_or_die (sndfile, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
memset (data, 0 , sizeof (data)) ;
test_read_short_or_die (sndfile, 0, data, BUFFER_LEN, __LINE__) ;
for (k = 0 ; k < BUFFER_LEN ; k++)
if (data [k] != k)
{ printf ("Error : line %d\n", __LINE__) ;
exit (1) ;
} ;
sf_close (sndfile) ;
unlink (filename) ;
puts ("ok") ;
} /* raw_offset_test */
static void
double_norm_test (const char *filename)
{ SNDFILE *file ;
SF_INFO sfinfo ;
unsigned int k ;
print_test_name ("double_norm_test", filename) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = (SF_FORMAT_RAW | SF_FORMAT_PCM_16) ;
sfinfo.channels = 1 ;
sfinfo.frames = BUFFER_LEN ;
/* Create double_data with all values being less than 1.0. */
for (k = 0 ; k < BUFFER_LEN / 2 ; k++)
double_data [k] = (k + 5) / (2.0 * BUFFER_LEN) ;
for (k = BUFFER_LEN / 2 ; k < BUFFER_LEN ; k++)
double_data [k] = (k + 5) ;
if (! (file = sf_open (filename, SFM_WRITE, &sfinfo)))
{ printf ("Line %d: sf_open_write failed with error : ", __LINE__) ;
fflush (stdout) ;
puts (sf_strerror (NULL)) ;
exit (1) ;
} ;
/* Normailsation is on by default so no need to do anything here. */
/*-sf_command (file, "set-norm-double", "true", 0) ;-*/
if ((k = sf_write_double (file, double_data, BUFFER_LEN / 2)) != BUFFER_LEN / 2)
{ printf ("Line %d: sf_write_double failed with short write (%d ->%d)\n", __LINE__, BUFFER_LEN, k) ;
exit (1) ;
} ;
/* Turn normalisation off. */
sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
if ((k = sf_write_double (file, double_data + BUFFER_LEN / 2, BUFFER_LEN / 2)) != BUFFER_LEN / 2)
{ printf ("Line %d: sf_write_double failed with short write (%d ->%d)\n", __LINE__, BUFFER_LEN, k) ;
exit (1) ;
} ;
sf_close (file) ;
if (! (file = sf_open (filename, SFM_READ, &sfinfo)))
{ printf ("Line %d: sf_open_read failed with error : ", __LINE__) ;
fflush (stdout) ;
puts (sf_strerror (NULL)) ;
exit (1) ;
} ;
if (sfinfo.format != (SF_FORMAT_RAW | SF_FORMAT_PCM_16))
{ printf ("Line %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, (SF_FORMAT_RAW | SF_FORMAT_PCM_16), sfinfo.format) ;
exit (1) ;
} ;
if (sfinfo.frames != BUFFER_LEN)
{ printf ("\n\nLine %d: Incorrect number of.frames in file. (%d => %ld)\n", __LINE__, BUFFER_LEN, SF_COUNT_TO_LONG (sfinfo.frames)) ;
exit (1) ;
} ;
if (sfinfo.channels != 1)
{ printf ("Line %d: Incorrect number of channels in file.\n", __LINE__) ;
exit (1) ;
} ;
/* Read double_data and check that it is normalised (ie default). */
if ((k = sf_read_double (file, double_data, BUFFER_LEN)) != BUFFER_LEN)
{ printf ("\n\nLine %d: sf_read_double failed with short read (%d ->%d)\n", __LINE__, BUFFER_LEN, k) ;
exit (1) ;
} ;
for (k = 0 ; k < BUFFER_LEN ; k++)
if (double_data [k] >= 1.0)
{ printf ("\n\nLine %d: double_data [%d] == %f which is greater than 1.0\n", __LINE__, k, double_data [k]) ;
exit (1) ;
} ;
/* Seek to start of file, turn normalisation off, read double_data and check again. */
sf_seek (file, 0, SEEK_SET) ;
sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
if ((k = sf_read_double (file, double_data, BUFFER_LEN)) != BUFFER_LEN)
{ printf ("\n\nLine %d: sf_read_double failed with short read (%d ->%d)\n", __LINE__, BUFFER_LEN, k) ;
exit (1) ;
} ;
for (k = 0 ; k < BUFFER_LEN ; k++)
if (double_data [k] < 1.0)
{ printf ("\n\nLine %d: double_data [%d] == %f which is less than 1.0\n", __LINE__, k, double_data [k]) ;
exit (1) ;
} ;
/* Seek to start of file, turn normalisation on, read double_data and do final check. */
sf_seek (file, 0, SEEK_SET) ;
sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_TRUE) ;
if ((k = sf_read_double (file, double_data, BUFFER_LEN)) != BUFFER_LEN)
{ printf ("\n\nLine %d: sf_read_double failed with short read (%d ->%d)\n", __LINE__, BUFFER_LEN, k) ;
exit (1) ;
} ;
for (k = 0 ; k < BUFFER_LEN ; k++)
if (double_data [k] > 1.0)
{ printf ("\n\nLine %d: double_data [%d] == %f which is greater than 1.0\n", __LINE__, k, double_data [k]) ;
exit (1) ;
} ;
sf_close (file) ;
unlink (filename) ;
printf ("ok\n") ;
} /* double_norm_test */
static void
broadcast_coding_history_size (const char *filename)
{ /* SF_BROADCAST_INFO struct with coding_history field of 1024 bytes. */
static SF_BROADCAST_INFO_VAR (1024) bc_write ;
static SF_BROADCAST_INFO_VAR (1024) bc_read ;
SNDFILE *file ;
SF_INFO sfinfo ;
int k ;
print_test_name (__func__, filename) ;
sfinfo.samplerate = 22050 ;
sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16 ;
sfinfo.channels = 1 ;
memset (&bc_write, 0, sizeof (bc_write)) ;
snprintf (bc_write.description, sizeof (bc_write.description), "Test description") ;
snprintf (bc_write.originator, sizeof (bc_write.originator), "Test originator") ;
snprintf (bc_write.originator_reference, sizeof (bc_write.originator_reference), "%08x-%08x", (unsigned int) time (NULL), (unsigned int) (~ time (NULL))) ;
snprintf (bc_write.origination_date, sizeof (bc_write.origination_date), "%d/%02d/%02d", 2006, 3, 30) ;
snprintf (bc_write.origination_time, sizeof (bc_write.origination_time), "%02d:%02d:%02d", 20, 27, 0) ;
snprintf (bc_write.umid, sizeof (bc_write.umid), "Some umid") ;
bc_write.coding_history_size = 0 ;
for (k = 0 ; bc_write.coding_history_size < 512 ; k++)
{ snprintf (bc_write.coding_history + bc_write.coding_history_size,
sizeof (bc_write.coding_history) - bc_write.coding_history_size, "line %4d\n", k) ;
bc_write.coding_history_size = strlen (bc_write.coding_history) ;
} ;
exit_if_true (bc_write.coding_history_size < 512,
"\n\nLine %d : bc_write.coding_history_size (%d) should be > 512.\n\n", __LINE__, bc_write.coding_history_size) ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_SET_BROADCAST_INFO, &bc_write, sizeof (bc_write)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
memset (&bc_read, 0, sizeof (bc_read)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sf_command (file, SFC_GET_BROADCAST_INFO, &bc_read, sizeof (bc_read)) == SF_FALSE)
{ printf ("\n\nLine %d : sf_command (SFC_SET_BROADCAST_INFO) failed.\n\n", __LINE__) ;
exit (1) ;
} ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
exit_if_true (bc_read.coding_history_size < 512,
"\n\nLine %d : unexpected coding history size %d (should be > 512).\n\n", __LINE__, bc_read.coding_history_size) ;
exit_if_true (strstr (bc_read.coding_history, "libsndfile") == NULL,
"\n\nLine %d : coding history incomplete (should contain 'libsndfile').\n\n", __LINE__) ;
unlink (filename) ;
puts ("ok") ;
} /* broadcast_coding_history_size */
static void
format_tests (void)
{ SF_FORMAT_INFO format_info ;
SF_INFO sfinfo ;
const char *last_name ;
int k, count ;
print_test_name ("format_tests", "(null)") ;
/* Clear out SF_INFO struct and set channels > 0. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.channels = 1 ;
/* First test simple formats. */
sf_command (NULL, SFC_GET_SIMPLE_FORMAT_COUNT, &count, sizeof (int)) ;
if (count < 0 || count > 30)
{ printf ("Line %d: Weird count.\n", __LINE__) ;
exit (1) ;
} ;
format_info.format = 0 ;
sf_command (NULL, SFC_GET_SIMPLE_FORMAT, &format_info, sizeof (format_info)) ;
last_name = format_info.name ;
for (k = 1 ; k < count ; k ++)
{ format_info.format = k ;
sf_command (NULL, SFC_GET_SIMPLE_FORMAT, &format_info, sizeof (format_info)) ;
if (strcmp (last_name, format_info.name) >= 0)
{ printf ("\n\nLine %d: format names out of sequence `%s' < `%s'.\n", __LINE__, last_name, format_info.name) ;
exit (1) ;
} ;
sfinfo.format = format_info.format ;
if (! sf_format_check (&sfinfo))
{ printf ("\n\nLine %d: sf_format_check failed.\n", __LINE__) ;
printf (" Name : %s\n", format_info.name) ;
printf (" Format : 0x%X\n", sfinfo.format) ;
printf (" Channels : 0x%X\n", sfinfo.channels) ;
printf (" Sample Rate : 0x%X\n", sfinfo.samplerate) ;
exit (1) ;
} ;
last_name = format_info.name ;
} ;
format_info.format = 666 ;
sf_command (NULL, SFC_GET_SIMPLE_FORMAT, &format_info, sizeof (format_info)) ;
/* Now test major formats. */
sf_command (NULL, SFC_GET_FORMAT_MAJOR_COUNT, &count, sizeof (int)) ;
if (count < 0 || count > 30)
{ printf ("Line %d: Weird count.\n", __LINE__) ;
exit (1) ;
} ;
format_info.format = 0 ;
sf_command (NULL, SFC_GET_FORMAT_MAJOR, &format_info, sizeof (format_info)) ;
last_name = format_info.name ;
for (k = 1 ; k < count ; k ++)
{ format_info.format = k ;
sf_command (NULL, SFC_GET_FORMAT_MAJOR, &format_info, sizeof (format_info)) ;
if (strcmp (last_name, format_info.name) >= 0)
{ printf ("\n\nLine %d: format names out of sequence (%d) `%s' < `%s'.\n", __LINE__, k, last_name, format_info.name) ;
exit (1) ;
} ;
last_name = format_info.name ;
} ;
format_info.format = 666 ;
sf_command (NULL, SFC_GET_FORMAT_MAJOR, &format_info, sizeof (format_info)) ;
/* Now test subtype formats. */
sf_command (NULL, SFC_GET_FORMAT_SUBTYPE_COUNT, &count, sizeof (int)) ;
if (count < 0 || count > 30)
{ printf ("Line %d: Weird count.\n", __LINE__) ;
exit (1) ;
} ;
format_info.format = 0 ;
sf_command (NULL, SFC_GET_FORMAT_SUBTYPE, &format_info, sizeof (format_info)) ;
last_name = format_info.name ;
for (k = 1 ; k < count ; k ++)
{ format_info.format = k ;
sf_command (NULL, SFC_GET_FORMAT_SUBTYPE, &format_info, sizeof (format_info)) ;
} ;
format_info.format = 666 ;
sf_command (NULL, SFC_GET_FORMAT_SUBTYPE, &format_info, sizeof (format_info)) ;
printf ("ok\n") ;
} /* format_tests */
static void
old_test (void)
{ static short buffer [BUFFER_SIZE] ;
SNDFILE *file ;
SF_INFO sfinfo ;
int k, filetype ;
const char *filename = "headerless.wav" ;
print_test_name (__func__, "") ;
for (k = 0 ; k < BUFFER_SIZE ; k++)
buffer [k] = k ;
filetype = SF_FORMAT_WAV | SF_FORMAT_PCM_16 ;
sfinfo.samplerate = 32000 ;
sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
sfinfo.channels = 1 ;
sfinfo.format = filetype ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
if ((k = sf_write_short (file, buffer, BUFFER_SIZE)) != BUFFER_SIZE)
{ printf ("Line %d: sf_write_short failed with short write (%d => %d).\n", __LINE__, BUFFER_SIZE, k) ;
fflush (stdout) ;
puts (sf_strerror (file)) ;
exit (1) ;
} ;
sf_close (file) ;
memset (buffer, 0, sizeof (buffer)) ;
/* Read as RAW but get the bit width and endian-ness correct. */
sfinfo.format = filetype = SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_16 ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
if (sfinfo.format != filetype)
{ printf ("Line %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
exit (1) ;
} ;
if (sfinfo.frames < BUFFER_SIZE)
{ printf ("Line %d: Incorrect number of.frames in file. (%d => %ld)\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
exit (1) ;
} ;
if (sfinfo.channels != 1)
{ printf ("Line %d: Incorrect number of channels in file.\n", __LINE__) ;
exit (1) ;
} ;
check_log_buffer_or_die (file, __LINE__) ;
if ((k = sf_read_short (file, buffer, BUFFER_SIZE)) != BUFFER_SIZE)
{ printf ("Line %d: short read (%d).\n", __LINE__, k) ;
exit (1) ;
} ;
for (k = 0 ; k < BUFFER_SIZE - 22 ; k++)
if (buffer [k + 22] != k)
{ printf ("Line %d: Incorrect sample (#%d : 0x%x => 0x%x).\n", __LINE__, k, k, buffer [k]) ;
exit (1) ;
} ;
sf_close (file) ;
printf ("ok\n") ;
unlink (filename) ;
} /* old_test */
static void
channel_map_test (const char *filename, int filetype)
{ SNDFILE *file ;
SF_INFO sfinfo ;
int channel_map_read [4], channel_map_write [4] =
{ SF_CHANNEL_MAP_LEFT, SF_CHANNEL_MAP_RIGHT, SF_CHANNEL_MAP_LFE,
SF_CHANNEL_MAP_REAR_CENTER
} ;
print_test_name ("channel_map_test", filename) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 11025 ;
sfinfo.format = filetype ;
sfinfo.channels = ARRAY_LEN (channel_map_read) ;
switch (filetype & SF_FORMAT_TYPEMASK)
{ /* WAVEX and RF64 have a default channel map, even if you don't specify one. */
case SF_FORMAT_WAVEX :
case SF_FORMAT_RF64 :
/* Write file without channel map. */
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
/* Read file making default channel map exists. */
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
exit_if_true (
sf_command (file, SFC_GET_CHANNEL_MAP_INFO, channel_map_read, sizeof (channel_map_read)) == SF_FALSE,
"\n\nLine %d : sf_command (SFC_GET_CHANNEL_MAP_INFO) should not have failed.\n\n", __LINE__
) ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
break ;
default :
break ;
} ;
/* Write file with a channel map. */
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
exit_if_true (
sf_command (file, SFC_SET_CHANNEL_MAP_INFO, channel_map_write, sizeof (channel_map_write)) == SF_FALSE,
"\n\nLine %d : sf_command (SFC_SET_CHANNEL_MAP_INFO) failed.\n\n", __LINE__
) ;
test_write_double_or_die (file, 0, double_data, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
/* Read file making sure no channel map exists. */
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
exit_if_true (
sf_command (file, SFC_GET_CHANNEL_MAP_INFO, channel_map_read, sizeof (channel_map_read)) != SF_TRUE,
"\n\nLine %d : sf_command (SFC_GET_CHANNEL_MAP_INFO) failed.\n\n", __LINE__
) ;
check_log_buffer_or_die (file, __LINE__) ;
sf_close (file) ;
exit_if_true (
memcmp (channel_map_read, channel_map_write, sizeof (channel_map_read)) != 0,
"\n\nLine %d : Channel map read does not match channel map written.\n\n", __LINE__
) ;
unlink (filename) ;
puts ("ok") ;
} /* channel_map_test */