/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#pragma hdrstop
#include "precompiled.h"

/*
================================================================================================
Contains the WaveFile implementation.
================================================================================================
*/

#include "WaveFile.h"

/*
========================
idWaveFile::Open

Returns true if the Open was successful and the file matches the expected format. If this
returns false, there is no need to call Close.
========================
*/
bool idWaveFile::Open( const char* filename )
{
	Close();
	
	if( filename == NULL || filename[0] == 0 )
	{
		return false;
	}
	
	if( file == NULL )
	{
		file = fileSystem->OpenFileReadMemory( filename );
		if( file == NULL )
		{
			return false;
		}
	}
	
	if( file->Length() == 0 )
	{
		Close();
		return false;
	}
	
	struct header_t
	{
		uint32 id;
		uint32 size;
		uint32 format;
	} header;
	
	file->Read( &header, sizeof( header ) );
	idSwap::Big( header.id );
	idSwap::Little( header.size );
	idSwap::Big( header.format );
	
	if( header.id != 'RIFF' || header.format != 'WAVE' || header.size < 4 )
	{
		Close();
		idLib::Warning( "Header is not RIFF WAVE in %s", filename );
		return false;
	}
	
	uint32 riffSize = header.size + 8;
	uint32 offset = sizeof( header );
	
	// Scan the file collecting chunks
	while( offset < riffSize )
	{
		struct chuckHeader_t
		{
			uint32 id;
			uint32 size;
		} chunkHeader;
		if( file->Read( &chunkHeader, sizeof( chunkHeader ) ) != sizeof( chunkHeader ) )
		{
			// It seems like some tools have extra data after the last chunk for no apparent reason
			// so don't treat this as an error
			return true;
		}
		idSwap::Big( chunkHeader.id );
		idSwap::Little( chunkHeader.size );
		offset += sizeof( chunkHeader );
		
		if( chunks.Num() >= chunks.Max() )
		{
			Close();
			idLib::Warning( "More than %d chunks in %s", chunks.Max(), filename );
			return false;
		}
		
		chunk_t* chunk = chunks.Alloc();
		chunk->id = chunkHeader.id;
		chunk->size = chunkHeader.size;
		chunk->offset = offset;
		offset += chunk->size;
		
		file->Seek( offset, FS_SEEK_SET );
	}
	
	return true;
}

/*
========================
idWaveFile::SeekToChunk

Seeks to the specified chunk and returns the size of the chunk or 0 if the chunk wasn't found.
========================
*/
uint32 idWaveFile::SeekToChunk( uint32 id )
{
	for( int i = 0; i < chunks.Num(); i++ )
	{
		if( chunks[i].id == id )
		{
			file->Seek( chunks[i].offset, FS_SEEK_SET );
			return chunks[i].size;
		}
	}
	return 0;
}

/*
========================
idWaveFile::GetChunkOffset

Seeks to the specified chunk and returns the size of the chunk or 0 if the chunk wasn't found.
========================
*/
uint32 idWaveFile::GetChunkOffset( uint32 id )
{
	for( int i = 0; i < chunks.Num(); i++ )
	{
		if( chunks[i].id == id )
		{
			return chunks[i].offset;
		}
	}
	return 0;
}

// Used in XMA2WAVEFORMAT for per-stream data
typedef struct XMA2STREAMFORMAT
{
	byte Channels;			// Number of channels in the stream (1 or 2)
	byte RESERVED;			// Reserved for future use
	uint16 ChannelMask;		// Spatial positions of the channels in the stream
} XMA2STREAMFORMAT;

// Legacy XMA2 format structure (big-endian byte ordering)
typedef struct XMA2WAVEFORMAT
{
	byte Version;			// XMA encoder version that generated the file.
	// Always 3 or higher for XMA2 files.
	byte NumStreams;		// Number of interleaved audio streams
	byte RESERVED;			// Reserved for future use
	byte LoopCount;			// Number of loop repetitions; 255 = infinite
	uint32 LoopBegin;		// Loop begin point, in samples
	uint32 LoopEnd;			// Loop end point, in samples
	uint32 SampleRate;		// The file's decoded sample rate
	uint32 EncodeOptions;		// Options for the XMA encoder/decoder
	uint32 PsuedoBytesPerSec;	// Used internally by the XMA encoder
	uint32 BlockSizeInBytes;	// Size in bytes of this file's XMA blocks (except
	// possibly the last one).  Always a multiple of
	// 2Kb, since XMA blocks are arrays of 2Kb packets.
	uint32 SamplesEncoded;		// Total number of PCM samples encoded in this file
	uint32 SamplesInSource;		// Actual number of PCM samples in the source
	// material used to generate this file
	uint32 BlockCount;			// Number of XMA blocks in this file (and hence
	// also the number of entries in its seek table)
} XMA2WAVEFORMAT;

