hipstercat/GiantsTools
1
0
Fork 0
mirror of https://github.com/ncblakely/GiantsTools synced 2024-11-22 22:25:37 +01:00
Code Issues Releases Wiki Activity
038b0a9d29
GiantsTools/Sdk/External/DirectXTK/XWBTool/xwbtool.cpp

1806 lines
63 KiB
C++
Raw Normal View History

Update to new SDK.
2021-01-24 00:40:09 +01:00
//--------------------------------------------------------------------------------------
// File: xwbtool.cpp
//
// Simple command-line tool for building wave banks from 1 or more .WAV files. This
// generates binary wave banks compliant with XACT 3's Wave Bank .XWB format. The
// .WAV files are not format converted or compressed.
//
// For a more full-featured builder, see XACT 3 and the XACTBLD tool in the legacy
// DirectX SDK (June 2010) release.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/?LinkId=248929
//--------------------------------------------------------------------------------------
#pragma warning(push)
#pragma warning(disable : 4005)
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#define NODRAWTEXT
#define NOGDI
#define NOBITMAP
#define NOMCX
#define NOSERVICE
#define NOHELP
#pragma warning(pop)
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <algorithm>
#include <fstream>
#include <list>
#include <memory>
#include <vector>
#include "WAVFileReader.h"
#ifdef __INTEL_COMPILER
#pragma warning(disable : 161)
// warning #161: unrecognized #pragma
#endif
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
(static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \
| (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \
| (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \
| (static_cast<uint32_t>(static_cast<uint8_t>(ch3)) << 24))
#endif /* defined(MAKEFOURCC) */
#ifndef WAVE_FORMAT_XMA2
#define WAVE_FORMAT_XMA2 0x166
#pragma pack(push,1)
struct XMA2WAVEFORMATEX
{
WAVEFORMATEX wfx;
// Meaning of the WAVEFORMATEX fields here:
// wFormatTag; // Audio format type; always WAVE_FORMAT_XMA2
// nChannels; // Channel count of the decoded audio
// nSamplesPerSec; // Sample rate of the decoded audio
// nAvgBytesPerSec; // Used internally by the XMA encoder
// nBlockAlign; // Decoded sample size; channels * wBitsPerSample / 8
// wBitsPerSample; // Bits per decoded mono sample; always 16 for XMA
// cbSize; // Size in bytes of the rest of this structure (34)
WORD NumStreams; // Number of audio streams (1 or 2 channels each)
DWORD ChannelMask; // Spatial positions of the channels in this file,
// stored as SPEAKER_xxx values (see audiodefs.h)
DWORD SamplesEncoded; // Total number of PCM samples per channel the file decodes to
DWORD BytesPerBlock; // XMA block size (but the last one may be shorter)
DWORD PlayBegin; // First valid sample in the decoded audio
DWORD PlayLength; // Length of the valid part of the decoded audio
DWORD LoopBegin; // Beginning of the loop region in decoded sample terms
DWORD LoopLength; // Length of the loop region in decoded sample terms
BYTE LoopCount; // Number of loop repetitions; 255 = infinite
BYTE EncoderVersion; // Version of XMA encoder that generated the file
WORD BlockCount; // XMA blocks in file (and entries in its seek table)
};
#pragma pack(pop)
#endif
static_assert(sizeof(XMA2WAVEFORMATEX) == 52, "Mismatch of XMA2 type");
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
namespace
{
struct handle_closer { void operator()(HANDLE h) { if (h) CloseHandle(h); } };
using ScopedHandle = std::unique_ptr<void, handle_closer>;
inline HANDLE safe_handle(HANDLE h) { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
struct find_closer { void operator()(HANDLE h) { assert(h != INVALID_HANDLE_VALUE); if (h) FindClose(h); } };
using ScopedFindHandle = std::unique_ptr<void, find_closer>;
#define BLOCKALIGNPAD(a, b) \
((((a) + ((b) - 1)) / (b)) * (b))
#define XACT_CONTENT_VERSION 46 // DirectX SDK (June 2010)
#pragma pack(push, 1)
static const size_t DVD_SECTOR_SIZE = 2048;
static const size_t ALIGNMENT_MIN = 4;
static const size_t ALIGNMENT_DVD = DVD_SECTOR_SIZE;
static const size_t MAX_COMPACT_DATA_SEGMENT_SIZE = 0x001FFFFF;
static const size_t ENTRYNAME_LENGTH = 64;
struct REGION
{
uint32_t dwOffset; // Region offset, in bytes.
uint32_t dwLength; // Region length, in bytes.
};
struct SAMPLEREGION
{
uint32_t dwStartSample; // Start sample for the region.
uint32_t dwTotalSamples; // Region length in samples.
};
struct HEADER
{
static const uint32_t SIGNATURE = MAKEFOURCC('W', 'B', 'N', 'D');
static const uint32_t VERSION = 44;
enum SEGIDX
{
SEGIDX_BANKDATA = 0, // Bank data
SEGIDX_ENTRYMETADATA, // Entry meta-data
SEGIDX_SEEKTABLES, // Storage for seek tables for the encoded waves.
SEGIDX_ENTRYNAMES, // Entry friendly names
SEGIDX_ENTRYWAVEDATA, // Entry wave data
SEGIDX_COUNT
};
uint32_t dwSignature; // File signature
uint32_t dwVersion; // Version of the tool that created the file
uint32_t dwHeaderVersion; // Version of the file format
REGION Segments[SEGIDX_COUNT]; // Segment lookup table
};
#pragma warning( disable : 4201 4203 )
union MINIWAVEFORMAT
{
static const uint32_t TAG_PCM = 0x0;
static const uint32_t TAG_XMA = 0x1;
static const uint32_t TAG_ADPCM = 0x2;
static const uint32_t TAG_WMA = 0x3;
static const uint32_t BITDEPTH_8 = 0x0; // PCM only
static const uint32_t BITDEPTH_16 = 0x1; // PCM only
static const size_t ADPCM_BLOCKALIGN_CONVERSION_OFFSET = 22;
struct
{
uint32_t wFormatTag : 2; // Format tag
uint32_t nChannels : 3; // Channel count (1 - 6)
uint32_t nSamplesPerSec : 18; // Sampling rate
uint32_t wBlockAlign : 8; // Block alignment. For WMA, lower 6 bits block alignment index, upper 2 bits bytes-per-second index.
uint32_t wBitsPerSample : 1; // Bits per sample (8 vs. 16, PCM only); WMAudio2/WMAudio3 (for WMA)
};
uint32_t dwValue;
};
struct ENTRY
{
static const uint32_t FLAGS_READAHEAD = 0x00000001; // Enable stream read-ahead
static const uint32_t FLAGS_LOOPCACHE = 0x00000002; // One or more looping sounds use this wave
static const uint32_t FLAGS_REMOVELOOPTAIL = 0x00000004;// Remove data after the end of the loop region
static const uint32_t FLAGS_IGNORELOOP = 0x00000008; // Used internally when the loop region can't be used
static const uint32_t FLAGS_MASK = 0x00000008;
union
{
struct
{
// Entry flags
uint32_t dwFlags : 4;
// Duration of the wave, in units of one sample.
// For instance, a ten second long wave sampled
// at 48KHz would have a duration of 480,000.
// This value is not affected by the number of
// channels, the number of bits per sample, or the
// compression format of the wave.
uint32_t Duration : 28;
};
uint32_t dwFlagsAndDuration;
};
MINIWAVEFORMAT Format; // Entry format.
REGION PlayRegion; // Region within the wave data segment that contains this entry.
SAMPLEREGION LoopRegion; // Region within the wave data (in samples) that should loop.
};
struct ENTRYCOMPACT
{
uint32_t dwOffset : 21; // Data offset, in multiplies of the bank alignment
uint32_t dwLengthDeviation : 11; // Data length deviation, in bytes
};
struct BANKDATA
{
static const size_t BANKNAME_LENGTH = 64;
static const uint32_t TYPE_BUFFER = 0x00000000;
static const uint32_t TYPE_STREAMING = 0x00000001;
static const uint32_t TYPE_MASK = 0x00000001;
static const uint32_t FLAGS_ENTRYNAMES = 0x00010000;
static const uint32_t FLAGS_COMPACT = 0x00020000;
static const uint32_t FLAGS_SYNC_DISABLED = 0x00040000;
static const uint32_t FLAGS_SEEKTABLES = 0x00080000;
static const uint32_t FLAGS_MASK = 0x000F0000;
uint32_t dwFlags; // Bank flags
uint32_t dwEntryCount; // Number of entries in the bank
char szBankName[BANKNAME_LENGTH]; // Bank friendly name
uint32_t dwEntryMetaDataElementSize; // Size of each entry meta-data element, in bytes
uint32_t dwEntryNameElementSize; // Size of each entry name element, in bytes
uint32_t dwAlignment; // Entry alignment, in bytes
MINIWAVEFORMAT CompactFormat; // Format data for compact bank
FILETIME BuildTime; // Build timestamp
};
#pragma pack(pop)
static_assert(sizeof(REGION) == 8, "Mismatch with xact3wb.h");
static_assert(sizeof(SAMPLEREGION) == 8, "Mismatch with xact3wb.h");
static_assert(sizeof(HEADER) == 52, "Mismatch with xact3wb.h");
static_assert(sizeof(ENTRY) == 24, "Mismatch with xact3wb.h");
static_assert(sizeof(MINIWAVEFORMAT) == 4, "Mismatch with xact3wb.h");
static_assert(sizeof(ENTRY) == 24, "Mismatch with xact3wb.h");
static_assert(sizeof(ENTRYCOMPACT) == 4, "Mismatch with xact3wb.h");
static_assert(sizeof(BANKDATA) == 96, "Mismatch with xact3wb.h");
template <typename T> WORD ChannelsSpecifiedInMask(T x)
{
WORD bitCount = 0;
while (x) { ++bitCount; x &= (x - 1); }
return bitCount;
}
WORD AdpcmBlockSizeFromPcmFrames(WORD nPcmFrames, WORD nChannels)
{
// The full calculation is as follows:
// UINT uHeaderBytes = MSADPCM_HEADER_LENGTH * nChannels;
// UINT uBitsPerSample = MSADPCM_BITS_PER_SAMPLE * nChannels;
// UINT uBlockAlign = uHeaderBytes + (nPcmFrames - 2) * uBitsPerSample / 8;
// return WORD(uBlockAlign);
assert(nChannels == 1 || nChannels == 2);
if (nPcmFrames)
{
if (nChannels == 1)
{
assert(nPcmFrames % 2 == 0); // Mono data needs even nPcmFrames
return WORD(nPcmFrames / 2 + 6);
}
else
{
return WORD(nPcmFrames + 12);
}
}
else
{
return 0;
}
}
DWORD EncodeWMABlockAlign(DWORD dwBlockAlign, DWORD dwAvgBytesPerSec)
{
static const uint32_t aWMABlockAlign[] =
{
929,
1487,
1280,
2230,
8917,
8192,
4459,
5945,
2304,
1536,
1485,
1008,
2731,
4096,
6827,
5462,
1280
};
static const uint32_t aWMAAvgBytesPerSec[] =
{
12000,
24000,
4000,
6000,
8000,
20000,
2500
};
auto bit = std::find(std::begin(aWMABlockAlign), std::end(aWMABlockAlign), dwBlockAlign);
if (bit == std::end(aWMABlockAlign))
return DWORD(-1);
DWORD blockAlignIndex = DWORD(bit - std::begin(aWMABlockAlign));
auto ait = std::find(std::begin(aWMAAvgBytesPerSec), std::end(aWMAAvgBytesPerSec), dwAvgBytesPerSec);
if (ait == std::end(aWMAAvgBytesPerSec))
return DWORD(-1);
DWORD bytesPerSecIndex = DWORD(ait - std::begin(aWMAAvgBytesPerSec));
return DWORD(blockAlignIndex | (bytesPerSecIndex << 5));
}
bool ConvertToMiniFormat(const WAVEFORMATEX* wfx, bool hasSeek, MINIWAVEFORMAT& miniFmt)
{
if (!wfx)
return false;
if (!wfx->nChannels)
{
wprintf(L"ERROR: Wave bank entry must have at least 1 channel\n");
return false;
}
if (wfx->nChannels > 7)
{
wprintf(L"ERROR: Wave banks only support up to 7 channels\n");
return false;
}
if (!wfx->nSamplesPerSec)
{
wprintf(L"ERROR: Wave banks entry sample rate must be non-zero\n");
return false;
}
if (wfx->nSamplesPerSec > 262143)
{
wprintf(L"ERROR: Wave banks only support sample rates up to 2^18 (262143)\n");
return false;
}
miniFmt.dwValue = 0;
miniFmt.nSamplesPerSec = wfx->nSamplesPerSec;
miniFmt.nChannels = wfx->nChannels;
switch (wfx->wFormatTag)
{
case WAVE_FORMAT_PCM:
if ((wfx->wBitsPerSample != 8) && (wfx->wBitsPerSample != 16))
{
wprintf(L"ERROR: Wave banks only support 8-bit or 16-bit integer PCM data\n");
return false;
}
if (wfx->nBlockAlign > 255)
{
wprintf(L"ERROR: Wave banks only support block alignments up to 255 (%u)\n", wfx->nBlockAlign);
return false;
}
if (wfx->nBlockAlign != (wfx->nChannels * wfx->wBitsPerSample / 8))
{
wprintf(L"ERROR: nBlockAlign (%u) != nChannels (%u) * wBitsPerSample (%u) / 8\n",
wfx->nBlockAlign, wfx->nChannels, wfx->wBitsPerSample);
return false;
}
if (wfx->nAvgBytesPerSec != (wfx->nSamplesPerSec * wfx->nBlockAlign))
{
wprintf(L"ERROR: nAvgBytesPerSec (%lu) != nSamplesPerSec (%lu) * nBlockAlign (%u)\n",
wfx->nAvgBytesPerSec, wfx->nSamplesPerSec, wfx->nBlockAlign);
return false;
}
miniFmt.wFormatTag = MINIWAVEFORMAT::TAG_PCM;
miniFmt.wBitsPerSample = (wfx->wBitsPerSample == 16) ? MINIWAVEFORMAT::BITDEPTH_16 : MINIWAVEFORMAT::BITDEPTH_8;
miniFmt.wBlockAlign = wfx->nBlockAlign;
return true;
case WAVE_FORMAT_IEEE_FLOAT:
wprintf(L"ERROR: Wave banks do not support IEEE float PCM data\n");
return false;
case WAVE_FORMAT_ADPCM:
if ((wfx->nChannels != 1) && (wfx->nChannels != 2))
{
wprintf(L"ERROR: ADPCM wave format must have 1 or 2 channels (not %u)\n", wfx->nChannels);
return false;
}
if (wfx->wBitsPerSample != 4 /*MSADPCM_BITS_PER_SAMPLE*/)
{
wprintf(L"ERROR: ADPCM wave format must have 4 bits per sample (not %u)\n", wfx->wBitsPerSample);
return false;
}
if (wfx->cbSize != 32 /*MSADPCM_FORMAT_EXTRA_BYTES*/)
{
wprintf(L"ERROR: ADPCM wave format must have cbSize = 32 (not %u)\n", wfx->cbSize);
return false;
}
else
{
auto wfadpcm = reinterpret_cast<const ADPCMWAVEFORMAT*>(wfx);
if (wfadpcm->wNumCoef != 7 /*MSADPCM_NUM_COEFFICIENTS*/)
{
wprintf(L"ERROR: ADPCM wave format must have 7 coefficients (not %u)\n", wfadpcm->wNumCoef);
return false;
}
bool valid = true;
for (int j = 0; j < 7 /*MSADPCM_NUM_COEFFICIENTS*/; ++j)
{
// Microsoft ADPCM standard encoding coefficients
static const short g_pAdpcmCoefficients1[] = { 256, 512, 0, 192, 240, 460, 392 };
static const short g_pAdpcmCoefficients2[] = { 0, -256, 0, 64, 0, -208, -232 };
if (wfadpcm->aCoef[j].iCoef1 != g_pAdpcmCoefficients1[j]
|| wfadpcm->aCoef[j].iCoef2 != g_pAdpcmCoefficients2[j])
{
valid = false;
}
}
if (!valid)
{
wprintf(L"ERROR: Non-standard coefficients for ADPCM found\n");
return false;
}
if ((wfadpcm->wSamplesPerBlock < 4 /*MSADPCM_MIN_SAMPLES_PER_BLOCK*/)
|| (wfadpcm->wSamplesPerBlock > 64000 /*MSADPCM_MAX_SAMPLES_PER_BLOCK*/))
{
wprintf(L"ERROR: ADPCM wave format wSamplesPerBlock must be 4..64000\n");
return false;
}
if (wfadpcm->wfx.nChannels == 1 && (wfadpcm->wSamplesPerBlock % 2))
{
wprintf(L"ERROR: ADPCM wave format mono files must have even wSamplesPerBlock\n");
return false;
}
unsigned int nHeaderBytes = 7 /*MSADPCM_HEADER_LENGTH*/ * wfx->nChannels;
unsigned int nBitsPerFrame = 4 /*MSADPCM_BITS_PER_SAMPLE*/ * wfx->nChannels;
unsigned int nPcmFramesPerBlock = (wfx->nBlockAlign - nHeaderBytes) * 8 / nBitsPerFrame + 2;
if (wfadpcm->wSamplesPerBlock != nPcmFramesPerBlock)
{
wprintf(L"ERROR: ADPCM %u-channel format with nBlockAlign = %u must have wSamplesPerBlock = %u (not %u)\n",
wfx->nChannels, wfx->nBlockAlign, nPcmFramesPerBlock, wfadpcm->wSamplesPerBlock);
return false;
}
miniFmt.wFormatTag = MINIWAVEFORMAT::TAG_ADPCM;
miniFmt.wBitsPerSample = 0;
miniFmt.wBlockAlign = AdpcmBlockSizeFromPcmFrames(wfadpcm->wSamplesPerBlock, 1) - MINIWAVEFORMAT::ADPCM_BLOCKALIGN_CONVERSION_OFFSET;
}
return true;
case WAVE_FORMAT_WMAUDIO2:
case WAVE_FORMAT_WMAUDIO3:
if (!hasSeek)
{
wprintf(L"ERROR: xWMA requires seek tables ('dpds' chunk)\n");
return false;
}
if (wfx->wBitsPerSample != 16)
{
wprintf(L"ERROR: Wave banks only support 16-bit xWMA data\n");
return false;
}
if (!wfx->nBlockAlign)
{
wprintf(L"ERROR: Wave bank xWMA must have a non-zero nBlockAlign\n");
return false;
}
if (!wfx->nAvgBytesPerSec)
{
wprintf(L"ERROR: Wave bank xWMA must have a non-zero nAvgBytesPerSec\n");
return false;
}
if (wfx->cbSize != 0)
{
wprintf(L"ERROR: Unexpected data found in xWMA header\n");
return false;
}
miniFmt.wFormatTag = MINIWAVEFORMAT::TAG_WMA;
miniFmt.wBitsPerSample = (wfx->wFormatTag == WAVE_FORMAT_WMAUDIO3) ? MINIWAVEFORMAT::BITDEPTH_16 : MINIWAVEFORMAT::BITDEPTH_8;
{
DWORD blockAlign = EncodeWMABlockAlign(wfx->nBlockAlign, wfx->nAvgBytesPerSec);
if (blockAlign == DWORD(-1))
{
wprintf(L"ERROR: Failed encoding nBlockAlign and nAvgBytesPerSec for xWMA\n");
return false;
}
miniFmt.wBlockAlign = blockAlign;
}
return true;
case WAVE_FORMAT_XMA2:
if (!hasSeek)
{
wprintf(L"ERROR: XMA2 requires seek tables ('seek' chunk)\n");
return false;
}
if (wfx->nBlockAlign != wfx->nChannels * 2 /*XMA_OUTPUT_SAMPLE_BYTES*/)
{
wprintf(L"ERROR: XMA2 nBlockAlign (%u) != nChannels(%u) * 2\n", wfx->nBlockAlign, wfx->nChannels);
return false;
}
if (wfx->wBitsPerSample != 16 /*XMA_OUTPUT_SAMPLE_BITS*/)
{
wprintf(L"ERROR: XMA2 wBitsPerSample (%u) should be 16\n", wfx->wBitsPerSample);
return false;
}
if (wfx->cbSize != (sizeof(XMA2WAVEFORMATEX) - sizeof(WAVEFORMATEX)))
{
wprintf(L"ERROR: XMA2 cbSize must be %zu (%u)", (sizeof(XMA2WAVEFORMATEX) - sizeof(WAVEFORMATEX)), wfx->cbSize);
return false;
}
else
{
auto xmaFmt = reinterpret_cast<const XMA2WAVEFORMATEX*>(wfx);
if (xmaFmt->EncoderVersion < 3)
{
wprintf(L"ERROR: XMA2 encoder version (%u) - 3 or higher is required", xmaFmt->EncoderVersion);
return false;
}
if (!xmaFmt->BlockCount)
{
wprintf(L"ERROR: XMA2 BlockCount must be non-zero\n");
return false;
}
if (!xmaFmt->BytesPerBlock || (xmaFmt->BytesPerBlock > 8386560 /*XMA_READBUFFER_MAX_BYTES*/))
{
wprintf(L"ERROR: XMA2 BytesPerBlock (%lu) is invalid\n", xmaFmt->BytesPerBlock);
return false;
}
if (xmaFmt->ChannelMask)
{
auto channelBits = ChannelsSpecifiedInMask(xmaFmt->ChannelMask);
if (channelBits != wfx->nChannels)
{
wprintf(L"ERROR: XMA2 nChannels=%lu but ChannelMask (%08X) has %u bits set\n",
xmaFmt->ChannelMask, wfx->nChannels, channelBits);
return false;
}
}
if (xmaFmt->NumStreams != ((wfx->nChannels + 1) / 2))
{
wprintf(L"ERROR: XMA2 NumStreams (%u) != ( nChannels(%u) + 1 ) / 2\n", xmaFmt->NumStreams, wfx->nChannels);
return false;
}
if (!xmaFmt->SamplesEncoded)
{
wprintf(L"ERROR: XMA2 SamplesEncoded must be non-zero\n");
return false;
}
if ((xmaFmt->PlayBegin + xmaFmt->PlayLength) > xmaFmt->SamplesEncoded)
{
wprintf(L"ERROR: XMA2 play region too large (%lu + %lu > %lu)", xmaFmt->PlayBegin, xmaFmt->PlayLength, xmaFmt->SamplesEncoded);
return false;
}
if ((xmaFmt->LoopBegin + xmaFmt->LoopLength) > xmaFmt->SamplesEncoded)
{
wprintf(L"ERROR: XMA2 loop region too large (%lu + %lu > %lu)", xmaFmt->LoopBegin, xmaFmt->LoopLength, xmaFmt->SamplesEncoded);
return false;
}
miniFmt.wFormatTag = MINIWAVEFORMAT::TAG_XMA;
miniFmt.wBlockAlign = 2 * wfx->nChannels;
miniFmt.wBitsPerSample = MINIWAVEFORMAT::BITDEPTH_16;
}
return true;
case WAVE_FORMAT_EXTENSIBLE:
if (wfx->cbSize < (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
{
wprintf(L"ERROR: WAVEFORMATEXTENSIBLE cbSize must be at least %zu (%u)", (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)), wfx->cbSize);
return false;
}
else
{
static const GUID s_wfexBase = { 0x00000000, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 } };
auto wfex = reinterpret_cast<const WAVEFORMATEXTENSIBLE*>(wfx);
if (memcmp(reinterpret_cast<const BYTE*>(&wfex->SubFormat) + sizeof(DWORD),
reinterpret_cast<const BYTE*>(&s_wfexBase) + sizeof(DWORD), sizeof(GUID) - sizeof(DWORD)) != 0)
{
wprintf(L"ERROR: WAVEFORMATEXTENSIBLE encountered with unknown GUID ({%8.8lX-%4.4X-%4.4X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X})\n",
wfex->SubFormat.Data1, wfex->SubFormat.Data2, wfex->SubFormat.Data3,
wfex->SubFormat.Data4[0], wfex->SubFormat.Data4[1], wfex->SubFormat.Data4[2], wfex->SubFormat.Data4[3],
wfex->SubFormat.Data4[4], wfex->SubFormat.Data4[5], wfex->SubFormat.Data4[6], wfex->SubFormat.Data4[7]);
return false;
}
switch (wfex->SubFormat.Data1)
{
case WAVE_FORMAT_PCM:
if ((wfx->wBitsPerSample != 8) && (wfx->wBitsPerSample != 16))
{
wprintf(L"ERROR: Wave banks only support 8-bit or 16-bit integer PCM data (%u)\n", wfx->wBitsPerSample);
return false;
}
if (!wfex->Samples.wValidBitsPerSample)
{
wprintf(L"WARNING: Integer PCM WAVEFORMATEXTENSIBLE format should not have wValidBitsPerSample = 0\n");
}
else if (((wfex->Samples.wValidBitsPerSample != 8) && (wfex->Samples.wValidBitsPerSample != 16))
|| (wfex->Samples.wValidBitsPerSample > wfx->wBitsPerSample))
{
wprintf(L"ERROR: Unexpected wValidBitsPerSample value (%u)\n", wfex->Samples.wValidBitsPerSample);
return false;
}
if (wfx->nBlockAlign > 255)
{
wprintf(L"ERROR: Wave banks only support block alignments up to 255 (%u)\n", wfx->nBlockAlign);
return false;
}
if (wfx->nBlockAlign != (wfx->nChannels * wfx->wBitsPerSample / 8))
{
wprintf(L"ERROR: nBlockAlign (%u) != nChannels (%u) * wBitsPerSample (%u) / 8\n",
wfx->nBlockAlign, wfx->nChannels, wfx->wBitsPerSample);
return false;
}
if (wfx->nAvgBytesPerSec != (wfx->nSamplesPerSec * wfx->nBlockAlign))
{
wprintf(L"ERROR: nAvgBytesPerSec (%lu) != nSamplesPerSec (%lu) * nBlockAlign (%u)\n",
wfx->nAvgBytesPerSec, wfx->nSamplesPerSec, wfx->nBlockAlign);
return false;
}
miniFmt.wFormatTag = MINIWAVEFORMAT::TAG_PCM;
miniFmt.wBitsPerSample = (wfex->Samples.wValidBitsPerSample == 16) ? MINIWAVEFORMAT::BITDEPTH_16 : MINIWAVEFORMAT::BITDEPTH_8;
miniFmt.wBlockAlign = wfx->nBlockAlign;
break;
case WAVE_FORMAT_IEEE_FLOAT:
wprintf(L"ERROR: Wave banks do not support float PCM data\n");
return false;
case WAVE_FORMAT_ADPCM:
wprintf(L"ERROR: ADPCM is not supported as a WAVEFORMATEXTENSIBLE\n");
return false;
case WAVE_FORMAT_WMAUDIO2:
case WAVE_FORMAT_WMAUDIO3:
if (!hasSeek)
{
wprintf(L"ERROR: xWMA requires seek tables (dpds chunk)\n");
return false;
}
if (wfx->wBitsPerSample != 16)
{
wprintf(L"ERROR: Wave banks only support 16-bit xWMA data\n");
return false;
}
if (!wfx->nBlockAlign)
{
wprintf(L"ERROR: Wvae bank xWMA must have a non-zero nBlockAlign\n");
return false;
}
if (!wfx->nAvgBytesPerSec)
{
wprintf(L"ERROR: Wave bank xWMA must have a non-zero nAvgBytesPerSec\n");
return false;
}
miniFmt.wFormatTag = MINIWAVEFORMAT::TAG_WMA;
miniFmt.wBitsPerSample = (wfx->wFormatTag == WAVE_FORMAT_WMAUDIO3) ? MINIWAVEFORMAT::BITDEPTH_16 : MINIWAVEFORMAT::BITDEPTH_8;
{
DWORD blockAlign = EncodeWMABlockAlign(wfx->nBlockAlign, wfx->nAvgBytesPerSec);
if (blockAlign == DWORD(-1))
{
wprintf(L"ERROR: Failed encoding nBlockAlign and nAvgBytesPerSec for xWMA\n");
return false;
}
miniFmt.wBlockAlign = blockAlign;
}
break;
case WAVE_FORMAT_XMA2:
wprintf(L"ERROR: XMA2 is not supported as a WAVEFORMATEXTENSIBLE\n");
return false;
default:
wprintf(L"ERROR: Unknown WAVEFORMATEXTENSIBLE format tag\n");
return false;
}
if (wfex->dwChannelMask)
{
auto channelBits = ChannelsSpecifiedInMask(wfex->dwChannelMask);
if (channelBits != wfx->nChannels)
{
wprintf(L"ERROR: WAVEFORMATEXTENSIBLE: nChannels=%u but ChannelMask has %u bits set\n",
wfx->nChannels, channelBits);
return false;
}
else
{
wprintf(L"WARNING: WAVEFORMATEXTENSIBLE ChannelMask is ignored in wave banks\n");
}
}
return true;
}
default:
return false;
}
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
enum OPTIONS
{
OPT_RECURSIVE = 1,
OPT_STREAMING,
OPT_OUTPUTFILE,
OPT_OUTPUTHEADER,
OPT_TOLOWER,
OPT_OVERWRITE,
OPT_COMPACT,
OPT_NOCOMPACT,
OPT_FRIENDLY_NAMES,
OPT_NOLOGO,
OPT_FILELIST,
OPT_MAX
};
static_assert(OPT_MAX <= 32, "dwOptions is a DWORD bitfield");
struct SConversion
{
wchar_t szSrc[MAX_PATH];
};
struct SValue
{
LPCWSTR pName;
DWORD dwValue;
};
struct WaveFile
{
DirectX::WAVData data;
size_t conv;
MINIWAVEFORMAT miniFmt;
std::unique_ptr<uint8_t[]> waveData;
WaveFile() noexcept :
data{},
conv(0),
miniFmt{}
{}
WaveFile(WaveFile&) = delete;
WaveFile& operator= (WaveFile&) = delete;
WaveFile(WaveFile&&) = default;
WaveFile& operator= (WaveFile&&) = default;
};
namespace
{
void FileNameToIdentifier(_Inout_updates_all_(count) wchar_t* str, size_t count)
{
size_t j = 0;
for (wchar_t* c = str; j < count && *c != 0; ++c, ++j)
{
wchar_t t = towupper(*c);
if (!iswdigit(t) && !iswalpha(t))
t = '_';
*c = t;
}
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
const SValue g_pOptions[] =
{
{ L"r", OPT_RECURSIVE },
{ L"s", OPT_STREAMING },
{ L"o", OPT_OUTPUTFILE },
{ L"l", OPT_TOLOWER },
{ L"h", OPT_OUTPUTHEADER },
{ L"y", OPT_OVERWRITE },
{ L"c", OPT_COMPACT },
{ L"nc", OPT_NOCOMPACT },
{ L"f", OPT_FRIENDLY_NAMES },
{ L"nologo", OPT_NOLOGO },
{ L"flist", OPT_FILELIST },
{ nullptr, 0 }
};
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
namespace
{
#ifdef _PREFAST_
#pragma prefast(disable : 26018, "Only used with static internal arrays")
#endif
DWORD LookupByName(const wchar_t *pName, const SValue *pArray)
{
while (pArray->pName)
{
if (!_wcsicmp(pName, pArray->pName))
return pArray->dwValue;
pArray++;
}
return 0;
}
void SearchForFiles(const wchar_t* path, std::list<SConversion>& files, bool recursive)
{
// Process files
WIN32_FIND_DATAW findData = {};
ScopedFindHandle hFile(safe_handle(FindFirstFileExW(path,
FindExInfoBasic, &findData,
FindExSearchNameMatch, nullptr,
FIND_FIRST_EX_LARGE_FETCH)));
if (hFile)
{
for (;;)
{
if (!(findData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY)))
{
wchar_t drive[_MAX_DRIVE] = {};
wchar_t dir[_MAX_DIR] = {};
_wsplitpath_s(path, drive, _MAX_DRIVE, dir, _MAX_DIR, nullptr, 0, nullptr, 0);
SConversion conv;
_wmakepath_s(conv.szSrc, drive, dir, findData.cFileName, nullptr);
files.push_back(conv);
}
if (!FindNextFileW(hFile.get(), &findData))
break;
}
}
// Process directories
if (recursive)
{
wchar_t searchDir[MAX_PATH] = {};
{
wchar_t drive[_MAX_DRIVE] = {};
wchar_t dir[_MAX_DIR] = {};
_wsplitpath_s(path, drive, _MAX_DRIVE, dir, _MAX_DIR, nullptr, 0, nullptr, 0);
_wmakepath_s(searchDir, drive, dir, L"*", nullptr);
}
hFile.reset(safe_handle(FindFirstFileExW(searchDir,
FindExInfoBasic, &findData,
FindExSearchLimitToDirectories, nullptr,
FIND_FIRST_EX_LARGE_FETCH)));
if (!hFile)
return;
for (;;)
{
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (findData.cFileName[0] != L'.')
{
wchar_t subdir[MAX_PATH] = {};
{
wchar_t drive[_MAX_DRIVE] = {};
wchar_t dir[_MAX_DIR] = {};
wchar_t fname[_MAX_FNAME] = {};
wchar_t ext[_MAX_FNAME] = {};
_wsplitpath_s(path, drive, dir, fname, ext);
wcscat_s(dir, findData.cFileName);
_wmakepath_s(subdir, drive, dir, fname, ext);
}
SearchForFiles(subdir, files, recursive);
}
}
if (!FindNextFileW(hFile.get(), &findData))
break;
}
}
}
void PrintLogo()
{
wchar_t version[32] = {};
wchar_t appName[_MAX_PATH] = {};
if (GetModuleFileNameW(nullptr, appName, _countof(appName)))
{
DWORD size = GetFileVersionInfoSizeW(appName, nullptr);
if (size > 0)
{
auto verInfo = std::make_unique<uint8_t[]>(size);
if (GetFileVersionInfoW(appName, 0, size, verInfo.get()))
{
LPVOID lpstr = nullptr;
UINT strLen = 0;
if (VerQueryValueW(verInfo.get(), L"\\StringFileInfo\\040904B0\\ProductVersion", &lpstr, &strLen))
{
wcsncpy_s(version, reinterpret_cast<const wchar_t*>(lpstr), strLen);
}
}
}
}
if (!*version)
{
wcscpy_s(version, L"MISSING");
}
wprintf(L"Microsoft (R) XACT-style Wave Bank Tool [DirectXTK] Version %ls\n", version);
wprintf(L"Copyright (C) Microsoft Corp. All rights reserved.\n");
#ifdef _DEBUG
wprintf(L"*** Debug build ***\n");
#endif
wprintf(L"\n");
}
void PrintUsage()
{
PrintLogo();
wprintf(L"Usage: xwbtool <options> <wav-files>\n");
wprintf(L"\n");
wprintf(L" -r wildcard filename search is recursive\n");
wprintf(L" -s creates a streaming wave bank,\n");
wprintf(L" otherwise an in-memory bank is created\n");
wprintf(L" -o <filename> output filename\n");
wprintf(L" -h <h-filename> output C/C++ header\n");
wprintf(L" -l force output filename to lower case\n");
wprintf(L" -y overwrite existing output file (if any)\n");
wprintf(L" -c force creation of compact wavebank\n");
wprintf(L" -nc force creation of non-compact wavebank\n");
wprintf(L" -f include entry friendly names\n");
wprintf(L" -nologo suppress copyright message\n");
wprintf(L" -flist <filename> use text file with a list of input files (one per line)\n");
}
const char* GetFormatTagName(WORD wFormatTag)
{
switch (wFormatTag)
{
case WAVE_FORMAT_PCM: return "PCM";
case WAVE_FORMAT_ADPCM: return "MS ADPCM";
case WAVE_FORMAT_EXTENSIBLE: return "EXTENSIBLE";
case WAVE_FORMAT_IEEE_FLOAT: return "IEEE float";
case WAVE_FORMAT_MPEGLAYER3: return "ISO/MPEG Layer3";
case WAVE_FORMAT_DOLBY_AC3_SPDIF: return "Dolby Audio Codec 3 over S/PDIF";
case WAVE_FORMAT_WMAUDIO2: return "Windows Media Audio";
case WAVE_FORMAT_WMAUDIO3: return "Windows Media Audio Pro";
case WAVE_FORMAT_WMASPDIF: return "Windows Media Audio over S/PDIF";
case 0x165: /*WAVE_FORMAT_XMA*/ return "Xbox XMA";
case 0x166: /*WAVE_FORMAT_XMA2*/ return "Xbox XMA2";
default: return "*UNKNOWN*";
}
}
const char *ChannelDesc(DWORD dwChannelMask)
{
switch (dwChannelMask)
{
case 0x00000004 /*SPEAKER_MONO*/: return "Mono";
case 0x00000003 /* SPEAKER_STEREO */: return "Stereo";
case 0x0000000B /* SPEAKER_2POINT1 */: return "2.1";
case 0x00000107 /* SPEAKER_SURROUND */: return "Surround";
case 0x00000033 /* SPEAKER_QUAD */: return "Quad";
case 0x0000003B /* SPEAKER_4POINT1 */: return "4.1";
case 0x0000003F /* SPEAKER_5POINT1 */: return "5.1";
case 0x000000FF /* SPEAKER_7POINT1 */: return "7.1";
case 0x0000060F /* SPEAKER_5POINT1_SURROUND */: return "Surround5.1";
case 0x0000063F /* SPEAKER_7POINT1_SURROUND */: return "Surround7.1";
default: return "Custom";
}
}
void PrintInfo(const WaveFile& wave)
{
if (wave.data.wfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE
&& (wave.data.wfx->cbSize >= (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX))))
{
auto wext = reinterpret_cast<const WAVEFORMATEXTENSIBLE*>(&wave.data.wfx);
wprintf(L" (%hs %u channels, %u-bit, %lu Hz, CMask:%hs)", GetFormatTagName(wave.data.wfx->wFormatTag), wave.data.wfx->nChannels, wave.data.wfx->wBitsPerSample, wave.data.wfx->nSamplesPerSec, ChannelDesc(wext->dwChannelMask));
}
else
{
wprintf(L" (%hs %u channels, %u-bit, %lu Hz)", GetFormatTagName(wave.data.wfx->wFormatTag), wave.data.wfx->nChannels, wave.data.wfx->wBitsPerSample, wave.data.wfx->nSamplesPerSec);
}
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------
// Entry-point
//--------------------------------------------------------------------------------------
#ifdef _PREFAST_
#pragma prefast(disable : 28198, "Command-line tool, frees all memory on exit")
#endif
int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
{
// Parameters and defaults
wchar_t szOutputFile[MAX_PATH] = {};
wchar_t szHeaderFile[MAX_PATH] = {};
ScopedHandle hFile;
// Process command line
DWORD dwOptions = 0;
std::list<SConversion> conversion;
for (int iArg = 1; iArg < argc; iArg++)
{
PWSTR pArg = argv[iArg];
if (('-' == pArg[0]) || ('/' == pArg[0]))
{
pArg++;
PWSTR pValue;
for (pValue = pArg; *pValue && (':' != *pValue); pValue++);
if (*pValue)
*pValue++ = 0;
DWORD dwOption = LookupByName(pArg, g_pOptions);
if (!dwOption || (dwOptions & (1 << dwOption)))
{
PrintUsage();
return 1;
}
dwOptions |= 1 << dwOption;
// Handle options with additional value parameter
switch (dwOption)
{
case OPT_OUTPUTFILE:
case OPT_OUTPUTHEADER:
case OPT_FILELIST:
if (!*pValue)
{
if ((iArg + 1 >= argc))
{
PrintUsage();
return 1;
}
iArg++;
pValue = argv[iArg];
}
break;
}
switch (dwOption)
{
case OPT_OUTPUTFILE:
wcscpy_s(szOutputFile, MAX_PATH, pValue);
break;
case OPT_OUTPUTHEADER:
wcscpy_s(szHeaderFile, MAX_PATH, pValue);
break;
case OPT_COMPACT:
if (dwOptions & (1 << OPT_NOCOMPACT))
{
wprintf(L"-c and -nc are mutually exclusive options\n");
return 1;
}
break;
case OPT_NOCOMPACT:
if (dwOptions & (1 << OPT_COMPACT))
{
wprintf(L"-c and -nc are mutually exclusive options\n");
return 1;
}
break;
case OPT_FILELIST:
{
std::wifstream inFile(pValue);
if (!inFile)
{
wprintf(L"Error opening -flist file %ls\n", pValue);
return 1;
}
wchar_t fname[1024] = {};
for (;;)
{
inFile >> fname;
if (!inFile)
break;
if (*fname == L'#')
{
// Comment
}
else if (*fname == L'-')
{
wprintf(L"Command-line arguments not supported in -flist file\n");
return 1;
}
else if (wcspbrk(fname, L"?*") != nullptr)
{
wprintf(L"Wildcards not supported in -flist file\n");
return 1;
}
else
{
SConversion conv;
wcscpy_s(conv.szSrc, MAX_PATH, fname);
conversion.push_back(conv);
}
inFile.ignore(1000, '\n');
}
inFile.close();
}
break;
}
}
else if (wcspbrk(pArg, L"?*") != nullptr)
{
size_t count = conversion.size();
SearchForFiles(pArg, conversion, (dwOptions & (1 << OPT_RECURSIVE)) != 0);
if (conversion.size() <= count)
{
wprintf(L"No matching files found for %ls\n", pArg);
return 1;
}
}
else
{
SConversion conv;
wcscpy_s(conv.szSrc, MAX_PATH, pArg);
conversion.push_back(conv);
}
}
if (conversion.empty())
{
wprintf(L"ERROR: Need at least 1 wave file to build wave bank\n\n");
PrintUsage();
return 0;
}
if (~dwOptions & (1 << OPT_NOLOGO))
PrintLogo();
// Determine output file name
if (!*szOutputFile)
{
auto pConv = conversion.begin();
wchar_t ext[_MAX_EXT];
wchar_t fname[_MAX_FNAME];
_wsplitpath_s(pConv->szSrc, nullptr, 0, nullptr, 0, fname, _MAX_FNAME, ext, _MAX_EXT);
if (_wcsicmp(ext, L".xwb") == 0)
{
wprintf(L"ERROR: Need to specify output file via -o\n");
return 1;
}
_wmakepath_s(szOutputFile, nullptr, nullptr, fname, L".xwb");
}
if (dwOptions & (1 << OPT_TOLOWER))
{
(void)_wcslwr_s(szOutputFile);
if (*szHeaderFile)
{
(void)_wcslwr_s(szHeaderFile);
}
}
if (~dwOptions & (1 << OPT_OVERWRITE))
{
if (GetFileAttributesW(szOutputFile) != INVALID_FILE_ATTRIBUTES)
{
wprintf(L"ERROR: Output file %ls already exists, use -y to overwrite!\n", szOutputFile);
return 1;
}
if (*szHeaderFile)
{
if (GetFileAttributesW(szHeaderFile) != INVALID_FILE_ATTRIBUTES)
{
wprintf(L"ERROR: Output header file %ls already exists!\n", szHeaderFile);
return 1;
}
}
}
// Gather wave files
std::unique_ptr<uint8_t[]> entries;
std::unique_ptr<char[]> entryNames;
std::vector<WaveFile> waves;
MINIWAVEFORMAT compactFormat = {};
bool xma = false;
size_t index = 0;
for (auto pConv = conversion.begin(); pConv != conversion.end(); ++pConv, ++index)
{
wchar_t ext[_MAX_EXT];
wchar_t fname[_MAX_FNAME];
_wsplitpath_s(pConv->szSrc, nullptr, 0, nullptr, 0, fname, _MAX_FNAME, ext, _MAX_EXT);
// Load source image
if (pConv != conversion.begin())
wprintf(L"\n");
wprintf(L"reading %ls", pConv->szSrc);
fflush(stdout);
WaveFile wave;
wave.conv = index;
std::unique_ptr<uint8_t[]> waveData;
HRESULT hr = DirectX::LoadWAVAudioFromFileEx(pConv->szSrc, waveData, wave.data);
if (FAILED(hr))
{
wprintf(L"\nERROR: Failed to load file (%08X)\n", static_cast<unsigned int>(hr));
return 1;
}
wave.waveData = std::move(waveData);
PrintInfo(wave);
if (wave.data.wfx->wFormatTag == WAVE_FORMAT_XMA2)
xma = true;
waves.emplace_back(std::move(wave));
}
wprintf(L"\n");
DWORD dwAlignment = ALIGNMENT_MIN;
if (dwOptions & (1 << OPT_STREAMING))
dwAlignment = ALIGNMENT_DVD;
else if (xma)
dwAlignment = 2048;
// Convert wave format to miniformat, failing if any won't map
// Check to see if we can use the compact wave bank format
bool compact = (dwOptions & (1 << OPT_NOCOMPACT)) ? false : true;
int reason = 0;
uint64_t waveOffset = 0;
for (auto it = waves.begin(); it != waves.end(); ++it)
{
if (!ConvertToMiniFormat(it->data.wfx, it->data.seek != nullptr, it->miniFmt))
{
auto cit = conversion.cbegin();
advance(cit, it->conv);
wprintf(L"ERROR: Failed encoding %ls\n", cit->szSrc);
return 1;
}
if (it == waves.begin())
{
memcpy(&compactFormat, &it->miniFmt, sizeof(MINIWAVEFORMAT));
}
else if (memcmp(&compactFormat, &it->miniFmt, sizeof(MINIWAVEFORMAT)) != 0)
{
compact = false;
reason |= 0x1;
}
if (it->data.loopLength > 0)
{
compact = false;
reason |= 0x2;
}
DWORD alignedSize = BLOCKALIGNPAD(it->data.audioBytes, dwAlignment);
waveOffset += alignedSize;
}
if (waveOffset > UINT32_MAX)
{
wprintf(L"ERROR: Audio wave data is too large to encode into wavebank (offset %llu)", waveOffset);
return 1;
}
else if (waveOffset > (MAX_COMPACT_DATA_SEGMENT_SIZE * uint64_t(dwAlignment)))
{
compact = false;
reason |= 0x4;
}
if ((dwOptions & (1 << OPT_COMPACT)) && !compact)
{
wprintf(L"ERROR: Cannot create compact wave bank:\n");
if (reason & 0x1)
{
wprintf(L"- Mismatched formats. All formats must be identical for a compact wavebank.\n");
}
if (reason & 0x2)
{
wprintf(L"- Found loop points. Compact wavebanks do not support loop points.\n");
}
if (reason & 0x4)
{
wprintf(L"- Audio wave data is too large to encode in compact wavebank (%llu > %llu).\n", waveOffset, (uint64_t(MAX_COMPACT_DATA_SEGMENT_SIZE) * uint64_t(dwAlignment)));
}
return 1;
}
// Build entry metadata (and assign wave offset within data segment)
// Build entry friendly names if requested
entries.reset(new uint8_t[(compact ? sizeof(ENTRYCOMPACT) : sizeof(ENTRY)) * waves.size()]);
if (dwOptions & (1 << OPT_FRIENDLY_NAMES))
{
entryNames.reset(new char[waves.size() * ENTRYNAME_LENGTH]);
memset(entryNames.get(), 0, sizeof(char) * waves.size() * ENTRYNAME_LENGTH);
}
waveOffset = 0;
size_t count = 0;
size_t seekEntries = 0;
for (auto it = waves.begin(); it != waves.end(); ++it, ++count)
{
DWORD alignedSize = BLOCKALIGNPAD(it->data.audioBytes, dwAlignment);
auto wfx = it->data.wfx;
uint64_t duration = 0;
switch (it->miniFmt.wFormatTag)
{
case MINIWAVEFORMAT::TAG_XMA:
if (it->data.seekCount > 0)
seekEntries += size_t(it->data.seekCount) + 1u;
duration = reinterpret_cast<const XMA2WAVEFORMATEX*>(wfx)->SamplesEncoded;
break;
case MINIWAVEFORMAT::TAG_ADPCM:
{
auto adpcmFmt = reinterpret_cast<const ADPCMEWAVEFORMAT*>(wfx);
duration = (uint64_t(it->data.audioBytes) / uint64_t(wfx->nBlockAlign)) * uint64_t(adpcmFmt->wSamplesPerBlock);
int partial = it->data.audioBytes % wfx->nBlockAlign;
if (partial)
{
if (partial >= (7 * wfx->nChannels))
duration += (uint64_t(partial) * 2 / uint64_t(wfx->nChannels - 12));
}
}
break;
case MINIWAVEFORMAT::TAG_WMA:
if (it->data.seekCount > 0)
{
seekEntries += size_t(it->data.seekCount) + 1u;
duration = it->data.seek[it->data.seekCount - 1] / uint32_t(2 * wfx->nChannels);
}
break;
default: // MINIWAVEFORMAT::TAG_PCM
duration = (uint64_t(it->data.audioBytes) * 8) / (uint64_t(wfx->wBitsPerSample) * uint64_t(wfx->nChannels));
break;
}
if (compact)
{
auto entry = reinterpret_cast<ENTRYCOMPACT*>(entries.get() + count * sizeof(ENTRYCOMPACT));
memset(entry, 0, sizeof(ENTRYCOMPACT));
assert(waveOffset <= (MAX_COMPACT_DATA_SEGMENT_SIZE * uint64_t(dwAlignment)));
entry->dwOffset = uint32_t(waveOffset / dwAlignment);
assert(dwAlignment <= 2048);
entry->dwLengthDeviation = alignedSize - it->data.audioBytes;
}
else
{
auto entry = reinterpret_cast<ENTRY*>(entries.get() + count * sizeof(ENTRY));
memset(entry, 0, sizeof(ENTRY));
if (duration > 268435455)
{
wprintf(L"ERROR: Duration of audio too long to encode into wavebank (%llu > 2^28))\n", duration);
return 1;
}
entry->Duration = uint32_t(duration);
memcpy(&entry->Format, &it->miniFmt, sizeof(MINIWAVEFORMAT));
entry->PlayRegion.dwOffset = uint32_t(waveOffset);
entry->PlayRegion.dwLength = it->data.audioBytes;
if (it->data.loopLength > 0)
{
entry->LoopRegion.dwStartSample = it->data.loopStart;
entry->LoopRegion.dwTotalSamples = it->data.loopLength;
}
}
if (dwOptions & (1 << OPT_FRIENDLY_NAMES))
{
auto cit = conversion.cbegin();
advance(cit, it->conv);
wchar_t wEntryName[_MAX_FNAME];
_wsplitpath_s(cit->szSrc, nullptr, 0, nullptr, 0, wEntryName, _MAX_FNAME, nullptr, 0);
int result = WideCharToMultiByte(CP_UTF8, WC_NO_BEST_FIT_CHARS, wEntryName, -1, &entryNames[count * ENTRYNAME_LENGTH], ENTRYNAME_LENGTH, nullptr, nullptr);
if (result <= 0)
{
memset(&entryNames[count * ENTRYNAME_LENGTH], 0, ENTRYNAME_LENGTH);
}
}
waveOffset += alignedSize;
}
assert(count > 0 && count == waves.size());
// Create wave bank
assert(*szOutputFile != 0);
wprintf(L"writing %ls%ls wavebank %ls w/ %zu entries\n", (compact) ? L"compact " : L"", (dwOptions & (1 << OPT_STREAMING)) ? L"streaming" : L"in-memory", szOutputFile, waves.size());
fflush(stdout);
hFile.reset(safe_handle(CreateFileW(szOutputFile, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr)));
if (!hFile)
{
wprintf(L"ERROR: Failed opening output file %ls, %lu\n", szOutputFile, GetLastError());
return 1;
}
// Setup wave bank header
HEADER header = {};
header.dwSignature = HEADER::SIGNATURE;
header.dwHeaderVersion = HEADER::VERSION;
header.dwVersion = XACT_CONTENT_VERSION;
DWORD segmentOffset = sizeof(HEADER);
// Write bank metadata
assert((segmentOffset % 4) == 0);
BANKDATA data = {};
data.dwEntryCount = uint32_t(waves.size());
data.dwAlignment = dwAlignment;
GetSystemTimeAsFileTime(&data.BuildTime);
data.dwFlags = (dwOptions & (1 << OPT_STREAMING)) ? BANKDATA::TYPE_STREAMING : BANKDATA::TYPE_BUFFER;
if (seekEntries > 0)
{
data.dwFlags |= BANKDATA::FLAGS_SEEKTABLES;
}
if (dwOptions & (1 << OPT_FRIENDLY_NAMES))
{
data.dwFlags |= BANKDATA::FLAGS_ENTRYNAMES;
data.dwEntryNameElementSize = ENTRYNAME_LENGTH;
}
if (compact)
{
data.dwFlags |= BANKDATA::FLAGS_COMPACT;
data.dwEntryMetaDataElementSize = sizeof(ENTRYCOMPACT);
memcpy(&data.CompactFormat, &compactFormat, sizeof(MINIWAVEFORMAT));
}
else
{
data.dwEntryMetaDataElementSize = sizeof(ENTRY);
}
{
wchar_t wBankName[_MAX_FNAME];
_wsplitpath_s(szOutputFile, nullptr, 0, nullptr, 0, wBankName, _MAX_FNAME, nullptr, 0);
int result = WideCharToMultiByte(CP_UTF8, WC_NO_BEST_FIT_CHARS, wBankName, -1, data.szBankName, BANKDATA::BANKNAME_LENGTH, nullptr, nullptr);
if (result <= 0)
{
memset(data.szBankName, 0, BANKDATA::BANKNAME_LENGTH);
}
}
if (SetFilePointer(hFile.get(), LONG(segmentOffset), nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed writing bank data to %ls, SFP %lu\n", szOutputFile, GetLastError());
return 1;
}
DWORD bytesWritten;
if (!WriteFile(hFile.get(), &data, sizeof(data), &bytesWritten, nullptr)
|| bytesWritten != sizeof(data))
{
wprintf(L"ERROR: Failed writing bank data to %ls, %lu\n", szOutputFile, GetLastError());
return 1;
}
header.Segments[HEADER::SEGIDX_BANKDATA].dwOffset = segmentOffset;
header.Segments[HEADER::SEGIDX_BANKDATA].dwLength = sizeof(BANKDATA);
segmentOffset += sizeof(BANKDATA);
// Write entry metadata
assert((segmentOffset % 4) == 0);
if (SetFilePointer(hFile.get(), LONG(segmentOffset), nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed writing entry metadata to %ls, SFP %lu\n", szOutputFile, GetLastError());
return 1;
}
uint32_t entryBytes = uint32_t(waves.size() * data.dwEntryMetaDataElementSize);
if (!WriteFile(hFile.get(), entries.get(), entryBytes, &bytesWritten, nullptr)
|| bytesWritten != entryBytes)
{
wprintf(L"ERROR: Failed writing entry metadata to %ls, %lu\n", szOutputFile, GetLastError());
return 1;
}
header.Segments[HEADER::SEGIDX_ENTRYMETADATA].dwOffset = segmentOffset;
header.Segments[HEADER::SEGIDX_ENTRYMETADATA].dwLength = entryBytes;
segmentOffset += entryBytes;
// Write seek tables
assert((segmentOffset % 4) == 0);
header.Segments[HEADER::SEGIDX_SEEKTABLES].dwOffset = segmentOffset;
if (seekEntries > 0)
{
seekEntries += waves.size(); // Room for an offset per entry
auto seekTables = std::make_unique<uint32_t[]>(seekEntries);
if (SetFilePointer(hFile.get(), LONG(segmentOffset), nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed writing seek tables to %ls, SFP %lu\n", szOutputFile, GetLastError());
return 1;
}
uint32_t seekoffset = 0;
uint32_t windex = 0;
for (auto it = waves.begin(); it != waves.end(); ++it, ++windex)
{
if (it->miniFmt.wFormatTag == MINIWAVEFORMAT::TAG_WMA)
{
seekTables[windex] = seekoffset * sizeof(uint32_t);
uint32_t baseoffset = uint32_t(waves.size() + seekoffset);
seekTables[baseoffset] = it->data.seekCount;
for (uint32_t j = 0; j < it->data.seekCount; ++j)
{
seekTables[size_t(baseoffset) + size_t(j) + 1u] = it->data.seek[j];
}
seekoffset += size_t(it->data.seekCount) + 1u;
}
else if (it->miniFmt.wFormatTag == MINIWAVEFORMAT::TAG_XMA)
{
seekTables[windex] = seekoffset * sizeof(uint32_t);
uint32_t baseoffset = uint32_t(waves.size() + seekoffset);
seekTables[baseoffset] = it->data.seekCount;
for (uint32_t j = 0; j < it->data.seekCount; ++j)
{
seekTables[size_t(baseoffset) + size_t(j) + 1u] = _byteswap_ulong(it->data.seek[j]);
}
seekoffset += it->data.seekCount + 1;
}
else
{
seekTables[windex] = uint32_t(-1);
}
}
uint32_t seekLen = uint32_t(sizeof(uint32_t) * seekEntries);
if (!WriteFile(hFile.get(), seekTables.get(), seekLen, &bytesWritten, nullptr)
|| bytesWritten != seekLen)
{
wprintf(L"ERROR: Failed writing seek tables to %ls, %lu\n", szOutputFile, GetLastError());
return 1;
}
segmentOffset += seekLen;
header.Segments[HEADER::SEGIDX_SEEKTABLES].dwLength = seekLen;
}
else
{
header.Segments[HEADER::SEGIDX_SEEKTABLES].dwLength = 0;
}
// Write entry names
if (dwOptions & (1 << OPT_FRIENDLY_NAMES))
{
assert((segmentOffset % 4) == 0);
if (SetFilePointer(hFile.get(), LONG(segmentOffset), nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed writing friendly entry names to %ls, SFP %lu\n", szOutputFile, GetLastError());
return 1;
}
uint32_t entryNamesBytes = uint32_t(count * data.dwEntryNameElementSize);
if (!WriteFile(hFile.get(), entryNames.get(), entryNamesBytes, &bytesWritten, nullptr)
|| bytesWritten != entryNamesBytes)
{
wprintf(L"ERROR: Failed writing friendly entry names to %ls, %lu\n", szOutputFile, GetLastError());
return 1;
}
header.Segments[HEADER::SEGIDX_ENTRYNAMES].dwOffset = segmentOffset;
header.Segments[HEADER::SEGIDX_ENTRYNAMES].dwLength = entryNamesBytes;
segmentOffset += entryNamesBytes;
}
// Write wave data
segmentOffset = BLOCKALIGNPAD(segmentOffset, dwAlignment);
header.Segments[HEADER::SEGIDX_ENTRYWAVEDATA].dwOffset = segmentOffset;
header.Segments[HEADER::SEGIDX_ENTRYWAVEDATA].dwLength = uint32_t(waveOffset);
for (auto it = waves.begin(); it != waves.end(); ++it)
{
if (SetFilePointer(hFile.get(), LONG(segmentOffset), nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed writing audio data to %ls, SFP %lu\n", szOutputFile, GetLastError());
return 1;
}
if (!WriteFile(hFile.get(), it->data.startAudio, it->data.audioBytes, &bytesWritten, nullptr)
|| bytesWritten != it->data.audioBytes)
{
wprintf(L"ERROR: Failed writing audio data to %ls, %lu\n", szOutputFile, GetLastError());
return 1;
}
DWORD alignedSize = BLOCKALIGNPAD(it->data.audioBytes, dwAlignment);
if ((uint64_t(segmentOffset) + alignedSize) > UINT32_MAX)
{
wprintf(L"ERROR: Data exceeds maximum size for wavebank\n");
return 1;
}
segmentOffset += alignedSize;
}
assert(segmentOffset == (header.Segments[HEADER::SEGIDX_ENTRYWAVEDATA].dwOffset + waveOffset));
// Commit wave bank
if (SetFilePointer(hFile.get(), LONG(segmentOffset), nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed committing output file %ls, EOF %lu\n", szOutputFile, GetLastError());
return 1;
}
if (!SetEndOfFile(hFile.get()))
{
wprintf(L"ERROR: Failed committing output file %ls, EOF %lu\n", szOutputFile, GetLastError());
return 1;
}
if (SetFilePointer(hFile.get(), 0, nullptr, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
wprintf(L"ERROR: Failed committing output file %ls, HDR %lu\n", szOutputFile, GetLastError());
return 1;
}
if (!WriteFile(hFile.get(), &header, sizeof(header), &bytesWritten, nullptr)
|| bytesWritten != sizeof(header))
{
wprintf(L"ERROR: Failed committing output file %ls, HDR %lu\n", szOutputFile, GetLastError());
return 1;
}
// Write C header if requested
if (*szHeaderFile)
{
wprintf(L"writing C header %ls\n", szHeaderFile);
fflush(stdout);
FILE* file = nullptr;
if (!_wfopen_s(&file, szHeaderFile, L"wt"))
{
wchar_t wBankName[_MAX_FNAME];
_wsplitpath_s(szOutputFile, nullptr, 0, nullptr, 0, wBankName, _MAX_FNAME, nullptr, 0);
FileNameToIdentifier(wBankName, _MAX_FNAME);
fprintf_s(file, "#pragma once\n\nenum XACT_WAVEBANK_%ls : unsigned int\n{\n", wBankName);
size_t windex = 0;
for (auto it = waves.begin(); it != waves.end(); ++it, ++windex)
{
auto cit = conversion.cbegin();
advance(cit, it->conv);
wchar_t wEntryName[_MAX_FNAME];
_wsplitpath_s(cit->szSrc, nullptr, 0, nullptr, 0, wEntryName, _MAX_FNAME, nullptr, 0);
FileNameToIdentifier(wEntryName, _MAX_FNAME);
fprintf_s(file, " XACT_WAVEBANK_%ls_%ls = %zu,\n", wBankName, wEntryName, windex);
}
fprintf_s(file, "};\n\n#define XACT_WAVEBANK_%ls_ENTRY_COUNT %zu\n", wBankName, count);
fclose(file);
}
else
{
wprintf(L"ERROR: Failed writing wave bank C header %ls\n", szHeaderFile);
return 1;
}
}
return 0;
}
Reference in New Issue Copy Permalink