流媒体/Mpeg4/MP4

开发平台：
C/C++

wav.c：源码内容
							/*
** Copyright (C) 1999-2000 Erik de Castro Lopo <erikd@zip.com.au>
**  
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU Lesser General Public License as published by
** the Free Software Foundation; either version 2.1 of the License, or
** (at your option) any later version.
** 
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU Lesser General Public License for more details.
** 
** You should have received a copy of the GNU Lesser General Public License
** along with this program; if not, write to the Free Software 
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include	<stdio.h>
#include	<unistd.h>
#include	<string.h>
#include	<ctype.h>
#include	"sndfile.h"
#include	"config.h"
#include	"sfendian.h"
#include	"common.h"
#include	"pcm.h"
#include	"ulaw.h"
#include	"alaw.h"
#include	"wav.h"
/*------------------------------------------------------------------------------
** List of known WAV format tags
*/
enum
{	
	WAVE_FORMAT_UNKNOWN				= 0x0000,		/* Microsoft Corporation */
	WAVE_FORMAT_PCM     		    = 0x0001, 		/* Microsoft PCM format */
	WAVE_FORMAT_MS_ADPCM			= 0x0002,		/* Microsoft ADPCM */
	WAVE_FORMAT_IEEE_FLOAT			= 0x0003,		/* Micrososft 32 bit float format */
	
	WAVE_FORMAT_IBM_CVSD			= 0x0005,		/* IBM Corporation */
	WAVE_FORMAT_ALAW				= 0x0006,		/* Microsoft Corporation */
	WAVE_FORMAT_MULAW				= 0x0007,		/* Microsoft Corporation */
	WAVE_FORMAT_OKI_ADPCM			= 0x0010,		/* OKI */
	WAVE_FORMAT_IMA_ADPCM			= 0x0011,		/* Intel Corporation */
	WAVE_FORMAT_MEDIASPACE_ADPCM	= 0x0012,		/* Videologic */
	WAVE_FORMAT_SIERRA_ADPCM		= 0x0013,		/* Sierra Semiconductor Corp */
	WAVE_FORMAT_G723_ADPCM			= 0x0014,		/* Antex Electronics Corporation */
	WAVE_FORMAT_DIGISTD				= 0x0015,		/* DSP Solutions, Inc. */
	WAVE_FORMAT_DIGIFIX				= 0x0016,		/* DSP Solutions, Inc. */
	WAVE_FORMAT_DIALOGIC_OKI_ADPCM	= 0x0017,		/*  Dialogic Corporation  */
	WAVE_FORMAT_MEDIAVISION_ADPCM	= 0x0018,		/*  Media Vision, Inc. */
	WAVE_FORMAT_YAMAHA_ADPCM		= 0x0020,		/* Yamaha Corporation of America */
	WAVE_FORMAT_SONARC				= 0x0021,		/* Speech Compression */
	WAVE_FORMAT_DSPGROUP_TRUESPEECH = 0x0022,		/* DSP Group, Inc */
	WAVE_FORMAT_ECHOSC1				= 0x0023,		/* Echo Speech Corporation */
	WAVE_FORMAT_AUDIOFILE_AF18  	= 0x0024,		/* Audiofile, Inc. */
	WAVE_FORMAT_APTX				= 0x0025,		/* Audio Processing Technology */
	WAVE_FORMAT_AUDIOFILE_AF10  	= 0x0026,		/* Audiofile, Inc. */
	WAVE_FORMAT_DOLBY_AC2			= 0x0030,		/* Dolby Laboratories */
	WAVE_FORMAT_GSM610				= 0x0031,		/* Microsoft Corporation */
	WAVE_FORMAT_MSNAUDIO			= 0x0032,		/* Microsoft Corporation */
	WAVE_FORMAT_ANTEX_ADPCME		= 0x0033, 		/* Antex Electronics Corporation */
	WAVE_FORMAT_CONTROL_RES_VQLPC	= 0x0034,		/* Control Resources Limited */
	WAVE_FORMAT_DIGIREAL			= 0x0035,		/* DSP Solutions, Inc. */
	WAVE_FORMAT_DIGIADPCM			= 0x0036,		/* DSP Solutions, Inc. */
	WAVE_FORMAT_CONTROL_RES_CR10	= 0x0037,		/* Control Resources Limited */
	WAVE_FORMAT_NMS_VBXADPCM		= 0x0038,		/* Natural MicroSystems */
	WAVE_FORMAT_ROCKWELL_ADPCM		= 0x003B,		/* Rockwell International */
	WAVE_FORMAT_ROCKWELL_DIGITALK	= 0x003C, 		/* Rockwell International */
	WAVE_FORMAT_G721_ADPCM			= 0x0040,		/* Antex Electronics Corporation */
	WAVE_FORMAT_MPEG				= 0x0050,		/* Microsoft Corporation */
	WAVE_FORMAT_MPEGLAYER3			= 0x0055,		/* MPEG 3 Layer 1 */
	IBM_FORMAT_MULAW				= 0x0101,		/* IBM mu-law format */
	IBM_FORMAT_ALAW					= 0x0102,		/* IBM a-law format */
	IBM_FORMAT_ADPCM				= 0x0103,		/* IBM AVC Adaptive Differential PCM format */
	WAVE_FORMAT_CREATIVE_ADPCM		= 0x0200,		/* Creative Labs, Inc */
	WAVE_FORMAT_FM_TOWNS_SND		= 0x0300,		/* Fujitsu Corp. */
	WAVE_FORMAT_OLIGSM				= 0x1000,		/* Ing C. Olivetti & C., S.p.A. */
	WAVE_FORMAT_OLIADPCM			= 0x1001,		/* Ing C. Olivetti & C., S.p.A. */
	WAVE_FORMAT_OLICELP				= 0x1002,		/* Ing C. Olivetti & C., S.p.A. */
	WAVE_FORMAT_OLISBC				= 0x1003,		/* Ing C. Olivetti & C., S.p.A. */
	WAVE_FORMAT_OLIOPR				= 0x1004,		/* Ing C. Olivetti & C., S.p.A. */
	WAVE_FORMAT_EXTENSIBLE			= 0xFFFE
} ;
/*------------------------------------------------------------------------------
 * Macros to handle big/little endian issues.
 */
