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

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

流媒体/Mpeg4/MP4

开发平台：

C/C++

wav_ms_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"
  32. typedef struct
  33. { unsigned int channels, blocksize, samplesperblock, blocks, dataremaining ; 
  34. int blockcount, samplecount ;
  35. unsigned char *block ;
  36. short *samples ;
  37. unsigned char dummydata [4] ; /* Dummy size */
  38. } MSADPCM_PRIVATE ;
  40. /*============================================================================================
  41. ** MS ADPCM static data and functions.
  42. */
  44. static int AdaptationTable []    = 
  45. { 230, 230, 230, 230, 307, 409, 512, 614,
  46. 768, 614, 512, 409, 307, 230, 230, 230 
  47. } ;
  49. /* TODO : The first 7 coef's are are always hardcode and must
  50.    appear in the actual WAVE file.  They should be read in
  51.    in case a sound program added extras to the list. */
  53. static int AdaptCoeff1 [] = 
  54. { 256, 512, 0, 192, 240, 460, 392 
  55. } ;
  57. static int AdaptCoeff2 [] = 
  58. { 0, -256, 0, 64, 0, -208, -232
  59. } ;
  61. /*============================================================================================
  62. ** MS ADPCM Block Layout.
  63. ** ======================
  64. ** Block is usually 256, 512 or 1024 bytes depending on sample rate.
  65. ** For a mono file, the block is laid out as follows:
  66. ** byte purpose
  67. ** 0 block predictor [0..6]
  68. ** 1,2 initial idelta (positive)
  69. ** 3,4 sample 1
  70. ** 5,6 sample 0
  71. ** 7..n packed bytecodes
  72. **
  73. ** For a stereo file, the block is laid out as follows:
  74. ** byte purpose
  75. ** 0 block predictor [0..6] for left channel
  76. ** 1 block predictor [0..6] for right channel
  77. ** 2,3 initial idelta (positive) for left channel
  78. ** 4,5 initial idelta (positive) for right channel
  79. ** 6,7 sample 1 for left channel
  80. ** 8,9 sample 1 for right channel
  81. ** 10,11 sample 0 for left channel
  82. ** 12,13 sample 0 for right channel
  83. ** 14..n packed bytecodes
  84. */
  86. /*============================================================================================
  87. ** Static functions.
  88. */
  90. static int msadpcm_read_block (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms) ;
  91. static int msadpcm_read (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, short *ptr, int len) ;
  93. static int msadpcm_write_block (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms) ;
  94. static int msadpcm_write (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, short *ptr, int len) ;
  96. static unsigned int srate2blocksize (unsigned int srate) ;
  97. static void choose_predictor (unsigned int channels, short *data, int *bpred, int *idelta) ;
  99. /*============================================================================================
  100. ** MS ADPCM Read Functions.
  101. */
  103. int msadpcm_reader_init (SF_PRIVATE *psf, WAV_FMT *fmt)
  104. { MSADPCM_PRIVATE *pms ;
  105. unsigned int pmssize ;
  106. int count ;
  108. pmssize = sizeof (MSADPCM_PRIVATE) + fmt->msadpcm.blockalign + 3 * fmt->msadpcm.channels * fmt->msadpcm.samplesperblock ;
  110. if (! (psf->fdata = malloc (pmssize)))
  111. return SFE_MALLOC_FAILED ;
  112. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  113. memset (pms, 0, pmssize) ;
  115. pms->block   = (unsigned char*) pms->dummydata ;
  116. pms->samples = (short*) (pms->dummydata + fmt->msadpcm.blockalign) ;
  118. pms->channels        = fmt->msadpcm.channels ;
  119. pms->blocksize       = fmt->msadpcm.blockalign ;
  120. pms->samplesperblock = fmt->msadpcm.samplesperblock ;
  122. pms->dataremaining  = psf->datalength ;
  124. if (psf->datalength % pms->blocksize)
  125. pms->blocks = psf->datalength / pms->blocksize  + 1 ;
  126. else
  127. pms->blocks = psf->datalength / pms->blocksize ;
  129. count = 2 * (pms->blocksize - 6 * pms->channels) / pms->channels ;
  130. if (pms->samplesperblock != count)
  131. psf_sprintf (psf, "*** Warning : samplesperblock shoud be %d.n", count) ;
  133. psf->sf.samples = (psf->datalength / pms->blocksize) * pms->samplesperblock ;
  135. psf_sprintf (psf, " bpred   ideltan") ;
  137. msadpcm_read_block (psf, pms) ;
  139. return 0 ;
  140. } /* msadpcm_reader_init */
  142. static
  143. int msadpcm_read_block (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms)
  144. { int chan, k, blockindex, sampleindex ;
  145. short bytecode, bpred [2], chan_idelta [2] ;
  147.     int predict ;
  148.     int current ;
  149.     int idelta ;
  151. pms->blockcount ++ ;
  152. pms->samplecount = 0 ;
  154. if (pms->blockcount > pms->blocks)
  155. { memset (pms->samples, 0, pms->samplesperblock * pms->channels) ;
  156. return 1 ;
  157. } ;
  159. if ((k = fread (pms->block, 1, pms->blocksize, psf->file)) != pms->blocksize)
  160. psf_sprintf (psf, "*** Warning : short read (%d != %d).n", k, pms->blocksize) ;
  162. /* Read and check the block header. */
  164. if (pms->channels == 1)
  165. { bpred [0] = pms->block [0] ;
  167. if (bpred [0] >= 7)
  168. psf_sprintf (psf, "MS ADPCM synchronisation error (%d).n", bpred [0]) ;
  170. chan_idelta [0] = pms->block [1] | (pms->block [2] << 8) ;
  171. chan_idelta [1] = 0 ;
  173. psf_sprintf (psf, "(%d) (%d)n", bpred [0], chan_idelta [0]) ;
  175. pms->samples [1] = pms->block [3] | (pms->block [4] << 8) ;
  176. pms->samples [0] = pms->block [5] | (pms->block [6] << 8) ;
  177. blockindex = 7 ;
  178. }
  179. else
  180. { bpred [0] = pms->block [0] ;
  181. bpred [1] = pms->block [1] ;
  183. if (bpred [0] >= 7 || bpred [1] >= 7)
  184. psf_sprintf (psf, "MS ADPCM synchronisation error (%d %d).n", bpred [0], bpred [1]) ;
  186. chan_idelta [0] = pms->block [2] | (pms->block [3] << 8) ;
  187. chan_idelta [1] = pms->block [4] | (pms->block [5] << 8) ;
  189. psf_sprintf (psf, "(%d, %d) (%d, %d)n", bpred [0], bpred [1], chan_idelta [0], chan_idelta [1]) ;
  191. pms->samples [2] = pms->block [6] | (pms->block [7] << 8) ;
  192. pms->samples [3] = pms->block [8] | (pms->block [9] << 8) ;
  194. pms->samples [0] = pms->block [10] | (pms->block [11] << 8) ;
  195. pms->samples [1] = pms->block [12] | (pms->block [13] << 8) ;
  197. blockindex = 14 ;
  198. } ;
  200.     if (chan_idelta [0] & 0x8000) 
  201. chan_idelta [0] -= 0x10000 ;
  202.     if (chan_idelta [1] & 0x8000) 
  203. chan_idelta [1] -= 0x10000 ;
  205. /* Pull apart the packed 4 bit samples and store them in their
  206. ** correct sample positions.
  207. */
  209. sampleindex = 2 * pms->channels ;
  210. while (blockindex <  pms->blocksize)
  211. { bytecode = pms->block [blockindex++] ;
  212.    pms->samples [sampleindex++] = (bytecode >> 4) & 0x0F ;
  213. pms->samples [sampleindex++] = bytecode & 0x0F ;
  214. } ;
  216. /* Decode the encoded 4 bit samples. */
  218. for (k = 2 * pms->channels ; k < (pms->samplesperblock * pms->channels) ; k ++)
  219. { chan = (pms->channels > 1) ? (k % 2) : 0 ;
  221. bytecode = pms->samples [k] & 0xF ;
  223.     /** Compute next Adaptive Scale Factor (ASF) **/
  224.     idelta = chan_idelta [chan] ;
  225.     chan_idelta [chan] = (AdaptationTable [bytecode] * idelta) >> 8 ; /* => / 256 => FIXED_POINT_ADAPTATION_BASE == 256 */
  226.     if (chan_idelta [chan] < 16) 
  227. chan_idelta [chan] = 16 ;
  228.     if (bytecode & 0x8) 
  229. bytecode -= 0x10 ;
  231.      predict = ((pms->samples [k - pms->channels] * AdaptCoeff1 [bpred [chan]]) 
  232. + (pms->samples [k - 2 * pms->channels] * AdaptCoeff2 [bpred [chan]])) >> 8 ; /* => / 256 => FIXED_POINT_COEFF_BASE == 256 */
  233.      current = (bytecode * idelta) + predict;
  234.     
  235.     if (current > 32767) 
  236. current = 32767 ;
  237.     else if (current < -32768) 
  238. current = -32768 ;
  239.     
  240. pms->samples [k] = current ;
  241. } ;
  243. return 1 ;
  244. } /* msadpcm_read_block */
  246. static
  247. int msadpcm_read (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, short *ptr, int len)
  248. { int count, total = 0, index = 0 ;
  250. while (index < len)
  251. { if (pms->blockcount >= pms->blocks && pms->samplecount >= pms->samplesperblock)
  252. { memset (&(ptr[index]), 0, (len - index) * sizeof (short)) ;
  253. return total ;
  254. } ;
  256. if (pms->samplecount >= pms->samplesperblock)
  257. msadpcm_read_block (psf, pms) ;
  259. count = (pms->samplesperblock - pms->samplecount) * pms->channels ;
  260. count = (len - index > count) ? count : len - index ;
  262. memcpy (&(ptr[index]), &(pms->samples [pms->samplecount * pms->channels]), count * sizeof (short)) ;
  263. index += count ;
  264. pms->samplecount += count / pms->channels ;
  265. total = index ;
  266. } ;
  268. return total ;
  269. } /* msadpcm_read */
  271. int msadpcm_read_s (SF_PRIVATE *psf, short *ptr, int len)
  272. { MSADPCM_PRIVATE  *pms ; 
  273. int total ;
  275. if (! psf->fdata)
  276. return 0 ;
  277. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  279. total = msadpcm_read (psf, pms, ptr, len) ;
  281. return total ;
  282. } /* msadpcm_read_s */
  284. int msadpcm_read_i  (SF_PRIVATE *psf, int *ptr, int len)
  285. { MSADPCM_PRIVATE *pms ; 
  286. short *sptr ;
  287. int k, bufferlen, readcount = 0, count ;
  288. int index = 0, total = 0 ;
  290. if (! psf->fdata)
  291. return 0 ;
  292. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  294. sptr = (short*) psf->buffer ;
  295. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  296. while (len > 0)
  297. { readcount = (len >= bufferlen) ? bufferlen : len ;
  298. count = msadpcm_read (psf, pms, sptr, readcount) ;
  299. for (k = 0 ; k < readcount ; k++)
  300. ptr [index+k] = (int) (sptr [k]) ;
  301. index += readcount ;
  302. total += count ;
  303. len -= readcount ;
  304. } ;
  305. return total ;
  306. } /* msadpcm_read_i */
  308. int msadpcm_read_d  (SF_PRIVATE *psf, double *ptr, int len, int normalize)
  309. { MSADPCM_PRIVATE *pms ; 
  310. short *sptr ;
  311. int k, bufferlen, readcount = 0, count ;
  312. int index = 0, total = 0 ;
  313. double  normfact ;
  315. normfact = (normalize ? 1.0 / ((double) 0x8000) : 1.0) ;
  317. if (! psf->fdata)
  318. return 0 ;
  319. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  321. sptr = (short*) psf->buffer ;
  322. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  323. while (len > 0)
  324. { readcount = (len >= bufferlen) ? bufferlen : len ;
  325. count = msadpcm_read (psf, pms, sptr, readcount) ;
  326. for (k = 0 ; k < readcount ; k++)
  327. ptr [index+k] = normfact * (double) (sptr [k]) ;
  328. index += readcount ;
  329. total += count ;
  330. len -= readcount ;
  331. } ;
  332. return total ;
  333. } /* msadpcm_read_d */
  336. off_t    msadpcm_seek   (SF_PRIVATE *psf, off_t offset, int whence)
  337. { MSADPCM_PRIVATE *pms ; 
  338. int newblock, newsample ;
  340. if (! psf->fdata)
  341. return 0 ;
  342. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  344. if (! (psf->blockwidth && psf->datalength && psf->dataoffset))
  345. { psf->error = SFE_BAD_SEEK ;
  346. return ((off_t) -1) ;
  347. } ;
  349. switch (whence)
  350. { case SEEK_SET :
  351. if (offset < 0 || offset > pms->blocks * pms->samplesperblock)
  352. { psf->error = SFE_BAD_SEEK ;
  353. return ((off_t) -1) ;
  354. } ;
  355. newblock  = offset / pms->samplesperblock ;
  356. newsample = offset % pms->samplesperblock ;
  357. break ;
  359. case SEEK_CUR :
  360. if (psf->current + offset < 0 || psf->current + offset > pms->blocks * pms->samplesperblock)
  361. { psf->error = SFE_BAD_SEEK ;
  362. return ((off_t) -1) ;
  363. } ;
  364. newblock  = (psf->current + offset) / pms->samplesperblock ;
  365. newsample = (psf->current + offset) % pms->samplesperblock ;
  366. break ;
  368. case SEEK_END :
  369. if (offset > 0 || pms->samplesperblock * pms->blocks + offset < 0)
  370. { psf->error = SFE_BAD_SEEK ;
  371. return ((off_t) -1) ;
  372. } ;
  373. newblock  = (pms->samplesperblock * pms->blocks + offset) / pms->samplesperblock ;
  374. newsample = (pms->samplesperblock * pms->blocks + offset) % pms->samplesperblock ;
  375. break ;
  377. default : 
  378. psf->error = SFE_BAD_SEEK ;
  379. return ((off_t) -1) ;
  380. } ;
  382. if (psf->mode == SF_MODE_READ)
  383. { fseek (psf->file, (int) (psf->dataoffset + newblock * pms->blocksize), SEEK_SET) ;
  384. pms->blockcount  = newblock ;
  385. msadpcm_read_block (psf, pms) ;
  386. pms->samplecount = newsample ;
  387. }
  388. else
  389. { /* What to do about write??? */ 
  390. psf->error = SFE_BAD_SEEK ;
  391. return ((off_t) -1) ;
  392. } ;
  394. psf->current = newblock * pms->samplesperblock + newsample ;
  395. return psf->current ;
  396. } /* msadpcm_seek */
  398. /*==========================================================================================
  399. ** MS ADPCM Write Functions.
  400. */
  402. int msadpcm_writer_init (SF_PRIVATE *psf, WAV_FMT *fmt)
  403. { MSADPCM_PRIVATE *pms ;
  404. unsigned int  k, pmssize ;
  406. if (fmt->format != 0x0002)
  407. psf_sprintf (psf, "*** Warning : format tag != WAVE_FORMAT_MS_ADPCM.n") ;
  409. fmt->msadpcm.blockalign      = srate2blocksize (fmt->msadpcm.samplerate) ;
  410. fmt->msadpcm.bitwidth        = 4 ;
  411. fmt->msadpcm.extrabytes      = 32 ;
  412. fmt->msadpcm.samplesperblock = 2 + 2 * (fmt->msadpcm.blockalign - 7 * fmt->msadpcm.channels) / fmt->msadpcm.channels ;
  414. fmt->msadpcm.bytespersec     = (fmt->msadpcm.samplerate * fmt->msadpcm.blockalign) / fmt->msadpcm.samplesperblock ;
  416. fmt->msadpcm.numcoeffs = 7 ;
  417. for (k = 0 ; k < 7 ; k++)
  418. { fmt->msadpcm.coeffs[k].coeff1 = AdaptCoeff1 [k] ;
  419. fmt->msadpcm.coeffs[k].coeff2 = AdaptCoeff2 [k] ;
  420. } ;
  422. pmssize = sizeof (MSADPCM_PRIVATE) + fmt->msadpcm.blockalign + 3 * fmt->msadpcm.channels * fmt->msadpcm.samplesperblock ;
  424. if (! (psf->fdata = malloc (pmssize)))
  425. return SFE_MALLOC_FAILED ;
  426. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  427. memset (pms, 0, pmssize) ;
  429. pms->channels        = fmt->msadpcm.channels ;
  430. pms->blocksize       = fmt->msadpcm.blockalign ;
  431. pms->samplesperblock = fmt->msadpcm.samplesperblock ;
  433. pms->block   = (unsigned char*) pms->dummydata ;
  434. pms->samples = (short*) (pms->dummydata + fmt->msadpcm.blockalign) ;
  436. pms->samplecount = 0 ;
  438. return 0 ;
  439. } /* msadpcm_writer_init */
  441. /*==========================================================================================
  442. */
  444. static
  445. int msadpcm_write_block (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms)
  446. { unsigned int blockindex ;
  447. unsigned char byte ;
  448. int chan, k, predict, bpred [2], idelta [2], errordelta, newsamp ;
  450. choose_predictor (pms->channels, pms->samples, bpred, idelta) ;
  452. /* Write the block header. */
  454. if (pms->channels == 1)
  455. { pms->block [0] = bpred [0] ;
  456. pms->block [1] = idelta [0] & 0xFF ;
  457. pms->block [2] = idelta [0] >> 8 ;
  458. pms->block [3] = pms->samples [1] & 0xFF ;
  459. pms->block [4] = pms->samples [1] >> 8 ;
  460. pms->block [5] = pms->samples [0] & 0xFF ;
  461. pms->block [6] = pms->samples [0] >> 8 ;
  463. blockindex = 7 ;
  464. byte = 0 ;
  466. /* Encode the samples as 4 bit. */
  468. for (k = 2 ; k < pms->samplesperblock ; k++)
  469. { predict = (pms->samples [k-1] * AdaptCoeff1 [bpred [0]] + pms->samples [k-2] * AdaptCoeff2 [bpred [0]]) >> 8 ;
  470. errordelta = (pms->samples [k] - predict) / idelta [0] ;
  471. if (errordelta < -8)
  472. errordelta = -8 ;
  473. else if (errordelta > 7)
  474. errordelta = 7 ;
  475. newsamp = predict + (idelta [0] * errordelta) ;
  476. if (newsamp > 32767)
  477. newsamp = 32767 ;
  478. else if (newsamp < -32768)
  479. newsamp = -32768 ;
  480. if (errordelta < 0)
  481. errordelta += 0x10 ;
  483. byte = (byte << 4) | (errordelta & 0xF) ;
  484. if (k % 2)
  485. { pms->block [blockindex++] = byte ;
  486. byte = 0 ;
  487. } ;
  489. idelta [0] = (idelta [0] * AdaptationTable [errordelta]) >> 8 ;
  490. if (idelta [0] < 16)
  491. idelta [0] = 16 ;
  492. pms->samples [k] = newsamp ;
  493. } ;
  494. }
  495. else
  496. { /* Stereo file. */
  498. pms->block [0] = bpred [0] ;
  499. pms->block [1] = bpred [1] ;
  501. pms->block [2] = idelta [0] & 0xFF ;
  502. pms->block [3] = idelta [0] >> 8 ;
  503. pms->block [4] = idelta [1] & 0xFF ;
  504. pms->block [5] = idelta [1] >> 8 ;
  506. pms->block [6] = pms->samples [2] & 0xFF ;
  507. pms->block [7] = pms->samples [2] >> 8 ;
  508. pms->block [8] = pms->samples [3] & 0xFF ;
  509. pms->block [9] = pms->samples [3] >> 8 ;
  511. pms->block [10] = pms->samples [0] & 0xFF ;
  512. pms->block [11] = pms->samples [0] >> 8 ;
  513. pms->block [12] = pms->samples [1] & 0xFF ;
  514. pms->block [13] = pms->samples [1] >> 8 ;
  516. blockindex = 14 ;
  517. byte = 0 ;
  518. chan = 1 ;
  520. for (k = 4 ; k < pms->samplesperblock ; k+=2)
  521. { chan = chan ? 0 : 1 ;
  522. predict = (pms->samples [k-2] * AdaptCoeff1 [bpred [chan]] + pms->samples [k-4] * AdaptCoeff2 [bpred [chan]]) >> 8 ;
  523. errordelta = (pms->samples [k] - predict) / idelta [chan] ;
  524. if (errordelta < -8)
  525. errordelta = -8 ;
  526. else if (errordelta > 7)
  527. errordelta = 7 ;
  528. newsamp = predict + (idelta [chan] * errordelta) ;
  529. if (newsamp > 32767)
  530. newsamp = 32767 ;
  531. else if (newsamp < -32768)
  532. newsamp = -32768 ;
  533. if (errordelta < 0)
  534. errordelta += 0x10 ;
  536. byte = (byte << 4) | (errordelta & 0xF) ;
  537. if (k % 2)
  538. { pms->block [blockindex++] = byte ;
  539. byte = 0 ;
  540. } ;
  542. idelta [chan] = (idelta [chan] * AdaptationTable [errordelta]) >> 8 ;
  543. if (idelta [chan] < 16)
  544. idelta [chan] = 16 ;
  545. pms->samples [k-2] = newsamp ;
  546. } ;
  547. } ;
  549. /* Write the block to disk. */
  551. if ((k = fwrite (pms->block, 1, pms->blocksize, psf->file)) != pms->blocksize)
  552. psf_sprintf (psf, "*** Warning : short write (%d != %d).n", k, pms->blocksize) ;
  554. memset (pms->samples, 0, pms->samplesperblock * sizeof (short)) ;
  556. pms->blockcount ++ ;
  557. pms->samplecount = 0 ;
  559. return 1 ;
  560. } /* msadpcm_write_block */
  562. static
  563. int msadpcm_write (SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, short *ptr, int len)
  564. { int count, total = 0, index = 0 ;
  566. while (index < len)
  567. { count = (pms->samplesperblock - pms->samplecount) * pms->channels ;
  569. if (count > len - index)
  570. count = len - index ;
  572. memcpy (&(pms->samples [pms->samplecount * pms->channels]), &(ptr [index]), count * sizeof (short)) ;
  573. index += count ;
  574. pms->samplecount += count / pms->channels ;
  575. total = index ;
  577. if (pms->samplecount >= pms->samplesperblock)
  578. msadpcm_write_block (psf, pms) ;
  579. } ;
  581. return total ;
  582. } /* msadpcm_write */
  584. int msadpcm_write_s (SF_PRIVATE *psf, short *ptr, int len)
  585. { MSADPCM_PRIVATE *pms ; 
  586. int total ;
  588. if (! psf->fdata)
  589. return 0 ;
  590. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  592. total = msadpcm_write (psf, pms, ptr, len) ;
  594. return total ;
  595. } /* msadpcm_write_s */
  597. int msadpcm_write_i  (SF_PRIVATE *psf, int *ptr, int len)
  598. { MSADPCM_PRIVATE *pms ; 
  599. short *sptr ;
  600. int k, bufferlen, writecount = 0, count ;
  601. int index = 0, total = 0 ;
  603. if (! psf->fdata)
  604. return 0 ;
  605. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  607. sptr = (short*) psf->buffer ;
  608. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  609. while (len > 0)
  610. { writecount = (len >= bufferlen) ? bufferlen : len ;
  611. for (k = 0 ; k < writecount ; k++)
  612. sptr [k] = (short) ptr [index+k] ;
  613. count = msadpcm_write (psf, pms, sptr, writecount) ;
  614. index += writecount ;
  615. total += count ;
  616. len -= writecount ;
  617. } ;
  618. return total ;
  619. } /* msadpcm_write_i */
  621. int msadpcm_write_d  (SF_PRIVATE *psf, double *ptr, int len, int normalize)
  622. { MSADPCM_PRIVATE *pms ; 
  623. short *sptr ;
  624. int k, bufferlen, writecount = 0, count ;
  625. int index = 0, total = 0 ;
  626. double  normfact ;
  628. normfact = (normalize ? ((double) 0x8000) : 1.0) ;
  630. if (! psf->fdata)
  631. return 0 ;
  632. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  634. sptr = (short*) psf->buffer ;
  635. bufferlen = ((SF_BUFFER_LEN / psf->blockwidth) * psf->blockwidth) / sizeof (short) ;
  636. while (len > 0)
  637. { writecount = (len >= bufferlen) ? bufferlen : len ;
  638. for (k = 0 ; k < writecount ; k++)
  639. sptr [k] = (short) (normfact * ptr [index+k]) ;
  640. count = msadpcm_write (psf, pms, sptr, writecount) ;
  641. index += writecount ;
  642. total += count ;
  643. len -= writecount ;
  644. } ;
  645. return total ;
  646. } /* msadpcm_write_d */
  648. /*========================================================================================
  649. */
  651. int msadpcm_close (SF_PRIVATE  *psf)
  652. { MSADPCM_PRIVATE *pms ; 
  653. unsigned int dword ;
  655. if (! psf->fdata)
  656. return wav_close (psf) ;
  658. pms = (MSADPCM_PRIVATE*) psf->fdata ;
  660. if (psf->mode == SF_MODE_WRITE)
  661. { /*  Now we know for certain the length of the file we can
  662. **  re-write correct values for the RIFF and data chunks.
  663. */
  664.  
  665. if (pms->samplecount && pms->samplecount < pms->samplesperblock)
  666. msadpcm_write_block (psf, pms) ;
  668. fseek (psf->file, 0, SEEK_END) ;
  669. psf->filelength = ftell (psf->file) ;
  671. /* Fix RIFF size. */
  672. dword = H2LE_INT (psf->filelength - 2 * sizeof (dword)) ;
  673. fseek (psf->file, sizeof (dword), SEEK_SET) ;
  674. fwrite (&dword, sizeof (dword), 1, psf->file) ;
  676. psf->datalength = psf->filelength - psf->dataoffset ;
  677. fseek (psf->file, (int) (psf->dataoffset - sizeof (dword)), SEEK_SET) ;
  678. dword = H2LE_INT (psf->datalength) ;
  679. fwrite (&dword, sizeof (dword), 1, psf->file) ;
  680. } ;
  682. if (psf->fdata)
  683. free (psf->fdata) ;
  684. psf->fdata = NULL ;
  686. return 0 ;
  687. } /* msadpcm_close */
  689. /*========================================================================================
  690. ** Static functions.
  691. */
  693. static
  694. unsigned int srate2blocksize (unsigned int srate)
  695. { if (srate < 12000)
  696. return 256 ;
  697. if (srate < 23000)
  698. return 512 ;
  699. return 1024 ;
  700. } /* srate2blocksize */
  704. /*----------------------------------------------------------------------------------------
  705. ** Choosing the block predictor.
  706. ** Each block requires a predictor and an idelta for each channel. 
  707. ** The predictor is in the range [0..6] which is an index into the two AdaptCoeff tables. 
  708. ** The predictor is chosen by trying all of the possible predictors on a small set of
  709. ** samples at the beginning of the block. The predictor with the smallest average
  710. ** abs (idelta) is chosen as the best predictor for this block. 
  711. ** The value of idelta is chosen to to give a 4 bit code value of +/- 4 (approx. half the 
  712. ** max. code value). If the average abs (idelta) is zero, the sixth predictor is chosen.
  713. ** If the value of idelta is less then 16 it is set to 16.
  714. **
  715. ** Microsoft uses an IDELTA_COUNT (number of sample pairs used to choose best predictor)
  716. ** value of 3. The best possible results would be obtained by using all the samples to
  717. ** choose the predictor.
  718. */
  720. #define IDELTA_COUNT 3
  722. static
  723. void choose_predictor (unsigned int channels, short *data, int *block_pred, int *idelta)
  724. { unsigned int chan, k, bpred, idelta_sum, best_bpred, best_idelta ;
  726. for (chan = 0 ; chan < channels; chan++)
  727. { best_bpred = best_idelta = 0 ;
  729. for (bpred = 0 ; bpred < 7 ; bpred++)
  730. { idelta_sum = 0 ;
  731. for (k = 2 ; k < 2 + IDELTA_COUNT ; k++)
  732. idelta_sum += abs (data [k*channels] - ((data [(k-1)*channels] * AdaptCoeff1 [bpred] + data [(k-2)*channels] * AdaptCoeff2 [bpred]) >> 8)) ;
  733. idelta_sum /= (4 * IDELTA_COUNT) ;
  735. if (bpred == 0 || idelta_sum < best_idelta)
  736. { best_bpred = bpred ;
  737. best_idelta = idelta_sum ;
  738. } ;
  740. if (! idelta_sum)
  741. { best_bpred = bpred ;
  742. best_idelta = 16 ;
  743. break ;
  744. } ;
  746. } ; /* for bpred ... */
  747. if (best_idelta < 16)
  748. best_idelta = 16 ;
  750. block_pred [chan] = best_bpred ;
  751. idelta [chan]     = best_idelta ;
  752. } ;
  754. return ;
  755. } /* choose_predictor */