2 ** Copyright (C) 1999-2005 Erik de Castro Lopo <erikd@mega-nerd.com>
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.
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.
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.
27 #include "float_cast.h"
30 typedef struct IMA_ADPCM_PRIVATE_tag
31 { int (*decode_block) (SF_PRIVATE *psf, struct IMA_ADPCM_PRIVATE_tag *pima) ;
32 int (*encode_block) (SF_PRIVATE *psf, struct IMA_ADPCM_PRIVATE_tag *pima) ;
34 int channels, blocksize, samplesperblock, blocks ;
35 int blockcount, samplecount ;
38 unsigned char *block ;
40 #if HAVE_FLEXIBLE_ARRAY
41 short data [] ; /* ISO C99 struct flexible array. */
43 short data [0] ; /* This is a hack and might not work. */
47 /*============================================================================================
48 ** Predefined IMA ADPCM data.
51 static int ima_indx_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 */
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,
68 static int ima_reader_init (SF_PRIVATE *psf, int blockalign, int samplesperblock) ;
69 static int ima_writer_init (SF_PRIVATE *psf, int blockalign) ;
71 static int ima_read_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, short *ptr, int len) ;
72 static int ima_write_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, const short *ptr, int len) ;
74 static sf_count_t ima_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
75 static sf_count_t ima_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
76 static sf_count_t ima_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
77 static sf_count_t ima_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
79 static sf_count_t ima_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
80 static sf_count_t ima_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
81 static sf_count_t ima_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
82 static sf_count_t ima_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
84 static sf_count_t ima_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;
86 static int ima_close (SF_PRIVATE *psf) ;
88 static int wav_w64_ima_decode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima) ;
89 static int wav_w64_ima_encode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima) ;
91 /*-static int aiff_ima_reader_init (SF_PRIVATE *psf, int blockalign, int samplesperblock) ;-*/
92 static int aiff_ima_decode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima) ;
93 static int aiff_ima_encode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima) ;
96 /*============================================================================================
97 ** IMA ADPCM Reader initialisation function.
101 wav_w64_ima_init (SF_PRIVATE *psf, int blockalign, int samplesperblock)
104 if (psf->fdata != NULL)
105 { psf_log_printf (psf, "*** psf->fdata is not NULL.\n") ;
106 return SFE_INTERNAL ;
109 if (psf->mode == SFM_RDWR)
110 return SFE_BAD_MODE_RW ;
112 if (psf->mode == SFM_READ)
113 if ((error = ima_reader_init (psf, blockalign, samplesperblock)))
116 if (psf->mode == SFM_WRITE)
117 if ((error = ima_writer_init (psf, blockalign)))
120 psf->codec_close = ima_close ;
121 psf->seek = ima_seek ;
124 } /* wav_w64_ima_init */
127 aiff_ima_init (SF_PRIVATE *psf, int blockalign, int samplesperblock)
130 if (psf->mode == SFM_RDWR)
131 return SFE_BAD_MODE_RW ;
133 if (psf->mode == SFM_READ)
134 if ((error = ima_reader_init (psf, blockalign, samplesperblock)))
137 if (psf->mode == SFM_WRITE)
138 if ((error = ima_writer_init (psf, blockalign)))
141 psf->codec_close = ima_close ;
144 } /* aiff_ima_init */
147 ima_close (SF_PRIVATE *psf)
148 { IMA_ADPCM_PRIVATE *pima ;
150 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
152 if (psf->mode == SFM_WRITE)
153 { /* If a block has been partially assembled, write it out
154 ** as the final block.
156 if (pima->samplecount && pima->samplecount < pima->samplesperblock)
157 pima->encode_block (psf, pima) ;
159 psf->sf.frames = pima->samplesperblock * pima->blockcount / psf->sf.channels ;
165 /*============================================================================================
166 ** IMA ADPCM Read Functions.
170 ima_reader_init (SF_PRIVATE *psf, int blockalign, int samplesperblock)
171 { IMA_ADPCM_PRIVATE *pima ;
172 int pimasize, count ;
174 if (psf->mode != SFM_READ)
175 return SFE_BAD_MODE_RW ;
177 pimasize = sizeof (IMA_ADPCM_PRIVATE) + blockalign * psf->sf.channels + 3 * psf->sf.channels * samplesperblock ;
179 if (! (pima = malloc (pimasize)))
180 return SFE_MALLOC_FAILED ;
182 psf->fdata = (void*) pima ;
184 memset (pima, 0, pimasize) ;
186 pima->samples = pima->data ;
187 pima->block = (unsigned char*) (pima->data + samplesperblock * psf->sf.channels) ;
189 pima->channels = psf->sf.channels ;
190 pima->blocksize = blockalign ;
191 pima->samplesperblock = samplesperblock ;
193 psf->filelength = psf_get_filelen (psf) ;
194 psf->datalength = (psf->dataend) ? psf->dataend - psf->dataoffset :
195 psf->filelength - psf->dataoffset ;
197 if (psf->datalength % pima->blocksize)
198 pima->blocks = psf->datalength / pima->blocksize + 1 ;
200 pima->blocks = psf->datalength / pima->blocksize ;
202 switch (psf->sf.format & SF_FORMAT_TYPEMASK)
203 { case SF_FORMAT_WAV :
205 count = 2 * (pima->blocksize - 4 * pima->channels) / pima->channels + 1 ;
207 if (pima->samplesperblock != count)
208 psf_log_printf (psf, "*** Warning : samplesperblock should be %d.\n", count) ;
210 pima->decode_block = wav_w64_ima_decode_block ;
212 psf->sf.frames = pima->samplesperblock * pima->blocks ;
215 case SF_FORMAT_AIFF :
216 psf_log_printf (psf, "still need to check block count\n") ;
217 pima->decode_block = aiff_ima_decode_block ;
218 psf->sf.frames = pima->samplesperblock * pima->blocks / pima->channels ;
222 psf_log_printf (psf, "ima_reader_init: bad psf->sf.format\n") ;
223 return SFE_INTERNAL ;
227 pima->decode_block (psf, pima) ; /* Read first block. */
229 psf->read_short = ima_read_s ;
230 psf->read_int = ima_read_i ;
231 psf->read_float = ima_read_f ;
232 psf->read_double = ima_read_d ;
235 } /* ima_reader_init */
238 aiff_ima_decode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima)
239 { unsigned char *blockdata ;
240 int chan, k, diff, bytecode ;
241 short step, stepindx, predictor, *sampledata ;
243 static int count = 0 ;
246 pima->blockcount += pima->channels ;
247 pima->samplecount = 0 ;
249 if (pima->blockcount > pima->blocks)
250 { memset (pima->samples, 0, pima->samplesperblock * pima->channels * sizeof (short)) ;
254 if ((k = psf_fread (pima->block, 1, pima->blocksize * pima->channels, psf)) != pima->blocksize * pima->channels)
255 psf_log_printf (psf, "*** Warning : short read (%d != %d).\n", k, pima->blocksize) ;
257 /* Read and check the block header. */
258 for (chan = 0 ; chan < pima->channels ; chan++)
259 { blockdata = pima->block + chan * 34 ;
260 sampledata = pima->samples + chan ;
262 predictor = (blockdata [0] << 8) | (blockdata [1] & 0x80) ;
263 stepindx = blockdata [1] & 0x7F ;
267 printf ("\nchan: %d predictor: %d stepindx: %d (%d)\n",
268 chan, predictor, stepindx, ima_step_size [stepindx]) ;
270 /* FIXME : Do this a better way. */
271 if (stepindx < 0) stepindx = 0 ;
272 else if (stepindx > 88) stepindx = 88 ;
275 ** Pull apart the packed 4 bit samples and store them in their
276 ** correct sample positions.
278 for (k = 0 ; k < pima->blocksize - 2 ; k++)
279 { bytecode = blockdata [k + 2] ;
280 sampledata [pima->channels * (2 * k + 0)] = bytecode & 0xF ;
281 sampledata [pima->channels * (2 * k + 1)] = (bytecode >> 4) & 0xF ;
284 /* Decode the encoded 4 bit samples. */
285 for (k = 0 ; k < pima->samplesperblock ; k ++)
286 { step = ima_step_size [stepindx] ;
288 bytecode = pima->samples [pima->channels * k + chan] ;
290 stepindx += ima_indx_adjust [bytecode] ;
292 if (stepindx < 0) stepindx = 0 ;
293 else if (stepindx > 88) stepindx = 88 ;
296 if (bytecode & 1) diff += step >> 2 ;
297 if (bytecode & 2) diff += step >> 1 ;
298 if (bytecode & 4) diff += step ;
299 if (bytecode & 8) diff = -diff ;
303 pima->samples [pima->channels * k + chan] = predictor ;
309 for (k = 0 ; k < 10 ; k++)
310 printf ("% 7d,", pima->samples [k]) ;
315 } /* aiff_ima_decode_block */
318 aiff_ima_encode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima)
319 { int chan, k, step, diff, vpdiff, blockindx, indx ;
320 short bytecode, mask ;
322 static int count = 0 ;
324 { pima->samples [0] = 0 ;
325 printf ("blocksize : %d\n", pima->blocksize) ;
326 printf ("pima->stepindx [0] : %d\n", pima->stepindx [0]) ;
330 /* Encode the block header. */
331 for (chan = 0 ; chan < pima->channels ; chan ++)
332 { blockindx = chan * pima->blocksize ;
334 pima->block [blockindx] = (pima->samples [chan] >> 8) & 0xFF ;
335 pima->block [blockindx + 1] = (pima->samples [chan] & 0x80) + (pima->stepindx [chan] & 0x7F) ;
337 pima->previous [chan] = pima->samples [chan] ;
340 /* Encode second and later samples for every block as a 4 bit value. */
341 for (k = pima->channels ; k < (pima->samplesperblock * pima->channels) ; k ++)
342 { chan = (pima->channels > 1) ? (k % 2) : 0 ;
344 diff = pima->samples [k] - pima->previous [chan] ;
347 step = ima_step_size [pima->stepindx [chan]] ;
365 pima->previous [chan] -= vpdiff ;
367 pima->previous [chan] += vpdiff ;
369 if (pima->previous [chan] > 32767)
370 pima->previous [chan] = 32767 ;
371 else if (pima->previous [chan] < -32768)
372 pima->previous [chan] = -32768 ;
374 pima->stepindx [chan] += ima_indx_adjust [bytecode] ;
375 if (pima->stepindx [chan] < 0)
376 pima->stepindx [chan] = 0 ;
377 else if (pima->stepindx [chan] > 88)
378 pima->stepindx [chan] = 88 ;
380 pima->samples [k] = bytecode ;
383 /* Pack the 4 bit encoded samples. */
385 for (chan = 0 ; chan < pima->channels ; chan ++)
386 { for (indx = pima->channels ; indx < pima->channels * pima->samplesperblock ; indx += 2 * pima->channels)
387 { blockindx = chan * pima->blocksize + 2 + indx / 2 ;
389 if (0 && count ++ < 5)
390 printf ("chan: %d blockindx: %3d indx: %3d\n", chan, blockindx, indx) ;
392 pima->block [blockindx] = pima->samples [indx] & 0x0F ;
393 pima->block [blockindx] |= (pima->samples [indx + pima->channels] << 4) & 0xF0 ;
397 /* Write the block to disk. */
399 if ((k = psf_fwrite (pima->block, 1, pima->channels * pima->blocksize, psf)) != pima->channels * pima->blocksize)
400 psf_log_printf (psf, "*** Warning : short write (%d != %d).\n", k, pima->channels * pima->blocksize) ;
402 memset (pima->samples, 0, pima->channels * pima->samplesperblock * sizeof (short)) ;
403 pima->samplecount = 0 ;
404 pima->blockcount ++ ;
407 } /* aiff_ima_encode_block */
410 wav_w64_ima_decode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima)
411 { int chan, k, current, blockindx, indx, indxstart, diff ;
412 short step, bytecode, stepindx [2] ;
414 pima->blockcount ++ ;
415 pima->samplecount = 0 ;
417 if (pima->blockcount > pima->blocks)
418 { memset (pima->samples, 0, pima->samplesperblock * pima->channels * sizeof (short)) ;
422 if ((k = psf_fread (pima->block, 1, pima->blocksize, psf)) != pima->blocksize)
423 psf_log_printf (psf, "*** Warning : short read (%d != %d).\n", k, pima->blocksize) ;
425 /* Read and check the block header. */
427 for (chan = 0 ; chan < pima->channels ; chan++)
428 { current = pima->block [chan*4] | (pima->block [chan*4+1] << 8) ;
429 if (current & 0x8000)
432 stepindx [chan] = pima->block [chan*4+2] ;
433 if (stepindx [chan] < 0)
434 stepindx [chan] = 0 ;
435 else if (stepindx [chan] > 88)
436 stepindx [chan] = 88 ;
438 if (pima->block [chan*4+3] != 0)
439 psf_log_printf (psf, "IMA ADPCM synchronisation error.\n") ;
441 pima->samples [chan] = current ;
445 ** Pull apart the packed 4 bit samples and store them in their
446 ** correct sample positions.
449 blockindx = 4 * pima->channels ;
451 indxstart = pima->channels ;
452 while (blockindx < pima->blocksize)
453 { for (chan = 0 ; chan < pima->channels ; chan++)
454 { indx = indxstart + chan ;
455 for (k = 0 ; k < 4 ; k++)
456 { bytecode = pima->block [blockindx++] ;
457 pima->samples [indx] = bytecode & 0x0F ;
458 indx += pima->channels ;
459 pima->samples [indx] = (bytecode >> 4) & 0x0F ;
460 indx += pima->channels ;
463 indxstart += 8 * pima->channels ;
466 /* Decode the encoded 4 bit samples. */
468 for (k = pima->channels ; k < (pima->samplesperblock * pima->channels) ; k ++)
469 { chan = (pima->channels > 1) ? (k % 2) : 0 ;
471 bytecode = pima->samples [k] & 0xF ;
473 step = ima_step_size [stepindx [chan]] ;
474 current = pima->samples [k - pima->channels] ;
490 else if (current < -32768)
493 stepindx [chan] += ima_indx_adjust [bytecode] ;
495 if (stepindx [chan] < 0)
496 stepindx [chan] = 0 ;
497 else if (stepindx [chan] > 88)
498 stepindx [chan] = 88 ;
500 pima->samples [k] = current ;
504 } /* wav_w64_ima_decode_block */
507 wav_w64_ima_encode_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima)
508 { int chan, k, step, diff, vpdiff, blockindx, indx, indxstart ;
509 short bytecode, mask ;
511 /* Encode the block header. */
512 for (chan = 0 ; chan < pima->channels ; chan++)
513 { pima->block [chan*4] = pima->samples [chan] & 0xFF ;
514 pima->block [chan*4+1] = (pima->samples [chan] >> 8) & 0xFF ;
516 pima->block [chan*4+2] = pima->stepindx [chan] ;
517 pima->block [chan*4+3] = 0 ;
519 pima->previous [chan] = pima->samples [chan] ;
522 /* Encode the samples as 4 bit. */
524 for (k = pima->channels ; k < (pima->samplesperblock * pima->channels) ; k ++)
525 { chan = (pima->channels > 1) ? (k % 2) : 0 ;
527 diff = pima->samples [k] - pima->previous [chan] ;
530 step = ima_step_size [pima->stepindx [chan]] ;
548 pima->previous [chan] -= vpdiff ;
550 pima->previous [chan] += vpdiff ;
552 if (pima->previous [chan] > 32767)
553 pima->previous [chan] = 32767 ;
554 else if (pima->previous [chan] < -32768)
555 pima->previous [chan] = -32768 ;
557 pima->stepindx [chan] += ima_indx_adjust [bytecode] ;
558 if (pima->stepindx [chan] < 0)
559 pima->stepindx [chan] = 0 ;
560 else if (pima->stepindx [chan] > 88)
561 pima->stepindx [chan] = 88 ;
563 pima->samples [k] = bytecode ;
566 /* Pack the 4 bit encoded samples. */
568 blockindx = 4 * pima->channels ;
570 indxstart = pima->channels ;
571 while (blockindx < pima->blocksize)
572 { for (chan = 0 ; chan < pima->channels ; chan++)
573 { indx = indxstart + chan ;
574 for (k = 0 ; k < 4 ; k++)
575 { pima->block [blockindx] = pima->samples [indx] & 0x0F ;
576 indx += pima->channels ;
577 pima->block [blockindx] |= (pima->samples [indx] << 4) & 0xF0 ;
578 indx += pima->channels ;
582 indxstart += 8 * pima->channels ;
585 /* Write the block to disk. */
587 if ((k = psf_fwrite (pima->block, 1, pima->blocksize, psf)) != pima->blocksize)
588 psf_log_printf (psf, "*** Warning : short write (%d != %d).\n", k, pima->blocksize) ;
590 memset (pima->samples, 0, pima->samplesperblock * sizeof (short)) ;
591 pima->samplecount = 0 ;
592 pima->blockcount ++ ;
595 } /* wav_w64_ima_encode_block */
598 ima_read_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, short *ptr, int len)
599 { int count, total = 0, indx = 0 ;
602 { if (pima->blockcount >= pima->blocks && pima->samplecount >= pima->samplesperblock)
603 { memset (&(ptr [indx]), 0, (size_t) ((len - indx) * sizeof (short))) ;
607 if (pima->samplecount >= pima->samplesperblock)
608 pima->decode_block (psf, pima) ;
610 count = (pima->samplesperblock - pima->samplecount) * pima->channels ;
611 count = (len - indx > count) ? count : len - indx ;
613 memcpy (&(ptr [indx]), &(pima->samples [pima->samplecount * pima->channels]), count * sizeof (short)) ;
615 pima->samplecount += count / pima->channels ;
620 } /* ima_read_block */
623 ima_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
624 { IMA_ADPCM_PRIVATE *pima ;
625 int readcount, count ;
626 sf_count_t total = 0 ;
630 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
633 { readcount = (len > 0x10000000) ? 0x10000000 : (int) len ;
635 count = ima_read_block (psf, pima, ptr, readcount) ;
639 if (count != readcount)
647 ima_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
648 { IMA_ADPCM_PRIVATE *pima ;
650 int k, bufferlen, readcount, count ;
651 sf_count_t total = 0 ;
655 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
658 bufferlen = ARRAY_LEN (psf->u.sbuf) ;
660 { readcount = (len >= bufferlen) ? bufferlen : (int) len ;
661 count = ima_read_block (psf, pima, sptr, readcount) ;
662 for (k = 0 ; k < readcount ; k++)
663 ptr [total + k] = ((int) sptr [k]) << 16 ;
666 if (count != readcount)
674 ima_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
675 { IMA_ADPCM_PRIVATE *pima ;
677 int k, bufferlen, readcount, count ;
678 sf_count_t total = 0 ;
683 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
685 normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
688 bufferlen = ARRAY_LEN (psf->u.sbuf) ;
690 { readcount = (len >= bufferlen) ? bufferlen : (int) len ;
691 count = ima_read_block (psf, pima, sptr, readcount) ;
692 for (k = 0 ; k < readcount ; k++)
693 ptr [total + k] = normfact * (float) (sptr [k]) ;
696 if (count != readcount)
704 ima_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
705 { IMA_ADPCM_PRIVATE *pima ;
707 int k, bufferlen, readcount, count ;
708 sf_count_t total = 0 ;
713 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
715 normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;
718 bufferlen = ARRAY_LEN (psf->u.sbuf) ;
720 { readcount = (len >= bufferlen) ? bufferlen : (int) len ;
721 count = ima_read_block (psf, pima, sptr, readcount) ;
722 for (k = 0 ; k < readcount ; k++)
723 ptr [total + k] = normfact * (double) (sptr [k]) ;
726 if (count != readcount)
734 ima_seek (SF_PRIVATE *psf, int mode, sf_count_t offset)
735 { IMA_ADPCM_PRIVATE *pima ;
736 int newblock, newsample ;
740 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
742 if (psf->datalength < 0 || psf->dataoffset < 0)
743 { psf->error = SFE_BAD_SEEK ;
744 return PSF_SEEK_ERROR ;
748 { psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
749 pima->blockcount = 0 ;
750 pima->decode_block (psf, pima) ;
751 pima->samplecount = 0 ;
755 if (offset < 0 || offset > pima->blocks * pima->samplesperblock)
756 { psf->error = SFE_BAD_SEEK ;
757 return PSF_SEEK_ERROR ;
760 newblock = offset / pima->samplesperblock ;
761 newsample = offset % pima->samplesperblock ;
763 if (mode == SFM_READ)
764 { psf_fseek (psf, psf->dataoffset + newblock * pima->blocksize, SEEK_SET) ;
765 pima->blockcount = newblock ;
766 pima->decode_block (psf, pima) ;
767 pima->samplecount = newsample ;
770 { /* What to do about write??? */
771 psf->error = SFE_BAD_SEEK ;
772 return PSF_SEEK_ERROR ;
775 return newblock * pima->samplesperblock + newsample ;
778 /*==========================================================================================
779 ** IMA ADPCM Write Functions.
783 ima_writer_init (SF_PRIVATE *psf, int blockalign)
784 { IMA_ADPCM_PRIVATE *pima ;
785 int samplesperblock ;
786 unsigned int pimasize ;
788 if (psf->mode != SFM_WRITE)
789 return SFE_BAD_MODE_RW ;
791 samplesperblock = 2 * (blockalign - 4 * psf->sf.channels) / psf->sf.channels + 1 ;
793 pimasize = sizeof (IMA_ADPCM_PRIVATE) + blockalign + 3 * psf->sf.channels * samplesperblock ;
795 if ((pima = calloc (1, pimasize)) == NULL)
796 return SFE_MALLOC_FAILED ;
798 psf->fdata = (void*) pima ;
800 pima->channels = psf->sf.channels ;
801 pima->blocksize = blockalign ;
802 pima->samplesperblock = samplesperblock ;
804 pima->block = (unsigned char*) pima->data ;
805 pima->samples = (short*) (pima->data + blockalign) ;
807 pima->samplecount = 0 ;
809 switch (psf->sf.format & SF_FORMAT_TYPEMASK)
810 { case SF_FORMAT_WAV :
812 pima->encode_block = wav_w64_ima_encode_block ;
815 case SF_FORMAT_AIFF :
816 pima->encode_block = aiff_ima_encode_block ;
820 psf_log_printf (psf, "ima_reader_init: bad psf->sf.format\n") ;
821 return SFE_INTERNAL ;
825 psf->write_short = ima_write_s ;
826 psf->write_int = ima_write_i ;
827 psf->write_float = ima_write_f ;
828 psf->write_double = ima_write_d ;
831 } /* ima_writer_init */
833 /*==========================================================================================
837 ima_write_block (SF_PRIVATE *psf, IMA_ADPCM_PRIVATE *pima, const short *ptr, int len)
838 { int count, total = 0, indx = 0 ;
841 { count = (pima->samplesperblock - pima->samplecount) * pima->channels ;
843 if (count > len - indx)
846 memcpy (&(pima->samples [pima->samplecount * pima->channels]), &(ptr [total]), count * sizeof (short)) ;
848 pima->samplecount += count / pima->channels ;
851 if (pima->samplecount >= pima->samplesperblock)
852 pima->encode_block (psf, pima) ;
856 } /* ima_write_block */
859 ima_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
860 { IMA_ADPCM_PRIVATE *pima ;
861 int writecount, count ;
862 sf_count_t total = 0 ;
866 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
869 { writecount = (len > 0x10000000) ? 0x10000000 : (int) len ;
871 count = ima_write_block (psf, pima, ptr, writecount) ;
875 if (count != writecount)
883 ima_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
884 { IMA_ADPCM_PRIVATE *pima ;
886 int k, bufferlen, writecount, count ;
887 sf_count_t total = 0 ;
891 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
894 bufferlen = ARRAY_LEN (psf->u.sbuf) ;
896 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
897 for (k = 0 ; k < writecount ; k++)
898 sptr [k] = ptr [total + k] >> 16 ;
899 count = ima_write_block (psf, pima, sptr, writecount) ;
902 if (count != writecount)
910 ima_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
911 { IMA_ADPCM_PRIVATE *pima ;
913 int k, bufferlen, writecount, count ;
914 sf_count_t total = 0 ;
919 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
921 normfact = (psf->norm_float == SF_TRUE) ? (1.0 * 0x7FFF) : 1.0 ;
924 bufferlen = ARRAY_LEN (psf->u.sbuf) ;
926 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
927 for (k = 0 ; k < writecount ; k++)
928 sptr [k] = lrintf (normfact * ptr [total + k]) ;
929 count = ima_write_block (psf, pima, sptr, writecount) ;
932 if (count != writecount)
940 ima_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
941 { IMA_ADPCM_PRIVATE *pima ;
943 int k, bufferlen, writecount, count ;
944 sf_count_t total = 0 ;
949 pima = (IMA_ADPCM_PRIVATE*) psf->fdata ;
951 normfact = (psf->norm_double == SF_TRUE) ? (1.0 * 0x7FFF) : 1.0 ;
954 bufferlen = ARRAY_LEN (psf->u.sbuf) ;
956 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
957 for (k = 0 ; k < writecount ; k++)
958 sptr [k] = lrint (normfact * ptr [total + k]) ;
959 count = ima_write_block (psf, pima, sptr, writecount) ;
962 if (count != writecount)
971 ** Do not edit or modify anything in this comment block.
972 ** The arch-tag line is a file identity tag for the GNU Arch
973 ** revision control system.
975 ** arch-tag: 75a54b82-ad18-4758-9933-64e00a7f24e0