static void
string_rdwr_grow_test (const char *filename, int typemajor)
{ SNDFILE *file ;
SF_INFO sfinfo ;
sf_count_t frames ;
const char * str ;
print_test_name (__func__, filename) ;
/* Create a file that contains some strings. Then open the file in RDWR mode and
grow the file by writing more audio data to it. Check that the audio data has
been added to the file, and that the strings are still there. */
/* Create a short file that contains a string. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 2 ;
sfinfo.frames = 0 ;
sfinfo.format = typemajor | SF_FORMAT_PCM_16 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
/* Write data to file. */
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
/* Write some strings at end of file. */
sf_set_string (file, SF_STR_TITLE , title) ;
sf_set_string (file, SF_STR_COMMENT, comment) ;
sf_close (file) ;
/* Now open file again in SFM_RDWR mode and write more audio data to it. */
file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
/* Write more data to file. */
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
/* Now open file again. It should now contain two BUFFER_LEN's worth of frames and the strings. */
frames = 2 * BUFFER_LEN / sfinfo.channels ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
exit_if_true (frames != sfinfo.frames, "\n\nLine %d : Frame count %" PRId64 " should be %" PRId64 ".\n", __LINE__, sfinfo.frames, frames) ;
/* Check the strings */
str = sf_get_string (file, SF_STR_TITLE) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_TITLE string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, title) != 0, "\n\nLine %d : SF_STR_TITLE doesn't match what was written.\n", __LINE__) ;
str = sf_get_string (file, SF_STR_COMMENT) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_COMMENT string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, comment) != 0, "\n\nLine %d : SF_STR_COMMENT doesn't match what was written.\n", __LINE__) ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
} /* string_rdwr_grow_test */
static void
rdwr_short_test (const char *filename)
{ SNDFILE *file ;
SF_INFO sfinfo ;
sf_count_t frames ;
short buffer [160] ;
print_test_name ("rdwr_short_test", filename) ;
memset (buffer, 0, sizeof (buffer)) ;
/* Create sound file with no data. */
sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16 ;
sfinfo.samplerate = 16000 ;
sfinfo.channels = 1 ;
unlink (filename) ;
frames = ARRAY_LEN (buffer) ;
/* Open again for read/write. */
file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
test_write_short_or_die (file, 0, buffer, frames, __LINE__) ;
test_read_short_or_die (file, 0, buffer, frames, __LINE__) ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
return ;
} /* rdwr_short_test */
static void
string_short_rdwr_test (const char *filename, int typemajor)
{ SNDFILE *file ;
SF_INFO sfinfo ;
sf_count_t frames = BUFFER_LEN ;
const char * str ;
print_test_name (__func__, filename) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.format = typemajor | SF_FORMAT_PCM_16 ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
/* Write data to file. */
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
sf_set_string (file, SF_STR_TITLE, long_title) ;
sf_set_string (file, SF_STR_ARTIST, long_artist) ;
sf_close (file) ;
/* Open the file RDWR. */
file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_FALSE, __LINE__) ;
exit_if_true (frames != sfinfo.frames, "\n\nLine %d : Frame count %" PRId64 " should be %" PRId64 ".\n", __LINE__, sfinfo.frames, frames) ;
str = sf_get_string (file, SF_STR_TITLE) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_TITLE string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, long_title) != 0, "\n\nLine %d : SF_STR_TITLE doesn't match what was written.\n", __LINE__) ;
str = sf_get_string (file, SF_STR_ARTIST) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_TITLE string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, long_artist) != 0, "\n\nLine %d : SF_STR_ARTIST doesn't match what was written.\n", __LINE__) ;
/* Change title and artist. */
sf_set_string (file, SF_STR_TITLE, title) ;
sf_set_string (file, SF_STR_ARTIST, artist) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
check_log_buffer_or_die (file, __LINE__) ;
str = sf_get_string (file, SF_STR_TITLE) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_TITLE string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, title) != 0, "\n\nLine %d : SF_STR_TITLE doesn't match what was written.\n", __LINE__) ;
str = sf_get_string (file, SF_STR_ARTIST) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_ARTIST string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, artist) != 0, "\n\nLine %d : SF_STR_ARTIST doesn't match what was written.\n", __LINE__) ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
} /* string_short_rdwr_test */
static void
error_close_test (void)
{ static short buffer [SHORT_BUFFER] ;
const char *filename = "error_close.wav" ;
SNDFILE *sndfile ;
SF_INFO sfinfo ;
FILE *file ;
print_test_name (__func__, filename) ;
/* Open a FILE* from which we will extract a file descriptor. */
if ((file = fopen (filename, "w")) == NULL)
{ printf ("\n\nLine %d : fopen returned NULL.\n", __LINE__) ;
exit (1) ;
} ;
/* Set parameters for writing the file. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.channels = 1 ;
sfinfo.samplerate = 44100 ;
sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16 ;
sndfile = sf_open_fd (fileno (file), SFM_WRITE, &sfinfo, SF_TRUE) ;
if (sndfile == NULL)
{ printf ("\n\nLine %d : sf_open_fd failed : %s\n", __LINE__, sf_strerror (NULL)) ;
exit (1) ;
} ;
test_write_short_or_die (sndfile, 0, buffer, ARRAY_LEN (buffer), __LINE__) ;
/* Now close the fd associated with file before calling sf_close. */
fclose (file) ;
if (sf_close (sndfile) == 0)
{
#if OS_IS_WIN32
OSVERSIONINFOEX osvi ;
memset (&osvi, 0, sizeof (OSVERSIONINFOEX)) ;
osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX) ;
if (GetVersionEx ((OSVERSIONINFO *) &osvi))
{ printf ("\n\nLine %d : sf_close should not have returned zero.\n", __LINE__) ;
printf ("\nHowever, this is a known bug in version %d.%d of windows so we'll ignore it.\n\n",
(int) osvi.dwMajorVersion, (int) osvi.dwMinorVersion) ;
} ;
#else
printf ("\n\nLine %d : sf_close should not have returned zero.\n", __LINE__) ;
exit (1) ;
#endif
} ;
unlink (filename) ;
puts ("ok") ;
} /* error_close_test */
static void
rf64_downgrade_test (const char *filename)
{ static short output [BUFFER_LEN] ;
static short input [BUFFER_LEN] ;
SNDFILE *file ;
SF_INFO sfinfo ;
unsigned k ;
print_test_name (__func__, filename) ;
sf_info_clear (&sfinfo) ;
sfinfo.samplerate = 44100 ;
sfinfo.frames = ARRAY_LEN (output) ;
sfinfo.channels = 1 ;
sfinfo.format = SF_FORMAT_RF64 | SF_FORMAT_PCM_16 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
exit_if_true (sf_command (file, SFC_RF64_AUTO_DOWNGRADE, NULL, SF_FALSE) != SF_FALSE, "\n\nLine %d: sf_command failed.\n", __LINE__) ;
exit_if_true (sf_command (file, SFC_RF64_AUTO_DOWNGRADE, NULL, SF_TRUE) != SF_TRUE, "\n\nLine %d: sf_command failed.\n", __LINE__) ;
test_write_short_or_die (file, 0, output, ARRAY_LEN (output), __LINE__) ;
exit_if_true (sf_command (file, SFC_RF64_AUTO_DOWNGRADE, NULL, SF_FALSE) != SF_TRUE, "\n\nLine %d: sf_command failed.\n", __LINE__) ;
exit_if_true (sf_command (file, SFC_RF64_AUTO_DOWNGRADE, NULL, SF_TRUE) != SF_TRUE, "\n\nLine %d: sf_command failed.\n", __LINE__) ;
sf_close (file) ;
memset (input, 0, sizeof (input)) ;
sf_info_clear (&sfinfo) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
exit_if_true (sfinfo.format != (SF_FORMAT_WAVEX | SF_FORMAT_PCM_16), "\n\nLine %d: RF64 to WAV downgrade failed.\n", __LINE__) ;
exit_if_true (sfinfo.frames != ARRAY_LEN (output), "\n\nLine %d: Incorrect number of frames in file (too short). (%d should be %d)\n", __LINE__, (int) sfinfo.frames, (int) ARRAY_LEN (output)) ;
exit_if_true (sfinfo.channels != 1, "\n\nLine %d: Incorrect number of channels in file.\n", __LINE__) ;
check_log_buffer_or_die (file, __LINE__) ;
test_read_short_or_die (file, 0, input, ARRAY_LEN (input), __LINE__) ;
sf_close (file) ;
for (k = 0 ; k < ARRAY_LEN (input) ; k++)
exit_if_true (input [k] != output [k],
"\n\nLine: %d: Error on input %d, expected %d, got %d\n", __LINE__, k, output [k], input [k]) ;
puts ("ok") ;
unlink (filename) ;
return ;
} /* rf64_downgrade_test */
static void
ogg_short_test (void)
{ const char * filename = "vorbis_short.oga" ;
SNDFILE * file ;
SF_INFO sfinfo ;
short seek_data [10] ;
unsigned k ;
print_test_name ("ogg_short_test", filename) ;
/* Generate float data. */
gen_windowed_sine_float (data_out.f, ARRAY_LEN (data_out.f), 1.0 * 0x7F00) ;
/* Convert to shorteger. */
for (k = 0 ; k < ARRAY_LEN (data_out.s) ; k++)
data_out.s [k] = lrintf (data_out.f [k]) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
/* Set up output file type. */
sfinfo.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS ;
sfinfo.channels = 1 ;
sfinfo.samplerate = SAMPLE_RATE ;
/* Write the output file. */
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
test_write_short_or_die (file, 0, data_out.s, ARRAY_LEN (data_out.s), __LINE__) ;
sf_close (file) ;
/* Read the file in again. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
test_read_short_or_die (file, 0, data_in.s, ARRAY_LEN (data_in.s), __LINE__) ;
sf_close (file) ;
puts ("ok") ;
/* Test seeking. */
print_test_name ("ogg_seek_test", filename) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
test_seek_or_die (file, 10, SEEK_SET, 10, sfinfo.channels, __LINE__) ;
test_read_short_or_die (file, 0, seek_data, ARRAY_LEN (seek_data), __LINE__) ;
compare_short_or_die (seek_data, data_in.s + 10, ARRAY_LEN (seek_data), __LINE__) ;
sf_close (file) ;
puts ("ok") ;
unlink (filename) ;
} /* ogg_short_test */
static void
checksum_test (const CHECKSUM * cksum)
{ SNDFILE * file ;
SF_INFO info ;
print_test_name (__func__, cksum->enc_name) ;
memset (&info, 0, sizeof (SF_INFO)) ;
info.format = cksum->enc_fmt ;
info.channels = 1 ;
info.samplerate = SAMPLE_RATE ;
file = test_open_file_or_die (cksum->enc_name, SFM_WRITE, &info, 0, __LINE__) ;
test_write_float_or_die (file, 0, orig, ARRAY_LEN (orig), __LINE__) ;
sf_close (file) ;
check_file_hash_or_die (cksum->enc_name, cksum->enc_cksum, __LINE__) ;
puts ("ok") ;
/*------------------------------------------------------------------------*/
print_test_name (__func__, cksum->dec_name) ;
memset (&info, 0, sizeof (SF_INFO)) ;
info.format = cksum->enc_fmt ;
info.channels = 1 ;
info.samplerate = SAMPLE_RATE ;
file = test_open_file_or_die (cksum->enc_name, SFM_READ, &info, 0, __LINE__) ;
test_read_short_or_die (file, 0, data, ARRAY_LEN (data), __LINE__) ;
sf_close (file) ;
memset (&info, 0, sizeof (SF_INFO)) ;
info.format = SF_ENDIAN_LITTLE | SF_FORMAT_RAW | SF_FORMAT_PCM_16 ;
info.channels = 1 ;
info.samplerate = SAMPLE_RATE ;
file = test_open_file_or_die (cksum->dec_name, SFM_WRITE, &info, 0, __LINE__) ;
test_write_short_or_die (file, 0, data, ARRAY_LEN (data), __LINE__) ;
sf_close (file) ;
check_file_hash_or_die (cksum->dec_name, cksum->dec_cksum, __LINE__) ;
remove (cksum->enc_name) ;
remove (cksum->dec_name) ;
puts ("ok") ;
} /* checksum_test */
static void
locale_test (const LOCALE_DATA * ldata)
{
#if !HAVE_LOCALE_H || !HAVE_SETLOCALE
locname = filename = NULL ;
width = 0 ;
return ;
#else
const short wdata [] = { 1, 2, 3, 4, 5, 6, 7, 8 } ;
short rdata [ARRAY_LEN (wdata)] ;
const char *old_locale ;
char utf8_locname [32] ;
SNDFILE *file ;
SF_INFO sfinfo ;
snprintf (utf8_locname, sizeof (utf8_locname), "%s%s", ldata->locale, ldata->utf8 ? ".UTF-8" : "") ;
/* Change the locale saving the old one. */
if ((old_locale = setlocale (LC_CTYPE, utf8_locname)) == NULL)
return ;
printf (" locale_test %-8s : %s %*c ", ldata->locale, ldata->filename, 24 - ldata->width, ' ') ;
fflush (stdout) ;
sfinfo.format = SF_FORMAT_AU | SF_FORMAT_PCM_16 ;
sfinfo.channels = 1 ;
sfinfo.samplerate = 44100 ;
file = test_open_file_or_die (ldata->filename, SFM_WRITE, &sfinfo, 0, __LINE__) ;
test_write_short_or_die (file, 0, wdata, ARRAY_LEN (wdata), __LINE__) ;
sf_close (file) ;
file = test_open_file_or_die (ldata->filename, SFM_READ, &sfinfo, 0, __LINE__) ;
test_read_short_or_die (file, 0, rdata, ARRAY_LEN (rdata), __LINE__) ;
sf_close (file) ;
unlink (ldata->filename) ;
/* Restore old locale. */
setlocale (LC_CTYPE, old_locale) ;
puts ("ok") ;
#endif
} /* locale_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
update_seek_short_test (const char *filename, int filetype)
{ SNDFILE *outfile, *infile ;
SF_INFO sfinfo ;
sf_count_t frames ;
short buffer [8] ;
int k ;
print_test_name ("update_seek_short_test", filename) ;
memset (buffer, 0, sizeof (buffer)) ;
/* Create sound outfile with no data. */
sfinfo.format = filetype | SF_FORMAT_PCM_16 ;
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_short_or_die (outfile, k, buffer, sfinfo.channels * frames, __LINE__) ;
else
test_writef_short_or_die (outfile, k, buffer, frames, __LINE__) ;
} ;
sf_close (outfile) ;
unlink (filename) ;
puts ("ok") ;
return ;
} /* update_seek_short_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
update_header_test (char *filename, int typemajor)
{ SNDFILE *outfile, *infile ;
SF_INFO sfinfo ;
int k, frames ;
printf (" update_header_test : %s ", filename) ;
fflush (stdout) ;
k = abs (18 - strlen (filename)) ;
PUT_DOTS (k) ;
sfinfo.samplerate = 44100 ;
sfinfo.format = (typemajor | SF_FORMAT_PCM_16) ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
frames = BUFFER_LEN / sfinfo.channels ;
outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, __LINE__) ;
for (k = 0 ; k < BUFFER_LEN ; k++)
data_out [k] = k + 1 ;
test_write_short_or_die (outfile, 0, data_out, BUFFER_LEN, __LINE__) ;
infile = test_open_file_or_die (filename, SFM_READ, &sfinfo, __LINE__) ;
sf_close (infile) ;
sf_command (outfile, SFC_UPDATE_HEADER_NOW, NULL, 0) ;
/* Open file and check log buffer for an error. If header update failed
** the the log buffer will contain errors.
*/
infile = test_open_file_or_die (filename, SFM_READ, &sfinfo, __LINE__) ;
check_log_buffer_or_die (infile) ;
if (abs (BUFFER_LEN - sfinfo.frames) > 1)
{ printf ("\n\nLine %d : Incorrect sample count (%ld should be %d)\n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), BUFFER_LEN) ;
dump_log_buffer (infile) ;
exit (1) ;
} ;
test_read_short_or_die (infile, 0, data_in, BUFFER_LEN, __LINE__) ;
for (k = 0 ; k < BUFFER_LEN ; k++)
if (data_out [k] != k + 1)
printf ("Error : line %d\n", __LINE__) ;
sf_close (infile) ;
/* Set auto update on. */
sf_command (outfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
/* Write more data_out. */
for (k = 0 ; k < BUFFER_LEN ; k++)
data_out [k] = k + 2 ;
test_write_short_or_die (outfile, 0, data_out, BUFFER_LEN, __LINE__) ;
/* Open file again and make sure no errors in log buffer. */
infile = test_open_file_or_die (filename, SFM_READ, &sfinfo, __LINE__) ;
check_log_buffer_or_die (infile) ;
if (abs (2 * BUFFER_LEN - sfinfo.frames) > 1)
{ printf ("\n\nLine %d : Incorrect sample count (%ld should be %d)\n", __LINE__, SF_COUNT_TO_LONG (sfinfo.frames), 2 * BUFFER_LEN) ;
dump_log_buffer (infile) ;
exit (1) ;
} ;
sf_close (infile) ;
sf_close (outfile) ;
unlink (filename) ;
puts ("ok") ;
} /* update_header_test */
static void
string_header_update (const char *filename, int typemajor)
{ SNDFILE *file , *file1 ;
SF_INFO sfinfo , sfinfo1 ;
sf_count_t frames ;
const char * str ;
const int GROW_BUFFER_AMOUNT = 4 ; /* this should be less than half the size of the string header */
print_test_name (__func__, filename) ;
/* Create a short file. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 2 ;
sfinfo.frames = 0 ;
sfinfo.format = typemajor | SF_FORMAT_PCM_16 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
sf_set_string (file, SF_STR_TITLE, long_title) ;
sf_close (file) ;
/* Check that SFC_UPDATE_HEADER_NOW correctly calculates datalength. */
file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
/* Write a very small amount of new audio data that doesn't completely overwrite the existing header. */
test_write_short_or_die (file, 0, data_out, GROW_BUFFER_AMOUNT, __LINE__) ;
/* Update the header without closing the file. */
sf_command (file, SFC_UPDATE_HEADER_NOW, NULL, 0) ;
/* The file should now contain BUFFER_LEN + GROW_BUFFER_AMOUNT frames.
Open a second handle to the file and check the reported length. */
memset (&sfinfo1, 0, sizeof (sfinfo1)) ;
file1 = test_open_file_or_die (filename, SFM_READ, &sfinfo1, SF_TRUE, __LINE__) ;
frames = (BUFFER_LEN + GROW_BUFFER_AMOUNT) / sfinfo.channels ;
exit_if_true (frames != sfinfo1.frames, "\n\nLine %d : Frame count %" PRId64 " should be %" PRId64 ".\n", __LINE__, sfinfo1.frames, frames) ;
/* The strings are probably not readable by the second soundfile handle because write_tailer has not yet been called.
It's a design decision whether SFC_UPDATE_HEADER_NOW should write the tailer. I think it's fine that it doesn't. */
sf_close (file1) ;
sf_close (file) ;
/* Check that sf_close correctly calculates datalength. */
file = test_open_file_or_die (filename, SFM_RDWR, &sfinfo, SF_TRUE, __LINE__) ;
/* Write a very small amount of new audio data that doesn't completely overwrite the existing header. */
test_write_short_or_die (file, 0, data_out, GROW_BUFFER_AMOUNT, __LINE__) ;
sf_close (file) ;
/* Open file again and verify data and string. */
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
frames = (BUFFER_LEN + 2*GROW_BUFFER_AMOUNT) / sfinfo.channels ;
exit_if_true (frames != sfinfo.frames, "\n\nLine %d : Frame count %" PRId64 " should be %" PRId64 ".\n", __LINE__, sfinfo.frames, frames) ;
str = sf_get_string (file, SF_STR_TITLE) ;
exit_if_true (str == NULL, "\n\nLine %d : SF_STR_TITLE string is NULL.\n", __LINE__) ;
exit_if_true (strcmp (str, long_title) != 0, "\n\nLine %d : SF_STR_TITLE doesn't match what was written.\n", __LINE__) ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
} /* string_header_update */
static void
string_multi_set_test (const char *filename, int typemajor)
{ static const char
new_software [] = "new software (libsndfile-X.Y.Z)",
new_copyright [] = "Copyright (c) 2001 New Artist",
new_artist [] = "The New Artist",
new_title [] = "This is the new title" ;
static char buffer [2048] ;
SNDFILE *file ;
SF_INFO sfinfo ;
int count ;
print_test_name (__func__, filename) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.format = typemajor | SF_FORMAT_PCM_16 ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
/* Write stuff at start of file. */
sf_set_string (file, SF_STR_TITLE, title) ;
sf_set_string (file, SF_STR_SOFTWARE, software) ;
sf_set_string (file, SF_STR_ARTIST, artist) ;
/* Write data to file. */
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
/* Write it all again. */
sf_set_string (file, SF_STR_TITLE, new_title) ;
sf_set_string (file, SF_STR_SOFTWARE, new_software) ;
sf_set_string (file, SF_STR_ARTIST, new_artist) ;
sf_set_string (file, SF_STR_COPYRIGHT, copyright) ;
sf_set_string (file, SF_STR_COMMENT, comment) ;
sf_set_string (file, SF_STR_DATE, date) ;
sf_set_string (file, SF_STR_ALBUM, album) ;
sf_set_string (file, SF_STR_LICENSE, license) ;
sf_set_string (file, SF_STR_COPYRIGHT, new_copyright) ;
sf_set_string (file, SF_STR_COMMENT, comment) ;
sf_set_string (file, SF_STR_DATE, date) ;
sf_set_string (file, SF_STR_ALBUM, album) ;
sf_set_string (file, SF_STR_LICENSE, license) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
sf_command (file, SFC_GET_LOG_INFO, buffer, sizeof (buffer)) ;
sf_close (file) ;
count = str_count (buffer, new_title) ;
exit_if_true (count < 1, "\n\nLine %d : Could not find new_title in :\n%s\n", __LINE__, buffer) ;
exit_if_true (count > 1, "\n\nLine %d : new_title appears %d times in :\n\n%s\n", __LINE__, count, buffer) ;
count = str_count (buffer, software) ;
exit_if_true (count < 1, "\n\nLine %d : Could not find new_software in :\n%s\n", __LINE__, buffer) ;
exit_if_true (count > 1, "\n\nLine %d : new_software appears %d times in :\n\n%s\n", __LINE__, count, buffer) ;
count = str_count (buffer, new_artist) ;
exit_if_true (count < 1, "\n\nLine %d : Could not find new_artist in :\n%s\n", __LINE__, buffer) ;
exit_if_true (count > 1, "\n\nLine %d : new_artist appears %d times in :\n\n%s\n", __LINE__, count, buffer) ;
count = str_count (buffer, new_copyright) ;
exit_if_true (count < 1, "\n\nLine %d : Could not find new_copyright in :\n%s\n", __LINE__, buffer) ;
exit_if_true (count > 1, "\n\nLine %d : new_copyright appears %d times in :\n\n%s\n", __LINE__, count, buffer) ;
unlink (filename) ;
puts ("ok") ;
} /* string_multi_set_test */
static void
string_start_test (const char *filename, int formattype)
{ const char *cptr ;
SNDFILE *file ;
SF_INFO sfinfo ;
int errors = 0 ;
int typemajor = SF_FORMAT_TYPEMASK & formattype ;
print_test_name ("string_start_test", filename) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
switch (formattype)
{ case SF_FORMAT_OGG | SF_FORMAT_OPUS :
/* Opus only supports some discrete sample rates. */
sfinfo.samplerate = 48000 ;
break ;
case SF_FORMAT_OGG | SF_FORMAT_VORBIS :
break ;
default :
formattype |= SF_FORMAT_PCM_16 ;
break ;
} ;
sfinfo.format = formattype ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
/* Write stuff at start of file. */
sf_set_string (file, SF_STR_TITLE, filename) ;
sf_set_string (file, SF_STR_SOFTWARE, software) ;
sf_set_string (file, SF_STR_ARTIST, artist) ;
sf_set_string (file, SF_STR_COPYRIGHT, copyright) ;
sf_set_string (file, SF_STR_COMMENT, comment) ;
sf_set_string (file, SF_STR_DATE, date) ;
sf_set_string (file, SF_STR_ALBUM, album) ;
sf_set_string (file, SF_STR_LICENSE, license) ;
/* Write data to file. */
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
check_log_buffer_or_die (file, __LINE__) ;
if (sfinfo.frames != BUFFER_LEN)
{ printf ("***** Bad frame count %d (should be %d)\n\n", (int) sfinfo.frames, BUFFER_LEN) ;
errors ++ ;
} ;
cptr = sf_get_string (file, SF_STR_TITLE) ;
if (cptr == NULL || strcmp (filename, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad filename : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_COPYRIGHT) ;
if (cptr == NULL || strcmp (copyright, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad copyright : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_SOFTWARE) ;
if (cptr == NULL || strstr (cptr, software) != cptr)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad software : %s\n", cptr) ;
} ;
if (cptr && str_count (cptr, "libsndfile") != 1)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad software : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_ARTIST) ;
if (cptr == NULL || strcmp (artist, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad artist : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_COMMENT) ;
if (cptr == NULL || strcmp (comment, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad comment : %s\n", cptr) ;
} ;
if (typemajor != SF_FORMAT_AIFF)
{ cptr = sf_get_string (file, SF_STR_DATE) ;
if (cptr == NULL || strcmp (date, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad date : %s\n", cptr) ;
} ;
} ;
if (typemajor != SF_FORMAT_WAV && typemajor != SF_FORMAT_AIFF)
{ cptr = sf_get_string (file, SF_STR_ALBUM) ;
if (cptr == NULL || strcmp (album, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad album : %s\n", cptr) ;
} ;
} ;
if (typemajor != SF_FORMAT_WAV && typemajor != SF_FORMAT_AIFF && typemajor != SF_FORMAT_RF64)
{ cptr = sf_get_string (file, SF_STR_LICENSE) ;
if (cptr == NULL || strcmp (license, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad license : %s\n", cptr) ;
} ;
} ;
if (errors > 0)
{ printf ("\n*** Error count : %d ***\n\n", errors) ;
dump_log_buffer (file) ;
exit (1) ;
} ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
} /* string_start_test */
static void
string_start_end_test (const char *filename, int typemajor)
{ const char *cptr ;
SNDFILE *file ;
SF_INFO sfinfo ;
int errors = 0 ;
print_test_name ("string_start_end_test", filename) ;
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.samplerate = 44100 ;
sfinfo.channels = 1 ;
sfinfo.frames = 0 ;
sfinfo.format = typemajor | SF_FORMAT_PCM_16 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
/* Write stuff at start of file. */
sf_set_string (file, SF_STR_TITLE, filename) ;
sf_set_string (file, SF_STR_SOFTWARE, software) ;
sf_set_string (file, SF_STR_ARTIST, artist) ;
sf_set_string (file, SF_STR_GENRE, genre) ;
sf_set_string (file, SF_STR_TRACKNUMBER, trackno) ;
/* Write data to file. */
test_write_short_or_die (file, 0, data_out, BUFFER_LEN, __LINE__) ;
test_seek_or_die (file, 0, SEEK_SET, 0, sfinfo.channels, __LINE__) ;
/* Write more stuff at end of file. */
sf_set_string (file, SF_STR_COPYRIGHT, copyright) ;
sf_set_string (file, SF_STR_COMMENT, comment) ;
sf_set_string (file, SF_STR_DATE, date) ;
sf_set_string (file, SF_STR_ALBUM, album) ;
sf_set_string (file, SF_STR_LICENSE, license) ;
sf_close (file) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
check_log_buffer_or_die (file, __LINE__) ;
if (sfinfo.frames != BUFFER_LEN)
{ printf ("***** Bad frame count %d (should be %d)\n\n", (int) sfinfo.frames, BUFFER_LEN) ;
errors ++ ;
} ;
cptr = sf_get_string (file, SF_STR_TITLE) ;
if (cptr == NULL || strcmp (filename, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad filename : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_COPYRIGHT) ;
if (cptr == NULL || strcmp (copyright, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad copyright : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_SOFTWARE) ;
if (cptr == NULL || strstr (cptr, software) != cptr)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad software : %s\n", cptr) ;
} ;
if (str_count (cptr, "libsndfile") != 1)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad software : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_ARTIST) ;
if (cptr == NULL || strcmp (artist, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad artist : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_COMMENT) ;
if (cptr == NULL || strcmp (comment, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad comment : %s\n", cptr) ;
} ;
if (typemajor != SF_FORMAT_AIFF)
{ cptr = sf_get_string (file, SF_STR_DATE) ;
if (cptr == NULL || strcmp (date, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad date : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_GENRE) ;
if (cptr == NULL || strcmp (genre, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad genre : %s\n", cptr) ;
} ;
} ;
switch (typemajor)
{ case SF_FORMAT_AIFF :
case SF_FORMAT_WAV :
case SF_FORMAT_WAVEX :
case SF_ENDIAN_BIG | SF_FORMAT_WAV :
case SF_FORMAT_RF64 :
/* These formats do not support the following. */
break ;
default :
cptr = sf_get_string (file, SF_STR_ALBUM) ;
if (cptr == NULL || strcmp (album, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad album : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_LICENSE) ;
if (cptr == NULL || strcmp (license, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad license : %s\n", cptr) ;
} ;
cptr = sf_get_string (file, SF_STR_TRACKNUMBER) ;
if (cptr == NULL || strcmp (trackno, cptr) != 0)
{ if (errors++ == 0)
puts ("\n") ;
printf (" Bad track no. : %s\n", cptr) ;
} ;
break ;
} ;
if (errors > 0)
{ printf ("\n*** Error count : %d ***\n\n", errors) ;
dump_log_buffer (file) ;
exit (1) ;
} ;
sf_close (file) ;
unlink (filename) ;
puts ("ok") ;
} /* string_start_end_test */
