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