#if (CPU_IS_LITTLE_ENDIAN == 1)
#	define	MAKE_MARKER(a,b,c,d)		((a)|((b)<<8)|((c)<<16)|((d)<<24))
#elif (CPU_IS_BIG_ENDIAN == 1)
#	define	MAKE_MARKER(a,b,c,d)		(((a)<<24)|((b)<<16)|((c)<<8)|(d))
#else
#	error "Cannot determine endian-ness of processor."
#endif
#define RIFF_MARKER	(MAKE_MARKER ('R', 'I', 'F', 'F')) 
#define WAVE_MARKER	(MAKE_MARKER ('W', 'A', 'V', 'E')) 
#define fmt_MARKER	(MAKE_MARKER ('f', 'm', 't', ' ')) 
#define data_MARKER	(MAKE_MARKER ('d', 'a', 't', 'a')) 
#define cue_MARKER	(MAKE_MARKER ('c', 'u', 'e', ' ')) 
#define LIST_MARKER	(MAKE_MARKER ('L', 'I', 'S', 'T')) 
#define slnt_MARKER	(MAKE_MARKER ('s', 'l', 'n', 't')) 
#define wavl_MARKER	(MAKE_MARKER ('w', 'a', 'v', 'l')) 
#define INFO_MARKER	(MAKE_MARKER ('I', 'N', 'F', 'O')) 
#define plst_MARKER	(MAKE_MARKER ('p', 'l', 's', 't')) 
#define adtl_MARKER	(MAKE_MARKER ('a', 'd', 't', 'l')) 
#define labl_MARKER	(MAKE_MARKER ('l', 'a', 'b', 'l')) 
#define note_MARKER	(MAKE_MARKER ('n', 'o', 't', 'e')) 
#define fact_MARKER	(MAKE_MARKER ('f', 'a', 'c', 't')) 
#define smpl_MARKER	(MAKE_MARKER ('s', 'm', 'p', 'l')) 
#define bext_MARKER	(MAKE_MARKER ('b', 'e', 'x', 't')) 
#define MEXT_MARKER	(MAKE_MARKER ('M', 'E', 'X', 'T')) 
#define DISP_MARKER	(MAKE_MARKER ('D', 'I', 'S', 'P')) 
/*------------------------------------------------------------------------------
 * Private static functions.
 */
static int		read_fmt_chunk	(SF_PRIVATE *psf, WAV_FMT *wav_fmt) ;
static int		write_header (SF_PRIVATE *psf, WAV_FMT *wav_fmt, unsigned int size, int do_fact) ;
static const 	char* wav_format_str (int k) ;
static void		le2h_wav_fmt (WAV_FMT *fmt) ;
static void		h2le_wav_fmt (WAV_FMT *fmt) ;
/*------------------------------------------------------------------------------
 * Public functions.
 */