/*
========================
idWaveFile::ReadWaveFormat

Reads a wave format header, returns NULL if it found one and read it.
otherwise, returns a human-readable error message.
========================
*/
const char* idWaveFile::ReadWaveFormat( waveFmt_t& format )
{
	memset( &format, 0, sizeof( format ) );
	
	uint32 formatSize = SeekToChunk( waveFmt_t::id );
	if( formatSize == 0 )
	{
		return "No format chunk";
	}
	if( formatSize < sizeof( format.basic ) )
	{
		return "Format chunk too small";
	}
	
	Read( &format.basic, sizeof( format.basic ) );
	
	idSwapClass<waveFmt_t::basic_t> swap;
	swap.Little( format.basic.formatTag );
	swap.Little( format.basic.numChannels );
	swap.Little( format.basic.samplesPerSec );
	swap.Little( format.basic.avgBytesPerSec );
	swap.Little( format.basic.blockSize );
	swap.Little( format.basic.bitsPerSample );
	
	if( format.basic.formatTag == FORMAT_PCM )
	{
	}
	else if( format.basic.formatTag == FORMAT_ADPCM )
	{
		Read( &format.extraSize, sizeof( format.extraSize ) );
		idSwap::Little( format.extraSize );
		if( format.extraSize != sizeof( waveFmt_t::extra_t::adpcm_t ) )
		{
			return "Incorrect number of coefficients in ADPCM file";
		}
		Read( &format.extra.adpcm, sizeof( format.extra.adpcm ) );
		idSwapClass<waveFmt_t::extra_t::adpcm_t> swap1;
		swap1.Little( format.extra.adpcm.samplesPerBlock );
		swap1.Little( format.extra.adpcm.numCoef );
		for( int i = 0; i < format.extra.adpcm.numCoef; i++ )
		{
			swap1.Little( format.extra.adpcm.aCoef[ i ].coef1 );
			swap1.Little( format.extra.adpcm.aCoef[ i ].coef2 );
		}
	}
	else if( format.basic.formatTag == FORMAT_XMA2 )
	{
		Read( &format.extraSize, sizeof( format.extraSize ) );
		idSwap::Little( format.extraSize );
		if( format.extraSize != sizeof( waveFmt_t::extra_t::xma2_t ) )
		{
			return "Incorrect chunk size in XMA2 file";
		}
		Read( &format.extra.xma2, sizeof( format.extra.xma2 ) );
		idSwapClass<waveFmt_t::extra_t::xma2_t> swap2;
		swap2.Little( format.extra.xma2.numStreams );
		swap2.Little( format.extra.xma2.channelMask );
		swap2.Little( format.extra.xma2.samplesEncoded );
		swap2.Little( format.extra.xma2.bytesPerBlock );
		swap2.Little( format.extra.xma2.playBegin );
		swap2.Little( format.extra.xma2.playLength );
		swap2.Little( format.extra.xma2.loopBegin );
		swap2.Little( format.extra.xma2.loopLength );
		swap2.Little( format.extra.xma2.loopCount );
		swap2.Little( format.extra.xma2.encoderVersion );
		swap2.Little( format.extra.xma2.blockCount );
	}
	else if( format.basic.formatTag == FORMAT_EXTENSIBLE )
	{
		Read( &format.extraSize, sizeof( format.extraSize ) );
		idSwap::Little( format.extraSize );
		if( format.extraSize != sizeof( waveFmt_t::extra_t::extensible_t ) )
		{
			return "Incorrect chunk size in extensible wave file";
		}
		Read( &format.extra.extensible, sizeof( format.extra.extensible ) );
		idSwapClass<waveFmt_t::extra_t::extensible_t> swap3;
		swap3.Little( format.extra.extensible.validBitsPerSample );
		swap3.Little( format.extra.extensible.channelMask );
		swap3.Little( format.extra.extensible.subFormat.data1 );
		swap3.Little( format.extra.extensible.subFormat.data2 );
		swap3.Little( format.extra.extensible.subFormat.data3 );
		swap3.LittleArray( format.extra.extensible.subFormat.data4, 8 );
		waveFmt_t::extra_t::extensible_t::guid_t pcmGuid =
		{
			FORMAT_PCM,
			0x0000,
			0x0010,
			{ 0x80, 0x00, 0x00,0xaa, 0x00, 0x38, 0x9b, 0x71 }
		};
		if( memcmp( &pcmGuid, &format.extra.extensible.subFormat, sizeof( pcmGuid ) ) != 0 )
		{
			return "Unsupported Extensible format";
		}
	}
	else
	{
		return "Unknown wave format tag";
	}
	
	return NULL;
}

