706 строки
22 KiB
C++
706 строки
22 KiB
C++
//--------------------------------------------------------------------------------------
|
|
// File: WAVFileReader.cpp
|
|
//
|
|
// Functions for loading WAV audio files
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
//-------------------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#include "WAVFileReader.h"
|
|
|
|
#ifndef MAKEFOURCC
|
|
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
|
|
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \
|
|
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
|
|
#endif /* defined(MAKEFOURCC) */
|
|
|
|
namespace
|
|
{
|
|
struct handle_closer { void operator()(HANDLE h) { if (h) CloseHandle(h); } };
|
|
|
|
typedef std::unique_ptr<void, handle_closer> ScopedHandle;
|
|
|
|
inline HANDLE safe_handle(HANDLE h) { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
|
|
|
|
//---------------------------------------------------------------------------------
|
|
// .WAV files
|
|
//---------------------------------------------------------------------------------
|
|
const uint32_t FOURCC_RIFF_TAG = MAKEFOURCC('R', 'I', 'F', 'F');
|
|
const uint32_t FOURCC_FORMAT_TAG = MAKEFOURCC('f', 'm', 't', ' ');
|
|
const uint32_t FOURCC_DATA_TAG = MAKEFOURCC('d', 'a', 't', 'a');
|
|
const uint32_t FOURCC_WAVE_FILE_TAG = MAKEFOURCC('W', 'A', 'V', 'E');
|
|
const uint32_t FOURCC_XWMA_FILE_TAG = MAKEFOURCC('X', 'W', 'M', 'A');
|
|
const uint32_t FOURCC_DLS_SAMPLE = MAKEFOURCC('w', 's', 'm', 'p');
|
|
const uint32_t FOURCC_MIDI_SAMPLE = MAKEFOURCC('s', 'm', 'p', 'l');
|
|
const uint32_t FOURCC_XWMA_DPDS = MAKEFOURCC('d', 'p', 'd', 's');
|
|
const uint32_t FOURCC_XMA_SEEK = MAKEFOURCC('s', 'e', 'e', 'k');
|
|
|
|
#pragma pack(push,1)
|
|
struct RIFFChunk
|
|
{
|
|
uint32_t tag;
|
|
uint32_t size;
|
|
};
|
|
|
|
struct RIFFChunkHeader
|
|
{
|
|
uint32_t tag;
|
|
uint32_t size;
|
|
uint32_t riff;
|
|
};
|
|
|
|
struct DLSLoop
|
|
{
|
|
static const uint32_t LOOP_TYPE_FORWARD = 0x00000000;
|
|
static const uint32_t LOOP_TYPE_RELEASE = 0x00000001;
|
|
|
|
uint32_t size;
|
|
uint32_t loopType;
|
|
uint32_t loopStart;
|
|
uint32_t loopLength;
|
|
};
|
|
|
|
struct RIFFDLSSample
|
|
{
|
|
static const uint32_t OPTIONS_NOTRUNCATION = 0x00000001;
|
|
static const uint32_t OPTIONS_NOCOMPRESSION = 0x00000002;
|
|
|
|
uint32_t size;
|
|
uint16_t unityNote;
|
|
int16_t fineTune;
|
|
int32_t gain;
|
|
uint32_t options;
|
|
uint32_t loopCount;
|
|
};
|
|
|
|
struct MIDILoop
|
|
{
|
|
static const uint32_t LOOP_TYPE_FORWARD = 0x00000000;
|
|
static const uint32_t LOOP_TYPE_ALTERNATING = 0x00000001;
|
|
static const uint32_t LOOP_TYPE_BACKWARD = 0x00000002;
|
|
|
|
uint32_t cuePointId;
|
|
uint32_t type;
|
|
uint32_t start;
|
|
uint32_t end;
|
|
uint32_t fraction;
|
|
uint32_t playCount;
|
|
};
|
|
|
|
struct RIFFMIDISample
|
|
{
|
|
uint32_t manufacturerId;
|
|
uint32_t productId;
|
|
uint32_t samplePeriod;
|
|
uint32_t unityNode;
|
|
uint32_t pitchFraction;
|
|
uint32_t SMPTEFormat;
|
|
uint32_t SMPTEOffset;
|
|
uint32_t loopCount;
|
|
uint32_t samplerData;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
static_assert(sizeof(RIFFChunk) == 8, "structure size mismatch");
|
|
static_assert(sizeof(RIFFChunkHeader) == 12, "structure size mismatch");
|
|
static_assert(sizeof(DLSLoop) == 16, "structure size mismatch");
|
|
static_assert(sizeof(RIFFDLSSample) == 20, "structure size mismatch");
|
|
static_assert(sizeof(MIDILoop) == 24, "structure size mismatch");
|
|
static_assert(sizeof(RIFFMIDISample) == 36, "structure size mismatch");
|
|
|
|
//---------------------------------------------------------------------------------
|
|
const RIFFChunk* FindChunk(
|
|
_In_reads_bytes_(sizeBytes) const uint8_t* data,
|
|
_In_ size_t sizeBytes,
|
|
_In_ uint32_t tag)
|
|
{
|
|
if (!data)
|
|
return nullptr;
|
|
|
|
const uint8_t* ptr = data;
|
|
const uint8_t* end = data + sizeBytes;
|
|
|
|
while (end > (ptr + sizeof(RIFFChunk)))
|
|
{
|
|
auto header = reinterpret_cast<const RIFFChunk*>(ptr);
|
|
if (header->tag == tag)
|
|
return header;
|
|
|
|
auto offset = header->size + sizeof(RIFFChunk);
|
|
ptr += offset;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
HRESULT WaveFindFormatAndData(
|
|
_In_reads_bytes_(wavDataSize) const uint8_t* wavData,
|
|
_In_ size_t wavDataSize,
|
|
_Outptr_ const WAVEFORMATEX** pwfx,
|
|
_Outptr_ const uint8_t** pdata,
|
|
_Out_ uint32_t* dataSize,
|
|
_Out_ bool& dpds,
|
|
_Out_ bool& seek)
|
|
{
|
|
if (!wavData || !pwfx)
|
|
return E_POINTER;
|
|
|
|
dpds = seek = false;
|
|
|
|
if (wavDataSize < (sizeof(RIFFChunk) * 2 + sizeof(uint32_t) + sizeof(WAVEFORMAT)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
const uint8_t* wavEnd = wavData + wavDataSize;
|
|
|
|
// Locate RIFF 'WAVE'
|
|
auto riffChunk = FindChunk(wavData, wavDataSize, FOURCC_RIFF_TAG);
|
|
if (!riffChunk || riffChunk->size < 4)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
auto riffHeader = reinterpret_cast<const RIFFChunkHeader*>(riffChunk);
|
|
if (riffHeader->riff != FOURCC_WAVE_FILE_TAG && riffHeader->riff != FOURCC_XWMA_FILE_TAG)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Locate 'fmt '
|
|
auto ptr = reinterpret_cast<const uint8_t*>(riffHeader) + sizeof(RIFFChunkHeader);
|
|
if ((ptr + sizeof(RIFFChunk)) > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
auto fmtChunk = FindChunk(ptr, riffHeader->size, FOURCC_FORMAT_TAG);
|
|
if (!fmtChunk || fmtChunk->size < sizeof(PCMWAVEFORMAT))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ptr = reinterpret_cast<const uint8_t*>(fmtChunk) + sizeof(RIFFChunk);
|
|
if (ptr + fmtChunk->size > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
auto wf = reinterpret_cast<const WAVEFORMAT*>(ptr);
|
|
|
|
// Validate WAVEFORMAT (focused on chunk size and format tag, not other data that XAUDIO2 will validate)
|
|
switch (wf->wFormatTag)
|
|
{
|
|
case WAVE_FORMAT_PCM:
|
|
case WAVE_FORMAT_IEEE_FLOAT:
|
|
// Can be a PCMWAVEFORMAT (16 bytes) or WAVEFORMATEX (18 bytes)
|
|
// We validiated chunk as at least sizeof(PCMWAVEFORMAT) above
|
|
break;
|
|
|
|
default:
|
|
{
|
|
if (fmtChunk->size < sizeof(WAVEFORMATEX))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
auto wfx = reinterpret_cast<const WAVEFORMATEX*>(ptr);
|
|
|
|
if (fmtChunk->size < (sizeof(WAVEFORMATEX) + wfx->cbSize))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
switch (wfx->wFormatTag)
|
|
{
|
|
case WAVE_FORMAT_WMAUDIO2:
|
|
case WAVE_FORMAT_WMAUDIO3:
|
|
dpds = true;
|
|
break;
|
|
|
|
case 0x166 /*WAVE_FORMAT_XMA2*/: // XMA2 is supported by Xbox One
|
|
if ((fmtChunk->size < 52 /*sizeof(XMA2WAVEFORMATEX)*/) || (wfx->cbSize < 34 /*( sizeof(XMA2WAVEFORMATEX) - sizeof(WAVEFORMATEX) )*/))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
seek = true;
|
|
break;
|
|
|
|
case WAVE_FORMAT_ADPCM:
|
|
if ((fmtChunk->size < (sizeof(WAVEFORMATEX) + 32)) || (wfx->cbSize < 32 /*MSADPCM_FORMAT_EXTRA_BYTES*/))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
break;
|
|
|
|
case WAVE_FORMAT_EXTENSIBLE:
|
|
if ((fmtChunk->size < sizeof(WAVEFORMATEXTENSIBLE)) || (wfx->cbSize < (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX))))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
static const GUID s_wfexBase = { 0x00000000, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 } };
|
|
|
|
auto wfex = reinterpret_cast<const WAVEFORMATEXTENSIBLE*>(ptr);
|
|
|
|
if (memcmp(reinterpret_cast<const BYTE*>(&wfex->SubFormat) + sizeof(DWORD),
|
|
reinterpret_cast<const BYTE*>(&s_wfexBase) + sizeof(DWORD), sizeof(GUID) - sizeof(DWORD)) != 0)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
switch (wfex->SubFormat.Data1)
|
|
{
|
|
case WAVE_FORMAT_PCM:
|
|
case WAVE_FORMAT_IEEE_FLOAT:
|
|
break;
|
|
|
|
// MS-ADPCM and XMA2 are not supported as WAVEFORMATEXTENSIBLE
|
|
|
|
case WAVE_FORMAT_WMAUDIO2:
|
|
case WAVE_FORMAT_WMAUDIO3:
|
|
dpds = true;
|
|
break;
|
|
|
|
default:
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Locate 'data'
|
|
ptr = reinterpret_cast<const uint8_t*>(riffHeader) + sizeof(RIFFChunkHeader);
|
|
if ((ptr + sizeof(RIFFChunk)) > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
auto dataChunk = FindChunk(ptr, riffChunk->size, FOURCC_DATA_TAG);
|
|
if (!dataChunk || !dataChunk->size)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
|
}
|
|
|
|
ptr = reinterpret_cast<const uint8_t*>(dataChunk) + sizeof(RIFFChunk);
|
|
if (ptr + dataChunk->size > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
*pwfx = reinterpret_cast<const WAVEFORMATEX*>(wf);
|
|
*pdata = ptr;
|
|
*dataSize = dataChunk->size;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
HRESULT WaveFindLoopInfo(
|
|
_In_reads_bytes_(wavDataSize) const uint8_t* wavData,
|
|
_In_ size_t wavDataSize,
|
|
_Out_ uint32_t* pLoopStart,
|
|
_Out_ uint32_t* pLoopLength)
|
|
{
|
|
if (!wavData || !pLoopStart || !pLoopLength)
|
|
return E_POINTER;
|
|
|
|
if (wavDataSize < (sizeof(RIFFChunk) + sizeof(uint32_t)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
*pLoopStart = 0;
|
|
*pLoopLength = 0;
|
|
|
|
const uint8_t* wavEnd = wavData + wavDataSize;
|
|
|
|
// Locate RIFF 'WAVE'
|
|
auto riffChunk = FindChunk(wavData, wavDataSize, FOURCC_RIFF_TAG);
|
|
if (!riffChunk || riffChunk->size < 4)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
auto riffHeader = reinterpret_cast<const RIFFChunkHeader*>(riffChunk);
|
|
if (riffHeader->riff == FOURCC_XWMA_FILE_TAG)
|
|
{
|
|
// xWMA files do not contain loop information
|
|
return S_OK;
|
|
}
|
|
|
|
if (riffHeader->riff != FOURCC_WAVE_FILE_TAG)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Locate 'wsmp' (DLS Chunk)
|
|
auto ptr = reinterpret_cast<const uint8_t*>(riffHeader) + sizeof(RIFFChunkHeader);
|
|
if ((ptr + sizeof(RIFFChunk)) > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
auto dlsChunk = FindChunk(ptr, riffChunk->size, FOURCC_DLS_SAMPLE);
|
|
if (dlsChunk)
|
|
{
|
|
ptr = reinterpret_cast<const uint8_t*>(dlsChunk) + sizeof(RIFFChunk);
|
|
if (ptr + dlsChunk->size > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
if (dlsChunk->size >= sizeof(RIFFDLSSample))
|
|
{
|
|
auto dlsSample = reinterpret_cast<const RIFFDLSSample*>(ptr);
|
|
|
|
if (dlsChunk->size >= (dlsSample->size + dlsSample->loopCount * sizeof(DLSLoop)))
|
|
{
|
|
auto loops = reinterpret_cast<const DLSLoop*>(ptr + dlsSample->size);
|
|
for (uint32_t j = 0; j < dlsSample->loopCount; ++j)
|
|
{
|
|
if ((loops[j].loopType == DLSLoop::LOOP_TYPE_FORWARD || loops[j].loopType == DLSLoop::LOOP_TYPE_RELEASE))
|
|
{
|
|
// Return 'forward' loop
|
|
*pLoopStart = loops[j].loopStart;
|
|
*pLoopLength = loops[j].loopLength;
|
|
return S_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Locate 'smpl' (Sample Chunk)
|
|
auto midiChunk = FindChunk(ptr, riffChunk->size, FOURCC_MIDI_SAMPLE);
|
|
if (midiChunk)
|
|
{
|
|
ptr = reinterpret_cast<const uint8_t*>(midiChunk) + sizeof(RIFFChunk);
|
|
if (ptr + midiChunk->size > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
if (midiChunk->size >= sizeof(RIFFMIDISample))
|
|
{
|
|
auto midiSample = reinterpret_cast<const RIFFMIDISample*>(ptr);
|
|
|
|
if (midiChunk->size >= (sizeof(RIFFMIDISample) + midiSample->loopCount * sizeof(MIDILoop)))
|
|
{
|
|
auto loops = reinterpret_cast<const MIDILoop*>(ptr + sizeof(RIFFMIDISample));
|
|
for (uint32_t j = 0; j < midiSample->loopCount; ++j)
|
|
{
|
|
if (loops[j].type == MIDILoop::LOOP_TYPE_FORWARD)
|
|
{
|
|
// Return 'forward' loop
|
|
*pLoopStart = loops[j].start;
|
|
*pLoopLength = loops[j].end + loops[j].start + 1;
|
|
return S_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
HRESULT WaveFindTable(
|
|
_In_reads_bytes_(wavDataSize) const uint8_t* wavData,
|
|
_In_ size_t wavDataSize,
|
|
_In_ uint32_t tag,
|
|
_Outptr_result_maybenull_ const uint32_t** pData,
|
|
_Out_ uint32_t* dataCount)
|
|
{
|
|
if (!wavData || !pData || !dataCount)
|
|
return E_POINTER;
|
|
|
|
if (wavDataSize < (sizeof(RIFFChunk) + sizeof(uint32_t)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
*pData = nullptr;
|
|
*dataCount = 0;
|
|
|
|
const uint8_t* wavEnd = wavData + wavDataSize;
|
|
|
|
// Locate RIFF 'WAVE'
|
|
auto riffChunk = FindChunk(wavData, wavDataSize, FOURCC_RIFF_TAG);
|
|
if (!riffChunk || riffChunk->size < 4)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
auto riffHeader = reinterpret_cast<const RIFFChunkHeader*>(riffChunk);
|
|
if (riffHeader->riff != FOURCC_WAVE_FILE_TAG && riffHeader->riff != FOURCC_XWMA_FILE_TAG)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Locate tag
|
|
auto ptr = reinterpret_cast<const uint8_t*>(riffHeader) + sizeof(RIFFChunkHeader);
|
|
if ((ptr + sizeof(RIFFChunk)) > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
auto tableChunk = FindChunk(ptr, riffChunk->size, tag);
|
|
if (tableChunk)
|
|
{
|
|
ptr = reinterpret_cast<const uint8_t*>(tableChunk) + sizeof(RIFFChunk);
|
|
if (ptr + tableChunk->size > wavEnd)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
|
|
}
|
|
|
|
if ((tableChunk->size % sizeof(uint32_t)) != 0)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
*pData = reinterpret_cast<const uint32_t*>(ptr);
|
|
*dataCount = tableChunk->size / 4;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
HRESULT LoadAudioFromFile(
|
|
_In_z_ const wchar_t* szFileName,
|
|
_Inout_ std::unique_ptr<uint8_t[]>& wavData,
|
|
_Out_ DWORD* bytesRead)
|
|
{
|
|
if (!szFileName)
|
|
return E_INVALIDARG;
|
|
|
|
// open the file
|
|
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
|
ScopedHandle hFile(safe_handle(CreateFile2(szFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
OPEN_EXISTING,
|
|
nullptr)));
|
|
#else
|
|
ScopedHandle hFile(safe_handle(CreateFileW(szFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
nullptr,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
nullptr)));
|
|
#endif
|
|
|
|
if (!hFile)
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
// Get the file size
|
|
FILE_STANDARD_INFO fileInfo;
|
|
if (!GetFileInformationByHandleEx(hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo)))
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
// File is too big for 32-bit allocation, so reject read
|
|
if (fileInfo.EndOfFile.HighPart > 0)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Need at least enough data to have a valid minimal WAV file
|
|
if (fileInfo.EndOfFile.LowPart < (sizeof(RIFFChunk) * 2 + sizeof(DWORD) + sizeof(WAVEFORMAT)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
// create enough space for the file data
|
|
wavData.reset(new (std::nothrow) uint8_t[fileInfo.EndOfFile.LowPart]);
|
|
if (!wavData)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// read the data in
|
|
if (!ReadFile(hFile.get(),
|
|
wavData.get(),
|
|
fileInfo.EndOfFile.LowPart,
|
|
bytesRead,
|
|
nullptr
|
|
))
|
|
{
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
return (*bytesRead < fileInfo.EndOfFile.LowPart) ? E_FAIL : S_OK;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
_Use_decl_annotations_
|
|
HRESULT DX::LoadWAVAudioInMemory(
|
|
const uint8_t* wavData,
|
|
size_t wavDataSize,
|
|
const WAVEFORMATEX** wfx,
|
|
const uint8_t** startAudio,
|
|
uint32_t* audioBytes)
|
|
{
|
|
if (!wavData || !wfx || !startAudio || !audioBytes)
|
|
return E_INVALIDARG;
|
|
|
|
*wfx = nullptr;
|
|
*startAudio = nullptr;
|
|
*audioBytes = 0;
|
|
|
|
// Need at least enough data to have a valid minimal WAV file
|
|
if (wavDataSize < (sizeof(RIFFChunk) * 2 + sizeof(DWORD) + sizeof(WAVEFORMAT)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
bool dpds, seek;
|
|
HRESULT hr = WaveFindFormatAndData(wavData, wavDataSize, wfx, startAudio, audioBytes, dpds, seek);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return (dpds || seek) ? E_FAIL : S_OK;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
_Use_decl_annotations_
|
|
HRESULT DX::LoadWAVAudioFromFile(
|
|
const wchar_t* szFileName,
|
|
std::unique_ptr<uint8_t[]>& wavData,
|
|
const WAVEFORMATEX** wfx,
|
|
const uint8_t** startAudio,
|
|
uint32_t* audioBytes)
|
|
{
|
|
if (!szFileName || !wfx || !startAudio || !audioBytes)
|
|
return E_INVALIDARG;
|
|
|
|
*wfx = nullptr;
|
|
*startAudio = nullptr;
|
|
*audioBytes = 0;
|
|
|
|
DWORD bytesRead = 0;
|
|
HRESULT hr = LoadAudioFromFile(szFileName, wavData, &bytesRead);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
bool dpds, seek;
|
|
hr = WaveFindFormatAndData(wavData.get(), bytesRead, wfx, startAudio, audioBytes, dpds, seek);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return (dpds || seek) ? E_FAIL : S_OK;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
_Use_decl_annotations_
|
|
HRESULT DX::LoadWAVAudioInMemoryEx(
|
|
const uint8_t* wavData,
|
|
size_t wavDataSize,
|
|
DX::WAVData& result)
|
|
{
|
|
if (!wavData)
|
|
return E_INVALIDARG;
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
|
|
// Need at least enough data to have a valid minimal WAV file
|
|
if (wavDataSize < (sizeof(RIFFChunk) * 2 + sizeof(DWORD) + sizeof(WAVEFORMAT)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
bool dpds, seek;
|
|
HRESULT hr = WaveFindFormatAndData(wavData, wavDataSize, &result.wfx, &result.startAudio, &result.audioBytes, dpds, seek);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = WaveFindLoopInfo(wavData, wavDataSize, &result.loopStart, &result.loopLength);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (dpds)
|
|
{
|
|
hr = WaveFindTable(wavData, wavDataSize, FOURCC_XWMA_DPDS, &result.seek, &result.seekCount);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
else if (seek)
|
|
{
|
|
hr = WaveFindTable(wavData, wavDataSize, FOURCC_XMA_SEEK, &result.seek, &result.seekCount);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
_Use_decl_annotations_
|
|
HRESULT DX::LoadWAVAudioFromFileEx(
|
|
const wchar_t* szFileName,
|
|
std::unique_ptr<uint8_t[]>& wavData,
|
|
DX::WAVData& result)
|
|
{
|
|
if (!szFileName)
|
|
return E_INVALIDARG;
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
|
|
DWORD bytesRead = 0;
|
|
HRESULT hr = LoadAudioFromFile(szFileName, wavData, &bytesRead);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
bool dpds, seek;
|
|
hr = WaveFindFormatAndData(wavData.get(), bytesRead, &result.wfx, &result.startAudio, &result.audioBytes, dpds, seek);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = WaveFindLoopInfo(wavData.get(), bytesRead, &result.loopStart, &result.loopLength);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (dpds)
|
|
{
|
|
hr = WaveFindTable(wavData.get(), bytesRead, FOURCC_XWMA_DPDS, &result.seek, &result.seekCount);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
else if (seek)
|
|
{
|
|
hr = WaveFindTable(wavData.get(), bytesRead, FOURCC_XMA_SEEK, &result.seek, &result.seekCount);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|