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

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

流媒体/Mpeg4/MP4

开发平台：

C/C++

wav_ima_adpcm.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. */
  20. #include <stdio.h>
  21. #include <unistd.h>
  22. #include <string.h>
  23. #include <math.h>
  25. #include "sndfile.h"
  26. #include "config.h"
  27. #include "sfendian.h"
  28. #include "common.h"
  29. #include "wav.h"
  31. typedef struct
  32. { unsigned int channels ;
  33. unsigned int blocksize ;
  34. unsigned int samplesperblock ; 
  35. } IMA_ADPCM_PUBLIC ;
  37. typedef struct
  38. { unsigned int channels, blocksize, samplesperblock, blocks ; 
  39. int blockcount, samplecount ;
  40. int previous [2] ;
  41. int stepindex [2] ;
  42. unsigned char *block ;
  43. short *samples ;
  44. unsigned char data [4] ; /* Dummy size */
  45. } IMA_ADPCM_PRIVATE ;
  47. /*============================================================================================
  48. ** Predefined IMA ADPCM data.
  49. */
  51. static int ima_index_adjust [16] = 
  52. { -1, -1, -1, -1, /* +0 - +3, decrease the step size */
  53.      2,  4,  6,  8,     /* +4 - +7, increase the step size */
  54.     -1, -1, -1, -1, /* -0 - -3, decrease the step size */
  55.      2,  4,  6,  8, /* -4 - -7, increase the step size */
  56. } ;
  58. static int ima_step_size [89] = 
  59. { 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 
  60. 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 
  61. 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 
  62. 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 
  63. 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442,
  64. 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 
  65. 32767
  66. } ;
  68. static int ima_read_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima) ;
  69. static int ima_read (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, short *ptr, int len) ;
  71. static int ima_write_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima) ;
  72. static int ima_write (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, short *ptr, int len) ;
  74. static unsigned int wav_srate2blocksize (unsigned int srate) ;
  78. /*============================================================================================
  79. ** IMA ADPCM Reader initialisation function.
  80. */
  82. int  ima_reader_init (SF_PRIVATE *psf, IMA_ADPCM_PUBLIC *public)
  83. { IMA_ADPCM_PRIVATE *pima ;
  84. unsigned int pimasize, count ;
  86. if (psf->mode != SF_MODE_READ)
  87. return SFE_BAD_MODE_RW ;
  89. pimasize = sizeof (IMA_ADPCM_PRIVATE) + public->blocksize + 3 * public->channels * public->samplesperblock ;
  91. if (! (pima = malloc (pimasize)))
  92. return SFE_MALLOC_FAILED ;
  94. psf->fdata = (void*) pima ;
  96. memset (pima, 0, pimasize) ;
  98. pima->block   = (unsigned char*) pima->data ;
  99. pima->samples = (short*) (pima->data + public->blocksize) ;
  101. pima->channels        = public->channels ;
  102. pima->blocksize       = public->blocksize ;
  103. pima->samplesperblock = public->samplesperblock ;
  105. if (psf->datalength % pima->blocksize)
  106. { psf_sprintf (psf, "*** Warning : data chunk seems to be truncated.n") ;
  107. pima->blocks = psf->datalength / pima->blocksize  + 1 ;
  108. }
  109. else
  110. pima->blocks = psf->datalength / pima->blocksize ;
  112. count = 2 * (pima->blocksize - 4 * pima->channels) / pima->channels + 1 ;
  113. if (pima->samplesperblock != count)
  114. psf_sprintf (psf, "*** Warning : samplesperblock should be %d.n", count) ;
  116. psf->sf.samples = pima->samplesperblock * pima->blocks ;
  118. ima_read_block (psf, pima) ; /* Read first block. */
  120. return 0 ;
  121. } /* ima_reader_init */
  123. int ima_writer_init (SF_PRIVATE *psf, IMA_ADPCM_PUBLIC *public)
  124. { IMA_ADPCM_PRIVATE *pima ;
  125. unsigned int  pimasize ;
  127. if (psf->mode != SF_MODE_WRITE)
  128. return SFE_BAD_MODE_RW ;
  130. public->blocksize       = wav_srate2blocksize (psf->sf.samplerate) ;
  131. public->samplesperblock = 2 * (public->blocksize - 4 * public->channels) / public->channels + 1 ;
  133. pimasize = sizeof (IMA_ADPCM_PRIVATE) + public->blocksize + 3 * public->channels * public->samplesperblock ;
  135. if (! (pima = malloc (pimasize)))
  136. return SFE_MALLOC_FAILED ;
  138. psf->fdata = (void*) pima ;
  140. memset (pima, 0, pimasize) ;
  142. pima->channels        = public->channels ;
  143. pima->blocksize       = public->blocksize ;
  144. pima->samplesperblock = public->samplesperblock ;
  146. pima->block   = (unsigned char*) pima->data ;
  147. pima->samples = (short*) (pima->data + public->blocksize) ;
  149. pima->samplecount = 0 ;
  151. return 0 ;
  152. } /* ima_writer_init */
  156. /*============================================================================================
  157. ** IMA ADPCM Read Functions.
  158. */
  160. int wav_ima_reader_init (SF_PRIVATE *psf, WAV_FMT *fmt)
  161. { IMA_ADPCM_PUBLIC public ;
  163. public.blocksize       = fmt->ima.blockalign ;
  164. public.channels        = fmt->ima.channels ;
  165. public.samplesperblock = fmt->ima.samplesperblock ;
  166. return ima_reader_init (psf, &public) ;
  167. } /* wav_ima_reader_init */
  169. static
  170. int ima_read_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima)
  171. { int chan, k, current, blockindex, index, indexstart ;
  172. short step, diff, bytecode, stepindex [2] ;
  174. pima->blockcount ++ ;
  175. pima->samplecount = 0 ;
  177. if (pima->blockcount > pima->blocks)
  178. { memset (pima->samples, 0, pima->samplesperblock * pima->channels * sizeof (short)) ;
  179. return 1 ;
  180. } ;
  182. if ((k = fread (pima->block, 1, pima->blocksize, psf->file)) != pima->blocksize)
  183. psf_sprintf (psf, "*** Warning : short read (%d != %d).n", k, pima->blocksize) ;
  185. /* Read and check the block header. */
  187. for (chan = 0 ; chan < pima->channels ; chan++)
  188. { current = pima->block [chan*4] | (pima->block [chan*4+1] << 8) ;
  189. if (current & 0x8000)
  190. current -= 0x10000 ;
  192. stepindex [chan] = pima->block [chan*4+2] ;
  193. if (stepindex [chan] < 0)
  194. stepindex [chan] = 0 ;
  195. else if (stepindex [chan] > 88)
  196. stepindex [chan] = 88 ;
  198. if (pima->block [chan*4+3] != 0)
  199. psf_sprintf (psf, "IMA ADPCM synchronisation error.n") ;
  201. pima->samples [chan] = current ;
  203. /* psf_sprintf (psf, "block %d : channel %d (current, index) : (%d, %d)n", 
  204. ** pima->blockcount, chan,  current, stepindex [chan]) ;
  205. */
  206. } ;
  208. /* Pull apart the packed 4 bit samples and store them in their
  209. ** correct sample positions.
  210. */
  212. blockindex = 4 * pima->channels ;
  214. indexstart = pima->channels ;
  215. while (blockindex <  pima->blocksize)
  216. { for (chan = 0 ; chan < pima->channels ; chan++)
  217. { index = indexstart + chan ;
  218. for (k = 0 ; k < 4 ; k++)
  219. { bytecode = pima->block [blockindex++] ;
  220. pima->samples [index] = bytecode & 0x0F ;
  221. index += pima->channels ;
  222. pima->samples [index] = (bytecode >> 4) & 0x0F ;
  223. index += pima->channels ;
  224. } ;
  225. } ;
  226. indexstart += 8 * pima->channels ;
  227. } ;
  229. /* Decode the encoded 4 bit samples. */
  231. for (k = pima->channels ; k < (pima->samplesperblock * pima->channels) ; k ++)
  232. { chan = (pima->channels > 1) ? (k % 2) : 0 ;
  234. bytecode = pima->samples [k] & 0xF ;
  236. step = ima_step_size [stepindex [chan]] ;
  237. current = pima->samples [k - pima->channels] ;
  238.   
  239. diff = step >> 3 ;
  240. if (bytecode & 1) 
  241. diff += step >> 2 ;
  242. if (bytecode & 2) 
  243. diff += step >> 1 ;
  244. if (bytecode & 4) 
  245. diff += step ;
  246. if (bytecode & 8) 
  247. diff = -diff ;
  249. current += diff ;
  251. if (current > 32767) 
  252. current = 32767;
  253. else if (current < -32768) 
  254. current = -32768 ;
  256. stepindex [chan] += ima_index_adjust [bytecode] ;
  258. if (stepindex [chan] < 0) 
  259. stepindex [chan] = 0 ;
  260. else if (stepindex [chan] > 88) 
  261. stepindex [chan] = 88 ;
  263. pima->samples [k] = current ;
  264. } ;
  266. return 1 ;
  267. } /* ima_read_block */
  269. static
  270. int ima_read (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, short *ptr, int len)
  271. { int count, total = 0, index = 0 ;
  273. while (index < len)
  274. { if (pima->blockcount >= pima->blocks && pima->samplecount >= pima->samplesperblock)
  275. { memset (&(ptr[index]), 0, (len - index) * sizeof (short)) ;
  276. return total ;
  277. } ;
  279. if (pima->samplecount >= pima->samplesperblock)
  280. ima_read_block (psf, pima) ;
  282. count = (pima->samplesperblock - pima->samplecount) * pima->channels ;
  283. count = (len - index > count) ? count : len - index ;
  285. memcpy (&(ptr[index]), &(pima->samples [pima->samplecount * pima->channels]), count * sizeof (short)) ;
  286. index += count ;
  287. pima->samplecount += count / pima->channels ;
  288. total = index ;
  289. } ;
  291. return total ;
  292. } /* ima_read */
  294. int ima_read_s (SF_PRIVATE *psf, short *ptr, int len)
  295. { IMA_ADPCM_PRIVATE  *pima ; 
  296. int total ;
  298. if (! psf->fdata)
  299. return 0 ;
  300. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  302. total = ima_read (psf, pima, ptr, len) ;
  304. return total ;
  305. } /* ima_read_s */
  307. int ima_read_i  (SF_PRIVATE *psf, int *ptr, int len)
  308. { IMA_ADPCM_PRIVATE *pima ; 
  309. short *sptr ;
  310. int k, bufferlen, readcount = 0, count ;
  311. int index = 0, total = 0 ;
  313. if (! psf->fdata)
  314. return 0 ;
  315. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  317. sptr = (short*) psf->buffer ;
  318. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  319. while (len > 0)
  320. { readcount = (len >= bufferlen) ? bufferlen : len ;
  321. count = ima_read (psf, pima, sptr, readcount) ;
  322. for (k = 0 ; k < readcount ; k++)
  323. ptr [index+k] = (int) (sptr [k]) ;
  324. index += readcount ;
  325. total += count ;
  326. len -= readcount ;
  327. } ;
  328. return total ;
  329. } /* ima_read_i */
  331. int ima_read_d  (SF_PRIVATE *psf, double *ptr, int len, int normalize)
  332. { IMA_ADPCM_PRIVATE *pima ; 
  333. short *sptr ;
  334. int k, bufferlen, readcount = 0, count ;
  335. int index = 0, total = 0 ;
  336. double  normfact ;
  338. normfact = (normalize ? 1.0 / ((double) 0x8000) : 1.0) ;
  340. if (! psf->fdata)
  341. return 0 ;
  342. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  344. sptr = (short*) psf->buffer ;
  345. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  346. while (len > 0)
  347. { readcount = (len >= bufferlen) ? bufferlen : len ;
  348. count = ima_read (psf, pima, sptr, readcount) ;
  349. for (k = 0 ; k < readcount ; k++)
  350. ptr [index+k] = normfact * (double) (sptr [k]) ;
  351. index += readcount ;
  352. total += count ;
  353. len -= readcount ;
  354. } ;
  355. return total ;
  356. } /* ima_read_d */
  359. off_t    ima_seek   (SF_PRIVATE *psf, off_t offset, int whence)
  360. { IMA_ADPCM_PRIVATE *pima ; 
  361. int newblock, newsample ;
  363. if (! psf->fdata)
  364. return 0 ;
  365. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  367. if (! (psf->blockwidth && psf->datalength && psf->dataoffset))
  368. { psf->error = SFE_BAD_SEEK ;
  369. return ((off_t) -1) ;
  370. } ;
  372. switch (whence)
  373. { case SEEK_SET :
  374. if (offset < 0 || offset > pima->blocks * pima->samplesperblock)
  375. { psf->error = SFE_BAD_SEEK ;
  376. return ((off_t) -1) ;
  377. } ;
  378. newblock  = offset / pima->samplesperblock ;
  379. newsample = offset % pima->samplesperblock ;
  380. break ;
  382. case SEEK_CUR :
  383. if (psf->current + offset < 0 || psf->current + offset > pima->blocks * pima->samplesperblock)
  384. { psf->error = SFE_BAD_SEEK ;
  385. return ((off_t) -1) ;
  386. } ;
  387. newblock  = (psf->current + offset) / pima->samplesperblock ;
  388. newsample = (psf->current + offset) % pima->samplesperblock ;
  389. break ;
  391. case SEEK_END :
  392. if (offset > 0 || pima->samplesperblock * pima->blocks + offset < 0)
  393. { psf->error = SFE_BAD_SEEK ;
  394. return ((off_t) -1) ;
  395. } ;
  396. newblock  = (pima->samplesperblock * pima->blocks + offset) / pima->samplesperblock ;
  397. newsample = (pima->samplesperblock * pima->blocks + offset) % pima->samplesperblock ;
  398. break ;
  400. default : 
  401. psf->error = SFE_BAD_SEEK ;
  402. return ((off_t) -1) ;
  403. } ;
  405. if (psf->mode == SF_MODE_READ)
  406. { fseek (psf->file, (int) (psf->dataoffset + newblock * pima->blocksize), SEEK_SET) ;
  407. pima->blockcount  = newblock ;
  408. ima_read_block (psf, pima) ;
  409. pima->samplecount = newsample ;
  410. }
  411. else
  412. { /* What to do about write??? */ 
  413. psf->error = SFE_BAD_SEEK ;
  414. return ((off_t) -1) ;
  415. } ;
  417. psf->current = newblock * pima->samplesperblock + newsample ;
  418. return psf->current ;
  419. } /* ima_seek */
  421. /*==========================================================================================
  422. ** IMA ADPCM Write Functions.
  423. */
  425. int wav_ima_writer_init (SF_PRIVATE *psf, WAV_FMT *fmt)
  426. { IMA_ADPCM_PUBLIC  public ;
  427. int error ;
  429. if (fmt->format != 0x0011)
  430. psf_sprintf (psf, "*** Warning : format tag != WAVE_FORMAT_IMA_ADPCM.n") ;
  432. public.blocksize = wav_srate2blocksize (fmt->ima.samplerate) ;
  433. public.channels  = psf->sf.channels ;
  434. public.samplesperblock = 2 * (public.blocksize - 4 * psf->sf.channels) / psf->sf.channels + 1 ;
  436. if ((error = ima_writer_init (psf, &public)))
  437. return error ;
  439. fmt->ima.blockalign      = public.blocksize ;
  440. fmt->ima.bitwidth        = 4 ;
  441. fmt->ima.extrabytes      = 2 ;
  442. fmt->ima.samplesperblock = public.samplesperblock ;
  443. fmt->ima.bytespersec     = (fmt->ima.samplerate * fmt->ima.blockalign) / fmt->ima.samplesperblock ;
  445. return 0 ;
  446. } /* wav_ima_writer_init */
  449. /*==========================================================================================
  450. */
  452. static
  453. int ima_write_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima)
  454. { int chan, k, step, diff, vpdiff, blockindex, index, indexstart ;
  455. short bytecode, mask ;
  457. /* Write the block header. */
  459. for (chan = 0 ; chan < pima->channels ; chan++)
  460. { pima->block [chan*4]   = pima->samples [chan] & 0xFF ;
  461. pima->block [chan*4+1] = (pima->samples [chan] >> 8) & 0xFF ;
  463. pima->block [chan*4+2] = pima->stepindex [chan] ;
  464. pima->block [chan*4+3] = 0 ;
  465. } ;
  467. pima->previous  [0] = pima->samples [0] ;
  468. pima->previous  [1] = pima->samples [1] ;
  470. /* Encode the samples as 4 bit. */
  472. for (k = pima->channels ; k < (pima->samplesperblock * pima->channels) ; k ++)
  473. { chan = (pima->channels > 1) ? (k % 2) : 0 ;
  475. diff = pima->samples [k] - pima->previous [chan] ;
  477. bytecode = 0 ;
  478. step = ima_step_size [pima->stepindex [chan]] ;
  479. vpdiff = step >> 3 ;
  480. if (diff < 0) 
  481. { bytecode = 8 ; 
  482. diff = -diff ;
  483. } ;
  484. mask = 4 ;
  485. while (mask)
  486. { if (diff >= step)
  487. { bytecode |= mask ;
  488. diff -= step ;
  489. vpdiff += step ;
  490. } ;
  491. step >>= 1 ;
  492. mask >>= 1 ;
  493. } ;
  495. if (bytecode & 8)
  496. pima->previous [chan] -= vpdiff ;
  497. else
  498. pima->previous [chan] += vpdiff ;
  500. if (pima->previous [chan] > 32767) 
  501. pima->previous [chan] = 32767;
  502. else if (pima->previous [chan] < -32768) 
  503. pima->previous [chan] = -32768;
  505. pima->stepindex [chan] += ima_index_adjust [bytecode] ;
  506. if (pima->stepindex [chan] < 0)
  507. pima->stepindex [chan] = 0 ;
  508. else if (pima->stepindex [chan] > 88)
  509. pima->stepindex [chan] = 88 ;
  511. pima->samples [k] = bytecode ;
  512. } ;
  514. /* Pack the 4 bit encoded samples. */
  516. blockindex = 4 * pima->channels ;
  518. indexstart = pima->channels ;
  519. while (blockindex <  pima->blocksize)
  520. { for (chan = 0 ; chan < pima->channels ; chan++)
  521. { index = indexstart + chan ;
  522. for (k = 0 ; k < 4 ; k++)
  523. { pima->block [blockindex] = pima->samples [index] & 0x0F ;
  524. index += pima->channels ;
  525. pima->block [blockindex] |= (pima->samples [index] << 4) & 0xF0 ;
  526. index += pima->channels ;
  527. blockindex ++ ;
  528. } ;
  529. } ;
  530. indexstart += 8 * pima->channels ;
  531. } ;
  533. /* Write the block to disk. */
  535. if ((k = fwrite (pima->block, 1, pima->blocksize, psf->file)) != pima->blocksize)
  536. psf_sprintf (psf, "*** Warning : short write (%d != %d).n", k, pima->blocksize) ;
  538. memset (pima->samples, 0, pima->samplesperblock * sizeof (short)) ;
  539. pima->samplecount = 0 ;
  541. return 1 ;
  542. } /* ima_write_block */
  544. static
  545. int ima_write (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, short *ptr, int len)
  546. { int count, total = 0, index = 0 ;
  548. while (index < len)
  549. { count = (pima->samplesperblock - pima->samplecount) * pima->channels ;
  551. if (count > len - index)
  552. count = len - index ;
  554. memcpy (&(pima->samples [pima->samplecount * pima->channels]), &(ptr [index]), count * sizeof (short)) ;
  555. index += count ;
  556. pima->samplecount += count / pima->channels ;
  557. total = index ;
  559. if (pima->samplecount >= pima->samplesperblock)
  560. ima_write_block (psf, pima) ;
  561. } ;
  563. return total ;
  564. } /* ima_write */
  566. int ima_write_s (SF_PRIVATE *psf, short *ptr, int len)
  567. { IMA_ADPCM_PRIVATE  *pima ; 
  568. int total ;
  570. if (! psf->fdata)
  571. return 0 ;
  572. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  574. total = ima_write (psf, pima, ptr, len) ;
  576. return total ;
  577. } /* ima_write_s */
  579. int ima_write_i  (SF_PRIVATE *psf, int *ptr, int len)
  580. { IMA_ADPCM_PRIVATE *pima ; 
  581. short *sptr ;
  582. int k, bufferlen, writecount = 0, count ;
  583. int index = 0, total = 0 ;
  585. if (! psf->fdata)
  586. return 0 ;
  587. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  589. sptr = (short*) psf->buffer ;
  590. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  591. while (len > 0)
  592. { writecount = (len >= bufferlen) ? bufferlen : len ;
  593. for (k = 0 ; k < writecount ; k++)
  594. sptr [k] = (short) ptr [index+k] ;
  595. count = ima_write (psf, pima, sptr, writecount) ;
  596. index += writecount ;
  597. total += count ;
  598. len -= writecount ;
  599. } ;
  600. return total ;
  601. } /* ima_write_i */
  603. int ima_write_d  (SF_PRIVATE *psf, double *ptr, int len, int normalize)
  604. { IMA_ADPCM_PRIVATE *pima ; 
  605. short *sptr ;
  606. int k, bufferlen, writecount = 0, count ;
  607. int index = 0, total = 0 ;
  608. double  normfact ;
  610. normfact = (normalize ? ((double) 0x8000) : 1.0) ;
  612. if (! psf->fdata)
  613. return 0 ;
  614. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  616. sptr = (short*) psf->buffer ;
  617. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  618. while (len > 0)
  619. { writecount = (len >= bufferlen) ? bufferlen : len ;
  620. for (k = 0 ; k < writecount ; k++)
  621. sptr [k] = (short) (normfact * ptr [index+k])  ;
  622. count = ima_write (psf, pima, sptr, writecount) ;
  623. index += writecount ;
  624. total += count ;
  625. len -= writecount ;
  626. } ;
  627. return total ;
  628. } /* ima_write_d */
  630. int wav_ima_close (SF_PRIVATE  *psf)
  631. { IMA_ADPCM_PRIVATE *pima ; 
  632. unsigned int dword ;
  634. if (! psf->fdata)
  635. return wav_close (psf) ;
  637. pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
  639. if (psf->mode == SF_MODE_WRITE)
  640. { /* If a block has been partially assembled, write it out
  641. ** as the final block.
  642. */
  644. if (pima->samplecount && pima->samplecount < pima->samplesperblock)
  645. ima_write_block (psf, pima) ;
  647. /*  Now we know for certain the length of the file we can
  648. **  re-write correct values for the RIFF and data chunks.
  649. */
  650.  
  651. fseek (psf->file, 0, SEEK_END) ;
  652. psf->filelength = ftell (psf->file) ;
  654. /* Fix RIFF size. */
  655. dword = H2LE_INT (psf->filelength - 2 * sizeof (dword)) ;
  656. fseek (psf->file, sizeof (dword), SEEK_SET) ;
  657. fwrite (&dword, sizeof (dword), 1, psf->file) ;
  659. psf->datalength = psf->filelength - psf->dataoffset ;
  660. fseek (psf->file, (int) (psf->dataoffset - sizeof (dword)), SEEK_SET) ;
  661. dword = H2LE_INT (psf->datalength) ;
  662. fwrite (&dword, sizeof (dword), 1, psf->file) ;
  663. } ;
  665. if (psf->fdata)
  666. free (psf->fdata) ;
  667. psf->fdata = NULL ;
  669. return 0 ;
  670. } /* wav_ima_close */
  672. static
  673. unsigned int wav_srate2blocksize (unsigned int srate)
  674. { if (srate < 12000)
  675. return 256 ;
  676. if (srate < 23000)
  677. return 512 ;
  678. return 1024 ;
  679. } /* wav_srate2blocksize */