/*
========================
idWaveFile::ReadWaveFormatDirect

Reads a wave format header from a file ptr,
========================
*/
bool idWaveFile::ReadWaveFormatDirect( waveFmt_t& format, idFile* file )
{

	file->Read( &format.basic, sizeof( format.basic ) );
	idSwapClass<waveFmt_t::basic_t> swap;
	swap.Little( format.basic.formatTag );
	swap.Little( format.basic.numChannels );
	swap.Little( format.basic.samplesPerSec );
	swap.Little( format.basic.avgBytesPerSec );
	swap.Little( format.basic.blockSize );
	swap.Little( format.basic.bitsPerSample );
	
	if( format.basic.formatTag == FORMAT_PCM )
	{
	}
	else if( format.basic.formatTag == FORMAT_ADPCM )
	{
		file->Read( &format.extraSize, sizeof( format.extraSize ) );
		idSwap::Little( format.extraSize );
		if( format.extraSize != sizeof( waveFmt_t::extra_t::adpcm_t ) )
		{
			return false;
		}
		file->Read( &format.extra.adpcm, sizeof( format.extra.adpcm ) );
		idSwapClass<waveFmt_t::extra_t::adpcm_t> swap4;
		swap4.Little( format.extra.adpcm.samplesPerBlock );
		swap4.Little( format.extra.adpcm.numCoef );
		for( int i = 0; i < format.extra.adpcm.numCoef; i++ )
		{
			swap4.Little( format.extra.adpcm.aCoef[ i ].coef1 );
			swap4.Little( format.extra.adpcm.aCoef[ i ].coef2 );
		}
	}
	else if( format.basic.formatTag == FORMAT_XMA2 )
	{
		file->Read( &format.extraSize, sizeof( format.extraSize ) );
		idSwap::Little( format.extraSize );
		if( format.extraSize != sizeof( waveFmt_t::extra_t::xma2_t ) )
		{
			return false;
		}
		file->Read( &format.extra.xma2, sizeof( format.extra.xma2 ) );
		idSwapClass<waveFmt_t::extra_t::xma2_t> swap5;
		swap5.Little( format.extra.xma2.numStreams );
		swap5.Little( format.extra.xma2.channelMask );
		swap5.Little( format.extra.xma2.samplesEncoded );
		swap5.Little( format.extra.xma2.bytesPerBlock );
		swap5.Little( format.extra.xma2.playBegin );
		swap5.Little( format.extra.xma2.playLength );
		swap5.Little( format.extra.xma2.loopBegin );
		swap5.Little( format.extra.xma2.loopLength );
		swap5.Little( format.extra.xma2.loopCount );
		swap5.Little( format.extra.xma2.encoderVersion );
		swap5.Little( format.extra.xma2.blockCount );
	}
	else if( format.basic.formatTag == FORMAT_EXTENSIBLE )
	{
		file->Read( &format.extraSize, sizeof( format.extraSize ) );
		idSwap::Little( format.extraSize );
		if( format.extraSize != sizeof( waveFmt_t::extra_t::extensible_t ) )
		{
			return false;
		}
		file->Read( &format.extra.extensible, sizeof( format.extra.extensible ) );
		idSwapClass<waveFmt_t::extra_t::extensible_t> swap6;
		swap6.Little( format.extra.extensible.validBitsPerSample );
		swap6.Little( format.extra.extensible.channelMask );
		swap6.Little( format.extra.extensible.subFormat.data1 );
		swap6.Little( format.extra.extensible.subFormat.data2 );
		swap6.Little( format.extra.extensible.subFormat.data3 );
		swap6.LittleArray( format.extra.extensible.subFormat.data4, 8 );
		waveFmt_t::extra_t::extensible_t::guid_t pcmGuid =
		{
			FORMAT_PCM,
			0x0000,
			0x0010,
			{ 0x80, 0x00, 0x00,0xaa, 0x00, 0x38, 0x9b, 0x71 }
		};
		if( memcmp( &pcmGuid, &format.extra.extensible.subFormat, sizeof( pcmGuid ) ) != 0 )
		{
			return false;
		}
	}
	else
	{
		return false;
	}
	
	return true;
}

