annotate src/libsndfile-1.0.25/tests/scale_clip_test.c @ 169:223a55898ab9 tip default

Add null config files
author Chris Cannam <cannam@all-day-breakfast.com>
date Mon, 02 Mar 2020 14:03:47 +0000
parents 545efbb81310
children
rev   line source
cannam@85 1 /*
cannam@85 2 ** Copyright (C) 1999-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
cannam@85 3 **
cannam@85 4 ** This program is free software; you can redistribute it and/or modify
cannam@85 5 ** it under the terms of the GNU General Public License as published by
cannam@85 6 ** the Free Software Foundation; either version 2 of the License, or
cannam@85 7 ** (at your option) any later version.
cannam@85 8 **
cannam@85 9 ** This program is distributed in the hope that it will be useful,
cannam@85 10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@85 11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
cannam@85 12 ** GNU General Public License for more details.
cannam@85 13 **
cannam@85 14 ** You should have received a copy of the GNU General Public License
cannam@85 15 ** along with this program; if not, write to the Free Software
cannam@85 16 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cannam@85 17 */
cannam@85 18
cannam@85 19 #include "sfconfig.h"
cannam@85 20
cannam@85 21 #include <stdio.h>
cannam@85 22 #include <stdlib.h>
cannam@85 23 #include <string.h>
cannam@85 24
cannam@85 25 #if HAVE_UNISTD_H
cannam@85 26 #include <unistd.h>
cannam@85 27 #endif
cannam@85 28
cannam@85 29 #include <math.h>
cannam@85 30
cannam@85 31 #include <sndfile.h>
cannam@85 32
cannam@85 33 #include "utils.h"
cannam@85 34
cannam@85 35 #ifndef M_PI
cannam@85 36 #define M_PI 3.14159265358979323846264338
cannam@85 37 #endif
cannam@85 38
cannam@85 39 #define HALF_BUFFER_SIZE (1 << 12)
cannam@85 40 #define BUFFER_SIZE (2 * HALF_BUFFER_SIZE)
cannam@85 41
cannam@85 42 #define SINE_AMP 1.1
cannam@85 43 #define MAX_ERROR 0.0202
cannam@85 44
cannam@85 45
cannam@85 46 static void flt_scale_clip_test_16 (const char *filename, int filetype, float maxval) ;
cannam@85 47 static void flt_scale_clip_test_24 (const char *filename, int filetype, float maxval) ;
cannam@85 48 static void flt_scale_clip_test_32 (const char *filename, int filetype, float maxval) ;
cannam@85 49 static void flt_scale_clip_test_08 (const char *filename, int filetype, float maxval) ;
cannam@85 50
cannam@85 51 static void dbl_scale_clip_test_16 (const char *filename, int filetype, float maxval) ;
cannam@85 52 static void dbl_scale_clip_test_24 (const char *filename, int filetype, float maxval) ;
cannam@85 53 static void dbl_scale_clip_test_32 (const char *filename, int filetype, float maxval) ;
cannam@85 54 static void dbl_scale_clip_test_08 (const char *filename, int filetype, float maxval) ;
cannam@85 55
cannam@85 56
cannam@85 57
cannam@85 58 static void flt_short_clip_read_test (const char *filename, int filetype) ;
cannam@85 59 static void flt_int_clip_read_test (const char *filename, int filetype) ;
cannam@85 60
cannam@85 61 static void dbl_short_clip_read_test (const char *filename, int filetype) ;
cannam@85 62 static void dbl_int_clip_read_test (const char *filename, int filetype) ;
cannam@85 63
cannam@85 64
cannam@85 65
cannam@85 66 static void short_flt_scale_write_test (const char *filename, int filetype) ;
cannam@85 67 static void short_dbl_scale_write_test (const char *filename, int filetype) ;
cannam@85 68
cannam@85 69 static void int_flt_scale_write_test (const char *filename, int filetype) ;
cannam@85 70 static void int_dbl_scale_write_test (const char *filename, int filetype) ;
cannam@85 71
cannam@85 72
cannam@85 73 typedef union
cannam@85 74 { double dbl [BUFFER_SIZE] ;
cannam@85 75 float flt [BUFFER_SIZE] ;
cannam@85 76 int i [BUFFER_SIZE] ;
cannam@85 77 short s [BUFFER_SIZE] ;
cannam@85 78 } BUFFER ;
cannam@85 79
cannam@85 80 /* Data buffer. */
cannam@85 81 static BUFFER buffer_out ;
cannam@85 82 static BUFFER buffer_in ;
cannam@85 83
cannam@85 84 int
cannam@85 85 main (void)
cannam@85 86 {
cannam@85 87 flt_scale_clip_test_08 ("scale_clip_s8.au", SF_FORMAT_AU | SF_FORMAT_PCM_S8, 1.0 * 0x80) ;
cannam@85 88 flt_scale_clip_test_08 ("scale_clip_u8.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8, 1.0 * 0x80) ;
cannam@85 89
cannam@85 90 dbl_scale_clip_test_08 ("scale_clip_s8.au", SF_FORMAT_AU | SF_FORMAT_PCM_S8, 1.0 * 0x80) ;
cannam@85 91 dbl_scale_clip_test_08 ("scale_clip_u8.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8, 1.0 * 0x80) ;
cannam@85 92
cannam@85 93 /*
cannam@85 94 ** Now use SF_FORMAT_AU where possible because it allows both
cannam@85 95 ** big and little endian files.
cannam@85 96 */
cannam@85 97
cannam@85 98 flt_scale_clip_test_16 ("scale_clip_be16.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
cannam@85 99 flt_scale_clip_test_16 ("scale_clip_le16.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
cannam@85 100 flt_scale_clip_test_24 ("scale_clip_be24.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
cannam@85 101 flt_scale_clip_test_24 ("scale_clip_le24.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
cannam@85 102 flt_scale_clip_test_32 ("scale_clip_be32.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
cannam@85 103 flt_scale_clip_test_32 ("scale_clip_le32.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
cannam@85 104
cannam@85 105 dbl_scale_clip_test_16 ("scale_clip_be16.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
cannam@85 106 dbl_scale_clip_test_16 ("scale_clip_le16.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_16, 1.0 * 0x8000) ;
cannam@85 107 dbl_scale_clip_test_24 ("scale_clip_be24.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
cannam@85 108 dbl_scale_clip_test_24 ("scale_clip_le24.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_24, 1.0 * 0x800000) ;
cannam@85 109 dbl_scale_clip_test_32 ("scale_clip_be32.au", SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
cannam@85 110 dbl_scale_clip_test_32 ("scale_clip_le32.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_PCM_32, 1.0 * 0x80000000) ;
cannam@85 111
cannam@85 112 flt_short_clip_read_test ("flt_short.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
cannam@85 113 flt_int_clip_read_test ("flt_int.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
cannam@85 114 dbl_short_clip_read_test ("dbl_short.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
cannam@85 115 dbl_int_clip_read_test ("dbl_int.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
cannam@85 116
cannam@85 117 short_flt_scale_write_test ("short_flt.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
cannam@85 118 int_flt_scale_write_test ("int_flt.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_FLOAT) ;
cannam@85 119 short_dbl_scale_write_test ("short_dbl.au" , SF_ENDIAN_BIG | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
cannam@85 120 int_dbl_scale_write_test ("int_dbl.au" , SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_DOUBLE) ;
cannam@85 121
cannam@85 122 return 0 ;
cannam@85 123 } /* main */
cannam@85 124
cannam@85 125 /*============================================================================================
cannam@85 126 ** Here are the test functions.
cannam@85 127 */
cannam@85 128
cannam@85 129
cannam@85 130 static void
cannam@85 131 flt_scale_clip_test_16 (const char *filename, int filetype, float maxval)
cannam@85 132 { SNDFILE *file ;
cannam@85 133 SF_INFO sfinfo ;
cannam@85 134 int k ;
cannam@85 135 float *data_out, *data_in ;
cannam@85 136 double diff, clip_max_diff ;
cannam@85 137
cannam@85 138 print_test_name ("flt_scale_clip_test_16", filename) ;
cannam@85 139
cannam@85 140 data_out = buffer_out.flt ;
cannam@85 141 data_in = buffer_in.flt ;
cannam@85 142
cannam@85 143 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 144 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 145 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 146 } ;
cannam@85 147
cannam@85 148 sfinfo.samplerate = 44100 ;
cannam@85 149 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 150 sfinfo.channels = 1 ;
cannam@85 151 sfinfo.format = filetype ;
cannam@85 152
cannam@85 153 /*
cannam@85 154 ** Write two versions of the data:
cannam@85 155 ** normalized and clipped
cannam@85 156 ** un-normalized and clipped.
cannam@85 157 */
cannam@85 158
cannam@85 159 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 160 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 161 test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 162 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 163 test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 164 sf_close (file) ;
cannam@85 165
cannam@85 166 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 167
cannam@85 168 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 169
cannam@85 170 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 171
cannam@85 172 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 173 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 174 exit (1) ;
cannam@85 175 } ;
cannam@85 176
cannam@85 177 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 178 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 179 exit (1) ;
cannam@85 180 } ;
cannam@85 181
cannam@85 182 if (sfinfo.channels != 1)
cannam@85 183 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 184 exit (1) ;
cannam@85 185 } ;
cannam@85 186
cannam@85 187 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 188
cannam@85 189 test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 190 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 191 test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 192 sf_close (file) ;
cannam@85 193
cannam@85 194 /* Check normalized version. */
cannam@85 195 clip_max_diff = 0.0 ;
cannam@85 196 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 197 { if (fabs (data_in [k]) > 1.0)
cannam@85 198 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 199 exit (1) ;
cannam@85 200 } ;
cannam@85 201
cannam@85 202 if (data_out [k] * data_in [k] < 0.0)
cannam@85 203 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 204 exit (1) ;
cannam@85 205 } ;
cannam@85 206
cannam@85 207 if (fabs (data_out [k]) > 1.0)
cannam@85 208 continue ;
cannam@85 209
cannam@85 210 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 211 if (diff > clip_max_diff)
cannam@85 212 clip_max_diff = diff ;
cannam@85 213 } ;
cannam@85 214
cannam@85 215 if (clip_max_diff < 1e-20)
cannam@85 216 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 217 exit (1) ;
cannam@85 218 } ;
cannam@85 219
cannam@85 220 if (clip_max_diff > 1.0 / 0x8000)
cannam@85 221 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 222 exit (1) ;
cannam@85 223 } ;
cannam@85 224
cannam@85 225 /* Check the un-normalized data. */
cannam@85 226 clip_max_diff = 0.0 ;
cannam@85 227 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 228 { if (fabs (data_in [k]) > maxval)
cannam@85 229 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 230 exit (1) ;
cannam@85 231 } ;
cannam@85 232
cannam@85 233 if (data_out [k] * data_in [k] < 0.0)
cannam@85 234 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 235 exit (1) ;
cannam@85 236 } ;
cannam@85 237
cannam@85 238 if (fabs (data_out [k]) > maxval)
cannam@85 239 continue ;
cannam@85 240
cannam@85 241 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 242 if (diff > clip_max_diff)
cannam@85 243 clip_max_diff = diff ;
cannam@85 244 } ;
cannam@85 245
cannam@85 246 if (clip_max_diff < 1e-20)
cannam@85 247 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 248 exit (1) ;
cannam@85 249 } ;
cannam@85 250
cannam@85 251 if (clip_max_diff > 1.0)
cannam@85 252 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 253 exit (1) ;
cannam@85 254 } ;
cannam@85 255
cannam@85 256 printf ("ok\n") ;
cannam@85 257 unlink (filename) ;
cannam@85 258 } /* flt_scale_clip_test_16 */
cannam@85 259
cannam@85 260 static void
cannam@85 261 flt_scale_clip_test_24 (const char *filename, int filetype, float maxval)
cannam@85 262 { SNDFILE *file ;
cannam@85 263 SF_INFO sfinfo ;
cannam@85 264 int k ;
cannam@85 265 float *data_out, *data_in ;
cannam@85 266 double diff, clip_max_diff ;
cannam@85 267
cannam@85 268 print_test_name ("flt_scale_clip_test_24", filename) ;
cannam@85 269
cannam@85 270 data_out = buffer_out.flt ;
cannam@85 271 data_in = buffer_in.flt ;
cannam@85 272
cannam@85 273 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 274 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 275 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 276 } ;
cannam@85 277
cannam@85 278 sfinfo.samplerate = 44100 ;
cannam@85 279 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 280 sfinfo.channels = 1 ;
cannam@85 281 sfinfo.format = filetype ;
cannam@85 282
cannam@85 283 /*
cannam@85 284 ** Write two versions of the data:
cannam@85 285 ** normalized and clipped
cannam@85 286 ** un-normalized and clipped.
cannam@85 287 */
cannam@85 288
cannam@85 289 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 290 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 291 test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 292 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 293 test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 294 sf_close (file) ;
cannam@85 295
cannam@85 296 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 297
cannam@85 298 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 299
cannam@85 300 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 301
cannam@85 302 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 303 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 304 exit (1) ;
cannam@85 305 } ;
cannam@85 306
cannam@85 307 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 308 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 309 exit (1) ;
cannam@85 310 } ;
cannam@85 311
cannam@85 312 if (sfinfo.channels != 1)
cannam@85 313 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 314 exit (1) ;
cannam@85 315 } ;
cannam@85 316
cannam@85 317 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 318
cannam@85 319 test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 320 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 321 test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 322 sf_close (file) ;
cannam@85 323
cannam@85 324 /* Check normalized version. */
cannam@85 325 clip_max_diff = 0.0 ;
cannam@85 326 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 327 { if (fabs (data_in [k]) > 1.0)
cannam@85 328 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 329 exit (1) ;
cannam@85 330 } ;
cannam@85 331
cannam@85 332 if (data_out [k] * data_in [k] < 0.0)
cannam@85 333 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 334 exit (1) ;
cannam@85 335 } ;
cannam@85 336
cannam@85 337 if (fabs (data_out [k]) > 1.0)
cannam@85 338 continue ;
cannam@85 339
cannam@85 340 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 341 if (diff > clip_max_diff)
cannam@85 342 clip_max_diff = diff ;
cannam@85 343 } ;
cannam@85 344
cannam@85 345 if (clip_max_diff < 1e-20)
cannam@85 346 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 347 exit (1) ;
cannam@85 348 } ;
cannam@85 349
cannam@85 350 if (clip_max_diff > 1.0 / 0x800000)
cannam@85 351 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 352 exit (1) ;
cannam@85 353 } ;
cannam@85 354
cannam@85 355 /* Check the un-normalized data. */
cannam@85 356 clip_max_diff = 0.0 ;
cannam@85 357 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 358 { if (fabs (data_in [k]) > maxval)
cannam@85 359 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 360 exit (1) ;
cannam@85 361 } ;
cannam@85 362
cannam@85 363 if (data_out [k] * data_in [k] < 0.0)
cannam@85 364 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 365 exit (1) ;
cannam@85 366 } ;
cannam@85 367
cannam@85 368 if (fabs (data_out [k]) > maxval)
cannam@85 369 continue ;
cannam@85 370
cannam@85 371 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 372 if (diff > clip_max_diff)
cannam@85 373 clip_max_diff = diff ;
cannam@85 374 } ;
cannam@85 375
cannam@85 376 if (clip_max_diff < 1e-20)
cannam@85 377 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 378 exit (1) ;
cannam@85 379 } ;
cannam@85 380
cannam@85 381 if (clip_max_diff > 1.0)
cannam@85 382 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 383 exit (1) ;
cannam@85 384 } ;
cannam@85 385
cannam@85 386 printf ("ok\n") ;
cannam@85 387 unlink (filename) ;
cannam@85 388 } /* flt_scale_clip_test_24 */
cannam@85 389
cannam@85 390 static void
cannam@85 391 flt_scale_clip_test_32 (const char *filename, int filetype, float maxval)
cannam@85 392 { SNDFILE *file ;
cannam@85 393 SF_INFO sfinfo ;
cannam@85 394 int k ;
cannam@85 395 float *data_out, *data_in ;
cannam@85 396 double diff, clip_max_diff ;
cannam@85 397
cannam@85 398 print_test_name ("flt_scale_clip_test_32", filename) ;
cannam@85 399
cannam@85 400 data_out = buffer_out.flt ;
cannam@85 401 data_in = buffer_in.flt ;
cannam@85 402
cannam@85 403 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 404 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 405 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 406 } ;
cannam@85 407
cannam@85 408 sfinfo.samplerate = 44100 ;
cannam@85 409 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 410 sfinfo.channels = 1 ;
cannam@85 411 sfinfo.format = filetype ;
cannam@85 412
cannam@85 413 /*
cannam@85 414 ** Write two versions of the data:
cannam@85 415 ** normalized and clipped
cannam@85 416 ** un-normalized and clipped.
cannam@85 417 */
cannam@85 418
cannam@85 419 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 420 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 421 test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 422 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 423 test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 424 sf_close (file) ;
cannam@85 425
cannam@85 426 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 427
cannam@85 428 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 429
cannam@85 430 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 431
cannam@85 432 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 433 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 434 exit (1) ;
cannam@85 435 } ;
cannam@85 436
cannam@85 437 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 438 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 439 exit (1) ;
cannam@85 440 } ;
cannam@85 441
cannam@85 442 if (sfinfo.channels != 1)
cannam@85 443 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 444 exit (1) ;
cannam@85 445 } ;
cannam@85 446
cannam@85 447 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 448
cannam@85 449 test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 450 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 451 test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 452 sf_close (file) ;
cannam@85 453
cannam@85 454 /* Check normalized version. */
cannam@85 455 clip_max_diff = 0.0 ;
cannam@85 456 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 457 { if (fabs (data_in [k]) > 1.0)
cannam@85 458 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 459 exit (1) ;
cannam@85 460 } ;
cannam@85 461
cannam@85 462 if (data_out [k] * data_in [k] < 0.0)
cannam@85 463 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 464 exit (1) ;
cannam@85 465 } ;
cannam@85 466
cannam@85 467 if (fabs (data_out [k]) > 1.0)
cannam@85 468 continue ;
cannam@85 469
cannam@85 470 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 471 if (diff > clip_max_diff)
cannam@85 472 clip_max_diff = diff ;
cannam@85 473 } ;
cannam@85 474
cannam@85 475 if (clip_max_diff < 1e-20)
cannam@85 476 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 477 exit (1) ;
cannam@85 478 } ;
cannam@85 479
cannam@85 480 if (clip_max_diff > 1.0 / 0x80000000)
cannam@85 481 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 482 exit (1) ;
cannam@85 483 } ;
cannam@85 484
cannam@85 485 /* Check the un-normalized data. */
cannam@85 486 clip_max_diff = 0.0 ;
cannam@85 487 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 488 { if (fabs (data_in [k]) > maxval)
cannam@85 489 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 490 exit (1) ;
cannam@85 491 } ;
cannam@85 492
cannam@85 493 if (data_out [k] * data_in [k] < 0.0)
cannam@85 494 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 495 exit (1) ;
cannam@85 496 } ;
cannam@85 497
cannam@85 498 if (fabs (data_out [k]) > maxval)
cannam@85 499 continue ;
cannam@85 500
cannam@85 501 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 502 if (diff > clip_max_diff)
cannam@85 503 clip_max_diff = diff ;
cannam@85 504 } ;
cannam@85 505
cannam@85 506 if (clip_max_diff < 1e-20)
cannam@85 507 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 508 exit (1) ;
cannam@85 509 } ;
cannam@85 510
cannam@85 511 if (clip_max_diff > 1.0)
cannam@85 512 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 513 exit (1) ;
cannam@85 514 } ;
cannam@85 515
cannam@85 516 printf ("ok\n") ;
cannam@85 517 unlink (filename) ;
cannam@85 518 } /* flt_scale_clip_test_32 */
cannam@85 519
cannam@85 520 static void
cannam@85 521 flt_scale_clip_test_08 (const char *filename, int filetype, float maxval)
cannam@85 522 { SNDFILE *file ;
cannam@85 523 SF_INFO sfinfo ;
cannam@85 524 int k ;
cannam@85 525 float *data_out, *data_in ;
cannam@85 526 double diff, clip_max_diff ;
cannam@85 527
cannam@85 528 print_test_name ("flt_scale_clip_test_08", filename) ;
cannam@85 529
cannam@85 530 data_out = buffer_out.flt ;
cannam@85 531 data_in = buffer_in.flt ;
cannam@85 532
cannam@85 533 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 534 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 535 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 536 } ;
cannam@85 537
cannam@85 538 sfinfo.samplerate = 44100 ;
cannam@85 539 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 540 sfinfo.channels = 1 ;
cannam@85 541 sfinfo.format = filetype ;
cannam@85 542
cannam@85 543 /*
cannam@85 544 ** Write two versions of the data:
cannam@85 545 ** normalized and clipped
cannam@85 546 ** un-normalized and clipped.
cannam@85 547 */
cannam@85 548
cannam@85 549 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 550 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 551 test_write_float_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 552 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 553 test_write_float_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 554 sf_close (file) ;
cannam@85 555
cannam@85 556 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 557
cannam@85 558 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 559
cannam@85 560 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 561
cannam@85 562 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 563 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 564 exit (1) ;
cannam@85 565 } ;
cannam@85 566
cannam@85 567 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 568 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 569 exit (1) ;
cannam@85 570 } ;
cannam@85 571
cannam@85 572 if (sfinfo.channels != 1)
cannam@85 573 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 574 exit (1) ;
cannam@85 575 } ;
cannam@85 576
cannam@85 577 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 578
cannam@85 579 test_read_float_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 580 sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
cannam@85 581 test_read_float_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 582 sf_close (file) ;
cannam@85 583
cannam@85 584 /* Check normalized version. */
cannam@85 585 clip_max_diff = 0.0 ;
cannam@85 586 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 587 { if (fabs (data_in [k]) > 1.0)
cannam@85 588 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 589 exit (1) ;
cannam@85 590 } ;
cannam@85 591
cannam@85 592 if (data_out [k] * data_in [k] < 0.0)
cannam@85 593 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 594 exit (1) ;
cannam@85 595 } ;
cannam@85 596
cannam@85 597 if (fabs (data_out [k]) > 1.0)
cannam@85 598 continue ;
cannam@85 599
cannam@85 600 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 601 if (diff > clip_max_diff)
cannam@85 602 clip_max_diff = diff ;
cannam@85 603 } ;
cannam@85 604
cannam@85 605 if (clip_max_diff < 1e-20)
cannam@85 606 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 607 exit (1) ;
cannam@85 608 } ;
cannam@85 609
cannam@85 610 if (clip_max_diff > 1.0 / 0x80)
cannam@85 611 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 612 exit (1) ;
cannam@85 613 } ;
cannam@85 614
cannam@85 615 /* Check the un-normalized data. */
cannam@85 616 clip_max_diff = 0.0 ;
cannam@85 617 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 618 { if (fabs (data_in [k]) > maxval)
cannam@85 619 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 620 exit (1) ;
cannam@85 621 } ;
cannam@85 622
cannam@85 623 if (data_out [k] * data_in [k] < 0.0)
cannam@85 624 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 625 exit (1) ;
cannam@85 626 } ;
cannam@85 627
cannam@85 628 if (fabs (data_out [k]) > maxval)
cannam@85 629 continue ;
cannam@85 630
cannam@85 631 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 632 if (diff > clip_max_diff)
cannam@85 633 clip_max_diff = diff ;
cannam@85 634 } ;
cannam@85 635
cannam@85 636 if (clip_max_diff < 1e-20)
cannam@85 637 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 638 exit (1) ;
cannam@85 639 } ;
cannam@85 640
cannam@85 641 if (clip_max_diff > 1.0)
cannam@85 642 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 643 exit (1) ;
cannam@85 644 } ;
cannam@85 645
cannam@85 646 printf ("ok\n") ;
cannam@85 647 unlink (filename) ;
cannam@85 648 } /* flt_scale_clip_test_08 */
cannam@85 649
cannam@85 650
cannam@85 651
cannam@85 652 static void
cannam@85 653 dbl_scale_clip_test_16 (const char *filename, int filetype, float maxval)
cannam@85 654 { SNDFILE *file ;
cannam@85 655 SF_INFO sfinfo ;
cannam@85 656 int k ;
cannam@85 657 double *data_out, *data_in ;
cannam@85 658 double diff, clip_max_diff ;
cannam@85 659
cannam@85 660 print_test_name ("dbl_scale_clip_test_16", filename) ;
cannam@85 661
cannam@85 662 data_out = buffer_out.dbl ;
cannam@85 663 data_in = buffer_in.dbl ;
cannam@85 664
cannam@85 665 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 666 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 667 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 668 } ;
cannam@85 669
cannam@85 670 sfinfo.samplerate = 44100 ;
cannam@85 671 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 672 sfinfo.channels = 1 ;
cannam@85 673 sfinfo.format = filetype ;
cannam@85 674
cannam@85 675 /*
cannam@85 676 ** Write two versions of the data:
cannam@85 677 ** normalized and clipped
cannam@85 678 ** un-normalized and clipped.
cannam@85 679 */
cannam@85 680
cannam@85 681 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 682 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 683 test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 684 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 685 test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 686 sf_close (file) ;
cannam@85 687
cannam@85 688 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 689
cannam@85 690 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 691
cannam@85 692 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 693
cannam@85 694 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 695 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 696 exit (1) ;
cannam@85 697 } ;
cannam@85 698
cannam@85 699 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 700 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 701 exit (1) ;
cannam@85 702 } ;
cannam@85 703
cannam@85 704 if (sfinfo.channels != 1)
cannam@85 705 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 706 exit (1) ;
cannam@85 707 } ;
cannam@85 708
cannam@85 709 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 710
cannam@85 711 test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 712 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 713 test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 714 sf_close (file) ;
cannam@85 715
cannam@85 716 /* Check normalized version. */
cannam@85 717 clip_max_diff = 0.0 ;
cannam@85 718 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 719 { if (fabs (data_in [k]) > 1.0)
cannam@85 720 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 721 exit (1) ;
cannam@85 722 } ;
cannam@85 723
cannam@85 724 if (data_out [k] * data_in [k] < 0.0)
cannam@85 725 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 726 exit (1) ;
cannam@85 727 } ;
cannam@85 728
cannam@85 729 if (fabs (data_out [k]) > 1.0)
cannam@85 730 continue ;
cannam@85 731
cannam@85 732 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 733 if (diff > clip_max_diff)
cannam@85 734 clip_max_diff = diff ;
cannam@85 735 } ;
cannam@85 736
cannam@85 737 if (clip_max_diff < 1e-20)
cannam@85 738 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 739 exit (1) ;
cannam@85 740 } ;
cannam@85 741
cannam@85 742 if (clip_max_diff > 1.0 / 0x8000)
cannam@85 743 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 744 exit (1) ;
cannam@85 745 } ;
cannam@85 746
cannam@85 747 /* Check the un-normalized data. */
cannam@85 748 clip_max_diff = 0.0 ;
cannam@85 749 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 750 { if (fabs (data_in [k]) > maxval)
cannam@85 751 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 752 exit (1) ;
cannam@85 753 } ;
cannam@85 754
cannam@85 755 if (data_out [k] * data_in [k] < 0.0)
cannam@85 756 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 757 exit (1) ;
cannam@85 758 } ;
cannam@85 759
cannam@85 760 if (fabs (data_out [k]) > maxval)
cannam@85 761 continue ;
cannam@85 762
cannam@85 763 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 764 if (diff > clip_max_diff)
cannam@85 765 clip_max_diff = diff ;
cannam@85 766 } ;
cannam@85 767
cannam@85 768 if (clip_max_diff < 1e-20)
cannam@85 769 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 770 exit (1) ;
cannam@85 771 } ;
cannam@85 772
cannam@85 773 if (clip_max_diff > 1.0)
cannam@85 774 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 775 exit (1) ;
cannam@85 776 } ;
cannam@85 777
cannam@85 778 printf ("ok\n") ;
cannam@85 779 unlink (filename) ;
cannam@85 780 } /* dbl_scale_clip_test_16 */
cannam@85 781
cannam@85 782 static void
cannam@85 783 dbl_scale_clip_test_24 (const char *filename, int filetype, float maxval)
cannam@85 784 { SNDFILE *file ;
cannam@85 785 SF_INFO sfinfo ;
cannam@85 786 int k ;
cannam@85 787 double *data_out, *data_in ;
cannam@85 788 double diff, clip_max_diff ;
cannam@85 789
cannam@85 790 print_test_name ("dbl_scale_clip_test_24", filename) ;
cannam@85 791
cannam@85 792 data_out = buffer_out.dbl ;
cannam@85 793 data_in = buffer_in.dbl ;
cannam@85 794
cannam@85 795 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 796 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 797 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 798 } ;
cannam@85 799
cannam@85 800 sfinfo.samplerate = 44100 ;
cannam@85 801 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 802 sfinfo.channels = 1 ;
cannam@85 803 sfinfo.format = filetype ;
cannam@85 804
cannam@85 805 /*
cannam@85 806 ** Write two versions of the data:
cannam@85 807 ** normalized and clipped
cannam@85 808 ** un-normalized and clipped.
cannam@85 809 */
cannam@85 810
cannam@85 811 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 812 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 813 test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 814 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 815 test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 816 sf_close (file) ;
cannam@85 817
cannam@85 818 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 819
cannam@85 820 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 821
cannam@85 822 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 823
cannam@85 824 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 825 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 826 exit (1) ;
cannam@85 827 } ;
cannam@85 828
cannam@85 829 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 830 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 831 exit (1) ;
cannam@85 832 } ;
cannam@85 833
cannam@85 834 if (sfinfo.channels != 1)
cannam@85 835 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 836 exit (1) ;
cannam@85 837 } ;
cannam@85 838
cannam@85 839 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 840
cannam@85 841 test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 842 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 843 test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 844 sf_close (file) ;
cannam@85 845
cannam@85 846 /* Check normalized version. */
cannam@85 847 clip_max_diff = 0.0 ;
cannam@85 848 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 849 { if (fabs (data_in [k]) > 1.0)
cannam@85 850 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 851 exit (1) ;
cannam@85 852 } ;
cannam@85 853
cannam@85 854 if (data_out [k] * data_in [k] < 0.0)
cannam@85 855 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 856 exit (1) ;
cannam@85 857 } ;
cannam@85 858
cannam@85 859 if (fabs (data_out [k]) > 1.0)
cannam@85 860 continue ;
cannam@85 861
cannam@85 862 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 863 if (diff > clip_max_diff)
cannam@85 864 clip_max_diff = diff ;
cannam@85 865 } ;
cannam@85 866
cannam@85 867 if (clip_max_diff < 1e-20)
cannam@85 868 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 869 exit (1) ;
cannam@85 870 } ;
cannam@85 871
cannam@85 872 if (clip_max_diff > 1.0 / 0x800000)
cannam@85 873 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 874 exit (1) ;
cannam@85 875 } ;
cannam@85 876
cannam@85 877 /* Check the un-normalized data. */
cannam@85 878 clip_max_diff = 0.0 ;
cannam@85 879 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 880 { if (fabs (data_in [k]) > maxval)
cannam@85 881 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 882 exit (1) ;
cannam@85 883 } ;
cannam@85 884
cannam@85 885 if (data_out [k] * data_in [k] < 0.0)
cannam@85 886 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 887 exit (1) ;
cannam@85 888 } ;
cannam@85 889
cannam@85 890 if (fabs (data_out [k]) > maxval)
cannam@85 891 continue ;
cannam@85 892
cannam@85 893 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 894 if (diff > clip_max_diff)
cannam@85 895 clip_max_diff = diff ;
cannam@85 896 } ;
cannam@85 897
cannam@85 898 if (clip_max_diff < 1e-20)
cannam@85 899 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 900 exit (1) ;
cannam@85 901 } ;
cannam@85 902
cannam@85 903 if (clip_max_diff > 1.0)
cannam@85 904 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 905 exit (1) ;
cannam@85 906 } ;
cannam@85 907
cannam@85 908 printf ("ok\n") ;
cannam@85 909 unlink (filename) ;
cannam@85 910 } /* dbl_scale_clip_test_24 */
cannam@85 911
cannam@85 912 static void
cannam@85 913 dbl_scale_clip_test_32 (const char *filename, int filetype, float maxval)
cannam@85 914 { SNDFILE *file ;
cannam@85 915 SF_INFO sfinfo ;
cannam@85 916 int k ;
cannam@85 917 double *data_out, *data_in ;
cannam@85 918 double diff, clip_max_diff ;
cannam@85 919
cannam@85 920 print_test_name ("dbl_scale_clip_test_32", filename) ;
cannam@85 921
cannam@85 922 data_out = buffer_out.dbl ;
cannam@85 923 data_in = buffer_in.dbl ;
cannam@85 924
cannam@85 925 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 926 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 927 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 928 } ;
cannam@85 929
cannam@85 930 sfinfo.samplerate = 44100 ;
cannam@85 931 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 932 sfinfo.channels = 1 ;
cannam@85 933 sfinfo.format = filetype ;
cannam@85 934
cannam@85 935 /*
cannam@85 936 ** Write two versions of the data:
cannam@85 937 ** normalized and clipped
cannam@85 938 ** un-normalized and clipped.
cannam@85 939 */
cannam@85 940
cannam@85 941 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 942 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 943 test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 944 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 945 test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 946 sf_close (file) ;
cannam@85 947
cannam@85 948 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 949
cannam@85 950 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 951
cannam@85 952 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 953
cannam@85 954 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 955 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 956 exit (1) ;
cannam@85 957 } ;
cannam@85 958
cannam@85 959 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 960 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 961 exit (1) ;
cannam@85 962 } ;
cannam@85 963
cannam@85 964 if (sfinfo.channels != 1)
cannam@85 965 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 966 exit (1) ;
cannam@85 967 } ;
cannam@85 968
cannam@85 969 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 970
cannam@85 971 test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 972 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 973 test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 974 sf_close (file) ;
cannam@85 975
cannam@85 976 /* Check normalized version. */
cannam@85 977 clip_max_diff = 0.0 ;
cannam@85 978 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 979 { if (fabs (data_in [k]) > 1.0)
cannam@85 980 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 981 exit (1) ;
cannam@85 982 } ;
cannam@85 983
cannam@85 984 if (data_out [k] * data_in [k] < 0.0)
cannam@85 985 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 986 exit (1) ;
cannam@85 987 } ;
cannam@85 988
cannam@85 989 if (fabs (data_out [k]) > 1.0)
cannam@85 990 continue ;
cannam@85 991
cannam@85 992 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 993 if (diff > clip_max_diff)
cannam@85 994 clip_max_diff = diff ;
cannam@85 995 } ;
cannam@85 996
cannam@85 997 if (clip_max_diff < 1e-20)
cannam@85 998 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 999 exit (1) ;
cannam@85 1000 } ;
cannam@85 1001
cannam@85 1002 if (clip_max_diff > 1.0 / 0x80000000)
cannam@85 1003 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1004 exit (1) ;
cannam@85 1005 } ;
cannam@85 1006
cannam@85 1007 /* Check the un-normalized data. */
cannam@85 1008 clip_max_diff = 0.0 ;
cannam@85 1009 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 1010 { if (fabs (data_in [k]) > maxval)
cannam@85 1011 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 1012 exit (1) ;
cannam@85 1013 } ;
cannam@85 1014
cannam@85 1015 if (data_out [k] * data_in [k] < 0.0)
cannam@85 1016 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 1017 exit (1) ;
cannam@85 1018 } ;
cannam@85 1019
cannam@85 1020 if (fabs (data_out [k]) > maxval)
cannam@85 1021 continue ;
cannam@85 1022
cannam@85 1023 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 1024 if (diff > clip_max_diff)
cannam@85 1025 clip_max_diff = diff ;
cannam@85 1026 } ;
cannam@85 1027
cannam@85 1028 if (clip_max_diff < 1e-20)
cannam@85 1029 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1030 exit (1) ;
cannam@85 1031 } ;
cannam@85 1032
cannam@85 1033 if (clip_max_diff > 1.0)
cannam@85 1034 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1035 exit (1) ;
cannam@85 1036 } ;
cannam@85 1037
cannam@85 1038 printf ("ok\n") ;
cannam@85 1039 unlink (filename) ;
cannam@85 1040 } /* dbl_scale_clip_test_32 */
cannam@85 1041
cannam@85 1042 static void
cannam@85 1043 dbl_scale_clip_test_08 (const char *filename, int filetype, float maxval)
cannam@85 1044 { SNDFILE *file ;
cannam@85 1045 SF_INFO sfinfo ;
cannam@85 1046 int k ;
cannam@85 1047 double *data_out, *data_in ;
cannam@85 1048 double diff, clip_max_diff ;
cannam@85 1049
cannam@85 1050 print_test_name ("dbl_scale_clip_test_08", filename) ;
cannam@85 1051
cannam@85 1052 data_out = buffer_out.dbl ;
cannam@85 1053 data_in = buffer_in.dbl ;
cannam@85 1054
cannam@85 1055 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 1056 { data_out [k] = 1.2 * sin (2 * M_PI * k / HALF_BUFFER_SIZE) ;
cannam@85 1057 data_out [k + HALF_BUFFER_SIZE] = data_out [k] * maxval ;
cannam@85 1058 } ;
cannam@85 1059
cannam@85 1060 sfinfo.samplerate = 44100 ;
cannam@85 1061 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1062 sfinfo.channels = 1 ;
cannam@85 1063 sfinfo.format = filetype ;
cannam@85 1064
cannam@85 1065 /*
cannam@85 1066 ** Write two versions of the data:
cannam@85 1067 ** normalized and clipped
cannam@85 1068 ** un-normalized and clipped.
cannam@85 1069 */
cannam@85 1070
cannam@85 1071 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1072 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 1073 test_write_double_or_die (file, 0, data_out, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 1074 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 1075 test_write_double_or_die (file, 0, data_out + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 1076 sf_close (file) ;
cannam@85 1077
cannam@85 1078 memset (&buffer_in, 0, sizeof (buffer_in)) ;
cannam@85 1079
cannam@85 1080 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1081
cannam@85 1082 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1083
cannam@85 1084 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1085 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1086 exit (1) ;
cannam@85 1087 } ;
cannam@85 1088
cannam@85 1089 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 1090 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1091 exit (1) ;
cannam@85 1092 } ;
cannam@85 1093
cannam@85 1094 if (sfinfo.channels != 1)
cannam@85 1095 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1096 exit (1) ;
cannam@85 1097 } ;
cannam@85 1098
cannam@85 1099 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1100
cannam@85 1101 test_read_double_or_die (file, 0, data_in, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 1102 sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
cannam@85 1103 test_read_double_or_die (file, 0, data_in + HALF_BUFFER_SIZE, HALF_BUFFER_SIZE, __LINE__) ;
cannam@85 1104 sf_close (file) ;
cannam@85 1105
cannam@85 1106 /* Check normalized version. */
cannam@85 1107 clip_max_diff = 0.0 ;
cannam@85 1108 for (k = 0 ; k < HALF_BUFFER_SIZE ; k++)
cannam@85 1109 { if (fabs (data_in [k]) > 1.0)
cannam@85 1110 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 1111 exit (1) ;
cannam@85 1112 } ;
cannam@85 1113
cannam@85 1114 if (data_out [k] * data_in [k] < 0.0)
cannam@85 1115 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 1116 exit (1) ;
cannam@85 1117 } ;
cannam@85 1118
cannam@85 1119 if (fabs (data_out [k]) > 1.0)
cannam@85 1120 continue ;
cannam@85 1121
cannam@85 1122 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 1123 if (diff > clip_max_diff)
cannam@85 1124 clip_max_diff = diff ;
cannam@85 1125 } ;
cannam@85 1126
cannam@85 1127 if (clip_max_diff < 1e-20)
cannam@85 1128 { printf ("\n\nLine %d: Clipping difference (%e) too small (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1129 exit (1) ;
cannam@85 1130 } ;
cannam@85 1131
cannam@85 1132 if (clip_max_diff > 1.0 / 0x80)
cannam@85 1133 { printf ("\n\nLine %d: Clipping difference (%e) too large (normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1134 exit (1) ;
cannam@85 1135 } ;
cannam@85 1136
cannam@85 1137 /* Check the un-normalized data. */
cannam@85 1138 clip_max_diff = 0.0 ;
cannam@85 1139 for (k = HALF_BUFFER_SIZE ; k < BUFFER_SIZE ; k++)
cannam@85 1140 { if (fabs (data_in [k]) > maxval)
cannam@85 1141 { printf ("\n\nLine %d: Input sample %d/%d (%f) has not been clipped.\n\n", __LINE__, k, BUFFER_SIZE, data_in [k]) ;
cannam@85 1142 exit (1) ;
cannam@85 1143 } ;
cannam@85 1144
cannam@85 1145 if (data_out [k] * data_in [k] < 0.0)
cannam@85 1146 { printf ("\n\nLine %d: Data wrap around at index %d/%d.\n\n", __LINE__, k, BUFFER_SIZE) ;
cannam@85 1147 exit (1) ;
cannam@85 1148 } ;
cannam@85 1149
cannam@85 1150 if (fabs (data_out [k]) > maxval)
cannam@85 1151 continue ;
cannam@85 1152
cannam@85 1153 diff = fabs (data_out [k] - data_in [k]) ;
cannam@85 1154 if (diff > clip_max_diff)
cannam@85 1155 clip_max_diff = diff ;
cannam@85 1156 } ;
cannam@85 1157
cannam@85 1158 if (clip_max_diff < 1e-20)
cannam@85 1159 { printf ("\n\nLine %d: Clipping difference (%e) too small (un-normalized).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1160 exit (1) ;
cannam@85 1161 } ;
cannam@85 1162
cannam@85 1163 if (clip_max_diff > 1.0)
cannam@85 1164 { printf ("\n\nLine %d: Clipping difference (%e) too large (un-normalised).\n\n", __LINE__, clip_max_diff) ;
cannam@85 1165 exit (1) ;
cannam@85 1166 } ;
cannam@85 1167
cannam@85 1168 printf ("ok\n") ;
cannam@85 1169 unlink (filename) ;
cannam@85 1170 } /* dbl_scale_clip_test_08 */
cannam@85 1171
cannam@85 1172
cannam@85 1173
cannam@85 1174
cannam@85 1175 /*==============================================================================
cannam@85 1176 */
cannam@85 1177
cannam@85 1178
cannam@85 1179 static void flt_short_clip_read_test (const char *filename, int filetype)
cannam@85 1180 { SNDFILE *file ;
cannam@85 1181 SF_INFO sfinfo ;
cannam@85 1182 float *data_out ;
cannam@85 1183 short *data_in, max_value ;
cannam@85 1184 int k ;
cannam@85 1185
cannam@85 1186 print_test_name ("flt_short_clip_read_test", filename) ;
cannam@85 1187
cannam@85 1188 data_out = buffer_out.flt ;
cannam@85 1189 data_in = buffer_in.s ;
cannam@85 1190
cannam@85 1191 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1192 data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
cannam@85 1193 data_out [BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1194 data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1195 data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1196 data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1197
cannam@85 1198 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1199 sfinfo.samplerate = 44100 ;
cannam@85 1200 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1201 sfinfo.channels = 1 ;
cannam@85 1202 sfinfo.format = filetype ;
cannam@85 1203
cannam@85 1204 /* Save unclipped data to the file. */
cannam@85 1205 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1206 test_write_float_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1207 sf_close (file) ;
cannam@85 1208
cannam@85 1209 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1210
cannam@85 1211 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1212 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
cannam@85 1213
cannam@85 1214 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1215
cannam@85 1216 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1217 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1218 exit (1) ;
cannam@85 1219 } ;
cannam@85 1220
cannam@85 1221 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 1222 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1223 exit (1) ;
cannam@85 1224 } ;
cannam@85 1225
cannam@85 1226 if (sfinfo.channels != 1)
cannam@85 1227 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1228 exit (1) ;
cannam@85 1229 } ;
cannam@85 1230
cannam@85 1231 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1232
cannam@85 1233 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 1234 test_read_short_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1235 /*-sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;-*/
cannam@85 1236 sf_close (file) ;
cannam@85 1237
cannam@85 1238 /* Check the first half. */
cannam@85 1239 max_value = 0 ;
cannam@85 1240 for (k = 0 ; k < sfinfo.frames ; k++)
cannam@85 1241 { /* Check if data_out has different sign from data_in. */
cannam@85 1242 if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
cannam@85 1243 { printf ("\n\nLine %d: Data wrap around at index %d/%d (%f -> %d).\n\n", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
cannam@85 1244 exit (1) ;
cannam@85 1245 } ;
cannam@85 1246 max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
cannam@85 1247 } ;
cannam@85 1248
cannam@85 1249 unlink (filename) ;
cannam@85 1250 puts ("ok") ;
cannam@85 1251 } /* flt_short_clip_read_test */
cannam@85 1252 static void flt_int_clip_read_test (const char *filename, int filetype)
cannam@85 1253 { SNDFILE *file ;
cannam@85 1254 SF_INFO sfinfo ;
cannam@85 1255 float *data_out ;
cannam@85 1256 int *data_in, max_value ;
cannam@85 1257 int k ;
cannam@85 1258
cannam@85 1259 print_test_name ("flt_int_clip_read_test", filename) ;
cannam@85 1260
cannam@85 1261 data_out = buffer_out.flt ;
cannam@85 1262 data_in = buffer_in.i ;
cannam@85 1263
cannam@85 1264 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1265 data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
cannam@85 1266 data_out [BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1267 data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1268 data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1269 data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1270
cannam@85 1271 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1272 sfinfo.samplerate = 44100 ;
cannam@85 1273 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1274 sfinfo.channels = 1 ;
cannam@85 1275 sfinfo.format = filetype ;
cannam@85 1276
cannam@85 1277 /* Save unclipped data to the file. */
cannam@85 1278 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1279 test_write_float_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1280 sf_close (file) ;
cannam@85 1281
cannam@85 1282 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1283
cannam@85 1284 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1285 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
cannam@85 1286
cannam@85 1287 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1288
cannam@85 1289 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1290 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1291 exit (1) ;
cannam@85 1292 } ;
cannam@85 1293
cannam@85 1294 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 1295 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1296 exit (1) ;
cannam@85 1297 } ;
cannam@85 1298
cannam@85 1299 if (sfinfo.channels != 1)
cannam@85 1300 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1301 exit (1) ;
cannam@85 1302 } ;
cannam@85 1303
cannam@85 1304 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1305
cannam@85 1306 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 1307 test_read_int_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1308 /*-sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;-*/
cannam@85 1309 sf_close (file) ;
cannam@85 1310
cannam@85 1311 /* Check the first half. */
cannam@85 1312 max_value = 0 ;
cannam@85 1313 for (k = 0 ; k < sfinfo.frames ; k++)
cannam@85 1314 { /* Check if data_out has different sign from data_in. */
cannam@85 1315 if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
cannam@85 1316 { printf ("\n\nLine %d: Data wrap around at index %d/%d (%f -> %d).\n\n", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
cannam@85 1317 exit (1) ;
cannam@85 1318 } ;
cannam@85 1319 max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
cannam@85 1320 } ;
cannam@85 1321
cannam@85 1322 unlink (filename) ;
cannam@85 1323 puts ("ok") ;
cannam@85 1324 } /* flt_int_clip_read_test */
cannam@85 1325
cannam@85 1326 static void dbl_short_clip_read_test (const char *filename, int filetype)
cannam@85 1327 { SNDFILE *file ;
cannam@85 1328 SF_INFO sfinfo ;
cannam@85 1329 double *data_out ;
cannam@85 1330 short *data_in, max_value ;
cannam@85 1331 int k ;
cannam@85 1332
cannam@85 1333 print_test_name ("dbl_short_clip_read_test", filename) ;
cannam@85 1334
cannam@85 1335 data_out = buffer_out.dbl ;
cannam@85 1336 data_in = buffer_in.s ;
cannam@85 1337
cannam@85 1338 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1339 data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
cannam@85 1340 data_out [BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1341 data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1342 data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1343 data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1344
cannam@85 1345 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1346 sfinfo.samplerate = 44100 ;
cannam@85 1347 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1348 sfinfo.channels = 1 ;
cannam@85 1349 sfinfo.format = filetype ;
cannam@85 1350
cannam@85 1351 /* Save unclipped data to the file. */
cannam@85 1352 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1353 test_write_double_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1354 sf_close (file) ;
cannam@85 1355
cannam@85 1356 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1357
cannam@85 1358 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1359 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
cannam@85 1360
cannam@85 1361 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1362
cannam@85 1363 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1364 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1365 exit (1) ;
cannam@85 1366 } ;
cannam@85 1367
cannam@85 1368 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 1369 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1370 exit (1) ;
cannam@85 1371 } ;
cannam@85 1372
cannam@85 1373 if (sfinfo.channels != 1)
cannam@85 1374 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1375 exit (1) ;
cannam@85 1376 } ;
cannam@85 1377
cannam@85 1378 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1379
cannam@85 1380 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 1381 test_read_short_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1382 /*-sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;-*/
cannam@85 1383 sf_close (file) ;
cannam@85 1384
cannam@85 1385 /* Check the first half. */
cannam@85 1386 max_value = 0 ;
cannam@85 1387 for (k = 0 ; k < sfinfo.frames ; k++)
cannam@85 1388 { /* Check if data_out has different sign from data_in. */
cannam@85 1389 if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
cannam@85 1390 { printf ("\n\nLine %d: Data wrap around at index %d/%d (%f -> %d).\n\n", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
cannam@85 1391 exit (1) ;
cannam@85 1392 } ;
cannam@85 1393 max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
cannam@85 1394 } ;
cannam@85 1395
cannam@85 1396 unlink (filename) ;
cannam@85 1397 puts ("ok") ;
cannam@85 1398 } /* dbl_short_clip_read_test */
cannam@85 1399 static void dbl_int_clip_read_test (const char *filename, int filetype)
cannam@85 1400 { SNDFILE *file ;
cannam@85 1401 SF_INFO sfinfo ;
cannam@85 1402 double *data_out ;
cannam@85 1403 int *data_in, max_value ;
cannam@85 1404 int k ;
cannam@85 1405
cannam@85 1406 print_test_name ("dbl_int_clip_read_test", filename) ;
cannam@85 1407
cannam@85 1408 data_out = buffer_out.dbl ;
cannam@85 1409 data_in = buffer_in.i ;
cannam@85 1410
cannam@85 1411 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1412 data_out [k] = 0.995 * sin (4 * M_PI * k / BUFFER_SIZE) ;
cannam@85 1413 data_out [BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1414 data_out [3 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1415 data_out [5 * BUFFER_SIZE / 8] = 1.0 ;
cannam@85 1416 data_out [7 * BUFFER_SIZE / 8] = -1.000000001 ;
cannam@85 1417
cannam@85 1418 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1419 sfinfo.samplerate = 44100 ;
cannam@85 1420 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1421 sfinfo.channels = 1 ;
cannam@85 1422 sfinfo.format = filetype ;
cannam@85 1423
cannam@85 1424 /* Save unclipped data to the file. */
cannam@85 1425 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1426 test_write_double_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1427 sf_close (file) ;
cannam@85 1428
cannam@85 1429 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1430
cannam@85 1431 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1432 sf_command (file, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
cannam@85 1433
cannam@85 1434 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1435
cannam@85 1436 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1437 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1438 exit (1) ;
cannam@85 1439 } ;
cannam@85 1440
cannam@85 1441 if (sfinfo.frames != BUFFER_SIZE)
cannam@85 1442 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1443 exit (1) ;
cannam@85 1444 } ;
cannam@85 1445
cannam@85 1446 if (sfinfo.channels != 1)
cannam@85 1447 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1448 exit (1) ;
cannam@85 1449 } ;
cannam@85 1450
cannam@85 1451 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1452
cannam@85 1453 sf_command (file, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
cannam@85 1454 test_read_int_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1455 /*-sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;-*/
cannam@85 1456 sf_close (file) ;
cannam@85 1457
cannam@85 1458 /* Check the first half. */
cannam@85 1459 max_value = 0 ;
cannam@85 1460 for (k = 0 ; k < sfinfo.frames ; k++)
cannam@85 1461 { /* Check if data_out has different sign from data_in. */
cannam@85 1462 if ((data_out [k] < 0.0 && data_in [k] > 0) || (data_out [k] > 0.0 && data_in [k] < 0))
cannam@85 1463 { printf ("\n\nLine %d: Data wrap around at index %d/%d (%f -> %d).\n\n", __LINE__, k, BUFFER_SIZE, data_out [k], data_in [k]) ;
cannam@85 1464 exit (1) ;
cannam@85 1465 } ;
cannam@85 1466 max_value = (max_value > abs (data_in [k])) ? max_value : abs (data_in [k]) ;
cannam@85 1467 } ;
cannam@85 1468
cannam@85 1469 unlink (filename) ;
cannam@85 1470 puts ("ok") ;
cannam@85 1471 } /* dbl_int_clip_read_test */
cannam@85 1472
cannam@85 1473
cannam@85 1474 /*==============================================================================
cannam@85 1475 */
cannam@85 1476
cannam@85 1477
cannam@85 1478 static void short_flt_scale_write_test (const char *filename, int filetype)
cannam@85 1479 { SNDFILE *file ;
cannam@85 1480 SF_INFO sfinfo ;
cannam@85 1481 short *data_out ;
cannam@85 1482 float *data_in, max_value ;
cannam@85 1483 int k ;
cannam@85 1484
cannam@85 1485 print_test_name ("short_flt_clip_write_test", filename) ;
cannam@85 1486
cannam@85 1487 data_out = buffer_out.s ;
cannam@85 1488 data_in = buffer_in.flt ;
cannam@85 1489
cannam@85 1490 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1491 data_out [k] = lrintf (0x7FFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
cannam@85 1492
cannam@85 1493 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1494 sfinfo.samplerate = 44100 ;
cannam@85 1495 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1496 sfinfo.channels = 1 ;
cannam@85 1497 sfinfo.format = filetype ;
cannam@85 1498
cannam@85 1499 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1500 test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1501 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
cannam@85 1502 test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1503 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
cannam@85 1504 test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1505 sf_close (file) ;
cannam@85 1506
cannam@85 1507 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1508
cannam@85 1509 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1510
cannam@85 1511 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1512
cannam@85 1513 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1514 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1515 exit (1) ;
cannam@85 1516 } ;
cannam@85 1517
cannam@85 1518 if (sfinfo.frames != 3 * BUFFER_SIZE)
cannam@85 1519 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1520 exit (1) ;
cannam@85 1521 } ;
cannam@85 1522
cannam@85 1523 if (sfinfo.channels != 1)
cannam@85 1524 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1525 exit (1) ;
cannam@85 1526 } ;
cannam@85 1527
cannam@85 1528 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1529
cannam@85 1530 /* Check the first section. */
cannam@85 1531 test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1532
cannam@85 1533 max_value = 0.0 ;
cannam@85 1534 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1535 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1536
cannam@85 1537 if (max_value < 1000.0)
cannam@85 1538 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1539 exit (1) ;
cannam@85 1540 } ;
cannam@85 1541
cannam@85 1542 /* Check the second section. */
cannam@85 1543 test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1544
cannam@85 1545 max_value = 0.0 ;
cannam@85 1546 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1547 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1548
cannam@85 1549 if (max_value > 1.0)
cannam@85 1550 { printf ("\n\nLine %d: Max value (%f) > 1.0.\n\n", __LINE__, max_value) ;
cannam@85 1551 exit (1) ;
cannam@85 1552 } ;
cannam@85 1553
cannam@85 1554 /* Check the third section. */
cannam@85 1555 test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1556
cannam@85 1557 max_value = 0.0 ;
cannam@85 1558 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1559 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1560
cannam@85 1561 if (max_value < 1000.0)
cannam@85 1562 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1563 exit (1) ;
cannam@85 1564 } ;
cannam@85 1565
cannam@85 1566 sf_close (file) ;
cannam@85 1567
cannam@85 1568 unlink (filename) ;
cannam@85 1569 puts ("ok") ;
cannam@85 1570 } /* short_flt_scale_write_test */
cannam@85 1571 static void short_dbl_scale_write_test (const char *filename, int filetype)
cannam@85 1572 { SNDFILE *file ;
cannam@85 1573 SF_INFO sfinfo ;
cannam@85 1574 short *data_out ;
cannam@85 1575 double *data_in, max_value ;
cannam@85 1576 int k ;
cannam@85 1577
cannam@85 1578 print_test_name ("short_dbl_clip_write_test", filename) ;
cannam@85 1579
cannam@85 1580 data_out = buffer_out.s ;
cannam@85 1581 data_in = buffer_in.dbl ;
cannam@85 1582
cannam@85 1583 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1584 data_out [k] = lrint (0x7FFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
cannam@85 1585
cannam@85 1586 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1587 sfinfo.samplerate = 44100 ;
cannam@85 1588 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1589 sfinfo.channels = 1 ;
cannam@85 1590 sfinfo.format = filetype ;
cannam@85 1591
cannam@85 1592 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1593 test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1594 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
cannam@85 1595 test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1596 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
cannam@85 1597 test_write_short_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1598 sf_close (file) ;
cannam@85 1599
cannam@85 1600 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1601
cannam@85 1602 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1603
cannam@85 1604 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1605
cannam@85 1606 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1607 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1608 exit (1) ;
cannam@85 1609 } ;
cannam@85 1610
cannam@85 1611 if (sfinfo.frames != 3 * BUFFER_SIZE)
cannam@85 1612 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1613 exit (1) ;
cannam@85 1614 } ;
cannam@85 1615
cannam@85 1616 if (sfinfo.channels != 1)
cannam@85 1617 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1618 exit (1) ;
cannam@85 1619 } ;
cannam@85 1620
cannam@85 1621 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1622
cannam@85 1623 /* Check the first section. */
cannam@85 1624 test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1625
cannam@85 1626 max_value = 0.0 ;
cannam@85 1627 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1628 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1629
cannam@85 1630 if (max_value < 1000.0)
cannam@85 1631 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1632 exit (1) ;
cannam@85 1633 } ;
cannam@85 1634
cannam@85 1635 /* Check the second section. */
cannam@85 1636 test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1637
cannam@85 1638 max_value = 0.0 ;
cannam@85 1639 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1640 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1641
cannam@85 1642 if (max_value > 1.0)
cannam@85 1643 { printf ("\n\nLine %d: Max value (%f) > 1.0.\n\n", __LINE__, max_value) ;
cannam@85 1644 exit (1) ;
cannam@85 1645 } ;
cannam@85 1646
cannam@85 1647 /* Check the third section. */
cannam@85 1648 test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1649
cannam@85 1650 max_value = 0.0 ;
cannam@85 1651 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1652 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1653
cannam@85 1654 if (max_value < 1000.0)
cannam@85 1655 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1656 exit (1) ;
cannam@85 1657 } ;
cannam@85 1658
cannam@85 1659 sf_close (file) ;
cannam@85 1660
cannam@85 1661 unlink (filename) ;
cannam@85 1662 puts ("ok") ;
cannam@85 1663 } /* short_dbl_scale_write_test */
cannam@85 1664
cannam@85 1665 static void int_flt_scale_write_test (const char *filename, int filetype)
cannam@85 1666 { SNDFILE *file ;
cannam@85 1667 SF_INFO sfinfo ;
cannam@85 1668 int *data_out ;
cannam@85 1669 float *data_in, max_value ;
cannam@85 1670 int k ;
cannam@85 1671
cannam@85 1672 print_test_name ("int_flt_clip_write_test", filename) ;
cannam@85 1673
cannam@85 1674 data_out = buffer_out.i ;
cannam@85 1675 data_in = buffer_in.flt ;
cannam@85 1676
cannam@85 1677 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1678 data_out [k] = lrintf (0x7FFFFFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
cannam@85 1679
cannam@85 1680 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1681 sfinfo.samplerate = 44100 ;
cannam@85 1682 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1683 sfinfo.channels = 1 ;
cannam@85 1684 sfinfo.format = filetype ;
cannam@85 1685
cannam@85 1686 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1687 test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1688 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
cannam@85 1689 test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1690 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
cannam@85 1691 test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1692 sf_close (file) ;
cannam@85 1693
cannam@85 1694 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1695
cannam@85 1696 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1697
cannam@85 1698 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1699
cannam@85 1700 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1701 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1702 exit (1) ;
cannam@85 1703 } ;
cannam@85 1704
cannam@85 1705 if (sfinfo.frames != 3 * BUFFER_SIZE)
cannam@85 1706 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1707 exit (1) ;
cannam@85 1708 } ;
cannam@85 1709
cannam@85 1710 if (sfinfo.channels != 1)
cannam@85 1711 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1712 exit (1) ;
cannam@85 1713 } ;
cannam@85 1714
cannam@85 1715 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1716
cannam@85 1717 /* Check the first section. */
cannam@85 1718 test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1719
cannam@85 1720 max_value = 0.0 ;
cannam@85 1721 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1722 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1723
cannam@85 1724 if (max_value < 1000.0)
cannam@85 1725 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1726 exit (1) ;
cannam@85 1727 } ;
cannam@85 1728
cannam@85 1729 /* Check the second section. */
cannam@85 1730 test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1731
cannam@85 1732 max_value = 0.0 ;
cannam@85 1733 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1734 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1735
cannam@85 1736 if (max_value > 1.0)
cannam@85 1737 { printf ("\n\nLine %d: Max value (%f) > 1.0.\n\n", __LINE__, max_value) ;
cannam@85 1738 exit (1) ;
cannam@85 1739 } ;
cannam@85 1740
cannam@85 1741 /* Check the third section. */
cannam@85 1742 test_read_float_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1743
cannam@85 1744 max_value = 0.0 ;
cannam@85 1745 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1746 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1747
cannam@85 1748 if (max_value < 1000.0)
cannam@85 1749 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1750 exit (1) ;
cannam@85 1751 } ;
cannam@85 1752
cannam@85 1753 sf_close (file) ;
cannam@85 1754
cannam@85 1755 unlink (filename) ;
cannam@85 1756 puts ("ok") ;
cannam@85 1757 } /* int_flt_scale_write_test */
cannam@85 1758 static void int_dbl_scale_write_test (const char *filename, int filetype)
cannam@85 1759 { SNDFILE *file ;
cannam@85 1760 SF_INFO sfinfo ;
cannam@85 1761 int *data_out ;
cannam@85 1762 double *data_in, max_value ;
cannam@85 1763 int k ;
cannam@85 1764
cannam@85 1765 print_test_name ("int_dbl_clip_write_test", filename) ;
cannam@85 1766
cannam@85 1767 data_out = buffer_out.i ;
cannam@85 1768 data_in = buffer_in.dbl ;
cannam@85 1769
cannam@85 1770 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1771 data_out [k] = lrint (0x7FFFFFFF * 0.995 * sin (4 * M_PI * k / BUFFER_SIZE)) ;
cannam@85 1772
cannam@85 1773 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1774 sfinfo.samplerate = 44100 ;
cannam@85 1775 sfinfo.frames = 123456789 ; /* Wrong length. Library should correct this on sf_close. */
cannam@85 1776 sfinfo.channels = 1 ;
cannam@85 1777 sfinfo.format = filetype ;
cannam@85 1778
cannam@85 1779 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1780 test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1781 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
cannam@85 1782 test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1783 sf_command (file, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_FALSE) ;
cannam@85 1784 test_write_int_or_die (file, 0, data_out, BUFFER_SIZE, __LINE__) ;
cannam@85 1785 sf_close (file) ;
cannam@85 1786
cannam@85 1787 memset (&sfinfo, 0, sizeof (sfinfo)) ;
cannam@85 1788
cannam@85 1789 file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_TRUE, __LINE__) ;
cannam@85 1790
cannam@85 1791 sfinfo.format &= (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK) ;
cannam@85 1792
cannam@85 1793 if (sfinfo.format != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
cannam@85 1794 { printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n\n", __LINE__, filetype, sfinfo.format) ;
cannam@85 1795 exit (1) ;
cannam@85 1796 } ;
cannam@85 1797
cannam@85 1798 if (sfinfo.frames != 3 * BUFFER_SIZE)
cannam@85 1799 { printf ("\n\nLine %d: Incorrect number of frames in file (%d => %ld).\n\n", __LINE__, 3 * BUFFER_SIZE, SF_COUNT_TO_LONG (sfinfo.frames)) ;
cannam@85 1800 exit (1) ;
cannam@85 1801 } ;
cannam@85 1802
cannam@85 1803 if (sfinfo.channels != 1)
cannam@85 1804 { printf ("\n\nLine %d: Incorrect number of channels in file.\n\n", __LINE__) ;
cannam@85 1805 exit (1) ;
cannam@85 1806 } ;
cannam@85 1807
cannam@85 1808 check_log_buffer_or_die (file, __LINE__) ;
cannam@85 1809
cannam@85 1810 /* Check the first section. */
cannam@85 1811 test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1812
cannam@85 1813 max_value = 0.0 ;
cannam@85 1814 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1815 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1816
cannam@85 1817 if (max_value < 1000.0)
cannam@85 1818 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1819 exit (1) ;
cannam@85 1820 } ;
cannam@85 1821
cannam@85 1822 /* Check the second section. */
cannam@85 1823 test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1824
cannam@85 1825 max_value = 0.0 ;
cannam@85 1826 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1827 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1828
cannam@85 1829 if (max_value > 1.0)
cannam@85 1830 { printf ("\n\nLine %d: Max value (%f) > 1.0.\n\n", __LINE__, max_value) ;
cannam@85 1831 exit (1) ;
cannam@85 1832 } ;
cannam@85 1833
cannam@85 1834 /* Check the third section. */
cannam@85 1835 test_read_double_or_die (file, 0, data_in, BUFFER_SIZE, __LINE__) ;
cannam@85 1836
cannam@85 1837 max_value = 0.0 ;
cannam@85 1838 for (k = 0 ; k < BUFFER_SIZE ; k++)
cannam@85 1839 max_value = (max_value > fabs (data_in [k])) ? max_value : fabs (data_in [k]) ;
cannam@85 1840
cannam@85 1841 if (max_value < 1000.0)
cannam@85 1842 { printf ("\n\nLine %d: Max value (%f) < 1000.0.\n\n", __LINE__, max_value) ;
cannam@85 1843 exit (1) ;
cannam@85 1844 } ;
cannam@85 1845
cannam@85 1846 sf_close (file) ;
cannam@85 1847
cannam@85 1848 unlink (filename) ;
cannam@85 1849 puts ("ok") ;
cannam@85 1850 } /* int_dbl_scale_write_test */
cannam@85 1851
cannam@85 1852
cannam@85 1853