PageRenderTime 92ms CodeModel.GetById 12ms app.highlight 73ms RepoModel.GetById 2ms app.codeStats 0ms

/project/jni/sndfile/src/ms_adpcm.c

https://github.com/aichunyu/FFPlayer
C | 834 lines | 565 code | 169 blank | 100 comment | 124 complexity | e55d299f8095fff85a3317f4f844077c MD5 | raw file
  1/*
  2** Copyright (C) 1999-2011 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*/
 18
 19#include	"sfconfig.h"
 20
 21#include	<stdio.h>
 22#include	<stdlib.h>
 23#include	<string.h>
 24#include	<math.h>
 25
 26#include	"sndfile.h"
 27#include	"sfendian.h"
 28#include	"common.h"
 29#include	"wav_w64.h"
 30
 31/* These required here because we write the header in this file. */
 32
 33#define RIFF_MARKER	(MAKE_MARKER ('R', 'I', 'F', 'F'))
 34#define WAVE_MARKER	(MAKE_MARKER ('W', 'A', 'V', 'E'))
 35#define fmt_MARKER	(MAKE_MARKER ('f', 'm', 't', ' '))
 36#define fact_MARKER	(MAKE_MARKER ('f', 'a', 'c', 't'))
 37#define data_MARKER	(MAKE_MARKER ('d', 'a', 't', 'a'))
 38
 39#define WAVE_FORMAT_MS_ADPCM	0x0002
 40
 41typedef struct
 42{	int				channels, blocksize, samplesperblock, blocks, dataremaining ;
 43	int				blockcount ;
 44	sf_count_t		samplecount ;
 45	short			*samples ;
 46	unsigned char	*block ;
 47#if HAVE_FLEXIBLE_ARRAY
 48	short			dummydata [] ; /* ISO C99 struct flexible array. */
 49#else
 50	short			dummydata [0] ; /* This is a hack an might not work. */
 51#endif
 52} MSADPCM_PRIVATE ;
 53
 54/*============================================================================================
 55** MS ADPCM static data and functions.
 56*/
 57
 58static int AdaptationTable [] =
 59{	230, 230, 230, 230, 307, 409, 512, 614,
 60	768, 614, 512, 409, 307, 230, 230, 230
 61} ;
 62
 63/* TODO : The first 7 coef's are are always hardcode and must
 64   appear in the actual WAVE file.  They should be read in
 65   in case a sound program added extras to the list. */
 66
 67static int AdaptCoeff1 [MSADPCM_ADAPT_COEFF_COUNT] =
 68{	256, 512, 0, 192, 240, 460, 392
 69} ;
 70
 71static int AdaptCoeff2 [MSADPCM_ADAPT_COEFF_COUNT] =
 72{	0, -256, 0, 64, 0, -208, -232
 73} ;
 74
 75/*============================================================================================
 76**	MS ADPCM Block Layout.
 77**	======================
 78**	Block is usually 256, 512 or 1024 bytes depending on sample rate.
 79**	For a mono file, the block is laid out as follows:
 80**		byte	purpose
 81**		0		block predictor [0..6]
 82**		1,2		initial idelta (positive)
 83**		3,4		sample 1
 84**		5,6		sample 0
 85**		7..n	packed bytecodes
 86**
 87**	For a stereo file, the block is laid out as follows:
 88**		byte	purpose
 89**		0		block predictor [0..6] for left channel
 90**		1		block predictor [0..6] for right channel
 91**		2,3		initial idelta (positive) for left channel
 92**		4,5		initial idelta (positive) for right channel
 93**		6,7		sample 1 for left channel
 94**		8,9		sample 1 for right channel
 95**		10,11	sample 0 for left channel
 96**		12,13	sample 0 for right channel
 97**		14..n	packed bytecodes
 98*/
 99
