src/sndfile.c

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