自学教程：C++ FindChunk函数代码示例

HRESULT AudioData::LoadXwma(LPCTSTR strFileName){	// Open the file	HANDLE hFile = CreateFile(		strFileName,		GENERIC_READ,		FILE_SHARE_READ,		NULL,		OPEN_EXISTING,		0,		NULL );	if( INVALID_HANDLE_VALUE == hFile )		return HRESULT_FROM_WIN32( GetLastError() );	if( INVALID_SET_FILE_POINTER == SetFilePointer( hFile, 0, NULL, FILE_BEGIN ) )		return HRESULT_FROM_WIN32( GetLastError() );	DWORD dwChunkSize;	DWORD dwChunkPosition;	//check the file type, should be fourccWAVE or 'XWMA'	FindChunk(hFile,fourccRIFF,dwChunkSize, dwChunkPosition );	DWORD filetype;	ReadChunkData(hFile,&filetype,sizeof(DWORD),dwChunkPosition);	if (filetype != fourccXWMA)		return E_FAIL;	//Locate the 'fmt ' chunk, and copy its contents into a WAVEFORMATEXTENSIBLE structure.	FindChunk(hFile,fourccFMT, dwChunkSize, dwChunkPosition );	ReadChunkData(hFile, &wfx, dwChunkSize, dwChunkPosition );	//fill out the audio data buffer with the contents of the fourccDATA chunk	FindChunk(hFile,fourccDATA,dwChunkSize, dwChunkPosition );	BYTE * pDataBuffer = new BYTE[dwChunkSize];	ReadChunkData(hFile, pDataBuffer, dwChunkSize, dwChunkPosition);	//Populate an XAUDIO2_BUFFER structure.	buffer.AudioBytes = dwChunkSize;  //buffer containing audio data	buffer.pAudioData = pDataBuffer;  //size of the audio buffer in bytes	buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer	//fill out the wma data buffer with the contents of the fourccDPDS chunk	FindChunk(hFile, fourccDPDS, dwChunkSize, dwChunkPosition);	UINT32 * pDataBufferWma = new UINT32[dwChunkSize/sizeof(UINT32)];	ReadChunkData(hFile, pDataBufferWma, dwChunkSize, dwChunkPosition);	//Populate an XAUDIO2_BUFFER_WMA structure.	wmabuffer.PacketCount = dwChunkSize/sizeof(UINT32);	wmabuffer.pDecodedPacketCumulativeBytes = pDataBufferWma;	// Don't forget to close the file.	CloseHandle(hFile);	return S_OK;}

/*============GetWavinfo============*/static wavinfo_t GetWavinfo( char *name, byte *wav, int wavlength ) {	wavinfo_t info;	Com_Memset( &info, 0, sizeof( info ) );	if ( !wav ) {		return info;	}	iff_data = wav;	iff_end = wav + wavlength;// find "RIFF" chunk	FindChunk( "RIFF" );	if ( !( data_p && !strncmp( (char *)data_p + 8, "WAVE", 4 ) ) ) {		Com_Printf( "Missing RIFF/WAVE chunks/n" );		return info;	}// get "fmt " chunk	iff_data = data_p + 12;// DumpChunks ();	FindChunk( "fmt " );	if ( !data_p ) {		Com_Printf( "Missing fmt chunk/n" );		return info;	}	data_p += 8;	info.format = GetLittleShort();	info.channels = GetLittleShort();	info.rate = GetLittleLong();	data_p += 4 + 2;	info.width = GetLittleShort() / 8;	if ( info.format != 1 ) {#if defined RTCW_ET		Com_Printf( "Unsupported format: %s/n", GetWaveFormatName( info.format ) );#endif // RTCW_XX		Com_Printf( "Microsoft PCM format only/n" );		return info;	}// find data chunk	FindChunk( "data" );	if ( !data_p ) {		Com_Printf( "Missing data chunk/n" );		return info;	}	data_p += 4;	info.samples = GetLittleLong() / info.width;	info.dataofs = data_p - wav;	return info;}

std::shared_ptr<Sound_Engine::Sound> Sound_Engine::LoadSound(std::string file){	std::string::size_type po = file.find_last_of('//');	if(po == std::string::npos) po = file.find_last_of('/');// couldnt find it with the double slashes, try a single forward slash	if(po == std::string::npos) {// no slashes.. there must be no path on this string so append our asset directory to where the sounds are stored		file = Internal::Asset_Dir + "Sound//" + file;	}// else the user specified some sort of directory, so use that instead.			std::ifstream f(file.c_str(), std::ios::beg | std::ios::binary);	assert(f);	// see if the sound data has been loaded already	std::map<std::string, std::weak_ptr<Internal::Sub_Sound>>::iterator soundloaded = Internal::LoadedSounds.find(file);	if(soundloaded != Internal::LoadedSounds.end()) {// the data exists		std::shared_ptr<Internal::Sub_Sound> ptr(soundloaded->second.lock());		if(ptr){// the sound data still exists			std::shared_ptr<Sound_Engine::Sound> sound_ptr = std::make_shared<Sound_Engine::Sound>();// create a new source 			sound_ptr->InternalSound = ptr;			Internal::Sources[sound_ptr.get()] = sound_ptr;// insert into the sources			return sound_ptr;		}	}	std::shared_ptr<Sound_Engine::Sound> retsound = std::make_shared<Sound_Engine::Sound>();	Internal::Sources[retsound.get()] = retsound;	retsound->InternalSound = std::make_shared<Internal::Sub_Sound>();	Internal::LoadedSounds[file]=retsound->InternalSound;	retsound->InternalSound->buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer	DWORD dwChunkSize(0);	DWORD dwChunkPosition(0);	//check the file type, should be fourccWAVE or 'XWMA'	FindChunk(f,fourccRIFF,dwChunkSize, dwChunkPosition );	DWORD filetype(0);	ReadChunkData(f, &filetype, sizeof(DWORD), dwChunkPosition);	if (filetype != fourccWAVE){		if(filetype != fourccXWMA){			f.close();			OUTPUT_DEBUG_MSG("File is not a .wav, or a xwma file... uh oh");			assert(true);		}	}	FindChunk(f,fourccFMT, dwChunkSize, dwChunkPosition );	ReadChunkData(f, &retsound->InternalSound->wfx, dwChunkSize, dwChunkPosition );	FindChunk(f,fourccDATA,dwChunkSize, dwChunkPosition );	retsound->InternalSound->buffer.AudioBytes = dwChunkSize;  //buffer containing audio data	BYTE *temp = new BYTE[dwChunkSize];  //size of the audio buffer in bytes	retsound->InternalSound->buffer.pAudioData = temp;	ReadChunkData(f, temp, dwChunkSize, dwChunkPosition);	if(filetype == fourccXWMA){// the file is an xwma file... we need an extra peice of data		FindChunk(f,fourccDPDS, dwChunkSize, dwChunkPosition );		// the chunksize is how many bytess there are, so we have to divide by sizeof(uint32t) to get the number of uint32's in the buffer		//so chunksize will be like 24, but that is how many bytes, we need 24/4 which is 6. Because there are 6 uint32's		retsound->InternalSound->wmaBuffer.PacketCount = dwChunkSize / sizeof(UINT32); 		UINT32 *temp2 = new UINT32[retsound->InternalSound->wmaBuffer.PacketCount];		ReadChunkData(f, temp2, dwChunkSize, dwChunkPosition);		retsound->InternalSound->wmaBuffer.pDecodedPacketCumulativeBytes= temp2;	}	f.close();	return retsound;}

	bool Audio::AddAudioFile(const char* i_AudioPath, bool bLoop, float i_InitialVolume)	{		WAVEFORMATEXTENSIBLE wfx = { 0 };		XAUDIO2_BUFFER buffer = { 0 };		// Open the file		HANDLE hFile = CreateFile(			i_AudioPath,			GENERIC_READ,			FILE_SHARE_READ,			NULL,			OPEN_EXISTING,			0,			NULL);		SetFilePointer(hFile, 0, NULL, FILE_BEGIN);		DWORD dwChunkSize;		DWORD dwChunkPosition;		//check the file type, should be fourccWAVE or 'XWMA'		FindChunk(hFile, fourccRIFF, dwChunkSize, dwChunkPosition);		DWORD filetype;		ReadChunkData(hFile, &filetype, sizeof(DWORD), dwChunkPosition);		if (filetype != fourccWAVE)			return false;		FindChunk(hFile, fourccFMT, dwChunkSize, dwChunkPosition);		ReadChunkData(hFile, &wfx, dwChunkSize, dwChunkPosition);		//fill out the audio data buffer with the contents of the fourccDATA chunk		FindChunk(hFile, fourccDATA, dwChunkSize, dwChunkPosition);		BYTE * pDataBuffer = new BYTE[dwChunkSize];		ReadChunkData(hFile, pDataBuffer, dwChunkSize, dwChunkPosition);		buffer.AudioBytes = dwChunkSize;  //buffer containing audio data		buffer.pAudioData = pDataBuffer;  //size of the audio buffer in bytes		buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer		if (bLoop)		{			buffer.LoopLength = 0;			buffer.LoopCount = XAUDIO2_LOOP_INFINITE;		}		HRESULT hr;		IXAudio2SourceVoice* pSourceVoice;		if (FAILED(hr = s_pXAudio2->CreateSourceVoice(&pSourceVoice, (WAVEFORMATEX*)&wfx)))			return false;		if (FAILED(hr = pSourceVoice->SubmitSourceBuffer(&buffer)))			return false;		pSourceVoice->SetVolume(i_InitialVolume);		s_SourceVoices.push_back(pSourceVoice);		s_AudioBuffers.push_back(buffer);	}

	bool SPWavFile::LoadWave()	{		if (path == L"")		{			return false;		}		DWORD dwChunkSize;		DWORD dwChunkPosition;		DWORD filetype;		// Check the file type, should be fourccWAVE or 'XWMA'		FindChunk(fourccRIFF, dwChunkSize, dwChunkPosition );				ReadChunkData(&filetype, sizeof(DWORD), dwChunkPosition);		if (filetype != fourccWAVE)		{			return false;		}		// Locate the 'fmt ' chunk, and copy its contents into a		// WAVEFORMATEXTENSIBLE structure.		FindChunk(fourccFMT, dwChunkSize, dwChunkPosition );		ReadChunkData(&wfx, dwChunkSize, dwChunkPosition );		// 		// Find the beginning position and the size of stream data.		// 		FindChunk(fourccDATA, soundDataLength, soundDataOffset);		SetPosition(soundDataOffset);		//		// Calculate sound length.		// 		int stereo = wfx.nChannels;		int numberBytePerChannalSample = wfx.wBitsPerSample / 8;		int bytePerSample = stereo * numberBytePerChannalSample;		int sampleRate = wfx.nSamplesPerSec;		float seconds = soundDataLength / (float)(sampleRate * bytePerSample);		songLength = seconds;		// 		// Set loaded flag.		// 		isLoaded = true;		return true;	}

void Sound::loadMusic(IXAudio2SourceVoice* &voice, std::string filename, BYTE* &soundBuffer, UINT32* &xwmaBuffer){	WAVEFORMATEXTENSIBLE wfx;	ZeroMemory(&wfx, sizeof(WAVEFORMATEXTENSIBLE));		HANDLE fileHandle = CreateFile((const char*) filename.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);		DWORD chunkSize = 0;	DWORD chunkPos = 0;	DWORD fileType = 0;	FindChunk(fileHandle, 'FFIR', chunkSize, chunkPos);	ReadChunkData(fileHandle, &fileType, sizeof(DWORD), chunkPos);	FindChunk(fileHandle, ' tmf', chunkSize, chunkPos);	ReadChunkData(fileHandle, &wfx, chunkSize, chunkPos);	// Read in audio data	FindChunk(fileHandle, 'atad', chunkSize, chunkPos);	soundBuffer = new BYTE[chunkSize];	ReadChunkData(fileHandle, soundBuffer, chunkSize, chunkPos);		XAUDIO2_BUFFER buffer;	ZeroMemory(&buffer, sizeof(XAUDIO2_BUFFER));	buffer.AudioBytes = chunkSize;	buffer.pAudioData = soundBuffer;	buffer.Flags = XAUDIO2_END_OF_STREAM;	buffer.LoopCount = XAUDIO2_LOOP_INFINITE;		XAUDIO2_BUFFER_WMA wmaBuffer;	ZeroMemory(&wmaBuffer, sizeof(XAUDIO2_BUFFER_WMA));		FindChunk(fileHandle, 'sdpd', chunkSize, chunkPos);	// Divide chunk size by sizeof(DWORD) and assign	wmaBuffer.PacketCount = chunkSize / 4;		xwmaBuffer = (UINT32*) new BYTE[chunkSize];	ReadChunkData(fileHandle, xwmaBuffer, chunkSize, chunkPos);	wmaBuffer.pDecodedPacketCumulativeBytes = xwmaBuffer;		audio->CreateSourceVoice(&voice, (WAVEFORMATEX*) &wfx, XAUDIO2_VOICE_USEFILTER, 2.0f, NULL, &musicSendList, NULL);	voice->SubmitSourceBuffer(&buffer, &wmaBuffer);	CloseHandle(fileHandle);}

CHUNK_t* NewChunk(SAVESTATE_t* save, const char *tag) {	int chunk = save->chunk_count;	if (FindChunk(save, tag) != NULL) {		return NULL;	}	if (save->chunks[chunk] != NULL) {		return NULL;	}	save->chunks[chunk] = (CHUNK_t *) malloc(sizeof(CHUNK_t));	if (!save->chunks[chunk]) {		return NULL;	}	save->chunks[chunk]->tag[0]	= tag[0];	save->chunks[chunk]->tag[1]	= tag[1];	save->chunks[chunk]->tag[2]	= tag[2];	save->chunks[chunk]->tag[3]	= tag[3];	save->chunks[chunk]->size	= 0;	save->chunks[chunk]->data	= NULL;	save->chunks[chunk]->pnt	= 0;	save->chunk_count++;	return save->chunks[chunk];}

	bool MarkChunkAsPadding ( LFA_FileRef inFileRef, RiffState & inOutRiffState, long riffType, long tagID, long subtypeID )	{		UInt32 len;		UInt64 pos;		atag tag;			try {				bool found = FindChunk ( inOutRiffState, tagID, riffType, subtypeID, NULL, &len, &pos );			if ( ! found ) return false;				if ( subtypeID != 0 ) {				pos -= 12;			} else {				pos -= 8;			}			tag.id = MakeUns32LE ( ckidPremierePadding );			LFA_Seek ( inFileRef, pos, SEEK_SET );			LFA_Write ( inFileRef, &tag, 4 );				pos += 8;			AddTag ( inOutRiffState, ckidPremierePadding, len, pos, 0, 0, 0 );			} catch(...) {				return false;	// If a write fails, it throws, so we return false.			}			return true;	}

CHUNK_t* NewChunk(SAVESTATE_t* save, const char *tag) {	int chunk = save->chunk_count;	if (FindChunk(save, tag) != nullptr) {		printf("Error: chunk '%s' already exists", tag);		return nullptr;	}	if (save->chunks[chunk] != nullptr) {		puts("Error new chunk was not null.");	}	save->chunks[chunk] = (CHUNK_t *) malloc(sizeof(CHUNK_t));	if (!save->chunks[chunk]) {		puts("Chunk could not be created");		return nullptr;	}	save->chunks[chunk]->tag[0]	= tag[0];	save->chunks[chunk]->tag[1]	= tag[1];	save->chunks[chunk]->tag[2]	= tag[2];	save->chunks[chunk]->tag[3]	= tag[3];	save->chunks[chunk]->size	= 0;	save->chunks[chunk]->data	= nullptr;	save->chunks[chunk]->pnt	= 0;	save->chunk_count++;	return save->chunks[chunk];}

sint64 VDAVIReadIndex::NextKey(sint64 samplePos) const {	if (samplePos < 0) {		if (IsKey(0))			return true;		samplePos = 0;	}	if (samplePos >= mSampleCount)		return -1;	uint32 sectorIndex = FindSectorIndexBySample(samplePos);	uint32 sampleOffset;	uint32 chunkIndex;	IndexEntry *ient = FindChunk(samplePos, sectorIndex, sampleOffset, chunkIndex);	while(++chunkIndex < mChunkCount) {		ient = &mIndex[chunkIndex >> kBlockSizeBits][chunkIndex & kBlockMask];		if ((sint32)ient->mSizeAndKeyFrameFlag < 0) {			sectorIndex = FindSectorIndexByChunk(chunkIndex);			return mSectors[sectorIndex].mChunkOffset + ient->mSampleOffset;		}	}	return -1;}

char* GetRomOnly(SAVESTATE_t *save, int *size) {	CHUNK_t* chunk = FindChunk(save, ROM_tag);	*size = 0;	if (!chunk) return nullptr;	*size = chunk->size;	return (char *) chunk->data;}

void LoadLCD(SAVESTATE_t* save, LCD_t* lcd) {	CHUNK_t* chunk = FindChunk(save,LCD_tag);	chunk->pnt = 0;	lcd->active		= ReadInt(chunk);	lcd->word_len	= ReadInt(chunk);	lcd->x			= ReadInt(chunk);	lcd->y			= ReadInt(chunk);	lcd->z			= ReadInt(chunk);	lcd->cursor_mode		= (LCD_CURSOR_MODE) ReadInt(chunk);	lcd->contrast	= ReadInt(chunk);	lcd->base_level	= ReadInt(chunk);	ReadBlock(chunk, lcd->display, DISPLAY_SIZE);	lcd->front		= ReadInt(chunk);	ReadBlock(chunk,  (unsigned char *) lcd->queue, LCD_MAX_SHADES * DISPLAY_SIZE);	lcd->shades		= ReadInt(chunk);	lcd->mode		= (LCD_MODE) ReadInt(chunk);	lcd->time		= ReadDouble(chunk);	lcd->ufps		= ReadDouble(chunk);	lcd->ufps_last	= ReadDouble(chunk);	lcd->lastgifframe= ReadDouble(chunk);	lcd->write_avg	= ReadDouble(chunk);	lcd->write_last = ReadDouble(chunk);}

sint64 VDAVIReadIndex::PrevKey(sint64 samplePos) const {	if (samplePos <= 0)		return -1;	if (samplePos >= mSampleCount)		return NearestKey(samplePos);	uint32 sectorIndex = FindSectorIndexBySample(samplePos);	uint32 sampleOffset;	uint32 chunkIndex;	IndexEntry *ient = FindChunk(samplePos, sectorIndex, sampleOffset, chunkIndex);	if (chunkIndex == 0)		return -1;	--chunkIndex;	for(;;) {		ient = &mIndex[chunkIndex >> kBlockSizeBits][chunkIndex & kBlockMask];		if ((sint32)ient->mSizeAndKeyFrameFlag < 0) {			sectorIndex = FindSectorIndexByChunk(chunkIndex);			return mSectors[sectorIndex].mChunkOffset + ient->mSampleOffset;		}		if (!chunkIndex)			break;		chunkIndex -= ient->mPrevKeyDistance;	}	return -1;}

/** * LoadBasicChunks */void LoadBasicChunks(void) {	byte *cptr;	int numObjects;	// Allocate RAM for savescene data	InitialiseSaveScenes();	// CHUNK_TOTAL_ACTORS seems to be missing in the released version, hard coding a value	// TODO: Would be nice to just change 511 to MAX_SAVED_ALIVES	cptr = FindChunk(MASTER_SCNHANDLE, CHUNK_TOTAL_ACTORS);	RegisterActors((cptr != NULL) ? READ_LE_UINT32(cptr) : 511);	// CHUNK_TOTAL_GLOBALS seems to be missing in some versions.	// So if it is missing, set a reasonably high value for the number of globals.	cptr = FindChunk(MASTER_SCNHANDLE, CHUNK_TOTAL_GLOBALS);	RegisterGlobals((cptr != NULL) ? READ_LE_UINT32(cptr) : 512);	cptr = FindChunk(INV_OBJ_SCNHANDLE, CHUNK_TOTAL_OBJECTS);	numObjects = (cptr != NULL) ? READ_LE_UINT32(cptr) : 0;	cptr = FindChunk(INV_OBJ_SCNHANDLE, CHUNK_OBJECTS);#ifdef SCUMM_BIG_ENDIAN	//convert to native endianness	INV_OBJECT *io = (INV_OBJECT *)cptr;	for (int i = 0; i < numObjects; i++, io++) {		io->id        = FROM_LE_32(io->id);		io->hIconFilm = FROM_LE_32(io->hIconFilm);		io->hScript   = FROM_LE_32(io->hScript);		io->attribute = FROM_LE_32(io->attribute);	}#endif	RegisterIcons(cptr, numObjects);	cptr = FindChunk(MASTER_SCNHANDLE, CHUNK_TOTAL_POLY);	if (cptr != NULL)		MaxPolygons(*cptr);	if (TinselV2) {		// Global processes		cptr = FindChunk(MASTER_SCNHANDLE, CHUNK_NUM_PROCESSES);		assert(cptr && (*cptr < 100));		int num = *cptr;		cptr = FindChunk(MASTER_SCNHANDLE, CHUNK_PROCESSES);		assert(!num || cptr);		GlobalProcesses(num, cptr);		// CdPlay() stuff		cptr = FindChunk(MASTER_SCNHANDLE, CHUNK_CDPLAY_HANDLE);		assert(cptr);		uint32 playHandle = READ_LE_UINT32(cptr);		assert(playHandle < 512);		SetCdPlayHandle(playHandle);	}}

		void ReadHeader()		{			FindChunk("RIFF");			size = read_value<int>();						unsigned char data[4];			stream.read(data, sizeof(data));			Compare(data, "WAVE");		}

void LoadCPU(SAVESTATE_t* save, CPU_t* cpu) {	CHUNK_t* chunk = FindChunk(save, CPU_tag);	chunk->pnt = 0;		cpu->a = ReadChar(chunk);	cpu->f = ReadChar(chunk);	cpu->b = ReadChar(chunk);	cpu->c = ReadChar(chunk);	cpu->d = ReadChar(chunk);	cpu->e = ReadChar(chunk);	cpu->h = ReadChar(chunk);	cpu->l = ReadChar(chunk);		cpu->ap = ReadChar(chunk);	cpu->fp = ReadChar(chunk);	cpu->bp = ReadChar(chunk);	cpu->cp = ReadChar(chunk);	cpu->dp = ReadChar(chunk);	cpu->ep = ReadChar(chunk);	cpu->hp = ReadChar(chunk);	cpu->lp = ReadChar(chunk);	cpu->ixl = ReadChar(chunk);	cpu->ixh = ReadChar(chunk);	cpu->iyl = ReadChar(chunk);	cpu->iyh = ReadChar(chunk);		cpu->pc = ReadShort(chunk);	cpu->sp = ReadShort(chunk);	cpu->i = ReadChar(chunk);	cpu->r = ReadChar(chunk);	cpu->bus = ReadChar(chunk);	cpu->imode = ReadInt(chunk);	cpu->interrupt = ReadInt(chunk);	cpu->ei_block = ReadInt(chunk);	cpu->iff1 = ReadInt(chunk);	cpu->iff2 = ReadInt(chunk);	cpu->halt = ReadInt(chunk);		cpu->read = ReadInt(chunk);	cpu->write = ReadInt(chunk);	cpu->output = ReadInt(chunk);	cpu->input = ReadInt(chunk);		cpu->prefix = ReadInt(chunk);	int i;	for(i = 0; i < 256; i++) {		interrupt_t *val = &cpu->pio.interrupt[i];		val->interrupt_val = ReadInt(chunk);		val->skip_factor = ReadInt(chunk);		val->skip_count = ReadInt(chunk);	}	}

void LoadTIMER(SAVESTATE_t* save, timerc* time) {	CHUNK_t* chunk = FindChunk(save,TIMER_tag);	chunk->pnt = 0;	time->tstates	= ReadLong(chunk);	time->freq		= (uint32_t) ReadLong(chunk);	time->elapsed	= ReadDouble(chunk);	time->lasttime	= ReadDouble(chunk);	// this isn't used.}

void* CFX_StaticStore::Alloc(size_t size) {  size = FX_4BYTEALIGN(size);  ASSERT(size != 0);  FX_STATICSTORECHUNK* pChunk = FindChunk(size);  ASSERT(pChunk->iFreeSize >= size);  uint8_t* p = (uint8_t*)pChunk;  p += sizeof(FX_STATICSTORECHUNK) + pChunk->iChunkSize - pChunk->iFreeSize;  pChunk->iFreeSize -= size;  m_iAllocatedSize += size;  return p;}

	LevelChunk* Level::GetChunk(const Vector2i& index)	{		SharedPtr<LevelChunk> chunk(FindChunk(index));		if (chunk) return chunk;		chunk = new LevelChunk(_context);		chunk->Init(this, index);		_chunks.Add(chunk);		return chunk;	}

void LoadSoundFromFile(LPCWSTR filename, WAVEFORMATEX& waveFormat, XAUDIO2_BUFFER& buffer){	// Open the file	HANDLE hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);	if(INVALID_HANDLE_VALUE == hFile)		exit(EXIT_FAILURE);	if(INVALID_SET_FILE_POINTER == SetFilePointer(hFile, 0, NULL, FILE_BEGIN))		exit(EXIT_FAILURE);	//locate the riff chunk and check the filetype	DWORD dwChunkSize;	DWORD dwChunkPosition;	//check the file type, should be fourccWAVE or 'XWMA'	FindChunk(hFile, fourccRIFF, dwChunkSize, dwChunkPosition);	DWORD filetype;	ReadChunkData(hFile,&filetype, sizeof(DWORD), dwChunkPosition);	if(filetype != fourccWAVE)		exit(EXIT_FAILURE);	//locate the "fmt" chunk and copy it into a WAVEFMTEXTENSIBLE structure (wfx)	//WAVEFORMATEXTENSIBLE wfx = {0};	FindChunk(hFile,fourccFMT, dwChunkSize, dwChunkPosition);	ReadChunkData(hFile, &waveFormat, dwChunkSize, dwChunkPosition);	//Locate the 'data' chunk, and read its contents into a buffer	//fill out the audio data buffer with the contents of the fourccDATA chunk	FindChunk(hFile,fourccDATA, dwChunkSize, dwChunkPosition);	BYTE * pDataBuffer = new BYTE[dwChunkSize];	ReadChunkData(hFile, pDataBuffer, dwChunkSize, dwChunkPosition);	//Populate an XAUDIO2_BUFFER structure	buffer.AudioBytes = dwChunkSize;  //buffer containing audio data	buffer.pAudioData = pDataBuffer;  //size of the audio buffer in bytes	buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer}

		void ReadFormatChunk()		{			FindChunk("fmt ");			int size = read_value<int>();			if (size < 16)			{				throw wave_reader_exception();			}			compression = (Compression) read_value<short int>();			numberChannels = read_value<short int>();			samplesPerSecond = read_value<int>();			averageBytesPerSecond = read_value<int>();			blockAlign = read_value<short int>();			bitsPerSample = read_value<short int>();		}

void LoadSTDINT(SAVESTATE_t* save, STDINT_t* stdint) {	int i;	CHUNK_t* chunk		= FindChunk(save,STDINT_tag);	chunk->pnt = 0;	stdint->intactive	= ReadChar(chunk);	stdint->lastchk1	= ReadDouble(chunk);	stdint->timermax1	= ReadDouble(chunk);	stdint->lastchk2	= ReadDouble(chunk);	stdint->timermax2	= ReadDouble(chunk);	for(i = 0; i < 4; i++) {		stdint->freq[i]	= ReadDouble(chunk);	}	stdint->mem			= ReadInt(chunk);	stdint->xy			= ReadInt(chunk);}

/** * Start up a SceneTinselProcess() running the scene * script for various events. */void SendSceneTinselProcess(TINSEL_EVENT event) {	SCENE_STRUC	*ss;	if (g_SceneHandle != (SCNHANDLE)NULL) {		ss = (SCENE_STRUC *) FindChunk(g_SceneHandle, CHUNK_SCENE);		if (ss->hSceneScript) {			TP_INIT	init;			init.event = event;			init.hTinselCode = ss->hSceneScript;			g_scheduler->createProcess(PID_TCODE, SceneTinselProcess, &init, sizeof(init));		}	}}

	bool RewriteChunk ( LFA_FileRef inFileRef, RiffState & inOutRiffState, long tagID, long parentID, const char * inData )	{		UInt32 len;		UInt64 pos;			try {			if ( FindChunk ( inOutRiffState, tagID, parentID, 0, NULL, &len, &pos ) ) {				LFA_Seek ( inFileRef, pos, SEEK_SET );				LFA_Write ( inFileRef, inData, len );			}		} catch ( ... ) {			return false;		}			return true;		}

	bool PutChunk ( LFA_FileRef inFileRef, RiffState & inOutRiffState, long riffType, long tagID, const char * inBuffer, UInt32 inBufferSize )	{		UInt32 len;		UInt64 pos;		atag tag;			// Make sure we're writting an even number of bytes. Required by the RIFF specification.		XMP_Assert ( (inBufferSize & 1) == 0 );			try {			bool found = FindChunk ( inOutRiffState, tagID, 0, 0, NULL, &len, &pos );			if ( found ) {				if ( len == inBufferSize ) {					LFA_Seek ( inFileRef, pos, SEEK_SET );					LFA_Write ( inFileRef, inBuffer, inBufferSize );					return true;				}					pos -= 8;				tag.id = MakeUns32LE ( ckidPremierePadding );				LFA_Seek ( inFileRef, pos, SEEK_SET );				LFA_Write ( inFileRef, &tag, 4 );					if ( len > inBufferSize ) {					pos += 8;					AddTag ( inOutRiffState, ckidPremierePadding, len, pos, 0, 0, 0 );				}			}		} catch ( ... ) {			// If a write fails, it throws, so we return false			return false;		}			bool ok = MakeChunk ( inFileRef, inOutRiffState, riffType, (inBufferSize + 8) );		if ( ! ok ) return false;			return WriteChunk ( inFileRef, tagID, inBuffer, inBufferSize );		}