100/*============================================================================================
101** Static functions.
102*/
103
104static	int	msadpcm_decode_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms) ;
105static sf_count_t msadpcm_read_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, short *ptr, int len) ;
106
107static	int	msadpcm_encode_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms) ;
108static sf_count_t msadpcm_write_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, const short *ptr, int len) ;
109
110static sf_count_t	msadpcm_read_s	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
111static sf_count_t	msadpcm_read_i	(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
112static sf_count_t	msadpcm_read_f	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
113static sf_count_t	msadpcm_read_d	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
114
115static sf_count_t	msadpcm_write_s	(SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
116static sf_count_t	msadpcm_write_i	(SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
117static sf_count_t	msadpcm_write_f	(SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
118static sf_count_t	msadpcm_write_d	(SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
119
120static sf_count_t msadpcm_seek	(SF_PRIVATE *psf, int mode, sf_count_t offset) ;
121static	int	msadpcm_close	(SF_PRIVATE *psf) ;
122
123static	void	choose_predictor (unsigned int channels, short *data, int *bpred, int *idelta) ;
124
125/*============================================================================================
126** MS ADPCM Read Functions.
127*/
128
129int
130wav_w64_msadpcm_init	(SF_PRIVATE *psf, int blockalign, int samplesperblock)
131{	MSADPCM_PRIVATE	*pms ;
132	unsigned int	pmssize ;
133	int				count ;
134
135	if (psf->codec_data != NULL)
136	{	psf_log_printf (psf, "*** psf->codec_data is not NULL.\n") ;
137		return SFE_INTERNAL ;
138		} ;
139
140	if (psf->file.mode == SFM_WRITE)
141		samplesperblock = 2 + 2 * (blockalign - 7 * psf->sf.channels) / psf->sf.channels ;
142
143	pmssize = sizeof (MSADPCM_PRIVATE) + blockalign + 3 * psf->sf.channels * samplesperblock ;
144
145	if (! (psf->codec_data = calloc (1, pmssize)))
146		return SFE_MALLOC_FAILED ;
147	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
148
149	pms->samples	= pms->dummydata ;
150	pms->block		= (unsigned char*) (pms->dummydata + psf->sf.channels * samplesperblock) ;
151
152	pms->channels	= psf->sf.channels ;
153	pms->blocksize	= blockalign ;
154	pms->samplesperblock = samplesperblock ;
155
156	if (pms->blocksize == 0)
157	{	psf_log_printf (psf, "*** Error : pms->blocksize should not be zero.\n") ;
158		return SFE_INTERNAL ;
159		} ;
160
161	if (psf->file.mode == SFM_READ)
162	{	pms->dataremaining	 = psf->datalength ;
163
164		if (psf->datalength % pms->blocksize)
165			pms->blocks = psf->datalength / pms->blocksize + 1 ;
166		else
167			pms->blocks = psf->datalength / pms->blocksize ;
168
169		count = 2 * (pms->blocksize - 6 * pms->channels) / pms->channels ;
170		if (pms->samplesperblock != count)
171		{	psf_log_printf (psf, "*** Error : samplesperblock should be %d.\n", count) ;
172			return SFE_INTERNAL ;
173			} ;
174
175		psf->sf.frames = (psf->datalength / pms->blocksize) * pms->samplesperblock ;
176
177		psf_log_printf (psf, " bpred   idelta\n") ;
178
179		msadpcm_decode_block (psf, pms) ;
180
181		psf->read_short		= msadpcm_read_s ;
182		psf->read_int		= msadpcm_read_i ;
183		psf->read_float		= msadpcm_read_f ;
184		psf->read_double	= msadpcm_read_d ;
185		} ;
186
187	if (psf->file.mode == SFM_WRITE)
188	{	pms->samples = pms->dummydata ;
189
190		pms->samplecount = 0 ;
191
192		psf->write_short	= msadpcm_write_s ;
193		psf->write_int		= msadpcm_write_i ;
194		psf->write_float	= msadpcm_write_f ;
195		psf->write_double	= msadpcm_write_d ;
196		} ;
197
198	psf->codec_close = msadpcm_close ;
199	psf->seek = msadpcm_seek ;
200
201	return 0 ;
202} /* wav_w64_msadpcm_init */
203
204static int
205msadpcm_decode_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms)
206{	int		chan, k, blockindx, sampleindx ;
207	short	bytecode, bpred [2], chan_idelta [2] ;
208
209    int predict ;
210    int current ;
211    int idelta ;
212
213	pms->blockcount ++ ;
214	pms->samplecount = 0 ;
215
216	if (pms->blockcount > pms->blocks)
217	{	memset (pms->samples, 0, pms->samplesperblock * pms->channels) ;
218		return 1 ;
219		} ;
220
221	if ((k = psf_fread (pms->block, 1, pms->blocksize, psf)) != pms->blocksize)
222		psf_log_printf (psf, "*** Warning : short read (%d != %d).\n", k, pms->blocksize) ;
223
224	/* Read and check the block header. */
225
226	if (pms->channels == 1)
227	{	bpred [0] = pms->block [0] ;
228
229		if (bpred [0] >= 7)
230			psf_log_printf (psf, "MS ADPCM synchronisation error (%d).\n", bpred [0]) ;
231
232		chan_idelta [0] = pms->block [1] | (pms->block [2] << 8) ;
233		chan_idelta [1] = 0 ;
234
235		psf_log_printf (psf, "(%d) (%d)\n", bpred [0], chan_idelta [0]) ;
236
237		pms->samples [1] = pms->block [3] | (pms->block [4] << 8) ;
238		pms->samples [0] = pms->block [5] | (pms->block [6] << 8) ;
239		blockindx = 7 ;
240		}
241	else
242	{	bpred [0] = pms->block [0] ;
243		bpred [1] = pms->block [1] ;
244
245		if (bpred [0] >= 7 || bpred [1] >= 7)
246			psf_log_printf (psf, "MS ADPCM synchronisation error (%d %d).\n", bpred [0], bpred [1]) ;
247
248		chan_idelta [0] = pms->block [2] | (pms->block [3] << 8) ;
249		chan_idelta [1] = pms->block [4] | (pms->block [5] << 8) ;
250
251		psf_log_printf (psf, "(%d, %d) (%d, %d)\n", bpred [0], bpred [1], chan_idelta [0], chan_idelta [1]) ;
252
253		pms->samples [2] = pms->block [6] | (pms->block [7] << 8) ;
254		pms->samples [3] = pms->block [8] | (pms->block [9] << 8) ;
255
256		pms->samples [0] = pms->block [10] | (pms->block [11] << 8) ;
257		pms->samples [1] = pms->block [12] | (pms->block [13] << 8) ;
258
259		blockindx = 14 ;
260		} ;
261
262	/*--------------------------------------------------------
263	This was left over from a time when calculations were done
264	as ints rather than shorts. Keep this around as a reminder
265	in case I ever find a file which decodes incorrectly.
266
267    if (chan_idelta [0] & 0x8000)
268		chan_idelta [0] -= 0x10000 ;
269    if (chan_idelta [1] & 0x8000)
270		chan_idelta [1] -= 0x10000 ;
271	--------------------------------------------------------*/
272
273	/* Pull apart the packed 4 bit samples and store them in their
274	** correct sample positions.
275	*/
276
277	sampleindx = 2 * pms->channels ;
278	while (blockindx < pms->blocksize)
279	{	bytecode = pms->block [blockindx++] ;
280  		pms->samples [sampleindx++] = (bytecode >> 4) & 0x0F ;
281		pms->samples [sampleindx++] = bytecode & 0x0F ;
282		} ;
283
284	/* Decode the encoded 4 bit samples. */
285
286	for (k = 2 * pms->channels ; k < (pms->samplesperblock * pms->channels) ; k ++)
287	{	chan = (pms->channels > 1) ? (k % 2) : 0 ;
288
289		bytecode = pms->samples [k] & 0xF ;
290
291		/* Compute next Adaptive Scale Factor (ASF) */
292		idelta = chan_idelta [chan] ;
293		chan_idelta [chan] = (AdaptationTable [bytecode] * idelta) >> 8 ;	/* => / 256 => FIXED_POINT_ADAPTATION_BASE == 256 */
294		if (chan_idelta [chan] < 16)
295			chan_idelta [chan] = 16 ;
296		if (bytecode & 0x8)
297			bytecode -= 0x10 ;
298
299    	predict = ((pms->samples [k - pms->channels] * AdaptCoeff1 [bpred [chan]])
300					+ (pms->samples [k - 2 * pms->channels] * AdaptCoeff2 [bpred [chan]])) >> 8 ; /* => / 256 => FIXED_POINT_COEFF_BASE == 256 */
301		current = (bytecode * idelta) + predict ;
302
303		if (current > 32767)
304			current = 32767 ;
305		else if (current < -32768)
306			current = -32768 ;
307
308		pms->samples [k] = current ;
309		} ;
310
311	return 1 ;
312} /* msadpcm_decode_block */
313
314static sf_count_t
315msadpcm_read_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, short *ptr, int len)
316{	int	count, total = 0, indx = 0 ;
317
318	while (indx < len)
319	{	if (pms->blockcount >= pms->blocks && pms->samplecount >= pms->samplesperblock)
320		{	memset (&(ptr [indx]), 0, (size_t) ((len - indx) * sizeof (short))) ;
321			return total ;
322			} ;
323
324		if (pms->samplecount >= pms->samplesperblock)
325			msadpcm_decode_block (psf, pms) ;
326
327		count = (pms->samplesperblock - pms->samplecount) * pms->channels ;
328		count = (len - indx > count) ? count : len - indx ;
329
330		memcpy (&(ptr [indx]), &(pms->samples [pms->samplecount * pms->channels]), count * sizeof (short)) ;
331		indx += count ;
332		pms->samplecount += count / pms->channels ;
333		total = indx ;
334		} ;
335
336	return total ;
337} /* msadpcm_read_block */
338
339static sf_count_t
340msadpcm_read_s	(SF_PRIVATE *psf, short *ptr, sf_count_t len)
341{	MSADPCM_PRIVATE 	*pms ;
342	int			readcount, count ;
343	sf_count_t	total = 0 ;
344
345	if (! psf->codec_data)
346		return 0 ;
347	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
348
349	while (len > 0)
350	{	readcount = (len > 0x10000000) ? 0x10000000 : (int) len ;
351
352		count = msadpcm_read_block (psf, pms, ptr, readcount) ;
353
354		total += count ;
355		len -= count ;
356		if (count != readcount)
357			break ;
358		} ;
359
360	return total ;
361} /* msadpcm_read_s */
362
363static sf_count_t
364msadpcm_read_i	(SF_PRIVATE *psf, int *ptr, sf_count_t len)
365{	MSADPCM_PRIVATE *pms ;
366	short		*sptr ;
367	int			k, bufferlen, readcount = 0, count ;
368	sf_count_t	total = 0 ;
369
370	if (! psf->codec_data)
371		return 0 ;
372	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
373
374	sptr = psf->u.sbuf ;
375	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
376	while (len > 0)
377	{	readcount = (len >= bufferlen) ? bufferlen : len ;
378		count = msadpcm_read_block (psf, pms, sptr, readcount) ;
379		for (k = 0 ; k < readcount ; k++)
380			ptr [total + k] = sptr [k] << 16 ;
381		total += count ;
382		len -= readcount ;
383		if (count != readcount)
384			break ;
385		} ;
386	return total ;
387} /* msadpcm_read_i */
388
389static sf_count_t
390msadpcm_read_f	(SF_PRIVATE *psf, float *ptr, sf_count_t len)
391{	MSADPCM_PRIVATE *pms ;
392	short		*sptr ;
393	int			k, bufferlen, readcount = 0, count ;
394	sf_count_t	total = 0 ;
395	float		normfact ;
396
397	if (! psf->codec_data)
398		return 0 ;
399	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
400
401	normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
402	sptr = psf->u.sbuf ;
403	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
404	while (len > 0)
405	{	readcount = (len >= bufferlen) ? bufferlen : len ;
406		count = msadpcm_read_block (psf, pms, sptr, readcount) ;
407		for (k = 0 ; k < readcount ; k++)
408			ptr [total + k] = normfact * (float) (sptr [k]) ;
409		total += count ;
410		len -= readcount ;
411		if (count != readcount)
412			break ;
413		} ;
414	return total ;
415} /* msadpcm_read_f */
416
417static sf_count_t
418msadpcm_read_d	(SF_PRIVATE *psf, double *ptr, sf_count_t len)
419{	MSADPCM_PRIVATE *pms ;
420	short		*sptr ;
421	int			k, bufferlen, readcount = 0, count ;
422	sf_count_t	total = 0 ;
423	double 		normfact ;
424
425	normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;
426
427	if (! psf->codec_data)
428		return 0 ;
429	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
430
431	sptr = psf->u.sbuf ;
432	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
433	while (len > 0)
434	{	readcount = (len >= bufferlen) ? bufferlen : len ;
435		count = msadpcm_read_block (psf, pms, sptr, readcount) ;
436		for (k = 0 ; k < readcount ; k++)
437			ptr [total + k] = normfact * (double) (sptr [k]) ;
438		total += count ;
439		len -= readcount ;
440		if (count != readcount)
441			break ;
442		} ;
443	return total ;
444} /* msadpcm_read_d */
445
446static sf_count_t
447msadpcm_seek	(SF_PRIVATE *psf, int mode, sf_count_t offset)
448{	MSADPCM_PRIVATE *pms ;
449	int			newblock, newsample ;
450
451	if (! psf->codec_data)
452		return 0 ;
453	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
454
455	if (psf->datalength < 0 || psf->dataoffset < 0)
456	{	psf->error = SFE_BAD_SEEK ;
457		return	PSF_SEEK_ERROR ;
458		} ;
459
460	if (offset == 0)
461	{	psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
462		pms->blockcount = 0 ;
463		msadpcm_decode_block (psf, pms) ;
464		pms->samplecount = 0 ;
465		return 0 ;
466		} ;
467
468	if (offset < 0 || offset > pms->blocks * pms->samplesperblock)
469	{	psf->error = SFE_BAD_SEEK ;
470		return	PSF_SEEK_ERROR ;
471		} ;
472
473	newblock	= offset / pms->samplesperblock ;
474	newsample	= offset % pms->samplesperblock ;
475
476	if (mode == SFM_READ)
477	{	psf_fseek (psf, psf->dataoffset + newblock * pms->blocksize, SEEK_SET) ;
478		pms->blockcount = newblock ;
479		msadpcm_decode_block (psf, pms) ;
480		pms->samplecount = newsample ;
481		}
482	else
483	{	/* What to do about write??? */
484		psf->error = SFE_BAD_SEEK ;
485		return	PSF_SEEK_ERROR ;
486		} ;
487
488	return newblock * pms->samplesperblock + newsample ;
489} /* msadpcm_seek */
490
491/*==========================================================================================
492** MS ADPCM Write Functions.
493*/
494
495void
496msadpcm_write_adapt_coeffs	(SF_PRIVATE *psf)
497{	int k ;
498
499	for (k = 0 ; k < MSADPCM_ADAPT_COEFF_COUNT ; k++)
500		psf_binheader_writef (psf, "22", AdaptCoeff1 [k], AdaptCoeff2 [k]) ;
501} /* msadpcm_write_adapt_coeffs */
502
503/*==========================================================================================
504*/
505
506static int
507msadpcm_encode_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms)
508{	unsigned int	blockindx ;
509	unsigned char	byte ;
510	int				chan, k, predict, bpred [2], idelta [2], errordelta, newsamp ;
511
512	choose_predictor (pms->channels, pms->samples, bpred, idelta) ;
513
514	/* Write the block header. */
515
516	if (pms->channels == 1)
517	{	pms->block [0]	= bpred [0] ;
518		pms->block [1]	= idelta [0] & 0xFF ;
519		pms->block [2]	= idelta [0] >> 8 ;
520		pms->block [3]	= pms->samples [1] & 0xFF ;
521		pms->block [4]	= pms->samples [1] >> 8 ;
522		pms->block [5]	= pms->samples [0] & 0xFF ;
523		pms->block [6]	= pms->samples [0] >> 8 ;
524
525		blockindx = 7 ;
526		byte = 0 ;
527
528		/* Encode the samples as 4 bit. */
529
530		for (k = 2 ; k < pms->samplesperblock ; k++)
531		{	predict = (pms->samples [k-1] * AdaptCoeff1 [bpred [0]] + pms->samples [k-2] * AdaptCoeff2 [bpred [0]]) >> 8 ;
532			errordelta = (pms->samples [k] - predict) / idelta [0] ;
533			if (errordelta < -8)
534				errordelta = -8 ;
535			else if (errordelta > 7)
536				errordelta = 7 ;
537			newsamp = predict + (idelta [0] * errordelta) ;
538			if (newsamp > 32767)
539				newsamp = 32767 ;
540			else if (newsamp < -32768)
541				newsamp = -32768 ;
542			if (errordelta < 0)
543				errordelta += 0x10 ;
544
545			byte = (byte << 4) | (errordelta & 0xF) ;
546			if (k % 2)
547			{	pms->block [blockindx++] = byte ;
548				byte = 0 ;
549				} ;
550
551			idelta [0] = (idelta [0] * AdaptationTable [errordelta]) >> 8 ;
552			if (idelta [0] < 16)
553				idelta [0] = 16 ;
554			pms->samples [k] = newsamp ;
555			} ;
556		}
557	else
558	{	/* Stereo file. */
559		pms->block [0]	= bpred [0] ;
560		pms->block [1]	= bpred [1] ;
561
562		pms->block [2]	= idelta [0] & 0xFF ;
563		pms->block [3]	= idelta [0] >> 8 ;
564		pms->block [4]	= idelta [1] & 0xFF ;
565		pms->block [5]	= idelta [1] >> 8 ;
566
567		pms->block [6]	= pms->samples [2] & 0xFF ;
568		pms->block [7]	= pms->samples [2] >> 8 ;
569		pms->block [8]	= pms->samples [3] & 0xFF ;
570		pms->block [9]	= pms->samples [3] >> 8 ;
571
572		pms->block [10]	= pms->samples [0] & 0xFF ;
573		pms->block [11]	= pms->samples [0] >> 8 ;
574		pms->block [12]	= pms->samples [1] & 0xFF ;
575		pms->block [13]	= pms->samples [1] >> 8 ;
576
577		blockindx = 14 ;
578		byte = 0 ;
579		chan = 1 ;
580
581		for (k = 4 ; k < 2 * pms->samplesperblock ; k++)
582		{	chan = k & 1 ;
583
584			predict = (pms->samples [k-2] * AdaptCoeff1 [bpred [chan]] + pms->samples [k-4] * AdaptCoeff2 [bpred [chan]]) >> 8 ;
585			errordelta = (pms->samples [k] - predict) / idelta [chan] ;
586
587
588			if (errordelta < -8)
589				errordelta = -8 ;
590			else if (errordelta > 7)
591				errordelta = 7 ;
592			newsamp = predict + (idelta [chan] * errordelta) ;
593			if (newsamp > 32767)
594				newsamp = 32767 ;
595			else if (newsamp < -32768)
596				newsamp = -32768 ;
597			if (errordelta < 0)
598				errordelta += 0x10 ;
599
600			byte = (byte << 4) | (errordelta & 0xF) ;
601
602			if (chan)
603			{	pms->block [blockindx++] = byte ;
604				byte = 0 ;
605				} ;
606
607			idelta [chan] = (idelta [chan] * AdaptationTable [errordelta]) >> 8 ;
608			if (idelta [chan] < 16)
609				idelta [chan] = 16 ;
610			pms->samples [k] = newsamp ;
611			} ;
612		} ;
613
614	/* Write the block to disk. */
615
616	if ((k = psf_fwrite (pms->block, 1, pms->blocksize, psf)) != pms->blocksize)
617		psf_log_printf (psf, "*** Warning : short write (%d != %d).\n", k, pms->blocksize) ;
618
619	memset (pms->samples, 0, pms->samplesperblock * sizeof (short)) ;
620
621	pms->blockcount ++ ;
622	pms->samplecount = 0 ;
623
624	return 1 ;
625} /* msadpcm_encode_block */
626
627static sf_count_t
628msadpcm_write_block	(SF_PRIVATE *psf, MSADPCM_PRIVATE *pms, const short *ptr, int len)
629{	int		count, total = 0, indx = 0 ;
630
631	while (indx < len)
632	{	count = (pms->samplesperblock - pms->samplecount) * pms->channels ;
633
634		if (count > len - indx)
635			count = len - indx ;
636
637		memcpy (&(pms->samples [pms->samplecount * pms->channels]), &(ptr [total]), count * sizeof (short)) ;
638		indx += count ;
639		pms->samplecount += count / pms->channels ;
640		total = indx ;
641
642		if (pms->samplecount >= pms->samplesperblock)
643			msadpcm_encode_block (psf, pms) ;
644		} ;
645
646	return total ;
647} /* msadpcm_write_block */
648
649static sf_count_t
650msadpcm_write_s	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
651{	MSADPCM_PRIVATE *pms ;
652	int			writecount, count ;
653	sf_count_t	total = 0 ;
654
655	if (! psf->codec_data)
656		return 0 ;
657	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
658
659	while (len > 0)
660	{	writecount = (len > 0x10000000) ? 0x10000000 : (int) len ;
661
662		count = msadpcm_write_block (psf, pms, ptr, writecount) ;
663
664		total += count ;
665		len -= count ;
666		if (count != writecount)
667			break ;
668		} ;
669
670	return total ;
671} /* msadpcm_write_s */
672
673static sf_count_t
674msadpcm_write_i	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
675{	MSADPCM_PRIVATE *pms ;
676	short		*sptr ;
677	int			k, bufferlen, writecount, count ;
678	sf_count_t	total = 0 ;
679
680	if (! psf->codec_data)
681		return 0 ;
682	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
683
684	sptr = psf->u.sbuf ;
685	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
686	while (len > 0)
687	{	writecount = (len >= bufferlen) ? bufferlen : len ;
688		for (k = 0 ; k < writecount ; k++)
689			sptr [k] = ptr [total + k] >> 16 ;
690		count = msadpcm_write_block (psf, pms, sptr, writecount) ;
691		total += count ;
692		len -= writecount ;
693		if (count != writecount)
694			break ;
695		} ;
696	return total ;
697} /* msadpcm_write_i */
698
699static sf_count_t
700msadpcm_write_f	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
701{	MSADPCM_PRIVATE *pms ;
702	short		*sptr ;
703	int			k, bufferlen, writecount, count ;
704	sf_count_t	total = 0 ;
705	float		normfact ;
706
707	if (! psf->codec_data)
708		return 0 ;
709	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
710
711	normfact = (psf->norm_float == SF_TRUE) ? (1.0 * 0x7FFF) : 1.0 ;
712
713	sptr = psf->u.sbuf ;
714	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
715	while (len > 0)
716	{	writecount = (len >= bufferlen) ? bufferlen : len ;
717		for (k = 0 ; k < writecount ; k++)
718			sptr [k] = lrintf (normfact * ptr [total + k]) ;
719		count = msadpcm_write_block (psf, pms, sptr, writecount) ;
720		total += count ;
721		len -= writecount ;
722		if (count != writecount)
723			break ;
724		} ;
725	return total ;
726} /* msadpcm_write_f */
727
728static sf_count_t
729msadpcm_write_d	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
730{	MSADPCM_PRIVATE *pms ;
731	short		*sptr ;
732	int			k, bufferlen, writecount, count ;
733	sf_count_t	total = 0 ;
734	double 		normfact ;
735
736	normfact = (psf->norm_double == SF_TRUE) ? (1.0 * 0x7FFF) : 1.0 ;
737
738	if (! psf->codec_data)
739		return 0 ;
740	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
741
742	sptr = psf->u.sbuf ;
743	bufferlen = ARRAY_LEN (psf->u.sbuf) ;
744	while (len > 0)
745	{	writecount = (len >= bufferlen) ? bufferlen : len ;
746		for (k = 0 ; k < writecount ; k++)
747			sptr [k] = lrint (normfact * ptr [total + k]) ;
748		count = msadpcm_write_block (psf, pms, sptr, writecount) ;
749		total += count ;
750		len -= writecount ;
751		if (count != writecount)
752			break ;
753		} ;
754	return total ;
755} /* msadpcm_write_d */
756
757/*========================================================================================
758*/
759
760static int
761msadpcm_close	(SF_PRIVATE *psf)
762{	MSADPCM_PRIVATE *pms ;
763
764	pms = (MSADPCM_PRIVATE*) psf->codec_data ;
765
766	if (psf->file.mode == SFM_WRITE)
767	{	/*  Now we know static int for certain the length of the file we can
768		**  re-write the header.
769		*/
770
771		if (pms->samplecount && pms->samplecount < pms->samplesperblock)
772			msadpcm_encode_block (psf, pms) ;
773		} ;
774
775	return 0 ;
776} /* msadpcm_close */
777
778/*========================================================================================
779** Static functions.
780*/
781
782/*----------------------------------------------------------------------------------------
783**	Choosing the block predictor.
784**	Each block requires a predictor and an idelta for each channel.
785**	The predictor is in the range [0..6] which is an indx into the	two AdaptCoeff tables.
786**	The predictor is chosen by trying all of the possible predictors on a small set of
787**	samples at the beginning of the block. The predictor with the smallest average
788**	abs (idelta) is chosen as the best predictor for this block.
789**	The value of idelta is chosen to to give a 4 bit code value of +/- 4 (approx. half the
790**	max. code value). If the average abs (idelta) is zero, the sixth predictor is chosen.
791**	If the value of idelta is less then 16 it is set to 16.
792**
793**	Microsoft uses an IDELTA_COUNT (number of sample pairs used to choose best predictor)
794**	value of 3. The best possible results would be obtained by using all the samples to
795**	choose the predictor.
796*/
797
798#define		IDELTA_COUNT	3
799
800static	void
801choose_predictor (unsigned int channels, short *data, int *block_pred, int *idelta)
802{	unsigned int	chan, k, bpred, idelta_sum, best_bpred, best_idelta ;
803
804	for (chan = 0 ; chan < channels ; chan++)
805	{	best_bpred = best_idelta = 0 ;
806
807		for (bpred = 0 ; bpred < 7 ; bpred++)
808		{	idelta_sum = 0 ;
809			for (k = 2 ; k < 2 + IDELTA_COUNT ; k++)
810				idelta_sum += abs (data [k * channels] - ((data [(k - 1) * channels] * AdaptCoeff1 [bpred] + data [(k - 2) * channels] * AdaptCoeff2 [bpred]) >> 8)) ;
811			idelta_sum /= (4 * IDELTA_COUNT) ;
812
813			if (bpred == 0 || idelta_sum < best_idelta)
814			{	best_bpred = bpred ;
815				best_idelta = idelta_sum ;
816				} ;
817
818			if (! idelta_sum)
819			{	best_bpred = bpred ;
820				best_idelta = 16 ;
821				break ;
822				} ;
823
824			} ; /* for bpred ... */
825		if (best_idelta < 16)
826			best_idelta = 16 ;
827
828		block_pred [chan]	= best_bpred ;
829		idelta [chan]		= best_idelta ;
830		} ;
831
832	return ;
833} /* choose_predictor */
834