int 	wav_open_read	(SF_PRIVATE *psf)
{	WAV_FMT			wav_fmt ;
	FACT_CHUNK		fact_chunk ;
	unsigned int	dword, marker, RIFFsize ;
	int				parsestage = 0, error, format = 0 ;
	/*or*/
	int force_open; 
	force_open = ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORCE_OPEN)?1:0;
	/*end or*/
	
	psf->sf.seekable = SF_TRUE ;
	while (1)
	{	fread (&marker, sizeof (marker), 1, psf->file) ;
		switch (marker)
		{	case RIFF_MARKER :
					if (parsestage != 0)
						return SFE_WAV_NO_RIFF ;
					fread (&dword, sizeof (dword), 1, psf->file) ;
					RIFFsize = LE2H_INT (dword) ;	
					if (psf->filelength  < RIFFsize + 2 * sizeof (dword))
					{	dword = psf->filelength - 2 * sizeof (dword);
						psf_sprintf (psf, "RIFF : %d (should be %d)n", RIFFsize, dword) ;
						RIFFsize = dword ;
						}
					else
						psf_sprintf (psf, "RIFF : %dn", RIFFsize) ;
					parsestage = 1 ;
					break ;
					
			case WAVE_MARKER :
					if (parsestage != 1)
						return SFE_WAV_NO_WAVE ;
					psf_sprintf (psf, "WAVEn") ;
					parsestage = 2 ;
					break ;
			
			case fmt_MARKER :
					if (parsestage != 2)
						return SFE_WAV_NO_FMT ;
					if ((error = read_fmt_chunk (psf, &wav_fmt)))
						return error ;
						
					format     = wav_fmt.format ;
					parsestage = 3 ;
					break ;
					
			case data_MARKER :
					if (parsestage < 3)
						return SFE_WAV_NO_DATA ;
					fread (&dword, sizeof (dword), 1, psf->file) ;
					psf->datalength = LE2H_INT (dword) ;
					psf->dataoffset = ftell (psf->file) ;
					
					if (psf->filelength < psf->dataoffset + psf->datalength)
					{	psf_sprintf (psf, "data : %d (should be %d)n", psf->datalength, psf->filelength - psf->dataoffset) ;
						psf->datalength = psf->filelength - psf->dataoffset ;
						}
					else
						psf_sprintf (psf, "data : %dn", psf->datalength) ;
					if (format == WAVE_FORMAT_MS_ADPCM && psf->datalength % 2)
					{	psf->datalength ++ ;
						psf_sprintf (psf, "*** Data length odd. Increasing it by 1.n") ;
						} ;
		
					fseek (psf->file, psf->datalength, SEEK_CUR) ;
					dword = ftell (psf->file) ;
					if (dword != (off_t) (psf->dataoffset + psf->datalength))
						psf_sprintf (psf, "*** fseek past end error ***n", dword, psf->dataoffset + psf->datalength) ;
					break ;
			case fact_MARKER :
					fread (&dword, sizeof (dword), 1, psf->file) ;
					dword = LE2H_INT (dword) ;
					fread (&fact_chunk, sizeof (fact_chunk), 1, psf->file) ;
					if (dword > sizeof (fact_chunk))
						fseek (psf->file, (int) (dword - sizeof (fact_chunk)), SEEK_CUR) ;
					fact_chunk.samples = LE2H_INT (fact_chunk.samples) ;
					psf_sprintf (psf, "%D : %dn", marker, dword) ;
					psf_sprintf (psf, "  samples : %dn", fact_chunk.samples) ;
					break ;
			case cue_MARKER :
			case LIST_MARKER :
			case INFO_MARKER :
			case smpl_MARKER :
			case bext_MARKER :
			case MEXT_MARKER :
			case DISP_MARKER :
					fread (&dword, sizeof (dword), 1, psf->file) ;
					dword = LE2H_INT (dword) ;
					psf_sprintf (psf, "%D : %dn", marker, dword) ;
					fseek (psf->file, (int) dword, SEEK_CUR) ;
					break ;
			default : 
					if (isprint ((marker >> 24) & 0xFF) && isprint ((marker >> 16) & 0xFF)
						&& isprint ((marker >> 8) & 0xFF) && isprint (marker & 0xFF))
					{	fread (&dword, sizeof (dword), 1, psf->file) ;
						psf_sprintf (psf, "%D : %d (unknown marker)n", marker, dword) ;
						fseek (psf->file, (int) dword, SEEK_CUR) ;
						break ;
						} ;
					if ((dword = ftell (psf->file)) & 0x03)
					{	psf_sprintf (psf, "  Unknown chunk marker at position %d. Resynching.n", dword - 4) ;
						fseek (psf->file, -3, SEEK_CUR) ;
						break ;
						} ;
					psf_sprintf (psf, "*** Unknown chunk marker : %X. Exiting parser.n", marker) ;
					break ;
			} ;	/* switch (dword) */
		if (ferror (psf->file))
		{	psf_sprintf (psf, "*** Error on file handle. ***n", marker) ;
			clearerr (psf->file) ;
			break ;
			} ;
		if (ftell (psf->file) >= (int) (psf->filelength - (2 * sizeof (dword))))
			break ;
		} ; /* while (1) */
		
	if (! psf->dataoffset)
		return SFE_WAV_NO_DATA ;
	psf->current     = 0 ;
	psf->endian      = SF_ENDIAN_LITTLE ;		/* All WAV files are little endian. */
	psf->sf.sections = 1 ;
	
	fseek (psf->file, psf->dataoffset, SEEK_SET) ;
	
	psf->close = (func_close) wav_close ;
	//or
	if(force_open)
	{
	    psf->sf.format_tag = format;
	    psf->sf.bytewidth = psf->bytewidth;
	    psf->sf.avg_bytes_per_sec=wav_fmt.min.bytespersec;
	    psf->sf.format = SF_FORMAT_WAV | SF_FORCE_OPEN ;
	}    
	//end or
	
	if (psf->blockwidth)
	{	if (psf->filelength - psf->dataoffset < psf->datalength)
			psf->sf.samples = (psf->filelength - psf->dataoffset) / psf->blockwidth ;
		else
			psf->sf.samples = psf->datalength / psf->blockwidth ;
		} ;
	switch (format)
	{	case 	WAVE_FORMAT_PCM :
		case	WAVE_FORMAT_EXTENSIBLE :
					break ;
					
		case	WAVE_FORMAT_MULAW :
					if(!force_open) //or
    					    psf->sf.format   = (SF_FORMAT_WAV | SF_FORMAT_ULAW) ;
					psf->read_short  = (func_short)  ulaw_read_ulaw2s ;
					psf->read_int    = (func_int)    ulaw_read_ulaw2i ;
					psf->read_double = (func_double) ulaw_read_ulaw2d ;
					return 0 ;
	
		case	WAVE_FORMAT_ALAW :
					if(!force_open) //or
					    psf->sf.format   = (SF_FORMAT_WAV | SF_FORMAT_ALAW) ;
					psf->read_short  = (func_short)  alaw_read_alaw2s ;
					psf->read_int    = (func_int)    alaw_read_alaw2i ;
					psf->read_double = (func_double) alaw_read_alaw2d ;
					return 0 ;
		
		case	WAVE_FORMAT_MS_ADPCM : 
					if(!force_open) //or
					    psf->sf.format   = (SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM) ;
					if ((error = msadpcm_reader_init (psf, &wav_fmt)))
						return error ;
					psf->read_short  = (func_short)  msadpcm_read_s ;
					psf->read_int    = (func_int)    msadpcm_read_i ;
					psf->read_double = (func_double) msadpcm_read_d ;
					psf->seek_func   = (func_seek)   msadpcm_seek ;
					return 0 ;
		case	WAVE_FORMAT_IMA_ADPCM :
					if(!force_open) //or
					    psf->sf.format   = (SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM) ;
					if ((error = wav_ima_reader_init (psf, &wav_fmt)))
						return error ;
					psf->read_short  = (func_short)  ima_read_s ;
					psf->read_int    = (func_int)    ima_read_i ;
					psf->read_double = (func_double) ima_read_d ;
					psf->seek_func   = (func_seek)   ima_seek ;
					return 0 ;
		
		case	WAVE_FORMAT_GSM610 :
					if(!force_open) //or
					    psf->sf.format   = (SF_FORMAT_WAV | SF_FORMAT_GSM610) ;
					if ((error = wav_gsm610_reader_init (psf, &wav_fmt)))
						return error ;
					psf->read_short  = (func_short)  wav_gsm610_read_s ;
					psf->read_int    = (func_int)    wav_gsm610_read_i ;
					psf->read_double = (func_double) wav_gsm610_read_d ;
					psf->seek_func   = NULL ;  /* Not seekable */
					return 0 ;
		
		case	WAVE_FORMAT_IEEE_FLOAT :
					if(!force_open) //or
					    psf->sf.format   = (SF_FORMAT_WAV | SF_FORMAT_FLOAT) ;
					if (CAN_READ_WRITE_x86_IEEE)
					{	psf->read_short  = (func_short)  pcm_read_f2s ;
						psf->read_int    = (func_int)    pcm_read_f2i ;
						psf->read_double = (func_double) pcm_read_f2d ;
						}
					else 
					{	psf->read_short  = (func_short)  wav_read_x86f2s ;
						psf->read_int    = (func_int)    wav_read_x86f2i ;
						psf->read_double = (func_double) wav_read_x86f2d ;
						} ;
					return 0 ;
		
		default :	
			{
			    //or
			    if(force_open)
				return 0;
			    else
			    // end or
				return SFE_UNIMPLEMENTED ;
			}
		} ;
	if(!force_open) //or
	    psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_PCM) ;
	
	switch (psf->bytewidth)
	{	case  1 :
				psf->read_short  = (func_short)  pcm_read_uc2s ;
				psf->read_int    = (func_int)    pcm_read_uc2i ;
				psf->read_double = (func_double) pcm_read_uc2d ;
				break ;
		case  2 :
				psf->read_short  = (func_short)  pcm_read_les2s ;
				psf->read_int    = (func_int)    pcm_read_les2i ;
				psf->read_double = (func_double) pcm_read_les2d ;
				break ;
		case  3 :
				psf->read_short  = (func_short)  pcm_read_let2s ;
				psf->read_int    = (func_int)    pcm_read_let2i ;
				psf->read_double = (func_double) pcm_read_let2d ;
				break ;
		case  4 :
				psf->read_short  = (func_short)  pcm_read_lei2s ;
				psf->read_int    = (func_int)    pcm_read_lei2i ;
				psf->read_double = (func_double) pcm_read_lei2d ;
				break ;
		default : return SFE_UNIMPLEMENTED ;
		} ;
	return 0 ;
} /* wav_open_read */
/*------------------------------------------------------------------------------
 */
