PageRenderTime 69ms CodeModel.GetById 17ms app.highlight 48ms RepoModel.GetById 1ms app.codeStats 0ms

/project/jni/sndfile/src/dither.c

https://github.com/aichunyu/FFPlayer
C | 534 lines | 358 code | 114 blank | 62 comment | 82 complexity | 5b1bd323250f895829fc8b5455bd4ff3 MD5 | raw file
  1/*
  2** Copyright (C) 2003-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	<stdlib.h>
 22
 23#include	"sndfile.h"
 24#include	"sfendian.h"
 25#include	"common.h"
 26
 27/*============================================================================
 28**	Rule number 1 is to only apply dither when going from a larger bitwidth
 29**	to a smaller bitwidth. This can happen on both read and write.
 30**
 31**	Need to apply dither on all conversions marked X below.
 32**
 33**	Dither on write:
 34**
 35**										Input
 36**					|	short		int			float		double
 37**			--------+-----------------------------------------------
 38**		O	8 bit	|	X			X			X			X
 39**		u	16 bit	|	none		X			X			X
 40**		t	24 bit	|	none		X			X			X
 41**		p	32 bit	|	none		none		X			X
 42**		u	float	|	none		none		none		none
 43**		t	double	|	none		none		none		none
 44**
 45**	Dither on read:
 46**
 47**										Input
 48**		O			|	8 bit	16 bit	24 bit	32 bit	float	double
 49**		u	--------+-------------------------------------------------
 50**		t	short	|	none	none	X		X		X		X
 51**		p	int		|	none	none	none	X		X		X
 52**		u	float	|	none	none	none	none	none	none
 53**		t	double	|	none	none	none	none	none	none
 54*/
 55
 56#define	SFE_DITHER_BAD_PTR	666
 57#define	SFE_DITHER_BAD_TYPE	667
 58
 59typedef struct
 60{	int			read_short_dither_bits, read_int_dither_bits ;
 61	int			write_short_dither_bits, write_int_dither_bits ;
 62	double		read_float_dither_scale, read_double_dither_bits ;
 63	double		write_float_dither_scale, write_double_dither_bits ;
 64
 65	sf_count_t	(*read_short)	(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
 66	sf_count_t	(*read_int)		(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
 67	sf_count_t	(*read_float)	(SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
 68	sf_count_t	(*read_double)	(SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
 69
 70	sf_count_t	(*write_short)	(SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
 71	sf_count_t	(*write_int)	(SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
 72	sf_count_t	(*write_float)	(SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
 73	sf_count_t	(*write_double)	(SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 74
 75	double buffer [SF_BUFFER_LEN / sizeof (double)] ;
 76} DITHER_DATA ;
 77
 78static sf_count_t dither_read_short		(SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
 79static sf_count_t dither_read_int		(SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
 80
 81static sf_count_t dither_write_short	(SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
 82static sf_count_t dither_write_int		(SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
 83static sf_count_t dither_write_float	(SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
 84static sf_count_t dither_write_double	(SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
 85
 86int
 87dither_init (SF_PRIVATE *psf, int mode)
 88{	DITHER_DATA *pdither ;
 89
 90	pdither = psf->dither ; /* This may be NULL. */
 91
 92	/* Turn off dither on read. */
 93	if (mode == SFM_READ && psf->read_dither.type == SFD_NO_DITHER)
 94	{	if (pdither == NULL)
 95			return 0 ; /* Dither is already off, so just return. */
 96
 97		if (pdither->read_short)
 98			psf->read_short = pdither->read_short ;
 99		if (pdither->read_int)
100			psf->read_int = pdither->read_int ;
101		if (pdither->read_float)
102			psf->read_float = pdither->read_float ;
103		if (pdither->read_double)
104			psf->read_double = pdither->read_double ;
105		return 0 ;
106		} ;
107
108	/* Turn off dither on write. */
109	if (mode == SFM_WRITE && psf->write_dither.type == SFD_NO_DITHER)
110	{	if (pdither == NULL)
111			return 0 ; /* Dither is already off, so just return. */
112
113		if (pdither->write_short)
114			psf->write_short = pdither->write_short ;
115		if (pdither->write_int)
116			psf->write_int = pdither->write_int ;
117		if (pdither->write_float)
118			psf->write_float = pdither->write_float ;
119		if (pdither->write_double)
120			psf->write_double = pdither->write_double ;
121		return 0 ;
122		} ;
123
124	/* Turn on dither on read if asked. */
125	if (mode == SFM_READ && psf->read_dither.type != 0)
126	{	if (pdither == NULL)
127			pdither = psf->dither = calloc (1, sizeof (DITHER_DATA)) ;
128		if (pdither == NULL)
129			return SFE_MALLOC_FAILED ;
130
131		switch (SF_CODEC (psf->sf.format))
132		{	case SF_FORMAT_DOUBLE :
133			case SF_FORMAT_FLOAT :
134					pdither->read_int = psf->read_int ;
135					psf->read_int = dither_read_int ;
136					break ;
137
138			case SF_FORMAT_PCM_32 :
139			case SF_FORMAT_PCM_24 :
140			case SF_FORMAT_PCM_16 :
141			case SF_FORMAT_PCM_S8 :
142			case SF_FORMAT_PCM_U8 :
143					pdither->read_short = psf->read_short ;
144					psf->read_short = dither_read_short ;
145					break ;
146
147			default : break ;
148			} ;
149		} ;
150
151	/* Turn on dither on write if asked. */
152	if (mode == SFM_WRITE && psf->write_dither.type != 0)
153	{	if (pdither == NULL)
154			pdither = psf->dither = calloc (1, sizeof (DITHER_DATA)) ;
155		if (pdither == NULL)
156			return SFE_MALLOC_FAILED ;
157
158		switch (SF_CODEC (psf->sf.format))
159		{	case SF_FORMAT_DOUBLE :
160			case SF_FORMAT_FLOAT :
161					pdither->write_int = psf->write_int ;
162					psf->write_int = dither_write_int ;
163					break ;
164
165			case SF_FORMAT_PCM_32 :
166			case SF_FORMAT_PCM_24 :
167			case SF_FORMAT_PCM_16 :
168			case SF_FORMAT_PCM_S8 :
169			case SF_FORMAT_PCM_U8 :
170					break ;
171
172			default : break ;
173			} ;
174
175		pdither->write_short = psf->write_short ;
176		psf->write_short = dither_write_short ;
177
178		pdither->write_int = psf->write_int ;
179		psf->write_int = dither_write_int ;
180
181		pdither->write_float = psf->write_float ;
182		psf->write_float = dither_write_float ;
183
184		pdither->write_double = psf->write_double ;
185		psf->write_double = dither_write_double ;
186		} ;
187
188	return 0 ;
189} /* dither_init */
190
191/*==============================================================================
192*/
193
194static void dither_short	(const short *in, short *out, int frames, int channels) ;
195static void dither_int		(const int *in, int *out, int frames, int channels) ;
196
197static void dither_float	(const float *in, float *out, int frames, int channels) ;
198static void dither_double	(const double *in, double *out, int frames, int channels) ;
199
200static sf_count_t
201dither_read_short (SF_PRIVATE * UNUSED (psf), short * UNUSED (ptr), sf_count_t len)
202{
203	return len ;
204} /* dither_read_short */
205
206static sf_count_t
207dither_read_int (SF_PRIVATE * UNUSED (psf), int * UNUSED (ptr), sf_count_t len)
208{
209	return len ;
210} /* dither_read_int */
211
212/*------------------------------------------------------------------------------
213*/
214
215static sf_count_t
216dither_write_short	(SF_PRIVATE *psf, const short *ptr, sf_count_t len)
217{	DITHER_DATA *pdither ;
218	int			bufferlen, writecount, thiswrite ;
219	sf_count_t	total = 0 ;
220
221	if ((pdither = psf->dither) == NULL)
222	{	psf->error = SFE_DITHER_BAD_PTR ;
223		return 0 ;
224		} ;
225
226	switch (SF_CODEC (psf->sf.format))
227	{	case SF_FORMAT_PCM_S8 :
228		case SF_FORMAT_PCM_U8 :
229		case SF_FORMAT_DPCM_8 :
230				break ;
231
232		default :
233			return pdither->write_short (psf, ptr, len) ;
234		} ;
235
236	bufferlen = sizeof (pdither->buffer) / sizeof (short) ;
237
238	while (len > 0)
239	{	writecount = (len >= bufferlen) ? bufferlen : (int) len ;
240		writecount /= psf->sf.channels ;
241		writecount *= psf->sf.channels ;
242
243		dither_short (ptr, (short*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ;
244
245		thiswrite = pdither->write_short (psf, (short*) pdither->buffer, writecount) ;
246		total += thiswrite ;
247		len -= thiswrite ;
248		if (thiswrite < writecount)
249			break ;
250		} ;
251
252	return total ;
253} /* dither_write_short */
254
255static sf_count_t
256dither_write_int	(SF_PRIVATE *psf, const int *ptr, sf_count_t len)
257{	DITHER_DATA *pdither ;
258	int			bufferlen, writecount, thiswrite ;
259	sf_count_t	total = 0 ;
260
261	if ((pdither = psf->dither) == NULL)
262	{	psf->error = SFE_DITHER_BAD_PTR ;
263		return 0 ;
264		} ;
265
266	switch (SF_CODEC (psf->sf.format))
267	{	case SF_FORMAT_PCM_S8 :
268		case SF_FORMAT_PCM_U8 :
269		case SF_FORMAT_PCM_16 :
270		case SF_FORMAT_PCM_24 :
271				break ;
272
273		case SF_FORMAT_DPCM_8 :
274		case SF_FORMAT_DPCM_16 :
275				break ;
276
277		default :
278			return pdither->write_int (psf, ptr, len) ;
279		} ;
280
281
282	bufferlen = sizeof (pdither->buffer) / sizeof (int) ;
283
284	while (len > 0)
285	{	writecount = (len >= bufferlen) ? bufferlen : (int) len ;
286		writecount /= psf->sf.channels ;
287		writecount *= psf->sf.channels ;
288
289		dither_int (ptr, (int*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ;
290
291		thiswrite = pdither->write_int (psf, (int*) pdither->buffer, writecount) ;
292		total += thiswrite ;
293		len -= thiswrite ;
294		if (thiswrite < writecount)
295			break ;
296		} ;
297
298	return total ;
299} /* dither_write_int */
300
301static sf_count_t
302dither_write_float	(SF_PRIVATE *psf, const float *ptr, sf_count_t len)
303{	DITHER_DATA *pdither ;
304	int			bufferlen, writecount, thiswrite ;
305	sf_count_t	total = 0 ;
306
307	if ((pdither = psf->dither) == NULL)
308	{	psf->error = SFE_DITHER_BAD_PTR ;
309		return 0 ;
310		} ;
311
312	switch (SF_CODEC (psf->sf.format))
313	{	case SF_FORMAT_PCM_S8 :
314		case SF_FORMAT_PCM_U8 :
315		case SF_FORMAT_PCM_16 :
316		case SF_FORMAT_PCM_24 :
317				break ;
318
319		case SF_FORMAT_DPCM_8 :
320		case SF_FORMAT_DPCM_16 :
321				break ;
322
323		default :
324			return pdither->write_float (psf, ptr, len) ;
325		} ;
326
327	bufferlen = sizeof (pdither->buffer) / sizeof (float) ;
328
329	while (len > 0)
330	{	writecount = (len >= bufferlen) ? bufferlen : (float) len ;
331		writecount /= psf->sf.channels ;
332		writecount *= psf->sf.channels ;
333
334		dither_float (ptr, (float*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ;
335
336		thiswrite = pdither->write_float (psf, (float*) pdither->buffer, writecount) ;
337		total += thiswrite ;
338		len -= thiswrite ;
339		if (thiswrite < writecount)
340			break ;
341		} ;
342
343	return total ;
344} /* dither_write_float */
345
346static sf_count_t
347dither_write_double	(SF_PRIVATE *psf, const double *ptr, sf_count_t len)
348{	DITHER_DATA *pdither ;
349	int			bufferlen, writecount, thiswrite ;
350	sf_count_t	total = 0 ;
351
352	if ((pdither = psf->dither) == NULL)
353	{	psf->error = SFE_DITHER_BAD_PTR ;
354		return 0 ;
355		} ;
356
357	switch (SF_CODEC (psf->sf.format))
358	{	case SF_FORMAT_PCM_S8 :
359		case SF_FORMAT_PCM_U8 :
360		case SF_FORMAT_PCM_16 :
361		case SF_FORMAT_PCM_24 :
362				break ;
363
364		case SF_FORMAT_DPCM_8 :
365		case SF_FORMAT_DPCM_16 :
366				break ;
367
368		default :
369			return pdither->write_double (psf, ptr, len) ;
370		} ;
371
372
373	bufferlen = sizeof (pdither->buffer) / sizeof (double) ;
374
375	while (len > 0)
376	{	writecount = (len >= bufferlen) ? bufferlen : (double) len ;
377		writecount /= psf->sf.channels ;
378		writecount *= psf->sf.channels ;
379
380		dither_double (ptr, (double*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ;
381
382		thiswrite = pdither->write_double (psf, (double*) pdither->buffer, writecount) ;
383		total += thiswrite ;
384		len -= thiswrite ;
385		if (thiswrite < writecount)
386			break ;
387		} ;
388
389	return total ;
390} /* dither_write_double */
391
392/*==============================================================================
393*/
394
395static void
396dither_short (const short *in, short *out, int frames, int channels)
397{	int ch, k ;
398
399	for (ch = 0 ; ch < channels ; ch++)
400		for (k = ch ; k < channels * frames ; k += channels)
401			out [k] = in [k] ;
402
403} /* dither_short */
404
405static void
406dither_int (const int *in, int *out, int frames, int channels)
407{	int ch, k ;
408
409	for (ch = 0 ; ch < channels ; ch++)
410		for (k = ch ; k < channels * frames ; k += channels)
411			out [k] = in [k] ;
412
413} /* dither_int */
414
415static void
416dither_float (const float *in, float *out, int frames, int channels)
417{	int ch, k ;
418
419	for (ch = 0 ; ch < channels ; ch++)
420		for (k = ch ; k < channels * frames ; k += channels)
421			out [k] = in [k] ;
422
423} /* dither_float */
424
425static void
426dither_double (const double *in, double *out, int frames, int channels)
427{	int ch, k ;
428
429	for (ch = 0 ; ch < channels ; ch++)
430		for (k = ch ; k < channels * frames ; k += channels)
431			out [k] = in [k] ;
432
433} /* dither_double */
434
435/*==============================================================================
436*/
437#if 0
438
439/*
440** Not made public because this (maybe) requires storage of state information.
441**
442** Also maybe need separate state info for each channel!!!!
443*/
444
445int
446DO_NOT_USE_sf_dither_short (const SF_DITHER_INFO *dither, const short *in, short *out, int frames, int channels)
447{	int ch, k ;
448
449	if (! dither)
450		return SFE_DITHER_BAD_PTR ;
451
452	switch (dither->type & SFD_TYPEMASK)
453	{	case SFD_WHITE :
454		case SFD_TRIANGULAR_PDF :
455				for (ch = 0 ; ch < channels ; ch++)
456					for (k = ch ; k < channels * frames ; k += channels)
457						out [k] = in [k] ;
458				break ;
459
460		default :
461			return SFE_DITHER_BAD_TYPE ;
462		} ;
463
464	return 0 ;
465} /* DO_NOT_USE_sf_dither_short */
466
467int
468DO_NOT_USE_sf_dither_int (const SF_DITHER_INFO *dither, const int *in, int *out, int frames, int channels)
469{	int ch, k ;
470
471	if (! dither)
472		return SFE_DITHER_BAD_PTR ;
473
474	switch (dither->type & SFD_TYPEMASK)
475	{	case SFD_WHITE :
476		case SFD_TRIANGULAR_PDF :
477				for (ch = 0 ; ch < channels ; ch++)
478					for (k = ch ; k < channels * frames ; k += channels)
479						out [k] = in [k] ;
480				break ;
481
482		default :
483			return SFE_DITHER_BAD_TYPE ;
484		} ;
485
486	return 0 ;
487} /* DO_NOT_USE_sf_dither_int */
488
489int
490DO_NOT_USE_sf_dither_float (const SF_DITHER_INFO *dither, const float *in, float *out, int frames, int channels)
491{	int ch, k ;
492
493	if (! dither)
494		return SFE_DITHER_BAD_PTR ;
495
496	switch (dither->type & SFD_TYPEMASK)
497	{	case SFD_WHITE :
498		case SFD_TRIANGULAR_PDF :
499				for (ch = 0 ; ch < channels ; ch++)
500					for (k = ch ; k < channels * frames ; k += channels)
501						out [k] = in [k] ;
502				break ;
503
504		default :
505			return SFE_DITHER_BAD_TYPE ;
506		} ;
507
508	return 0 ;
509} /* DO_NOT_USE_sf_dither_float */
510
511int
512DO_NOT_USE_sf_dither_double (const SF_DITHER_INFO *dither, const double *in, double *out, int frames, int channels)
513{	int ch, k ;
514
515	if (! dither)
516		return SFE_DITHER_BAD_PTR ;
517
518	switch (dither->type & SFD_TYPEMASK)
519	{	case SFD_WHITE :
520		case SFD_TRIANGULAR_PDF :
521				for (ch = 0 ; ch < channels ; ch++)
522					for (k = ch ; k < channels * frames ; k += channels)
523						out [k] = in [k] ;
524				break ;
525
526		default :
527			return SFE_DITHER_BAD_TYPE ;
528		} ;
529
530	return 0 ;
531} /* DO_NOT_USE_sf_dither_double */
532
533#endif
534