tests/lossy_comp_test.c

   1 /*
   2 ** Copyright (C) 1999-2014 Erik de Castro Lopo <erikd@mega-nerd.com>
   3 **
   4 ** This program is free software; you can redistribute it and/or modify
   5 ** it under the terms of the GNU General Public License as published by
   6 ** the Free Software Foundation; either version 2 of the License, or
   7 ** (at your option) any later version.
   8 **
   9 ** This program is distributed in the hope that it will be useful,
  10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 ** GNU General Public License for more details.
  13 **
  14 ** You should have received a copy of the GNU General Public License
  15 ** along with this program; if not, write to the Free Software
  16 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17 */
  18
  19 #include "sfconfig.h"
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <math.h>
  25 #include <inttypes.h>
  26
  27
  28 #if HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31
  32 #include <sndfile.h>
  33
  34 #include "utils.h"
  35
  36 #define BUFFER_SIZE             (1 << 14)
  37 #define SAMPLE_RATE             11025
  38
  39 #ifndef         M_PI
  40 #define         M_PI            3.14159265358979323846264338
  41 #endif
  42
  43 #define         LCT_MAX(x, y)   ((x) > (y) ? (x) : (y))
  44
  45 static  void    lcomp_test_short        (const char *filename, int filetype, int chan, double margin) ;
  46 static  void    lcomp_test_int          (const char *filename, int filetype, int chan, double margin) ;
  47 static  void    lcomp_test_float        (const char *filename, int filetype, int chan, double margin) ;
  48 static  void    lcomp_test_double       (const char *filename, int filetype, int chan, double margin) ;
  49
  50 static  void    sdlcomp_test_short      (const char *filename, int filetype, int chan, double margin) ;
  51 static  void    sdlcomp_test_int        (const char *filename, int filetype, int chan, double margin) ;
  52 static  void    sdlcomp_test_float      (const char *filename, int filetype, int chan, double margin) ;
  53 static  void    sdlcomp_test_double     (const char *filename, int filetype, int chan, double margin) ;
  54
  55 static void             read_raw_test (const char *filename, int filetype, int chan) ;
  56
  57 static  int             error_function (double data, double orig, double margin) ;
  58 static  int             decay_response (int k) ;
  59
  60 static  void    gen_signal_double (double *data, double scale, int channels, int datalen) ;
  61
  62 static  void    smoothed_diff_short (short *data, unsigned int datalen) ;
  63 static  void    smoothed_diff_int (int *data, unsigned int datalen) ;
  64 static  void    smoothed_diff_float (float *data, unsigned int datalen) ;
  65 static  void    smoothed_diff_double (double *data, unsigned int datalen) ;
  66
  67 static void             check_comment (SNDFILE * file, int format, int lineno) ;
  68
  69 static int              is_lossy (int filetype) ;
  70
  71 /*
  72 ** Force the start of these buffers to be double aligned. Sparc-solaris will
  73 ** choke if they are not.
  74 */
  75 typedef union
  76 {       double  d [BUFFER_SIZE + 1] ;
  77         float   f [BUFFER_SIZE + 1] ;
  78         int             i [BUFFER_SIZE + 1] ;
  79         short   s [BUFFER_SIZE + 1] ;
  80         char    c [BUFFER_SIZE + 1] ;
  81 } BUFFER ;
  82
  83 static  BUFFER  data_buffer ;
  84 static  BUFFER  orig_buffer ;
  85 static  BUFFER  smooth_buffer ;
  86
  87 static const char *long_comment =
  88         "This is really quite a long comment. It is designed to be long enough "
  89         "to screw up the encoders and decoders if the file container format does "
  90         "not handle things correctly. If everything is working correctly, the "
  91         "decoder will only decode the actual audio data, and not this string at "
  92         "the end of the file." ;
  93
  94 int
  95 main (int argc, char *argv [])
  96 {       int             do_all = 0 ;
  97         int             test_count = 0 ;
  98
  99         if (argc != 2)
 100         {       printf ("Usage : %s <test>\n", argv [0]) ;
 101                 printf ("    Where <test> is one of the following:\n") ;
 102                 printf ("           wav_ima     - test IMA ADPCM WAV file functions\n") ;
 103                 printf ("           wav_msadpcm - test MS ADPCM WAV file functions\n") ;
 104                 printf ("           wav_gsm610  - test GSM 6.10 WAV file functions\n") ;
 105                 printf ("           wav_ulaw    - test u-law WAV file functions\n") ;
 106                 printf ("           wav_alaw    - test A-law WAV file functions\n") ;
 107                 printf ("           wve         - test Psion WVE file functions\n") ;
 108                 printf ("           all         - perform all tests\n") ;
 109                 exit (1) ;
 110                 } ;
 111
 112         do_all = ! strcmp (argv [1], "all") ;
 113
 114         if (do_all || strcmp (argv [1], "wav_pcm") == 0)
 115         {       /* This is just a sanity test for PCM encoding. */
 116                 lcomp_test_short        ("pcm.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_16, 2, 1e-50) ;
 117                 lcomp_test_int          ("pcm.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_32, 2, 1e-50) ;
 118                 lcomp_test_short        ("pcm.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_16, 2, 1e-50) ;
 119                 lcomp_test_int          ("pcm.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_PCM_32, 2, 1e-50) ;
 120                 /* Lite remove start */
 121                 lcomp_test_float        ("pcm.wav", SF_FORMAT_WAV | SF_FORMAT_FLOAT, 2, 1e-50) ;
 122                 lcomp_test_double       ("pcm.wav", SF_FORMAT_WAV | SF_FORMAT_DOUBLE, 2, 1e-50) ;
 123                 /* Lite remove end */
 124
 125                 read_raw_test ("pcm.wav", SF_FORMAT_WAV | SF_FORMAT_PCM_U8, 2) ;
 126                 test_count++ ;
 127                 } ;
 128
 129         /* For all the rest, if the file format supports more than 1 channel, use stereo. */
 130         /* Lite remove start */
 131         if (do_all || strcmp (argv [1], "wav_ima") == 0)
 132         {       lcomp_test_short        ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 133                 lcomp_test_int          ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.65) ;
 134                 lcomp_test_float        ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 135                 lcomp_test_double       ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 136
 137                 lcomp_test_short        ("ima.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 138                 lcomp_test_int          ("ima.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 139                 lcomp_test_float        ("ima.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 140                 lcomp_test_double       ("ima.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 141
 142                 sdlcomp_test_short      ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 143                 sdlcomp_test_int        ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 144                 sdlcomp_test_float      ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 145                 sdlcomp_test_double     ("ima.wav", SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 146                 test_count++ ;
 147                 } ;
 148
 149         if (do_all || strcmp (argv [1], "wav_msadpcm") == 0)
 150         {       lcomp_test_short        ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 151                 lcomp_test_int          ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 152                 lcomp_test_float        ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 153                 lcomp_test_double       ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 154
 155                 lcomp_test_short        ("msadpcm.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 156                 lcomp_test_int          ("msadpcm.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 157                 lcomp_test_float        ("msadpcm.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 158                 lcomp_test_double       ("msadpcm.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 159
 160                 sdlcomp_test_short      ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 161                 sdlcomp_test_int        ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 162                 sdlcomp_test_float      ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 163                 sdlcomp_test_double     ("msadpcm.wav", SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 164
 165                 test_count++ ;
 166                 } ;
 167
 168         if (do_all || strcmp (argv [1], "wav_g721") == 0)
 169         {       printf ("**** Fix this later : error bound should be 0.06 ****\n") ;
 170                 lcomp_test_short        ("g721.wav", SF_FORMAT_WAV | SF_FORMAT_G721_32, 1, 0.7) ;
 171                 lcomp_test_int          ("g721.wav", SF_FORMAT_WAV | SF_FORMAT_G721_32, 1, 0.7) ;
 172
 173                 lcomp_test_short        ("g721.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_G721_32, 1, 0.7) ;
 174                 lcomp_test_int          ("g721.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_G721_32, 1, 0.7) ;
 175
 176                 test_count++ ;
 177                 } ;
 178         /* Lite remove end */
 179
 180         if (do_all || strcmp (argv [1], "wav_ulaw") == 0)
 181         {       lcomp_test_short        ("ulaw.wav", SF_FORMAT_WAV | SF_FORMAT_ULAW, 2, 0.04) ;
 182                 lcomp_test_int          ("ulaw.wav", SF_FORMAT_WAV | SF_FORMAT_ULAW, 2, 0.04) ;
 183
 184                 lcomp_test_short        ("ulaw.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_ULAW, 2, 0.04) ;
 185                 lcomp_test_int          ("ulaw.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_ULAW, 2, 0.04) ;
 186
 187                 /* Lite remove start */
 188                 lcomp_test_float        ("ulaw.wav", SF_FORMAT_WAV | SF_FORMAT_ULAW, 2, 0.04) ;
 189                 lcomp_test_double       ("ulaw.wav", SF_FORMAT_WAV | SF_FORMAT_ULAW, 2, 0.04) ;
 190                 /* Lite remove end */
 191
 192                 read_raw_test ("ulaw.wav", SF_FORMAT_WAV | SF_FORMAT_ULAW, 2) ;
 193                 test_count++ ;
 194                 } ;
 195
 196         if (do_all || strcmp (argv [1], "wav_alaw") == 0)
 197         {       lcomp_test_short        ("alaw.wav", SF_FORMAT_WAV | SF_FORMAT_ALAW, 2, 0.04) ;
 198                 lcomp_test_int          ("alaw.wav", SF_FORMAT_WAV | SF_FORMAT_ALAW, 2, 0.04) ;
 199                 /* Lite remove start */
 200                 lcomp_test_float        ("alaw.wav", SF_FORMAT_WAV | SF_FORMAT_ALAW, 2, 0.04) ;
 201                 lcomp_test_double       ("alaw.wav", SF_FORMAT_WAV | SF_FORMAT_ALAW, 2, 0.04) ;
 202                 /* Lite remove end */
 203
 204                 read_raw_test ("alaw.wav", SF_FORMAT_WAV | SF_FORMAT_ALAW, 2) ;
 205                 test_count++ ;
 206                 } ;
 207
 208         if (do_all || strcmp (argv [1], "wav_gsm610") == 0)
 209         {       /* Don't do lcomp_test_XXX as the errors are too big. */
 210                 sdlcomp_test_short      ("gsm610.wav", SF_FORMAT_WAV | SF_FORMAT_GSM610, 1, 0.24) ;
 211                 sdlcomp_test_int        ("gsm610.wav", SF_FORMAT_WAV | SF_FORMAT_GSM610, 1, 0.24) ;
 212
 213                 sdlcomp_test_short      ("gsm610.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_GSM610, 1, 0.24) ;
 214                 sdlcomp_test_int        ("gsm610.rifx", SF_ENDIAN_BIG | SF_FORMAT_WAV | SF_FORMAT_GSM610, 1, 0.24) ;
 215
 216                 /* Lite remove start */
 217                 sdlcomp_test_float      ("gsm610.wav", SF_FORMAT_WAV | SF_FORMAT_GSM610, 1, 0.24) ;
 218                 sdlcomp_test_double     ("gsm610.wav", SF_FORMAT_WAV | SF_FORMAT_GSM610, 1, 0.24) ;
 219                 /* Lite remove end */
 220                 test_count++ ;
 221                 } ;
 222
 223         if (do_all || strcmp (argv [1], "aiff_ulaw") == 0)
 224         {       lcomp_test_short        ("ulaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ULAW, 2, 0.04) ;
 225                 lcomp_test_int          ("ulaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ULAW, 2, 0.04) ;
 226                 /* Lite remove start */
 227                 lcomp_test_float        ("ulaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ULAW, 2, 0.04) ;
 228                 lcomp_test_double       ("ulaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ULAW, 2, 0.04) ;
 229                 /* Lite remove end */
 230
 231                 read_raw_test ("ulaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ULAW, 2) ;
 232                 test_count++ ;
 233                 } ;
 234
 235         if (do_all || strcmp (argv [1], "aiff_alaw") == 0)
 236         {       lcomp_test_short        ("alaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ALAW, 2, 0.04) ;
 237                 lcomp_test_int          ("alaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ALAW, 2, 0.04) ;
 238                 /* Lite remove start */
 239                 lcomp_test_float        ("alaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ALAW, 2, 0.04) ;
 240                 lcomp_test_double       ("alaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ALAW, 2, 0.04) ;
 241                 /* Lite remove end */
 242
 243                 read_raw_test ("alaw.aiff", SF_FORMAT_AIFF | SF_FORMAT_ALAW, 2) ;
 244                 test_count++ ;
 245                 } ;
 246
 247         if (do_all || strcmp (argv [1], "aiff_gsm610") == 0)
 248         {       /* Don't do lcomp_test_XXX as the errors are too big. */
 249                 sdlcomp_test_short      ("gsm610.aiff", SF_FORMAT_AIFF | SF_FORMAT_GSM610, 1, 0.24) ;
 250                 sdlcomp_test_int        ("gsm610.aiff", SF_FORMAT_AIFF | SF_FORMAT_GSM610, 1, 0.24) ;
 251                 /* Lite remove start */
 252                 sdlcomp_test_float      ("gsm610.aiff", SF_FORMAT_AIFF | SF_FORMAT_GSM610, 1, 0.24) ;
 253                 sdlcomp_test_double     ("gsm610.aiff", SF_FORMAT_AIFF | SF_FORMAT_GSM610, 1, 0.24) ;
 254                 /* Lite remove end */
 255                 test_count++ ;
 256                 } ;
 257
 258         if (strcmp (argv [1], "aiff_ima") == 0)
 259         {       lcomp_test_short        ("ima.aiff", SF_FORMAT_AIFF | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 260                 lcomp_test_int          ("ima.aiff", SF_FORMAT_AIFF | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 261                 /* Lite remove start */
 262                 lcomp_test_float        ("ima.aiff", SF_FORMAT_AIFF | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 263                 lcomp_test_double       ("ima.aiff", SF_FORMAT_AIFF | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 264                 /* Lite remove end */
 265                 } ;
 266
 267         if (do_all || strcmp (argv [1], "au_ulaw") == 0)
 268         {       lcomp_test_short        ("ulaw.au", SF_ENDIAN_BIG               | SF_FORMAT_AU | SF_FORMAT_ULAW, 2, 0.04) ;
 269                 lcomp_test_int          ("ulaw.au", SF_ENDIAN_LITTLE    | SF_FORMAT_AU | SF_FORMAT_ULAW, 2, 0.04) ;
 270                 /* Lite remove start */
 271                 lcomp_test_float        ("ulaw.au", SF_ENDIAN_LITTLE    | SF_FORMAT_AU | SF_FORMAT_ULAW, 2, 0.04) ;
 272                 lcomp_test_double       ("ulaw.au", SF_ENDIAN_BIG               | SF_FORMAT_AU | SF_FORMAT_ULAW, 2, 0.04) ;
 273                 /* Lite remove end */
 274                 test_count++ ;
 275                 } ;
 276
 277         if (do_all || strcmp (argv [1], "au_alaw") == 0)
 278         {       lcomp_test_short        ("alaw.au", SF_ENDIAN_LITTLE    | SF_FORMAT_AU | SF_FORMAT_ALAW, 2, 0.04) ;
 279                 lcomp_test_int          ("alaw.au", SF_ENDIAN_BIG               | SF_FORMAT_AU | SF_FORMAT_ALAW, 2, 0.04) ;
 280                 /* Lite remove start */
 281                 lcomp_test_float        ("alaw.au", SF_ENDIAN_BIG               | SF_FORMAT_AU | SF_FORMAT_ALAW, 2, 0.04) ;
 282                 lcomp_test_double       ("alaw.au", SF_ENDIAN_LITTLE    | SF_FORMAT_AU | SF_FORMAT_ALAW, 2, 0.04) ;
 283                 /* Lite remove end */
 284                 test_count++ ;
 285                 } ;
 286
 287         /* Lite remove start */
 288         if (do_all || strcmp (argv [1], "au_g721") == 0)
 289         {       printf ("**** Fix this later : error bound should be 0.06 ****\n") ;
 290                 lcomp_test_short        ("g721.au", SF_ENDIAN_LITTLE    | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.7) ;
 291                 lcomp_test_int          ("g721.au", SF_ENDIAN_BIG               | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.7) ;
 292                 lcomp_test_float        ("g721.au", SF_ENDIAN_LITTLE    | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.7) ;
 293                 lcomp_test_double       ("g721.au", SF_ENDIAN_BIG               | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.7) ;
 294
 295 /*-             sdlcomp_test_short      ("g721.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.07) ;
 296                 sdlcomp_test_int        ("g721.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.07) ;
 297                 sdlcomp_test_float  ("g721.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.07) ;
 298                 sdlcomp_test_double     ("g721.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G721_32, 1, 0.12) ;
 299 -*/
 300                 test_count++ ;
 301                 } ;
 302
 303         if (do_all || strcmp (argv [1], "au_g723") == 0)
 304         {       printf ("**** Fix this later : error bound should be 0.16 ****\n") ;
 305                 lcomp_test_short        ("g723_24.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.7) ;
 306                 lcomp_test_int          ("g723_24.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.7) ;
 307                 lcomp_test_float        ("g723_24.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.7) ;
 308                 lcomp_test_double       ("g723_24.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.7) ;
 309
 310                 lcomp_test_short        ("g723_40.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G723_40, 1, 0.85) ;
 311                 lcomp_test_int          ("g723_40.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G723_40, 1, 0.84) ;
 312                 lcomp_test_float        ("g723_40.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G723_40, 1, 0.86) ;
 313                 lcomp_test_double       ("g723_40.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G723_40, 1, 0.86) ;
 314
 315 /*-             sdlcomp_test_short      ("g723.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.15) ;
 316                 sdlcomp_test_int        ("g723.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.15) ;
 317                 sdlcomp_test_float      ("g723.au", SF_ENDIAN_BIG    | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.15) ;
 318                 sdlcomp_test_double     ("g723.au", SF_ENDIAN_LITTLE | SF_FORMAT_AU | SF_FORMAT_G723_24, 1, 0.15) ;
 319 -*/
 320                 test_count++ ;
 321                 } ;
 322         /* Lite remove end */
 323
 324         if (do_all || strcmp (argv [1], "caf_ulaw") == 0)
 325         {       lcomp_test_short        ("ulaw.caf", SF_FORMAT_CAF | SF_FORMAT_ULAW, 2, 0.04) ;
 326                 lcomp_test_int          ("ulaw.caf", SF_FORMAT_CAF | SF_FORMAT_ULAW, 2, 0.04) ;
 327                 /* Lite remove start */
 328                 lcomp_test_float        ("ulaw.caf", SF_FORMAT_CAF | SF_FORMAT_ULAW, 2, 0.04) ;
 329                 lcomp_test_double       ("ulaw.caf", SF_FORMAT_CAF | SF_FORMAT_ULAW, 2, 0.04) ;
 330                 /* Lite remove end */
 331
 332                 read_raw_test ("ulaw.caf", SF_FORMAT_CAF | SF_FORMAT_ULAW, 2) ;
 333                 test_count++ ;
 334                 } ;
 335
 336         if (do_all || strcmp (argv [1], "caf_alaw") == 0)
 337         {       lcomp_test_short        ("alaw.caf", SF_FORMAT_CAF | SF_FORMAT_ALAW, 2, 0.04) ;
 338                 lcomp_test_int          ("alaw.caf", SF_FORMAT_CAF | SF_FORMAT_ALAW, 2, 0.04) ;
 339                 /* Lite remove start */
 340                 lcomp_test_float        ("alaw.caf", SF_FORMAT_CAF | SF_FORMAT_ALAW, 2, 0.04) ;
 341                 lcomp_test_double       ("alaw.caf", SF_FORMAT_CAF | SF_FORMAT_ALAW, 2, 0.04) ;
 342                 /* Lite remove end */
 343
 344                 read_raw_test ("alaw.caf", SF_FORMAT_CAF | SF_FORMAT_ALAW, 2) ;
 345                 test_count++ ;
 346                 } ;
 347
 348
 349         if (do_all || strcmp (argv [1], "raw_ulaw") == 0)
 350         {       lcomp_test_short        ("ulaw.raw", SF_ENDIAN_LITTLE   | SF_FORMAT_RAW | SF_FORMAT_ULAW, 2, 0.04) ;
 351                 lcomp_test_int          ("ulaw.raw", SF_ENDIAN_BIG              | SF_FORMAT_RAW | SF_FORMAT_ULAW, 2, 0.04) ;
 352                 /* Lite remove start */
 353                 lcomp_test_float        ("ulaw.raw", SF_ENDIAN_LITTLE   | SF_FORMAT_RAW | SF_FORMAT_ULAW, 2, 0.04) ;
 354                 lcomp_test_double       ("ulaw.raw", SF_ENDIAN_BIG              | SF_FORMAT_RAW | SF_FORMAT_ULAW, 2, 0.04) ;
 355                 /* Lite remove end */
 356                 test_count++ ;
 357                 } ;
 358
 359         if (do_all || strcmp (argv [1], "raw_alaw") == 0)
 360         {       lcomp_test_short        ("alaw.raw", SF_ENDIAN_LITTLE   | SF_FORMAT_RAW | SF_FORMAT_ALAW, 2, 0.04) ;
 361                 lcomp_test_int          ("alaw.raw", SF_ENDIAN_BIG              | SF_FORMAT_RAW | SF_FORMAT_ALAW, 2, 0.04) ;
 362                 /* Lite remove start */
 363                 lcomp_test_float        ("alaw.raw", SF_ENDIAN_LITTLE   | SF_FORMAT_RAW | SF_FORMAT_ALAW, 2, 0.04) ;
 364                 lcomp_test_double       ("alaw.raw", SF_ENDIAN_BIG              | SF_FORMAT_RAW | SF_FORMAT_ALAW, 2, 0.04) ;
 365                 /* Lite remove end */
 366                 test_count++ ;
 367                 } ;
 368
 369         if (do_all || strcmp (argv [1], "raw_gsm610") == 0)
 370         {       /* Don't do lcomp_test_XXX as the errors are too big. */
 371                 sdlcomp_test_short      ("raw.gsm", SF_FORMAT_RAW | SF_FORMAT_GSM610, 1, 0.24) ;
 372                 sdlcomp_test_int        ("raw.gsm", SF_FORMAT_RAW | SF_FORMAT_GSM610, 1, 0.24) ;
 373                 sdlcomp_test_float      ("raw.gsm", SF_FORMAT_RAW | SF_FORMAT_GSM610, 1, 0.24) ;
 374                 sdlcomp_test_double     ("raw.gsm", SF_FORMAT_RAW | SF_FORMAT_GSM610, 1, 0.24) ;
 375                 test_count++ ;
 376                 } ;
 377
 378         if (do_all || strcmp (argv [1], "ogg_vorbis") == 0)
 379         {       if (HAVE_EXTERNAL_LIBS)
 380                 {       /* Don't do lcomp_test_XXX as the errors are too big. */
 381                         sdlcomp_test_short      ("vorbis.oga", SF_FORMAT_OGG | SF_FORMAT_VORBIS, 1, 0.30) ;
 382                         sdlcomp_test_int        ("vorbis.oga", SF_FORMAT_OGG | SF_FORMAT_VORBIS, 1, 0.30) ;
 383                         sdlcomp_test_float      ("vorbis.oga", SF_FORMAT_OGG | SF_FORMAT_VORBIS, 1, 0.30) ;
 384                         sdlcomp_test_double     ("vorbis.oga", SF_FORMAT_OGG | SF_FORMAT_VORBIS, 1, 0.30) ;
 385                         }
 386                 else
 387                         puts ("    No Ogg/Vorbis tests because Ogg/Vorbis support was not compiled in.") ;
 388
 389                 test_count++ ;
 390                 } ;
 391
 392         /* Lite remove start */
 393         if (do_all || strcmp (argv [1], "ircam_ulaw") == 0)
 394         {       lcomp_test_short        ("ulaw.ircam", SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_ULAW, 2, 0.04) ;
 395                 lcomp_test_int          ("ulaw.ircam", SF_ENDIAN_BIG    | SF_FORMAT_IRCAM | SF_FORMAT_ULAW, 2, 0.04) ;
 396                 lcomp_test_float        ("ulaw.ircam", SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_ULAW, 2, 0.04) ;
 397                 lcomp_test_double       ("ulaw.ircam", SF_ENDIAN_BIG    | SF_FORMAT_IRCAM | SF_FORMAT_ULAW, 2, 0.04) ;
 398                 test_count++ ;
 399                 } ;
 400
 401         if (do_all || strcmp (argv [1], "ircam_alaw") == 0)
 402         {       lcomp_test_short        ("alaw.ircam", SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_ALAW, 2, 0.04) ;
 403                 lcomp_test_int          ("alaw.ircam", SF_ENDIAN_BIG    | SF_FORMAT_IRCAM | SF_FORMAT_ALAW, 2, 0.04) ;
 404                 lcomp_test_float        ("alaw.ircam", SF_ENDIAN_LITTLE | SF_FORMAT_IRCAM | SF_FORMAT_ALAW, 2, 0.04) ;
 405                 lcomp_test_double       ("alaw.ircam", SF_ENDIAN_BIG    | SF_FORMAT_IRCAM | SF_FORMAT_ALAW, 2, 0.04) ;
 406                 test_count++ ;
 407                 } ;
 408
 409         if (do_all || strcmp (argv [1], "nist_ulaw") == 0)
 410         {       lcomp_test_short        ("ulaw.nist", SF_ENDIAN_LITTLE  | SF_FORMAT_NIST | SF_FORMAT_ULAW, 2, 0.04) ;
 411                 lcomp_test_int          ("ulaw.nist", SF_ENDIAN_BIG             | SF_FORMAT_NIST | SF_FORMAT_ULAW, 2, 0.04) ;
 412                 lcomp_test_float        ("ulaw.nist", SF_ENDIAN_LITTLE  | SF_FORMAT_NIST | SF_FORMAT_ULAW, 2, 0.04) ;
 413                 lcomp_test_double       ("ulaw.nist", SF_ENDIAN_BIG             | SF_FORMAT_NIST | SF_FORMAT_ULAW, 2, 0.04) ;
 414                 test_count++ ;
 415                 } ;
 416
 417         if (do_all || strcmp (argv [1], "nist_alaw") == 0)
 418         {       lcomp_test_short        ("alaw.nist", SF_ENDIAN_LITTLE  | SF_FORMAT_NIST | SF_FORMAT_ALAW, 2, 0.04) ;
 419                 lcomp_test_int          ("alaw.nist", SF_ENDIAN_BIG             | SF_FORMAT_NIST | SF_FORMAT_ALAW, 2, 0.04) ;
 420                 lcomp_test_float        ("alaw.nist", SF_ENDIAN_LITTLE  | SF_FORMAT_NIST | SF_FORMAT_ALAW, 2, 0.04) ;
 421                 lcomp_test_double       ("alaw.nist", SF_ENDIAN_BIG             | SF_FORMAT_NIST | SF_FORMAT_ALAW, 2, 0.04) ;
 422                 test_count++ ;
 423                 } ;
 424
 425         if (do_all || strcmp (argv [1], "voc_ulaw") == 0)
 426         {       lcomp_test_short        ("ulaw.voc", SF_FORMAT_VOC | SF_FORMAT_ULAW, 2, 0.04) ;
 427                 lcomp_test_int          ("ulaw.voc", SF_FORMAT_VOC | SF_FORMAT_ULAW, 2, 0.04) ;
 428                 lcomp_test_float        ("ulaw.voc", SF_FORMAT_VOC | SF_FORMAT_ULAW, 2, 0.04) ;
 429                 lcomp_test_double       ("ulaw.voc", SF_FORMAT_VOC | SF_FORMAT_ULAW, 2, 0.04) ;
 430                 test_count++ ;
 431                 } ;
 432
 433         if (do_all || strcmp (argv [1], "voc_alaw") == 0)
 434         {       lcomp_test_short        ("alaw.voc", SF_FORMAT_VOC | SF_FORMAT_ALAW, 2, 0.04) ;
 435                 lcomp_test_int          ("alaw.voc", SF_FORMAT_VOC | SF_FORMAT_ALAW, 2, 0.04) ;
 436                 lcomp_test_float        ("alaw.voc", SF_FORMAT_VOC | SF_FORMAT_ALAW, 2, 0.04) ;
 437                 lcomp_test_double       ("alaw.voc", SF_FORMAT_VOC | SF_FORMAT_ALAW, 2, 0.04) ;
 438                 test_count++ ;
 439                 } ;
 440         /* Lite remove end */
 441
 442         if (do_all || strcmp (argv [1], "w64_ulaw") == 0)
 443         {       lcomp_test_short        ("ulaw.w64", SF_FORMAT_W64 | SF_FORMAT_ULAW, 2, 0.04) ;
 444                 lcomp_test_int          ("ulaw.w64", SF_FORMAT_W64 | SF_FORMAT_ULAW, 2, 0.04) ;
 445                 /* Lite remove start */
 446                 lcomp_test_float        ("ulaw.w64", SF_FORMAT_W64 | SF_FORMAT_ULAW, 2, 0.04) ;
 447                 lcomp_test_double       ("ulaw.w64", SF_FORMAT_W64 | SF_FORMAT_ULAW, 2, 0.04) ;
 448                 /* Lite remove end */
 449
 450                 read_raw_test ("ulaw.w64", SF_FORMAT_W64 | SF_FORMAT_ULAW, 2) ;
 451                 test_count++ ;
 452                 } ;
 453
 454         if (do_all || strcmp (argv [1], "w64_alaw") == 0)
 455         {       lcomp_test_short        ("alaw.w64", SF_FORMAT_W64 | SF_FORMAT_ALAW, 2, 0.04) ;
 456                 lcomp_test_int          ("alaw.w64", SF_FORMAT_W64 | SF_FORMAT_ALAW, 2, 0.04) ;
 457                 /* Lite remove start */
 458                 lcomp_test_float        ("alaw.w64", SF_FORMAT_W64 | SF_FORMAT_ALAW, 2, 0.04) ;
 459                 lcomp_test_double       ("alaw.w64", SF_FORMAT_W64 | SF_FORMAT_ALAW, 2, 0.04) ;
 460                 /* Lite remove end */
 461
 462                 read_raw_test ("alaw.w64", SF_FORMAT_W64 | SF_FORMAT_ALAW, 2) ;
 463                 test_count++ ;
 464                 } ;
 465
 466         /* Lite remove start */
 467         if (do_all || strcmp (argv [1], "w64_ima") == 0)
 468         {       lcomp_test_short        ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 469                 lcomp_test_int          ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 470                 lcomp_test_float        ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 471                 lcomp_test_double       ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 472
 473                 sdlcomp_test_short      ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 474                 sdlcomp_test_int        ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 475                 sdlcomp_test_float      ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 476                 sdlcomp_test_double     ("ima.w64", SF_FORMAT_W64 | SF_FORMAT_IMA_ADPCM, 2, 0.18) ;
 477                 test_count++ ;
 478                 } ;
 479
 480         if (do_all || strcmp (argv [1], "w64_msadpcm") == 0)
 481         {       lcomp_test_short        ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 482                 lcomp_test_int          ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 483                 lcomp_test_float        ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 484                 lcomp_test_double       ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 485
 486                 sdlcomp_test_short      ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 487                 sdlcomp_test_int        ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 488                 sdlcomp_test_float      ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 489                 sdlcomp_test_double     ("msadpcm.w64", SF_FORMAT_W64 | SF_FORMAT_MS_ADPCM, 2, 0.36) ;
 490                 test_count++ ;
 491                 } ;
 492
 493         if (do_all || strcmp (argv [1], "wve") == 0)
 494         {       lcomp_test_short        ("psion.wve", SF_FORMAT_WVE | SF_FORMAT_ALAW, 1, 0.04) ;
 495                 lcomp_test_int          ("psion.wve", SF_FORMAT_WVE | SF_FORMAT_ALAW, 1, 0.04) ;
 496                 /* Lite remove start */
 497                 lcomp_test_float        ("psion.wve", SF_FORMAT_WVE | SF_FORMAT_ALAW, 1, 0.04) ;
 498                 lcomp_test_double       ("psion.wve", SF_FORMAT_WVE | SF_FORMAT_ALAW, 1, 0.04) ;
 499                 /* Lite remove end */
 500                 test_count++ ;
 501                 } ;
 502
 503         /* Lite remove end */
 504
 505         if (do_all || strcmp (argv [1], "w64_gsm610") == 0)
 506         {       /* Don't do lcomp_test_XXX as the errors are too big. */
 507                 sdlcomp_test_short      ("gsm610.w64", SF_FORMAT_W64 | SF_FORMAT_GSM610, 1, 0.2) ;
 508                 sdlcomp_test_int        ("gsm610.w64", SF_FORMAT_W64 | SF_FORMAT_GSM610, 1, 0.2) ;
 509                 /* Lite remove start */
 510                 sdlcomp_test_float      ("gsm610.w64", SF_FORMAT_W64 | SF_FORMAT_GSM610, 1, 0.2) ;
 511                 sdlcomp_test_double     ("gsm610.w64", SF_FORMAT_W64 | SF_FORMAT_GSM610, 1, 0.2) ;
 512                 /* Lite remove end */
 513                 test_count++ ;
 514                 } ;
 515
 516         /* Lite remove start */
 517         if (do_all || strcmp (argv [1], "vox_adpcm") == 0)
 518         {       lcomp_test_short        ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.17) ;
 519                 lcomp_test_int          ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.17) ;
 520                 lcomp_test_float        ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.17) ;
 521                 lcomp_test_double       ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.17) ;
 522
 523                 sdlcomp_test_short      ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.072) ;
 524                 sdlcomp_test_int        ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.072) ;
 525                 sdlcomp_test_float      ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.072) ;
 526                 sdlcomp_test_double     ("adpcm.vox", SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM, 1, 0.072) ;
 527                 test_count++ ;
 528                 } ;
 529
 530         if (do_all || strcmp (argv [1], "xi_dpcm") == 0)
 531         {       lcomp_test_short        ("8bit.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_8, 1, 0.25) ;
 532                 lcomp_test_int          ("8bit.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_8, 1, 0.25) ;
 533
 534                 lcomp_test_short        ("16bit.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_16, 1, 0.002) ;
 535                 lcomp_test_int          ("16bit.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_16, 1, 0.002) ;
 536                 lcomp_test_float        ("16bit.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_16, 1, 0.002) ;
 537                 lcomp_test_double       ("16bit.xi", SF_FORMAT_XI | SF_FORMAT_DPCM_16, 1, 0.002) ;
 538                 test_count++ ;
 539                 } ;
 540         /* Lite remove end */
 541
 542         if (test_count == 0)
 543         {       printf ("************************************\n") ;
 544                 printf ("*  No '%s' test defined.\n", argv [1]) ;
 545                 printf ("************************************\n") ;
 546                 return 1 ;
 547                 } ;
 548
 549         return 0 ;
 550 } /* main */
 551
 552 /*============================================================================================
 553 **      Here are the test functions.
 554 */
 555
 556 static void
 557 lcomp_test_short (const char *filename, int filetype, int channels, double margin)
 558 {       SNDFILE                 *file ;
 559         SF_INFO                 sfinfo ;
 560         int                             k, m, seekpos, half_max_abs ;
 561         sf_count_t              datalen ;
 562         short                   *orig, *data ;
 563
 564         print_test_name ("lcomp_test_short", filename) ;
 565
 566         datalen = BUFFER_SIZE / channels ;
 567
 568         data = data_buffer.s ;
 569         orig = orig_buffer.s ;
 570
 571         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
 572         for (k = 0 ; k < channels * datalen ; k++)
 573                 orig [k] = (short) (orig_buffer.d [k]) ;
 574
 575         sfinfo.samplerate       = SAMPLE_RATE ;
 576         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
 577         sfinfo.channels         = channels ;
 578         sfinfo.format           = filetype ;
 579
 580         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
 581         test_writef_short_or_die (file, 0, orig, datalen, __LINE__) ;
 582         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
 583         sf_close (file) ;
 584
 585         memset (data, 0, datalen * sizeof (short)) ;
 586
 587         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
 588                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
 589
 590         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
 591
 592         if ((sfinfo.format & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)) != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
 593         {       printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
 594                 exit (1) ;
 595                 } ;
 596
 597         if (sfinfo.frames < datalen / channels)
 598         {       printf ("Too few frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
 599                 exit (1) ;
 600                 } ;
 601
 602         if (sfinfo.frames > (datalen + datalen / 20))
 603         {       printf ("Too many frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
 604                 exit (1) ;
 605                 } ;
 606
 607         if (sfinfo.channels != channels)
 608         {       printf ("Incorrect number of channels in file.\n") ;
 609                 exit (1) ;
 610                 } ;
 611
 612         check_log_buffer_or_die (file, __LINE__) ;
 613
 614         check_comment (file, filetype, __LINE__) ;
 615
 616         test_readf_short_or_die (file, 0, data, datalen, __LINE__) ;
 617
 618         half_max_abs = 0 ;
 619         for (k = 0 ; k < datalen ; k++)
 620         {       if (error_function (data [k], orig [k], margin))
 621                 {       printf ("\n\nLine %d: Incorrect sample A (#%d : %d should be %d).\n", __LINE__, k, data [k], orig [k]) ;
 622                         oct_save_short (orig, data, datalen) ;
 623                         exit (1) ;
 624                         } ;
 625                 half_max_abs = LCT_MAX (half_max_abs, abs (data [k] / 2)) ;
 626                 } ;
 627
 628         if (half_max_abs < 1.0)
 629         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
 630                 exit (1) ;
 631                 } ;
 632
 633         if ((k = sf_readf_short (file, data, datalen)) != sfinfo.frames - datalen)
 634         {       printf ("\n\nLine %d: Incorrect read length (%" PRId64 " should be %d).\n", __LINE__,
 635                         channels * sfinfo.frames - datalen, k) ;
 636                 exit (1) ;
 637                 } ;
 638
 639         /*      This check is only for block based encoders which must append silence
 640         **      to the end of a file so as to fill out a block.
 641         */
 642         for (k = 0 ; k < sfinfo.frames - datalen ; k++)
 643                 if (abs (data [channels * k]) > decay_response (channels * k))
 644                 {       printf ("\n\nLine %d : Incorrect sample B (#%d : abs (%d) should be < %d).\n", __LINE__, channels * k, data [channels * k], decay_response (channels * k)) ;
 645                         exit (1) ;
 646                         } ;
 647
 648         if (! sfinfo.seekable)
 649         {       sf_close (file) ;
 650                 unlink (filename) ;
 651                 printf ("ok\n") ;
 652                 return ;
 653                 } ;
 654
 655         /* Now test sf_seek function. */
 656
 657         if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
 658         {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
 659                 exit (1) ;
 660                 } ;
 661
 662         for (m = 0 ; m < 3 ; m++)
 663         {       test_readf_short_or_die (file, m, data, 11, __LINE__) ;
 664
 665                 for (k = 0 ; k < channels * 11 ; k++)
 666                         if (error_function (1.0 * data [k], 1.0 * orig [k + channels * m * 11], margin))
 667                         {       printf ("\n\nLine %d: Incorrect sample (m = %d) (#%d : %d => %d).\n", __LINE__, m, k + channels * m * 11, orig [k + channels * m * 11], data [k]) ;
 668                                 for (m = 0 ; m < channels ; m++)
 669                                         printf ("%d ", data [m]) ;
 670                                 printf ("\n") ;
 671                                 exit (1) ;
 672                                 } ;
 673                 } ;
 674
 675         seekpos = BUFFER_SIZE / 10 ;
 676
 677         /* Check seek from start of file. */
 678         if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
 679         {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
 680                 exit (1) ;
 681                 } ;
 682
 683         test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
 684
 685         if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin))
 686         {       printf ("\n\nLine %d: sf_seek (SEEK_SET) followed by sf_readf_short failed (%d, %d).\n", __LINE__, orig [1], data [0]) ;
 687                 exit (1) ;
 688                 } ;
 689
 690         if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
 691         {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
 692                 exit (1) ;
 693                 } ;
 694
 695         seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
 696         k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
 697         test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
 698         if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
 699         {       printf ("\n\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_readf_short failed (%d, %d) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos + 1) ;
 700                 oct_save_short (orig, data, datalen) ;
 701                 exit (1) ;
 702                 } ;
 703
 704         seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
 705         /* Check seek backward from current position. */
 706         k = sf_seek (file, -20, SEEK_CUR) ;
 707         test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
 708         if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
 709         {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_readf_short failed (%d, %d) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos) ;
 710                 exit (1) ;
 711                 } ;
 712
 713         /* Check that read past end of file returns number of items. */
 714         sf_seek (file, sfinfo.frames, SEEK_SET) ;
 715
 716         if ((k = sf_readf_short (file, data, datalen)) != 0)
 717         {       printf ("\n\nLine %d: Return value from sf_readf_short past end of file incorrect (%d).\n", __LINE__, k) ;
 718                 exit (1) ;
 719                 } ;
 720
 721         /* Check seek backward from end. */
 722         if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
 723         {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
 724                 exit (1) ;
 725                 } ;
 726
 727         test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
 728         if (error_function (1.0 * data [0], 1.0 * orig [5 * channels], margin))
 729         {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_readf_short failed (%d should be %d).\n", __LINE__, data [0], orig [5 * channels]) ;
 730                 exit (1) ;
 731                 } ;
 732
 733         sf_close (file) ;
 734
 735         unlink (filename) ;
 736         printf ("ok\n") ;
 737 } /* lcomp_test_short */
 738
 739 /*--------------------------------------------------------------------------------------------
 740 */
 741
 742 static void
 743 lcomp_test_int (const char *filename, int filetype, int channels, double margin)
 744 {       SNDFILE                 *file ;
 745         SF_INFO                 sfinfo ;
 746         int                             k, m, half_max_abs ;
 747         sf_count_t              datalen, seekpos ;
 748         double                  scale, max_val ;
 749         int                             *orig, *data ;
 750
 751         print_test_name ("lcomp_test_int", filename) ;
 752
 753         datalen = BUFFER_SIZE / channels ;
 754
 755         if (is_lossy (filetype))
 756         {       scale = 1.0 * 0x10000 ;
 757                 max_val = 32000.0 * scale ;
 758                 }
 759         else
 760         {       scale = 1.0 ;
 761                 max_val = 0x7fffffff * scale ;
 762                 } ;
 763
 764         data = data_buffer.i ;
 765         orig = orig_buffer.i ;
 766
 767         gen_signal_double (orig_buffer.d, max_val, channels, datalen) ;
 768
 769         for (k = 0 ; k < channels * datalen ; k++)
 770                 orig [k] = lrint (orig_buffer.d [k]) ;
 771
 772         sfinfo.samplerate       = SAMPLE_RATE ;
 773         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
 774         sfinfo.channels         = channels ;
 775         sfinfo.format           = filetype ;
 776
 777         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
 778         test_writef_int_or_die (file, 0, orig, datalen, __LINE__) ;
 779         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
 780         sf_close (file) ;
 781
 782         memset (data, 0, datalen * sizeof (int)) ;
 783
 784         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
 785                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
 786
 787         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
 788
 789         if ((sfinfo.format & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)) != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
 790         {       printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
 791                 exit (1) ;
 792                 } ;
 793
 794         if (sfinfo.frames < datalen / channels)
 795         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
 796                 exit (1) ;
 797                 } ;
 798
 799         if (sfinfo.frames > (datalen + datalen / 20))
 800         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
 801                 exit (1) ;
 802                 } ;
 803
 804         if (sfinfo.channels != channels)
 805         {       printf ("Incorrect number of channels in file.\n") ;
 806                 exit (1) ;
 807                 } ;
 808
 809         check_log_buffer_or_die (file, __LINE__) ;
 810
 811         check_comment (file, filetype, __LINE__) ;
 812
 813         test_readf_int_or_die (file, 0, data, datalen, __LINE__) ;
 814
 815         half_max_abs = 0 ;
 816         for (k = 0 ; k < datalen ; k++)
 817         {       if (error_function (data [k] / scale, orig [k] / scale, margin))
 818                 {       printf ("\nLine %d: Incorrect sample (#%d : %f should be %f).\n", __LINE__, k, data [k] / scale, orig [k] / scale) ;
 819                         oct_save_int (orig, data, datalen) ;
 820                         exit (1) ;
 821                         } ;
 822                 half_max_abs = LCT_MAX (half_max_abs, abs (data [k] / 2)) ;
 823                 } ;
 824
 825         if (half_max_abs < 1.0)
 826         {       printf ("\n\nLine %d: Signal is all zeros (%d, 0x%X).\n", __LINE__, half_max_abs, half_max_abs) ;
 827                 exit (1) ;
 828                 } ;
 829
 830         if ((k = sf_readf_int (file, data, datalen)) != sfinfo.frames - datalen)
 831         {       printf ("\n\nLine %d: Incorrect read length (%" PRId64 " should be %d).\n", __LINE__,
 832                         channels * sfinfo.frames - datalen, k) ;
 833                 exit (1) ;
 834                 } ;
 835
 836         /*      This check is only for block based encoders which must append silence
 837         **      to the end of a file so as to fill out a block.
 838         */
 839         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM)
 840                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
 841                         if (ABS (data [channels * k] / scale) > decay_response (channels * k))
 842                         {       printf ("\n\nLine %d : Incorrect sample B (#%d : abs (%d) should be < %d).\n", __LINE__, channels * k, data [channels * k], decay_response (channels * k)) ;
 843                                 exit (1) ;
 844                                 } ;
 845
 846         if (! sfinfo.seekable)
 847         {       sf_close (file) ;
 848                 unlink (filename) ;
 849                 printf ("ok\n") ;
 850                 return ;
 851                 } ;
 852
 853         /* Now test sf_seek function. */
 854
 855         if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
 856         {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
 857                 exit (1) ;
 858                 } ;
 859
 860         for (m = 0 ; m < 3 ; m++)
 861         {       test_readf_int_or_die (file, m, data, 11, __LINE__) ;
 862
 863                 for (k = 0 ; k < channels * 11 ; k++)
 864                         if (error_function (data [k] / scale, orig [k + channels * m * 11] / scale, margin))
 865                         {       printf ("\nLine %d: Incorrect sample (m = %d) (#%d : %d => %d).\n", __LINE__, m, k + channels * m * 11, orig [k + channels * m * 11], data [k]) ;
 866                                 for (m = 0 ; m < channels ; m++)
 867                                         printf ("%d ", data [m]) ;
 868                                 printf ("\n") ;
 869                                 exit (1) ;
 870                                 } ;
 871                 } ;
 872
 873         seekpos = BUFFER_SIZE / 10 ;
 874
 875         /* Check seek from start of file. */
 876         if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
 877         {       printf ("Seek to start of file + %" PRId64 " failed (%d).\n", seekpos, k) ;
 878                 exit (1) ;
 879                 } ;
 880
 881         test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
 882
 883         if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin))
 884         {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_readf_int failed (%d, %d).\n", __LINE__, orig [1], data [0]) ;
 885                 exit (1) ;
 886                 } ;
 887
 888         if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
 889         {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %" PRId64 ")\n", __LINE__, k, seekpos + 1) ;
 890                 exit (1) ;
 891                 } ;
 892
 893         seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
 894         k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
 895         test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
 896         if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
 897         {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_readf_int failed (%d, %d) (%d, %" PRId64 ").\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos + 1) ;
 898                 exit (1) ;
 899                 } ;
 900
 901         seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
 902         /* Check seek backward from current position. */
 903         k = sf_seek (file, -20, SEEK_CUR) ;
 904         test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
 905         if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
 906         {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_readf_int failed (%d, %d) (%d, %" PRId64 ").\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos) ;
 907                 exit (1) ;
 908                 } ;
 909
 910         /* Check that read past end of file returns number of items. */
 911         sf_seek (file, sfinfo.frames, SEEK_SET) ;
 912
 913         if ((k = sf_readf_int (file, data, datalen)) != 0)
 914         {       printf ("\n\nLine %d: Return value from sf_readf_int past end of file incorrect (%d).\n", __LINE__, k) ;
 915                 exit (1) ;
 916                 } ;
 917
 918         /* Check seek backward from end. */
 919         if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
 920         {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
 921                 exit (1) ;
 922                 } ;
 923
 924         test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
 925         if (error_function (data [0] / scale, orig [5 * channels] / scale, margin))
 926         {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_readf_short failed (%d should be %d).\n", __LINE__, data [0], orig [5]) ;
 927                 exit (1) ;
 928                 } ;
 929
 930         sf_close (file) ;
 931
 932         unlink (filename) ;
 933         printf ("ok\n") ;
 934 } /* lcomp_test_int */
 935
 936 /*--------------------------------------------------------------------------------------------
 937 */
 938
 939 static void
 940 lcomp_test_float (const char *filename, int filetype, int channels, double margin)
 941 {       SNDFILE                 *file ;
 942         SF_INFO                 sfinfo ;
 943         int                             k, m, seekpos ;
 944         sf_count_t              datalen ;
 945         float                   *orig, *data ;
 946         double                  half_max_abs ;
 947
 948         print_test_name ("lcomp_test_float", filename) ;
 949
 950         datalen = BUFFER_SIZE / channels ;
 951
 952         data = data_buffer.f ;
 953         orig = orig_buffer.f ;
 954
 955         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
 956         for (k = 0 ; k < channels * datalen ; k++)
 957                 orig [k] = orig_buffer.d [k] ;
 958
 959         sfinfo.samplerate       = SAMPLE_RATE ;
 960         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
 961         sfinfo.channels         = channels ;
 962         sfinfo.format           = filetype ;
 963
 964         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
 965         sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
 966         test_writef_float_or_die (file, 0, orig, datalen, __LINE__) ;
 967         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
 968         sf_close (file) ;
 969
 970         memset (data, 0, datalen * sizeof (float)) ;
 971
 972         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
 973                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
 974
 975         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
 976
 977         if ((sfinfo.format & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)) != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
 978         {       printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
 979                 exit (1) ;
 980                 } ;
 981
 982         if (sfinfo.frames < datalen / channels)
 983         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
 984                 exit (1) ;
 985                 } ;
 986
 987         if (sfinfo.frames > (datalen + datalen / 20))
 988         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
 989                 exit (1) ;
 990                 } ;
 991
 992         if (sfinfo.channels != channels)
 993         {       printf ("Incorrect number of channels in file.\n") ;
 994                 exit (1) ;
 995                 } ;
 996
 997         check_comment (file, filetype, __LINE__) ;
 998
 999         sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1000
1001         check_log_buffer_or_die (file, __LINE__) ;
1002
1003         check_comment (file, filetype, __LINE__) ;
1004
1005         sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1006
1007         test_readf_float_or_die (file, 0, data, datalen, __LINE__) ;
1008
1009         half_max_abs = 0.0 ;
1010         for (k = 0 ; k < datalen ; k++)
1011         {       if (error_function (data [k], orig [k], margin))
1012                 {       printf ("\nLine %d: Incorrect sample A (#%d : %f should be %f).\n", __LINE__, k, data [k], orig [k]) ;
1013                         oct_save_float (orig, data, datalen) ;
1014                         exit (1) ;
1015                         } ;
1016                 half_max_abs = LCT_MAX (half_max_abs, fabs (0.5 * data [k])) ;
1017                 } ;
1018
1019         if (half_max_abs < 1.0)
1020         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
1021                 exit (1) ;
1022                 } ;
1023
1024         if ((k = sf_readf_float (file, data, datalen)) != sfinfo.frames - datalen)
1025         {       printf ("\n\nLine %d: Incorrect read length (%" PRId64 " should be %d).\n", __LINE__,
1026                         channels * sfinfo.frames - datalen, k) ;
1027                 exit (1) ;
1028                 } ;
1029
1030         /*      This check is only for block based encoders which must append silence
1031         **      to the end of a file so as to fill out a block.
1032         */
1033         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM)
1034                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
1035                         if (ABS (data [channels * k]) > decay_response (channels * k))
1036                         {       printf ("\n\nLine %d : Incorrect sample B (#%d : abs (%f) should be < %d).\n", __LINE__, channels * k, data [channels * k], decay_response (channels * k)) ;
1037                                 exit (1) ;
1038                                 } ;
1039
1040         if (! sfinfo.seekable)
1041         {       sf_close (file) ;
1042                 unlink (filename) ;
1043                 printf ("ok\n") ;
1044                 return ;
1045                 } ;
1046
1047         /* Now test sf_seek function. */
1048
1049         if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
1050         {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
1051                 exit (1) ;
1052                 } ;
1053
1054         for (m = 0 ; m < 3 ; m++)
1055         {       test_readf_float_or_die (file, 0, data, 11, __LINE__) ;
1056
1057                 for (k = 0 ; k < channels * 11 ; k++)
1058                         if (error_function (data [k], orig [k + channels * m * 11], margin))
1059                         {       printf ("\nLine %d: Incorrect sample (m = %d) (#%d : %f => %f).\n", __LINE__, m, k + channels * m * 11, orig [k + channels * m * 11], data [k]) ;
1060                                 for (m = 0 ; m < channels ; m++)
1061                                         printf ("%f ", data [m]) ;
1062                                 printf ("\n") ;
1063                                 exit (1) ;
1064                                 } ;
1065                 } ;
1066
1067         seekpos = BUFFER_SIZE / 10 ;
1068
1069         /* Check seek from start of file. */
1070         if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
1071         {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
1072                 exit (1) ;
1073                 } ;
1074
1075         test_readf_float_or_die (file, 0, data, 1, __LINE__) ;
1076
1077         if (error_function (data [0], orig [seekpos * channels], margin))
1078         {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_readf_float failed (%f, %f).\n", __LINE__, orig [1], data [0]) ;
1079                 exit (1) ;
1080                 } ;
1081
1082         if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
1083         {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
1084                 exit (1) ;
1085                 } ;
1086
1087         seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
1088         k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
1089         test_readf_float_or_die (file, 0, data, 1, __LINE__) ;
1090         if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
1091         {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_readf_float failed (%f, %f) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos + 1) ;
1092                 exit (1) ;
1093                 } ;
1094
1095         seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
1096         /* Check seek backward from current position. */
1097         k = sf_seek (file, -20, SEEK_CUR) ;
1098         test_readf_float_or_die (file, 0, data, 1, __LINE__) ;
1099         if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
1100         {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_readf_float failed (%f, %f) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos) ;
1101                 exit (1) ;
1102                 } ;
1103
1104         /* Check that read past end of file returns number of items. */
1105         sf_seek (file, sfinfo.frames, SEEK_SET) ;
1106
1107         if ((k = sf_readf_float (file, data, datalen)) != 0)
1108         {       printf ("\n\nLine %d: Return value from sf_readf_float past end of file incorrect (%d).\n", __LINE__, k) ;
1109                 exit (1) ;
1110                 } ;
1111
1112         /* Check seek backward from end. */
1113         if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
1114         {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
1115                 exit (1) ;
1116                 } ;
1117
1118         test_readf_float_or_die (file, 0, data, 1, __LINE__) ;
1119         if (error_function (data [0], orig [5 * channels], margin))
1120         {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_readf_short failed (%f should be %f).\n", __LINE__, data [0], orig [5 * channels]) ;
1121                 exit (1) ;
1122                 } ;
1123
1124         sf_close (file) ;
1125
1126         unlink (filename) ;
1127         printf ("ok\n") ;
1128 } /* lcomp_test_float */
1129
1130 /*--------------------------------------------------------------------------------------------
1131 */
1132
1133 static void
1134 lcomp_test_double (const char *filename, int filetype, int channels, double margin)
1135 {       SNDFILE                 *file ;
1136         SF_INFO                 sfinfo ;
1137         int                             k, m, seekpos ;
1138         sf_count_t              datalen ;
1139         double                  *orig, *data ;
1140         double                  half_max_abs ;
1141
1142         print_test_name ("lcomp_test_double", filename) ;
1143
1144         datalen = BUFFER_SIZE / channels ;
1145
1146         data = data_buffer.d ;
1147         orig = orig_buffer.d ;
1148
1149         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
1150         for (k = 0 ; k < channels * datalen ; k++)
1151                 orig [k] = orig_buffer.d [k] ;
1152
1153         sfinfo.samplerate       = SAMPLE_RATE ;
1154         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
1155         sfinfo.channels         = channels ;
1156         sfinfo.format           = filetype ;
1157
1158         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
1159         sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
1160         test_writef_double_or_die (file, 0, orig, datalen, __LINE__) ;
1161         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
1162         sf_close (file) ;
1163
1164         memset (data, 0, datalen * sizeof (double)) ;
1165
1166         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1167                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1168
1169         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
1170
1171         if ((sfinfo.format & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)) != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
1172         {       printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
1173                 exit (1) ;
1174                 } ;
1175
1176         if (sfinfo.frames < datalen / channels)
1177         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
1178                 exit (1) ;
1179                 } ;
1180
1181         if (sfinfo.frames > (datalen + datalen / 20))
1182         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
1183                 exit (1) ;
1184                 } ;
1185
1186         if (sfinfo.channels != channels)
1187         {       printf ("Incorrect number of channels in file.\n") ;
1188                 exit (1) ;
1189                 } ;
1190
1191         check_comment (file, filetype, __LINE__) ;
1192
1193         sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
1194
1195         check_log_buffer_or_die (file, __LINE__) ;
1196
1197         check_comment (file, filetype, __LINE__) ;
1198
1199         sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
1200
1201         test_readf_double_or_die (file, 0, data, datalen, __LINE__) ;
1202
1203         half_max_abs = 0.0 ;
1204         for (k = 0 ; k < datalen ; k++)
1205         {       if (error_function (data [k], orig [k], margin))
1206                 {       printf ("\nLine %d: Incorrect sample A (#%d : %f should be %f).\n", __LINE__, k, data [k], orig [k]) ;
1207                         oct_save_double (orig, data, datalen) ;
1208                         exit (1) ;
1209                         } ;
1210                 half_max_abs = LCT_MAX (half_max_abs, ABS (0.5 * data [k])) ;
1211                 } ;
1212
1213         if (half_max_abs < 1.0)
1214         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
1215                 exit (1) ;
1216                 } ;
1217
1218         if ((k = sf_readf_double (file, data, datalen)) != sfinfo.frames - datalen)
1219         {       printf ("\n\nLine %d: Incorrect read length (%" PRId64 " should be %d).\n", __LINE__,
1220                         channels * sfinfo.frames - datalen, k) ;
1221                 exit (1) ;
1222                 } ;
1223
1224         /*      This check is only for block based encoders which must append silence
1225         **      to the end of a file so as to fill out a block.
1226         */
1227         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM)
1228                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
1229                         if (ABS (data [channels * k]) > decay_response (channels * k))
1230                         {       printf ("\n\nLine %d : Incorrect sample B (#%d : abs (%f) should be < %d).\n", __LINE__, channels * k, data [channels * k], decay_response (channels * k)) ;
1231                                 exit (1) ;
1232                                 } ;
1233
1234         if (! sfinfo.seekable)
1235         {       sf_close (file) ;
1236                 unlink (filename) ;
1237                 printf ("ok\n") ;
1238                 return ;
1239                 } ;
1240
1241         /* Now test sf_seek function. */
1242
1243         if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
1244         {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
1245                 exit (1) ;
1246                 } ;
1247
1248         for (m = 0 ; m < 3 ; m++)
1249         {       test_readf_double_or_die (file, m, data, 11, __LINE__) ;
1250
1251                 for (k = 0 ; k < channels * 11 ; k++)
1252                         if (error_function (data [k], orig [k + channels * m * 11], margin))
1253                         {       printf ("\nLine %d: Incorrect sample (m = %d) (#%d : %f => %f).\n", __LINE__, m, k + channels * m * 11, orig [k + channels * m * 11], data [k]) ;
1254                                 for (m = 0 ; m < channels ; m++)
1255                                         printf ("%f ", data [m]) ;
1256                                 printf ("\n") ;
1257                                 exit (1) ;
1258                                 } ;
1259                 } ;
1260
1261         seekpos = BUFFER_SIZE / 10 ;
1262
1263         /* Check seek from start of file. */
1264         if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
1265         {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
1266                 exit (1) ;
1267                 } ;
1268
1269         test_readf_double_or_die (file, 0, data, 1, __LINE__) ;
1270
1271         if (error_function (data [0], orig [seekpos * channels], margin))
1272         {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_readf_double failed (%f, %f).\n", __LINE__, orig [1], data [0]) ;
1273                 exit (1) ;
1274                 } ;
1275
1276         if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
1277         {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
1278                 exit (1) ;
1279                 } ;
1280
1281         seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
1282         k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
1283         test_readf_double_or_die (file, 0, data, 1, __LINE__) ;
1284         if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
1285         {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_readf_double failed (%f, %f) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos + 1) ;
1286                 exit (1) ;
1287                 } ;
1288
1289         seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
1290         /* Check seek backward from current position. */
1291         k = sf_seek (file, -20, SEEK_CUR) ;
1292         test_readf_double_or_die (file, 0, data, 1, __LINE__) ;
1293         if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
1294         {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_readf_double failed (%f, %f) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos) ;
1295                 exit (1) ;
1296                 } ;
1297
1298         /* Check that read past end of file returns number of items. */
1299         sf_seek (file, sfinfo.frames, SEEK_SET) ;
1300
1301         if ((k = sf_readf_double (file, data, datalen)) != 0)
1302         {       printf ("\n\nLine %d: Return value from sf_readf_double past end of file incorrect (%d).\n", __LINE__, k) ;
1303                 exit (1) ;
1304                 } ;
1305
1306         /* Check seek backward from end. */
1307         if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
1308         {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
1309                 exit (1) ;
1310                 } ;
1311
1312         test_readf_double_or_die (file, 0, data, 1, __LINE__) ;
1313         if (error_function (data [0], orig [5 * channels], margin))
1314         {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_readf_short failed (%f should be %f).\n", __LINE__, data [0], orig [5 * channels]) ;
1315                 exit (1) ;
1316                 } ;
1317
1318         sf_close (file) ;
1319
1320         unlink (filename) ;
1321         printf ("ok\n") ;
1322 } /* lcomp_test_double */
1323
1324 /*========================================================================================
1325 **      Smoothed differential loss compression tests.
1326 */
1327
1328 static void
1329 sdlcomp_test_short      (const char *filename, int filetype, int channels, double margin)
1330 {       SNDFILE                 *file ;
1331         SF_INFO                 sfinfo ;
1332         int                             k, m, seekpos, half_max_abs ;
1333         sf_count_t              datalen ;
1334         short                   *orig, *data, *smooth ;
1335
1336 channels = 1 ;
1337         print_test_name ("sdlcomp_test_short", filename) ;
1338
1339         datalen = BUFFER_SIZE ;
1340
1341         orig = orig_buffer.s ;
1342         data = data_buffer.s ;
1343         smooth = smooth_buffer.s ;
1344
1345         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
1346         for (k = 0 ; k < datalen ; k++)
1347                 orig [k] = lrint (orig_buffer.d [k]) ;
1348
1349         sfinfo.samplerate       = SAMPLE_RATE ;
1350         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
1351         sfinfo.channels         = channels ;
1352         sfinfo.format           = filetype ;
1353
1354         /*      The Vorbis encoder has a bug on PowerPC and X86-64 with sample rates
1355         **      <= 22050. Increasing the sample rate to 32000 avoids triggering it.
1356         **      See https://trac.xiph.org/ticket/1229
1357         */
1358         if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
1359         {       const char * errstr ;
1360
1361                 errstr = sf_strerror (NULL) ;
1362                 if (strstr (errstr, "Sample rate chosen is known to trigger a Vorbis") == NULL)
1363                 {       printf ("Line %d: sf_open_fd (SFM_WRITE) failed : %s\n", __LINE__, errstr) ;
1364                         dump_log_buffer (NULL) ;
1365                         exit (1) ;
1366                         } ;
1367
1368                 printf ("\n                                  Sample rate -> 32kHz    ") ;
1369                 sfinfo.samplerate = 32000 ;
1370
1371                 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1372                 } ;
1373
1374         test_write_short_or_die (file, 0, orig, datalen, __LINE__) ;
1375         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
1376         sf_close (file) ;
1377
1378         memset (data, 0, datalen * sizeof (short)) ;
1379
1380         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1381                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1382
1383         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
1384
1385         if (sfinfo.format != filetype)
1386         {       printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
1387                 exit (1) ;
1388                 } ;
1389
1390         if (sfinfo.frames < datalen / channels)
1391         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
1392                 exit (1) ;
1393                 } ;
1394
1395         if (sfinfo.frames > (datalen + 400))
1396         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
1397                 exit (1) ;
1398                 } ;
1399
1400         if (sfinfo.channels != channels)
1401         {       printf ("Incorrect number of channels in file.\n") ;
1402                 exit (1) ;
1403                 } ;
1404
1405         check_comment (file, filetype, __LINE__) ;
1406
1407         sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1408
1409         check_log_buffer_or_die (file, __LINE__) ;
1410
1411         test_readf_short_or_die (file, 0, data, datalen, __LINE__) ;
1412
1413         memcpy (smooth, orig, datalen * sizeof (short)) ;
1414         smoothed_diff_short (data, datalen) ;
1415         smoothed_diff_short (smooth, datalen) ;
1416
1417         half_max_abs = 0.0 ;
1418         for (k = 0 ; k < datalen ; k++)
1419         {       if (error_function (1.0 * data [k], 1.0 * smooth [k], margin))
1420                 {       printf ("\nLine %d: Incorrect sample (#%d : %d should be %d).\n", __LINE__, k, data [k], smooth [k]) ;
1421                         oct_save_short (orig, smooth, datalen) ;
1422                         exit (1) ;
1423                         } ;
1424                 half_max_abs = LCT_MAX (half_max_abs, ABS (0.5 * data [k])) ;
1425                 } ;
1426
1427         if (half_max_abs < 1)
1428         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
1429                 exit (1) ;
1430                 } ;
1431
1432         if ((k = sf_read_short (file, data, datalen)) != sfinfo.frames - datalen)
1433         {       printf ("\n\nLine %d: Incorrect read length (%d should be %" PRId64 ").\n", __LINE__, k, sfinfo.frames - datalen) ;
1434                 exit (1) ;
1435                 } ;
1436
1437         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
1438                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610)
1439                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
1440                         if (ABS (data [k]) > decay_response (k))
1441                         {       printf ("\n\nLine %d: Incorrect sample (#%" PRId64 " : abs (%d) should be < %d).\n", __LINE__, datalen + k, data [k], decay_response (k)) ;
1442                                 exit (1) ;
1443                                 } ;
1444
1445         /* Now test sf_seek function. */
1446         if (sfinfo.seekable)
1447         {       if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
1448                 {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
1449                         exit (1) ;
1450                         } ;
1451
1452                 for (m = 0 ; m < 3 ; m++)
1453                 {       test_readf_short_or_die (file, m, data, datalen / 7, __LINE__) ;
1454
1455                         smoothed_diff_short (data, datalen / 7) ;
1456                         memcpy (smooth, orig + m * datalen / 7, datalen / 7 * sizeof (short)) ;
1457                         smoothed_diff_short (smooth, datalen / 7) ;
1458
1459                         for (k = 0 ; k < datalen / 7 ; k++)
1460                                 if (error_function (1.0 * data [k], 1.0 * smooth [k], margin))
1461                                 {       printf ("\nLine %d: Incorrect sample C (#%d (%" PRId64 ") : %d => %d).\n", __LINE__, k, k + m * (datalen / 7), smooth [k], data [k]) ;
1462                                         for (m = 0 ; m < 10 ; m++)
1463                                                 printf ("%d ", data [k]) ;
1464                                         printf ("\n") ;
1465                                         exit (1) ;
1466                                         } ;
1467                         } ; /* for (m = 0 ; m < 3 ; m++) */
1468
1469                 seekpos = BUFFER_SIZE / 10 ;
1470
1471                 /* Check seek from start of file. */
1472                 if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
1473                 {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
1474                         exit (1) ;
1475                         } ;
1476                 test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
1477
1478                 if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin))
1479                 {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_read_short failed (%d, %d).\n", __LINE__, orig [1], data [0]) ;
1480                         exit (1) ;
1481                         } ;
1482
1483                 if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
1484                 {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
1485                         exit (1) ;
1486                         } ;
1487
1488                 seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
1489                 k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
1490                 test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
1491                 if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
1492                 {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_read_short failed (%d, %d) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos + 1) ;
1493                         exit (1) ;
1494                         } ;
1495
1496                 seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
1497                 /* Check seek backward from current position. */
1498                 k = sf_seek (file, -20, SEEK_CUR) ;
1499                 test_readf_short_or_die (file, 0, data, 1, __LINE__) ;
1500                 if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
1501                 {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_read_short failed (%d, %d) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos) ;
1502                         exit (1) ;
1503                         } ;
1504
1505                 /* Check that read past end of file returns number of items. */
1506                 sf_seek (file, sfinfo.frames, SEEK_SET) ;
1507
1508                 if ((k = sf_read_short (file, data, datalen)) != 0)
1509                 {       printf ("\n\nLine %d: Return value from sf_read_short past end of file incorrect (%d).\n", __LINE__, k) ;
1510                         exit (1) ;
1511                         } ;
1512
1513                 /* Check seek backward from end. */
1514
1515                 if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
1516                 {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
1517                         exit (1) ;
1518                         } ;
1519
1520                 test_read_short_or_die (file, 0, data, channels, __LINE__) ;
1521                 if (error_function (1.0 * data [0], 1.0 * orig [5 * channels], margin))
1522                 {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_read_short failed (%d should be %d).\n", __LINE__, data [0], orig [5 * channels]) ;
1523                         exit (1) ;
1524                         } ;
1525                 } /* if (sfinfo.seekable) */
1526
1527         sf_close (file) ;
1528
1529         unlink (filename) ;
1530         printf ("ok\n") ;
1531 } /* sdlcomp_test_short */
1532
1533 static  void
1534 sdlcomp_test_int        (const char *filename, int filetype, int channels, double margin)
1535 {       SNDFILE                 *file ;
1536         SF_INFO                 sfinfo ;
1537         int                             k, m, seekpos, half_max_abs ;
1538         sf_count_t              datalen ;
1539         int                             *orig, *data, *smooth ;
1540         double                  scale ;
1541
1542 channels = 1 ;
1543
1544         print_test_name ("sdlcomp_test_int", filename) ;
1545
1546         datalen = BUFFER_SIZE ;
1547         scale = 1.0 * 0x10000 ;
1548
1549         orig = orig_buffer.i ;
1550         data = data_buffer.i ;
1551         smooth = smooth_buffer.i ;
1552
1553         gen_signal_double (orig_buffer.d, 32000.0 * scale, channels, datalen) ;
1554         for (k = 0 ; k < datalen ; k++)
1555                 orig [k] = lrint (orig_buffer.d [k]) ;
1556
1557         sfinfo.samplerate       = SAMPLE_RATE ;
1558         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
1559         sfinfo.channels         = channels ;
1560         sfinfo.format           = filetype ;
1561
1562         /*      The Vorbis encoder has a bug on PowerPC and X86-64 with sample rates
1563         **      <= 22050. Increasing the sample rate to 32000 avoids triggering it.
1564         **      See https://trac.xiph.org/ticket/1229
1565         */
1566         if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
1567         {       const char * errstr ;
1568
1569                 errstr = sf_strerror (NULL) ;
1570                 if (strstr (errstr, "Sample rate chosen is known to trigger a Vorbis") == NULL)
1571                 {       printf ("Line %d: sf_open_fd (SFM_WRITE) failed : %s\n", __LINE__, errstr) ;
1572                         dump_log_buffer (NULL) ;
1573                         exit (1) ;
1574                         } ;
1575
1576                 printf ("\n                                  Sample rate -> 32kHz    ") ;
1577                 sfinfo.samplerate = 32000 ;
1578
1579                 file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
1580                 } ;
1581
1582         test_writef_int_or_die (file, 0, orig, datalen, __LINE__) ;
1583         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
1584         sf_close (file) ;
1585
1586         memset (data, 0, datalen * sizeof (int)) ;
1587
1588         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1589                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1590
1591         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
1592
1593         if (sfinfo.format != filetype)
1594         {       printf ("Returned format incorrect (0x%08X => 0x%08X).\n", filetype, sfinfo.format) ;
1595                 exit (1) ;
1596                 } ;
1597
1598         if (sfinfo.frames < datalen / channels)
1599         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
1600                 exit (1) ;
1601                 } ;
1602
1603         if (sfinfo.frames > (datalen + 400))
1604         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
1605                 exit (1) ;
1606                 } ;
1607
1608         if (sfinfo.channels != channels)
1609         {       printf ("Incorrect number of channels in file.\n") ;
1610                 exit (1) ;
1611                 } ;
1612
1613         check_log_buffer_or_die (file, __LINE__) ;
1614
1615         test_readf_int_or_die (file, 0, data, datalen, __LINE__) ;
1616
1617         memcpy (smooth, orig, datalen * sizeof (int)) ;
1618         smoothed_diff_int (data, datalen) ;
1619         smoothed_diff_int (smooth, datalen) ;
1620
1621         half_max_abs = abs (data [0] >> 16) ;
1622         for (k = 1 ; k < datalen ; k++)
1623         {       if (error_function (data [k] / scale, smooth [k] / scale, margin))
1624                 {       printf ("\nLine %d: Incorrect sample (#%d : %d should be %d).\n", __LINE__, k, data [k], smooth [k]) ;
1625                         oct_save_int (orig, smooth, datalen) ;
1626                         exit (1) ;
1627                         } ;
1628                 half_max_abs = LCT_MAX (half_max_abs, abs (data [k] / 2)) ;
1629                 } ;
1630
1631         if (half_max_abs < 1)
1632         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
1633                 exit (1) ;
1634                 } ;
1635
1636         if ((k = sf_readf_int (file, data, datalen)) != sfinfo.frames - datalen)
1637         {       printf ("\n\nLine %d: Incorrect read length (%d should be %" PRId64 ").\n", __LINE__, k, sfinfo.frames - datalen) ;
1638                 exit (1) ;
1639                 } ;
1640
1641         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_IMA_ADPCM &&
1642                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
1643                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610 &&
1644                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_G721_32 &&
1645                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_G723_24)
1646                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
1647                         if (abs (data [k]) > decay_response (k))
1648                         {       printf ("\n\nLine %d: Incorrect sample (#%" PRId64 " : abs (%d) should be < %d).\n", __LINE__, datalen + k, data [k], decay_response (k)) ;
1649                                 exit (1) ;
1650                                 } ;
1651
1652         /* Now test sf_seek function. */
1653         if (sfinfo.seekable)
1654         {       if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
1655                 {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
1656                         exit (1) ;
1657                         } ;
1658
1659                 for (m = 0 ; m < 3 ; m++)
1660                 {       test_readf_int_or_die (file, m, data, datalen / 7, __LINE__) ;
1661
1662                         smoothed_diff_int (data, datalen / 7) ;
1663                         memcpy (smooth, orig + m * datalen / 7, datalen / 7 * sizeof (int)) ;
1664                         smoothed_diff_int (smooth, datalen / 7) ;
1665
1666                         for (k = 0 ; k < datalen / 7 ; k++)
1667                                 if (error_function (data [k] / scale, smooth [k] / scale, margin))
1668                                 {       printf ("\nLine %d: Incorrect sample (#%d (%" PRId64 ") : %d => %d).\n", __LINE__, k, k + m * (datalen / 7), smooth [k], data [k]) ;
1669                                         for (m = 0 ; m < 10 ; m++)
1670                                                 printf ("%d ", data [k]) ;
1671                                         printf ("\n") ;
1672                                         exit (1) ;
1673                                         } ;
1674                         } ; /* for (m = 0 ; m < 3 ; m++) */
1675
1676                 seekpos = BUFFER_SIZE / 10 ;
1677
1678                 /* Check seek from start of file. */
1679                 if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
1680                 {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
1681                         exit (1) ;
1682                         } ;
1683                 test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
1684
1685                 if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin))
1686                 {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_readf_int failed (%d, %d).\n", __LINE__, orig [1], data [0]) ;
1687                         exit (1) ;
1688                         } ;
1689
1690                 if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
1691                 {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
1692                         exit (1) ;
1693                         } ;
1694
1695                 seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
1696                 k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
1697                 test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
1698                 if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
1699                 {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_readf_int failed (%d, %d) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos + 1) ;
1700                         exit (1) ;
1701                         } ;
1702
1703                 seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
1704                 /* Check seek backward from current position. */
1705                 k = sf_seek (file, -20, SEEK_CUR) ;
1706                 test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
1707                 if (error_function (1.0 * data [0], 1.0 * orig [seekpos * channels], margin) || k != seekpos)
1708                 {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_readf_int failed (%d, %d) (%d, %d).\n", __LINE__, data [0], orig [seekpos * channels], k, seekpos) ;
1709                         exit (1) ;
1710                         } ;
1711
1712                 /* Check that read past end of file returns number of items. */
1713                 sf_seek (file, sfinfo.frames, SEEK_SET) ;
1714
1715                 if ((k = sf_readf_int (file, data, datalen)) != 0)
1716                 {       printf ("\n\nLine %d: Return value from sf_readf_int past end of file incorrect (%d).\n", __LINE__, k) ;
1717                         exit (1) ;
1718                         } ;
1719
1720                 /* Check seek backward from end. */
1721
1722                 if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
1723                 {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
1724                         exit (1) ;
1725                         } ;
1726
1727                 test_readf_int_or_die (file, 0, data, 1, __LINE__) ;
1728                 if (error_function (data [0] / scale, orig [5] / scale, margin))
1729                 {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_readf_int failed (%d should be %d).\n", __LINE__, data [0], orig [5]) ;
1730                         exit (1) ;
1731                         } ;
1732                 } /* if (sfinfo.seekable) */
1733
1734         sf_close (file) ;
1735
1736         unlink (filename) ;
1737         printf ("ok\n") ;
1738 } /* sdlcomp_test_int */
1739
1740 static void
1741 sdlcomp_test_float      (const char *filename, int filetype, int channels, double margin)
1742 {       SNDFILE                 *file ;
1743         SF_INFO                 sfinfo ;
1744         int                             k, m, seekpos ;
1745         sf_count_t              datalen ;
1746         float                   *orig, *data, *smooth ;
1747         double                  half_max_abs ;
1748
1749 channels = 1 ;
1750
1751         print_test_name ("sdlcomp_test_float", filename) ;
1752
1753         if ((filetype & SF_FORMAT_SUBMASK) == SF_FORMAT_VORBIS)
1754         {       puts ("Not working for this format.") ;
1755                 return ;
1756                 } ;
1757
1758 printf ("** fix this ** ") ;
1759
1760         datalen = BUFFER_SIZE ;
1761
1762         orig = orig_buffer.f ;
1763         data = data_buffer.f ;
1764         smooth = smooth_buffer.f ;
1765
1766         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
1767         for (k = 0 ; k < datalen ; k++)
1768                 orig [k] = lrint (orig_buffer.d [k]) ;
1769
1770         sfinfo.samplerate       = SAMPLE_RATE ;
1771         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
1772         sfinfo.channels         = channels ;
1773         sfinfo.format           = filetype ;
1774
1775         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
1776         sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1777         test_write_float_or_die (file, 0, orig, datalen, __LINE__) ;
1778         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
1779         sf_close (file) ;
1780
1781         memset (data, 0, datalen * sizeof (float)) ;
1782
1783         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1784                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1785
1786         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
1787
1788         if ((sfinfo.format & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)) != (filetype & (SF_FORMAT_TYPEMASK | SF_FORMAT_SUBMASK)))
1789         {       printf ("\n\nLine %d: Returned format incorrect (0x%08X => 0x%08X).\n", __LINE__, filetype, sfinfo.format) ;
1790                 exit (1) ;
1791                 } ;
1792
1793         if (sfinfo.frames < datalen / channels)
1794         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
1795                 exit (1) ;
1796                 } ;
1797
1798         if (sfinfo.frames > (datalen + 400))
1799         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
1800                 exit (1) ;
1801                 } ;
1802
1803         if (sfinfo.channels != channels)
1804         {       printf ("Incorrect number of channels in file.\n") ;
1805                 exit (1) ;
1806                 } ;
1807
1808         check_comment (file, filetype, __LINE__) ;
1809
1810         sf_command (file, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
1811
1812         check_log_buffer_or_die (file, __LINE__) ;
1813
1814         test_read_float_or_die (file, 0, data, datalen, __LINE__) ;
1815
1816         memcpy (smooth, orig, datalen * sizeof (float)) ;
1817         smoothed_diff_float (data, datalen) ;
1818         smoothed_diff_float (smooth, datalen) ;
1819
1820         half_max_abs = fabs (data [0]) ;
1821         for (k = 1 ; k < datalen ; k++)
1822         {       if (error_function (data [k], smooth [k], margin))
1823                 {       printf ("\nLine %d: Incorrect sample (#%d : %d should be %d).\n", __LINE__, k, (int) data [k], (int) smooth [k]) ;
1824                         oct_save_float (orig, smooth, datalen) ;
1825                         exit (1) ;
1826                         } ;
1827                 half_max_abs = LCT_MAX (half_max_abs, ABS (0.5 * data [k])) ;
1828                 } ;
1829
1830         if (half_max_abs <= 0.0)
1831         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
1832                 printf ("half_max_abs : % 10.6f\n", half_max_abs) ;
1833                 exit (1) ;
1834                 } ;
1835
1836         if ((k = sf_read_float (file, data, datalen)) != sfinfo.frames - datalen)
1837         {       printf ("\n\nLine %d: Incorrect read length (%d should be %" PRId64 ").\n", __LINE__, k, sfinfo.frames - datalen) ;
1838                 exit (1) ;
1839                 } ;
1840
1841         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
1842                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610)
1843                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
1844                         if (ABS (data [k]) > decay_response (k))
1845                         {       printf ("\n\nLine %d: Incorrect sample (#%" PRId64 " : abs (%d) should be < %d).\n", __LINE__, datalen + k, (int) data [k], (int) decay_response (k)) ;
1846                                 exit (1) ;
1847                                 } ;
1848
1849         /* Now test sf_seek function. */
1850         if (sfinfo.seekable)
1851         {       if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
1852                 {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
1853                         exit (1) ;
1854                         } ;
1855
1856                 for (m = 0 ; m < 3 ; m++)
1857                 {       test_read_float_or_die (file, 0, data, datalen / 7, __LINE__) ;
1858
1859                         smoothed_diff_float (data, datalen / 7) ;
1860                         memcpy (smooth, orig + m * datalen / 7, datalen / 7 * sizeof (float)) ;
1861                         smoothed_diff_float (smooth, datalen / 7) ;
1862
1863                         for (k = 0 ; k < datalen / 7 ; k++)
1864                                 if (error_function (data [k], smooth [k], margin))
1865                                 {       printf ("\nLine %d: Incorrect sample C (#%d (%" PRId64 ") : %d => %d).\n", __LINE__, k, k + m * (datalen / 7), (int) smooth [k], (int) data [k]) ;
1866                                         for (m = 0 ; m < 10 ; m++)
1867                                                 printf ("%d ", (int) data [k]) ;
1868                                         printf ("\n") ;
1869                                         exit (1) ;
1870                                         } ;
1871                         } ; /* for (m = 0 ; m < 3 ; m++) */
1872
1873                 seekpos = BUFFER_SIZE / 10 ;
1874
1875                 /* Check seek from start of file. */
1876                 if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
1877                 {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
1878                         exit (1) ;
1879                         } ;
1880                 test_read_float_or_die (file, 0, data, channels, __LINE__) ;
1881
1882                 if (error_function (data [0], orig [seekpos * channels], margin))
1883                 {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_read_float failed (%d, %d).\n", __LINE__, (int) orig [1], (int) data [0]) ;
1884                         exit (1) ;
1885                         } ;
1886
1887                 if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
1888                 {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
1889                         exit (1) ;
1890                         } ;
1891
1892                 seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
1893                 k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
1894                 test_read_float_or_die (file, 0, data, channels, __LINE__) ;
1895                 if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
1896                 {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_read_float failed (%d, %d) (%d, %d).\n", __LINE__, (int) data [0], (int) orig [seekpos * channels], k, seekpos + 1) ;
1897                         exit (1) ;
1898                         } ;
1899
1900                 seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
1901                 /* Check seek backward from current position. */
1902                 k = sf_seek (file, -20, SEEK_CUR) ;
1903                 test_read_float_or_die (file, 0, data, channels, __LINE__) ;
1904                 if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
1905                 {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_read_float failed (%d, %d) (%d, %d).\n", __LINE__, (int) data [0], (int) orig [seekpos * channels], k, seekpos) ;
1906                         exit (1) ;
1907                         } ;
1908
1909                 /* Check that read past end of file returns number of items. */
1910                 sf_seek (file, sfinfo.frames, SEEK_SET) ;
1911
1912                 if ((k = sf_read_float (file, data, datalen)) != 0)
1913                 {       printf ("\n\nLine %d: Return value from sf_read_float past end of file incorrect (%d).\n", __LINE__, k) ;
1914                         exit (1) ;
1915                         } ;
1916
1917                 /* Check seek backward from end. */
1918
1919                 if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
1920                 {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
1921                         exit (1) ;
1922                         } ;
1923
1924                 test_read_float_or_die (file, 0, data, channels, __LINE__) ;
1925                 if (error_function (data [0], orig [5 * channels], margin))
1926                 {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_read_float failed (%f should be %f).\n", __LINE__, data [0], orig [5 * channels]) ;
1927                         exit (1) ;
1928                         } ;
1929                 } /* if (sfinfo.seekable) */
1930
1931         sf_close (file) ;
1932
1933         unlink (filename) ;
1934         printf ("ok\n") ;
1935 } /* sdlcomp_test_float */
1936
1937 static void
1938 sdlcomp_test_double     (const char *filename, int filetype, int channels, double margin)
1939 {       SNDFILE                 *file ;
1940         SF_INFO                 sfinfo ;
1941         int                             k, m, seekpos ;
1942         sf_count_t              datalen ;
1943         double                  *orig, *data, *smooth, half_max_abs ;
1944
1945 channels = 1 ;
1946         print_test_name ("sdlcomp_test_double", filename) ;
1947
1948         if ((filetype & SF_FORMAT_SUBMASK) == SF_FORMAT_VORBIS)
1949         {       puts ("Not working for this format.") ;
1950                 return ;
1951                 } ;
1952
1953         datalen = BUFFER_SIZE ;
1954
1955         orig = orig_buffer.d ;
1956         data = data_buffer.d ;
1957         smooth = smooth_buffer.d ;
1958
1959         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
1960
1961         sfinfo.samplerate       = SAMPLE_RATE ;
1962         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
1963         sfinfo.channels         = channels ;
1964         sfinfo.format           = filetype ;
1965
1966         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
1967         sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
1968         test_write_double_or_die (file, 0, orig, datalen, __LINE__) ;
1969         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
1970         sf_close (file) ;
1971
1972         memset (data, 0, datalen * sizeof (double)) ;
1973
1974         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1975                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
1976
1977         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
1978
1979         if (sfinfo.format != filetype)
1980         {       printf ("Returned format incorrect (0x%08X => 0x%08X).\n", filetype, sfinfo.format) ;
1981                 exit (1) ;
1982                 } ;
1983
1984         if (sfinfo.frames < datalen / channels)
1985         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
1986                 exit (1) ;
1987                 } ;
1988
1989         if (sfinfo.frames > (datalen + 400))
1990         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
1991                 exit (1) ;
1992                 } ;
1993
1994         if (sfinfo.channels != channels)
1995         {       printf ("Incorrect number of channels in file.\n") ;
1996                 exit (1) ;
1997                 } ;
1998
1999         check_comment (file, filetype, __LINE__) ;
2000
2001         check_comment (file, filetype, __LINE__) ;
2002
2003         sf_command (file, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
2004
2005         check_log_buffer_or_die (file, __LINE__) ;
2006
2007         test_read_double_or_die (file, 0, data, datalen, __LINE__) ;
2008
2009         memcpy (smooth, orig, datalen * sizeof (double)) ;
2010         smoothed_diff_double (data, datalen) ;
2011         smoothed_diff_double (smooth, datalen) ;
2012
2013         half_max_abs = 0.0 ;
2014         for (k = 0 ; k < datalen ; k++)
2015         {       if (error_function (data [k], smooth [k], margin))
2016                 {       printf ("\n\nLine %d: Incorrect sample (#%d : %d should be %d).\n", __LINE__, k, (int) data [k], (int) smooth [k]) ;
2017                         oct_save_double (orig, smooth, datalen) ;
2018                         exit (1) ;
2019                         } ;
2020                 half_max_abs = LCT_MAX (half_max_abs, 0.5 * fabs (data [k])) ;
2021                 } ;
2022
2023         if (half_max_abs < 1.0)
2024         {       printf ("\n\nLine %d: Signal is all zeros.\n", __LINE__) ;
2025                 exit (1) ;
2026                 } ;
2027
2028         if ((k = sf_read_double (file, data, datalen)) != sfinfo.frames - datalen)
2029         {       printf ("\n\nLine %d: Incorrect read length (%d should be %" PRId64 ").\n", __LINE__, k, sfinfo.frames - datalen) ;
2030                 exit (1) ;
2031                 } ;
2032
2033         if ((sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_MS_ADPCM &&
2034                 (sfinfo.format & SF_FORMAT_SUBMASK) != SF_FORMAT_GSM610)
2035                 for (k = 0 ; k < sfinfo.frames - datalen ; k++)
2036                         if (ABS (data [k]) > decay_response (k))
2037                         {       printf ("\n\nLine %d: Incorrect sample (#%" PRId64 " : abs (%d) should be < %d).\n", __LINE__, datalen + k, (int) data [k], (int) decay_response (k)) ;
2038                                 exit (1) ;
2039                                 } ;
2040
2041         /* Now test sf_seek function. */
2042         if (sfinfo.seekable)
2043         {       if ((k = sf_seek (file, 0, SEEK_SET)) != 0)
2044                 {       printf ("\n\nLine %d: Seek to start of file failed (%d).\n", __LINE__, k) ;
2045                         exit (1) ;
2046                         } ;
2047
2048                 for (m = 0 ; m < 3 ; m++)
2049                 {       test_read_double_or_die (file, m, data, datalen / 7, __LINE__) ;
2050
2051                         smoothed_diff_double (data, datalen / 7) ;
2052                         memcpy (smooth, orig + m * datalen / 7, datalen / 7 * sizeof (double)) ;
2053                         smoothed_diff_double (smooth, datalen / 7) ;
2054
2055                         for (k = 0 ; k < datalen / 7 ; k++)
2056                                 if (error_function (data [k], smooth [k], margin))
2057                                 {       printf ("\nLine %d: Incorrect sample C (#%d (%" PRId64 ") : %d => %d).\n", __LINE__, k, k + m * (datalen / 7), (int) smooth [k], (int) data [k]) ;
2058                                         for (m = 0 ; m < 10 ; m++)
2059                                                 printf ("%d ", (int) data [k]) ;
2060                                         printf ("\n") ;
2061                                         exit (1) ;
2062                                         } ;
2063                         } ; /* for (m = 0 ; m < 3 ; m++) */
2064
2065                 seekpos = BUFFER_SIZE / 10 ;
2066
2067                 /* Check seek from start of file. */
2068                 if ((k = sf_seek (file, seekpos, SEEK_SET)) != seekpos)
2069                 {       printf ("Seek to start of file + %d failed (%d).\n", seekpos, k) ;
2070                         exit (1) ;
2071                         } ;
2072                 test_read_double_or_die (file, 0, data, channels, __LINE__) ;
2073
2074                 if (error_function (data [0], orig [seekpos * channels], margin))
2075                 {       printf ("\nLine %d: sf_seek (SEEK_SET) followed by sf_read_double failed (%d, %d).\n", __LINE__, (int) orig [1], (int) data [0]) ;
2076                         exit (1) ;
2077                         } ;
2078
2079                 if ((k = sf_seek (file, 0, SEEK_CUR)) != seekpos + 1)
2080                 {       printf ("\n\nLine %d: sf_seek (SEEK_CUR) with 0 offset failed (%d should be %d)\n", __LINE__, k, seekpos + 1) ;
2081                         exit (1) ;
2082                         } ;
2083
2084                 seekpos = sf_seek (file, 0, SEEK_CUR) + BUFFER_SIZE / 5 ;
2085                 k = sf_seek (file, BUFFER_SIZE / 5, SEEK_CUR) ;
2086                 test_read_double_or_die (file, 0, data, channels, __LINE__) ;
2087                 if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
2088                 {       printf ("\nLine %d: sf_seek (forwards, SEEK_CUR) followed by sf_read_double failed (%d, %d) (%d, %d).\n", __LINE__, (int) data [0], (int) orig [seekpos * channels], k, seekpos + 1) ;
2089                         exit (1) ;
2090                         } ;
2091
2092                 seekpos = sf_seek (file, 0, SEEK_CUR) - 20 ;
2093                 /* Check seek backward from current position. */
2094                 k = sf_seek (file, -20, SEEK_CUR) ;
2095                 test_read_double_or_die (file, 0, data, channels, __LINE__) ;
2096                 if (error_function (data [0], orig [seekpos * channels], margin) || k != seekpos)
2097                 {       printf ("\nLine %d: sf_seek (backwards, SEEK_CUR) followed by sf_read_double failed (%d, %d) (%d, %d).\n", __LINE__, (int) data [0], (int) orig [seekpos * channels], k, seekpos) ;
2098                         exit (1) ;
2099                         } ;
2100
2101                 /* Check that read past end of file returns number of items. */
2102                 sf_seek (file, sfinfo.frames, SEEK_SET) ;
2103
2104                 if ((k = sf_read_double (file, data, datalen)) != 0)
2105                 {       printf ("\n\nLine %d: Return value from sf_read_double past end of file incorrect (%d).\n", __LINE__, k) ;
2106                         exit (1) ;
2107                         } ;
2108
2109                 /* Check seek backward from end. */
2110
2111                 if ((k = sf_seek (file, 5 - sfinfo.frames, SEEK_END)) != 5)
2112                 {       printf ("\n\nLine %d: sf_seek (SEEK_END) returned %d instead of %d.\n", __LINE__, k, 5) ;
2113                         exit (1) ;
2114                         } ;
2115
2116                 test_read_double_or_die (file, 0, data, channels, __LINE__) ;
2117                 if (error_function (data [0], orig [5 * channels], margin))
2118                 {       printf ("\nLine %d: sf_seek (SEEK_END) followed by sf_read_double failed (%f should be %f).\n", __LINE__, data [0], orig [5 * channels]) ;
2119                         exit (1) ;
2120                         } ;
2121                 } /* if (sfinfo.seekable) */
2122
2123         sf_close (file) ;
2124
2125         unlink (filename) ;
2126         printf ("ok\n") ;
2127 } /* sdlcomp_test_double */
2128
2129 static void
2130 read_raw_test (const char *filename, int filetype, int channels)
2131 {       SNDFILE                 *file ;
2132         SF_INFO                 sfinfo ;
2133         sf_count_t              count, datalen ;
2134         short                   *orig, *data ;
2135         int                             k ;
2136
2137         print_test_name ("read_raw_test", filename) ;
2138
2139         datalen = ARRAY_LEN (orig_buffer.s) / 2 ;
2140
2141         orig = orig_buffer.s ;
2142         data = data_buffer.s ;
2143
2144         gen_signal_double (orig_buffer.d, 32000.0, channels, datalen) ;
2145         for (k = 0 ; k < datalen ; k++)
2146                 orig [k] = lrint (orig_buffer.d [k]) ;
2147
2148         sfinfo.samplerate       = SAMPLE_RATE ;
2149         sfinfo.frames           = 123456789 ;   /* Ridiculous value. */
2150         sfinfo.channels         = channels ;
2151         sfinfo.format           = filetype ;
2152
2153         file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_FALSE, __LINE__) ;
2154         test_write_short_or_die (file, 0, orig, datalen, __LINE__) ;
2155         sf_set_string (file, SF_STR_COMMENT, long_comment) ;
2156         sf_close (file) ;
2157
2158         memset (data, 0, datalen * sizeof (double)) ;
2159
2160         if ((filetype & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
2161                 memset (&sfinfo, 0, sizeof (sfinfo)) ;
2162
2163         file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
2164
2165         if (sfinfo.format != filetype)
2166         {       printf ("Returned format incorrect (0x%08X => 0x%08X).\n", filetype, sfinfo.format) ;
2167                 exit (1) ;
2168                 } ;
2169
2170         if (sfinfo.frames < datalen / channels)
2171         {       printf ("Too few.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", datalen, sfinfo.frames) ;
2172                 exit (1) ;
2173                 } ;
2174
2175         if (sfinfo.frames > (datalen + 400))
2176         {       printf ("Too many.frames in file. (%" PRId64 " should be a little more than %" PRId64 ")\n", sfinfo.frames, datalen) ;
2177                 exit (1) ;
2178                 } ;
2179
2180         if (sfinfo.channels != channels)
2181         {       printf ("Incorrect number of channels in file.\n") ;
2182                 exit (1) ;
2183                 } ;
2184
2185         check_comment (file, filetype, __LINE__) ;
2186
2187         count = sf_read_raw (file, orig_buffer.c, datalen + 5 * channels) ;
2188         if (count != sfinfo.channels * sfinfo.frames)
2189         {       printf ("\nLine %d : sf_read_raw returned %" PRId64 " should be %" PRId64 "\n", __LINE__, count, sfinfo.channels * sfinfo.frames) ;
2190                 exit (1) ;
2191                 } ;
2192
2193         sf_close (file) ;
2194
2195         unlink (filename) ;
2196         printf ("ok\n") ;
2197 } /* read_raw_test */
2198
2199 /*========================================================================================
2200 **      Auxiliary functions
2201 */
2202
2203 #define         SIGNAL_MAXVAL   30000.0
2204 #define         DECAY_COUNT             1000
2205
2206 static int
2207 decay_response (int k)
2208 {       if (k < 1)
2209                 return (int) (1.2 * SIGNAL_MAXVAL) ;
2210         if (k > DECAY_COUNT)
2211                 return 0 ;
2212         return (int) (1.2 * SIGNAL_MAXVAL * (DECAY_COUNT - k) / (1.0 * DECAY_COUNT)) ;
2213 } /* decay_response */
2214
2215 static void
2216 gen_signal_double (double *data, double scale, int channels, int datalen)
2217 {       int             k, ramplen ;
2218         double  amp = 0.0 ;
2219
2220         ramplen = DECAY_COUNT ;
2221
2222         if (channels == 1)
2223         {       for (k = 0 ; k < datalen ; k++)
2224                 {       if (k <= ramplen)
2225                                 amp = scale * k / ((double) ramplen) ;
2226                         else if (k > datalen - ramplen)
2227                                 amp = scale * (datalen - k) / ((double) ramplen) ;
2228
2229 /*-printf ("%3d : %g\n", k, amp) ;-*/
2230
2231                         data [k] = amp * (0.4 * sin (33.3 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))
2232                                                         + 0.3 * cos (201.1 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))) ;
2233                         } ;
2234                 }
2235         else
2236         {       for (k = 0 ; k < datalen ; k ++)
2237                 {       if (k <= ramplen)
2238                                 amp = scale * k / ((double) ramplen) ;
2239                         else if (k > datalen - ramplen)
2240                                 amp = scale * (datalen - k) / ((double) ramplen) ;
2241
2242                         data [2 * k] = amp * (0.4 * sin (33.3 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))
2243                                                         + 0.3 * cos (201.1 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))) ;
2244                         data [2 * k + 1] = amp * (0.4 * sin (55.5 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))
2245                                                         + 0.3 * cos (201.1 * 2.0 * M_PI * ((double) (k+1)) / ((double) SAMPLE_RATE))) ;
2246                         } ;
2247                 } ;
2248
2249         return ;
2250 } /* gen_signal_double */
2251
2252 static int
2253 error_function (double data, double orig, double margin)
2254 {       double error ;
2255
2256         if (fabs (orig) <= 500.0)
2257                 error = fabs (fabs (data) - fabs (orig)) / 2000.0 ;
2258         else if (fabs (orig) <= 1000.0)
2259                 error = fabs (data - orig) / 3000.0 ;
2260         else
2261                 error = fabs (data - orig) / fabs (orig) ;
2262
2263         if (error > margin)
2264         {       printf ("\n\nerror_function (data = %f, orig = %f, margin = %f) -> %f\n", data, orig, margin, error) ;
2265                 return 1 ;
2266                 } ;
2267         return 0 ;
2268 } /* error_function */
2269
2270 static void
2271 smoothed_diff_short (short *data, unsigned int datalen)
2272 {       unsigned int k ;
2273         double memory = 0.0 ;
2274
2275         /* Calculate the smoothed sample-to-sample difference. */
2276         for (k = 0 ; k < datalen - 1 ; k++)
2277         {       memory = 0.7 * memory + (1 - 0.7) * (double) (data [k+1] - data [k]) ;
2278                 data [k] = (short) memory ;
2279                 } ;
2280         data [datalen-1] = data [datalen-2] ;
2281
2282 } /* smoothed_diff_short */
2283
2284 static void
2285 smoothed_diff_int (int *data, unsigned int datalen)
2286 {       unsigned int k ;
2287         double memory = 0.0 ;
2288
2289         /* Calculate the smoothed sample-to-sample difference. */
2290         for (k = 0 ; k < datalen - 1 ; k++)
2291         {       memory = 0.7 * memory + (1 - 0.7) * (double) (data [k+1] - data [k]) ;
2292                 data [k] = (int) memory ;
2293                 } ;
2294         data [datalen-1] = data [datalen-2] ;
2295
2296 } /* smoothed_diff_int */
2297
2298 static  void
2299 smoothed_diff_float (float *data, unsigned int datalen)
2300 {       unsigned int k ;
2301         float memory = 0.0 ;
2302
2303         /* Calculate the smoothed sample-to-sample difference. */
2304         for (k = 0 ; k < datalen - 1 ; k++)
2305         {       memory = 0.7 * memory + (1 - 0.7) * (data [k+1] - data [k]) ;
2306                 data [k] = memory ;
2307                 } ;
2308         data [datalen-1] = data [datalen-2] ;
2309
2310 } /* smoothed_diff_float */
2311
2312 static  void
2313 smoothed_diff_double (double *data, unsigned int datalen)
2314 {       unsigned int k ;
2315         double memory = 0.0 ;
2316
2317         /* Calculate the smoothed sample-to-sample difference. */
2318         for (k = 0 ; k < datalen - 1 ; k++)
2319         {       memory = 0.7 * memory + (1 - 0.7) * (data [k+1] - data [k]) ;
2320                 data [k] = memory ;
2321                 } ;
2322         data [datalen-1] = data [datalen-2] ;
2323
2324 } /* smoothed_diff_double */
2325
2326 static void
2327 check_comment (SNDFILE * file, int format, int lineno)
2328 {       const char              *comment ;
2329
2330         switch (format & SF_FORMAT_TYPEMASK)
2331         {       case SF_FORMAT_AIFF :
2332                 case SF_FORMAT_WAV :
2333                 case SF_FORMAT_WAVEX :
2334                         break ;
2335                 default :
2336                         return ;
2337                 } ;
2338
2339         comment = sf_get_string (file, SF_STR_COMMENT) ;
2340         if (comment == NULL)
2341         {       printf ("\n\nLine %d : File does not contain a comment string.\n\n", lineno) ;
2342                 exit (1) ;
2343                 } ;
2344
2345         if (strcmp (comment, long_comment) != 0)
2346         {       printf ("\n\nLine %d : File comment does not match comment written.\n\n", lineno) ;
2347                 exit (1) ;
2348                 } ;
2349
2350         return ;
2351 } /* check_comment */
2352
2353 static int
2354 is_lossy (int filetype)
2355 {
2356         switch (SF_FORMAT_SUBMASK & filetype)
2357         {       case SF_FORMAT_PCM_U8 :
2358                 case SF_FORMAT_PCM_S8 :
2359                 case SF_FORMAT_PCM_16 :
2360                 case SF_FORMAT_PCM_24 :
2361                 case SF_FORMAT_PCM_32 :
2362                 case SF_FORMAT_FLOAT :
2363                 case SF_FORMAT_DOUBLE :
2364                         return 0 ;
2365
2366                 default :
2367                         break ;
2368                 } ;
2369
2370         return 1 ;
2371 } /* is_lossy */
2372