int 	wav_open_write	(SF_PRIVATE *psf)
{	WAV_FMT			wav_fmt ;
	unsigned int	dword, subformat ;
	int				error ;
	
	if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_WAV)
		return	SFE_BAD_OPEN_FORMAT ;
	
	psf->endian      = SF_ENDIAN_LITTLE ;		/* All WAV files are little endian. */
	psf->sf.seekable = SF_TRUE ;
	psf->error       = 0 ;
	subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
	if (subformat == SF_FORMAT_ULAW || subformat == SF_FORMAT_ALAW)
		psf->bytewidth = 1 ;
	else
	//or
	    if(subformat == SF_FORCE_OPEN)
		psf->bytewidth = psf->sf.bytewidth;
	    else
	//end or    
		psf->bytewidth = BITWIDTH2BYTES (psf->sf.pcmbitwidth) ;
	psf->blockwidth  = psf->bytewidth * psf->sf.channels ;
	wav_fmt.min.channels    = psf->sf.channels ;
	wav_fmt.min.samplerate  = psf->sf.samplerate ;
	//or
	if(subformat == SF_FORCE_OPEN)
	    wav_fmt.min.bytespersec = psf->sf.avg_bytes_per_sec;
	else
	//end or
    	    wav_fmt.min.bytespersec = psf->sf.samplerate * psf->bytewidth * psf->sf.channels ;
	wav_fmt.min.blockalign  = psf->bytewidth * psf->sf.channels ;
	
	//or
	if(subformat == SF_FORCE_OPEN)
	{
	    switch(psf->sf.format_tag)
	    {
	    case 6: //alaw
	    case 7: //ulaw 
		wav_fmt.min.bitwidth = 8 ;
		break;
	    default:
		wav_fmt.min.bitwidth    = psf->sf.pcmbitwidth ;
	    }
	
	}
	else
	//end or
	    wav_fmt.min.bitwidth    = psf->sf.pcmbitwidth ;
	
	switch (psf->sf.format & SF_FORMAT_SUBMASK)
	{	case	SF_FORMAT_PCM : 
					wav_fmt.format = WAVE_FORMAT_PCM ;
					psf->dataoffset  = 7 * sizeof (dword) + sizeof (MIN_WAV_FMT) ;
					psf->datalength  = psf->blockwidth * psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (MIN_WAV_FMT), 0) ;
					break ;
		case	SF_FORMAT_FLOAT : 
					wav_fmt.format = WAVE_FORMAT_IEEE_FLOAT ;
					psf->dataoffset  = 9 * sizeof (dword) + sizeof (MIN_WAV_FMT) + sizeof (FACT_CHUNK) ;
					psf->datalength  = psf->blockwidth * psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (MIN_WAV_FMT), 1) ;
					break ;
		case	SF_FORMAT_ULAW : 
					wav_fmt.format = WAVE_FORMAT_MULAW ;
					wav_fmt.size20.bitwidth = 8 ;
					wav_fmt.size20.extrabytes = 0 ;
					wav_fmt.size20.dummy = 0 ;
					psf->dataoffset  = 9 * sizeof (dword) + sizeof (WAV_FMT_SIZE20) - 2 + sizeof (FACT_CHUNK) ;
					
					psf->datalength  = psf->blockwidth * psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (WAV_FMT_SIZE20), 1) ;
					break ;
					
		case	SF_FORMAT_ALAW :
					wav_fmt.format = WAVE_FORMAT_ALAW ;
					wav_fmt.size20.bitwidth = 8 ;
					wav_fmt.size20.extrabytes = 0 ;
					wav_fmt.size20.dummy = 0 ;
					psf->dataoffset  = 9 * sizeof (dword) + sizeof (WAV_FMT_SIZE20) + sizeof (FACT_CHUNK) ;
					
					psf->datalength  = psf->blockwidth * psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (WAV_FMT_SIZE20), 1) ;
					break ;
		case	SF_FORMAT_IMA_ADPCM : 
					wav_fmt.format = WAVE_FORMAT_IMA_ADPCM ;
					if ((error = wav_ima_writer_init (psf, &wav_fmt)))
						return error ;
					psf->dataoffset  = 9 * sizeof (dword) + sizeof (IMA_ADPCM_WAV_FMT) + sizeof (FACT_CHUNK) ;
					if (psf->sf.samples % wav_fmt.ima.samplesperblock)
						psf->datalength  = ((psf->sf.samples / wav_fmt.ima.samplesperblock) + 1) * wav_fmt.ima.samplesperblock ;
					else
						psf->datalength  = psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (IMA_ADPCM_WAV_FMT), 1) ;
					break ;
		case	SF_FORMAT_MS_ADPCM : 
					wav_fmt.format = WAVE_FORMAT_MS_ADPCM ;
					msadpcm_writer_init (psf, &wav_fmt) ;
					psf->dataoffset  = 9 * sizeof (dword) + sizeof (MS_ADPCM_WAV_FMT) + sizeof (FACT_CHUNK) ;
					if (psf->sf.samples % wav_fmt.msadpcm.samplesperblock)
						psf->datalength  = ((psf->sf.samples / wav_fmt.msadpcm.samplesperblock) + 1) * wav_fmt.msadpcm.samplesperblock ;
					else
						psf->datalength  = psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (MS_ADPCM_WAV_FMT), 1) ;
					break ;
		case	SF_FORMAT_GSM610 : 
					wav_fmt.format = WAVE_FORMAT_GSM610 ;
					wav_gsm610_writer_init (psf, &wav_fmt) ;
					psf->dataoffset  = 9 * sizeof (dword) + sizeof (GSM610_WAV_FMT) + sizeof (FACT_CHUNK) ;
					if (psf->sf.samples % wav_fmt.gsm610.samplesperblock)
						psf->datalength  = ((psf->sf.samples / wav_fmt.gsm610.samplesperblock) + 1) * wav_fmt.gsm610.samplesperblock ;
					else
						psf->datalength  = psf->sf.samples ;
					psf->filelength  = psf->datalength + psf->dataoffset ;
					write_header (psf, &wav_fmt, sizeof (GSM610_WAV_FMT), 1) ;
					break ;
		default :
		{ 	
		    //or
		    if(subformat==SF_FORCE_OPEN)
		    {
			wav_fmt.format = psf->sf.format_tag;
			wav_fmt.wavfmtex.extrabytes = 0 ;
			psf->dataoffset  = 9 * sizeof (dword) + sizeof (WAV_FMT_EX) + sizeof (FACT_CHUNK) ;
			psf->datalength  = psf->blockwidth * psf->sf.samples ;
			psf->filelength  = psf->datalength + psf->dataoffset ;
			write_header (psf, &wav_fmt, sizeof (WAV_FMT_EX), 1) ;
		    }
		    else
		    //end or
		    return SFE_UNIMPLEMENTED ;
		}
		} ;
	dword = data_MARKER ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	dword = H2LE_INT (psf->datalength) ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	
	psf->close = (func_close) wav_close ;
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_FLOAT)
	{	psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_FLOAT) ;
		if (CAN_READ_WRITE_x86_IEEE)
		{	psf->write_short  = (func_short)  pcm_write_s2f ;
			psf->write_int    = (func_int)    pcm_write_i2f ;
			psf->write_double = (func_double) pcm_write_d2f ;
			}
		else 
		{	psf->write_short  = (func_short)  wav_write_s2x86f ;
			psf->write_int    = (func_int)    wav_write_i2x86f ;
			psf->write_double = (func_double) wav_write_d2x86f ;
			} ;
		return	 0 ;
		} ;
	
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_IMA_ADPCM)
	{	psf->sf.format    = (SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM) ;
		psf->write_short  = (func_short)  ima_write_s ;
		psf->write_int    = (func_int)    ima_write_i ;
		psf->write_double = (func_double) ima_write_d ;
		psf->seek_func    = (func_seek)   ima_seek ;
		psf->close        = (func_close)  wav_ima_close ;
		return 0 ;
		} ;
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_MS_ADPCM)
	{	psf->sf.format    = (SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM) ;
		psf->write_short  = (func_short)  msadpcm_write_s ;
		psf->write_int    = (func_int)    msadpcm_write_i ;
		psf->write_double = (func_double) msadpcm_write_d ;
		psf->seek_func    = (func_seek)   msadpcm_seek ;
		psf->close        = (func_close)  msadpcm_close ;
		return 0 ;
		} ;
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_GSM610)
	{	psf->sf.format    = (SF_FORMAT_WAV | SF_FORMAT_GSM610) ;
		psf->write_short  = (func_short)  wav_gsm610_write_s ;
		psf->write_int    = (func_int)    wav_gsm610_write_i ;
		psf->write_double = (func_double) wav_gsm610_write_d ;
		psf->seek_func    = NULL ; /* Not seekable */
		psf->close        = (func_close)  wav_gsm610_close ;
		return 0 ;
		} ;
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_ULAW)
	{	psf->sf.format    = (SF_FORMAT_WAV | SF_FORMAT_ULAW) ;
		psf->write_short  = (func_short)  ulaw_write_s2ulaw ;
		psf->write_int    = (func_int)    ulaw_write_i2ulaw ;
		psf->write_double = (func_double) ulaw_write_d2ulaw ;
		return 0 ;
		} ;
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_ALAW)
	{	psf->sf.format    = (SF_FORMAT_WAV | SF_FORMAT_ALAW) ;
		psf->write_short  = (func_short)  alaw_write_s2alaw ;
		psf->write_int    = (func_int)    alaw_write_i2alaw ;
		psf->write_double = (func_double) alaw_write_d2alaw ;
		return 0 ;
		} ;
	if ((psf->sf.format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM) //
	//or
	//	return SFE_UNIMPLEMENTED ;
	{
	switch (psf->bytewidth)
	{	case  1 :
				psf->write_short  = (func_short)  pcm_write_s2uc ;
				psf->write_int    = (func_int)    pcm_write_i2uc ;
				psf->write_double = (func_double) pcm_write_d2uc ;
				break ;
		case  2 :
				psf->write_short  = (func_short)  pcm_write_s2les ;
				psf->write_int    = (func_int)    pcm_write_i2les ;
				psf->write_double = (func_double) pcm_write_d2les ;
				break ;
		case  3 :
				psf->write_short  = (func_short)  pcm_write_s2let ;
				psf->write_int    = (func_int)    pcm_write_i2let ;
				psf->write_double = (func_double) pcm_write_d2let ;
				break ;
		case  4 :
				psf->write_short  = (func_short)  pcm_write_s2lei ;
				psf->write_int    = (func_int)    pcm_write_i2lei ;
				psf->write_double = (func_double) pcm_write_d2lei ;
				break ;
		default : return SFE_UNIMPLEMENTED ;
		} ;
	}
	//or
	else
	{
	
	}
	//end or
	return 0 ;
} /* wav_open_write */
/*------------------------------------------------------------------------------
 */
