void kwlDecoder_deinit(kwlDecoder* decoder)
{
/*Shut down the decoder.*/
decoder->threadJoinRequested = 1;
kwlSemaphorePost(decoder->semaphore);
kwlThreadJoin(&decoder->decodingThread);
/*Dispose of the semaphore.*/
kwlSemaphoreDestroy(decoder->semaphore, decoder->semaphoreName);
/*Free back and front buffers.*/
KWL_FREE(decoder->currentDecodedBuffer);
KWL_FREE(decoder->currentDecodedBufferFront);
/*Close input stream*/
kwlInputStream_close(&decoder->audioDataStream);
/*Codec specific cleanup.*/
decoder->deinit(decoder);
decoder->codecData = NULL;
}
kwlError kwlWaveBank_verifyWaveBankBinary(kwlEngine* engine,
const char* const waveBankPath,
kwlWaveBank** waveBank)
{
/*Open the file...*/
kwlInputStream stream;
kwlError result = kwlInputStream_initWithFile(&stream, waveBankPath);
if (result != KWL_NO_ERROR)
{
kwlInputStream_close(&stream);
return result;
}
/*... and check the wave bank file identifier.*/
int i;
for (i = 0; i < KWL_WAVE_BANK_BINARY_FILE_IDENTIFIER_LENGTH; i++)
{
const char identifierChari = kwlInputStream_readChar(&stream);
if (identifierChari != KWL_WAVE_BANK_BINARY_FILE_IDENTIFIER[i])
{
/* Not the file identifier we expected. */
kwlInputStream_close(&stream);
return KWL_UNKNOWN_FILE_FORMAT;
}
}
/*Read the ID from the wave bank binary file and find a matching wave bank struct.*/
const char* waveBankToLoadId = kwlInputStream_readASCIIString(&stream);
const int waveBankToLoadnumAudioDataEntries = kwlInputStream_readIntBE(&stream);
const int numWaveBanks = engine->engineData.numWaveBanks;
kwlWaveBank* matchingWaveBank = NULL;
for (i = 0; i < numWaveBanks; i++)
{
if (strcmp(waveBankToLoadId, engine->engineData.waveBanks[i].id) == 0)
{
matchingWaveBank = &engine->engineData.waveBanks[i];
}
}
KWL_FREE((void*)waveBankToLoadId);
if (matchingWaveBank == NULL)
{
/*No matching bank was found. Close the file stream and return an error.*/
kwlInputStream_close(&stream);
return KWL_NO_MATCHING_WAVE_BANK;
}
else if (waveBankToLoadnumAudioDataEntries != matchingWaveBank->numAudioDataEntries)
{
/*A matching wave bank was found but the number of audio data entries
does not match the binary wave bank data.*/
kwlInputStream_close(&stream);
return KWL_WAVE_BANK_ENTRY_MISMATCH;
}
else if (matchingWaveBank->isLoaded != 0)
{
/*The wave bank is already loaded, just set the handle and do nothing.*/
*waveBank = matchingWaveBank;
kwlInputStream_close(&stream);
return KWL_NO_ERROR;
}
/*Store the path the wave bank was loaded from (used when streaming from disk).*/
const int pathLen = strlen(waveBankPath);
matchingWaveBank->waveBankFilePath = (char*)KWL_MALLOC((pathLen + 1) * sizeof(char), "wave bank path string");
strcpy(matchingWaveBank->waveBankFilePath, waveBankPath);
/*Make sure that the entries of the wave bank to load and the wave bank struct line up.*/
for (i = 0; i < waveBankToLoadnumAudioDataEntries; i++)
{
const char* filePathi = kwlInputStream_readASCIIString(&stream);
int matchingEntryIndex = -1;
int j = 0;
for (j = 0; j < waveBankToLoadnumAudioDataEntries; j++)
{
if (strcmp(matchingWaveBank->audioDataItems[j].filePath, filePathi) == 0)
{
matchingEntryIndex = j;
break;
}
}
KWL_FREE((void*)filePathi);
if (matchingEntryIndex < 0)
{
/* This wave bank entry has no corresponding waveform slot. Abort loading.*/
kwlInputStream_close(&stream);
return KWL_WAVE_BANK_ENTRY_MISMATCH;
}
/*skip to the next wave data entry*/
/*const int encoding = */kwlInputStream_readIntBE(&stream);
/*const int streamFromDisk = */kwlInputStream_readIntBE(&stream);
const int numChannels = kwlInputStream_readIntBE(&stream);
KWL_ASSERT((numChannels == 0 || numChannels == 1 || numChannels == 2) && "invalid num channels");
const int numBytes = kwlInputStream_readIntBE(&stream);
KWL_ASSERT(numBytes > 0);
kwlInputStream_skip(&stream, numBytes);
}
/* Reading went well. */
kwlInputStream_close(&stream);
*waveBank = matchingWaveBank;
return KWL_NO_ERROR;
}