开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
sndfile.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：33k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

sndfile.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2000 Erik de Castro Lopo <erikd@zip.com.au>
  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. */
  19. #include <stdio.h>
  20. #include <unistd.h>
  21. #include <fcntl.h>
  22. #include <string.h>
  23. #include <ctype.h>
  25. /* For the Metrowerks CodeWarrior Pro Compiler (mainly MacOS) */
  27. #if (defined (__MWERKS__))
  28. #include <stat.h>
  29. #else
  30. #include <sys/stat.h>
  31. #endif
  33. #include "sndfile.h"
  34. #include "config.h"
  35. #include "sfendian.h"
  36. #include "common.h"
  38. #if (CPU_IS_LITTLE_ENDIAN == 1)
  39. # define MAKE_MARKER(a,b,c,d) ((a)|((b)<<8)|((c)<<16)|((d)<<24))
  40. #elif (CPU_IS_BIG_ENDIAN == 1)
  41. # define MAKE_MARKER(a,b,c,d) (((a)<<24)|((b)<<16)|((c)<<8)|(d))
  42. #else
  43. # error "Cannot determine endian-ness of processor."
  44. #endif
  46. #define SNDFILE_MAGICK 0x1234C0DE
  48. typedef struct
  49. { int  error ;
  50. char *str ;
  51. } ErrorStruct ;
  53. static
  54. ErrorStruct SndfileErrors [] = 
  55. { 
  56. { SFE_NO_ERROR , "No Error." },
  57. { SFE_BAD_FILE , "File does not exist or is not a regular file (possibly a pipe?)." },
  58. { SFE_OPEN_FAILED , "Could not open file." },
  59. { SFE_BAD_OPEN_FORMAT , "Bad format specified for file open." },
  60. { SFE_BAD_SNDFILE_PTR , "Not a valid SNDFILE* pointer." },
  61. { SFE_BAD_SF_INFO_PTR , "NULL SF_INFO pointer passed to libsndfile." },
  62. { SFE_BAD_INT_FD , "Bad file descriptor." },
  63. { SFE_BAD_INT_PTR , "Internal error, Bad pointer." },
  64. { SFE_MALLOC_FAILED , "Internal malloc () failed." },
  65. { SFE_BAD_SEEK , "Internal fseek() failed." },
  66. { SFE_NOT_SEEKABLE , "Seek attempted on unseekable file type." },
  67. { SFE_UNIMPLEMENTED , "File contains data in an unimplemented format." },
  68. { SFE_BAD_READ_ALIGN   , "Attempt to read a non-integer number of channels." },
  69. { SFE_BAD_WRITE_ALIGN  , "Attempt to write a non-integer number of channels." },
  70. { SFE_UNKNOWN_FORMAT , "File contains data in an unknown format." },
  71. { SFE_NOT_READMODE , "Read attempted on file currently open for write." },
  72. { SFE_NOT_WRITEMODE , "Write attempted on file currently open for read." },
  73. { SFE_BAD_MODE_RW , "This file format does not support read/write mode." },
  74. { SFE_BAD_SF_INFO , "Internal error : SF_INFO struct incomplete." },
  76. { SFE_SHORT_READ , "Short read error." },
  77. { SFE_SHORT_WRITE , "Short write error." },
  78. { SFE_INTERNAL , "Unspecified internal error." },
  80. { SFE_WAV_NO_RIFF , "Error in WAV file. No 'RIFF' chunk marker." },
  81. { SFE_WAV_NO_WAVE , "Error in WAV file. No 'WAVE' chunk marker." },
  82. { SFE_WAV_NO_FMT , "Error in WAV file. No 'fmt ' chunk marker." },
  83. { SFE_WAV_FMT_SHORT , "Error in WAV file. Short 'fmt ' chunk." },
  85. { SFE_WAV_FMT_TOO_BIG , "Error in WAV file. 'fmt ' chunk too large." },
  87. { SFE_WAV_BAD_FORMAT , "Error in WAV file. Errors in 'fmt ' chunk." },
  88. { SFE_WAV_BAD_BLOCKALIGN , "Error in WAV file. Block alignment in 'fmt ' chunk is incorrect." },
  89. { SFE_WAV_NO_DATA , "Error in WAV file. No 'data' chunk marker." },
  90. { SFE_WAV_UNKNOWN_CHUNK , "Error in WAV file. File contains an unknown chunk marker." },
  92. { SFE_WAV_ADPCM_NOT4BIT , "Error in ADPCM WAV file. Invalid bit width."},
  93. { SFE_WAV_ADPCM_CHANNELS , "Error in ADPCM WAV file. Invalid number of channels."},
  94. { SFE_WAV_GSM610_FORMAT , "Error in GSM610 WAV file. Invalid format chunk."},
  95.   
  96. { SFE_AIFF_NO_FORM , "Error in AIFF file, bad 'FORM' marker."},
  97. { SFE_AIFF_UNKNOWN_CHUNK , "Error in AIFF file, unknown chunk."},
  98. { SFE_COMM_CHUNK_SIZE , "Error in AIFF file, bad 'COMM' chunk size."},
  99. { SFE_AIFF_NO_SSND , "Error in AIFF file, bad 'SSND' chunk."},
  100. { SFE_AIFF_NO_DATA , "Error in AIFF file, no sound data."},
  102. { SFE_AU_UNKNOWN_FORMAT , "Error in AU file, unknown format."},
  103. { SFE_AU_NO_DOTSND , "Error in AU file, missing '.snd' or 'dns.' marker."},
  105. { SFE_RAW_READ_BAD_SPEC , "Error while opening RAW file for read. Must specify format, pcmbitwidth and channels."},
  106. { SFE_RAW_BAD_BITWIDTH , "Error. RAW file bitwidth must be a multiple of 8."},
  108. { SFE_PAF_NO_MARKER , "Error in PAF file, no marker."},
  109. { SFE_PAF_VERSION , "Error in PAF file, bad version."}, 
  110. { SFE_PAF_UNKNOWN_FORMAT , "Error in PAF file, unknown format."}, 
  111. { SFE_PAF_SHORT_HEADER , "Error in PAF file. File shorter than minimal header."},
  113. { SFE_SVX_NO_FORM , "Error in 8SVX / 16SV file, no 'FORM' marker."}, 
  114. { SFE_SVX_NO_BODY , "Error in 8SVX / 16SV file, no 'BODY' marker."}, 
  115. { SFE_SVX_NO_DATA , "Error in 8SVX / 16SV file, no sound data."},
  116. { SFE_SVX_BAD_COMP , "Error in 8SVX / 16SV file, unsupported compression format."},
  118. { SFE_NIST_BAD_HEADER , "Error in NIST file, bad header."},
  119. { SFE_NIST_BAD_ENCODING , "Error in NIST file, unsupported compression format."},
  121. { SFE_MAX_ERROR , "Maximum error number." }
  122. } ;
  124. /*------------------------------------------------------------------------------
  125. ** Private (static) variables.
  126. */
  128. static int sf_errno = 0 ;
  129. static char sf_strbuffer [SF_BUFFER_LEN] = { 0 } ;
  131. /*------------------------------------------------------------------------------
  132. ** Private static functions.
  133. */
  136. #define VALIDATE_SNDFILE_AND_ASSIGN_PSF(a,b)
  137. { if (! (a))
  138. return SFE_BAD_SNDFILE_PTR ;
  139. (b) = (SF_PRIVATE*) (a) ;
  140. if (!((b)->file))
  141. return SFE_BAD_INT_FD ;
  142. if ((b)->Magick != SNDFILE_MAGICK)
  143. return SFE_BAD_SNDFILE_PTR ;
  144. (b)->error = 0 ;
  145. } 
  147. static
  148. int does_extension_match (const char *ext, const char *test)
  149. { char c1, c2 ;
  151. if ((! ext) || (! test))
  152. return 0 ;
  154. if (strlen (ext) != strlen (test))
  155. return 0 ;
  157. while (*ext && *test)
  158. { c1 = tolower (*ext) ;
  159. c2 = tolower (*test) ;
  160. if (c1 > c2)
  161. return 0 ;
  162. if (c1 < c2)
  163. return 0 ;
  164. ext ++ ;
  165. test ++ ;
  166. } 
  168. return 1 ;
  169. } /* does_extension_match */
  171. static
  172. int is_au_snd_file (const char *filename)
  173. { const char *cptr ;
  175. if (! (cptr = strrchr (filename, '.')))
  176. return 0 ;
  177. cptr ++ ;
  179. if (does_extension_match (cptr, "au"))
  180. return 1 ;
  182. if (does_extension_match (cptr, "snd"))
  183. return 1 ;
  185. return 0 ;
  186. } /* is_au_snd_file */
  188. static
  189. int guess_file_type (FILE *file, const char *filename)
  190. { unsigned int buffer [3] ;
  192. fread (buffer, sizeof(buffer), 1, file) ;
  193. fseek (file, 0, SEEK_SET) ;
  195. if (buffer [0] == MAKE_MARKER ('R','I','F','F') && buffer [2] == MAKE_MARKER ('W','A','V','E'))
  196. return SF_FORMAT_WAV ;
  198. if (buffer [0] == MAKE_MARKER ('F','O','R','M'))
  199. { if (buffer [2] == MAKE_MARKER ('A','I','F','F') || buffer [2] == MAKE_MARKER ('A','I','F','C'))
  200. return SF_FORMAT_AIFF ;
  201. if (buffer [2] == MAKE_MARKER ('8','S','V','X') || buffer [2] == MAKE_MARKER ('1','6','S','V'))
  202. return SF_FORMAT_SVX ;
  203. return 0 ;
  204. } ;
  206. if ((buffer [0] == MAKE_MARKER ('.','s','n','d') || buffer [0] == MAKE_MARKER ('d','n','s','.')))
  207. return SF_FORMAT_AU ;
  209. if ((buffer [0] == MAKE_MARKER ('f','a','p',' ') || buffer [0] == MAKE_MARKER (' ','p','a','f')))
  210. return SF_FORMAT_PAF ;
  212. if (buffer [0] == MAKE_MARKER ('N','I','S','T'))
  213. return SF_FORMAT_NIST ;
  215. if (filename && is_au_snd_file (filename))
  216. return SF_FORMAT_AU | SF_FORMAT_ULAW ;
  218. /* Default to header-less RAW PCM file type. */
  219. return SF_FORMAT_RAW ;
  220. } /* guess_file_type */
  223. static
  224. int validate_sfinfo (SF_INFO *sfinfo)
  225. { if (! sfinfo->samplerate)
  226. return 0 ;
  227. if (! sfinfo->samples && (sfinfo->format & SF_FORMAT_SUBMASK != SF_FORCE_OPEN) ) //or
  228. return 0 ;
  229. if (! sfinfo->channels)
  230. return 0 ;
  231. if (! sfinfo->pcmbitwidth && (sfinfo->format & SF_FORMAT_SUBMASK != SF_FORCE_OPEN) ) //or
  232. return 0 ;
  233. if (! sfinfo->format & SF_FORMAT_TYPEMASK)
  234. return 0 ;
  235. if (! sfinfo->format & SF_FORMAT_SUBMASK)
  236. return 0 ;
  237. if (! sfinfo->sections)
  238. return 0 ;
  239. return 1 ;
  240. } /* validate_sfinfo */
  242. static
  243. int validate_psf (SF_PRIVATE *psf)
  244. {
  245. if (! psf->blockwidth && (psf->sf.format & SF_FORMAT_SUBMASK != SF_FORCE_OPEN) ) //or
  246. return 0 ;
  247. if (! psf->bytewidth && (psf->sf.format & SF_FORMAT_SUBMASK != SF_FORCE_OPEN)  ) //or
  248. return 0 ;
  249. if (! psf->datalength )
  250. return 0 ;
  251. if (psf->blockwidth != psf->sf.channels * psf->bytewidth)
  252. return 0 ;
  253. return 1 ;
  254. } /* validate_psf */
  256. static
  257. void save_header_info (SF_PRIVATE *psf)
  258. { memset (sf_strbuffer, 0, sizeof (sf_strbuffer)) ;
  259. strcpy (sf_strbuffer, psf->strbuffer) ;
  260. } /* validate_psf */
  262. static
  263. void copy_filename (SF_PRIVATE *psf, const char *path)
  264. { const char *cptr ;
  266. if ((cptr = strrchr (path, '/')) || (cptr = strrchr (path, '\')))
  267. cptr ++ ;
  268. else
  269. cptr = path ;
  271. memset (psf->filename, 0, SF_FILENAME_LEN) ;
  272. strncpy (psf->filename, cptr, SF_FILENAME_LEN - 1) ;
  273. psf->filename [SF_FILENAME_LEN - 1] = 0 ;
  274. } /* copy_filename */
  276. /*------------------------------------------------------------------------------
  277. ** Public functions.
  278. */
  280. SNDFILE*  sf_open_read (const char *path, SF_INFO *sfinfo)
  281. { SF_PRIVATE  *psf ;
  282. int filetype, seekable ;
  284. if (! sfinfo)
  285. { sf_errno = SFE_BAD_SF_INFO_PTR ;
  286. return NULL ;
  287. } ;
  289. sf_errno = 0 ;
  290. sf_strbuffer [0] = 0 ;
  292. psf = malloc (sizeof (SF_PRIVATE)) ; 
  293. if (! psf)
  294. { sf_errno = SFE_MALLOC_FAILED ;
  295. return NULL ;
  296. } ;
  298. memset (psf, 0, sizeof (SF_PRIVATE)) ;
  299. psf->Magick = SNDFILE_MAGICK ;
  301. if (! strcmp (path, "-"))
  302. { psf->file = stdin ;
  303. seekable = SF_FALSE ;
  304. }
  305. else
  306. { /* fopen with 'b' means binary file mode for Win32 systems. */
  307. psf->file = fopen (path, "rb") ;
  308. seekable = SF_TRUE ;
  309. } ;
  310.  
  311. if (! psf->file) 
  312. { sf_errno = SFE_OPEN_FAILED ;
  313. sf_close (psf) ;
  314. return NULL ;
  315. } ;
  317. psf->mode = SF_MODE_READ ;
  319. psf_sprintf (psf, "%sn", path) ;
  320. if (seekable)
  321. { fseek (psf->file, 0, SEEK_END) ;
  322. psf->filelength = ftell (psf->file) ;
  323. fseek (psf->file, 0, SEEK_SET) ;
  324. psf_sprintf (psf, "size : %dn", psf->filelength) ;
  325. }
  326. else
  327. psf->filelength = 2048 ;
  329. copy_filename (psf, path) ;
  331. filetype = guess_file_type (psf->file, psf->filename) ;
  332. fseek (psf->file, 0, SEEK_SET) ;
  334. //or
  335. memcpy (&(psf->sf), sfinfo, sizeof (SF_INFO)) ;
  336. // end or
  337. switch (filetype)
  338. { case SF_FORMAT_WAV :
  339. sf_errno = wav_open_read (psf) ;
  340. break ;
  342. case SF_FORMAT_AIFF :
  343. sf_errno = aiff_open_read (psf) ;
  344. break ;
  346. case SF_FORMAT_AU :
  347. sf_errno = au_open_read (psf) ;
  348. break ;
  350. case SF_FORMAT_AU | SF_FORMAT_ULAW :
  351. psf_sprintf (psf, "Headers-less u-law encoded file.n") ;
  352. sf_errno = au_nh_open_read (psf) ;
  353. break ;
  355. case SF_FORMAT_RAW :
  356. /* For RAW files, need the sfinfo struct data to
  357. ** figure out the bitwidth, endian-ness etc.
  358. */
  359. memcpy (&(psf->sf), sfinfo, sizeof (SF_INFO)) ;
  360. sf_errno = raw_open_read (psf) ;
  361. break ;
  363. case SF_FORMAT_PAF :
  364. sf_errno = paf_open_read (psf) ;
  365. break ;
  367. case SF_FORMAT_SVX :
  368. sf_errno = svx_open_read (psf) ;
  369. break ;
  371. default :
  372. sf_errno = SFE_UNKNOWN_FORMAT ;
  373. } ;
  375. /* Both the file format and the file must be seekable to enable sf_seek(). */
  376. psf->sf.seekable = (psf->sf.seekable && seekable) ? SF_TRUE : SF_FALSE ;
  377. if (sf_errno)
  378. { save_header_info (psf) ;
  379. sf_close (psf) ;
  380. return NULL ;
  381. } ;
  383. if (! validate_sfinfo (&(psf->sf)))
  384. { save_header_info (psf) ;
  385. sf_errno = SFE_BAD_SF_INFO ;
  386. sf_close (psf) ;
  387. return NULL ;
  388. } ;
  390. if (! validate_psf (psf))
  391. { save_header_info (psf) ;
  392. sf_errno = SFE_INTERNAL ;
  393. sf_close (psf) ;
  394. return NULL ;
  395. } ;
  397. memcpy (sfinfo, &(psf->sf), sizeof (SF_INFO)) ;
  399. return (SNDFILE*) psf ;
  400. } /* sf_open_read */
  402. /*------------------------------------------------------------------------------
  403. */
  405. SNDFILE*  sf_open_write (const char *path, const SF_INFO *sfinfo)
  406. { SF_PRIVATE  *psf ;
  407. if (! sfinfo)
  408. { sf_errno = SFE_BAD_SF_INFO_PTR ;
  409. return NULL ;
  410. } ;
  412. if (! sf_format_check (sfinfo))
  413. { sf_errno = SFE_BAD_OPEN_FORMAT ;
  414. return NULL ;
  415. } ;
  417. sf_errno = 0 ;
  418. sf_strbuffer [0] = 0 ;
  420. psf = malloc (sizeof (SF_PRIVATE)) ; 
  421. if (! psf)
  422. { sf_errno = SFE_MALLOC_FAILED ;
  423. return NULL ;
  424. } ;
  426. memset (psf, 0, sizeof (SF_PRIVATE)) ;
  427. memcpy (&(psf->sf), sfinfo, sizeof (SF_INFO)) ;
  429. psf->Magick = SNDFILE_MAGICK ;
  431. /* fopen with 'b' means binary file mode for Win32 systems. */
  433. if (! (psf->file = fopen (path, "wb")))
  434. { sf_errno = SFE_OPEN_FAILED ;
  435. sf_close (psf) ;
  436. return NULL ;
  437. } ;
  439. psf->mode = SF_MODE_WRITE ;
  441. psf->filelength = ftell (psf->file) ;
  442. fseek (psf->file, 0, SEEK_SET) ;
  444. copy_filename (psf, path) ;
  446. switch (sfinfo->format & SF_FORMAT_TYPEMASK)
  447. { case SF_FORMAT_WAV :
  448. if ((sf_errno = wav_open_write (psf)))
  449. { sf_close (psf) ;
  450. return NULL ;
  451. } ;
  452. break ;
  454. case SF_FORMAT_AIFF :
  455. if ((sf_errno = aiff_open_write (psf)))
  456. { sf_close (psf) ;
  457. return NULL ;
  458. } ;
  459. break ;
  461. case SF_FORMAT_AU :
  462. case SF_FORMAT_AULE :
  463. if ((sf_errno = au_open_write (psf)))
  464. { sf_close (psf) ;
  466. return NULL ;
  467. } ;
  468. break ;
  470. case    SF_FORMAT_RAW :
  471. if ((sf_errno = raw_open_write (psf)))
  472. { sf_close (psf) ;
  473. return NULL ;
  474. } ;
  475. break ;
  477. case    SF_FORMAT_PAF :
  478. if ((sf_errno = paf_open_write (psf)))
  479. { sf_close (psf) ;
  480. return NULL ;
  481. } ;
  482. break ;
  484. case    SF_FORMAT_SVX :
  485. if ((sf_errno = svx_open_write (psf)))
  486. { sf_close (psf) ;
  487. return NULL ;
  488. } ;
  489. break ;
  491. default :
  492. sf_errno = SFE_UNKNOWN_FORMAT ;
  493. sf_close (psf) ;
  494. return NULL ;
  495. } ;
  497. return (SNDFILE*) psf ;
  498. } /* sf_open_write */
  500. /*------------------------------------------------------------------------------
  501. */
  503. int sf_perror (SNDFILE *sndfile)
  504. { SF_PRIVATE  *psf ;
  505. int  k, errnum ;
  507. if (! sndfile)
  508. { errnum = sf_errno ;
  509. }
  510. else
  511. { VALIDATE_SNDFILE_AND_ASSIGN_PSF(sndfile,psf) ;
  512. errnum = psf->error ;
  513. } ;
  515. errnum = (errnum >= SFE_MAX_ERROR || errnum < 0) ? 0 : errnum ;
  517. for (k = 0 ; SndfileErrors[k].str ; k++)
  518. if (errnum == SndfileErrors[k].error)
  519. { printf ("%sn", SndfileErrors[k].str) ;
  520. return SFE_NO_ERROR ;
  521. } ;
  523. printf ("No error string for error number %d.n", errnum) ;
  524. return SFE_NO_ERROR ;
  525. } /* sf_perror */
  527. /*------------------------------------------------------------------------------
  528. */
  530. int sf_set_bytewidth(SNDFILE *sndfile, SF_INFO* sfinfo)
  531. {   
  532.     SF_PRIVATE  *psf ;
  533.     VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  534.     psf->sf.pcmbitwidth=sfinfo->pcmbitwidth;
  535.     psf->sf.bytewidth=sfinfo->bytewidth;
  536.     psf->bytewidth=sfinfo->bytewidth;
  537.     psf->blockwidth = psf->sf.channels * psf->bytewidth ;
  538.     if ( psf->blockwidth)
  539. psf->sf.samples = psf->datalength / psf->blockwidth ;
  540.     sfinfo->samples=psf->sf.samples;
  541.     return 0;    
  542. }
  544. /*------------------------------------------------------------------------------
  545. */
  547. int sf_error_str (SNDFILE *sndfile, char *str, size_t maxlen)
  548. { SF_PRIVATE  *psf ;
  549. int  errnum, k ;
  551. if (! sndfile)
  552. { errnum = sf_errno ;
  553. }
  554. else
  555. { VALIDATE_SNDFILE_AND_ASSIGN_PSF(sndfile,psf) ;
  556. errnum = psf->error ;
  557. } ;
  559. errnum = (errnum >= SFE_MAX_ERROR || errnum < 0) ? 0 : errnum ;
  561. for (k = 0 ; SndfileErrors[k].str ; k++)
  562. if (errnum == SndfileErrors[k].error)
  563. { strncpy (str, SndfileErrors [errnum].str, maxlen) ;
  564. str [maxlen-1] = 0 ;
  565. return SFE_NO_ERROR ;
  566. } ;
  568. strncpy (str, "No error defined for this error number. This is a bug in libsndfile.", maxlen) ;
  569. str [maxlen-1] = 0 ;
  571. return SFE_NO_ERROR ;
  572. } /* sf_error_str */
  574. /*------------------------------------------------------------------------------
  575. */
  577. int sf_error_number (int errnum, char *str, size_t maxlen)
  578. { int  k ;
  580. errnum = (errnum >= SFE_MAX_ERROR || errnum < 0) ? 0 : errnum ;
  582. for (k = 0 ; SndfileErrors[k].str ; k++)
  583. if (errnum == SndfileErrors[k].error)
  584. { strncpy (str, SndfileErrors [errnum].str, maxlen) ;
  585. str [maxlen-1] = 0 ;
  586. return SFE_NO_ERROR ;
  587. } ;
  589. strncpy (str, "No error defined for this error number. This is a bug in libsndfile.", maxlen) ;
  590. str [maxlen-1] = 0 ;
  592. return SFE_NO_ERROR ;
  593. } /* sf_error_number */
  595. /*------------------------------------------------------------------------------
  596. */
  598. int sf_format_check (const SF_INFO *info)
  599. { int subformat = info->format & SF_FORMAT_SUBMASK ;
  600. int force_open; //or
  602. /* This is the place where each file format can check if the suppiled
  603. ** SF_INFO struct is valid.
  604. ** Return 0 on failure, 1 ons success. 
  605. */
  607. if (info->channels < 1 || info->channels > 256)
  608. return 0 ;
  610. //or
  611. force_open = ((info->format & SF_FORMAT_SUBMASK) == SF_FORCE_OPEN)?1:0;
  612. if(force_open && info->format_tag && info->bytewidth) 
  613.     return 1;
  614. //end or
  617. switch (info->format & SF_FORMAT_TYPEMASK)
  618. { case SF_FORMAT_WAV :
  619. if (subformat == SF_FORMAT_PCM && (info->pcmbitwidth >= 8 && info->pcmbitwidth <= 32))
  620. return 1 ;
  621. if (subformat == SF_FORMAT_FLOAT && info->pcmbitwidth == 32)
  622. return 1 ;
  623. if (subformat == SF_FORMAT_IMA_ADPCM && info->pcmbitwidth == 16 && info->channels <= 2)
  624. return 1 ;
  625. if (subformat == SF_FORMAT_MS_ADPCM && info->pcmbitwidth == 16 && info->channels <= 2)
  626. return 1 ;
  627. if (subformat == SF_FORMAT_GSM610 && info->pcmbitwidth == 16 && info->channels == 1)
  628. return 1 ;
  629. if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
  630. return 1 ;
  631. break ;
  633. case SF_FORMAT_AIFF :
  634. if (subformat == SF_FORMAT_PCM && (info->pcmbitwidth >= 8 && info->pcmbitwidth <= 32))
  635. return 1 ;
  636. break ;
  638. case SF_FORMAT_AU :
  639. case SF_FORMAT_AULE :
  640. if (subformat == SF_FORMAT_PCM && (info->pcmbitwidth >= 8 && info->pcmbitwidth <= 32))
  641. return 1 ;
  642. if (subformat == SF_FORMAT_ULAW)
  643. return 1 ;
  644. if (subformat == SF_FORMAT_ALAW)
  645. return 1 ;
  646. if (subformat == SF_FORMAT_G721_32 && info->channels == 1)
  647. return 1 ;
  648. if (subformat == SF_FORMAT_G723_24 && info->channels == 1)
  649. return 1 ;
  650. break ;
  652. case SF_FORMAT_RAW :
  653. if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
  654. return 1 ;
  655. if (subformat == SF_FORMAT_PCM_S8 && info->pcmbitwidth == 8)
  656. return 1 ;
  657. if (subformat == SF_FORMAT_PCM_U8 && info->pcmbitwidth == 8)
  658. return 1 ;
  659. if (subformat != SF_FORMAT_PCM_BE && subformat != SF_FORMAT_PCM_LE)
  660. break ;
  661. if (info->pcmbitwidth % 8 || info->pcmbitwidth > 32)
  662. break ;
  663. return 1 ;
  664. break ;
  666. case SF_FORMAT_PAF :
  667. if (subformat == SF_FORMAT_PCM_S8 && info->pcmbitwidth == 8)
  668. return 1 ;
  669. if (subformat != SF_FORMAT_PCM_BE && subformat != SF_FORMAT_PCM_LE)
  670. break ;
  671. if (info->pcmbitwidth % 8 || info->pcmbitwidth > 24)
  672. break ;
  673. return 1 ;
  674. break ;
  676. case SF_FORMAT_SVX :
  677. if (subformat == SF_FORMAT_PCM && (info->pcmbitwidth == 8 || info->pcmbitwidth == 16))
  678. return 1 ;
  679. break ;
  681. default : break ;
  682. } ;
  684. return 0 ;
  685. } /* sf_format_check */
  687. /*------------------------------------------------------------------------------
  688. */
  690. size_t sf_get_header_info (SNDFILE *sndfile, char *buffer, size_t bufferlen, size_t offset)
  691. { SF_PRIVATE *psf ;
  692. int len ;
  694. if (! sndfile)
  695. { strncpy (buffer, sf_strbuffer, bufferlen - 1) ;
  696. buffer [bufferlen - 1] = 0 ;
  697. return strlen (sf_strbuffer) ;
  698. } ;
  700. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  702. len = strlen (psf->strbuffer) ;
  703. if (offset < 0 || offset >= len)
  704. return 0 ;
  706. strncpy (buffer, psf->strbuffer, bufferlen - 1) ;
  707. buffer [bufferlen - 1] = 0 ;
  709. return strlen (psf->strbuffer) ;
  710. } /* sf_get_header_info */
  712. /*------------------------------------------------------------------------------
  713. */
  715. size_t sf_get_lib_version (char *buffer, size_t bufferlen)
  716. { if (! buffer || ! bufferlen)
  717. return 0 ;
  719. strncpy (buffer, PACKAGE, bufferlen - 1) ;
  720. buffer [bufferlen - 1] = 0 ;
  721. strncat (buffer, "-", bufferlen - strlen (buffer) - 1) ;
  722. strncat (buffer, VERSION, bufferlen - strlen (buffer) - 1) ;
  724. return strlen (buffer) ;
  725. } /* sf_get_lib_version */
  727. /*------------------------------------------------------------------------------
  728. */
  730. double  sf_signal_max   (SNDFILE *sndfile)
  731. { SF_PRIVATE  *psf ;
  732. off_t position ;
  733. unsigned int k, len, readcount ;
  734. double  max = 0.0, *data, temp ;
  736. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  738. if (! psf->sf.seekable)
  739. { psf->error = SFE_NOT_SEEKABLE ;
  740. return 0.0 ;
  741. } ;
  744. if (! psf->read_double)
  745. { psf->error = SFE_UNIMPLEMENTED ;
  746. return -1 ;
  747. } ;
  749. position = sf_seek (sndfile, 0, SEEK_CUR) ; /* Get current position in file */
  750. sf_seek (sndfile, 0, SEEK_SET) ; /* Go to start of file. */
  752. len = psf->sf.channels * 1024 ;
  754. data = malloc (len * sizeof (double)) ;
  755. readcount = len ;
  756. while (readcount == len)
  757. { readcount = psf->read_double (psf, data, len, 0) ;
  758. for (k = 0 ; k < len ; k++)
  759. { temp = data [k] ;
  760. temp = temp < 0.0 ? -temp : temp ;
  761. max  = temp > max ? temp : max ;
  762. } ;
  763. } ;
  764. free (data) ;
  766. sf_seek (sndfile, position, SEEK_SET) ; /* Return to original position. */
  768. return max ;
  769. } /* sf_signal_max */
  771. /*------------------------------------------------------------------------------
  772. */
  774. off_t sf_seek (SNDFILE *sndfile, off_t offset, int whence)
  775. { SF_PRIVATE  *psf ;
  776. off_t realseek, position ;
  778. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  780. if (! psf->sf.seekable)
  781. { psf->error = SFE_NOT_SEEKABLE ;
  782. return ((off_t) -1) ;
  783. } ;
  785. if (psf->seek_func)
  786. return psf->seek_func (psf, offset, whence) ;
  788. if (! (psf->blockwidth && psf->datalength && psf->dataoffset))
  789. { psf->error = SFE_BAD_SEEK ;
  790. return ((off_t) -1) ;
  791. } ;
  793. switch (whence)
  794. { case SEEK_SET :
  795. if (offset < 0 || offset * psf->blockwidth > psf->datalength)
  796. { psf->error = SFE_BAD_SEEK ;
  797. return ((off_t) -1) ;
  798. } ;
  799. realseek = psf->dataoffset + offset * psf->blockwidth ;
  800. fseek (psf->file, realseek, SEEK_SET) ;
  801. position = ftell (psf->file) ;
  802. break ;
  804. case SEEK_CUR :
  805. realseek = offset * psf->blockwidth ;
  806. position = ftell (psf->file) - psf->dataoffset ;
  807. if (position + realseek > psf->datalength || position + realseek < 0)
  808. { psf->error = SFE_BAD_SEEK ;
  809. return ((off_t) -1) ;
  810. } ;
  811. fseek (psf->file, realseek, SEEK_CUR) ;
  812. position = ftell (psf->file) ;
  813. break ;
  815. case SEEK_END :
  816. if (offset > 0 || psf->sf.samples + offset < 0)
  817. { psf->error = SFE_BAD_SEEK ;
  818. return ((off_t) -1) ;
  819. } ;
  820. realseek = (psf->sf.samples + offset) * psf->blockwidth + psf->dataoffset ;
  822. fseek (psf->file, realseek, SEEK_SET) ;
  823. position = ftell (psf->file) ;
  824. break ;
  826. default : 
  827. psf->error = SFE_BAD_SEEK ;
  828. return ((off_t) -1) ;
  829. } ;
  831. psf->current = (position - psf->dataoffset) / psf->blockwidth ;
  832. return psf->current ;
  833. } /* sf_seek */
  835. /*------------------------------------------------------------------------------
  836. */
  838. size_t sf_read_raw (SNDFILE *sndfile, void *ptr, size_t bytes)
  839. { SF_PRIVATE  *psf ;
  840. size_t count ;
  842. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  844. if (psf->mode != SF_MODE_READ)
  845. { psf->error = SFE_NOT_READMODE ;
  846. return ((size_t) -1) ;
  847. } ;
  849. if (psf->current >= psf->datalength)
  850. { memset (ptr, 0, bytes) ;
  851. return 0 ;
  852. } ;
  854. if (bytes % (psf->sf.channels * psf->bytewidth))
  855. { psf->error = SFE_BAD_READ_ALIGN ;
  856. return (size_t) -1 ;
  857. } ;
  859. count = fread (ptr, 1, bytes, psf->file) ;
  861. if (count < bytes)
  862. memset (((char*)ptr) + count, 0, bytes - count) ;
  864. psf->current += count / psf->blockwidth ;
  866. return count ;
  867. } /* sf_read_raw */
  869. /*------------------------------------------------------------------------------
  870. */
  872. size_t sf_read_short (SNDFILE *sndfile, short *ptr, size_t len)
  873. { SF_PRIVATE  *psf ;
  874. size_t count, extra ;
  876. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  878. if (psf->mode != SF_MODE_READ)
  879. { psf->error = SFE_NOT_READMODE ;
  880. return (size_t) -1 ;
  881. } ;
  883. if (len % psf->sf.channels)
  884. { psf->error = SFE_BAD_READ_ALIGN ;
  885. return (size_t) -1 ;
  886. } ;
  888. if (psf->current >= psf->sf.samples)
  889. { memset (ptr, 0, len * sizeof (short)) ;
  890. return 0 ; /* End of file. */
  891. } ;
  893. if (! psf->read_short)
  894. { psf->error = SFE_UNIMPLEMENTED ;
  895. return (size_t) -1 ;
  896. } ;
  898. count = psf->read_short (psf, ptr, len) ;
  900. if (psf->current + count / psf->sf.channels > psf->sf.samples)
  901. { count = (psf->sf.samples - psf->current) * psf->sf.channels ;
  902. extra = len - count ;
  903. memset (ptr + count, 0, extra * sizeof (short)) ;
  904. psf->current = psf->sf.samples ;
  905. } ;
  907. psf->current += count / psf->sf.channels ;
  909. return count ;
  910. } /* sf_read_short */
  912. size_t sf_readf_short (SNDFILE *sndfile, short *ptr, size_t frames)
  913. { SF_PRIVATE  *psf ;
  914. size_t count, extra ;
  916. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  918. if (psf->mode != SF_MODE_READ)
  919. { psf->error = SFE_NOT_READMODE ;
  920. return (size_t) -1 ;
  921. } ;
  923. if (psf->current >= psf->sf.samples)
  924. { memset (ptr, 0, frames * psf->sf.channels * sizeof (short)) ;
  925. return 0 ; /* End of file. */
  926. } ;
  928. if (! psf->read_short)
  929. { psf->error = SFE_UNIMPLEMENTED ;
  930. return (size_t) -1 ;
  931. } ;
  933. count = psf->read_short (psf, ptr, frames * psf->sf.channels) ;
  935. if (psf->current + count / psf->sf.channels > psf->sf.samples)
  936. { count = (psf->sf.samples - psf->current) * psf->sf.channels ;
  937. extra =  frames * psf->sf.channels - count ;
  938. memset (ptr + count, 0, extra * sizeof (short)) ;
  939. psf->current = psf->sf.samples ;
  940. } ;
  942. psf->current += count / psf->sf.channels ;
  944. return count / psf->sf.channels ;
  945. } /* sf_readf_short */
  947. /*------------------------------------------------------------------------------
  948. */
  950. size_t sf_read_int (SNDFILE *sndfile, int *ptr, size_t len)
  951. { SF_PRIVATE  *psf ;
  952. size_t count, extra ;
  954. VALIDATE_SNDFILE_AND_ASSIGN_PSF   (sndfile,psf) ;
  956. if (psf->mode != SF_MODE_READ)
  957. return SFE_NOT_READMODE ;
  959. if (len % psf->sf.channels)
  960. return (psf->error = SFE_BAD_READ_ALIGN) ;
  962. if (psf->current >= psf->sf.samples)
  963. { memset (ptr, 0, len * sizeof (int)) ;
  964. return 0 ;
  965. } ;
  967. if (! psf->read_int)
  968. { psf->error = SFE_UNIMPLEMENTED ;
  969. return (size_t) -1 ;
  970. } ;
  972. count = psf->read_int (psf, ptr, len) ;
  974. if (psf->current + count / psf->sf.channels > psf->sf.samples)
  975. { count = (psf->sf.samples - psf->current) * psf->sf.channels ;
  976. extra = len - count ;
  977. memset (ptr + count, 0, extra * sizeof (int)) ;
  978. psf->current = psf->sf.samples ;
  979. } ;
  981. psf->current += count / psf->sf.channels ;
  983. return count ;
  984. } /* sf_read_int */
  986. size_t sf_readf_int (SNDFILE *sndfile, int *ptr, size_t frames)
  987. { SF_PRIVATE  *psf ;
  988. size_t count, extra ;
  990. VALIDATE_SNDFILE_AND_ASSIGN_PSF   (sndfile,psf) ;
  992. if (psf->mode != SF_MODE_READ)
  993. return SFE_NOT_READMODE ;
  995. if (psf->current >= psf->sf.samples)
  996. { memset (ptr, 0, frames * psf->sf.channels * sizeof (int)) ;
  997. return 0 ;
  998. } ;
  1000. if (! psf->read_int)
  1001. { psf->error = SFE_UNIMPLEMENTED ;
  1002. return (size_t) -1 ;
  1003. } ;
  1005. count = psf->read_int (psf, ptr, frames * psf->sf.channels) ;
  1007. if (psf->current + count / psf->sf.channels > psf->sf.samples)
  1008. { count = (psf->sf.samples - psf->current) * psf->sf.channels ;
  1009. extra = frames * psf->sf.channels - count ;
  1010. memset (ptr + count, 0, extra * sizeof (int)) ;
  1011. psf->current = psf->sf.samples ;
  1012. } ;
  1014. psf->current += count / psf->sf.channels ;
  1016. return count / psf->sf.channels ;
  1017. } /* sf_readf_int */
  1019. /*------------------------------------------------------------------------------
  1020. */
  1022. size_t sf_read_double (SNDFILE *sndfile, double *ptr, size_t len, int normalize)
  1023. { SF_PRIVATE  *psf ;
  1024. size_t count, extra ;
  1026. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf) ;
  1028. if (psf->mode != SF_MODE_READ)
  1029. return SFE_NOT_READMODE ;
  1031. if (len % psf->sf.channels)
  1032. return (psf->error = SFE_BAD_READ_ALIGN) ;
  1034. if (psf->current >= psf->sf.samples)
  1035. { memset (ptr, 0, len * sizeof (double)) ;
  1036. return 0 ;
  1037. } ;
  1039. if (! psf->read_double)
  1040. { psf->error = SFE_UNIMPLEMENTED ;
  1041. return (size_t) -1 ;
  1042. } ;
  1044. count = psf->read_double (psf, ptr, len, normalize) ;
  1046. if (psf->current + count / psf->sf.channels > psf->sf.samples)
  1047. { count = (psf->sf.samples - psf->current) * psf->sf.channels ;
  1048. extra = len - count ;
  1049. memset (ptr + count, 0, extra * sizeof (double)) ;
  1050. psf->current = psf->sf.samples ;
  1051. } ;
  1053. psf->current += count / psf->sf.channels ;
  1055. return count ;
  1056. } /* sf_read_double */
  1058. size_t sf_readf_double (SNDFILE *sndfile, double *ptr, size_t frames, int normalize)
  1059. { SF_PRIVATE  *psf ;
  1060. size_t count, extra ;
  1062. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile, psf) ;
  1064. if (psf->mode != SF_MODE_READ)
  1065. return SFE_NOT_READMODE ;
  1067. if (psf->current >= psf->sf.samples)
  1068. { memset (ptr, 0, frames * psf->sf.channels * sizeof (double)) ;
  1069. return 0 ;
  1070. } ;
  1072. if (! psf->read_double)
  1073. { psf->error = SFE_UNIMPLEMENTED ;
  1074. return (size_t) -1 ;
  1075. } ;
  1077. count = psf->read_double (psf, ptr, frames * psf->sf.channels, normalize) ;
  1079. if (psf->current + count / psf->sf.channels > psf->sf.samples)
  1080. { count = (psf->sf.samples - psf->current) * psf->sf.channels ;
  1081. extra = frames * psf->sf.channels - count ;
  1082. memset (ptr + count, 0, extra * sizeof (double)) ;
  1083. psf->current = psf->sf.samples ;
  1084. } ;
  1086. psf->current += count / psf->sf.channels ;
  1088. return count / psf->sf.channels ;
  1089. } /* sf_readf_double */
  1091. /*------------------------------------------------------------------------------
  1092. */
  1094. size_t sf_write_raw (SNDFILE *sndfile, void *ptr, size_t len)
  1095. { SF_PRIVATE  *psf ;
  1096. size_t count ;
  1098. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1100. if (psf->mode != SF_MODE_WRITE)
  1101. { psf->error = SFE_NOT_WRITEMODE ;
  1102. return (size_t) -1 ;
  1103. } ;
  1105. if (len % (psf->sf.channels * psf->bytewidth))
  1106. { psf->error = SFE_BAD_WRITE_ALIGN ;
  1107. return (size_t) -1 ;
  1108. } ;
  1110. count = fwrite (ptr, 1, len, psf->file) ;
  1112. psf->current += count / psf->blockwidth ;
  1114. return count ;
  1115. } /* sf_write_raw */
  1117. /*------------------------------------------------------------------------------
  1118. */
  1120. size_t sf_write_short (SNDFILE *sndfile, short *ptr, size_t len)
  1121. { SF_PRIVATE  *psf ;
  1122. size_t count ;
  1124. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1126. if (psf->mode != SF_MODE_WRITE)
  1127. { psf->error = SFE_NOT_WRITEMODE ;
  1128. return (size_t) -1 ;
  1129. } ;
  1131. if (len % psf->sf.channels)
  1132. { psf->error = SFE_BAD_WRITE_ALIGN ;
  1133. return (size_t) -1 ;
  1134. } ;
  1136. if (! psf->write_short)
  1137. { psf->error = SFE_UNIMPLEMENTED ;
  1138. return (size_t) -1 ;
  1139. } ;
  1141. count = psf->write_short (sndfile, ptr, len) ;
  1143. psf->current += count / psf->sf.channels ;
  1145. return count ;
  1146. } /* sf_write_short */
  1148. size_t sf_writef_short (SNDFILE *sndfile, short *ptr, size_t frames)
  1149. { SF_PRIVATE  *psf ;
  1150. size_t count ;
  1152. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1154. if (psf->mode != SF_MODE_WRITE)
  1155. { psf->error = SFE_NOT_WRITEMODE ;
  1156. return (size_t) -1 ;
  1157. } ;
  1159. if (! psf->write_short)
  1160. { psf->error = SFE_UNIMPLEMENTED ;
  1161. return (size_t) -1 ;
  1162. } ;
  1164. count = psf->write_short (sndfile, ptr, frames * psf->sf.channels) ;
  1166. psf->current += count / psf->sf.channels ;
  1168. return count / psf->sf.channels ;
  1169. } /* sf_writef_short */
  1171. /*------------------------------------------------------------------------------
  1172. */
  1174. size_t sf_write_int (SNDFILE *sndfile, int *ptr, size_t len)
  1175. { SF_PRIVATE  *psf ;
  1176. size_t count ;
  1178. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1180. if (psf->mode != SF_MODE_WRITE)
  1181. { psf->error = SFE_NOT_WRITEMODE ;
  1182. return (size_t) -1 ;
  1183. } ;
  1185. if (len % psf->sf.channels)
  1186. { psf->error = SFE_BAD_WRITE_ALIGN ;
  1187. return (size_t) -1 ;
  1188. } ;
  1190. if (! psf->write_int)
  1191. { psf->error = SFE_UNIMPLEMENTED ;
  1192. return (size_t) -1 ;
  1193. } ;
  1195. count = psf->write_int (sndfile, ptr, len) ;
  1197. psf->current += count / psf->sf.channels ;
  1199. return count ;
  1200. } /* sf_write_int */
  1202. size_t sf_writef_int (SNDFILE *sndfile, int *ptr, size_t frames)
  1203. { SF_PRIVATE  *psf ;
  1204. size_t count ;
  1206. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1208. if (psf->mode != SF_MODE_WRITE)
  1209. { psf->error = SFE_NOT_WRITEMODE ;
  1210. return (size_t) -1 ;
  1211. } ;
  1213. if (! psf->write_int)
  1214. { psf->error = SFE_UNIMPLEMENTED ;
  1215. return (size_t) -1 ;
  1216. } ;
  1218. count = psf->write_int (sndfile, ptr, frames * psf->sf.channels) ;
  1220. psf->current += count / psf->sf.channels ;
  1222. return count / psf->sf.channels ;
  1223. } /* sf_writef_int */
  1225. /*------------------------------------------------------------------------------
  1226. */
  1228. size_t sf_write_double (SNDFILE *sndfile, double *ptr, size_t len, int normalize)
  1229. { SF_PRIVATE  *psf ;
  1230. size_t count ;
  1232. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1234. if (psf->mode != SF_MODE_WRITE)
  1235. { psf->error = SFE_NOT_WRITEMODE ;
  1236. return (size_t) -1 ;
  1237. } ;
  1239. if (len % psf->sf.channels)
  1240. { psf->error = SFE_BAD_WRITE_ALIGN ;
  1241. return (size_t) -1 ;
  1242. } ;
  1244. if (! psf->write_double)
  1245. { psf->error = SFE_UNIMPLEMENTED ;
  1246. return (size_t) -1 ;
  1247. } ;
  1249. count = psf->write_double (sndfile, ptr, len, normalize) ;
  1251. psf->current += count / psf->sf.channels ;
  1253. return count ;
  1254. } /* sf_write_double */
  1256. size_t sf_writef_double (SNDFILE *sndfile, double *ptr, size_t frames, int normalize)
  1257. { SF_PRIVATE  *psf ;
  1258. size_t count ;
  1260. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1262. if (psf->mode != SF_MODE_WRITE)
  1263. { psf->error = SFE_NOT_WRITEMODE ;
  1264. return (size_t) -1 ;
  1265. } ;
  1267. if (! psf->write_double)
  1268. { psf->error = SFE_UNIMPLEMENTED ;
  1269. return (size_t) -1 ;
  1270. } ;
  1272. count = psf->write_double (sndfile, ptr, frames * psf->sf.channels, normalize) ;
  1274. psf->current += count / psf->sf.channels ;
  1276. return count / psf->sf.channels ;
  1277. } /* sf_writef_double */
  1279. /*------------------------------------------------------------------------------
  1280. */
  1282. int sf_close (SNDFILE *sndfile)
  1283. { SF_PRIVATE  *psf ;
  1284. int error ;
  1286. VALIDATE_SNDFILE_AND_ASSIGN_PSF (sndfile,psf) ;
  1288. if (psf->close)
  1289. error = psf->close (psf) ;
  1291. fclose (psf->file) ;
  1292. memset (psf, 0, sizeof (SF_PRIVATE)) ;
  1294. free (psf) ;
  1296. return 0 ;
  1297. } /* sf_close */
  1300. /*=========================================================================
  1301. ** Private functions.
  1302. */