libs/libsndfile/src/sndfile.c

   1 /*
   2 ** Copyright (C) 1999-2005 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 Lesser General Public License as published by
   6 ** the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  13 **
  14 ** You should have received a copy of the GNU Lesser 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        <stdlib.h>
  22 #include        <string.h>
  23 #include        <ctype.h>
  24
  25 #include        "sndfile.h"
  26 #include        "sfendian.h"
  27 #include        "common.h"
  28
  29 #define         SNDFILE_MAGICK  0x1234C0DE
  30
  31 typedef struct
  32 {       int             error ;
  33         const char      *str ;
  34 } ErrorStruct ;
  35
  36 static
  37 ErrorStruct SndfileErrors [] =
  38 {
  39         /* Public error values and their associated strings. */
  40         {       SF_ERR_NO_ERROR                         , "No Error." },
  41         {       SF_ERR_UNRECOGNISED_FORMAT      , "File opened for read. Format not recognised." },
  42         {       SF_ERR_SYSTEM                           , "System error." /* Often replaced. */         },
  43         {       SF_ERR_MALFORMED_FILE           , "Supported file format but file is malformed." },
  44         {       SF_ERR_UNSUPPORTED_ENCODING     , "Supported file format but unsupported encoding." },
  45
  46         /* Private error values and their associated strings. */
  47         {       SFE_BAD_FILE                    , "File does not exist or is not a regular file (possibly a pipe?)." },
  48         {       SFE_BAD_FILE_READ               , "File exists but no data could be read." },
  49         {       SFE_OPEN_FAILED                 , "Could not open file." },
  50         {       SFE_BAD_SNDFILE_PTR             , "Not a valid SNDFILE* pointer." },
  51         {       SFE_BAD_SF_INFO_PTR             , "NULL SF_INFO pointer passed to libsndfile." },
  52         {       SFE_BAD_SF_INCOMPLETE   , "SF_PRIVATE struct incomplete and end of header parsing." },
  53         {       SFE_BAD_FILE_PTR                , "Bad FILE pointer." },
  54         {       SFE_BAD_INT_PTR                 , "Internal error, Bad pointer." },
  55         {       SFE_BAD_STAT_SIZE               , "Error : software was misconfigured at compile time (sizeof statbuf.st_size)." },
  56
  57         {       SFE_MALLOC_FAILED               , "Internal malloc () failed." },
  58         {       SFE_UNIMPLEMENTED               , "File contains data in an unimplemented format." },
  59         {       SFE_BAD_READ_ALIGN              , "Attempt to read a non-integer number of channels." },
  60         {       SFE_BAD_WRITE_ALIGN     , "Attempt to write a non-integer number of channels." },
  61         {       SFE_UNKNOWN_FORMAT              , "File contains data in an unknown format." },
  62         {       SFE_NOT_READMODE                , "Read attempted on file currently open for write." },
  63         {       SFE_NOT_WRITEMODE               , "Write attempted on file currently open for read." },
  64         {       SFE_BAD_MODE_RW                 , "This file format does not support read/write mode." },
  65         {       SFE_BAD_SF_INFO                 , "Internal error : SF_INFO struct incomplete." },
  66         {       SFE_BAD_OFFSET                  , "Error : supplied offset beyond end of file." },
  67         {       SFE_NO_EMBED_SUPPORT    , "Error : embedding not supported for this file format." },
  68         {       SFE_NO_EMBEDDED_RDWR    , "Error : cannot open embedded file read/write." },
  69         {       SFE_NO_PIPE_WRITE               , "Error : this file format does not support pipe write." },
  70         {       SFE_BAD_RDWR_FORMAT             , "Attempted to open read only format for RDWR." },
  71         {       SFE_BAD_VIRTUAL_IO              , "Error : bad pointer on SF_VIRTUAL_IO struct." },
  72
  73         {       SFE_INTERLEAVE_MODE             , "Attempt to write to file with non-interleaved data." },
  74         {       SFE_INTERLEAVE_SEEK             , "Bad karma in seek during interleave read operation." },
  75         {       SFE_INTERLEAVE_READ             , "Bad karma in read during interleave read operation." },
  76
  77         {       SFE_INTERNAL                    , "Unspecified internal error." },
  78         {       SFE_BAD_CONTROL_CMD             , "Bad command passed to function sf_command()." },
  79         {       SFE_BAD_ENDIAN                  , "Bad endian-ness. Try default endian-ness" },
  80         {       SFE_CHANNEL_COUNT               , "Too many channels specified." },
  81
  82         {       SFE_BAD_SEEK                    , "Internal psf_fseek() failed." },
  83         {       SFE_NOT_SEEKABLE                , "Seek attempted on unseekable file type." },
  84         {       SFE_AMBIGUOUS_SEEK              , "Error : combination of file open mode and seek command is ambiguous." },
  85         {       SFE_WRONG_SEEK                  , "Error : invalid seek parameters." },
  86         {       SFE_SEEK_FAILED                 , "Error : parameters OK, but psf_seek() failed." },
  87
  88         {       SFE_BAD_OPEN_MODE               , "Error : bad mode parameter for file open." },
  89         {       SFE_OPEN_PIPE_RDWR              , "Error : attempt toopen a pipe in read/write mode." },
  90         {       SFE_RDWR_POSITION               , "Error on RDWR position (cryptic)." },
  91         {       SFE_RDWR_BAD_HEADER             , "Error : Cannot open file in read/write mode due to string data in header." },
  92
  93         {       SFE_STR_NO_SUPPORT              , "Error : File type does not support string data." },
  94         {       SFE_STR_NOT_WRITE               , "Error : Trying to set a string when file is not in write mode." },
  95         {       SFE_STR_MAX_DATA                , "Error : Maximum string data storage reached." },
  96         {       SFE_STR_MAX_COUNT               , "Error : Maximum string data count reached." },
  97         {       SFE_STR_BAD_TYPE                , "Error : Bad string data type." },
  98         {       SFE_STR_NO_ADD_END              , "Error : file type does not support strings added at end of file." },
  99         {       SFE_STR_BAD_STRING              , "Error : bad string." },
 100         {       SFE_STR_WEIRD                   , "Error : Weird string error." },
 101
 102         {       SFE_WAV_NO_RIFF                 , "Error in WAV file. No 'RIFF' chunk marker." },
 103         {       SFE_WAV_NO_WAVE                 , "Error in WAV file. No 'WAVE' chunk marker." },
 104         {       SFE_WAV_NO_FMT                  , "Error in WAV file. No 'fmt ' chunk marker." },
 105         {       SFE_WAV_FMT_SHORT               , "Error in WAV file. Short 'fmt ' chunk." },
 106
 107         {       SFE_WAV_BAD_FACT                , "Error in WAV file. 'fact' chunk out of place." },
 108         {       SFE_WAV_BAD_PEAK                , "Error in WAV file. Bad 'PEAK' chunk." },
 109         {       SFE_WAV_PEAK_B4_FMT             , "Error in WAV file. 'PEAK' chunk found before 'fmt ' chunk." },
 110
 111         {       SFE_WAV_BAD_FORMAT              , "Error in WAV file. Errors in 'fmt ' chunk." },
 112         {       SFE_WAV_BAD_BLOCKALIGN  , "Error in WAV file. Block alignment in 'fmt ' chunk is incorrect." },
 113         {       SFE_WAV_NO_DATA                 , "Error in WAV file. No 'data' chunk marker." },
 114         {       SFE_WAV_BAD_LIST                , "Error in WAV file. Malformed LIST chunk." },
 115         {       SFE_WAV_UNKNOWN_CHUNK   , "Error in WAV file. File contains an unknown chunk marker." },
 116         {       SFE_WAV_WVPK_DATA               , "Error in WAV file. Data is in WAVPACK format." },
 117
 118         {       SFE_WAV_ADPCM_NOT4BIT   , "Error in ADPCM WAV file. Invalid bit width." },
 119         {       SFE_WAV_ADPCM_CHANNELS  , "Error in ADPCM WAV file. Invalid number of channels." },
 120         {       SFE_WAV_GSM610_FORMAT   , "Error in GSM610 WAV file. Invalid format chunk." },
 121
 122         {       SFE_AIFF_NO_FORM                , "Error in AIFF file, bad 'FORM' marker." },
 123         {       SFE_AIFF_AIFF_NO_FORM   , "Error in AIFF file, 'AIFF' marker without 'FORM'." },
 124         {       SFE_AIFF_COMM_NO_FORM   , "Error in AIFF file, 'COMM' marker without 'FORM'." },
 125         {       SFE_AIFF_SSND_NO_COMM   , "Error in AIFF file, 'SSND' marker without 'COMM'." },
 126         {       SFE_AIFF_UNKNOWN_CHUNK  , "Error in AIFF file, unknown chunk." },
 127         {       SFE_AIFF_COMM_CHUNK_SIZE, "Error in AIFF file, bad 'COMM' chunk size." },
 128         {       SFE_AIFF_BAD_COMM_CHUNK , "Error in AIFF file, bad 'COMM' chunk." },
 129         {       SFE_AIFF_PEAK_B4_COMM   , "Error in AIFF file. 'PEAK' chunk found before 'COMM' chunk." },
 130         {       SFE_AIFF_BAD_PEAK               , "Error in AIFF file. Bad 'PEAK' chunk." },
 131         {       SFE_AIFF_NO_SSND                , "Error in AIFF file, bad 'SSND' chunk." },
 132         {       SFE_AIFF_NO_DATA                , "Error in AIFF file, no sound data." },
 133         {       SFE_AIFF_RW_SSND_NOT_LAST, "Error in AIFF file, RDWR only possible if SSND chunk at end of file." },
 134
 135         {       SFE_AU_UNKNOWN_FORMAT   , "Error in AU file, unknown format." },
 136         {       SFE_AU_NO_DOTSND                , "Error in AU file, missing '.snd' or 'dns.' marker." },
 137         {       SFE_AU_EMBED_BAD_LEN    , "Embedded AU file with unknown length." },
 138
 139         {       SFE_RAW_READ_BAD_SPEC   , "Error while opening RAW file for read. Must specify format and channels.\n"
 140                                                                         "Possibly trying to open unsupported format."
 141                                                                          },
 142         {       SFE_RAW_BAD_BITWIDTH    , "Error. RAW file bitwidth must be a multiple of 8." },
 143         {       SFE_RAW_BAD_FORMAT              , "Error. Bad format field in SF_INFO struct when openning a RAW file for read." },
 144
 145         {       SFE_PAF_NO_MARKER               , "Error in PAF file, no marker." },
 146         {       SFE_PAF_VERSION                 , "Error in PAF file, bad version." },
 147         {       SFE_PAF_UNKNOWN_FORMAT  , "Error in PAF file, unknown format." },
 148         {       SFE_PAF_SHORT_HEADER    , "Error in PAF file. File shorter than minimal header." },
 149
 150         {       SFE_SVX_NO_FORM                 , "Error in 8SVX / 16SV file, no 'FORM' marker." },
 151         {       SFE_SVX_NO_BODY                 , "Error in 8SVX / 16SV file, no 'BODY' marker." },
 152         {       SFE_SVX_NO_DATA                 , "Error in 8SVX / 16SV file, no sound data." },
 153         {       SFE_SVX_BAD_COMP                , "Error in 8SVX / 16SV file, unsupported compression format." },
 154         {       SFE_SVX_BAD_NAME_LENGTH , "Error in 8SVX / 16SV file, NAME chunk too long." },
 155
 156         {       SFE_NIST_BAD_HEADER             , "Error in NIST file, bad header." },
 157         {       SFE_NIST_CRLF_CONVERISON, "Error : NIST file damaged by Windows CR -> CRLF conversion process." },
 158         {       SFE_NIST_BAD_ENCODING   , "Error in NIST file, unsupported compression format." },
 159
 160         {       SFE_VOC_NO_CREATIVE             , "Error in VOC file, no 'Creative Voice File' marker." },
 161         {       SFE_VOC_BAD_FORMAT              , "Error in VOC file, bad format." },
 162         {       SFE_VOC_BAD_VERSION             , "Error in VOC file, bad version number." },
 163         {       SFE_VOC_BAD_MARKER              , "Error in VOC file, bad marker in file." },
 164         {       SFE_VOC_BAD_SECTIONS    , "Error in VOC file, incompatible VOC sections." },
 165         {       SFE_VOC_MULTI_SAMPLERATE, "Error in VOC file, more than one sample rate defined." },
 166         {       SFE_VOC_MULTI_SECTION   , "Unimplemented VOC file feature, file contains multiple sound sections." },
 167         {       SFE_VOC_MULTI_PARAM             , "Error in VOC file, file contains multiple bit or channel widths." },
 168         {       SFE_VOC_SECTION_COUNT   , "Error in VOC file, too many sections." },
 169         {       SFE_VOC_NO_PIPE                 , "Error : not able to operate on VOC files over a pipe." },
 170
 171         {       SFE_IRCAM_NO_MARKER             , "Error in IRCAM file, bad IRCAM marker." },
 172         {       SFE_IRCAM_BAD_CHANNELS  , "Error in IRCAM file, bad channel count." },
 173         {       SFE_IRCAM_UNKNOWN_FORMAT, "Error in IRCAM file, unknow encoding format." },
 174
 175         {       SFE_W64_64_BIT                  , "Error in W64 file, file contains 64 bit offset." },
 176
 177         {       SFE_W64_NO_RIFF                 , "Error in W64 file. No 'riff' chunk marker." },
 178         {       SFE_W64_NO_WAVE                 , "Error in W64 file. No 'wave' chunk marker." },
 179         {       SFE_W64_NO_FMT                  , "Error in W64 file. No 'fmt ' chunk marker." },
 180         {       SFE_W64_NO_DATA                 , "Error in W64 file. No 'data' chunk marker." },
 181
 182         {       SFE_W64_FMT_SHORT               , "Error in W64 file. Short 'fmt ' chunk." },
 183         {       SFE_W64_FMT_TOO_BIG             , "Error in W64 file. 'fmt ' chunk too large." },
 184
 185         {       SFE_W64_ADPCM_NOT4BIT   , "Error in ADPCM W64 file. Invalid bit width." },
 186         {       SFE_W64_ADPCM_CHANNELS  , "Error in ADPCM W64 file. Invalid number of channels." },
 187         {       SFE_W64_GSM610_FORMAT   , "Error in GSM610 W64 file. Invalid format chunk." },
 188
 189         {       SFE_MAT4_BAD_NAME               , "Error in MAT4 file. No variable name." },
 190         {       SFE_MAT4_NO_SAMPLERATE  , "Error in MAT4 file. No sample rate." },
 191         {       SFE_MAT4_ZERO_CHANNELS  , "Error in MAT4 file. Channel count is zero." },
 192
 193         {       SFE_MAT5_BAD_ENDIAN             , "Error in MAT5 file. Not able to determine endian-ness." },
 194         {       SFE_MAT5_NO_BLOCK               , "Error in MAT5 file. Bad block structure." },
 195         {       SFE_MAT5_SAMPLE_RATE    , "Error in MAT5 file. Not able to determine sample rate." },
 196         {       SFE_MAT5_ZERO_CHANNELS  , "Error in MAT5 file. Channel count is zero." },
 197
 198         {       SFE_PVF_NO_PVF1                 , "Error in PVF file. No PVF1 marker." },
 199         {       SFE_PVF_BAD_HEADER              , "Error in PVF file. Bad header." },
 200         {       SFE_PVF_BAD_BITWIDTH    , "Error in PVF file. Bad bit width." },
 201
 202         {       SFE_XI_BAD_HEADER               , "Error in XI file. Bad header." },
 203         {       SFE_XI_EXCESS_SAMPLES   , "Error in XI file. Excess samples in file." },
 204         {       SFE_XI_NO_PIPE                  , "Error : not able to operate on XI files over a pipe." },
 205
 206         {       SFE_HTK_NO_PIPE                 , "Error : not able to operate on HTK files over a pipe." },
 207
 208         {       SFE_SDS_NOT_SDS                 , "Error : not an SDS file." },
 209         {       SFE_SDS_BAD_BIT_WIDTH   , "Error : bad bit width for SDS file." },
 210
 211         {       SFE_SD2_FD_DISALLOWED   , "Error : cannot open SD2 file without a file name." },
 212         {       SFE_SD2_BAD_DATA_OFFSET , "Error : bad data offset." },
 213         {       SFE_SD2_BAD_MAP_OFFSET  , "Error : bad map offset." },
 214         {       SFE_SD2_BAD_DATA_LENGTH , "Error : bad data length." },
 215         {       SFE_SD2_BAD_MAP_LENGTH  , "Error : bad map length." },
 216         {       SFE_SD2_BAD_RSRC                , "Error : bad resource fork." },
 217         {       SFE_SD2_BAD_SAMPLE_SIZE , "Error : bad sample size." },
 218
 219         {       SFE_FLAC_BAD_HEADER             , "Error : bad flac header." },
 220         {       SFE_FLAC_NEW_DECODER    , "Error : problem while creating flac decoder." },
 221         {       SFE_FLAC_INIT_DECODER   , "Error : problem while initialization of the flac decoder." },
 222         {       SFE_FLAC_LOST_SYNC              , "Error : flac decoder lost sync." },
 223         {       SFE_FLAC_BAD_SAMPLE_RATE, "Error : flac does not support this sample rate." },
 224         {       SFE_FLAC_UNKOWN_ERROR   , "Error : unkown error in flac decoder." },
 225
 226         {       SFE_DWVW_BAD_BITWIDTH   , "Error : Bad bit width for DWVW encoding. Must be 12, 16 or 24." },
 227         {       SFE_G72X_NOT_MONO               , "Error : G72x encoding does not support more than 1 channel." },
 228
 229         {       SFE_MAX_ERROR                   , "Maximum error number." },
 230         {       SFE_MAX_ERROR + 1               , NULL }
 231 } ;
 232
 233 /*------------------------------------------------------------------------------
 234 */
 235
 236 static int      format_from_extension (SF_PRIVATE *psf) ;
 237 static int      guess_file_type (SF_PRIVATE *psf) ;
 238 static int      validate_sfinfo (SF_INFO *sfinfo) ;
 239 static int      validate_psf (SF_PRIVATE *psf) ;
 240 static void     save_header_info (SF_PRIVATE *psf) ;
 241 static void     copy_filename (SF_PRIVATE *psf, const char *path) ;
 242 static int      psf_close (SF_PRIVATE *psf) ;
 243 static int      psf_open_file (SF_PRIVATE *psf, int mode, SF_INFO *sfinfo) ;
 244
 245 static int      try_resource_fork (SF_PRIVATE * psf, int mode) ;
 246
 247 /*------------------------------------------------------------------------------
 248 ** Private (static) variables.
 249 */
 250
 251 static int      sf_errno = 0 ;
 252 static char     sf_logbuffer [SF_BUFFER_LEN] = { 0 } ;
 253 static char     sf_syserr [SF_SYSERR_LEN] = { 0 } ;
 254
 255 /*------------------------------------------------------------------------------
 256 */
 257
 258 #define VALIDATE_SNDFILE_AND_ASSIGN_PSF(a,b,c)          \
 259                 {       if (! (a))                                                              \
 260                         {       sf_errno = SFE_BAD_SNDFILE_PTR ;        \
 261                                 return 0 ;                                                      \
 262                                 } ;                                                                     \
 263                         (b) = (SF_PRIVATE*) (a) ;                               \
 264                         if ((b)->virtual_io == SF_FALSE &&              \
 265                                 psf_file_valid (b) == 0)                        \
 266                         {       (b)->error = SFE_BAD_FILE_PTR ;         \
 267                                 return 0 ;                                                      \
 268                                 } ;                                                                     \
 269                         if ((b)->Magick != SNDFILE_MAGICK)              \
 270                         {       (b)->error = SFE_BAD_SNDFILE_PTR ;      \
 271                                 return 0 ;                                                      \
 272                                 } ;                                                                     \
 273                         if (c) (b)->error = 0 ;                                 \
 274                         }
 275
 276 /*------------------------------------------------------------------------------
 277 **      Public functions.
 278 */
 279
 280 SNDFILE*
 281 sf_open (const char *path, int mode, SF_INFO *sfinfo)
 282 {       SF_PRIVATE      *psf ;
 283         int                     error = 0 ;
 284
 285         if ((psf = calloc (1, sizeof (SF_PRIVATE))) == NULL)
 286         {       sf_errno = SFE_MALLOC_FAILED ;
 287                 return  NULL ;
 288                 } ;
 289
 290         memset (psf, 0, sizeof (SF_PRIVATE)) ;
 291         psf_init_files (psf) ;
 292
 293         psf_log_printf (psf, "File : %s\n", path) ;
 294
 295         copy_filename (psf, path) ;
 296
 297         if (strcmp (path, "-") == 0)
 298                 error = psf_set_stdio (psf, mode) ;
 299         else
 300                 error = psf_fopen (psf, path, mode) ;
 301
 302         if (error == 0)
 303                 error = psf_open_file (psf, mode, sfinfo) ;
 304
 305         if (error)
 306         {       sf_errno = error ;
 307                 if (error == SFE_SYSTEM)
 308                         LSF_SNPRINTF (sf_syserr, sizeof (sf_syserr), "%s", psf->syserr) ;
 309                 LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "%s", psf->logbuffer) ;
 310                 psf_close (psf) ;
 311                 return NULL ;
 312                 } ;
 313
 314         memcpy (sfinfo, &(psf->sf), sizeof (SF_INFO)) ;
 315
 316         return (SNDFILE*) psf ;
 317 } /* sf_open */
 318
 319 SNDFILE*
 320 sf_open_fd      (int fd, int mode, SF_INFO *sfinfo, int close_desc)
 321 {       SF_PRIVATE      *psf ;
 322         int                     error ;
 323
 324         if ((sfinfo->format & SF_FORMAT_TYPEMASK) == SF_FORMAT_SD2)
 325         {       sf_errno = SFE_SD2_FD_DISALLOWED ;
 326                 return  NULL ;
 327                 } ;
 328
 329         if ((psf = calloc (1, sizeof (SF_PRIVATE))) == NULL)
 330         {       sf_errno = SFE_MALLOC_FAILED ;
 331                 return  NULL ;
 332                 } ;
 333
 334         psf_init_files (psf) ;
 335
 336         psf_set_file (psf, fd) ;
 337         psf->is_pipe = psf_is_pipe (psf) ;
 338         psf->fileoffset = psf_ftell (psf) ;
 339
 340         if (! close_desc)
 341                 psf->do_not_close_descriptor = SF_TRUE ;
 342
 343         error = psf_open_file (psf, mode, sfinfo) ;
 344
 345         if (error)
 346         {       sf_errno = error ;
 347                 if (error == SFE_SYSTEM)
 348                         LSF_SNPRINTF (sf_syserr, sizeof (sf_syserr), "%s", psf->syserr) ;
 349                 LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "%s", psf->logbuffer) ;
 350                 psf_close (psf) ;
 351                 return NULL ;
 352                 } ;
 353
 354         memcpy (sfinfo, &(psf->sf), sizeof (SF_INFO)) ;
 355
 356         return (SNDFILE*) psf ;
 357 } /* sf_open_fd */
 358
 359 SNDFILE*
 360 sf_open_virtual (SF_VIRTUAL_IO *sfvirtual, int mode, SF_INFO *sfinfo, void *user_data)
 361 {       SF_PRIVATE      *psf ;
 362         int                     error = 0 ;
 363
 364         /* Make sure we have a valid set ot virtual pointers. */
 365         if (sfvirtual->get_filelen == NULL || sfvirtual->seek == NULL || sfvirtual->tell == NULL)
 366         {       sf_errno = SFE_BAD_VIRTUAL_IO ;
 367                 LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "Bad vio_get_filelen / vio_seek / vio_tell in SF_VIRTUAL_IO struct.\n") ;
 368                 return NULL ;
 369                 } ;
 370
 371         if ((mode == SFM_READ || mode == SFM_RDWR) && sfvirtual->read == NULL)
 372         {       sf_errno = SFE_BAD_VIRTUAL_IO ;
 373                 LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "Bad vio_read in SF_VIRTUAL_IO struct.\n") ;
 374                 return NULL ;
 375                 } ;
 376
 377         if ((mode == SFM_WRITE || mode == SFM_RDWR) && sfvirtual->write == NULL)
 378         {       sf_errno = SFE_BAD_VIRTUAL_IO ;
 379                 LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "Bad vio_write in SF_VIRTUAL_IO struct.\n") ;
 380                 return NULL ;
 381                 } ;
 382
 383         if ((psf = calloc (1, sizeof (SF_PRIVATE))) == NULL)
 384         {       sf_errno = SFE_MALLOC_FAILED ;
 385                 return  NULL ;
 386                 } ;
 387
 388         psf_init_files (psf) ;
 389
 390         psf->virtual_io = SF_TRUE ;
 391         psf->vio = *sfvirtual ;
 392         psf->vio_user_data = user_data ;
 393
 394         psf->mode = mode ;
 395
 396         error = psf_open_file (psf, mode, sfinfo) ;
 397
 398         if (error)
 399         {       sf_errno = error ;
 400                 if (error == SFE_SYSTEM)
 401                         LSF_SNPRINTF (sf_syserr, sizeof (sf_syserr), "%s", psf->syserr) ;
 402                 LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "%s", psf->logbuffer) ;
 403                 psf_close (psf) ;
 404                 return NULL ;
 405                 } ;
 406
 407         memcpy (sfinfo, &(psf->sf), sizeof (SF_INFO)) ;
 408
 409         return (SNDFILE*) psf ;
 410 } /* sf_open_virtual */
 411
 412 int
 413 sf_close        (SNDFILE *sndfile)
 414 {       SF_PRIVATE      *psf ;
 415
 416         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
 417
 418         return psf_close (psf) ;
 419 } /* sf_close */
 420
 421 void
 422 sf_write_sync   (SNDFILE *sndfile)
 423 {       SF_PRIVATE      *psf ;
 424
 425         if ((psf = (SF_PRIVATE *) sndfile) == NULL)
 426                 return ;
 427
 428         psf_fsync (psf) ;
 429
 430         return ;
 431 } /* sf_write_sync */
 432
 433 /*==============================================================================
 434 */
 435
 436 const char*
 437 sf_error_number (int errnum)
 438 {       static const char *bad_errnum =
 439                 "No error defined for this error number. This is a bug in libsndfile." ;
 440         int     k ;
 441
 442         if (errnum == SFE_MAX_ERROR)
 443                 return SndfileErrors [0].str ;
 444
 445         if (errnum < 0 || errnum > SFE_MAX_ERROR)
 446         {       /* This really shouldn't happen in release versions. */
 447                 printf ("Not a valid error number (%d).\n", errnum) ;
 448                 return bad_errnum ;
 449                 } ;
 450
 451         for (k = 0 ; SndfileErrors [k].str ; k++)
 452                 if (errnum == SndfileErrors [k].error)
 453                         return SndfileErrors [k].str ;
 454
 455         return bad_errnum ;
 456 } /* sf_error_number */
 457
 458 const char*
 459 sf_strerror (SNDFILE *sndfile)
 460 {       SF_PRIVATE      *psf = NULL ;
 461         int errnum ;
 462
 463         if (! sndfile)
 464         {       errnum = sf_errno ;
 465                 if (errnum == SFE_SYSTEM && sf_syserr [0])
 466                         return sf_syserr ;
 467                 }
 468         else
 469         {       psf = (SF_PRIVATE *) sndfile ;
 470
 471                 if (psf->Magick != SNDFILE_MAGICK)
 472                         return  "sf_strerror : Bad magic number." ;
 473
 474                 errnum = psf->error ;
 475
 476                 if (errnum == SFE_SYSTEM && psf->syserr [0])
 477                         return psf->syserr ;
 478                 } ;
 479
 480         return sf_error_number (errnum) ;
 481 } /* sf_strerror */
 482
 483 /*------------------------------------------------------------------------------
 484 */
 485
 486 int
 487 sf_error (SNDFILE *sndfile)
 488 {       SF_PRIVATE      *psf ;
 489
 490         if (! sndfile)
 491         {       if (sf_error != 0)
 492                         return sf_errno ;
 493                 return 0 ;
 494                 } ;
 495
 496         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 0) ;
 497
 498         if (psf->error)
 499                 return psf->error ;
 500
 501         return 0 ;
 502 } /* sf_error */
 503
 504 /*------------------------------------------------------------------------------
 505 */
 506
 507 int
 508 sf_perror (SNDFILE *sndfile)
 509 {       SF_PRIVATE      *psf ;
 510         int             errnum ;
 511
 512         if (! sndfile)
 513         {       errnum = sf_errno ;
 514                 }
 515         else
 516         {       VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 0) ;
 517                 errnum = psf->error ;
 518                 } ;
 519
 520         fprintf (stderr, "%s\n", sf_error_number (errnum)) ;
 521         return SFE_NO_ERROR ;
 522 } /* sf_perror */
 523
 524
 525 /*------------------------------------------------------------------------------
 526 */
 527
 528 int
 529 sf_error_str (SNDFILE *sndfile, char *str, size_t maxlen)
 530 {       SF_PRIVATE      *psf ;
 531         int             errnum ;
 532
 533         if (! str)
 534                 return SFE_INTERNAL ;
 535
 536         if (! sndfile)
 537                 errnum = sf_errno ;
 538         else
 539         {       VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 0) ;
 540                 errnum = psf->error ;
 541                 } ;
 542
 543         LSF_SNPRINTF (str, maxlen, "%s", sf_error_number (errnum)) ;
 544
 545         return SFE_NO_ERROR ;
 546 } /* sf_error_str */
 547
 548 /*==============================================================================
 549 */
 550
 551 int
 552 sf_format_check (const SF_INFO *info)
 553 {       int     subformat, endian ;
 554
 555         subformat = info->format & SF_FORMAT_SUBMASK ;
 556         endian = info->format & SF_FORMAT_ENDMASK ;
 557
 558         /* This is the place where each file format can check if the suppiled
 559         ** SF_INFO struct is valid.
 560         ** Return 0 on failure, 1 ons success.
 561         */
 562
 563         if (info->channels < 1 || info->channels > 256)
 564                 return 0 ;
 565
 566         if (info->samplerate < 0)
 567                 return 0 ;
 568
 569         switch (info->format & SF_FORMAT_TYPEMASK)
 570         {       case SF_FORMAT_WAV :
 571                 case SF_FORMAT_WAVEX :
 572                                 /* WAV now allows both endian, RIFF or RIFX (little or big respectively) */
 573                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_16)
 574                                         return 1 ;
 575                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 576                                         return 1 ;
 577                                 if ((subformat == SF_FORMAT_IMA_ADPCM || subformat == SF_FORMAT_MS_ADPCM) && info->channels <= 2)
 578                                         return 1 ;
 579                                 if (subformat == SF_FORMAT_GSM610 && info->channels == 1)
 580                                         return 1 ;
 581                                 if (subformat == SF_FORMAT_G721_32 && info->channels == 1)
 582                                         return 1 ;
 583                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 584                                         return 1 ;
 585                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 586                                         return 1 ;
 587                                 break ;
 588
 589                 case SF_FORMAT_AIFF :
 590                                 /* AIFF does allow both endian-nesses for PCM data.*/
 591                                 if (subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 592                                         return 1 ;
 593                                 /* Other encodings. Check for endian-ness. */
 594                                 if (endian == SF_ENDIAN_LITTLE || endian == SF_ENDIAN_CPU)
 595                                         return 0 ;
 596                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_S8)
 597                                         return 1 ;
 598                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 599                                         return 1 ;
 600                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 601                                         return 1 ;
 602                                 if ((subformat == SF_FORMAT_DWVW_12 || subformat == SF_FORMAT_DWVW_16 ||
 603                                                         subformat == SF_FORMAT_DWVW_24) && info-> channels == 1)
 604                                         return 1 ;
 605                                 if (subformat == SF_FORMAT_GSM610 && info->channels == 1)
 606                                         return 1 ;
 607                                 if (subformat == SF_FORMAT_IMA_ADPCM && (info->channels == 1 || info->channels == 2))
 608                                         return 1 ;
 609                                 break ;
 610
 611                 case SF_FORMAT_AU :
 612                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16)
 613                                         return 1 ;
 614                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 615                                         return 1 ;
 616                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 617                                         return 1 ;
 618                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 619                                         return 1 ;
 620                                 if (subformat == SF_FORMAT_G721_32 && info->channels == 1)
 621                                         return 1 ;
 622                                 if (subformat == SF_FORMAT_G723_24 && info->channels == 1)
 623                                         return 1 ;
 624                                 if (subformat == SF_FORMAT_G723_40 && info->channels == 1)
 625                                         return 1 ;
 626                                 break ;
 627
 628                 case SF_FORMAT_CAF :
 629                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16)
 630                                         return 1 ;
 631                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 632                                         return 1 ;
 633                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 634                                         return 1 ;
 635                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 636                                         return 1 ;
 637                                 break ;
 638
 639                 case SF_FORMAT_RAW :
 640                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16)
 641                                         return 1 ;
 642                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 643                                         return 1 ;
 644                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 645                                         return 1 ;
 646                                 if (subformat == SF_FORMAT_ALAW || subformat == SF_FORMAT_ULAW)
 647                                         return 1 ;
 648                                 if ((subformat == SF_FORMAT_DWVW_12 || subformat == SF_FORMAT_DWVW_16 ||
 649                                                         subformat == SF_FORMAT_DWVW_24) && info-> channels == 1)
 650                                         return 1 ;
 651                                 if (subformat == SF_FORMAT_GSM610 && info->channels == 1)
 652                                         return 1 ;
 653                                 if (subformat == SF_FORMAT_VOX_ADPCM && info->channels == 1)
 654                                         return 1 ;
 655                                 break ;
 656
 657                 case SF_FORMAT_PAF :
 658                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16)
 659                                         return 1 ;
 660                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 661                                         return 1 ;
 662                                 break ;
 663
 664                 case SF_FORMAT_SVX :
 665                                 /* SVX currently does not support more than one channel for write.
 666                                 ** Read will allow more than one channel but only allow one here.
 667                                 */
 668                                 if (info->channels != 1)
 669                                         return 0 ;
 670                                 /* Always big endian. */
 671                                 if (endian == SF_ENDIAN_LITTLE || endian == SF_ENDIAN_CPU)
 672                                         return 0 ;
 673
 674                                 if ((subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16) && info->channels == 1)
 675                                         return 1 ;
 676                                 break ;
 677
 678                 case SF_FORMAT_NIST :
 679                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16)
 680                                         return 1 ;
 681                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 682                                         return 1 ;
 683                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 684                                         return 1 ;
 685                                 break ;
 686
 687                 case SF_FORMAT_IRCAM :
 688                                 if (subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 689                                         return 1 ;
 690                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW || subformat == SF_FORMAT_FLOAT)
 691                                         return 1 ;
 692                                 break ;
 693
 694                 case SF_FORMAT_VOC :
 695                                 /* VOC is strictly little endian. */
 696                                 if (endian == SF_ENDIAN_BIG || endian == SF_ENDIAN_CPU)
 697                                         return 0 ;
 698                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_16)
 699                                         return 1 ;
 700                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 701                                         return 1 ;
 702                                 break ;
 703
 704                 case SF_FORMAT_W64 :
 705                                 /* W64 is strictly little endian. */
 706                                 if (endian == SF_ENDIAN_BIG || endian == SF_ENDIAN_CPU)
 707                                         return 0 ;
 708                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_16)
 709                                         return 1 ;
 710                                 if (subformat == SF_FORMAT_PCM_24 || subformat == SF_FORMAT_PCM_32)
 711                                         return 1 ;
 712                                 if ((subformat == SF_FORMAT_IMA_ADPCM || subformat == SF_FORMAT_MS_ADPCM) && info->channels <= 2)
 713                                         return 1 ;
 714                                 if (subformat == SF_FORMAT_GSM610 && info->channels == 1)
 715                                         return 1 ;
 716                                 if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
 717                                         return 1 ;
 718                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 719                                         return 1 ;
 720                                 break ;
 721
 722                 case SF_FORMAT_MAT4 :
 723                                 if (subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_32)
 724                                         return 1 ;
 725                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 726                                         return 1 ;
 727                                 break ;
 728
 729                 case SF_FORMAT_MAT5 :
 730                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_32)
 731                                         return 1 ;
 732                                 if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
 733                                         return 1 ;
 734                                 break ;
 735
 736                 case SF_FORMAT_PVF :
 737                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_32)
 738                                         return 1 ;
 739                                 break ;
 740
 741                 case SF_FORMAT_XI :
 742                                 if (info->channels != 1)
 743                                         return 0 ;
 744                                 if (subformat == SF_FORMAT_DPCM_8 || subformat == SF_FORMAT_DPCM_16)
 745                                         return 1 ;
 746                                 break ;
 747
 748                 case SF_FORMAT_HTK :
 749                                 /* HTK is strictly big endian. */
 750                                 if (endian == SF_ENDIAN_LITTLE || endian == SF_ENDIAN_CPU)
 751                                         return 0 ;
 752                                 if (info->channels != 1)
 753                                         return 0 ;
 754                                 if (subformat == SF_FORMAT_PCM_16)
 755                                         return 1 ;
 756                                 break ;
 757
 758                 case SF_FORMAT_SDS :
 759                                 /* SDS is strictly big endian. */
 760                                 if (endian == SF_ENDIAN_LITTLE || endian == SF_ENDIAN_CPU)
 761                                         return 0 ;
 762                                 if (info->channels != 1)
 763                                         return 0 ;
 764                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_24)
 765                                         return 1 ;
 766                                 break ;
 767
 768                 case SF_FORMAT_AVR :
 769                                 /* SDS is strictly big endian. */
 770                                 if (endian == SF_ENDIAN_LITTLE || endian == SF_ENDIAN_CPU)
 771                                         return 0 ;
 772                                 if (info->channels > 2)
 773                                         return 0 ;
 774                                 if (subformat == SF_FORMAT_PCM_U8 || subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16)
 775                                         return 1 ;
 776                                 break ;
 777
 778                 case SF_FORMAT_FLAC :
 779                                 /* FLAC can't do more than 8 channels. */
 780                                 if (info->channels > 8)
 781                                         return 0 ;
 782                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_24)
 783                                         return 1 ;
 784                                 break ;
 785
 786                 case SF_FORMAT_SD2 :
 787                                 /* SD2 is strictly big endian. */
 788                                 if (endian == SF_ENDIAN_LITTLE || endian == SF_ENDIAN_CPU)
 789                                         return 0 ;
 790                                 if (subformat == SF_FORMAT_PCM_S8 || subformat == SF_FORMAT_PCM_16 || subformat == SF_FORMAT_PCM_24)
 791                                         return 1 ;
 792                                 break ;
 793
 794                 default : break ;
 795                 } ;
 796
 797         return 0 ;
 798 } /* sf_format_check */
 799
 800 /*------------------------------------------------------------------------------
 801 */
 802
 803 int
 804 sf_command      (SNDFILE *sndfile, int command, void *data, int datasize)
 805 {       SF_PRIVATE      *psf = NULL ;
 806         int old_value ;
 807
 808         /* This set of commands do not need the sndfile parameter. */
 809         switch (command)
 810         {       case SFC_GET_LIB_VERSION :
 811                         if (data == NULL)
 812                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 813                         if (ENABLE_EXPERIMENTAL_CODE)
 814                                 LSF_SNPRINTF (data, datasize, "%s-%s-exp", PACKAGE_NAME, PACKAGE_VERSION) ;
 815                         else
 816                                 LSF_SNPRINTF (data, datasize, "%s-%s", PACKAGE_NAME, PACKAGE_VERSION) ;
 817                         return strlen (data) ;
 818
 819                 case SFC_GET_SIMPLE_FORMAT_COUNT :
 820                         if (data == NULL || datasize != SIGNED_SIZEOF (int))
 821                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 822                         *((int*) data) = psf_get_format_simple_count () ;
 823                         return 0 ;
 824
 825                 case SFC_GET_SIMPLE_FORMAT :
 826                         if (data == NULL || datasize != SIGNED_SIZEOF (SF_FORMAT_INFO))
 827                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 828                         return psf_get_format_simple (data) ;
 829
 830                 case SFC_GET_FORMAT_MAJOR_COUNT :
 831                         if (data == NULL || datasize != SIGNED_SIZEOF (int))
 832                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 833                         *((int*) data) = psf_get_format_major_count () ;
 834                         return 0 ;
 835
 836                 case SFC_GET_FORMAT_MAJOR :
 837                         if (data == NULL || datasize != SIGNED_SIZEOF (SF_FORMAT_INFO))
 838                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 839                         return psf_get_format_major (data) ;
 840
 841                 case SFC_GET_FORMAT_SUBTYPE_COUNT :
 842                         if (data == NULL || datasize != SIGNED_SIZEOF (int))
 843                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 844                         *((int*) data) = psf_get_format_subtype_count () ;
 845                         return 0 ;
 846
 847                 case SFC_GET_FORMAT_SUBTYPE :
 848                         if (data == NULL || datasize != SIGNED_SIZEOF (SF_FORMAT_INFO))
 849                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 850                         return psf_get_format_subtype (data) ;
 851
 852                 case SFC_GET_FORMAT_INFO :
 853                         if (data == NULL || datasize != SIGNED_SIZEOF (SF_FORMAT_INFO))
 854                                 return (sf_errno = SFE_BAD_CONTROL_CMD) ;
 855                         return psf_get_format_info (data) ;
 856                 } ;
 857
 858         if (sndfile == NULL && command == SFC_GET_LOG_INFO)
 859         {       if (data == NULL)
 860                         return (psf->error = SFE_BAD_CONTROL_CMD) ;
 861                 LSF_SNPRINTF (data, datasize, "%s", sf_logbuffer) ;
 862                 return strlen (data) ;
 863                 } ;
 864
 865         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
 866
 867         switch (command)
 868         {       case SFC_SET_NORM_FLOAT :
 869                         old_value = psf->norm_float ;
 870                         psf->norm_float = (datasize) ? SF_TRUE : SF_FALSE ;
 871                         return old_value ;
 872
 873                 case SFC_SET_NORM_DOUBLE :
 874                         old_value = psf->norm_double ;
 875                         psf->norm_double = (datasize) ? SF_TRUE : SF_FALSE ;
 876                         return old_value ;
 877
 878                 case SFC_GET_NORM_FLOAT :
 879                         return psf->norm_float ;
 880
 881                 case SFC_GET_NORM_DOUBLE :
 882                         return psf->norm_double ;
 883
 884                 case SFC_SET_SCALE_FLOAT_INT_READ :
 885                         old_value = psf->float_int_mult ;
 886
 887                         psf->float_int_mult = (datasize != 0) ? SF_TRUE : SF_FALSE ;
 888                         if (psf->float_int_mult && psf->float_max < 0.0)
 889                                 psf->float_max = psf_calc_signal_max (psf, SF_FALSE) ;
 890                         return old_value ;
 891
 892                 case SFC_SET_ADD_PEAK_CHUNK :
 893                         {       int format = psf->sf.format & SF_FORMAT_TYPEMASK ;
 894
 895                                 /* Only WAV and AIFF support the PEAK chunk. */
 896                                 if (format != SF_FORMAT_WAV && format != SF_FORMAT_WAVEX && format != SF_FORMAT_AIFF)
 897                                         return SF_FALSE ;
 898
 899                                 format = psf->sf.format & SF_FORMAT_SUBMASK ;
 900
 901                                 /* Only files containg the following data types support the PEAK chunk. */
 902                                 if (format != SF_FORMAT_FLOAT && format != SF_FORMAT_DOUBLE)
 903                                         return SF_FALSE ;
 904
 905                                 } ;
 906                         /* Can only do this is in SFM_WRITE mode. */
 907                         if (psf->mode != SFM_WRITE)
 908                                 return SF_FALSE ;
 909                         /* If data has already been written this must fail. */
 910                         if (psf->have_written)
 911                                 return SF_FALSE ;
 912                         /* Everything seems OK, so set psf->has_peak and re-write header. */
 913                         if (datasize == SF_FALSE && psf->peak_info != NULL)
 914                         {       free (psf->peak_info) ;
 915                                 psf->peak_info = NULL ;
 916                                 }
 917                         else if (psf->peak_info == NULL)
 918                         {       psf->peak_info = peak_info_calloc (psf->sf.channels) ;
 919                                 psf->peak_info->peak_loc = SF_PEAK_START ;
 920                                 } ;
 921
 922                         if (psf->write_header)
 923                                 psf->write_header (psf, SF_TRUE) ;
 924                         return datasize ;
 925
 926                 case SFC_GET_LOG_INFO :
 927                         if (data == NULL)
 928                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 929                         LSF_SNPRINTF (data, datasize, "%s", psf->logbuffer) ;
 930                         break ;
 931
 932                 case SFC_CALC_SIGNAL_MAX :
 933                         if (data == NULL || datasize != sizeof (double))
 934                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 935                         *((double*) data) = psf_calc_signal_max (psf, SF_FALSE) ;
 936                         break ;
 937
 938                 case SFC_CALC_NORM_SIGNAL_MAX :
 939                         if (data == NULL || datasize != sizeof (double))
 940                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 941                         *((double*) data) = psf_calc_signal_max (psf, SF_TRUE) ;
 942                         break ;
 943
 944                 case SFC_CALC_MAX_ALL_CHANNELS :
 945                         if (data == NULL || datasize != SIGNED_SIZEOF (double) * psf->sf.channels)
 946                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 947                         return psf_calc_max_all_channels (psf, (double*) data, SF_FALSE) ;
 948
 949                 case SFC_CALC_NORM_MAX_ALL_CHANNELS :
 950                         if (data == NULL || datasize != SIGNED_SIZEOF (double) * psf->sf.channels)
 951                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 952                         return psf_calc_max_all_channels (psf, (double*) data, SF_TRUE) ;
 953
 954                 case SFC_GET_SIGNAL_MAX :
 955                         if (data == NULL || datasize != sizeof (double))
 956                         {       psf->error = SFE_BAD_CONTROL_CMD ;
 957                                 return SF_FALSE ;
 958                                 } ;
 959                         return psf_get_signal_max (psf, (double *) data) ;
 960
 961                 case SFC_GET_MAX_ALL_CHANNELS :
 962                         if (data == NULL || datasize != SIGNED_SIZEOF (double) * psf->sf.channels)
 963                         {       psf->error = SFE_BAD_CONTROL_CMD ;
 964                                 return SF_FALSE ;
 965                                 } ;
 966                         return psf_get_max_all_channels (psf, (double*) data) ;
 967
 968                 case SFC_UPDATE_HEADER_NOW :
 969                         if (psf->write_header)
 970                                 psf->write_header (psf, SF_TRUE) ;
 971                         break ;
 972
 973                 case SFC_SET_UPDATE_HEADER_AUTO :
 974                         psf->auto_header = datasize ? SF_TRUE : SF_FALSE ;
 975                         return psf->auto_header ;
 976                         break ;
 977
 978                 case SFC_SET_ADD_DITHER_ON_WRITE :
 979                 case SFC_SET_ADD_DITHER_ON_READ :
 980                         /*
 981                         ** FIXME !
 982                         ** These are obsolete. Just return.
 983                         ** Remove some time after version 1.0.8.
 984                         */
 985                         break ;
 986
 987                 case SFC_SET_DITHER_ON_WRITE :
 988                         if (data == NULL || datasize != SIGNED_SIZEOF (SF_DITHER_INFO))
 989                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 990                         memcpy (&psf->write_dither, data, sizeof (psf->write_dither)) ;
 991                         if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
 992                                 dither_init (psf, SFM_WRITE) ;
 993                         break ;
 994
 995                 case SFC_SET_DITHER_ON_READ :
 996                         if (data == NULL || datasize != SIGNED_SIZEOF (SF_DITHER_INFO))
 997                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
 998                         memcpy (&psf->read_dither, data, sizeof (psf->read_dither)) ;
 999                         if (psf->mode == SFM_READ || psf->mode == SFM_RDWR)
1000                                 dither_init (psf, SFM_READ) ;
1001                         break ;
1002
1003                 case SFC_FILE_TRUNCATE :
1004                         if (psf->mode != SFM_WRITE && psf->mode != SFM_RDWR)
1005                                 return SF_TRUE ;
1006                         if (datasize != sizeof (sf_count_t))
1007                                 return SF_TRUE ;
1008                         {       sf_count_t position ;
1009
1010                                 position = *((sf_count_t*) data) ;
1011
1012                                 if (sf_seek (sndfile, position, SEEK_SET) != position)
1013                                         return SF_TRUE ;
1014
1015                                 psf->sf.frames = position ;
1016
1017                                 position = psf_fseek (psf, 0, SEEK_CUR) ;
1018
1019                                 return psf_ftruncate (psf, position) ;
1020                                 } ;
1021                         break ;
1022
1023                 case SFC_SET_RAW_START_OFFSET :
1024                         if (data == NULL || datasize != sizeof (sf_count_t))
1025                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
1026                         if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
1027                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
1028
1029                         psf->dataoffset = *((sf_count_t*) data) ;
1030                         sf_seek (sndfile, 0, SEEK_CUR) ;
1031                         break ;
1032
1033                 case SFC_GET_EMBED_FILE_INFO :
1034                         if (data == NULL || datasize != sizeof (SF_EMBED_FILE_INFO))
1035                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
1036
1037                         ((SF_EMBED_FILE_INFO*) data)->offset = psf->fileoffset ;
1038                         ((SF_EMBED_FILE_INFO*) data)->length = psf->filelength ;
1039                         break ;
1040
1041                 /* Lite remove start */
1042                 case SFC_TEST_IEEE_FLOAT_REPLACE :
1043                         psf->ieee_replace = (datasize) ? SF_TRUE : SF_FALSE ;
1044                         if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_FLOAT)
1045                                 float32_init (psf) ;
1046                         else if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_DOUBLE)
1047                                 double64_init (psf) ;
1048                         else
1049                                 return (psf->error = SFE_BAD_CONTROL_CMD) ;
1050                         break ;
1051                 /* Lite remove end */
1052
1053                 case SFC_SET_CLIPPING :
1054                         psf->add_clipping = (datasize) ? SF_TRUE : SF_FALSE ;
1055                         return psf->add_clipping ;
1056
1057                 case SFC_GET_CLIPPING :
1058                         return psf->add_clipping ;
1059
1060                 case SFC_GET_LOOP_INFO :
1061                         if (datasize != sizeof (SF_LOOP_INFO) || data == NULL)
1062                                 return SF_FALSE ;
1063                         if (psf->loop_info == NULL)
1064                                 return SF_FALSE ;
1065                         memcpy (data, psf->loop_info, sizeof (SF_LOOP_INFO)) ;
1066                         return SF_TRUE ;
1067
1068                 case SFC_SET_BROADCAST_INFO :
1069                         {       int format = psf->sf.format & SF_FORMAT_TYPEMASK ;
1070
1071                                 /* Only WAV supports the BEXT (Broadcast) chunk. */
1072                                 if (format != SF_FORMAT_WAV && format != SF_FORMAT_WAVEX)
1073                                         return SF_FALSE ;
1074                                  } ;
1075
1076                         /* Can only do this is in SFM_RDWR or SFM_WRITE modes. */
1077                         if (psf->mode == SFM_READ)
1078                                 return SF_FALSE ;
1079
1080                         /* If data has already been written this must fail. */
1081                         if (psf->broadcast_info == NULL && psf->have_written)
1082                                 return SF_FALSE ;
1083
1084                         if (psf->broadcast_info == NULL)
1085                                 psf->broadcast_info = broadcast_info_alloc () ;
1086
1087                         broadcast_info_copy (psf->broadcast_info, data) ;
1088                         broadcast_add_coding_history (psf->broadcast_info, psf->sf.channels, psf->sf.samplerate) ;
1089
1090                         if (psf->write_header)
1091                                 psf->write_header (psf, SF_TRUE) ;
1092                         return SF_TRUE ;
1093
1094                 case SFC_GET_BROADCAST_INFO :
1095                         if (datasize != sizeof (SF_BROADCAST_INFO) || data == NULL)
1096                                 return SF_FALSE ;
1097                         if (psf->broadcast_info == NULL)
1098                                 return SF_FALSE ;
1099                         return broadcast_info_copy (data, psf->broadcast_info) ;
1100
1101                 case SFC_GET_INSTRUMENT :
1102                         if (datasize != sizeof (SF_INSTRUMENT) || data == NULL)
1103                                 return SF_FALSE ;
1104                         if (psf->instrument == NULL)
1105                                 return SF_FALSE ;
1106                         memcpy (data, psf->instrument, sizeof (SF_INSTRUMENT)) ;
1107                         return SF_TRUE ;
1108
1109                 case SFC_SET_INSTRUMENT :
1110                         /* If data has already been written this must fail. */
1111                         if (psf->have_written)
1112                                 return SF_FALSE ;
1113                         if (datasize != sizeof (SF_INSTRUMENT) || data == NULL)
1114                                 return SF_FALSE ;
1115                         if (psf->instrument == NULL && (psf->instrument = psf_instrument_alloc ()) == NULL)
1116                         {       psf->error = SFE_MALLOC_FAILED ;
1117                                 return SF_FALSE ;
1118                                 } ;
1119                         memcpy (psf->instrument, data, sizeof (SF_INSTRUMENT)) ;
1120                         return SF_TRUE ;
1121
1122                 default :
1123                         /* Must be a file specific command. Pass it on. */
1124                         if (psf->command)
1125                                 return psf->command (psf, command, data, datasize) ;
1126
1127                         psf_log_printf (psf, "*** sf_command : cmd = 0x%X\n", command) ;
1128                         return (psf->error = SFE_BAD_CONTROL_CMD) ;
1129                 } ;
1130
1131         return 0 ;
1132 } /* sf_command */
1133
1134 /*------------------------------------------------------------------------------
1135 */
1136
1137 sf_count_t
1138 sf_seek (SNDFILE *sndfile, sf_count_t offset, int whence)
1139 {       SF_PRIVATE      *psf ;
1140         sf_count_t      seek_from_start = 0, retval ;
1141
1142         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1143
1144         if (! psf->sf.seekable)
1145         {       psf->error = SFE_NOT_SEEKABLE ;
1146                 return  PSF_SEEK_ERROR ;
1147                 } ;
1148
1149         /* If the whence parameter has a mode ORed in, check to see that
1150         ** it makes sense.
1151         */
1152         if (((whence & SFM_MASK) == SFM_WRITE && psf->mode == SFM_READ) ||
1153                         ((whence & SFM_MASK) == SFM_WRITE && psf->mode == SFM_WRITE))
1154         {       psf->error = SFE_WRONG_SEEK ;
1155                 return PSF_SEEK_ERROR ;
1156                 } ;
1157
1158         /* Convert all SEEK_CUR and SEEK_END into seek_from_start to be
1159         ** used with SEEK_SET.
1160         */
1161         switch (whence)
1162         {       /* The SEEK_SET behaviour is independant of mode. */
1163                 case SEEK_SET :
1164                 case SEEK_SET | SFM_READ :
1165                 case SEEK_SET | SFM_WRITE :
1166                 case SEEK_SET | SFM_RDWR :
1167                                 seek_from_start = offset ;
1168                                 break ;
1169
1170                 /* The SEEK_CUR is a little more tricky. */
1171                 case SEEK_CUR :
1172                                 if (offset == 0)
1173                                 {       if (psf->mode == SFM_READ)
1174                                                 return psf->read_current ;
1175                                         if (psf->mode == SFM_WRITE)
1176                                                 return psf->write_current ;
1177                                         } ;
1178                                 if (psf->mode == SFM_READ)
1179                                         seek_from_start = psf->read_current + offset ;
1180                                 else if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
1181                                         seek_from_start = psf->write_current + offset ;
1182                                 else
1183                                         psf->error = SFE_AMBIGUOUS_SEEK ;
1184                                 break ;
1185
1186                 case SEEK_CUR | SFM_READ :
1187                                 if (offset == 0)
1188                                         return psf->read_current ;
1189                                 seek_from_start = psf->read_current + offset ;
1190                                 break ;
1191
1192                 case SEEK_CUR | SFM_WRITE :
1193                                 if (offset == 0)
1194                                         return psf->write_current ;
1195                                 seek_from_start = psf->write_current + offset ;
1196                                 break ;
1197
1198                 /* The SEEK_END */
1199                 case SEEK_END :
1200                 case SEEK_END | SFM_READ :
1201                 case SEEK_END | SFM_WRITE :
1202                                 seek_from_start = psf->sf.frames + offset ;
1203                                 break ;
1204
1205                 default :
1206                                 psf->error = SFE_BAD_SEEK ;
1207                                 break ;
1208                 } ;
1209
1210         if (psf->error)
1211                 return PSF_SEEK_ERROR ;
1212
1213         if (seek_from_start < 0 || seek_from_start > psf->sf.frames)
1214         {       psf->error = SFE_BAD_SEEK ;
1215                 return PSF_SEEK_ERROR ;
1216                 } ;
1217
1218         if (psf->seek)
1219         {       int new_mode = (whence & SFM_MASK) ? (whence & SFM_MASK) : psf->mode ;
1220
1221                 retval = psf->seek (psf, new_mode, seek_from_start) ;
1222
1223                 switch (new_mode)
1224                 {       case SFM_READ :
1225                                         psf->read_current = retval ;
1226                                         break ;
1227                         case SFM_WRITE :
1228                                         psf->write_current = retval ;
1229                                         break ;
1230                         case SFM_RDWR :
1231                                         psf->read_current = retval ;
1232                                         psf->write_current = retval ;
1233                                         new_mode = SFM_READ ;
1234                                         break ;
1235                         } ;
1236
1237                 psf->last_op = new_mode ;
1238
1239                 return retval ;
1240                 } ;
1241
1242         psf->error = SFE_AMBIGUOUS_SEEK ;
1243         return PSF_SEEK_ERROR ;
1244 } /* sf_seek */
1245
1246 /*------------------------------------------------------------------------------
1247 */
1248
1249 const char*
1250 sf_get_string (SNDFILE *sndfile, int str_type)
1251 {       SF_PRIVATE      *psf ;
1252
1253         if ((psf = (SF_PRIVATE*) sndfile) == NULL)
1254                 return NULL ;
1255         if (psf->Magick != SNDFILE_MAGICK)
1256                 return NULL ;
1257
1258         return psf_get_string (psf, str_type) ;
1259 } /* sf_get_string */
1260
1261 int
1262 sf_set_string (SNDFILE *sndfile, int str_type, const char* str)
1263 {       SF_PRIVATE      *psf ;
1264
1265         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1266
1267         return psf_set_string (psf, str_type, str) ;
1268 } /* sf_get_string */
1269
1270 /*==============================================================================
1271 */
1272
1273 sf_count_t
1274 sf_read_raw             (SNDFILE *sndfile, void *ptr, sf_count_t bytes)
1275 {       SF_PRIVATE      *psf ;
1276         sf_count_t      count ;
1277         int                     bytewidth, blockwidth ;
1278
1279         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1280
1281         bytewidth = (psf->bytewidth > 0) ? psf->bytewidth : 1 ;
1282         blockwidth = (psf->blockwidth > 0) ? psf->blockwidth : 1 ;
1283
1284         if (psf->mode == SFM_WRITE)
1285         {       psf->error = SFE_NOT_READMODE ;
1286                 return  0 ;
1287                 } ;
1288
1289         if (bytes < 0 || psf->read_current >= psf->datalength)
1290         {       psf_memset (ptr, 0, bytes) ;
1291                 return 0 ;
1292                 } ;
1293
1294         if (bytes % (psf->sf.channels * bytewidth))
1295         {       psf->error = SFE_BAD_READ_ALIGN ;
1296                 return 0 ;
1297                 } ;
1298
1299         count = psf_fread (ptr, 1, bytes, psf) ;
1300
1301         if (count < bytes)
1302                 psf_memset (((char*) ptr) + count, 0, bytes - count) ;
1303
1304         psf->read_current += count / blockwidth ;
1305
1306         psf->last_op = SFM_READ ;
1307
1308         return count ;
1309 } /* sf_read_raw */
1310
1311 /*------------------------------------------------------------------------------
1312 */
1313
1314 sf_count_t
1315 sf_read_short   (SNDFILE *sndfile, short *ptr, sf_count_t len)
1316 {       SF_PRIVATE      *psf ;
1317         sf_count_t      count, extra ;
1318
1319         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1320
1321         if (psf->mode == SFM_WRITE)
1322         {       psf->error = SFE_NOT_READMODE ;
1323                 return 0 ;
1324                 } ;
1325
1326         if (len % psf->sf.channels)
1327         {       psf->error = SFE_BAD_READ_ALIGN ;
1328                 return 0 ;
1329                 } ;
1330
1331         if (len <= 0 || psf->read_current >= psf->sf.frames)
1332         {       psf_memset (ptr, 0, len * sizeof (short)) ;
1333                 return 0 ; /* End of file. */
1334                 } ;
1335
1336         if (! psf->read_short || psf->seek == NULL)
1337         {       psf->error = SFE_UNIMPLEMENTED ;
1338                 return  0 ;
1339                 } ;
1340
1341         if (psf->last_op != SFM_READ)
1342                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1343                         return 0 ;
1344
1345         count = psf->read_short (psf, ptr, len) ;
1346
1347         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1348         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1349                 extra = len - count ;
1350                 psf_memset (ptr + count, 0, extra * sizeof (short)) ;
1351                 psf->read_current = psf->sf.frames ;
1352                 } ;
1353
1354         psf->read_current += count / psf->sf.channels ;
1355
1356         psf->last_op = SFM_READ ;
1357
1358         if (psf->read_current > psf->sf.frames)
1359         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1360                 psf->read_current = psf->sf.frames ;
1361                 } ;
1362
1363         return count ;
1364 } /* sf_read_short */
1365
1366 sf_count_t
1367 sf_readf_short          (SNDFILE *sndfile, short *ptr, sf_count_t frames)
1368 {       SF_PRIVATE      *psf ;
1369         sf_count_t      count, extra ;
1370
1371         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1372
1373         if (psf->mode == SFM_WRITE)
1374         {       psf->error = SFE_NOT_READMODE ;
1375                 return 0 ;
1376                 } ;
1377
1378         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1379         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (short)) ;
1380                 return 0 ; /* End of file. */
1381                 } ;
1382
1383         if (! psf->read_short || psf->seek == NULL)
1384         {       psf->error = SFE_UNIMPLEMENTED ;
1385                 return 0 ;
1386                 } ;
1387
1388         if (psf->last_op != SFM_READ)
1389                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1390                         return 0 ;
1391
1392         count = psf->read_short (psf, ptr, frames * psf->sf.channels) ;
1393
1394         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1395         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1396                 extra = frames * psf->sf.channels - count ;
1397                 psf_memset (ptr + count, 0, extra * sizeof (short)) ;
1398                 psf->read_current = psf->sf.frames ;
1399                 } ;
1400
1401         psf->read_current += count / psf->sf.channels ;
1402
1403         psf->last_op = SFM_READ ;
1404
1405         if (psf->read_current > psf->sf.frames)
1406         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1407                 psf->read_current = psf->sf.frames ;
1408                 } ;
1409
1410         return count / psf->sf.channels ;
1411 } /* sf_readf_short */
1412
1413 /*------------------------------------------------------------------------------
1414 */
1415
1416 sf_count_t
1417 sf_read_int             (SNDFILE *sndfile, int *ptr, sf_count_t len)
1418 {       SF_PRIVATE      *psf ;
1419         sf_count_t      count, extra ;
1420
1421         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1422
1423         if (psf->mode == SFM_WRITE)
1424         {       psf->error = SFE_NOT_READMODE ;
1425                 return 0 ;
1426                 } ;
1427
1428         if (len % psf->sf.channels)
1429         {       psf->error = SFE_BAD_READ_ALIGN ;
1430                 return 0 ;
1431                 } ;
1432
1433         if (len <= 0 || psf->read_current >= psf->sf.frames)
1434         {       psf_memset (ptr, 0, len * sizeof (int)) ;
1435                 return 0 ;
1436                 } ;
1437
1438         if (! psf->read_int || psf->seek == NULL)
1439         {       psf->error = SFE_UNIMPLEMENTED ;
1440                 return 0 ;
1441                 } ;
1442
1443         if (psf->last_op != SFM_READ)
1444                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1445                         return 0 ;
1446
1447         count = psf->read_int (psf, ptr, len) ;
1448
1449         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1450         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1451                 extra = len - count ;
1452                 psf_memset (ptr + count, 0, extra * sizeof (int)) ;
1453                 psf->read_current = psf->sf.frames ;
1454                 } ;
1455
1456         psf->read_current += count / psf->sf.channels ;
1457
1458         psf->last_op = SFM_READ ;
1459
1460         if (psf->read_current > psf->sf.frames)
1461         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1462                 psf->read_current = psf->sf.frames ;
1463                 } ;
1464
1465         return count ;
1466 } /* sf_read_int */
1467
1468 sf_count_t
1469 sf_readf_int    (SNDFILE *sndfile, int *ptr, sf_count_t frames)
1470 {       SF_PRIVATE      *psf ;
1471         sf_count_t      count, extra ;
1472
1473         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1474
1475         if (psf->mode == SFM_WRITE)
1476         {       psf->error = SFE_NOT_READMODE ;
1477                 return 0 ;
1478                 } ;
1479
1480         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1481         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (int)) ;
1482                 return 0 ;
1483                 } ;
1484
1485         if (! psf->read_int || psf->seek == NULL)
1486         {       psf->error = SFE_UNIMPLEMENTED ;
1487                 return  0 ;
1488                 } ;
1489
1490         if (psf->last_op != SFM_READ)
1491                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1492                         return 0 ;
1493
1494         count = psf->read_int (psf, ptr, frames * psf->sf.channels) ;
1495
1496         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1497         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1498                 extra = frames * psf->sf.channels - count ;
1499                 psf_memset (ptr + count, 0, extra * sizeof (int)) ;
1500                 psf->read_current = psf->sf.frames ;
1501                 } ;
1502
1503         psf->read_current += count / psf->sf.channels ;
1504
1505         psf->last_op = SFM_READ ;
1506
1507         if (psf->read_current > psf->sf.frames)
1508         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1509                 psf->read_current = psf->sf.frames ;
1510                 } ;
1511
1512         return count / psf->sf.channels ;
1513 } /* sf_readf_int */
1514
1515 /*------------------------------------------------------------------------------
1516 */
1517
1518 sf_count_t
1519 sf_read_float   (SNDFILE *sndfile, float *ptr, sf_count_t len)
1520 {       SF_PRIVATE      *psf ;
1521         sf_count_t      count, extra ;
1522
1523         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1524
1525         if (psf->mode == SFM_WRITE)
1526         {       psf->error = SFE_NOT_READMODE ;
1527                 return 0 ;
1528                 } ;
1529
1530         if (len % psf->sf.channels)
1531         {       psf->error = SFE_BAD_READ_ALIGN ;
1532                 return 0 ;
1533                 } ;
1534
1535         if (len <= 0 || psf->read_current >= psf->sf.frames)
1536         {       psf_memset (ptr, 0, len * sizeof (float)) ;
1537                 return 0 ;
1538                 } ;
1539
1540         if (! psf->read_float || psf->seek == NULL)
1541         {       psf->error = SFE_UNIMPLEMENTED ;
1542                 return  0 ;
1543                 } ;
1544
1545         if (psf->last_op != SFM_READ)
1546                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1547                         return 0 ;
1548
1549         count = psf->read_float (psf, ptr, len) ;
1550
1551         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1552         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1553                 extra = len - count ;
1554                 psf_memset (ptr + count, 0, extra * sizeof (float)) ;
1555                 psf->read_current = psf->sf.frames ;
1556                 } ;
1557
1558         psf->read_current += count / psf->sf.channels ;
1559
1560         psf->last_op = SFM_READ ;
1561
1562         if (psf->read_current > psf->sf.frames)
1563         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1564                 psf->read_current = psf->sf.frames ;
1565                 } ;
1566
1567         return count ;
1568 } /* sf_read_float */
1569
1570 sf_count_t
1571 sf_readf_float  (SNDFILE *sndfile, float *ptr, sf_count_t frames)
1572 {       SF_PRIVATE      *psf ;
1573         sf_count_t      count, extra ;
1574
1575         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1576
1577         if (psf->mode == SFM_WRITE)
1578         {       psf->error = SFE_NOT_READMODE ;
1579                 return 0 ;
1580                 } ;
1581
1582         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1583         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (float)) ;
1584                 return 0 ;
1585                 } ;
1586
1587         if (! psf->read_float || psf->seek == NULL)
1588         {       psf->error = SFE_UNIMPLEMENTED ;
1589                 return  0 ;
1590                 } ;
1591
1592         if (psf->last_op != SFM_READ)
1593                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1594                         return 0 ;
1595
1596         count = psf->read_float (psf, ptr, frames * psf->sf.channels) ;
1597
1598         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1599         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1600                 extra = frames * psf->sf.channels - count ;
1601                 psf_memset (ptr + count, 0, extra * sizeof (float)) ;
1602                 psf->read_current = psf->sf.frames ;
1603                 } ;
1604
1605         psf->read_current += count / psf->sf.channels ;
1606
1607         psf->last_op = SFM_READ ;
1608
1609         if (psf->read_current > psf->sf.frames)
1610         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1611                 psf->read_current = psf->sf.frames ;
1612                 } ;
1613
1614         return count / psf->sf.channels ;
1615 } /* sf_readf_float */
1616
1617 /*------------------------------------------------------------------------------
1618 */
1619
1620 sf_count_t
1621 sf_read_double  (SNDFILE *sndfile, double *ptr, sf_count_t len)
1622 {       SF_PRIVATE      *psf ;
1623         sf_count_t      count, extra ;
1624
1625         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1626
1627         if (psf->mode == SFM_WRITE)
1628         {       psf->error = SFE_NOT_READMODE ;
1629                 return 0 ;
1630                 } ;
1631
1632         if (len % psf->sf.channels)
1633         {       psf->error = SFE_BAD_READ_ALIGN ;
1634                 return 0 ;
1635                 } ;
1636
1637         if (len <= 0 || psf->read_current >= psf->sf.frames)
1638         {       psf_memset (ptr, 0, len * sizeof (double)) ;
1639                 return 0 ;
1640                 } ;
1641
1642         if (! psf->read_double || psf->seek == NULL)
1643         {       psf->error = SFE_UNIMPLEMENTED ;
1644                 return  0 ;
1645                 } ;
1646
1647         if (psf->last_op != SFM_READ)
1648                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1649                         return 0 ;
1650
1651         count = psf->read_double (psf, ptr, len) ;
1652
1653         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1654         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1655                 extra = len - count ;
1656                 psf_memset (ptr + count, 0, extra * sizeof (double)) ;
1657                 psf->read_current = psf->sf.frames ;
1658                 } ;
1659
1660         psf->read_current += count / psf->sf.channels ;
1661
1662         psf->last_op = SFM_READ ;
1663
1664         if (psf->read_current > psf->sf.frames)
1665         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1666                 psf->read_current = psf->sf.frames ;
1667                 } ;
1668
1669         return count ;
1670 } /* sf_read_double */
1671
1672 sf_count_t
1673 sf_readf_double (SNDFILE *sndfile, double *ptr, sf_count_t frames)
1674 {       SF_PRIVATE      *psf ;
1675         sf_count_t      count, extra ;
1676
1677         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1678
1679         if (psf->mode == SFM_WRITE)
1680         {       psf->error = SFE_NOT_READMODE ;
1681                 return 0 ;
1682                 } ;
1683
1684         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1685         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (double)) ;
1686                 return 0 ;
1687                 } ;
1688
1689         if (! psf->read_double || psf->seek == NULL)
1690         {       psf->error = SFE_UNIMPLEMENTED ;
1691                 return  0 ;
1692                 } ;
1693
1694         if (psf->last_op != SFM_READ)
1695                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1696                         return 0 ;
1697
1698         count = psf->read_double (psf, ptr, frames * psf->sf.channels) ;
1699
1700         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1701         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1702                 extra = frames * psf->sf.channels - count ;
1703                 psf_memset (ptr + count, 0, extra * sizeof (double)) ;
1704                 psf->read_current = psf->sf.frames ;
1705                 } ;
1706
1707         psf->read_current += count / psf->sf.channels ;
1708
1709         psf->last_op = SFM_READ ;
1710
1711         if (psf->read_current > psf->sf.frames)
1712         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1713                 psf->read_current = psf->sf.frames ;
1714                 } ;
1715
1716         return count / psf->sf.channels ;
1717 } /* sf_readf_double */
1718
1719 /*------------------------------------------------------------------------------
1720 */
1721
1722 sf_count_t
1723 sf_write_raw    (SNDFILE *sndfile, const void *ptr, sf_count_t len)
1724 {       SF_PRIVATE      *psf ;
1725         sf_count_t      count ;
1726         int                     bytewidth, blockwidth ;
1727
1728         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1729
1730         bytewidth = (psf->bytewidth > 0) ? psf->bytewidth : 1 ;
1731         blockwidth = (psf->blockwidth > 0) ? psf->blockwidth : 1 ;
1732
1733         if (psf->mode == SFM_READ)
1734         {       psf->error = SFE_NOT_WRITEMODE ;
1735                 return 0 ;
1736                 } ;
1737
1738         if (len % (psf->sf.channels * bytewidth))
1739         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1740                 return 0 ;
1741                 } ;
1742
1743         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1744                 psf->write_header (psf, SF_FALSE) ;
1745         psf->have_written = SF_TRUE ;
1746
1747         count = psf_fwrite (ptr, 1, len, psf) ;
1748
1749         psf->write_current += count / blockwidth ;
1750
1751         if (psf->write_current > psf->sf.frames)
1752                 psf->sf.frames = psf->write_current ;
1753
1754         psf->last_op = SFM_WRITE ;
1755
1756         return count ;
1757 } /* sf_write_raw */
1758
1759 /*------------------------------------------------------------------------------
1760 */
1761
1762 sf_count_t
1763 sf_write_short  (SNDFILE *sndfile, const short *ptr, sf_count_t len)
1764 {       SF_PRIVATE      *psf ;
1765         sf_count_t      count ;
1766
1767         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1768
1769         if (psf->mode == SFM_READ)
1770         {       psf->error = SFE_NOT_WRITEMODE ;
1771                 return 0 ;
1772                 } ;
1773
1774         if (len % psf->sf.channels)
1775         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1776                 return 0 ;
1777                 } ;
1778
1779         if (! psf->write_short || psf->seek == NULL)
1780         {       psf->error = SFE_UNIMPLEMENTED ;
1781                 return 0 ;
1782                 } ;
1783
1784         if (psf->last_op != SFM_WRITE)
1785                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1786                         return 0 ;
1787
1788         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1789                 psf->write_header (psf, SF_FALSE) ;
1790         psf->have_written = SF_TRUE ;
1791
1792         count = psf->write_short (psf, ptr, len) ;
1793
1794         psf->write_current += count / psf->sf.channels ;
1795
1796         psf->last_op = SFM_WRITE ;
1797
1798         if (psf->auto_header && psf->write_header != NULL)
1799                 psf->write_header (psf, SF_TRUE) ;
1800
1801         if (psf->write_current > psf->sf.frames)
1802                 psf->sf.frames = psf->write_current ;
1803
1804         return count ;
1805 } /* sf_write_short */
1806
1807 sf_count_t
1808 sf_writef_short (SNDFILE *sndfile, const short *ptr, sf_count_t frames)
1809 {       SF_PRIVATE      *psf ;
1810         sf_count_t      count ;
1811
1812         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1813
1814         if (psf->mode == SFM_READ)
1815         {       psf->error = SFE_NOT_WRITEMODE ;
1816                 return 0 ;
1817                 } ;
1818
1819         if (! psf->write_short || psf->seek == NULL)
1820         {       psf->error = SFE_UNIMPLEMENTED ;
1821                 return 0 ;
1822                 } ;
1823
1824         if (psf->last_op != SFM_WRITE)
1825                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1826                         return 0 ;
1827
1828         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1829                 psf->write_header (psf, SF_FALSE) ;
1830         psf->have_written = SF_TRUE ;
1831
1832         count = psf->write_short (psf, ptr, frames * psf->sf.channels) ;
1833
1834         psf->write_current += count / psf->sf.channels ;
1835
1836         psf->last_op = SFM_WRITE ;
1837
1838         if (psf->auto_header && psf->write_header != NULL)
1839                 psf->write_header (psf, SF_TRUE) ;
1840
1841         if (psf->write_current > psf->sf.frames)
1842                 psf->sf.frames = psf->write_current ;
1843
1844         return count / psf->sf.channels ;
1845 } /* sf_writef_short */
1846
1847 /*------------------------------------------------------------------------------
1848 */
1849
1850 sf_count_t
1851 sf_write_int    (SNDFILE *sndfile, const int *ptr, sf_count_t len)
1852 {       SF_PRIVATE      *psf ;
1853         sf_count_t      count ;
1854
1855         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1856
1857         if (psf->mode == SFM_READ)
1858         {       psf->error = SFE_NOT_WRITEMODE ;
1859                 return 0 ;
1860                 } ;
1861
1862         if (len % psf->sf.channels)
1863         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1864                 return 0 ;
1865                 } ;
1866
1867         if (! psf->write_int || psf->seek == NULL)
1868         {       psf->error = SFE_UNIMPLEMENTED ;
1869                 return 0 ;
1870                 } ;
1871
1872         if (psf->last_op != SFM_WRITE)
1873                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1874                         return 0 ;
1875
1876         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1877                 psf->write_header (psf, SF_FALSE) ;
1878         psf->have_written = SF_TRUE ;
1879
1880         count = psf->write_int (psf, ptr, len) ;
1881
1882         psf->write_current += count / psf->sf.channels ;
1883
1884         psf->last_op = SFM_WRITE ;
1885
1886         if (psf->auto_header && psf->write_header != NULL)
1887                 psf->write_header (psf, SF_TRUE) ;
1888
1889         if (psf->write_current > psf->sf.frames)
1890                 psf->sf.frames = psf->write_current ;
1891
1892         return count ;
1893 } /* sf_write_int */
1894
1895 sf_count_t
1896 sf_writef_int   (SNDFILE *sndfile, const int *ptr, sf_count_t frames)
1897 {       SF_PRIVATE      *psf ;
1898         sf_count_t      count ;
1899
1900         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1901
1902         if (psf->mode == SFM_READ)
1903         {       psf->error = SFE_NOT_WRITEMODE ;
1904                 return 0 ;
1905                 } ;
1906
1907         if (! psf->write_int || psf->seek == NULL)
1908         {       psf->error = SFE_UNIMPLEMENTED ;
1909                 return 0 ;
1910                 } ;
1911
1912         if (psf->last_op != SFM_WRITE)
1913                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1914                         return 0 ;
1915
1916         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1917                 psf->write_header (psf, SF_FALSE) ;
1918         psf->have_written = SF_TRUE ;
1919
1920         count = psf->write_int (psf, ptr, frames * psf->sf.channels) ;
1921
1922         psf->write_current += count / psf->sf.channels ;
1923
1924         psf->last_op = SFM_WRITE ;
1925
1926         if (psf->auto_header && psf->write_header != NULL)
1927                 psf->write_header (psf, SF_TRUE) ;
1928
1929         if (psf->write_current > psf->sf.frames)
1930                 psf->sf.frames = psf->write_current ;
1931
1932         return count / psf->sf.channels ;
1933 } /* sf_writef_int */
1934
1935 /*------------------------------------------------------------------------------
1936 */
1937
1938 sf_count_t
1939 sf_write_float  (SNDFILE *sndfile, const float *ptr, sf_count_t len)
1940 {       SF_PRIVATE      *psf ;
1941         sf_count_t      count ;
1942
1943         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1944
1945         if (psf->mode == SFM_READ)
1946         {       psf->error = SFE_NOT_WRITEMODE ;
1947                 return 0 ;
1948                 } ;
1949
1950         if (len % psf->sf.channels)
1951         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1952                 return 0 ;
1953                 } ;
1954
1955         if (! psf->write_float || psf->seek == NULL)
1956         {       psf->error = SFE_UNIMPLEMENTED ;
1957                 return 0 ;
1958                 } ;
1959
1960         if (psf->last_op != SFM_WRITE)
1961                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1962                         return 0 ;
1963
1964         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1965                 psf->write_header (psf, SF_FALSE) ;
1966         psf->have_written = SF_TRUE ;
1967
1968         count = psf->write_float (psf, ptr, len) ;
1969
1970         psf->write_current += count / psf->sf.channels ;
1971
1972         psf->last_op = SFM_WRITE ;
1973
1974         if (psf->auto_header && psf->write_header != NULL)
1975                 psf->write_header (psf, SF_TRUE) ;
1976
1977         if (psf->write_current > psf->sf.frames)
1978                 psf->sf.frames = psf->write_current ;
1979
1980         return count ;
1981 } /* sf_write_float */
1982
1983 sf_count_t
1984 sf_writef_float (SNDFILE *sndfile, const float *ptr, sf_count_t frames)
1985 {       SF_PRIVATE      *psf ;
1986         sf_count_t      count ;
1987
1988         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1989
1990         if (psf->mode == SFM_READ)
1991         {       psf->error = SFE_NOT_WRITEMODE ;
1992                 return 0 ;
1993                 } ;
1994
1995         if (! psf->write_float || psf->seek == NULL)
1996         {       psf->error = SFE_UNIMPLEMENTED ;
1997                 return 0 ;
1998                 } ;
1999
2000         if (psf->last_op != SFM_WRITE)
2001                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
2002                         return 0 ;
2003
2004         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
2005                 psf->write_header (psf, SF_FALSE) ;
2006         psf->have_written = SF_TRUE ;
2007
2008         count = psf->write_float (psf, ptr, frames * psf->sf.channels) ;
2009
2010         psf->write_current += count / psf->sf.channels ;
2011
2012         psf->last_op = SFM_WRITE ;
2013
2014         if (psf->auto_header && psf->write_header != NULL)
2015                 psf->write_header (psf, SF_TRUE) ;
2016
2017         if (psf->write_current > psf->sf.frames)
2018                 psf->sf.frames = psf->write_current ;
2019
2020         return count / psf->sf.channels ;
2021 } /* sf_writef_float */
2022
2023 /*------------------------------------------------------------------------------
2024 */
2025
2026 sf_count_t
2027 sf_write_double (SNDFILE *sndfile, const double *ptr, sf_count_t len)
2028 {       SF_PRIVATE      *psf ;
2029         sf_count_t      count ;
2030
2031         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
2032
2033         if (psf->mode == SFM_READ)
2034         {       psf->error = SFE_NOT_WRITEMODE ;
2035                 return 0 ;
2036                 } ;
2037
2038         if (len % psf->sf.channels)
2039         {       psf->error = SFE_BAD_WRITE_ALIGN ;
2040                 return  0 ;
2041                 } ;
2042
2043         if (! psf->write_double || psf->seek == NULL)
2044         {       psf->error = SFE_UNIMPLEMENTED ;
2045                 return 0 ;
2046                 } ;
2047
2048         if (psf->last_op != SFM_WRITE)
2049                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
2050                         return 0 ;
2051
2052         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
2053                 psf->write_header (psf, SF_FALSE) ;
2054         psf->have_written = SF_TRUE ;
2055
2056         count = psf->write_double (psf, ptr, len) ;
2057
2058         psf->write_current += count / psf->sf.channels ;
2059
2060         psf->last_op = SFM_WRITE ;
2061
2062         if (psf->auto_header && psf->write_header != NULL)
2063                 psf->write_header (psf, SF_TRUE) ;
2064
2065         if (psf->write_current > psf->sf.frames)
2066                 psf->sf.frames = psf->write_current ;
2067
2068         return count ;
2069 } /* sf_write_double */
2070
2071 sf_count_t
2072 sf_writef_double        (SNDFILE *sndfile, const double *ptr, sf_count_t frames)
2073 {       SF_PRIVATE      *psf ;
2074         sf_count_t      count ;
2075
2076         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
2077
2078         if (psf->mode == SFM_READ)
2079         {       psf->error = SFE_NOT_WRITEMODE ;
2080                 return 0 ;
2081                 } ;
2082
2083         if (! psf->write_double || psf->seek == NULL)
2084         {       psf->error = SFE_UNIMPLEMENTED ;
2085                 return 0 ;
2086                 } ;
2087
2088         if (psf->last_op != SFM_WRITE)
2089                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
2090                         return 0 ;
2091
2092         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
2093                 psf->write_header (psf, SF_FALSE) ;
2094         psf->have_written = SF_TRUE ;
2095
2096         count = psf->write_double (psf, ptr, frames * psf->sf.channels) ;
2097
2098         psf->write_current += count / psf->sf.channels ;
2099
2100         psf->last_op = SFM_WRITE ;
2101
2102         if (psf->auto_header && psf->write_header != NULL)
2103                 psf->write_header (psf, SF_TRUE) ;
2104
2105         if (psf->write_current > psf->sf.frames)
2106                 psf->sf.frames = psf->write_current ;
2107
2108         return count / psf->sf.channels ;
2109 } /* sf_writef_double */
2110
2111 /*=========================================================================
2112 ** Private functions.
2113 */
2114
2115 static int
2116 try_resource_fork (SF_PRIVATE * psf, int mode)
2117 {
2118         if (psf_open_rsrc (psf, mode) != 0)
2119                 return 0 ;
2120
2121         /* More checking here. */
2122         psf_log_printf (psf, "Resource fork : %s\n", psf->rsrcpath) ;
2123
2124         return SF_FORMAT_SD2 ;
2125 } /* try_resource_fork */
2126
2127 static int
2128 format_from_extension (SF_PRIVATE *psf)
2129 {       char *cptr ;
2130         char buffer [16] ;
2131
2132         if (psf->filename == NULL)
2133                 return 0 ;
2134
2135         if ((cptr = strrchr (psf->filename, '.')) == NULL)
2136                 return 0 ;
2137
2138         cptr ++ ;
2139         if (strlen (cptr) > sizeof (buffer) - 1)
2140                 return 0 ;
2141
2142         strncpy (buffer, cptr, sizeof (buffer)) ;
2143         buffer [sizeof (buffer) - 1] = 0 ;
2144
2145         /* Convert everything in the buffer to lower case. */
2146         cptr = buffer ;
2147         while (*cptr)
2148         {       *cptr = tolower (*cptr) ;
2149                 cptr ++ ;
2150                 } ;
2151
2152         cptr = buffer ;
2153
2154         if (strcmp (cptr, "au") == 0)
2155         {       psf->sf.channels = 1 ;
2156                 psf->sf.samplerate = 8000 ;
2157                 return SF_FORMAT_RAW | SF_FORMAT_ULAW ;
2158                 } ;
2159
2160         if (strcmp (cptr, "snd") == 0)
2161         {       psf->sf.channels = 1 ;
2162                 psf->sf.samplerate = 8000 ;
2163                 return SF_FORMAT_RAW | SF_FORMAT_ULAW ;
2164                 } ;
2165
2166         if (strcmp (cptr, "vox") == 0)
2167         {       psf->sf.channels = 1 ;
2168                 psf->sf.samplerate = 8000 ;
2169                 return SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM ;
2170                 } ;
2171
2172         if (strcmp (cptr, "gsm") == 0)
2173         {       psf->sf.channels = 1 ;
2174                 psf->sf.samplerate = 8000 ;
2175                 return SF_FORMAT_RAW | SF_FORMAT_GSM610 ;
2176                 } ;
2177
2178         return 0 ;
2179 } /* format_from_extension */
2180
2181 static int
2182 guess_file_type (SF_PRIVATE *psf)
2183 {       int buffer [3], format ;
2184
2185         if (psf_binheader_readf (psf, "b", &buffer, SIGNED_SIZEOF (buffer)) != SIGNED_SIZEOF (buffer))
2186         {       psf->error = SFE_BAD_FILE_READ ;
2187                 return 0 ;
2188                 } ;
2189
2190         if ((buffer [0] == MAKE_MARKER ('R', 'I', 'F', 'F') || buffer [0] == MAKE_MARKER ('R', 'I', 'F', 'X'))
2191                         && buffer [2] == MAKE_MARKER ('W', 'A', 'V', 'E'))
2192                 return SF_FORMAT_WAV ;
2193
2194         if (buffer [0] == MAKE_MARKER ('F', 'O', 'R', 'M'))
2195         {       if (buffer [2] == MAKE_MARKER ('A', 'I', 'F', 'F') || buffer [2] == MAKE_MARKER ('A', 'I', 'F', 'C'))
2196                         return SF_FORMAT_AIFF ;
2197                 if (buffer [2] == MAKE_MARKER ('8', 'S', 'V', 'X') || buffer [2] == MAKE_MARKER ('1', '6', 'S', 'V'))
2198                         return SF_FORMAT_SVX ;
2199                 return 0 ;
2200                 } ;
2201
2202         if (buffer [0] == MAKE_MARKER ('.', 's', 'n', 'd') || buffer [0] == MAKE_MARKER ('d', 'n', 's', '.'))
2203                 return SF_FORMAT_AU ;
2204
2205         if ((buffer [0] == MAKE_MARKER ('f', 'a', 'p', ' ') || buffer [0] == MAKE_MARKER (' ', 'p', 'a', 'f')))
2206                 return SF_FORMAT_PAF ;
2207
2208         if (buffer [0] == MAKE_MARKER ('N', 'I', 'S', 'T'))
2209                 return SF_FORMAT_NIST ;
2210
2211         if (buffer [0] == MAKE_MARKER ('C', 'r', 'e', 'a') && buffer [1] == MAKE_MARKER ('t', 'i', 'v', 'e'))
2212                 return SF_FORMAT_VOC ;
2213
2214         if ((buffer [0] & MAKE_MARKER (0xFF, 0xFF, 0xF8, 0xFF)) == MAKE_MARKER (0x64, 0xA3, 0x00, 0x00) ||
2215                 (buffer [0] & MAKE_MARKER (0xFF, 0xF8, 0xFF, 0xFF)) == MAKE_MARKER (0x00, 0x00, 0xA3, 0x64))
2216                 return SF_FORMAT_IRCAM ;
2217
2218         if (buffer [0] == MAKE_MARKER ('r', 'i', 'f', 'f'))
2219                 return SF_FORMAT_W64 ;
2220
2221         if (buffer [0] == MAKE_MARKER (0, 0, 0x03, 0xE8) && buffer [1] == MAKE_MARKER (0, 0, 0, 1) &&
2222                                                                 buffer [2] == MAKE_MARKER (0, 0, 0, 1))
2223                 return SF_FORMAT_MAT4 ;
2224
2225         if (buffer [0] == MAKE_MARKER (0, 0, 0, 0) && buffer [1] == MAKE_MARKER (1, 0, 0, 0) &&
2226                                                                 buffer [2] == MAKE_MARKER (1, 0, 0, 0))
2227                 return SF_FORMAT_MAT4 ;
2228
2229         if (buffer [0] == MAKE_MARKER ('M', 'A', 'T', 'L') && buffer [1] == MAKE_MARKER ('A', 'B', ' ', '5'))
2230                 return SF_FORMAT_MAT5 ;
2231
2232         if (buffer [0] == MAKE_MARKER ('P', 'V', 'F', '1'))
2233                 return SF_FORMAT_PVF ;
2234
2235         if (buffer [0] == MAKE_MARKER ('E', 'x', 't', 'e') && buffer [1] == MAKE_MARKER ('n', 'd', 'e', 'd') &&
2236                                                                 buffer [2] == MAKE_MARKER (' ', 'I', 'n', 's'))
2237                 return SF_FORMAT_XI ;
2238
2239         if (buffer [0] == MAKE_MARKER ('c', 'a', 'f', 'f') && buffer [2] == MAKE_MARKER ('d', 'e', 's', 'c'))
2240                 return SF_FORMAT_CAF ;
2241
2242         if (ENABLE_EXPERIMENTAL_CODE && buffer [0] == MAKE_MARKER ('O', 'g', 'g', 'S'))
2243                 return SF_FORMAT_OGG ;
2244
2245         if (buffer [0] == MAKE_MARKER ('A', 'L', 'a', 'w') && buffer [1] == MAKE_MARKER ('S', 'o', 'u', 'n')
2246                         && buffer [2] == MAKE_MARKER ('d', 'F', 'i', 'l'))
2247                 return SF_FORMAT_WVE ;
2248
2249         if (buffer [0] == MAKE_MARKER ('D', 'i', 'a', 'm') && buffer [1] == MAKE_MARKER ('o', 'n', 'd', 'W')
2250                         && buffer [2] == MAKE_MARKER ('a', 'r', 'e', ' '))
2251                 return SF_FORMAT_DWD ;
2252
2253         if (buffer [0] == MAKE_MARKER ('L', 'M', '8', '9') || buffer [0] == MAKE_MARKER ('5', '3', 0, 0))
2254                 return SF_FORMAT_TXW ;
2255
2256         if ((buffer [0] & MAKE_MARKER (0xFF, 0xFF, 0x80, 0xFF)) == MAKE_MARKER (0xF0, 0x7E, 0, 0x01))
2257                 return SF_FORMAT_SDS ;
2258
2259         if (buffer [0] == MAKE_MARKER ('C', 'A', 'T', ' ') && buffer [2] == MAKE_MARKER ('R', 'E', 'X', '2'))
2260                 return SF_FORMAT_REX2 ;
2261
2262         if (buffer [0] == MAKE_MARKER (0x30, 0x26, 0xB2, 0x75) && buffer [1] == MAKE_MARKER (0x8E, 0x66, 0xCF, 0x11))
2263                 return 0 /*-SF_FORMAT_WMA-*/ ;
2264
2265         /* HMM (Hidden Markov Model) Tool Kit. */
2266         if (2 * BEI2H_INT (buffer [0]) + 12 == psf->filelength && buffer [2] == MAKE_MARKER (0, 2, 0, 0))
2267                 return SF_FORMAT_HTK ;
2268
2269         if (buffer [0] == MAKE_MARKER ('f', 'L', 'a', 'C'))
2270                 return SF_FORMAT_FLAC ;
2271
2272         /* Turtle Beach SMP 16-bit */
2273         if (buffer [0] == MAKE_MARKER ('S', 'O', 'U', 'N') && buffer [1] == MAKE_MARKER ('D', ' ', 'S', 'A'))
2274                 return 0 ;
2275
2276         if (buffer [0] == MAKE_MARKER ('S', 'Y', '8', '0') || buffer [0] == MAKE_MARKER ('S', 'Y', '8', '5'))
2277                 return 0 ;
2278
2279         if (buffer [0] == MAKE_MARKER ('a', 'j', 'k', 'g'))
2280                 return 0 /*-SF_FORMAT_SHN-*/ ;
2281
2282         if (buffer [0] == MAKE_MARKER ('2', 'B', 'I', 'T'))
2283                 return SF_FORMAT_AVR ;
2284
2285         /* This must be the second last one. */
2286         if (psf->filelength > 0 && (format = try_resource_fork (psf, SFM_READ)) != 0)
2287                 return format ;
2288
2289         return 0 ;
2290 } /* guess_file_type */
2291
2292
2293 static int
2294 validate_sfinfo (SF_INFO *sfinfo)
2295 {       if (sfinfo->samplerate < 1)
2296                 return 0 ;
2297         if (sfinfo->frames < 0)
2298                 return 0 ;
2299         if (sfinfo->channels < 1)
2300                 return 0 ;
2301         if ((sfinfo->format & SF_FORMAT_TYPEMASK) == 0)
2302                 return 0 ;
2303         if ((sfinfo->format & SF_FORMAT_SUBMASK) == 0)
2304                 return 0 ;
2305         if (sfinfo->sections < 1)
2306                 return 0 ;
2307         return 1 ;
2308 } /* validate_sfinfo */
2309
2310 static int
2311 validate_psf (SF_PRIVATE *psf)
2312 {
2313         if (psf->datalength < 0)
2314         {       psf_log_printf (psf, "Invalid SF_PRIVATE field : datalength == %D.\n", psf->datalength) ;
2315                 return 0 ;
2316                 } ;
2317         if (psf->dataoffset < 0)
2318         {       psf_log_printf (psf, "Invalid SF_PRIVATE field : dataoffset == %D.\n", psf->dataoffset) ;
2319                 return 0 ;
2320                 } ;
2321         if (psf->blockwidth && psf->blockwidth != psf->sf.channels * psf->bytewidth)
2322         {       psf_log_printf (psf, "Invalid SF_PRIVATE field : channels * bytewidth == %d.\n",
2323                                                                 psf->sf.channels * psf->bytewidth) ;
2324                 return 0 ;
2325                 } ;
2326         return 1 ;
2327 } /* validate_psf */
2328
2329 static void
2330 save_header_info (SF_PRIVATE *psf)
2331 {       LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "%s", psf->logbuffer) ;
2332 } /* save_header_info */
2333
2334 static void
2335 copy_filename (SF_PRIVATE *psf, const char *path)
2336 {       const char *ccptr ;
2337         char *cptr ;
2338
2339         LSF_SNPRINTF (psf->filepath, sizeof (psf->filepath), "%s", path) ;
2340         if ((ccptr = strrchr (path, '/')) || (ccptr = strrchr (path, '\\')))
2341                 ccptr ++ ;
2342         else
2343                 ccptr = path ;
2344
2345         LSF_SNPRINTF (psf->filename, sizeof (psf->filename), "%s", ccptr) ;
2346
2347         /* Now grab the directory. */
2348         LSF_SNPRINTF (psf->directory, sizeof (psf->directory), "%s", path) ;
2349         if ((cptr = strrchr (psf->directory, '/')) || (cptr = strrchr (psf->directory, '\\')))
2350                 cptr [1] = 0 ;
2351         else
2352                 psf->directory [0] = 0 ;
2353
2354         return ;
2355 } /* copy_filename */
2356
2357 /*==============================================================================
2358 */
2359
2360 static int
2361 psf_close (SF_PRIVATE *psf)
2362 {       int     error ;
2363
2364         if (psf->codec_close)
2365                 error = psf->codec_close (psf) ;
2366         if (psf->container_close)
2367                 error = psf->container_close (psf) ;
2368
2369         psf_fclose (psf) ;
2370         psf_close_rsrc (psf) ;
2371
2372         if (psf->fdata)
2373                 free (psf->fdata) ;
2374
2375         if (psf->interleave)
2376                 free (psf->interleave) ;
2377
2378         if (psf->dither)
2379                 free (psf->dither) ;
2380
2381         if (psf->peak_info)
2382                 free (psf->peak_info) ;
2383
2384         if (psf->broadcast_info)
2385                 free (psf->broadcast_info) ;
2386
2387         if (psf->loop_info)
2388                 free (psf->loop_info) ;
2389
2390         if (psf->instrument)
2391                 free (psf->instrument) ;
2392
2393         if (psf->format_desc)
2394         {       memset (psf->format_desc, 0, strlen (psf->format_desc)) ;
2395                 free (psf->format_desc) ;
2396                 } ;
2397
2398         memset (psf, 0, sizeof (SF_PRIVATE)) ;
2399         free (psf) ;
2400
2401         return 0 ;
2402 } /* psf_close */
2403
2404 static int
2405 psf_open_file (SF_PRIVATE *psf, int mode, SF_INFO *sfinfo)
2406 {       int             error, format ;
2407
2408         if (mode != SFM_READ && mode != SFM_WRITE && mode != SFM_RDWR)
2409                 return SFE_BAD_OPEN_MODE ;
2410
2411         if (sfinfo == NULL)
2412                 return SFE_BAD_SF_INFO_PTR ;
2413
2414         /* Zero out these fields. */
2415         sfinfo->frames = 0 ;
2416         sfinfo->sections = 0 ;
2417         sfinfo->seekable = 0 ;
2418
2419         if (mode == SFM_READ)
2420         {       if ((sfinfo->format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW)
2421                 {       if (sf_format_check (sfinfo) == 0)
2422                                 return SFE_RAW_BAD_FORMAT ;
2423                         }
2424                 else
2425                         memset (sfinfo, 0, sizeof (SF_INFO)) ;
2426                 } ;
2427
2428         sf_errno = error = 0 ;
2429         sf_logbuffer [0] = 0 ;
2430
2431         memcpy (&(psf->sf), sfinfo, sizeof (SF_INFO)) ;
2432
2433         psf->Magick             = SNDFILE_MAGICK ;
2434         psf->norm_float         = SF_TRUE ;
2435         psf->norm_double        = SF_TRUE ;
2436         psf->mode                       = mode ;
2437         psf->dataoffset         = -1 ;
2438         psf->datalength         = -1 ;
2439         psf->read_current       = -1 ;
2440         psf->write_current      = -1 ;
2441         psf->auto_header        = SF_FALSE ;
2442         psf->rwf_endian         = SF_ENDIAN_LITTLE ;
2443         psf->seek                       = psf_default_seek ;
2444         psf->float_int_mult = 0 ;
2445         psf->float_max          = -1.0 ;
2446
2447         psf->sf.sections = 1 ;
2448
2449         psf->is_pipe = psf_is_pipe (psf) ;
2450
2451         if (psf->is_pipe)
2452         {       psf->sf.seekable = SF_FALSE ;
2453                 psf->filelength = SF_COUNT_MAX ;
2454                 }
2455         else
2456         {       psf->sf.seekable = SF_TRUE ;
2457
2458                 /* File is open, so get the length. */
2459                 psf->filelength = psf_get_filelen (psf) ;
2460                 } ;
2461
2462         if (psf->fileoffset > 0)
2463         {       switch (psf->mode)
2464                 {       case SFM_READ :
2465                                 if (psf->filelength < 44)
2466                                 {       psf_log_printf (psf, "Short filelength: %D (fileoffset: %D)\n", psf->filelength, psf->fileoffset) ;
2467                                         return SFE_BAD_OFFSET ;
2468                                         } ;
2469                                 break ;
2470
2471                         case SFM_WRITE :
2472                                 psf->fileoffset = 0 ;
2473                                 psf_fseek (psf, 0, SEEK_END) ;
2474                                 psf->fileoffset = psf_ftell (psf) ;
2475                                 break ;
2476
2477                         case SFM_RDWR :
2478                                 return SFE_NO_EMBEDDED_RDWR ;
2479                         } ;
2480
2481                 psf_log_printf (psf, "Embedded file offset : %D\n", psf->fileoffset) ;
2482                 } ;
2483
2484         if (psf->filelength == SF_COUNT_MAX)
2485                 psf_log_printf (psf, "Length : unknown\n") ;
2486         else
2487                 psf_log_printf (psf, "Length : %D\n", psf->filelength) ;
2488
2489         if (mode == SFM_WRITE || (mode == SFM_RDWR && psf->filelength == 0))
2490         {       /* If the file is being opened for write or RDWR and the file is currently
2491                 ** empty, then the SF_INFO struct must contain valid data.
2492                 */
2493                 if (sf_format_check (&(psf->sf)) == 0)
2494                         return SFE_BAD_OPEN_FORMAT ;
2495                 }
2496         else if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
2497         {       /* If type RAW has not been specified then need to figure out file type. */
2498                 psf->sf.format = guess_file_type (psf) ;
2499
2500                 if (psf->sf.format == 0)
2501                         psf->sf.format = format_from_extension (psf) ;
2502                 } ;
2503
2504         /* Prevent unnecessary seeks */
2505         psf->last_op = psf->mode ;
2506
2507         /* Set bytewidth if known. */
2508         switch (psf->sf.format & SF_FORMAT_SUBMASK)
2509         {       case SF_FORMAT_PCM_S8 :
2510                 case SF_FORMAT_PCM_U8 :
2511                 case SF_FORMAT_ULAW :
2512                 case SF_FORMAT_ALAW :
2513                 case SF_FORMAT_DPCM_8 :
2514                                 psf->bytewidth = 1 ;
2515                                 break ;
2516
2517                 case SF_FORMAT_PCM_16 :
2518                 case SF_FORMAT_DPCM_16 :
2519                                 psf->bytewidth = 2 ;
2520                                 break ;
2521
2522                 case SF_FORMAT_PCM_24 :
2523                                 psf->bytewidth = 3 ;
2524                                 break ;
2525
2526                 case SF_FORMAT_PCM_32 :
2527                 case SF_FORMAT_FLOAT :
2528                                 psf->bytewidth = 4 ;
2529                                 break ;
2530
2531                 case SF_FORMAT_DOUBLE :
2532                                 psf->bytewidth = 8 ;
2533                                 break ;
2534                 } ;
2535
2536         /* Call the initialisation function for the relevant file type. */
2537         switch (psf->sf.format & SF_FORMAT_TYPEMASK)
2538         {       case    SF_FORMAT_WAV :
2539                 case    SF_FORMAT_WAVEX :
2540                                 error = wav_open (psf) ;
2541                                 break ;
2542
2543                 case    SF_FORMAT_AIFF :
2544                                 error = aiff_open (psf) ;
2545                                 break ;
2546
2547                 case    SF_FORMAT_AU :
2548                                 error = au_open (psf) ;
2549                                 break ;
2550
2551                 case    SF_FORMAT_RAW :
2552                                 error = raw_open (psf) ;
2553                                 break ;
2554
2555                 case    SF_FORMAT_W64 :
2556                                 error = w64_open (psf) ;
2557                                 break ;
2558
2559                 /* Lite remove start */
2560                 case    SF_FORMAT_PAF :
2561                                 error = paf_open (psf) ;
2562                                 break ;
2563
2564                 case    SF_FORMAT_SVX :
2565                                 error = svx_open (psf) ;
2566                                 break ;
2567
2568                 case    SF_FORMAT_NIST :
2569                                 error = nist_open (psf) ;
2570                                 break ;
2571
2572                 case    SF_FORMAT_IRCAM :
2573                                 error = ircam_open (psf) ;
2574                                 break ;
2575
2576                 case    SF_FORMAT_VOC :
2577                                 error = voc_open (psf) ;
2578                                 break ;
2579
2580                 case    SF_FORMAT_SDS :
2581                                 error = sds_open (psf) ;
2582                                 break ;
2583
2584                 case    SF_FORMAT_OGG :
2585                                 error = ogg_open (psf) ;
2586                                 break ;
2587
2588                 case    SF_FORMAT_TXW :
2589                                 error = txw_open (psf) ;
2590                                 break ;
2591
2592                 case    SF_FORMAT_WVE :
2593                                 error = wve_open (psf) ;
2594                                 break ;
2595
2596                 case    SF_FORMAT_DWD :
2597                                 error = dwd_open (psf) ;
2598                                 break ;
2599
2600                 case    SF_FORMAT_MAT4 :
2601                                 error = mat4_open (psf) ;
2602                                 break ;
2603
2604                 case    SF_FORMAT_MAT5 :
2605                                 error = mat5_open (psf) ;
2606                                 break ;
2607
2608                 case    SF_FORMAT_PVF :
2609                                 error = pvf_open (psf) ;
2610                                 break ;
2611
2612                 case    SF_FORMAT_XI :
2613                                 error = xi_open (psf) ;
2614                                 break ;
2615
2616                 case    SF_FORMAT_HTK :
2617                                 error = htk_open (psf) ;
2618                                 break ;
2619
2620                 case    SF_FORMAT_SD2 :
2621                                 error = sd2_open (psf) ;
2622                                 break ;
2623
2624                 case    SF_FORMAT_REX2 :
2625                                 error = rx2_open (psf) ;
2626                                 break ;
2627
2628                 case    SF_FORMAT_AVR :
2629                                 error = avr_open (psf) ;
2630                                 break ;
2631
2632                 case    SF_FORMAT_FLAC :
2633                                 error = flac_open (psf) ;
2634                                 break ;
2635
2636                 case    SF_FORMAT_CAF :
2637                                 error = caf_open (psf) ;
2638                                 break ;
2639
2640                 /* Lite remove end */
2641
2642                 default :
2643                                 error = SFE_UNKNOWN_FORMAT ;
2644                 } ;
2645
2646         if (error)
2647         {       if (error != SF_ERR_SYSTEM && error != SF_ERR_UNSUPPORTED_ENCODING)
2648                 {       psf_log_printf (psf, "Parse error : %s\n", sf_error_number (error)) ;
2649                         error = SF_ERR_MALFORMED_FILE ;
2650                         } ;
2651
2652                 return error ;
2653                 } ;
2654
2655         /* For now, check whether embedding is supported. */
2656         format = psf->sf.format & SF_FORMAT_TYPEMASK ;
2657         if (psf->fileoffset > 0 &&
2658                         (format != SF_FORMAT_WAV) && (format != SF_FORMAT_WAVEX) &&
2659                         (format != SF_FORMAT_AIFF) && (format != SF_FORMAT_AU)
2660                         )
2661                 return SFE_NO_EMBED_SUPPORT ;
2662
2663         if (psf->fileoffset > 0)
2664                 psf_log_printf (psf, "Embedded file length : %D\n", psf->filelength) ;
2665
2666         if (mode == SFM_RDWR && sf_format_check (&(psf->sf)) == 0)
2667                 return SFE_BAD_RDWR_FORMAT ;
2668
2669         if (validate_sfinfo (&(psf->sf)) == 0)
2670         {       psf_log_SF_INFO (psf) ;
2671                 save_header_info (psf) ;
2672                 return SFE_BAD_SF_INFO ;
2673                 } ;
2674
2675         if (validate_psf (psf) == 0)
2676         {       save_header_info (psf) ;
2677                 return SFE_INTERNAL ;
2678                 } ;
2679
2680         psf->read_current = 0 ;
2681         psf->write_current = (psf->mode == SFM_RDWR) ? psf->sf.frames : 0 ;
2682
2683         memcpy (sfinfo, &(psf->sf), sizeof (SF_INFO)) ;
2684
2685         return 0 ;
2686 } /* psf_open_file */
2687
2688 /*
2689 ** Do not edit or modify anything in this comment block.
2690 ** The arch-tag line is a file identity tag for the GNU Arch
2691 ** revision control system.
2692 **
2693 ** arch-tag: cd4f9e91-a8ec-4154-9bf6-fe4b8c69a615
2694 */