/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_wave.c
 *
 * Contents and purpose:
 * This module contains .WAV file functions for the EAS synthesizer
 * test harness.  
 *			
 * Copyright Sonic Network Inc. 2005

 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *----------------------------------------------------------------------------
 * Revision Control:
 *   $Revision: 658 $
 *   $Date: 2007-04-24 13:35:49 -0700 (Tue, 24 Apr 2007) $
 *----------------------------------------------------------------------------
*/

/* lint complaints about most C library headers, so we use our own during lint step */
#ifdef _lint
#include "lint_stdlib.h"
#else
#include <stdio.h>
#include <stdlib.h>
#endif

#include "eas_wave.h"

/* .WAV file format tags */
const EAS_U32 riffTag = 0x46464952;
const EAS_U32 waveTag = 0x45564157;
const EAS_U32 fmtTag = 0x20746d66;
const EAS_U32 dataTag = 0x61746164;

#ifdef _BIG_ENDIAN
/*----------------------------------------------------------------------------
 * FlipDWord()
 *----------------------------------------------------------------------------
 * Purpose: Endian flip a DWORD for big-endian processors
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static void FlipDWord (EAS_U32 *pValue)
{
	EAS_U8 *p;
	EAS_U32 temp;

	p = (EAS_U8*) pValue;
	temp = (((((p[3] << 8) | p[2]) << 8) | p[1]) << 8) | p[0];
	*pValue = temp;
}

/*----------------------------------------------------------------------------
 * FlipWord()
 *----------------------------------------------------------------------------
 * Purpose: Endian flip a WORD for big-endian processors
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static void FlipWord (EAS_U16 *pValue)
{
	EAS_U8 *p;
	EAS_U16 temp;

	p = (EAS_U8*) pValue;
	temp = (p[1] << 8) | p[0];
	*pValue = temp;
}

/*----------------------------------------------------------------------------
 * FlipWaveHeader()
 *----------------------------------------------------------------------------
 * Purpose: Endian flip the wave header for big-endian processors
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static void FlipWaveHeader (WAVE_HEADER *p)
{

	FlipDWord(&p->nRiffTag);
	FlipDWord(&p->nRiffSize);
	FlipDWord(&p->nWaveTag);
	FlipDWord(&p->nFmtTag);
	FlipDWord(&p->nFmtSize);
	FlipDWord(&p->nDataTag);
	FlipDWord(&p->nDataSize);
	FlipWord(&p->fc.wFormatTag);
	FlipWord(&p->fc.nChannels);
	FlipDWord(&p->fc.nSamplesPerSec);
	FlipDWord(&p->fc.nAvgBytesPerSec);
	FlipWord(&p->fc.nBlockAlign);
	FlipWord(&p->fc.wBitsPerSample);
	
}
#endif

/*----------------------------------------------------------------------------
 * WaveFileCreate()
 *----------------------------------------------------------------------------
 * Purpose: Opens a wave file for writing and writes the header
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/

WAVE_FILE *WaveFileCreate (const char *filename, EAS_I32 nChannels, EAS_I32 nSamplesPerSec, EAS_I32 wBitsPerSample)
{
	WAVE_FILE *wFile;

	/* allocate memory */
	wFile = malloc(sizeof(WAVE_FILE));
	if (!wFile)
		return NULL;
	wFile->write = EAS_TRUE;

	/* create the file */
	wFile->file = fopen(filename,"wb");
	if (!wFile->file)
	{
		free(wFile);
		return NULL;
	}

	/* initialize PCM format .WAV file header */
	wFile->wh.nRiffTag = riffTag;
	wFile->wh.nRiffSize = sizeof(WAVE_HEADER) - 8;
	wFile->wh.nWaveTag = waveTag;
	wFile->wh.nFmtTag = fmtTag;
	wFile->wh.nFmtSize = sizeof(FMT_CHUNK);

	/* initalize 'fmt' chunk */
	wFile->wh.fc.wFormatTag = 1;
	wFile->wh.fc.nChannels = (EAS_U16) nChannels;
	wFile->wh.fc.nSamplesPerSec = (EAS_U32) nSamplesPerSec;
	wFile->wh.fc.wBitsPerSample = (EAS_U16) wBitsPerSample;
	wFile->wh.fc.nBlockAlign = (EAS_U16) (nChannels * (EAS_U16) (wBitsPerSample / 8));
	wFile->wh.fc.nAvgBytesPerSec = wFile->wh.fc.nBlockAlign * (EAS_U32) nSamplesPerSec;

	/* initialize 'data' chunk */
	wFile->wh.nDataTag = dataTag;
	wFile->wh.nDataSize = 0;

#ifdef _BIG_ENDIAN
	FlipWaveHeader(&wFile->wh);
#endif

	/* write the header */
	if (fwrite(&wFile->wh, sizeof(WAVE_HEADER), 1, wFile->file) != 1)
	{
		fclose(wFile->file);
		free(wFile);
		return NULL;
	}

#ifdef _BIG_ENDIAN
	FlipWaveHeader(&wFile->wh);
