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_READ && 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 #ifdef ECDL_ORIGINAL#
1214         if (seek_from_start < 0 || seek_from_start > psf->sf.frames)
1215         {       psf->error = SFE_BAD_SEEK ;
1216                 return PSF_SEEK_ERROR ;
1217                 } ;
1218 #else
1219         if (((whence & SFM_MASK) == SFM_WRITE) || (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR))
1220         {   if (seek_from_start < 0  /* || (seek_from_start > psf->sf.frames && post-audio chunks exist) */ )
1221             {   psf->error = SFE_BAD_SEEK ;
1222                 return PSF_SEEK_ERROR ;
1223                 }
1224             }
1225         else /* seek for reading */
1226         {   if (seek_from_start < 0 || seek_from_start > psf->sf.frames)
1227             {   psf->error = SFE_BAD_SEEK ;
1228                 return PSF_SEEK_ERROR ;
1229                 }
1230             }
1231 #endif
1232
1233         if (psf->seek)
1234         {       int new_mode = (whence & SFM_MASK) ? (whence & SFM_MASK) : psf->mode ;
1235
1236                 retval = psf->seek (psf, new_mode, seek_from_start) ;
1237
1238                 switch (new_mode)
1239                 {       case SFM_READ :
1240                                         psf->read_current = retval ;
1241                                         break ;
1242                         case SFM_WRITE :
1243                                         psf->write_current = retval ;
1244                                         break ;
1245                         case SFM_RDWR :
1246                                         psf->read_current = retval ;
1247                                         psf->write_current = retval ;
1248                                         new_mode = SFM_READ ;
1249                                         break ;
1250                         } ;
1251
1252
1253                 psf->last_op = new_mode ;
1254
1255                 return retval ;
1256                 } ;
1257
1258         psf->error = SFE_AMBIGUOUS_SEEK ;
1259         return PSF_SEEK_ERROR ;
1260 } /* sf_seek */
1261
1262 /*------------------------------------------------------------------------------
1263 */
1264
1265 const char*
1266 sf_get_string (SNDFILE *sndfile, int str_type)
1267 {       SF_PRIVATE      *psf ;
1268
1269         if ((psf = (SF_PRIVATE*) sndfile) == NULL)
1270                 return NULL ;
1271         if (psf->Magick != SNDFILE_MAGICK)
1272                 return NULL ;
1273
1274         return psf_get_string (psf, str_type) ;
1275 } /* sf_get_string */
1276
1277 int
1278 sf_set_string (SNDFILE *sndfile, int str_type, const char* str)
1279 {       SF_PRIVATE      *psf ;
1280
1281         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1282
1283         return psf_set_string (psf, str_type, str) ;
1284 } /* sf_get_string */
1285
1286 /*==============================================================================
1287 */
1288
1289 sf_count_t
1290 sf_read_raw             (SNDFILE *sndfile, void *ptr, sf_count_t bytes)
1291 {       SF_PRIVATE      *psf ;
1292         sf_count_t      count ;
1293         int                     bytewidth, blockwidth ;
1294
1295         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1296
1297         bytewidth = (psf->bytewidth > 0) ? psf->bytewidth : 1 ;
1298         blockwidth = (psf->blockwidth > 0) ? psf->blockwidth : 1 ;
1299
1300         if (psf->mode == SFM_WRITE)
1301         {       psf->error = SFE_NOT_READMODE ;
1302                 return  0 ;
1303                 } ;
1304
1305         if (bytes < 0 || psf->read_current >= psf->datalength)
1306         {       psf_memset (ptr, 0, bytes) ;
1307                 return 0 ;
1308                 } ;
1309
1310         if (bytes % (psf->sf.channels * bytewidth))
1311         {       psf->error = SFE_BAD_READ_ALIGN ;
1312                 return 0 ;
1313                 } ;
1314
1315         count = psf_fread (ptr, 1, bytes, psf) ;
1316
1317         if (count < bytes)
1318                 psf_memset (((char*) ptr) + count, 0, bytes - count) ;
1319
1320         psf->read_current += count / blockwidth ;
1321
1322         psf->last_op = SFM_READ ;
1323
1324         return count ;
1325 } /* sf_read_raw */
1326
1327 /*------------------------------------------------------------------------------
1328 */
1329
1330 sf_count_t
1331 sf_read_short   (SNDFILE *sndfile, short *ptr, sf_count_t len)
1332 {       SF_PRIVATE      *psf ;
1333         sf_count_t      count, extra ;
1334
1335         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1336
1337         if (psf->mode == SFM_WRITE)
1338         {       psf->error = SFE_NOT_READMODE ;
1339                 return 0 ;
1340                 } ;
1341
1342         if (len % psf->sf.channels)
1343         {       psf->error = SFE_BAD_READ_ALIGN ;
1344                 return 0 ;
1345                 } ;
1346
1347         if (len <= 0 || psf->read_current >= psf->sf.frames)
1348         {       psf_memset (ptr, 0, len * sizeof (short)) ;
1349                 return 0 ; /* End of file. */
1350                 } ;
1351
1352         if (! psf->read_short || psf->seek == NULL)
1353         {       psf->error = SFE_UNIMPLEMENTED ;
1354                 return  0 ;
1355                 } ;
1356
1357         if (psf->last_op != SFM_READ)
1358                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1359                         return 0 ;
1360
1361         count = psf->read_short (psf, ptr, len) ;
1362
1363         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1364         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1365                 extra = len - count ;
1366                 psf_memset (ptr + count, 0, extra * sizeof (short)) ;
1367                 psf->read_current = psf->sf.frames ;
1368                 } ;
1369
1370         psf->read_current += count / psf->sf.channels ;
1371
1372         psf->last_op = SFM_READ ;
1373
1374         if (psf->read_current > psf->sf.frames)
1375         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1376                 psf->read_current = psf->sf.frames ;
1377                 } ;
1378
1379         return count ;
1380 } /* sf_read_short */
1381
1382 sf_count_t
1383 sf_readf_short          (SNDFILE *sndfile, short *ptr, sf_count_t frames)
1384 {       SF_PRIVATE      *psf ;
1385         sf_count_t      count, extra ;
1386
1387         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1388
1389         if (psf->mode == SFM_WRITE)
1390         {       psf->error = SFE_NOT_READMODE ;
1391                 return 0 ;
1392                 } ;
1393
1394         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1395         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (short)) ;
1396                 return 0 ; /* End of file. */
1397                 } ;
1398
1399         if (! psf->read_short || psf->seek == NULL)
1400         {       psf->error = SFE_UNIMPLEMENTED ;
1401                 return 0 ;
1402                 } ;
1403
1404         if (psf->last_op != SFM_READ)
1405                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1406                         return 0 ;
1407
1408         count = psf->read_short (psf, ptr, frames * psf->sf.channels) ;
1409
1410         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1411         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1412                 extra = frames * psf->sf.channels - count ;
1413                 psf_memset (ptr + count, 0, extra * sizeof (short)) ;
1414                 psf->read_current = psf->sf.frames ;
1415                 } ;
1416
1417         psf->read_current += count / psf->sf.channels ;
1418
1419         psf->last_op = SFM_READ ;
1420
1421         if (psf->read_current > psf->sf.frames)
1422         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1423                 psf->read_current = psf->sf.frames ;
1424                 } ;
1425
1426         return count / psf->sf.channels ;
1427 } /* sf_readf_short */
1428
1429 /*------------------------------------------------------------------------------
1430 */
1431
1432 sf_count_t
1433 sf_read_int             (SNDFILE *sndfile, int *ptr, sf_count_t len)
1434 {       SF_PRIVATE      *psf ;
1435         sf_count_t      count, extra ;
1436
1437         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1438
1439         if (psf->mode == SFM_WRITE)
1440         {       psf->error = SFE_NOT_READMODE ;
1441                 return 0 ;
1442                 } ;
1443
1444         if (len % psf->sf.channels)
1445         {       psf->error = SFE_BAD_READ_ALIGN ;
1446                 return 0 ;
1447                 } ;
1448
1449         if (len <= 0 || psf->read_current >= psf->sf.frames)
1450         {       psf_memset (ptr, 0, len * sizeof (int)) ;
1451                 return 0 ;
1452                 } ;
1453
1454         if (! psf->read_int || psf->seek == NULL)
1455         {       psf->error = SFE_UNIMPLEMENTED ;
1456                 return 0 ;
1457                 } ;
1458
1459         if (psf->last_op != SFM_READ)
1460                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1461                         return 0 ;
1462
1463         count = psf->read_int (psf, ptr, len) ;
1464
1465         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1466         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1467                 extra = len - count ;
1468                 psf_memset (ptr + count, 0, extra * sizeof (int)) ;
1469                 psf->read_current = psf->sf.frames ;
1470                 } ;
1471
1472         psf->read_current += count / psf->sf.channels ;
1473
1474         psf->last_op = SFM_READ ;
1475
1476         if (psf->read_current > psf->sf.frames)
1477         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1478                 psf->read_current = psf->sf.frames ;
1479                 } ;
1480
1481         return count ;
1482 } /* sf_read_int */
1483
1484 sf_count_t
1485 sf_readf_int    (SNDFILE *sndfile, int *ptr, sf_count_t frames)
1486 {       SF_PRIVATE      *psf ;
1487         sf_count_t      count, extra ;
1488
1489         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1490
1491         if (psf->mode == SFM_WRITE)
1492         {       psf->error = SFE_NOT_READMODE ;
1493                 return 0 ;
1494                 } ;
1495
1496         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1497         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (int)) ;
1498                 return 0 ;
1499                 } ;
1500
1501         if (! psf->read_int || psf->seek == NULL)
1502         {       psf->error = SFE_UNIMPLEMENTED ;
1503                 return  0 ;
1504                 } ;
1505
1506         if (psf->last_op != SFM_READ)
1507                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1508                         return 0 ;
1509
1510         count = psf->read_int (psf, ptr, frames * psf->sf.channels) ;
1511
1512         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1513         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1514                 extra = frames * psf->sf.channels - count ;
1515                 psf_memset (ptr + count, 0, extra * sizeof (int)) ;
1516                 psf->read_current = psf->sf.frames ;
1517                 } ;
1518
1519         psf->read_current += count / psf->sf.channels ;
1520
1521         psf->last_op = SFM_READ ;
1522
1523         if (psf->read_current > psf->sf.frames)
1524         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1525                 psf->read_current = psf->sf.frames ;
1526                 } ;
1527
1528         return count / psf->sf.channels ;
1529 } /* sf_readf_int */
1530
1531 /*------------------------------------------------------------------------------
1532 */
1533
1534 sf_count_t
1535 sf_read_float   (SNDFILE *sndfile, float *ptr, sf_count_t len)
1536 {       SF_PRIVATE      *psf ;
1537         sf_count_t      count, extra ;
1538
1539         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1540
1541         if (psf->mode == SFM_WRITE)
1542         {       psf->error = SFE_NOT_READMODE ;
1543                 return 0 ;
1544                 } ;
1545
1546         if (len % psf->sf.channels)
1547         {       psf->error = SFE_BAD_READ_ALIGN ;
1548                 return 0 ;
1549                 } ;
1550
1551         if (len <= 0 || psf->read_current >= psf->sf.frames)
1552         {       psf_memset (ptr, 0, len * sizeof (float)) ;
1553                 return 0 ;
1554                 } ;
1555
1556         if (! psf->read_float || psf->seek == NULL)
1557         {       psf->error = SFE_UNIMPLEMENTED ;
1558                 return  0 ;
1559                 } ;
1560
1561         if (psf->last_op != SFM_READ)
1562                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1563                         return 0 ;
1564
1565         count = psf->read_float (psf, ptr, len) ;
1566
1567         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1568         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1569                 extra = len - count ;
1570                 psf_memset (ptr + count, 0, extra * sizeof (float)) ;
1571                 psf->read_current = psf->sf.frames ;
1572                 } ;
1573
1574         psf->read_current += count / psf->sf.channels ;
1575
1576         psf->last_op = SFM_READ ;
1577
1578         if (psf->read_current > psf->sf.frames)
1579         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1580                 psf->read_current = psf->sf.frames ;
1581                 } ;
1582
1583         return count ;
1584 } /* sf_read_float */
1585
1586 sf_count_t
1587 sf_readf_float  (SNDFILE *sndfile, float *ptr, sf_count_t frames)
1588 {       SF_PRIVATE      *psf ;
1589         sf_count_t      count, extra ;
1590
1591         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1592
1593         if (psf->mode == SFM_WRITE)
1594         {       psf->error = SFE_NOT_READMODE ;
1595                 return 0 ;
1596                 } ;
1597
1598         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1599         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (float)) ;
1600                 return 0 ;
1601                 } ;
1602
1603         if (! psf->read_float || psf->seek == NULL)
1604         {       psf->error = SFE_UNIMPLEMENTED ;
1605                 return  0 ;
1606                 } ;
1607
1608         if (psf->last_op != SFM_READ)
1609                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1610                         return 0 ;
1611
1612         count = psf->read_float (psf, ptr, frames * psf->sf.channels) ;
1613
1614         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1615         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1616                 extra = frames * psf->sf.channels - count ;
1617                 psf_memset (ptr + count, 0, extra * sizeof (float)) ;
1618                 psf->read_current = psf->sf.frames ;
1619                 } ;
1620
1621         psf->read_current += count / psf->sf.channels ;
1622
1623         psf->last_op = SFM_READ ;
1624
1625         if (psf->read_current > psf->sf.frames)
1626         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1627                 psf->read_current = psf->sf.frames ;
1628                 } ;
1629
1630         return count / psf->sf.channels ;
1631 } /* sf_readf_float */
1632
1633 /*------------------------------------------------------------------------------
1634 */
1635
1636 sf_count_t
1637 sf_read_double  (SNDFILE *sndfile, double *ptr, sf_count_t len)
1638 {       SF_PRIVATE      *psf ;
1639         sf_count_t      count, extra ;
1640
1641         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1642
1643         if (psf->mode == SFM_WRITE)
1644         {       psf->error = SFE_NOT_READMODE ;
1645                 return 0 ;
1646                 } ;
1647
1648         if (len % psf->sf.channels)
1649         {       psf->error = SFE_BAD_READ_ALIGN ;
1650                 return 0 ;
1651                 } ;
1652
1653         if (len <= 0 || psf->read_current >= psf->sf.frames)
1654         {       psf_memset (ptr, 0, len * sizeof (double)) ;
1655                 return 0 ;
1656                 } ;
1657
1658         if (! psf->read_double || psf->seek == NULL)
1659         {       psf->error = SFE_UNIMPLEMENTED ;
1660                 return  0 ;
1661                 } ;
1662
1663         if (psf->last_op != SFM_READ)
1664                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1665                         return 0 ;
1666
1667         count = psf->read_double (psf, ptr, len) ;
1668
1669         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1670         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1671                 extra = len - count ;
1672                 psf_memset (ptr + count, 0, extra * sizeof (double)) ;
1673                 psf->read_current = psf->sf.frames ;
1674                 } ;
1675
1676         psf->read_current += count / psf->sf.channels ;
1677
1678         psf->last_op = SFM_READ ;
1679
1680         if (psf->read_current > psf->sf.frames)
1681         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1682                 psf->read_current = psf->sf.frames ;
1683                 } ;
1684
1685         return count ;
1686 } /* sf_read_double */
1687
1688 sf_count_t
1689 sf_readf_double (SNDFILE *sndfile, double *ptr, sf_count_t frames)
1690 {       SF_PRIVATE      *psf ;
1691         sf_count_t      count, extra ;
1692
1693         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1694
1695         if (psf->mode == SFM_WRITE)
1696         {       psf->error = SFE_NOT_READMODE ;
1697                 return 0 ;
1698                 } ;
1699
1700         if (frames <= 0 || psf->read_current >= psf->sf.frames)
1701         {       psf_memset (ptr, 0, frames * psf->sf.channels * sizeof (double)) ;
1702                 return 0 ;
1703                 } ;
1704
1705         if (! psf->read_double || psf->seek == NULL)
1706         {       psf->error = SFE_UNIMPLEMENTED ;
1707                 return  0 ;
1708                 } ;
1709
1710         if (psf->last_op != SFM_READ)
1711                 if (psf->seek (psf, SFM_READ, psf->read_current) < 0)
1712                         return 0 ;
1713
1714         count = psf->read_double (psf, ptr, frames * psf->sf.channels) ;
1715
1716         if (psf->read_current + count / psf->sf.channels > psf->sf.frames)
1717         {       count = (psf->sf.frames - psf->read_current) * psf->sf.channels ;
1718                 extra = frames * psf->sf.channels - count ;
1719                 psf_memset (ptr + count, 0, extra * sizeof (double)) ;
1720                 psf->read_current = psf->sf.frames ;
1721                 } ;
1722
1723         psf->read_current += count / psf->sf.channels ;
1724
1725         psf->last_op = SFM_READ ;
1726
1727         if (psf->read_current > psf->sf.frames)
1728         {       count = psf->sf.channels * (psf->read_current - psf->sf.frames) ;
1729                 psf->read_current = psf->sf.frames ;
1730                 } ;
1731
1732         return count / psf->sf.channels ;
1733 } /* sf_readf_double */
1734
1735 /*------------------------------------------------------------------------------
1736 */
1737
1738 sf_count_t
1739 sf_write_raw    (SNDFILE *sndfile, const void *ptr, sf_count_t len)
1740 {       SF_PRIVATE      *psf ;
1741         sf_count_t      count ;
1742         int                     bytewidth, blockwidth ;
1743
1744         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1745
1746         bytewidth = (psf->bytewidth > 0) ? psf->bytewidth : 1 ;
1747         blockwidth = (psf->blockwidth > 0) ? psf->blockwidth : 1 ;
1748
1749         if (psf->mode == SFM_READ)
1750         {       psf->error = SFE_NOT_WRITEMODE ;
1751                 return 0 ;
1752                 } ;
1753
1754         if (len % (psf->sf.channels * bytewidth))
1755         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1756                 return 0 ;
1757                 } ;
1758
1759         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1760                 psf->write_header (psf, SF_FALSE) ;
1761         psf->have_written = SF_TRUE ;
1762
1763         count = psf_fwrite (ptr, 1, len, psf) ;
1764
1765         psf->write_current += count / blockwidth ;
1766
1767         if (psf->write_current > psf->sf.frames)
1768                 psf->sf.frames = psf->write_current ;
1769
1770         psf->last_op = SFM_WRITE ;
1771
1772         return count ;
1773 } /* sf_write_raw */
1774
1775 /*------------------------------------------------------------------------------
1776 */
1777
1778 sf_count_t
1779 sf_write_short  (SNDFILE *sndfile, const short *ptr, sf_count_t len)
1780 {       SF_PRIVATE      *psf ;
1781         sf_count_t      count ;
1782
1783         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1784
1785         if (psf->mode == SFM_READ)
1786         {       psf->error = SFE_NOT_WRITEMODE ;
1787                 return 0 ;
1788                 } ;
1789
1790         if (len % psf->sf.channels)
1791         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1792                 return 0 ;
1793                 } ;
1794
1795         if (! psf->write_short || psf->seek == NULL)
1796         {       psf->error = SFE_UNIMPLEMENTED ;
1797                 return 0 ;
1798                 } ;
1799
1800         if (psf->last_op != SFM_WRITE)
1801                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1802                         return 0 ;
1803
1804         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1805                 psf->write_header (psf, SF_FALSE) ;
1806         psf->have_written = SF_TRUE ;
1807
1808         count = psf->write_short (psf, ptr, len) ;
1809
1810         psf->write_current += count / psf->sf.channels ;
1811
1812         psf->last_op = SFM_WRITE ;
1813
1814         if (psf->auto_header && psf->write_header != NULL)
1815                 psf->write_header (psf, SF_TRUE) ;
1816
1817         if (psf->write_current > psf->sf.frames)
1818                 psf->sf.frames = psf->write_current ;
1819
1820         return count ;
1821 } /* sf_write_short */
1822
1823 sf_count_t
1824 sf_writef_short (SNDFILE *sndfile, const short *ptr, sf_count_t frames)
1825 {       SF_PRIVATE      *psf ;
1826         sf_count_t      count ;
1827
1828         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1829
1830         if (psf->mode == SFM_READ)
1831         {       psf->error = SFE_NOT_WRITEMODE ;
1832                 return 0 ;
1833                 } ;
1834
1835         if (! psf->write_short || psf->seek == NULL)
1836         {       psf->error = SFE_UNIMPLEMENTED ;
1837                 return 0 ;
1838                 } ;
1839
1840         if (psf->last_op != SFM_WRITE)
1841                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1842                         return 0 ;
1843
1844         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1845                 psf->write_header (psf, SF_FALSE) ;
1846         psf->have_written = SF_TRUE ;
1847
1848         count = psf->write_short (psf, ptr, frames * psf->sf.channels) ;
1849
1850         psf->write_current += count / psf->sf.channels ;
1851
1852         psf->last_op = SFM_WRITE ;
1853
1854         if (psf->auto_header && psf->write_header != NULL)
1855                 psf->write_header (psf, SF_TRUE) ;
1856
1857         if (psf->write_current > psf->sf.frames)
1858                 psf->sf.frames = psf->write_current ;
1859
1860         return count / psf->sf.channels ;
1861 } /* sf_writef_short */
1862
1863 /*------------------------------------------------------------------------------
1864 */
1865
1866 sf_count_t
1867 sf_write_int    (SNDFILE *sndfile, const int *ptr, sf_count_t len)
1868 {       SF_PRIVATE      *psf ;
1869         sf_count_t      count ;
1870
1871         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1872
1873         if (psf->mode == SFM_READ)
1874         {       psf->error = SFE_NOT_WRITEMODE ;
1875                 return 0 ;
1876                 } ;
1877
1878         if (len % psf->sf.channels)
1879         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1880                 return 0 ;
1881                 } ;
1882
1883         if (! psf->write_int || psf->seek == NULL)
1884         {       psf->error = SFE_UNIMPLEMENTED ;
1885                 return 0 ;
1886                 } ;
1887
1888         if (psf->last_op != SFM_WRITE)
1889                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1890                         return 0 ;
1891
1892         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1893                 psf->write_header (psf, SF_FALSE) ;
1894         psf->have_written = SF_TRUE ;
1895
1896         count = psf->write_int (psf, ptr, len) ;
1897
1898         psf->write_current += count / psf->sf.channels ;
1899
1900         psf->last_op = SFM_WRITE ;
1901
1902         if (psf->auto_header && psf->write_header != NULL)
1903                 psf->write_header (psf, SF_TRUE) ;
1904
1905         if (psf->write_current > psf->sf.frames)
1906                 psf->sf.frames = psf->write_current ;
1907
1908         return count ;
1909 } /* sf_write_int */
1910
1911 sf_count_t
1912 sf_writef_int   (SNDFILE *sndfile, const int *ptr, sf_count_t frames)
1913 {       SF_PRIVATE      *psf ;
1914         sf_count_t      count ;
1915
1916         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1917
1918         if (psf->mode == SFM_READ)
1919         {       psf->error = SFE_NOT_WRITEMODE ;
1920                 return 0 ;
1921                 } ;
1922
1923         if (! psf->write_int || psf->seek == NULL)
1924         {       psf->error = SFE_UNIMPLEMENTED ;
1925                 return 0 ;
1926                 } ;
1927
1928         if (psf->last_op != SFM_WRITE)
1929                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1930                         return 0 ;
1931
1932         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1933                 psf->write_header (psf, SF_FALSE) ;
1934         psf->have_written = SF_TRUE ;
1935
1936         count = psf->write_int (psf, ptr, frames * psf->sf.channels) ;
1937
1938         psf->write_current += count / psf->sf.channels ;
1939
1940         psf->last_op = SFM_WRITE ;
1941
1942         if (psf->auto_header && psf->write_header != NULL)
1943                 psf->write_header (psf, SF_TRUE) ;
1944
1945         if (psf->write_current > psf->sf.frames)
1946                 psf->sf.frames = psf->write_current ;
1947
1948         return count / psf->sf.channels ;
1949 } /* sf_writef_int */
1950
1951 /*------------------------------------------------------------------------------
1952 */
1953
1954 sf_count_t
1955 sf_write_float  (SNDFILE *sndfile, const float *ptr, sf_count_t len)
1956 {       SF_PRIVATE      *psf ;
1957         sf_count_t      count ;
1958
1959         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
1960
1961         if (psf->mode == SFM_READ)
1962         {       psf->error = SFE_NOT_WRITEMODE ;
1963                 return 0 ;
1964                 } ;
1965
1966         if (len % psf->sf.channels)
1967         {       psf->error = SFE_BAD_WRITE_ALIGN ;
1968                 return 0 ;
1969                 } ;
1970
1971         if (! psf->write_float || psf->seek == NULL)
1972         {       psf->error = SFE_UNIMPLEMENTED ;
1973                 return 0 ;
1974                 } ;
1975
1976         if (psf->last_op != SFM_WRITE)
1977                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
1978                         return 0 ;
1979
1980         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
1981                 psf->write_header (psf, SF_FALSE) ;
1982         psf->have_written = SF_TRUE ;
1983
1984         count = psf->write_float (psf, ptr, len) ;
1985
1986         psf->write_current += count / psf->sf.channels ;
1987
1988         psf->last_op = SFM_WRITE ;
1989
1990         if (psf->auto_header && psf->write_header != NULL)
1991                 psf->write_header (psf, SF_TRUE) ;
1992
1993         if (psf->write_current > psf->sf.frames)
1994                 psf->sf.frames = psf->write_current ;
1995
1996         return count ;
1997 } /* sf_write_float */
1998
1999 sf_count_t
2000 sf_writef_float (SNDFILE *sndfile, const float *ptr, sf_count_t frames)
2001 {       SF_PRIVATE      *psf ;
2002         sf_count_t      count ;
2003
2004         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
2005
2006         if (psf->mode == SFM_READ)
2007         {       psf->error = SFE_NOT_WRITEMODE ;
2008                 return 0 ;
2009                 } ;
2010
2011         if (! psf->write_float || psf->seek == NULL)
2012         {       psf->error = SFE_UNIMPLEMENTED ;
2013                 return 0 ;
2014                 } ;
2015
2016         if (psf->last_op != SFM_WRITE)
2017                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
2018                         return 0 ;
2019
2020         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
2021                 psf->write_header (psf, SF_FALSE) ;
2022         psf->have_written = SF_TRUE ;
2023
2024         count = psf->write_float (psf, ptr, frames * psf->sf.channels) ;
2025
2026         psf->write_current += count / psf->sf.channels ;
2027
2028         psf->last_op = SFM_WRITE ;
2029
2030         if (psf->auto_header && psf->write_header != NULL)
2031                 psf->write_header (psf, SF_TRUE) ;
2032
2033         if (psf->write_current > psf->sf.frames)
2034                 psf->sf.frames = psf->write_current ;
2035
2036         return count / psf->sf.channels ;
2037 } /* sf_writef_float */
2038
2039 /*------------------------------------------------------------------------------
2040 */
2041
2042 sf_count_t
2043 sf_write_double (SNDFILE *sndfile, const double *ptr, sf_count_t len)
2044 {       SF_PRIVATE      *psf ;
2045         sf_count_t      count ;
2046
2047         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
2048
2049         if (psf->mode == SFM_READ)
2050         {       psf->error = SFE_NOT_WRITEMODE ;
2051                 return 0 ;
2052                 } ;
2053
2054         if (len % psf->sf.channels)
2055         {       psf->error = SFE_BAD_WRITE_ALIGN ;
2056                 return  0 ;
2057                 } ;
2058
2059         if (! psf->write_double || psf->seek == NULL)
2060         {       psf->error = SFE_UNIMPLEMENTED ;
2061                 return 0 ;
2062                 } ;
2063
2064         if (psf->last_op != SFM_WRITE)
2065                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
2066                         return 0 ;
2067
2068         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
2069                 psf->write_header (psf, SF_FALSE) ;
2070         psf->have_written = SF_TRUE ;
2071
2072         count = psf->write_double (psf, ptr, len) ;
2073
2074         psf->write_current += count / psf->sf.channels ;
2075
2076         psf->last_op = SFM_WRITE ;
2077
2078         if (psf->auto_header && psf->write_header != NULL)
2079                 psf->write_header (psf, SF_TRUE) ;
2080
2081         if (psf->write_current > psf->sf.frames)
2082                 psf->sf.frames = psf->write_current ;
2083
2084         return count ;
2085 } /* sf_write_double */
2086
2087 sf_count_t
2088 sf_writef_double        (SNDFILE *sndfile, const double *ptr, sf_count_t frames)
2089 {       SF_PRIVATE      *psf ;
2090         sf_count_t      count ;
2091
2092         VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf, 1) ;
2093
2094         if (psf->mode == SFM_READ)
2095         {       psf->error = SFE_NOT_WRITEMODE ;
2096                 return 0 ;
2097                 } ;
2098
2099         if (! psf->write_double || psf->seek == NULL)
2100         {       psf->error = SFE_UNIMPLEMENTED ;
2101                 return 0 ;
2102                 } ;
2103
2104         if (psf->last_op != SFM_WRITE)
2105                 if (psf->seek (psf, SFM_WRITE, psf->write_current) < 0)
2106                         return 0 ;
2107
2108         if (psf->have_written == SF_FALSE && psf->write_header != NULL)
2109                 psf->write_header (psf, SF_FALSE) ;
2110         psf->have_written = SF_TRUE ;
2111
2112         count = psf->write_double (psf, ptr, frames * psf->sf.channels) ;
2113
2114         psf->write_current += count / psf->sf.channels ;
2115
2116         psf->last_op = SFM_WRITE ;
2117
2118         if (psf->auto_header && psf->write_header != NULL)
2119                 psf->write_header (psf, SF_TRUE) ;
2120
2121         if (psf->write_current > psf->sf.frames)
2122                 psf->sf.frames = psf->write_current ;
2123
2124         return count / psf->sf.channels ;
2125 } /* sf_writef_double */
2126
2127 /*=========================================================================
2128 ** Private functions.
2129 */
2130
2131 static int
2132 try_resource_fork (SF_PRIVATE * psf, int mode)
2133 {
2134         if (psf_open_rsrc (psf, mode) != 0)
2135                 return 0 ;
2136
2137         /* More checking here. */
2138         psf_log_printf (psf, "Resource fork : %s\n", psf->rsrcpath) ;
2139
2140         return SF_FORMAT_SD2 ;
2141 } /* try_resource_fork */
2142
2143 static int
2144 format_from_extension (SF_PRIVATE *psf)
2145 {       char *cptr ;
2146         char buffer [16] ;
2147
2148         if (psf->filename == NULL)
2149                 return 0 ;
2150
2151         if ((cptr = strrchr (psf->filename, '.')) == NULL)
2152                 return 0 ;
2153
2154         cptr ++ ;
2155         if (strlen (cptr) > sizeof (buffer) - 1)
2156                 return 0 ;
2157
2158         strncpy (buffer, cptr, sizeof (buffer)) ;
2159         buffer [sizeof (buffer) - 1] = 0 ;
2160
2161         /* Convert everything in the buffer to lower case. */
2162         cptr = buffer ;
2163         while (*cptr)
2164         {       *cptr = tolower (*cptr) ;
2165                 cptr ++ ;
2166                 } ;
2167
2168         cptr = buffer ;
2169
2170         if (strcmp (cptr, "au") == 0)
2171         {       psf->sf.channels = 1 ;
2172                 psf->sf.samplerate = 8000 ;
2173                 return SF_FORMAT_RAW | SF_FORMAT_ULAW ;
2174                 } ;
2175
2176         if (strcmp (cptr, "snd") == 0)
2177         {       psf->sf.channels = 1 ;
2178                 psf->sf.samplerate = 8000 ;
2179                 return SF_FORMAT_RAW | SF_FORMAT_ULAW ;
2180                 } ;
2181
2182         if (strcmp (cptr, "vox") == 0)
2183         {       psf->sf.channels = 1 ;
2184                 psf->sf.samplerate = 8000 ;
2185                 return SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM ;
2186                 } ;
2187
2188         if (strcmp (cptr, "gsm") == 0)
2189         {       psf->sf.channels = 1 ;
2190                 psf->sf.samplerate = 8000 ;
2191                 return SF_FORMAT_RAW | SF_FORMAT_GSM610 ;
2192                 } ;
2193
2194         return 0 ;
2195 } /* format_from_extension */
2196
2197 static int
2198 guess_file_type (SF_PRIVATE *psf)
2199 {       int buffer [3], format ;
2200
2201         if (psf_binheader_readf (psf, "b", &buffer, SIGNED_SIZEOF (buffer)) != SIGNED_SIZEOF (buffer))
2202         {       psf->error = SFE_BAD_FILE_READ ;
2203                 return 0 ;
2204                 } ;
2205
2206         if ((buffer [0] == MAKE_MARKER ('R', 'I', 'F', 'F') || buffer [0] == MAKE_MARKER ('R', 'I', 'F', 'X'))
2207                         && buffer [2] == MAKE_MARKER ('W', 'A', 'V', 'E'))
2208                 return SF_FORMAT_WAV ;
2209
2210         if (buffer [0] == MAKE_MARKER ('F', 'O', 'R', 'M'))
2211         {       if (buffer [2] == MAKE_MARKER ('A', 'I', 'F', 'F') || buffer [2] == MAKE_MARKER ('A', 'I', 'F', 'C'))
2212                         return SF_FORMAT_AIFF ;
2213                 if (buffer [2] == MAKE_MARKER ('8', 'S', 'V', 'X') || buffer [2] == MAKE_MARKER ('1', '6', 'S', 'V'))
2214                         return SF_FORMAT_SVX ;
2215                 return 0 ;
2216                 } ;
2217
2218         if (buffer [0] == MAKE_MARKER ('.', 's', 'n', 'd') || buffer [0] == MAKE_MARKER ('d', 'n', 's', '.'))
2219                 return SF_FORMAT_AU ;
2220
2221         if ((buffer [0] == MAKE_MARKER ('f', 'a', 'p', ' ') || buffer [0] == MAKE_MARKER (' ', 'p', 'a', 'f')))
2222                 return SF_FORMAT_PAF ;
2223
2224         if (buffer [0] == MAKE_MARKER ('N', 'I', 'S', 'T'))
2225                 return SF_FORMAT_NIST ;
2226
2227         if (buffer [0] == MAKE_MARKER ('C', 'r', 'e', 'a') && buffer [1] == MAKE_MARKER ('t', 'i', 'v', 'e'))
2228                 return SF_FORMAT_VOC ;
2229
2230         if ((buffer [0] & MAKE_MARKER (0xFF, 0xFF, 0xF8, 0xFF)) == MAKE_MARKER (0x64, 0xA3, 0x00, 0x00) ||
2231                 (buffer [0] & MAKE_MARKER (0xFF, 0xF8, 0xFF, 0xFF)) == MAKE_MARKER (0x00, 0x00, 0xA3, 0x64))
2232                 return SF_FORMAT_IRCAM ;
2233
2234         if (buffer [0] == MAKE_MARKER ('r', 'i', 'f', 'f'))
2235                 return SF_FORMAT_W64 ;
2236
2237         if (buffer [0] == MAKE_MARKER (0, 0, 0x03, 0xE8) && buffer [1] == MAKE_MARKER (0, 0, 0, 1) &&
2238                                                                 buffer [2] == MAKE_MARKER (0, 0, 0, 1))
2239                 return SF_FORMAT_MAT4 ;
2240
2241         if (buffer [0] == MAKE_MARKER (0, 0, 0, 0) && buffer [1] == MAKE_MARKER (1, 0, 0, 0) &&
2242                                                                 buffer [2] == MAKE_MARKER (1, 0, 0, 0))
2243                 return SF_FORMAT_MAT4 ;
2244
2245         if (buffer [0] == MAKE_MARKER ('M', 'A', 'T', 'L') && buffer [1] == MAKE_MARKER ('A', 'B', ' ', '5'))
2246                 return SF_FORMAT_MAT5 ;
2247
2248         if (buffer [0] == MAKE_MARKER ('P', 'V', 'F', '1'))
2249                 return SF_FORMAT_PVF ;
2250
2251         if (buffer [0] == MAKE_MARKER ('E', 'x', 't', 'e') && buffer [1] == MAKE_MARKER ('n', 'd', 'e', 'd') &&
2252                                                                 buffer [2] == MAKE_MARKER (' ', 'I', 'n', 's'))
2253                 return SF_FORMAT_XI ;
2254
2255         if (buffer [0] == MAKE_MARKER ('c', 'a', 'f', 'f') && buffer [2] == MAKE_MARKER ('d', 'e', 's', 'c'))
2256                 return SF_FORMAT_CAF ;
2257
2258         if (ENABLE_EXPERIMENTAL_CODE && buffer [0] == MAKE_MARKER ('O', 'g', 'g', 'S'))
2259                 return SF_FORMAT_OGG ;
2260
2261         if (buffer [0] == MAKE_MARKER ('A', 'L', 'a', 'w') && buffer [1] == MAKE_MARKER ('S', 'o', 'u', 'n')
2262                         && buffer [2] == MAKE_MARKER ('d', 'F', 'i', 'l'))
2263                 return SF_FORMAT_WVE ;
2264
2265         if (buffer [0] == MAKE_MARKER ('D', 'i', 'a', 'm') && buffer [1] == MAKE_MARKER ('o', 'n', 'd', 'W')
2266                         && buffer [2] == MAKE_MARKER ('a', 'r', 'e', ' '))
2267                 return SF_FORMAT_DWD ;
2268
2269         if (buffer [0] == MAKE_MARKER ('L', 'M', '8', '9') || buffer [0] == MAKE_MARKER ('5', '3', 0, 0))
2270                 return SF_FORMAT_TXW ;
2271
2272         if ((buffer [0] & MAKE_MARKER (0xFF, 0xFF, 0x80, 0xFF)) == MAKE_MARKER (0xF0, 0x7E, 0, 0x01))
2273                 return SF_FORMAT_SDS ;
2274
2275         if (buffer [0] == MAKE_MARKER ('C', 'A', 'T', ' ') && buffer [2] == MAKE_MARKER ('R', 'E', 'X', '2'))
2276                 return SF_FORMAT_REX2 ;
2277
2278         if (buffer [0] == MAKE_MARKER (0x30, 0x26, 0xB2, 0x75) && buffer [1] == MAKE_MARKER (0x8E, 0x66, 0xCF, 0x11))
2279                 return 0 /*-SF_FORMAT_WMA-*/ ;
2280
2281         /* HMM (Hidden Markov Model) Tool Kit. */
2282         if (2 * BEI2H_INT (buffer [0]) + 12 == psf->filelength && buffer [2] == MAKE_MARKER (0, 2, 0, 0))
2283                 return SF_FORMAT_HTK ;
2284
2285         if (buffer [0] == MAKE_MARKER ('f', 'L', 'a', 'C'))
2286                 return SF_FORMAT_FLAC ;
2287
2288         /* Turtle Beach SMP 16-bit */
2289         if (buffer [0] == MAKE_MARKER ('S', 'O', 'U', 'N') && buffer [1] == MAKE_MARKER ('D', ' ', 'S', 'A'))
2290                 return 0 ;
2291
2292         if (buffer [0] == MAKE_MARKER ('S', 'Y', '8', '0') || buffer [0] == MAKE_MARKER ('S', 'Y', '8', '5'))
2293                 return 0 ;
2294
2295         if (buffer [0] == MAKE_MARKER ('a', 'j', 'k', 'g'))
2296                 return 0 /*-SF_FORMAT_SHN-*/ ;
2297
2298         if (buffer [0] == MAKE_MARKER ('2', 'B', 'I', 'T'))
2299                 return SF_FORMAT_AVR ;
2300
2301         /* This must be the second last one. */
2302         if (psf->filelength > 0 && (format = try_resource_fork (psf, SFM_READ)) != 0)
2303                 return format ;
2304
2305         return 0 ;
2306 } /* guess_file_type */
2307
2308
2309 static int
2310 validate_sfinfo (SF_INFO *sfinfo)
2311 {       if (sfinfo->samplerate < 1)
2312                 return 0 ;
2313         if (sfinfo->frames < 0)
2314                 return 0 ;
2315         if (sfinfo->channels < 1)
2316                 return 0 ;
2317         if ((sfinfo->format & SF_FORMAT_TYPEMASK) == 0)
2318                 return 0 ;
2319         if ((sfinfo->format & SF_FORMAT_SUBMASK) == 0)
2320                 return 0 ;
2321         if (sfinfo->sections < 1)
2322                 return 0 ;
2323         return 1 ;
2324 } /* validate_sfinfo */
2325
2326 static int
2327 validate_psf (SF_PRIVATE *psf)
2328 {
2329         if (psf->datalength < 0)
2330         {       psf_log_printf (psf, "Invalid SF_PRIVATE field : datalength == %D.\n", psf->datalength) ;
2331                 return 0 ;
2332                 } ;
2333         if (psf->dataoffset < 0)
2334         {       psf_log_printf (psf, "Invalid SF_PRIVATE field : dataoffset == %D.\n", psf->dataoffset) ;
2335                 return 0 ;
2336                 } ;
2337         if (psf->blockwidth && psf->blockwidth != psf->sf.channels * psf->bytewidth)
2338         {       psf_log_printf (psf, "Invalid SF_PRIVATE field : channels * bytewidth == %d.\n",
2339                                                                 psf->sf.channels * psf->bytewidth) ;
2340                 return 0 ;
2341                 } ;
2342         return 1 ;
2343 } /* validate_psf */
2344
2345 static void
2346 save_header_info (SF_PRIVATE *psf)
2347 {       LSF_SNPRINTF (sf_logbuffer, sizeof (sf_logbuffer), "%s", psf->logbuffer) ;
2348 } /* save_header_info */
2349
2350 static void
2351 copy_filename (SF_PRIVATE *psf, const char *path)
2352 {       const char *ccptr ;
2353         char *cptr ;
2354
2355         LSF_SNPRINTF (psf->filepath, sizeof (psf->filepath), "%s", path) ;
2356         if ((ccptr = strrchr (path, '/')) || (ccptr = strrchr (path, '\\')))
2357                 ccptr ++ ;
2358         else
2359                 ccptr = path ;
2360
2361         LSF_SNPRINTF (psf->filename, sizeof (psf->filename), "%s", ccptr) ;
2362
2363         /* Now grab the directory. */
2364         LSF_SNPRINTF (psf->directory, sizeof (psf->directory), "%s", path) ;
2365         if ((cptr = strrchr (psf->directory, '/')) || (cptr = strrchr (psf->directory, '\\')))
2366                 cptr [1] = 0 ;
2367         else
2368                 psf->directory [0] = 0 ;
2369
2370         return ;
2371 } /* copy_filename */
2372
2373 /*==============================================================================
2374 */
2375
2376 static int
2377 psf_close (SF_PRIVATE *psf)
2378 {       int     error ;
2379
2380         if (psf->codec_close)
2381                 error = psf->codec_close (psf) ;
2382         if (psf->container_close)
2383                 error = psf->container_close (psf) ;
2384
2385         psf_fclose (psf) ;
2386         psf_close_rsrc (psf) ;
2387
2388         if (psf->fdata)
2389                 free (psf->fdata) ;
2390
2391         if (psf->interleave)
2392                 free (psf->interleave) ;
2393
2394         if (psf->dither)
2395                 free (psf->dither) ;
2396
2397         if (psf->peak_info)
2398                 free (psf->peak_info) ;
2399
2400         if (psf->broadcast_info)
2401                 free (psf->broadcast_info) ;
2402
2403         if (psf->loop_info)
2404                 free (psf->loop_info) ;
2405
2406         if (psf->instrument)
2407                 free (psf->instrument) ;
2408
2409         if (psf->format_desc)
2410         {       memset (psf->format_desc, 0, strlen (psf->format_desc)) ;
2411                 free (psf->format_desc) ;
2412                 } ;
2413
2414         memset (psf, 0, sizeof (SF_PRIVATE)) ;
2415         free (psf) ;
2416
2417         return 0 ;
2418 } /* psf_close */
2419
2420 static int
2421 psf_open_file (SF_PRIVATE *psf, int mode, SF_INFO *sfinfo)
2422 {       int             error, format ;
2423
2424         if (mode != SFM_READ && mode != SFM_WRITE && mode != SFM_RDWR)
2425                 return SFE_BAD_OPEN_MODE ;
2426
2427         if (sfinfo == NULL)
2428                 return SFE_BAD_SF_INFO_PTR ;
2429
2430         /* Zero out these fields. */
2431         sfinfo->frames = 0 ;
2432         sfinfo->sections = 0 ;
2433         sfinfo->seekable = 0 ;
2434
2435         if (mode == SFM_READ)
2436         {       if ((sfinfo->format & SF_FORMAT_TYPEMASK) == SF_FORMAT_RAW)
2437                 {       if (sf_format_check (sfinfo) == 0)
2438                                 return SFE_RAW_BAD_FORMAT ;
2439                         }
2440                 else
2441                         memset (sfinfo, 0, sizeof (SF_INFO)) ;
2442                 } ;
2443
2444         sf_errno = error = 0 ;
2445         sf_logbuffer [0] = 0 ;
2446
2447         memcpy (&(psf->sf), sfinfo, sizeof (SF_INFO)) ;
2448
2449         psf->Magick             = SNDFILE_MAGICK ;
2450         psf->norm_float         = SF_TRUE ;
2451         psf->norm_double        = SF_TRUE ;
2452         psf->mode                       = mode ;
2453         psf->dataoffset         = -1 ;
2454         psf->datalength         = -1 ;
2455         psf->read_current       = -1 ;
2456         psf->write_current      = -1 ;
2457         psf->auto_header        = SF_FALSE ;
2458         psf->rwf_endian         = SF_ENDIAN_LITTLE ;
2459         psf->seek                       = psf_default_seek ;
2460         psf->float_int_mult = 0 ;
2461         psf->float_max          = -1.0 ;
2462
2463         psf->sf.sections = 1 ;
2464
2465         psf->is_pipe = psf_is_pipe (psf) ;
2466
2467         if (psf->is_pipe)
2468         {       psf->sf.seekable = SF_FALSE ;
2469                 psf->filelength = SF_COUNT_MAX ;
2470                 }
2471         else
2472         {       psf->sf.seekable = SF_TRUE ;
2473
2474                 /* File is open, so get the length. */
2475                 psf->filelength = psf_get_filelen (psf) ;
2476                 } ;
2477
2478         if (psf->fileoffset > 0)
2479         {       switch (psf->mode)
2480                 {       case SFM_READ :
2481                                 if (psf->filelength < 44)
2482                                 {       psf_log_printf (psf, "Short filelength: %D (fileoffset: %D)\n", psf->filelength, psf->fileoffset) ;
2483                                         return SFE_BAD_OFFSET ;
2484                                         } ;
2485                                 break ;
2486
2487                         case SFM_WRITE :
2488                                 psf->fileoffset = 0 ;
2489                                 psf_fseek (psf, 0, SEEK_END) ;
2490                                 psf->fileoffset = psf_ftell (psf) ;
2491                                 break ;
2492
2493                         case SFM_RDWR :
2494                                 return SFE_NO_EMBEDDED_RDWR ;
2495                         } ;
2496
2497                 psf_log_printf (psf, "Embedded file offset : %D\n", psf->fileoffset) ;
2498                 } ;
2499
2500         if (psf->filelength == SF_COUNT_MAX)
2501                 psf_log_printf (psf, "Length : unknown\n") ;
2502         else
2503                 psf_log_printf (psf, "Length : %D\n", psf->filelength) ;
2504
2505         if (mode == SFM_WRITE || (mode == SFM_RDWR && psf->filelength == 0))
2506         {       /* If the file is being opened for write or RDWR and the file is currently
2507                 ** empty, then the SF_INFO struct must contain valid data.
2508                 */
2509                 if (sf_format_check (&(psf->sf)) == 0)
2510                         return SFE_BAD_OPEN_FORMAT ;
2511                 }
2512         else if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RAW)
2513         {       /* If type RAW has not been specified then need to figure out file type. */
2514                 psf->sf.format = guess_file_type (psf) ;
2515
2516                 if (psf->sf.format == 0)
2517                         psf->sf.format = format_from_extension (psf) ;
2518                 } ;
2519
2520         /* Prevent unnecessary seeks */
2521         psf->last_op = psf->mode ;
2522
2523         /* Set bytewidth if known. */
2524         switch (psf->sf.format & SF_FORMAT_SUBMASK)
2525         {       case SF_FORMAT_PCM_S8 :
2526                 case SF_FORMAT_PCM_U8 :
2527                 case SF_FORMAT_ULAW :
2528                 case SF_FORMAT_ALAW :
2529                 case SF_FORMAT_DPCM_8 :
2530                                 psf->bytewidth = 1 ;
2531                                 break ;
2532
2533                 case SF_FORMAT_PCM_16 :
2534                 case SF_FORMAT_DPCM_16 :
2535                                 psf->bytewidth = 2 ;
2536                                 break ;
2537
2538                 case SF_FORMAT_PCM_24 :
2539                                 psf->bytewidth = 3 ;
2540                                 break ;
2541
2542                 case SF_FORMAT_PCM_32 :
2543                 case SF_FORMAT_FLOAT :
2544                                 psf->bytewidth = 4 ;
2545                                 break ;
2546
2547                 case SF_FORMAT_DOUBLE :
2548                                 psf->bytewidth = 8 ;
2549                                 break ;
2550                 } ;
2551
2552         /* Call the initialisation function for the relevant file type. */
2553         switch (psf->sf.format & SF_FORMAT_TYPEMASK)
2554         {       case    SF_FORMAT_WAV :
2555                 case    SF_FORMAT_WAVEX :
2556                                 error = wav_open (psf) ;
2557                                 break ;
2558
2559                 case    SF_FORMAT_AIFF :
2560                                 error = aiff_open (psf) ;
2561                                 break ;
2562
2563                 case    SF_FORMAT_AU :
2564                                 error = au_open (psf) ;
2565                                 break ;
2566
2567                 case    SF_FORMAT_RAW :
2568                                 error = raw_open (psf) ;
2569                                 break ;
2570
2571                 case    SF_FORMAT_W64 :
2572                                 error = w64_open (psf) ;
2573                                 break ;
2574
2575                 /* Lite remove start */
2576                 case    SF_FORMAT_PAF :
2577                                 error = paf_open (psf) ;
2578                                 break ;
2579
2580                 case    SF_FORMAT_SVX :
2581                                 error = svx_open (psf) ;
2582                                 break ;
2583
2584                 case    SF_FORMAT_NIST :
2585                                 error = nist_open (psf) ;
2586                                 break ;
2587
2588                 case    SF_FORMAT_IRCAM :
2589                                 error = ircam_open (psf) ;
2590                                 break ;
2591
2592                 case    SF_FORMAT_VOC :
2593                                 error = voc_open (psf) ;
2594                                 break ;
2595
2596                 case    SF_FORMAT_SDS :
2597                                 error = sds_open (psf) ;
2598                                 break ;
2599
2600                 case    SF_FORMAT_OGG :
2601                                 error = ogg_open (psf) ;
2602                                 break ;
2603
2604                 case    SF_FORMAT_TXW :
2605                                 error = txw_open (psf) ;
2606                                 break ;
2607
2608                 case    SF_FORMAT_WVE :
2609                                 error = wve_open (psf) ;
2610                                 break ;
2611
2612                 case    SF_FORMAT_DWD :
2613                                 error = dwd_open (psf) ;
2614                                 break ;
2615
2616                 case    SF_FORMAT_MAT4 :
2617                                 error = mat4_open (psf) ;
2618                                 break ;
2619
2620                 case    SF_FORMAT_MAT5 :
2621                                 error = mat5_open (psf) ;
2622                                 break ;
2623
2624                 case    SF_FORMAT_PVF :
2625                                 error = pvf_open (psf) ;
2626                                 break ;
2627
2628                 case    SF_FORMAT_XI :
2629                                 error = xi_open (psf) ;
2630                                 break ;
2631
2632                 case    SF_FORMAT_HTK :
2633                                 error = htk_open (psf) ;
2634                                 break ;
2635
2636                 case    SF_FORMAT_SD2 :
2637                                 error = sd2_open (psf) ;
2638                                 break ;
2639
2640                 case    SF_FORMAT_REX2 :
2641                                 error = rx2_open (psf) ;
2642                                 break ;
2643
2644                 case    SF_FORMAT_AVR :
2645                                 error = avr_open (psf) ;
2646                                 break ;
2647
2648                 case    SF_FORMAT_FLAC :
2649                                 error = flac_open (psf) ;
2650                                 break ;
2651
2652                 case    SF_FORMAT_CAF :
2653                                 error = caf_open (psf) ;
2654                                 break ;
2655
2656                 /* Lite remove end */
2657
2658                 default :
2659                                 error = SFE_UNKNOWN_FORMAT ;
2660                 } ;
2661
2662         if (error)
2663         {       if (error != SF_ERR_SYSTEM && error != SF_ERR_UNSUPPORTED_ENCODING)
2664                 {       psf_log_printf (psf, "Parse error : %s\n", sf_error_number (error)) ;
2665                         error = SF_ERR_MALFORMED_FILE ;
2666                         } ;
2667
2668                 return error ;
2669                 } ;
2670
2671         /* For now, check whether embedding is supported. */
2672         format = psf->sf.format & SF_FORMAT_TYPEMASK ;
2673         if (psf->fileoffset > 0 &&
2674                         (format != SF_FORMAT_WAV) && (format != SF_FORMAT_WAVEX) &&
2675                         (format != SF_FORMAT_AIFF) && (format != SF_FORMAT_AU)
2676                         )
2677                 return SFE_NO_EMBED_SUPPORT ;
2678
2679         if (psf->fileoffset > 0)
2680                 psf_log_printf (psf, "Embedded file length : %D\n", psf->filelength) ;
2681
2682         if (mode == SFM_RDWR && sf_format_check (&(psf->sf)) == 0)
2683                 return SFE_BAD_RDWR_FORMAT ;
2684
2685         if (validate_sfinfo (&(psf->sf)) == 0)
2686         {       psf_log_SF_INFO (psf) ;
2687                 save_header_info (psf) ;
2688                 return SFE_BAD_SF_INFO ;
2689                 } ;
2690
2691         if (validate_psf (psf) == 0)
2692         {       save_header_info (psf) ;
2693                 return SFE_INTERNAL ;
2694                 } ;
2695
2696         psf->read_current = 0 ;
2697         psf->write_current = (psf->mode == SFM_RDWR) ? psf->sf.frames : 0 ;
2698
2699         memcpy (sfinfo, &(psf->sf), sizeof (SF_INFO)) ;
2700
2701         return 0 ;
2702 } /* psf_open_file */
2703
2704 /*
2705 ** Do not edit or modify anything in this comment block.
2706 ** The arch-tag line is a file identity tag for the GNU Arch
2707 ** revision control system.
2708 **
2709 ** arch-tag: cd4f9e91-a8ec-4154-9bf6-fe4b8c69a615
2710 */