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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
paf.c
资源名称：libsndfile-1.0.21.tar.gz　[点击查看]
上传用户：shw771010
上传日期：2022-01-05
资源大小：991k
文件大小：23k
源码类别：

Audio

开发平台：

Unix_Linux

paf.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2009 Erik de Castro Lopo <erikd@mega-nerd.com>
  3. **
  4. ** This program is free software; you can redistribute it and/or modify
  5. ** it under the terms of the GNU Lesser General Public License as published by
  6. ** the Free Software Foundation; either version 2.1 of the License, or
  7. ** (at your option) any later version.
  8. **
  9. ** This program is distributed in the hope that it will be useful,
  10. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. ** GNU Lesser General Public License for more details.
  13. **
  14. ** You should have received a copy of the GNU Lesser General Public License
  15. ** along with this program; if not, write to the Free Software
  16. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. */
  19. #include "sfconfig.h"
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <fcntl.h>
  24. #include <string.h>
  25. #include <ctype.h>
  26. #include <math.h>
  28. #include "sndfile.h"
  29. #include "sfendian.h"
  30. #include "common.h"
  32. /*------------------------------------------------------------------------------
  33. ** Macros to handle big/little endian issues.
  34. */
  36. #define FAP_MARKER (MAKE_MARKER ('f', 'a', 'p', ' '))
  37. #define PAF_MARKER (MAKE_MARKER (' ', 'p', 'a', 'f'))
  39. /*------------------------------------------------------------------------------
  40. ** Other defines.
  41. */
  43. #define PAF_HEADER_LENGTH  2048
  45. #define PAF24_SAMPLES_PER_BLOCK 10
  46. #define PAF24_BLOCK_SIZE 32
  48. /*------------------------------------------------------------------------------
  49. ** Typedefs.
  50. */
  52. typedef struct
  53. { int version ;
  54. int endianness ;
  55.     int samplerate ;
  56.     int format ;
  57. int channels ;
  58. int source ;
  59. } PAF_FMT ;
  61. typedef struct
  62. { int max_blocks, channels, samplesperblock, blocksize ;
  63. int read_block, write_block, read_count, write_count ;
  64. sf_count_t sample_count ;
  65. int *samples ;
  66. unsigned char *block ;
  67. #if HAVE_FLEXIBLE_ARRAY
  68. int data [] ; /* ISO C99 struct flexible array. */
  69. #else
  70. int data [1] ; /* This is a hack and may not work. */
  71. #endif
  72. } PAF24_PRIVATE ;
  74. /*------------------------------------------------------------------------------
  75. ** Private static functions.
  76. */
  78. static int paf24_init (SF_PRIVATE *psf) ;
  80. static int paf_read_header (SF_PRIVATE *psf) ;
  81. static int paf_write_header (SF_PRIVATE *psf, int calc_length) ;
  83. static sf_count_t paf24_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
  84. static sf_count_t paf24_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
  85. static sf_count_t paf24_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
  86. static sf_count_t paf24_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
  88. static sf_count_t paf24_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
  89. static sf_count_t paf24_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
  90. static sf_count_t paf24_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
  91. static sf_count_t paf24_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
  93. static sf_count_t paf24_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;
  95. enum
  96. { PAF_PCM_16 = 0,
  97. PAF_PCM_24 = 1,
  98. PAF_PCM_S8 = 2
  99. } ;
  101. /*------------------------------------------------------------------------------
  102. ** Public function.
  103. */
  105. int
  106. paf_open (SF_PRIVATE *psf)
  107. { int subformat, error, endian ;
  109.   psf->dataoffset = PAF_HEADER_LENGTH ;
  111. if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
  112. { if ((error = paf_read_header (psf)))
  113. return error ;
  114. } ;
  116. subformat = SF_CODEC (psf->sf.format) ;
  118. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  119. { if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_PAF)
  120. return SFE_BAD_OPEN_FORMAT ;
  122. endian = SF_ENDIAN (psf->sf.format) ;
  124. /* PAF is by default big endian. */
  125. psf->endian = SF_ENDIAN_BIG ;
  127. if (endian == SF_ENDIAN_LITTLE || (CPU_IS_LITTLE_ENDIAN && (endian == SF_ENDIAN_CPU)))
  128. psf->endian = SF_ENDIAN_LITTLE ;
  130. if ((error = paf_write_header (psf, SF_FALSE)))
  131. return error ;
  133. psf->write_header = paf_write_header ;
  134. } ;
  136. switch (subformat)
  137. { case SF_FORMAT_PCM_S8 :
  138. psf->bytewidth = 1 ;
  139. error = pcm_init (psf) ;
  140. break ;
  142. case SF_FORMAT_PCM_16 :
  143. psf->bytewidth = 2 ;
  144. error = pcm_init (psf) ;
  145. break ;
  147. case SF_FORMAT_PCM_24 :
  148. /* No bytewidth because of whacky 24 bit encoding. */
  149. error = paf24_init (psf) ;
  150. break ;
  152. default : return SFE_PAF_UNKNOWN_FORMAT ;
  153. } ;
  155. return error ;
  156. } /* paf_open */
  158. /*------------------------------------------------------------------------------
  159. */
  161. static int
  162. paf_read_header (SF_PRIVATE *psf)
  163. { PAF_FMT paf_fmt ;
  164. int marker ;
  166. memset (&paf_fmt, 0, sizeof (paf_fmt)) ;
  167. psf_binheader_readf (psf, "pm", 0, &marker) ;
  169. psf_log_printf (psf, "Signature   : '%M'n", marker) ;
  171. if (marker == PAF_MARKER)
  172. { psf_binheader_readf (psf, "E444444", &(paf_fmt.version), &(paf_fmt.endianness),
  173. &(paf_fmt.samplerate), &(paf_fmt.format), &(paf_fmt.channels), &(paf_fmt.source)) ;
  174. }
  175. else if (marker == FAP_MARKER)
  176. { psf_binheader_readf (psf, "e444444", &(paf_fmt.version), &(paf_fmt.endianness),
  177. &(paf_fmt.samplerate), &(paf_fmt.format), &(paf_fmt.channels), &(paf_fmt.source)) ;
  178. }
  179. else
  180. return SFE_PAF_NO_MARKER ;
  182. psf_log_printf (psf, "Version     : %dn", paf_fmt.version) ;
  184. if (paf_fmt.version != 0)
  185. { psf_log_printf (psf, "*** Bad version number. should be zero.n") ;
  186. return SFE_PAF_VERSION ;
  187. } ;
  189. psf_log_printf (psf, "Sample Rate : %dn", paf_fmt.samplerate) ;
  190. psf_log_printf (psf, "Channels    : %dn", paf_fmt.channels) ;
  192. psf_log_printf (psf, "Endianness  : %d => ", paf_fmt.endianness) ;
  193. if (paf_fmt.endianness)
  194. { psf_log_printf (psf, "Littlen", paf_fmt.endianness) ;
  195. psf->endian = SF_ENDIAN_LITTLE ;
  196. }
  197. else
  198. { psf_log_printf (psf, "Bign", paf_fmt.endianness) ;
  199. psf->endian = SF_ENDIAN_BIG ;
  200. } ;
  202. if (psf->filelength < PAF_HEADER_LENGTH)
  203. return SFE_PAF_SHORT_HEADER ;
  205. psf->datalength = psf->filelength - psf->dataoffset ;
  207. psf_binheader_readf (psf, "p", (int) psf->dataoffset) ;
  209. psf->sf.samplerate = paf_fmt.samplerate ;
  210. psf->sf.channels  = paf_fmt.channels ;
  212. /* Only fill in type major. */
  213. psf->sf.format = SF_FORMAT_PAF ;
  215. psf_log_printf (psf, "Format      : %d => ", paf_fmt.format) ;
  217. /* PAF is by default big endian. */
  218. psf->sf.format |= paf_fmt.endianness ? SF_ENDIAN_LITTLE : SF_ENDIAN_BIG ;
  220. switch (paf_fmt.format)
  221. { case PAF_PCM_S8 :
  222. psf_log_printf (psf, "8 bit linear PCMn") ;
  223. psf->bytewidth = 1 ;
  225. psf->sf.format |= SF_FORMAT_PCM_S8 ;
  227. psf->blockwidth = psf->bytewidth * psf->sf.channels ;
  228. psf->sf.frames = psf->datalength / psf->blockwidth ;
  229. break ;
  231. case PAF_PCM_16 :
  232. psf_log_printf (psf, "16 bit linear PCMn") ;
  233. psf->bytewidth = 2 ;
  235. psf->sf.format |= SF_FORMAT_PCM_16 ;
  237. psf->blockwidth = psf->bytewidth * psf->sf.channels ;
  238. psf->sf.frames = psf->datalength / psf->blockwidth ;
  239. break ;
  241. case PAF_PCM_24 :
  242. psf_log_printf (psf, "24 bit linear PCMn") ;
  243. psf->bytewidth = 3 ;
  245. psf->sf.format |= SF_FORMAT_PCM_24 ;
  247. psf->blockwidth = 0 ;
  248. psf->sf.frames = PAF24_SAMPLES_PER_BLOCK * psf->datalength /
  249. (PAF24_BLOCK_SIZE * psf->sf.channels) ;
  250. break ;
  252. default : psf_log_printf (psf, "Unknownn") ;
  253. return SFE_PAF_UNKNOWN_FORMAT ;
  254. break ;
  255. } ;
  257. psf_log_printf (psf, "Source      : %d => ", paf_fmt.source) ;
  259. switch (paf_fmt.source)
  260. { case 1 : psf_log_printf (psf, "Analog Recordingn") ;
  261. break ;
  262. case 2 : psf_log_printf (psf, "Digital Transfern") ;
  263. break ;
  264. case 3 : psf_log_printf (psf, "Multi-track Mixdownn") ;
  265. break ;
  266. case 5 : psf_log_printf (psf, "Audio Resulting From DSP Processingn") ;
  267. break ;
  268. default : psf_log_printf (psf, "Unknownn") ;
  269. break ;
  270. } ;
  272. return 0 ;
  273. } /* paf_read_header */
  275. static int
  276. paf_write_header (SF_PRIVATE *psf, int UNUSED (calc_length))
  277. { int paf_format ;
  279. /* PAF header already written so no need to re-write. */
  280. if (psf_ftell (psf) >= PAF_HEADER_LENGTH)
  281. return 0 ;
  283. psf->dataoffset = PAF_HEADER_LENGTH ;
  285. switch (SF_CODEC (psf->sf.format))
  286. { case SF_FORMAT_PCM_S8 :
  287. paf_format = PAF_PCM_S8 ;
  288. break ;
  290. case SF_FORMAT_PCM_16 :
  291. paf_format = PAF_PCM_16 ;
  292. break ;
  294. case SF_FORMAT_PCM_24 :
  295. paf_format = PAF_PCM_24 ;
  296. break ;
  298. default : return SFE_PAF_UNKNOWN_FORMAT ;
  299. } ;
  301. /* Reset the current header length to zero. */
  302. psf->header [0] = 0 ;
  303. psf->headindex = 0 ;
  305. if (psf->endian == SF_ENDIAN_BIG)
  306. { /* Marker, version, endianness, samplerate */
  307. psf_binheader_writef (psf, "Em444", PAF_MARKER, 0, 0, psf->sf.samplerate) ;
  308. /* format, channels, source */
  309. psf_binheader_writef (psf, "E444", paf_format, psf->sf.channels, 0) ;
  310. }
  311. else if (psf->endian == SF_ENDIAN_LITTLE)
  312. { /* Marker, version, endianness, samplerate */
  313. psf_binheader_writef (psf, "em444", FAP_MARKER, 0, 1, psf->sf.samplerate) ;
  314. /* format, channels, source */
  315. psf_binheader_writef (psf, "e444", paf_format, psf->sf.channels, 0) ;
  316. } ;
  318. /* Zero fill to dataoffset. */
  319. psf_binheader_writef (psf, "z", (size_t) (psf->dataoffset - psf->headindex)) ;
  321. psf_fwrite (psf->header, psf->headindex, 1, psf) ;
  323. return psf->error ;
  324. } /* paf_write_header */
  326. /*===============================================================================
  327. ** 24 bit PAF files have a really weird encoding.
  328. **  For a mono file, 10 samples (each being 3 bytes) are packed into a 32 byte
  329. ** block. The 8 ints in this 32 byte block are then endian swapped (as ints)
  330. ** if necessary before being written to disk.
  331. **  For a stereo file, blocks of 10 samples from the same channel are encoded
  332. **  into 32 bytes as for the mono case. The 32 byte blocks are then interleaved
  333. ** on disk.
  334. ** Reading has to reverse the above process :-).
  335. ** Weird!!!
  336. **
  337. ** The code below attempts to gain efficiency while maintaining readability.
  338. */
  340. static int paf24_read_block (SF_PRIVATE *psf, PAF24_PRIVATE *ppaf24) ;
  341. static int paf24_write_block (SF_PRIVATE *psf, PAF24_PRIVATE *ppaf24) ;
  342. static int paf24_close (SF_PRIVATE *psf) ;
  345. static int
  346. paf24_init (SF_PRIVATE *psf)
  347. { PAF24_PRIVATE *ppaf24 ;
  348. int paf24size ;
  350. paf24size = sizeof (PAF24_PRIVATE) + psf->sf.channels *
  351. (PAF24_BLOCK_SIZE + PAF24_SAMPLES_PER_BLOCK * sizeof (int)) ;
  353. /*
  354. ** Not exatly sure why this needs to be here but the tests
  355. ** fail without it.
  356. */
  357. psf->last_op = 0 ;
  359. if (! (psf->codec_data = malloc (paf24size)))
  360. return SFE_MALLOC_FAILED ;
  362. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  363. memset (ppaf24, 0, paf24size) ;
  365. ppaf24->channels = psf->sf.channels ;
  366. ppaf24->samples = ppaf24->data ;
  367. ppaf24->block = (unsigned char*) (ppaf24->data + PAF24_SAMPLES_PER_BLOCK * ppaf24->channels) ;
  369. ppaf24->blocksize = PAF24_BLOCK_SIZE * ppaf24->channels ;
  370. ppaf24->samplesperblock = PAF24_SAMPLES_PER_BLOCK ;
  372. if (psf->file.mode == SFM_READ || psf->file.mode == SFM_RDWR)
  373. { paf24_read_block (psf, ppaf24) ; /* Read first block. */
  375. psf->read_short = paf24_read_s ;
  376. psf->read_int = paf24_read_i ;
  377. psf->read_float = paf24_read_f ;
  378. psf->read_double = paf24_read_d ;
  379. } ;
  381. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  382. { psf->write_short = paf24_write_s ;
  383. psf->write_int = paf24_write_i ;
  384. psf->write_float = paf24_write_f ;
  385. psf->write_double = paf24_write_d ;
  386. } ;
  388. psf->seek = paf24_seek ;
  389. psf->container_close = paf24_close ;
  391. psf->filelength = psf_get_filelen (psf) ;
  392. psf->datalength = psf->filelength - psf->dataoffset ;
  394. if (psf->datalength % PAF24_BLOCK_SIZE)
  395. { if (psf->file.mode == SFM_READ)
  396. psf_log_printf (psf, "*** Warning : file seems to be truncated.n") ;
  397. ppaf24->max_blocks = psf->datalength / ppaf24->blocksize + 1 ;
  398. }
  399. else
  400. ppaf24->max_blocks = psf->datalength / ppaf24->blocksize ;
  402. ppaf24->read_block = 0 ;
  403. if (psf->file.mode == SFM_RDWR)
  404. ppaf24->write_block = ppaf24->max_blocks ;
  405. else
  406. ppaf24->write_block = 0 ;
  408. psf->sf.frames = ppaf24->samplesperblock * ppaf24->max_blocks ;
  409. ppaf24->sample_count = psf->sf.frames ;
  411. return 0 ;
  412. } /* paf24_init */
  414. static sf_count_t
  415. paf24_seek (SF_PRIVATE *psf, int mode, sf_count_t offset)
  416. { PAF24_PRIVATE *ppaf24 ;
  417. int newblock, newsample ;
  419. if (psf->codec_data == NULL)
  420. { psf->error = SFE_INTERNAL ;
  421. return PSF_SEEK_ERROR ;
  422. } ;
  424. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  426. if (mode == SFM_READ && ppaf24->write_count > 0)
  427. paf24_write_block (psf, ppaf24) ;
  429. newblock = offset / ppaf24->samplesperblock ;
  430. newsample = offset % ppaf24->samplesperblock ;
  432. switch (mode)
  433. { case SFM_READ :
  434. if (psf->last_op == SFM_WRITE && ppaf24->write_count)
  435. paf24_write_block (psf, ppaf24) ;
  437. psf_fseek (psf, psf->dataoffset + newblock * ppaf24->blocksize, SEEK_SET) ;
  438. ppaf24->read_block = newblock ;
  439. paf24_read_block (psf, ppaf24) ;
  440. ppaf24->read_count = newsample ;
  441. break ;
  443. case SFM_WRITE :
  444. if (offset > ppaf24->sample_count)
  445. { psf->error = SFE_BAD_SEEK ;
  446. return PSF_SEEK_ERROR ;
  447. } ;
  449. if (psf->last_op == SFM_WRITE && ppaf24->write_count)
  450. paf24_write_block (psf, ppaf24) ;
  452. psf_fseek (psf, psf->dataoffset + newblock * ppaf24->blocksize, SEEK_SET) ;
  453. ppaf24->write_block = newblock ;
  454. paf24_read_block (psf, ppaf24) ;
  455. ppaf24->write_count = newsample ;
  456. break ;
  458. default :
  459. psf->error = SFE_BAD_SEEK ;
  460. return PSF_SEEK_ERROR ;
  461. } ;
  463. return newblock * ppaf24->samplesperblock + newsample ;
  464. } /* paf24_seek */
  466. static int
  467. paf24_close (SF_PRIVATE *psf)
  468. { PAF24_PRIVATE *ppaf24 ;
  470. if (psf->codec_data == NULL)
  471. return 0 ;
  473. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  475. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  476. { if (ppaf24->write_count > 0)
  477. paf24_write_block (psf, ppaf24) ;
  478. } ;
  480. return 0 ;
  481. } /* paf24_close */
  483. /*---------------------------------------------------------------------------
  484. */
  485. static int
  486. paf24_read_block (SF_PRIVATE *psf, PAF24_PRIVATE *ppaf24)
  487. { int k, channel ;
  488. unsigned char *cptr ;
  490. ppaf24->read_block ++ ;
  491. ppaf24->read_count = 0 ;
  493. if (ppaf24->read_block * ppaf24->samplesperblock > ppaf24->sample_count)
  494. { memset (ppaf24->samples, 0, ppaf24->samplesperblock * ppaf24->channels) ;
  495. return 1 ;
  496. } ;
  498. /* Read the block. */
  499. if ((k = psf_fread (ppaf24->block, 1, ppaf24->blocksize, psf)) != ppaf24->blocksize)
  500. psf_log_printf (psf, "*** Warning : short read (%d != %d).n", k, ppaf24->blocksize) ;
  503. if (CPU_IS_LITTLE_ENDIAN)
  504. { /* Do endian swapping if necessary. */
  505. if (psf->endian == SF_ENDIAN_BIG)
  506. endswap_int_array  (ppaf24->data, 8 * ppaf24->channels) ;
  508. /* Unpack block. */
  509. for (k = 0 ; k < PAF24_SAMPLES_PER_BLOCK * ppaf24->channels ; k++)
  510. { channel = k % ppaf24->channels ;
  511. cptr = ppaf24->block + PAF24_BLOCK_SIZE * channel + 3 * (k / ppaf24->channels) ;
  512. ppaf24->samples [k] = (cptr [0] << 8) | (cptr [1] << 16) | (cptr [2] << 24) ;
  513. } ;
  514. }
  515. else
  516. { /* Do endian swapping if necessary. */
  517. if (psf->endian == SF_ENDIAN_BIG)
  518. endswap_int_array  (ppaf24->data, 8 * ppaf24->channels) ;
  520. /* Unpack block. */
  521. for (k = 0 ; k < PAF24_SAMPLES_PER_BLOCK * ppaf24->channels ; k++)
  522. { channel = k % ppaf24->channels ;
  523. cptr = ppaf24->block + PAF24_BLOCK_SIZE * channel + 3 * (k / ppaf24->channels) ;
  524. ppaf24->samples [k] = (cptr [0] << 8) | (cptr [1] << 16) | (cptr [2] << 24) ;
  525. } ;
  526. } ;
  528. return 1 ;
  529. } /* paf24_read_block */
  531. static int
  532. paf24_read (SF_PRIVATE *psf, PAF24_PRIVATE *ppaf24, int *ptr, int len)
  533. { int count, total = 0 ;
  535. while (total < len)
  536. { if (ppaf24->read_block * ppaf24->samplesperblock >= ppaf24->sample_count)
  537. { memset (&(ptr [total]), 0, (len - total) * sizeof (int)) ;
  538. return total ;
  539. } ;
  541. if (ppaf24->read_count >= ppaf24->samplesperblock)
  542. paf24_read_block (psf, ppaf24) ;
  544. count = (ppaf24->samplesperblock - ppaf24->read_count) * ppaf24->channels ;
  545. count = (len - total > count) ? count : len - total ;
  547. memcpy (&(ptr [total]), &(ppaf24->samples [ppaf24->read_count * ppaf24->channels]), count * sizeof (int)) ;
  548. total += count ;
  549. ppaf24->read_count += count / ppaf24->channels ;
  550. } ;
  552. return total ;
  553. } /* paf24_read */
  555. static sf_count_t
  556. paf24_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
  557. { PAF24_PRIVATE  *ppaf24 ;
  558. int *iptr ;
  559. int k, bufferlen, readcount, count ;
  560. sf_count_t total = 0 ;
  562. if (psf->codec_data == NULL)
  563. return 0 ;
  564. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  566. iptr = psf->u.ibuf ;
  567. bufferlen = ARRAY_LEN (psf->u.ibuf) ;
  568. while (len > 0)
  569. { readcount = (len >= bufferlen) ? bufferlen : len ;
  570. count = paf24_read (psf, ppaf24, iptr, readcount) ;
  571. for (k = 0 ; k < readcount ; k++)
  572. ptr [total + k] = iptr [k] >> 16 ;
  573. total += count ;
  574. len -= readcount ;
  575. } ;
  576. return total ;
  577. } /* paf24_read_s */
  579. static sf_count_t
  580. paf24_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
  581. { PAF24_PRIVATE *ppaf24 ;
  582. int total ;
  584. if (psf->codec_data == NULL)
  585. return 0 ;
  586. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  588. total = paf24_read (psf, ppaf24, ptr, len) ;
  590. return total ;
  591. } /* paf24_read_i */
  593. static sf_count_t
  594. paf24_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
  595. { PAF24_PRIVATE  *ppaf24 ;
  596. int *iptr ;
  597. int k, bufferlen, readcount, count ;
  598. sf_count_t total = 0 ;
  599. float normfact ;
  601. if (psf->codec_data == NULL)
  602. return 0 ;
  603. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  605. normfact = (psf->norm_float == SF_TRUE) ? (1.0 / 0x80000000) : (1.0 / 0x100) ;
  607. iptr = psf->u.ibuf ;
  608. bufferlen = ARRAY_LEN (psf->u.ibuf) ;
  609. while (len > 0)
  610. { readcount = (len >= bufferlen) ? bufferlen : len ;
  611. count = paf24_read (psf, ppaf24, iptr, readcount) ;
  612. for (k = 0 ; k < readcount ; k++)
  613. ptr [total + k] = normfact * iptr [k] ;
  614. total += count ;
  615. len -= readcount ;
  616. } ;
  617. return total ;
  618. } /* paf24_read_f */
  620. static sf_count_t
  621. paf24_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
  622. { PAF24_PRIVATE  *ppaf24 ;
  623. int *iptr ;
  624. int k, bufferlen, readcount, count ;
  625. sf_count_t total = 0 ;
  626. double  normfact ;
  628. if (psf->codec_data == NULL)
  629. return 0 ;
  630. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  632. normfact = (psf->norm_double == SF_TRUE) ? (1.0 / 0x80000000) : (1.0 / 0x100) ;
  634. iptr = psf->u.ibuf ;
  635. bufferlen = ARRAY_LEN (psf->u.ibuf) ;
  636. while (len > 0)
  637. { readcount = (len >= bufferlen) ? bufferlen : len ;
  638. count = paf24_read (psf, ppaf24, iptr, readcount) ;
  639. for (k = 0 ; k < readcount ; k++)
  640. ptr [total + k] = normfact * iptr [k] ;
  641. total += count ;
  642. len -= readcount ;
  643. } ;
  644. return total ;
  645. } /* paf24_read_d */
  647. /*---------------------------------------------------------------------------
  648. */
  650. static int
  651. paf24_write_block (SF_PRIVATE *psf, PAF24_PRIVATE *ppaf24)
  652. { int k, nextsample, channel ;
  653. unsigned char *cptr ;
  655. /* First pack block. */
  657. if (CPU_IS_LITTLE_ENDIAN)
  658. { for (k = 0 ; k < PAF24_SAMPLES_PER_BLOCK * ppaf24->channels ; k++)
  659. { channel = k % ppaf24->channels ;
  660. cptr = ppaf24->block + PAF24_BLOCK_SIZE * channel + 3 * (k / ppaf24->channels) ;
  661. nextsample = ppaf24->samples [k] >> 8 ;
  662. cptr [0] = nextsample ;
  663. cptr [1] = nextsample >> 8 ;
  664. cptr [2] = nextsample >> 16 ;
  665. } ;
  667. /* Do endian swapping if necessary. */
  668. if (psf->endian == SF_ENDIAN_BIG)
  669. endswap_int_array (ppaf24->data, 8 * ppaf24->channels) ;
  670. }
  671. else if (CPU_IS_BIG_ENDIAN)
  672. { /* This is correct. */
  673. for (k = 0 ; k < PAF24_SAMPLES_PER_BLOCK * ppaf24->channels ; k++)
  674. { channel = k % ppaf24->channels ;
  675. cptr = ppaf24->block + PAF24_BLOCK_SIZE * channel + 3 * (k / ppaf24->channels) ;
  676. nextsample = ppaf24->samples [k] >> 8 ;
  677. cptr [0] = nextsample ;
  678. cptr [1] = nextsample >> 8 ;
  679. cptr [2] = nextsample >> 16 ;
  680. } ;
  681. if (psf->endian == SF_ENDIAN_BIG)
  682. endswap_int_array (ppaf24->data, 8 * ppaf24->channels) ;
  683. } ;
  685. /* Write block to disk. */
  686. if ((k = psf_fwrite (ppaf24->block, 1, ppaf24->blocksize, psf)) != ppaf24->blocksize)
  687. psf_log_printf (psf, "*** Warning : short write (%d != %d).n", k, ppaf24->blocksize) ;
  689. if (ppaf24->sample_count < ppaf24->write_block * ppaf24->samplesperblock + ppaf24->write_count)
  690. ppaf24->sample_count = ppaf24->write_block * ppaf24->samplesperblock + ppaf24->write_count ;
  692. if (ppaf24->write_count == ppaf24->samplesperblock)
  693. { ppaf24->write_block ++ ;
  694. ppaf24->write_count = 0 ;
  695. } ;
  697. return 1 ;
  698. } /* paf24_write_block */
  700. static int
  701. paf24_write (SF_PRIVATE *psf, PAF24_PRIVATE *ppaf24, const int *ptr, int len)
  702. { int count, total = 0 ;
  704. while (total < len)
  705. { count = (ppaf24->samplesperblock - ppaf24->write_count) * ppaf24->channels ;
  707. if (count > len - total)
  708. count = len - total ;
  710. memcpy (&(ppaf24->samples [ppaf24->write_count * ppaf24->channels]), &(ptr [total]), count * sizeof (int)) ;
  711. total += count ;
  712. ppaf24->write_count += count / ppaf24->channels ;
  714. if (ppaf24->write_count >= ppaf24->samplesperblock)
  715. paf24_write_block (psf, ppaf24) ;
  716. } ;
  718. return total ;
  719. } /* paf24_write */
  721. static sf_count_t
  722. paf24_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
  723. { PAF24_PRIVATE  *ppaf24 ;
  724. int *iptr ;
  725. int k, bufferlen, writecount = 0, count ;
  726. sf_count_t total = 0 ;
  728. if (psf->codec_data == NULL)
  729. return 0 ;
  730. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  732. iptr = psf->u.ibuf ;
  733. bufferlen = ARRAY_LEN (psf->u.ibuf) ;
  734. while (len > 0)
  735. { writecount = (len >= bufferlen) ? bufferlen : len ;
  736. for (k = 0 ; k < writecount ; k++)
  737. iptr [k] = ptr [total + k] << 16 ;
  738. count = paf24_write (psf, ppaf24, iptr, writecount) ;
  739. total += count ;
  740. len -= writecount ;
  741. if (count != writecount)
  742. break ;
  743. } ;
  744. return total ;
  745. } /* paf24_write_s */
  747. static sf_count_t
  748. paf24_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
  749. { PAF24_PRIVATE  *ppaf24 ;
  750. int writecount, count ;
  751. sf_count_t total = 0 ;
  753. if (psf->codec_data == NULL)
  754. return 0 ;
  755. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  757. while (len > 0)
  758. { writecount = (len > 0x10000000) ? 0x10000000 : (int) len ;
  760. count = paf24_write (psf, ppaf24, ptr, writecount) ;
  762. total += count ;
  763. len -= count ;
  764. if (count != writecount)
  765. break ;
  766. } ;
  768. return total ;
  769. } /* paf24_write_i */
  771. static sf_count_t
  772. paf24_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
  773. { PAF24_PRIVATE  *ppaf24 ;
  774. int *iptr ;
  775. int k, bufferlen, writecount = 0, count ;
  776. sf_count_t total = 0 ;
  777. float normfact ;
  779. if (psf->codec_data == NULL)
  780. return 0 ;
  781. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  783. normfact = (psf->norm_float == SF_TRUE) ? (1.0 * 0x7FFFFFFF) : (1.0 / 0x100) ;
  785. iptr = psf->u.ibuf ;
  786. bufferlen = ARRAY_LEN (psf->u.ibuf) ;
  787. while (len > 0)
  788. { writecount = (len >= bufferlen) ? bufferlen : len ;
  789. for (k = 0 ; k < writecount ; k++)
  790. iptr [k] = lrintf (normfact * ptr [total + k]) ;
  791. count = paf24_write (psf, ppaf24, iptr, writecount) ;
  792. total += count ;
  793. len -= writecount ;
  794. if (count != writecount)
  795. break ;
  796. } ;
  798. return total ;
  799. } /* paf24_write_f */
  801. static sf_count_t
  802. paf24_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
  803. { PAF24_PRIVATE  *ppaf24 ;
  804. int *iptr ;
  805. int k, bufferlen, writecount = 0, count ;
  806. sf_count_t total = 0 ;
  807. double normfact ;
  809. if (psf->codec_data == NULL)
  810. return 0 ;
  811. ppaf24 = (PAF24_PRIVATE*) psf->codec_data ;
  813. normfact = (psf->norm_double == SF_TRUE) ? (1.0 * 0x7FFFFFFF) : (1.0 / 0x100) ;
  815. iptr = psf->u.ibuf ;
  816. bufferlen = ARRAY_LEN (psf->u.ibuf) ;
  817. while (len > 0)
  818. { writecount = (len >= bufferlen) ? bufferlen : len ;
  819. for (k = 0 ; k < writecount ; k++)
  820. iptr [k] = lrint (normfact * ptr [total+k]) ;
  821. count = paf24_write (psf, ppaf24, iptr, writecount) ;
  822. total += count ;
  823. len -= writecount ;
  824. if (count != writecount)
  825. break ;
  826. } ;
  828. return total ;
  829. } /* paf24_write_d */