#endif

	/* return the file handle */
	return wFile;
} /* end WaveFileCreate */

/*----------------------------------------------------------------------------
 * WaveFileWrite()
 *----------------------------------------------------------------------------
 * Purpose: Writes data to the wave file
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
EAS_I32 WaveFileWrite (WAVE_FILE *wFile, void *buffer, EAS_I32 n)
{
	EAS_I32 count;

	/* make sure we have an open file */
	if (wFile == NULL)
	{
		return 0;
	}

#ifdef _BIG_ENDIAN
	{
		EAS_I32 i;
		EAS_U16 *p;
		p = buffer;
		i = n >> 1;
		while (i--)
			FlipWord(p++);
	}
#endif	
	
	/* write the data */
	count = (EAS_I32) fwrite(buffer, 1, (size_t) n, wFile->file);

	/* add the number of bytes written */
	wFile->wh.nRiffSize += (EAS_U32) count;
	wFile->wh.nDataSize += (EAS_U32) count;

	/* return the count of bytes written */
	return count;
} /* end WriteWaveHeader */

/*----------------------------------------------------------------------------
 * WaveFileClose()
 *----------------------------------------------------------------------------
 * Purpose: Opens a wave file for writing and writes the header
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/

EAS_BOOL WaveFileClose (WAVE_FILE *wFile)
{
	EAS_I32 count = 1;

	/* return to beginning of file and write the header */
	if (wFile->write)
	{
		if (fseek(wFile->file, 0L, SEEK_SET) == 0)
		{
			
#ifdef _BIG_ENDIAN
			FlipWaveHeader(&wFile->wh);
#endif
			count = (EAS_I32) fwrite(&wFile->wh, sizeof(WAVE_HEADER), 1, wFile->file);
#ifdef _BIG_ENDIAN
			FlipWaveHeader(&wFile->wh);
#endif
		}
	}
	
	/* close the file */
	if (fclose(wFile->file) != 0)
		count = 0;

	/* free the memory */
	free(wFile);

	/* return the file handle */
	return (count == 1 ? EAS_TRUE : EAS_FALSE);
} /* end WaveFileClose */

#ifdef _WAVE_FILE_READ
#ifdef _BIG_ENDIAN
#error "WaveFileOpen not currently supported on big-endian processors"
#endif
/*----------------------------------------------------------------------------
 * WaveFileOpen()
 *----------------------------------------------------------------------------
 * Purpose: Opens a wave file for reading and reads the header
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/

WAVE_FILE *WaveFileOpen (const char *filename)
{
	WAVE_FILE *wFile;
	struct
	{
		EAS_U32 tag;
		EAS_U32 size;
	} chunk;
	EAS_U32 tag;
	EAS_I32 startChunkPos;
	EAS_INT state;
	EAS_BOOL done;

	/* allocate memory */
	wFile = malloc(sizeof(WAVE_FILE));
	if (!wFile)
		return NULL;

	/* open the file */
	wFile->write = EAS_FALSE;
	wFile->file = fopen(filename,"rb");
	if (!wFile->file)
	{
		free(wFile);
		return NULL;
	}

	/* make lint happy */
	chunk.tag = chunk.size = 0;
	startChunkPos = 0;

	/* read the RIFF tag and file size */
	state = 0;
	done = EAS_FALSE;
	while (!done)
	{

		switch(state)
		{
			/* read the RIFF tag */
			case 0:
				if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1)
					done = EAS_TRUE;
				else
				{
					if (chunk.tag != riffTag)
						done = EAS_TRUE;
					else
						state++;
				}
				break;

			/* read the WAVE tag */
			case 1:
				if (fread(&tag, sizeof(tag), 1, wFile->file) != 1)
					done = EAS_TRUE;
				else
				{
					if (tag != waveTag)
						done = EAS_TRUE;
					else
						state++;
				}
				break;

			/* looking for fmt chunk */
			case 2:
				if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1)
					done = EAS_TRUE;
				else
				{
					startChunkPos = ftell(wFile->file);
						
					/* not fmt tag, skip it */
					if (chunk.tag != fmtTag)
						fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET);
					else
						state++;
				}
				break;

			/* read fmt chunk */
			case 3:
				if (fread(&wFile->wh.fc, sizeof(FMT_CHUNK), 1, wFile->file) != 1)
					done = EAS_TRUE;
				else
				{
					fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET);
					state++;				
				}
				break;
				
			/* looking for data chunk */
			case 4:
				if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1)
					done = EAS_TRUE;
				else
				{
					startChunkPos = ftell(wFile->file);
						
					/* not data tag, skip it */
					if (chunk.tag != dataTag)
						fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET);
					else
					{
						wFile->dataSize = chunk.size;
						state++;
						done = EAS_TRUE;
					}
				}
				break;
				
			default:
				done = EAS_TRUE;
				break;
		}
	}

	/* if not final state, an error occurred */
	if (state != 5)
	{
		fclose(wFile->file);
		free(wFile);
		return NULL;
	}

	/* return the file handle */
	return wFile;
} /* end WaveFileOpen */
#endif