int	wav_close	(SF_PRIVATE  *psf)
{	unsigned int		dword ;
	if (psf->mode == SF_MODE_WRITE)
	{	/*  Now we know for certain the length of the file we can
		 *  re-write correct values for the RIFF and data chunks.
		 */
		fseek (psf->file, 0, SEEK_END) ;
		psf->filelength = ftell (psf->file) ;
		/* Fix RIFF size. */
		dword = H2LE_INT (psf->filelength - 2 * sizeof (dword)) ;
		fseek (psf->file, sizeof (dword), SEEK_SET) ;
		fwrite (&dword, sizeof (dword), 1, psf->file) ;
		
		psf->datalength = psf->filelength - psf->dataoffset ;
		psf->sf.samples = psf->datalength / (psf->sf.channels * psf->bytewidth) ;
		fseek (psf->file, (int) (psf->dataoffset - sizeof (dword)), SEEK_SET) ;
		dword = H2LE_INT (psf->datalength) ;
		fwrite (&dword, sizeof (dword), 1, psf->file) ;
		} ;
	if (psf->fdata)
		free (psf->fdata) ;
	psf->fdata = NULL ;
	return 0 ;
} /* wav_close */
/*=========================================================================
 * Private functions.
 */
static
int read_fmt_chunk (SF_PRIVATE *psf, WAV_FMT *wav_fmt)
{	unsigned int	dword, bytesread, k, structsize, bytespersec = 0  ;
	
	memset (wav_fmt, 0, sizeof (WAV_FMT)) ;
	bytesread = 0 ;
	fread (&dword, sizeof (dword), 1, psf->file) ;
	structsize = LE2H_INT (dword) ;
	
	psf_sprintf (psf, "fmt  : %dn", structsize) ;
	
	if (structsize < 16)
		return SFE_WAV_FMT_SHORT ;
	if (structsize > sizeof (WAV_FMT))
		return SFE_WAV_FMT_TOO_BIG ;
					
	fread (wav_fmt, structsize, 1, psf->file) ;
	bytesread += structsize ;
	if (CPU_IS_BIG_ENDIAN)
		le2h_wav_fmt (wav_fmt) ;
	psf_sprintf (psf, "  Format        : 0x%X => %sn", wav_fmt->format, wav_format_str (wav_fmt->format)) ;
	psf_sprintf (psf, "  Channels      : %dn", wav_fmt->min.channels) ;
	psf_sprintf (psf, "  Sample Rate   : %dn", wav_fmt->min.samplerate) ;
	psf_sprintf (psf, "  Block Align   : %dn", wav_fmt->min.blockalign) ;
	psf_sprintf (psf, "  Bit Width     : %dn", wav_fmt->min.bitwidth) ;
	
	psf->sf.samplerate		= wav_fmt->min.samplerate ;
	psf->sf.samples 		= 0 ;					/* Correct this when reading data chunk. */
	psf->sf.channels		= wav_fmt->min.channels ;
	
	switch (wav_fmt->format)
	{	case WAVE_FORMAT_PCM :
		case WAVE_FORMAT_IEEE_FLOAT :
				bytespersec = wav_fmt->min.samplerate * wav_fmt->min.blockalign ;
				if (wav_fmt->min.bytespersec != bytespersec)
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d)n", wav_fmt->min.bytespersec, bytespersec) ;
				else
					psf_sprintf (psf, "  Bytes/sec     : %dn", wav_fmt->min.bytespersec) ;
		
				psf->sf.pcmbitwidth	= wav_fmt->min.bitwidth ;
				psf->bytewidth      = BITWIDTH2BYTES (wav_fmt->min.bitwidth) ;
				break ;
		case WAVE_FORMAT_ALAW :
		case WAVE_FORMAT_MULAW :
				if (wav_fmt->min.bytespersec / wav_fmt->min.blockalign != wav_fmt->min.samplerate)
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d)n", wav_fmt->min.bytespersec, wav_fmt->min.samplerate * wav_fmt->min.blockalign) ;
				else
					psf_sprintf (psf, "  Bytes/sec     : %dn", wav_fmt->min.bytespersec) ;
				psf->sf.pcmbitwidth	= 16 ;
				psf->bytewidth      = 1 ;
				if (structsize >= 18)
					psf_sprintf (psf, "  Extra Bytes   : %dn", wav_fmt->size20.extrabytes) ;
				break ;
		case WAVE_FORMAT_MS_ADPCM :
				if (wav_fmt->msadpcm.bitwidth != 4)
					return SFE_WAV_ADPCM_NOT4BIT ;
				if (wav_fmt->msadpcm.channels < 1 || wav_fmt->msadpcm.channels > 2)
					return SFE_WAV_ADPCM_CHANNELS ;
				bytespersec = (wav_fmt->msadpcm.samplerate * wav_fmt->msadpcm.blockalign) / wav_fmt->msadpcm.samplesperblock ;
				if (wav_fmt->min.bytespersec == bytespersec)
					psf_sprintf (psf, "  Bytes/sec     : %dn", wav_fmt->min.bytespersec) ;
				else if (wav_fmt->min.bytespersec == (wav_fmt->msadpcm.samplerate / wav_fmt->msadpcm.samplesperblock) * wav_fmt->msadpcm.blockalign) 
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d (MS BUG!))n", wav_fmt->min.bytespersec, bytespersec) ;
				else
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d)n", wav_fmt->min.bytespersec, bytespersec) ;
				psf->sf.pcmbitwidth = 16 ;
				psf->bytewidth      = 2 ;
				psf_sprintf (psf, "  Extra Bytes   : %dn", wav_fmt->msadpcm.extrabytes) ;
				psf_sprintf (psf, "  Samples/Block : %dn", wav_fmt->msadpcm.samplesperblock) ;
				if (wav_fmt->msadpcm.numcoeffs > sizeof (MS_ADPCM_WAV_FMT) / sizeof (int))
				{	psf_sprintf (psf, "  No. of Coeffs : %d ****n", wav_fmt->msadpcm.numcoeffs) ;
					wav_fmt->msadpcm.numcoeffs = sizeof (MS_ADPCM_WAV_FMT) / sizeof (int) ;
					}
				else
					psf_sprintf (psf, "  No. of Coeffs : %dn", wav_fmt->msadpcm.numcoeffs) ;
				psf_sprintf (psf, "    Coeff 1 : ") ;
				for (k = 0 ; k < wav_fmt->msadpcm.numcoeffs ; k++)
					psf_sprintf (psf, "%d ", wav_fmt->msadpcm.coeffs [k].coeff1) ;
				psf_sprintf (psf, "n    Coeff 2 : ") ;
				for (k = 0 ; k < wav_fmt->msadpcm.numcoeffs ; k++)
					psf_sprintf (psf, "%d ", wav_fmt->msadpcm.coeffs [k].coeff2) ;
				psf_sprintf (psf, "n") ;
				break ;
				
		case WAVE_FORMAT_IMA_ADPCM :
				if (wav_fmt->ima.bitwidth != 4)
					return SFE_WAV_ADPCM_NOT4BIT ;
				if (wav_fmt->ima.channels < 1 || wav_fmt->ima.channels > 2)
					return SFE_WAV_ADPCM_CHANNELS ;
				bytespersec = (wav_fmt->ima.samplerate * wav_fmt->ima.blockalign) / wav_fmt->ima.samplesperblock ;
				if (wav_fmt->ima.bytespersec != bytespersec)
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d)n", wav_fmt->ima.bytespersec, bytespersec) ;
				else
					psf_sprintf (psf, "  Bytes/sec     : %dn", wav_fmt->ima.bytespersec) ;
				psf->sf.pcmbitwidth = 16 ;
				psf->bytewidth      = 2 ;
				psf_sprintf (psf, "  Extra Bytes   : %dn", wav_fmt->ima.extrabytes) ;
				psf_sprintf (psf, "  Samples/Block : %dn", wav_fmt->ima.samplesperblock) ;
				break ;
				
		case WAVE_FORMAT_EXTENSIBLE :
				if (wav_fmt->ext.bytespersec / wav_fmt->ext.blockalign != wav_fmt->ext.samplerate)
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d)n", wav_fmt->ext.bytespersec, wav_fmt->ext.samplerate * wav_fmt->ext.blockalign) ;
				else
					psf_sprintf (psf, "  Bytes/sec     : %dn", wav_fmt->ext.bytespersec) ;
				psf_sprintf (psf, "  Valid Bits    : %dn", wav_fmt->ext.validbits) ;
				psf_sprintf (psf, "  Channel Mask  : 0x%Xn", wav_fmt->ext.channelmask) ;
				psf_sprintf (psf, "  Subformatn") ;
				psf_sprintf (psf, "    esf_field1 : 0x%Xn", wav_fmt->ext.esf.esf_field1) ;
				psf_sprintf (psf, "    esf_field2 : 0x%Xn", wav_fmt->ext.esf.esf_field2) ;
				psf_sprintf (psf, "    esf_field3 : 0x%Xn", wav_fmt->ext.esf.esf_field3) ;
				psf_sprintf (psf, "    esf_field4 : ") ;
				for (k = 0 ; k < 8 ; k++)
					psf_sprintf (psf, "0x%X ", wav_fmt->ext.esf.esf_field4 [k] & 0xFF) ;
				psf_sprintf (psf, "n") ;
				psf->sf.pcmbitwidth = wav_fmt->ext.bitwidth ;
				psf->bytewidth      = BITWIDTH2BYTES (wav_fmt->ext.bitwidth) ;
				break ;
		case WAVE_FORMAT_GSM610 :
				if (wav_fmt->gsm610.channels != 1 || wav_fmt->gsm610.blockalign != 65)
					return SFE_WAV_GSM610_FORMAT ;
				if (wav_fmt->gsm610.samplesperblock != 320)
					return SFE_WAV_GSM610_FORMAT ;
				bytespersec = (wav_fmt->gsm610.samplerate * wav_fmt->gsm610.blockalign) / wav_fmt->gsm610.samplesperblock ;
				if (wav_fmt->gsm610.bytespersec != bytespersec)
					psf_sprintf (psf, "  Bytes/sec     : %d (should be %d)n", wav_fmt->gsm610.bytespersec, bytespersec) ;
				else
					psf_sprintf (psf, "  Bytes/sec     : %dn", wav_fmt->gsm610.bytespersec) ;
				psf->sf.pcmbitwidth = 16 ;
				psf->bytewidth      = 2 ;
				psf_sprintf (psf, "  Extra Bytes   : %dn", wav_fmt->gsm610.extrabytes) ;
				psf_sprintf (psf, "  Samples/Block : %dn", wav_fmt->gsm610.samplesperblock) ;
				break ;
		default : 
				//or
				psf->sf.pcmbitwidth	= wav_fmt->min.bitwidth ;
				psf->bytewidth      = wav_fmt->min.blockalign/wav_fmt->min.channels ;
				//end or
		
		break ;
		} ;
	
	psf->blockwidth = wav_fmt->min.channels * psf->bytewidth ;
	return 0 ;
} /* read_fmt_chunk */
static
int write_header (SF_PRIVATE *psf, WAV_FMT *wav_fmt, unsigned int size, int do_fact)
{	FACT_CHUNK		fact_chunk ;
	unsigned int dword, RIFFsize ;
	RIFFsize   = psf->filelength - 2 * sizeof (dword) ;
	dword = RIFF_MARKER ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	dword = H2LE_INT (RIFFsize) ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	
	dword = WAVE_MARKER ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	dword = fmt_MARKER ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	
	dword = H2LE_INT (size) ;
	fwrite (&dword, sizeof (dword), 1, psf->file) ;
	if (CPU_IS_BIG_ENDIAN)
		h2le_wav_fmt (wav_fmt) ;
	fwrite (wav_fmt, size, 1, psf->file) ;
	
	if (do_fact)
	{	dword = fact_MARKER ;
		fwrite (&dword, sizeof (dword), 1, psf->file) ;
		dword = H2LE_INT (sizeof (FACT_CHUNK)) ;
		fwrite (&dword, sizeof (dword), 1, psf->file) ;
		fact_chunk.samples = H2LE_INT (psf->sf.samples) ;
		fwrite (&fact_chunk, sizeof (fact_chunk), 1, psf->file) ;
		} ;
	return 0 ;
} /* write_header */
static 
void	le2h_wav_fmt (WAV_FMT *fmt)
{	int		k ;
	fmt->min.format      = ENDSWAP_SHORT (fmt->min.format) ;
	fmt->min.channels    = ENDSWAP_SHORT (fmt->min.channels) ;
	fmt->min.samplerate  = ENDSWAP_INT   (fmt->min.samplerate) ;
	fmt->min.bytespersec = ENDSWAP_INT   (fmt->min.bytespersec) ;
	fmt->min.blockalign  = ENDSWAP_SHORT (fmt->min.blockalign) ;
	fmt->min.bitwidth    = ENDSWAP_SHORT (fmt->min.bitwidth) ;
	switch (fmt->format)
	{	case WAVE_FORMAT_MS_ADPCM :	
				fmt->msadpcm.extrabytes      = ENDSWAP_SHORT (fmt->msadpcm.extrabytes) ;
				fmt->msadpcm.samplesperblock = ENDSWAP_SHORT (fmt->msadpcm.samplesperblock) ;
				fmt->msadpcm.numcoeffs       = ENDSWAP_SHORT (fmt->msadpcm.numcoeffs) ;
				for (k = 0 ; k < fmt->msadpcm.numcoeffs  ; k++)
				{	fmt->msadpcm.coeffs [k].coeff1 = ENDSWAP_SHORT (fmt->msadpcm.coeffs [k].coeff1) ;
					fmt->msadpcm.coeffs [k].coeff2 = ENDSWAP_SHORT (fmt->msadpcm.coeffs [k].coeff2) ;
					} ;
				break ;
				
		case WAVE_FORMAT_IMA_ADPCM :	
				fmt->ima.extrabytes      = ENDSWAP_SHORT (fmt->ima.extrabytes) ;
				fmt->ima.samplesperblock = ENDSWAP_SHORT (fmt->ima.samplesperblock) ;
				break ;
				
		case WAVE_FORMAT_ALAW :	
		case WAVE_FORMAT_MULAW :	
				fmt->size20.extrabytes = ENDSWAP_SHORT (fmt->size20.extrabytes) ;
				fmt->size20.dummy      = ENDSWAP_SHORT (fmt->size20.dummy) ;
				break ;
				
		case	WAVE_FORMAT_GSM610 :
				fmt->gsm610.extrabytes      = ENDSWAP_SHORT (fmt->gsm610.extrabytes) ;
				fmt->gsm610.samplesperblock = ENDSWAP_SHORT (fmt->gsm610.samplesperblock) ;
				break ;
				
		default : break ;
		} ;
} /* le2h_wav_fmt */
static 
void	h2le_wav_fmt (WAV_FMT *fmt)
{	int		k ;
	switch (fmt->format)
	{	case WAVE_FORMAT_MS_ADPCM :	
				for (k = 0 ; k < fmt->msadpcm.numcoeffs  ; k++)
				{	fmt->msadpcm.coeffs [k].coeff1 = ENDSWAP_SHORT (fmt->msadpcm.coeffs [k].coeff1) ;
					fmt->msadpcm.coeffs [k].coeff2 = ENDSWAP_SHORT (fmt->msadpcm.coeffs [k].coeff2) ;
					} ;
				fmt->msadpcm.numcoeffs       = ENDSWAP_SHORT (fmt->msadpcm.numcoeffs) ;
				fmt->msadpcm.extrabytes      = ENDSWAP_SHORT (fmt->msadpcm.extrabytes) ;
				fmt->msadpcm.samplesperblock = ENDSWAP_SHORT (fmt->msadpcm.samplesperblock) ;
				break ;
				
		case WAVE_FORMAT_IMA_ADPCM :	
				fmt->ima.extrabytes      = ENDSWAP_SHORT (fmt->ima.extrabytes) ;
				fmt->ima.samplesperblock = ENDSWAP_SHORT (fmt->ima.samplesperblock) ;
				break ;
				
		case WAVE_FORMAT_ALAW :	
		case WAVE_FORMAT_MULAW :	
				fmt->size20.extrabytes = ENDSWAP_SHORT (fmt->size20.extrabytes) ;
				fmt->size20.dummy      = ENDSWAP_SHORT (fmt->size20.dummy) ;
				break ;
				
		case	WAVE_FORMAT_GSM610 :
				fmt->gsm610.extrabytes      = ENDSWAP_SHORT (fmt->gsm610.extrabytes) ;
				fmt->gsm610.samplesperblock = ENDSWAP_SHORT (fmt->gsm610.samplesperblock) ;
				break ;
				
		default : break ;
		} ;
	fmt->min.format      = ENDSWAP_SHORT (fmt->min.format) ;
	fmt->min.channels    = ENDSWAP_SHORT (fmt->min.channels) ;
	fmt->min.samplerate  = ENDSWAP_INT   (fmt->min.samplerate) ;
	fmt->min.bytespersec = ENDSWAP_INT   (fmt->min.bytespersec) ;
	fmt->min.blockalign  = ENDSWAP_SHORT (fmt->min.blockalign) ;
	fmt->min.bitwidth    = ENDSWAP_SHORT (fmt->min.bitwidth) ;
} /* h2le_wav_fmt */
static
const char* wav_format_str (int k)
{	switch (k)
	{	case WAVE_FORMAT_UNKNOWN :
			return "WAVE_FORMAT_UNKNOWN" ;
		case WAVE_FORMAT_PCM          :
			return "WAVE_FORMAT_PCM         " ;
		case WAVE_FORMAT_MS_ADPCM :
			return "WAVE_FORMAT_MS_ADPCM" ;
		case WAVE_FORMAT_IEEE_FLOAT :
			return "WAVE_FORMAT_IEEE_FLOAT" ;
		case WAVE_FORMAT_IBM_CVSD :
			return "WAVE_FORMAT_IBM_CVSD" ;
		case WAVE_FORMAT_ALAW :
			return "WAVE_FORMAT_ALAW" ;
		case WAVE_FORMAT_MULAW :
			return "WAVE_FORMAT_MULAW" ;
		case WAVE_FORMAT_OKI_ADPCM :
			return "WAVE_FORMAT_OKI_ADPCM" ;
		case WAVE_FORMAT_IMA_ADPCM :
			return "WAVE_FORMAT_IMA_ADPCM" ;
		case WAVE_FORMAT_MEDIASPACE_ADPCM :
			return "WAVE_FORMAT_MEDIASPACE_ADPCM" ;
		case WAVE_FORMAT_SIERRA_ADPCM :
			return "WAVE_FORMAT_SIERRA_ADPCM" ;
		case WAVE_FORMAT_G723_ADPCM :
			return "WAVE_FORMAT_G723_ADPCM" ;
		case WAVE_FORMAT_DIGISTD :
			return "WAVE_FORMAT_DIGISTD" ;
		case WAVE_FORMAT_DIGIFIX :
			return "WAVE_FORMAT_DIGIFIX" ;
		case WAVE_FORMAT_DIALOGIC_OKI_ADPCM :
			return "WAVE_FORMAT_DIALOGIC_OKI_ADPCM" ;
		case WAVE_FORMAT_MEDIAVISION_ADPCM :
			return "WAVE_FORMAT_MEDIAVISION_ADPCM" ;
		case WAVE_FORMAT_YAMAHA_ADPCM :
			return "WAVE_FORMAT_YAMAHA_ADPCM" ;
		case WAVE_FORMAT_SONARC :
			return "WAVE_FORMAT_SONARC" ;
		case WAVE_FORMAT_DSPGROUP_TRUESPEECH  :
			return "WAVE_FORMAT_DSPGROUP_TRUESPEECH " ;
		case WAVE_FORMAT_ECHOSC1 :
			return "WAVE_FORMAT_ECHOSC1" ;
		case WAVE_FORMAT_AUDIOFILE_AF18   :
			return "WAVE_FORMAT_AUDIOFILE_AF18  " ;
		case WAVE_FORMAT_APTX :
			return "WAVE_FORMAT_APTX" ;
		case WAVE_FORMAT_AUDIOFILE_AF10   :
			return "WAVE_FORMAT_AUDIOFILE_AF10  " ;
		case WAVE_FORMAT_DOLBY_AC2 :
			return "WAVE_FORMAT_DOLBY_AC2" ;
		case WAVE_FORMAT_GSM610 :
			return "WAVE_FORMAT_GSM610" ;
		case WAVE_FORMAT_MSNAUDIO :
			return "WAVE_FORMAT_MSNAUDIO" ;
		case WAVE_FORMAT_ANTEX_ADPCME :
			return "WAVE_FORMAT_ANTEX_ADPCME" ;
		case WAVE_FORMAT_CONTROL_RES_VQLPC :
			return "WAVE_FORMAT_CONTROL_RES_VQLPC" ;
		case WAVE_FORMAT_DIGIREAL :
			return "WAVE_FORMAT_DIGIREAL" ;
		case WAVE_FORMAT_DIGIADPCM :
			return "WAVE_FORMAT_DIGIADPCM" ;
		case WAVE_FORMAT_CONTROL_RES_CR10 :
			return "WAVE_FORMAT_CONTROL_RES_CR10" ;
		case WAVE_FORMAT_NMS_VBXADPCM :
			return "WAVE_FORMAT_NMS_VBXADPCM" ;
		case WAVE_FORMAT_ROCKWELL_ADPCM :
			return "WAVE_FORMAT_ROCKWELL_ADPCM" ;
		case WAVE_FORMAT_ROCKWELL_DIGITALK :
			return "WAVE_FORMAT_ROCKWELL_DIGITALK" ;
		case WAVE_FORMAT_G721_ADPCM :
			return "WAVE_FORMAT_G721_ADPCM" ;
		case WAVE_FORMAT_MPEG :
			return "WAVE_FORMAT_MPEG" ;
		case WAVE_FORMAT_MPEGLAYER3 :
			return "WAVE_FORMAT_MPEGLAYER3" ;
		case IBM_FORMAT_MULAW :
			return "IBM_FORMAT_MULAW" ;
		case IBM_FORMAT_ALAW :
			return "IBM_FORMAT_ALAW" ;
		case IBM_FORMAT_ADPCM :
			return "IBM_FORMAT_ADPCM" ;
		case WAVE_FORMAT_CREATIVE_ADPCM :
			return "WAVE_FORMAT_CREATIVE_ADPCM" ;
		case WAVE_FORMAT_FM_TOWNS_SND :
			return "WAVE_FORMAT_FM_TOWNS_SND" ;
		case WAVE_FORMAT_OLIGSM :
			return "WAVE_FORMAT_OLIGSM" ;
		case WAVE_FORMAT_OLIADPCM :
			return "WAVE_FORMAT_OLIADPCM" ;
		case WAVE_FORMAT_OLICELP :
			return "WAVE_FORMAT_OLICELP" ;
		case WAVE_FORMAT_OLISBC :
			return "WAVE_FORMAT_OLISBC" ;
		case WAVE_FORMAT_OLIOPR :
			return "WAVE_FORMAT_OLIOPR" ;
		case WAVE_FORMAT_EXTENSIBLE :
			return "WAVE_FORMAT_EXTENSIBLE" ;
		break ;
		} ;
	return "Unknown format" ;
} /* wav_format_str */

						