/*
========================
idWaveFile::WriteWaveFormatDirect

Writes a wave format header to a file ptr,
========================
*/
bool idWaveFile::WriteWaveFormatDirect( waveFmt_t& format, idFile* file )
{
	//idSwapClass<waveFmt_t::basic_t> swap;
	//swap.Little( format.basic.formatTag );
	//swap.Little( format.basic.numChannels );
	//swap.Little( format.basic.samplesPerSec );
	//swap.Little( format.basic.avgBytesPerSec );
	//swap.Little( format.basic.blockSize );
	//swap.Little( format.basic.bitsPerSample );
	file->Write( &format.basic, sizeof( format.basic ) );
	if( format.basic.formatTag == FORMAT_PCM )
	{
		//file->Write( &format.basic, sizeof( format.basic ) );
	}
	else if( format.basic.formatTag == FORMAT_ADPCM )
	{
		//file->Write( &format.basic, sizeof( format.basic ) );
		file->Write( &format.extraSize, sizeof( format.extraSize ) );
		file->Write( &format.extra.adpcm, sizeof( format.extra.adpcm ) );
	}
	else if( format.basic.formatTag == FORMAT_XMA2 )
	{
		//file->Write( &format.basic, sizeof( format.basic ) );
		file->Write( &format.extraSize, sizeof( format.extraSize ) );
		file->Write( &format.extra.xma2, sizeof( format.extra.xma2 ) );
	}
	else if( format.basic.formatTag == FORMAT_EXTENSIBLE )
	{
		//file->Write( &format.basic, sizeof( format.basic ) );
		file->Write( &format.extraSize, sizeof( format.extraSize ) );
		file->Write( &format.extra.extensible, sizeof( format.extra.extensible ) );
	}
	else
	{
		return false;
	}
	return true;
}

/*
========================
idWaveFile::WriteWaveFormatDirect

Writes a wave format header to a file ptr,
========================
*/

bool idWaveFile::WriteSampleDataDirect( idList< sampleData_t >& sampleData, idFile* file )
{
	static const uint32 sample = 'smpl';
	file->WriteBig( sample );
	uint32 samplerData = sampleData.Num() * 24;
	uint32 chunkSize = 36 + samplerData;
	uint32 zero = 0;
	uint32 numSamples = sampleData.Num();
	
	file->Write( &chunkSize, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &zero, sizeof( uint32 ) );
	file->Write( &numSamples, sizeof( uint32 ) );
	file->Write( &samplerData, sizeof( uint32 ) );
	
	for( int i = 0; i < sampleData.Num(); ++i )
	{
		file->Write( &zero, sizeof( uint32 ) );
		file->Write( &zero, sizeof( uint32 ) );
		file->Write( &sampleData[ i ].start, sizeof( uint32 ) );
		file->Write( &sampleData[ i ].end, sizeof( uint32 ) );
		file->Write( &zero, sizeof( uint32 ) );
		file->Write( &zero, sizeof( uint32 ) );
	}
	return true;
}

/*
========================
idWaveFile::WriteWaveFormatDirect

Writes a data chunk to a file ptr
========================
*/

bool idWaveFile::WriteDataDirect( char* _data, uint32 size, idFile* file )
{
	static const uint32 data = 'data';
	file->WriteBig( data );
	file->Write( &size, sizeof( uint32 ) );
	file->WriteBigArray( _data, size );
	return true;
}

/*
========================
idWaveFile::WriteWaveFormatDirect

Writes a wave header to a file ptr,
========================
*/

bool idWaveFile::WriteHeaderDirect( uint32 fileSize, idFile* file )
{
	static const uint32 riff = 'RIFF';
	static const uint32 wave = 'WAVE';
	file->WriteBig( riff );
	file->WriteBig( fileSize );
	file->WriteBig( wave );
	return true;
}

/*
========================
idWaveFile::ReadLoopPoint

Reads a loop point from a 'smpl' chunk in a wave file, returns 0 if none are found.
========================
*/
bool idWaveFile::ReadLoopData( int& start, int& end )
{
	uint32 chunkSize = SeekToChunk( samplerChunk_t::id );
	if( chunkSize < sizeof( samplerChunk_t ) )
	{
		return false;
	}
	
	samplerChunk_t smpl;
	Read( &smpl, sizeof( smpl ) );
	idSwap::Little( smpl.numSampleLoops );
	
	if( smpl.numSampleLoops < 1 )
	{
		return false; // this is possible returning false lets us know there are more then 1 sample look in the file and is not appropriate for traditional looping
	}
	
	sampleData_t smplData;
	Read( &smplData, sizeof( smplData ) );
	idSwap::Little( smplData.start );
	idSwap::Little( smplData.end );
	
	if( smplData.type != 0 )
	{
		idLib::Warning( "Invalid loop type in %s", file->GetName() );
		return false;
	}
	
	start = smplData.start;
	end = smplData.end;
	return true;
}

/*
========================
idWaveFile::Close

Closes the file and frees resources.
========================
*/
void idWaveFile::Close()
{
	if( file != NULL )
	{
		delete file;
		file = NULL;
	}
	chunks.SetNum( 0 );
}
