3d-pinball-space-cadet/sound/wavemix.cpp

#include "../pinball.h"

//----- (0101CFD0) --------------------------------------------------------
_WORD *__stdcall SessionToGlobalDataPtr(_WORD *a1)
{
if ( a1 && *a1 == 21554 && a1[222] == 21554 )
return a1;
MessageBeep(0xFFFFFFFF);
_wsprintfA(aWavemixV23ByAn, "Invalid session handle 0x%04X passed to WaveMix API", a1);
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x30u);
return 0;
}

//----- (0101D02C) --------------------------------------------------------
BOOL __stdcall IsValidLPMIXWAVE(int a1)
{
BOOL result; // eax

result = a1;
if ( a1 )
result = *(_WORD *)(a1 + 64) == 21554;
return result;
}

//----- (0101D04E) --------------------------------------------------------
bool __stdcall HasCurrentOutputFormat(const void *a1)
{
return memcmp(a1, (const void *)(hMem + 380), 0x10u) == 0;
}

//----- (0101D079) --------------------------------------------------------
int __stdcall DefaultPauseBlocks(int a1)
{
int result; // eax

if ( GetVersion() < 0x80000000 || (unsigned __int8)GetVersion() < 4u )
result = a1;
else
result = 0;
return result;
}

//----- (0101D0A5) --------------------------------------------------------
unsigned int __stdcall DefaultGoodWavePos(UINT_PTR uDeviceID)
{
signed int v1; // eax
unsigned int result; // eax
struct tagWAVEOUTCAPSA pwoc; // [esp+0h] [ebp-38h]

v1 = waveOutGetNumDevs();
if ( (signed int)uDeviceID > v1 || (uDeviceID & 0x80000000) != 0 || !v1 || waveOutGetDevCapsA(uDeviceID, &pwoc, 0x34u) )
result = 0;
else
result = ((unsigned int)LOBYTE(pwoc.dwSupport) >> 5) & 1;
return result;
}

//----- (0101D0FC) --------------------------------------------------------
DWORD __stdcall MyWaveOutGetPosition(HWAVEOUT hwo, int a2)
{
struct mmtime_tag pmmt; // [esp+0h] [ebp-10h]

if ( !a2 )
return (timeGetTime() - *(_DWORD *)(hMem + 416)) * *(_DWORD *)(hMem + 388) / 0x3E8 & 0xFFFFFFF8;
pmmt.wType = 4;
waveOutGetPosition(hwo, &pmmt, 0xCu);
return (*(int (__stdcall **)(DWORD, _DWORD))(hMem + 436))(pmmt.u.ms, *(_DWORD *)(hMem + 424));
}

//----- (0101D178) --------------------------------------------------------
int __stdcall AddFactor(int a1, int a2)
{
return a1 + a2;
}

//----- (0101D18E) --------------------------------------------------------
int __stdcall SubFactor(int a1, int a2)
{
return a1 - a2;
}

//----- (0101D1A2) --------------------------------------------------------
unsigned int __stdcall SetWaveOutPosition(unsigned int a1)
{
LPARAM v1; // eax
HWAVEOUT v2; // ecx
DWORD v3; // ecx
DWORD v4; // eax
LPARAM v5; // ecx
DWORD v6; // edi
unsigned int result; // eax
struct mmtime_tag pmmt; // [esp+0h] [ebp-10h]

v1 = hMem;
v2 = *(HWAVEOUT *)(hMem + 12);
pmmt.wType = 4;
if ( v2 )
{
waveOutGetPosition(v2, &pmmt, 0xCu);
v3 = pmmt.u.ms;
v1 = hMem;
}
else
{
v3 = 0;
pmmt.u.ms = 0;
}
if ( v3 < a1 )
{
*(_DWORD *)(v1 + 424) = a1 - v3;
*(_DWORD *)(v1 + 436) = AddFactor;
}
else
{
*(_DWORD *)(v1 + 424) = v3 - a1;
*(_DWORD *)(v1 + 436) = SubFactor;
}
v4 = timeGetTime();
v5 = hMem;
v6 = v4;
result = 1000 * a1 / *(_DWORD *)(hMem + 388);
*(_DWORD *)(hMem + 412) = a1;
*(_DWORD *)(v5 + 416) = v6 - result;
return result;
}

//----- (0101D251) --------------------------------------------------------
unsigned int __stdcall MyWaveOutReset(HWAVEOUT hwo)
{
unsigned int v1; // esi

v1 = MyWaveOutGetPosition(hwo, *(_DWORD *)(hMem + 420));
waveOutReset(hwo);
return SetWaveOutPosition(v1);
}

//----- (0101D285) --------------------------------------------------------
__int16 __stdcall cmixit(_BYTE *a1, char *a2, char *a3, int a4, unsigned __int16 a5)
{
int v5; // eax
unsigned __int8 *v6; // esi
_BYTE *v7; // edi
int v8; // ecx
int v9; // edx
_BYTE *v10; // edi
unsigned __int8 *v11; // esi
int v12; // edx
int v13; // ebx
unsigned __int16 *v14; // eax
int v15; // ecx
unsigned __int8 *v16; // ecx
int v17; // ecx
bool v18; // zf
unsigned __int8 *v19; // esi
int v20; // edi
_BYTE *v21; // ecx
int v22; // ebx
unsigned __int16 *v23; // ecx
int v24; // eax
int v26; // [esp+10h] [ebp-8h]
int v27; // [esp+10h] [ebp-8h]
unsigned __int16 v28; // [esp+14h] [ebp-4h]
unsigned __int16 v29; // [esp+14h] [ebp-4h]
int v30; // [esp+30h] [ebp+18h]
int v31; // [esp+30h] [ebp+18h]

LOWORD(v5) = hMem;
if ( *(_WORD *)(hMem + 382) == 2 )
{
if ( a4 == 1 )
{
v6 = *(unsigned __int8 **)a2;
LOWORD(v5) = (_WORD)a3;
if ( a5 )
{
v7 = a1;
v5 = *(unsigned __int16 *)a3 << 8;
v8 = *((unsigned __int16 *)a3 + 1) << 8;
v9 = (unsigned __int16)(((unsigned __int16)(a5 - 1) >> 1) + 1);
do
{
*v7 = byte_1025970[*v6 + v5];
v10 = v7 + 1;
v11 = v6 + 1;
*v10 = byte_1025970[*v11 + v8];
v7 = v10 + 1;
v6 = v11 + 1;
--v9;
}
while ( v9 );
}
}
else
{
v28 = 0;
LOWORD(v5) = a5;
if ( a5 )
{
v26 = (unsigned __int16)(((unsigned __int16)(a5 - 1) >> 1) + 1);
do
{
v12 = 128;
v13 = 128;
if ( a4 > 0 )
{
v14 = (unsigned __int16 *)a3;
v15 = a2 - a3;
v30 = a4;
while ( 1 )
{
v16 = (unsigned __int8 *)(*(_DWORD *)((char *)v14 + v15) + v28);
v13 = v13 + (unsigned __int8)byte_1025970[256 * *v14 + *v16] - 128;
v17 = (unsigned __int8)byte_1025970[256 * v14[1] + v16[1]];
v14 += 2;
v18 = v30-- == 1;
v12 = v12 + v17 - 128;
if ( v18 )
break;
v15 = a2 - a3;
}
if ( v13 >= 0 )
{
if ( v13 > 255 )
LOBYTE(v13) = -1;
}
else
{
LOBYTE(v13) = 0;
}
if ( v12 >= 0 )
{
if ( v12 > 255 )
LOBYTE(v12) = -1;
}
else
{
LOBYTE(v12) = 0;
}
}
v28 += 2;
*a1 = v13;
a1[1] = v12;
LOWORD(v5) = (_WORD)a1 + 2;
v18 = v26-- == 1;
a1 += 2;
}
while ( !v18 );
}
}
}
else if ( a4 == 1 )
{
v19 = *(unsigned __int8 **)a2;
v5 = (*(unsigned __int16 *)a3 + *((unsigned __int16 *)a3 + 1)) / 2;
if ( a5 )
{
v20 = a5;
v21 = a1;
v5 = (unsigned __int16)v5 << 8;
do
{
*v21++ = byte_1025970[*v19++ + v5];
--v20;
}
while ( v20 );
}
}
else
{
v29 = 0;
if ( a5 )
{
v27 = a5;
do
{
v22 = 128;
if ( a4 > 0 )
{
v23 = (unsigned __int16 *)a3;
v31 = a4;
do
{
v24 = (unsigned __int8)byte_1025970[256 * (unsigned __int16)((*v23 + v23[1]) / 2)
+ *(unsigned __int8 *)(*(_DWORD *)((char *)v23 + a2 - a3) + v29)];
v23 += 2;
v18 = v31-- == 1;
v22 = v22 + v24 - 128;
}
while ( !v18 );
if ( v22 >= 0 )
{
if ( v22 > 255 )
LOBYTE(v22) = -1;
}
else
{
LOBYTE(v22) = 0;
}
}
v5 = (int)a1++;
++v29;
v18 = v27-- == 1;
*(_BYTE *)v5 = v22;
}
while ( !v18 );
}
}
return v5;
}

//----- (0101D491) --------------------------------------------------------
_DWORD *__stdcall InitChannelNodes()
{
_DWORD *result; // eax

result = &unk_1026470;
do
{
*result = result + 15;
result += 15;
}
while ( (signed int)result < (signed int)&unk_1027B68 );
dword_1027BA4 = 0;
dword_1025964 = (int)&unk_1026470;
return result;
}
// 1025964: using guessed type int dword_1025964;
// 1027BA4: using guessed type int dword_1027BA4;

//----- (0101D4B9) --------------------------------------------------------
int __stdcall GetChannelNode()
{
int result; // eax
int v1; // ecx

result = dword_1025964;
if ( dword_1025964 )
{
v1 = *(_DWORD *)dword_1025964;
*(_DWORD *)dword_1025964 = 0;
dword_1025964 = v1;
}
return result;
}
// 1025964: using guessed type int dword_1025964;

//----- (0101D4D4) --------------------------------------------------------
_DWORD *__stdcall FreeChannelNode(_DWORD *a1)
{
_DWORD *result; // eax

result = a1;
if ( a1 )
{
*a1 = dword_1025964;
dword_1025964 = (int)a1;
}
return result;
}
// 1025964: using guessed type int dword_1025964;

//----- (0101D4F6) --------------------------------------------------------
struct wavehdr_tag *__stdcall FreeWaveBlocks(HWAVEOUT hwo, int a2)
{
signed int v2; // ebx
LPCVOID *v3; // esi
struct wavehdr_tag *result; // eax
HGLOBAL v5; // eax
HGLOBAL v6; // eax

v2 = 0;
do
{
v3 = (LPCVOID *)(a2 + 4 * v2);
result = (struct wavehdr_tag *)*v3;
if ( *v3 )
{
waveOutUnprepareHeader(hwo, result, 0x20u);
v5 = GlobalHandle(*v3);
GlobalUnlock(v5);
v6 = GlobalHandle(*v3);
result = (struct wavehdr_tag *)GlobalFree(v6);
*v3 = 0;
}
++v2;
}
while ( v2 < 10 );
return result;
}

//----- (0101D549) --------------------------------------------------------
int __stdcall AllocWaveBlocks(HWAVEOUT hwo, int a2)
{
signed int v2; // edi
HGLOBAL v3; // eax
_DWORD *v4; // eax
int v5; // ecx
signed int v6; // edi
int i; // edi
HGLOBAL v9; // eax
HGLOBAL v10; // eax

v2 = 0;
do
{
v3 = GlobalAlloc(0x2000u, 0x2B41u);
v4 = GlobalLock(v3);
v5 = a2 + 4 * v2;
*(_DWORD *)v5 = v4;
if ( !v4 )
{
if ( dword_1027BE4 )
MessageBoxA(
0,
"Unable to allocate memory for waveform data.  Try making more memory available by closing other applications.",
"WavMix32",
0x30u);
for ( i = v2 - 1; i >= 0; --i )
{
v9 = GlobalHandle(*(LPCVOID *)(a2 + 4 * i));
GlobalUnlock(v9);
v10 = GlobalHandle(*(LPCVOID *)(a2 + 4 * i));
GlobalFree(v10);
*(_DWORD *)(a2 + 4 * i) = 0;
}
return 0;
}
*v4 = v4 + 12;
*(_DWORD *)(*(_DWORD *)v5 + 4) = *(_DWORD *)(hMem + 396);
*(_DWORD *)(*(_DWORD *)v5 + 16) = 0;
*(_DWORD *)(*(_DWORD *)v5 + 20) = 0;
*(_DWORD *)(*(_DWORD *)v5 + 32) = 1;
++v2;
*(_DWORD *)(*(_DWORD *)v5 + 36) = 0;
}
while ( v2 < 10 );
v6 = 0;
while ( !waveOutPrepareHeader(hwo, *(LPWAVEHDR *)(a2 + 4 * v6), 0x20u) )
{
*(_DWORD *)(*(_DWORD *)(a2 + 4 * v6++) + 16) |= 1u;
if ( v6 >= 10 )
return 1;
}
if ( dword_1027BE4 )
MessageBoxA(0, "Unable to prepare wave header.", "WavMix32", 0x30u);
FreeWaveBlocks(hwo, a2);
return 0;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101D649) --------------------------------------------------------
_DWORD *__stdcall SwapWaveBlocks()
{
_DWORD *result; // eax

result = (_DWORD *)(hMem + 408);
if ( *(_UNKNOWN **)(hMem + 408) == &unk_10257E4 )
*result = &unk_1025770;
else
*result = &unk_10257E4;
return result;
}

//----- (0101D66B) --------------------------------------------------------
_DWORD *__stdcall GetWaveBlock()
{
int v0; // edx
int v1; // eax
int v2; // esi
_DWORD *result; // eax
int v4; // ecx

v0 = *(_DWORD *)(hMem + 400);
v1 = 0;
if ( v0 > 0 )
{
v2 = *(_DWORD *)(hMem + 408);
do
{
if ( *(_DWORD *)(*(_DWORD *)v2 + 32) )
break;
++v1;
v2 += 4;
}
while ( v1 < v0 );
}
if ( v1 >= v0 )
return 0;
v4 = *(_DWORD *)(hMem + 396);
result = *(_DWORD **)(*(_DWORD *)(hMem + 408) + 4 * v1);
result[8] = 0;
result[1] = v4;
*result = result + 12;
result[10] = dword_1025798;
return result;
}
// 1025798: using guessed type int dword_1025798;

//----- (0101D6C8) --------------------------------------------------------
struct wavehdr_tag *__stdcall RemoveFromPlayingQueue(struct wavehdr_tag *a1)
{
struct wavehdr_tag *result; // eax
LPWAVEHDR v2; // edx
DWORD v3; // ecx
bool v4; // zf

if ( !pwh )
return 0;
result = a1;
if ( a1 != pwh )
{
v2 = pwh;
v3 = pwh[1].dwUser;
if ( v3 )
{
do
{
if ( (struct wavehdr_tag *)v3 == a1 )
break;
v2 = (LPWAVEHDR)v3;
v3 = *(_DWORD *)(v3 + 44);
}
while ( v3 );
if ( v3 )
{
v4 = v3 == dword_1027BF0;
v2[1].dwUser = *(_DWORD *)(v3 + 44);
if ( v4 )
dword_1027BF0 = (int)v2;
goto LABEL_12;
}
}
return 0;
}
pwh = (LPWAVEHDR)a1[1].dwUser;
if ( !pwh )
dword_1027BF0 = 0;
LABEL_12:
a1[1].dwUser = 0;
return result;
}
// 1027BF0: using guessed type int dword_1027BF0;

//----- (0101D734) --------------------------------------------------------
LPWAVEHDR __stdcall DestroyPlayQueue()
{
struct wavehdr_tag *v0; // ST00_4
LPWAVEHDR result; // eax

while ( 1 )
{
result = pwh;
if ( !pwh )
break;
v0 = pwh;
pwh[1].lpData = (LPSTR)1;
RemoveFromPlayingQueue(v0);
}
return result;
}

//----- (0101D752) --------------------------------------------------------
int __stdcall ReleaseWaveDevice(int a1)
{
int result; // eax
HWND v2; // ST04_4

if ( *(_DWORD *)(a1 + 16) )
{
result = *(_DWORD *)(a1 + 12);
if ( result )
{
MyWaveOutReset(*(HWAVEOUT *)(a1 + 12));
DestroyPlayQueue();
FreeWaveBlocks(*(HWAVEOUT *)(a1 + 12), (int)&unk_10257E4);
FreeWaveBlocks(*(HWAVEOUT *)(a1 + 12), (int)&unk_1025770);
waveOutClose(*(HWAVEOUT *)(a1 + 12));
v2 = *(HWND *)(a1 + 4);
*(_DWORD *)(a1 + 12) = 0;
result = DestroyWindow(v2);
*(_DWORD *)(a1 + 4) = 0;
}
}
return result;
}

//----- (0101D7B1) --------------------------------------------------------
signed int __stdcall GetWaveDevice()
{
HWND v0; // eax
LPARAM v1; // ecx
MMRESULT v2; // edi
HWND v4; // ST2C_4
WAVEFORMATEX pwfx; // [esp+Ch] [ebp-14h]

if ( *(_DWORD *)(hMem + 12) )
return 0;
v0 = CreateWindowExA(0, "WavMix32", WindowName, 0x8000000u, 0, 0, 0, 0, 0, 0, dword_10257E0, 0);
v1 = hMem;
*(_DWORD *)(hMem + 4) = v0;
if ( !v0 )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to create callback window.", "WavMix32", 0x30u);
return 1;
}
pwfx.wFormatTag = *(_WORD *)(v1 + 380);
pwfx.nChannels = *(_WORD *)(v1 + 382);
pwfx.nSamplesPerSec = *(_DWORD *)(v1 + 384);
pwfx.nAvgBytesPerSec = *(_DWORD *)(v1 + 388);
pwfx.nBlockAlign = *(_WORD *)(v1 + 392);
pwfx.wBitsPerSample = *(_WORD *)(v1 + 394);
pwfx.cbSize = 0;
v2 = waveOutOpen((LPHWAVEOUT)(v1 + 12), 0xFFFFFFFF, &pwfx, *(_DWORD *)(v1 + 4), 0, 0x10000u);
if ( v2 )
{
DestroyWindow(*(HWND *)(hMem + 4));
*(_DWORD *)(hMem + 4) = 0;
return v2;
}
if ( AllocWaveBlocks(*(HWAVEOUT *)(hMem + 12), (int)&unk_10257E4)
&& AllocWaveBlocks(*(HWAVEOUT *)(hMem + 12), (int)&unk_1025770) )
{
*(_DWORD *)(hMem + 408) = &unk_10257E4;
return 0;
}
FreeWaveBlocks(*(HWAVEOUT *)(hMem + 12), (int)&unk_10257E4);
FreeWaveBlocks(*(HWAVEOUT *)(hMem + 12), (int)&unk_1025770);
waveOutClose(*(HWAVEOUT *)(hMem + 12));
v4 = *(HWND *)(hMem + 4);
*(_DWORD *)(hMem + 12) = 0;
DestroyWindow(v4);
return 1;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101D918) --------------------------------------------------------
signed int __stdcall WaveMixOpenChannel(_WORD *a1, signed int a2, unsigned int a3)
{
_WORD *v3; // eax
signed int v4; // ecx
int v6; // ecx
_DWORD *v7; // edx
int v8; // ecx
_DWORD *v9; // edx

v3 = SessionToGlobalDataPtr(a1);
hMem = (LPARAM)v3;
if ( !v3 )
return 5;
if ( a3 > 2 )
return 10;
v4 = a2;
if ( a3 )
{
if ( a3 == 2 && (a2 > 16 || a2 < 1) )
return 11;
}
else if ( a2 >= 16 )
{
return 11;
}
if ( a3 )
{
if ( a3 == 1 )
{
v4 = 16;
}
else if ( a3 != 2 )
{
return 10;
}
v6 = v4 - 1;
if ( v6 >= 0 )
{
v7 = &v3[2 * v6 + 122];
v8 = v6 + 1;
do
{
if ( *v7 == -1 )
{
*v7 = 0;
*((_WORD *)v7 - 32) = v3[88];
*((_WORD *)v7 - 31) = v3[89];
++*((_DWORD *)v3 + 77);
}
--v7;
--v8;
}
while ( v8 );
}
}
else
{
v9 = &v3[2 * a2 + 122];
if ( *v9 != -1 )
return 4;
*v9 = 0;
v3[2 * a2 + 90] = v3[88];
v3[2 * a2 + 91] = v3[89];
++*((_DWORD *)v3 + 77);
}
return 0;
}

//----- (0101D9E7) --------------------------------------------------------
LPWAVEHDR __stdcall AddToPlayingQueue(struct wavehdr_tag *a1)
{
LPWAVEHDR result; // eax

result = pwh;
a1[1].dwUser = 0;
if ( result )
{
*(_DWORD *)(dword_1027BF0 + 44) = a1;
}
else
{
result = a1;
pwh = a1;
}
dword_1027BF0 = (int)a1;
return result;
}
// 1027BF0: using guessed type int dword_1027BF0;

//----- (0101DA1D) --------------------------------------------------------
int __stdcall MixerPlay(LPWAVEHDR pwh, int a2)
{
LPWAVEHDR v2; // edi
LPARAM v4; // esi
_DWORD *v5; // ecx
signed int v6; // ebx
_DWORD *v7; // eax
int v8; // edx
unsigned int v9; // ebx
int v10; // eax
unsigned int v11; // ecx
int v12; // edi
unsigned int v13; // eax
unsigned int v14; // edx
unsigned int v15; // ebx
int v16; // eax
unsigned int v17; // eax
int v18; // eax
int v19; // edx
int v20; // edi
unsigned int v21; // edx
int *v22; // eax
int v23; // ecx
bool v24; // zf
unsigned int v25; // [esp+4h] [ebp-1Ch]
unsigned int v26; // [esp+8h] [ebp-18h]
int v27; // [esp+Ch] [ebp-14h]
LPSTR v28; // [esp+10h] [ebp-10h]
int v29; // [esp+14h] [ebp-Ch]
unsigned int v30; // [esp+18h] [ebp-8h]
unsigned int v31; // [esp+1Ch] [ebp-4h]

v2 = pwh;
if ( !pwh )
return 0;
v30 = -1;
v31 = 0;
v4 = hMem;
v5 = (_DWORD *)(hMem + 244);
v6 = 16;
do
{
v7 = (_DWORD *)*v5;
if ( *v5 != -1 && v7 )
{
do
{
if ( v7[11] > *(_DWORD *)(v4 + 412) )
break;
v7 = (_DWORD *)*v7;
}
while ( v7 );
if ( v7 )
{
if ( v7[10] < v30 )
v30 = v7[10];
v8 = v31++;
dword_1025730[v8] = (int)v7;
}
}
++v5;
--v6;
}
while ( v6 );
if ( !v31 )
{
if ( a2 )
pwh[1].lpData = (LPSTR)1;
return 0;
}
v9 = *(_DWORD *)(v4 + 412);
v28 = pwh->lpData;
LOWORD(v10) = *(_WORD *)(v4 + 396);
v25 = *(_DWORD *)(v4 + 412);
v27 = *(unsigned __int16 *)(v4 + 396);
while ( (_WORD)v10 )
{
if ( v9 >= v30 )
{
v26 = 0;
v29 = 0;
v11 = v9 + (unsigned __int16)v10;
if ( !v31 )
goto LABEL_47;
do
{
v12 = dword_1025730[v26];
v13 = *(_DWORD *)(v12 + 40);
if ( v13 <= v9 )
{
if ( *(_DWORD *)(v12 + 44) < v11 )
v11 = *(_DWORD *)(v12 + 44);
v14 = v9 - v13;
if ( *(_WORD *)(v12 + 26) )
{
v15 = *(_DWORD *)(v12 + 36);
v14 %= v15;
v16 = v15 - v14;
v9 = v25;
v17 = v25 + v16;
if ( v17 < v11 )
v11 = v17;
}
v18 = v14 + *(_DWORD *)(v12 + 48);
v19 = v29++;
dword_10257A0[v19] = v18;
word_1025810[2 * v19] = *(_WORD *)(v12 + 56);
word_1025812[2 * v19] = *(_WORD *)(v12 + 58);
}
else if ( v13 < v11 )
{
v11 = *(_DWORD *)(v12 + 40);
}
++v26;
}
while ( v26 < v31 );
if ( v29 )
{
v20 = v11 - v9;
(*(void (__stdcall **)(LPSTR, int *, __int16 *, int, unsigned int))(v4 + 428))(
v28,
dword_10257A0,
word_1025810,
v29,
v11 - v9);
v28 += v20;
v27 -= v20;
v30 = -1;
v9 += v20;
v25 = v9;
v21 = 0;
v22 = dword_1025730;
do
{
if ( !*v22 )
goto LABEL_57;
do
{
if ( *(_DWORD *)(*v22 + 44) > v9 )
break;
v23 = *(_DWORD *)*v22;
*v22 = v23;
}
while ( v23 );
if ( *v22 )
{
if ( *(_DWORD *)(*v22 + 40) < v30 )
v30 = *(_DWORD *)(*v22 + 40);
++v21;
++v22;
}
else
{
LABEL_57:
v24 = v31-- == 1;
*v22 = dword_1025730[v31];
if ( v24 )
break;
}
}
while ( v21 < v31 );
v4 = hMem;
}
}
else
{
v10 = (unsigned __int16)v10;
if ( (unsigned __int16)v10 + v9 >= v30 )
v10 = v30 - v9;
memset(v28, 0x80u, (unsigned __int16)v10);
v28 += v10;
v9 += v10;
v27 -= v10;
v25 = v9;
}
v2 = pwh;
LABEL_47:
LOWORD(v10) = v27;
}
v2[1].dwBufferLength = *(_DWORD *)(v4 + 412);
*(_DWORD *)(v4 + 412) += *(_DWORD *)(v4 + 396);
if ( a2 )
{
AddToPlayingQueue(v2);
if ( waveOutWrite(*(HWAVEOUT *)(v4 + 12), v2, 0x20u) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to write block to device", "WavMix32", 0x30u);
v2[1].lpData = (LPSTR)1;
RemoveFromPlayingQueue(v2);
}
}
return 1;
}
// 1025810: using guessed type __int16 word_1025810[];
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101DC8C) --------------------------------------------------------
DWORD __stdcall FreePlayedBlocks()
{
DWORD result; // eax
LPARAM v1; // esi
signed int v2; // ebx
_DWORD *v3; // edi
HWND v4; // eax
signed int v5; // edi
DWORD v6; // [esp+Ch] [ebp-8h]
WPARAM wParam; // [esp+10h] [ebp-4h]

result = MyWaveOutGetPosition(*(HWAVEOUT *)(hMem + 12), *(_DWORD *)(hMem + 420));
wParam = 0;
v1 = hMem;
v6 = result;
v2 = 244;
do
{
v3 = *(_DWORD **)(v2 + v1);
if ( v3 && v3 != (_DWORD *)-1 )
{
do
{
result = v6;
if ( v6 < v3[11] )
break;
*(_DWORD *)(v2 + v1) = *v3;
v4 = *(HWND *)((char *)v3 + 18);
if ( v4 )
{
PostMessageA(v4, 0x3BDu, wParam, v3[8]);
v1 = hMem;
}
result = (DWORD)FreeChannelNode(v3);
v3 = *(_DWORD **)(v2 + v1);
}
while ( v3 );
}
++wParam;
v2 += 4;
}
while ( v2 < 308 );
if ( !*(_DWORD *)(v1 + 420) && !pwh )
{
v5 = 244;
do
{
result = *(_DWORD *)(v5 + v1);
if ( result )
{
if ( result != -1 )
{
result = PostMessageA(*(HWND *)(v1 + 4), 0x400u, 0, v1);
v1 = hMem;
}
}
v5 += 4;
}
while ( v5 < 308 );
}
return result;
}

//----- (0101DD5D) --------------------------------------------------------
int __stdcall WaveMixPump()
{
int result; // eax
LPWAVEHDR i; // esi
struct wavehdr_tag *v2; // eax

result = dword_1025798;
hMem = dword_1025798;
if ( dword_1025798 )
{
LABEL_5:
for ( i = pwh; i; i = (LPWAVEHDR)i[1].dwUser )
{
if ( i->dwFlags & 1 )
{
RemoveFromPlayingQueue(i);
i[1].lpData = (LPSTR)1;
goto LABEL_5;
}
}
FreePlayedBlocks();
do
{
v2 = (struct wavehdr_tag *)GetWaveBlock();
result = MixerPlay(v2, 1);
}
while ( result );
}
return result;
}
// 1025798: using guessed type int dword_1025798;

//----- (0101DDAD) --------------------------------------------------------
LRESULT __stdcall WndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
if ( Msg != 957 && Msg != 1024 )
return DefWindowProcA(hWnd, Msg, wParam, lParam);
WaveMixPump();
return 0;
}

//----- (0101DDD8) --------------------------------------------------------
signed int __stdcall NoResetRemix(int a1, int a2)
{
WaveMixPump();
return 1;
}

//----- (0101DDE8) --------------------------------------------------------
signed int __stdcall ResetRemix(int a1, int a2)
{
struct wavehdr_tag *v2; // eax
struct wavehdr_tag *v3; // esi
int v4; // esi
LPARAM v5; // eax
bool v6; // zf
bool v7; // sf
LPWAVEHDR i; // esi
signed int v10; // [esp+Ch] [ebp-8h]
int v11; // [esp+10h] [ebp-4h]

v10 = 0;
v11 = 0;
*(_DWORD *)(hMem + 412) = a1;
DestroyPlayQueue();
SwapWaveBlocks();
while ( 1 )
{
v2 = (struct wavehdr_tag *)GetWaveBlock();
v3 = v2;
if ( !v2 )
break;
if ( !MixerPlay(v2, 0) )
{
v3[1].lpData = (LPSTR)1;
break;
}
AddToPlayingQueue(v3);
}
v4 = *(_DWORD *)(hMem + 412);
MyWaveOutReset(*(HWAVEOUT *)(hMem + 12));
v5 = hMem;
v6 = *(_DWORD *)(hMem + 404) == 0;
v7 = *(_DWORD *)(hMem + 404) < 0;
*(_DWORD *)(hMem + 412) = v4;
if ( !v7 && !v6 )
{
waveOutPause(*(HWAVEOUT *)(v5 + 12));
v5 = hMem;
v10 = 1;
v11 = 0;
}
for ( i = pwh; i; i = (LPWAVEHDR)i[1].dwUser )
{
if ( waveOutWrite(*(HWAVEOUT *)(v5 + 12), i, 0x20u) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to write block to device", "WavMix32", 0x30u);
i[1].lpData = (LPSTR)1;
RemoveFromPlayingQueue(i);
}
v5 = hMem;
if ( v10 )
{
if ( ++v11 >= *(_DWORD *)(hMem + 404) )
{
waveOutRestart(*(HWAVEOUT *)(hMem + 12));
v5 = hMem;
v10 = 0;
}
}
}
if ( v10 )
waveOutRestart(*(HWAVEOUT *)(v5 + 12));
return 1;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101DF07) --------------------------------------------------------
void __stdcall ResetWavePosIfNoChannelData()
{
signed int v0; // edx
_DWORD *v1; // eax

if ( !pwh )
{
v0 = 0;
v1 = (_DWORD *)(hMem + 244);
while ( !*v1 || *v1 == -1 )
{
++v0;
++v1;
if ( v0 >= 16 )
{
SetWaveOutPosition(0);
return;
}
}
}
}

//----- (0101DF3D) --------------------------------------------------------
signed int __stdcall WaveMixPlay(int a1)
{
_WORD *v1; // ebx
const void *v2; // edi
int v3; // eax
signed int v4; // edx
signed int v5; // ecx
_DWORD *v6; // eax
bool v7; // zf
int v8; // eax
int v9; // edx
int v10; // ecx
int v11; // ecx
int v12; // esi
_DWORD **v13; // ebx
LPARAM v14; // esi
DWORD v15; // eax
_DWORD *v16; // eax
_DWORD *v17; // edi
int v18; // ecx
int v19; // eax
__int16 v20; // bx
_DWORD **v21; // ebx
_DWORD *i; // eax
_DWORD *v23; // ST24_4
DWORD v24; // eax
_DWORD *v25; // ecx
_DWORD *v26; // eax
DWORD v27; // eax
unsigned __int16 v28; // ax
int v29; // ebx
signed int v30; // edi
struct wavehdr_tag *v31; // eax
int j; // eax
struct wavehdr_tag *v33; // eax
const CHAR *v35; // [esp-14h] [ebp-24h]
signed int v36; // [esp+8h] [ebp-8h]
signed int v37; // [esp+Ch] [ebp-4h]
DWORD v38; // [esp+18h] [ebp+8h]

++dword_1027BF8;
v37 = 12;
v36 = 0;
if ( dword_1027BF8 > 1 )
goto LABEL_97;
if ( !a1 )
{
if ( dword_1027BE4 )
MessageBoxA(0, "NULL parameters pointer passed to WaveMixPlay!", "WavMix32", 0x30u);
v37 = 5;
goto LABEL_97;
}
v1 = SessionToGlobalDataPtr(*(_WORD **)(a1 + 2));
hMem = (LPARAM)v1;
if ( !v1 )
{
if ( !dword_1027BE4 )
{
LABEL_10:
v37 = 5;
goto LABEL_97;
}
v35 = "Invalid session handle passed to WaveMixPlay";
LABEL_9:
MessageBoxA(0, v35, "WavMix32", 0x30u);
goto LABEL_10;
}
v2 = *(const void **)(a1 + 10);
if ( !IsValidLPMIXWAVE(*(_DWORD *)(a1 + 10)) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Invalid or NULL wave pointer passed to WaveMixPlay!", "WavMix32", 0x30u);
goto LABEL_10;
}
LOBYTE(v3) = HasCurrentOutputFormat(v2);
if ( !v3 )
{
_wsprintfA(
aWavemixV23ByAn,
"The LPMIXWAVE 0x%lx is not in the current output format, close the wave and reopen it.",
v2);
if ( dword_1027BE4 )
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x30u);
v37 = 8;
goto LABEL_97;
}
if ( *((_DWORD *)v1 + 4) )
{
if ( !*((_DWORD *)v1 + 77) )
{
if ( !dword_1027BE4 )
goto LABEL_10;
v35 = "You must open a channel before you can play a wave!";
goto LABEL_9;
}
if ( *(_BYTE *)(a1 + 18) & 2 )
{
v4 = 0;
v5 = 0;
v6 = v1 + 156;
do
{
if ( *(v6 - 17) != -1 )
{
if ( !*(_DWORD *)&v1[2 * v4 + 122] )
break;
if ( v5 != v4 && *v6 < *(_DWORD *)&v1[2 * v4 + 156] )
v4 = v5;
}
++v5;
++v6;
}
while ( v5 < 16 );
*(_DWORD *)(a1 + 6) = v4;
}
else
{
v4 = *(_DWORD *)(a1 + 6);
}
++*((_DWORD *)v1 + 94);
v7 = *(_DWORD *)&v1[2 * v4 + 122] == -1;
*(_DWORD *)&v1[2 * v4 + 156] = *((_DWORD *)v1 + 94);
if ( v7 )
goto LABEL_10;
v8 = GetChannelNode();
if ( !v8 )
goto LABEL_97;
qmemcpy((void *)(v8 + 4), (const void *)a1, 0x1Cu);
v10 = *(_DWORD *)(v8 + 14);
*(_DWORD *)(v8 + 32) = v10;
*(_DWORD *)(v8 + 36) = *(_DWORD *)(v10 + 20);
v11 = *(_DWORD *)(v10 + 16);
*(_DWORD *)(v8 + 48) = v11;
v12 = (unsigned __int16)v1[196];
v13 = (_DWORD **)(v1 + 220);
*(_DWORD *)(v8 + 52) = *(_DWORD *)(v8 + 36) + v11 - v12;
*(_DWORD *)(v8 + 10) = v9;
if ( *v13 )
{
*(_DWORD *)v8 = **v13;
**v13 = v8;
*v13 = (_DWORD *)v8;
}
else
{
*v13 = (_DWORD *)v8;
*(_DWORD *)v8 = v8;
}
if ( !(*(_BYTE *)(v8 + 22) & 8) )
{
ResetWavePosIfNoChannelData();
v14 = hMem;
if ( *(signed int (__stdcall **)(int, int))(hMem + 432) == ResetRemix )
{
v15 = MyWaveOutGetPosition(*(HWAVEOUT *)(hMem + 12), *(_DWORD *)(hMem + 420));
v14 = hMem;
}
else
{
v15 = *(_DWORD *)(hMem + 412);
}
v38 = v15;
if ( !*(_DWORD *)(v14 + 440) )
goto LABEL_84;
do
{
v16 = *(_DWORD **)(v14 + 440);
v17 = (_DWORD *)*v16;
if ( (_DWORD *)*v16 == v16 )
*(_DWORD *)(v14 + 440) = 0;
else
*v16 = *v17;
v18 = *(_DWORD *)((char *)v17 + 22);
v19 = *(_DWORD *)((char *)v17 + 10);
*v17 = 0;
if ( v18 & 0x10 )
{
*((_WORD *)v17 + 28) = *((_WORD *)v17 + 14);
v20 = *((_WORD *)v17 + 15);
}
else
{
*((_WORD *)v17 + 28) = *(_WORD *)(v14 + 4 * v19 + 180);
v20 = *(_WORD *)(v14 + 4 * v19 + 182);
}
*((_WORD *)v17 + 29) = v20;
if ( *((_WORD *)v17 + 28) > 0xAu )
*((_WORD *)v17 + 28) = 10;
if ( *((_WORD *)v17 + 29) > 0xAu )
*((_WORD *)v17 + 29) = 10;
if ( v18 & 1 )
{
v21 = (_DWORD **)(v14 + 4 * v19 + 244);
for ( i = *v21; i; i = v23 )
{
v23 = (_DWORD *)*i;
FreeChannelNode(i);
}
v7 = pwh == 0;
*v21 = v17;
if ( !v7 )
v36 = 1;
if ( *((_BYTE *)v17 + 22) & 4 )
v24 = v38;
else
v24 = *(_DWORD *)(v14 + 412);
v17[10] = v24;
}
else
{
v25 = (_DWORD *)(v14 + 4 * v19 + 244);
v26 = (_DWORD *)*v25;
if ( *v25 )
{
while ( *v26 )
v26 = (_DWORD *)*v26;
*v26 = v17;
v27 = v26[11];
if ( *((_BYTE *)v17 + 22) & 4 )
{
if ( v27 <= v38 )
v27 = v38;
}
else if ( *(_DWORD *)(v14 + 412) > v27 )
{
v27 = *(_DWORD *)(v14 + 412);
}
}
else
{
v27 = v38;
*v25 = v17;
if ( !(*((_BYTE *)v17 + 22) & 4) )
v27 = *(_DWORD *)(v14 + 412);
}
v17[10] = v27;
if ( *(_DWORD *)(v14 + 412) > v17[10] )
v36 = 1;
}
v28 = *((_WORD *)v17 + 13);
if ( v28 == -1 )
v17[11] = -1;
else
v17[11] = v17[10] + v17[9] * (v28 + 1) - *(unsigned __int16 *)(v14 + 392);
}
while ( *(_DWORD *)(v14 + 440) );
if ( !v36 )
goto LABEL_84;
if ( !(*(int (__stdcall **)(DWORD, _DWORD))(v14 + 432))(v38, 0) )
{
v14 = hMem;
LABEL_84:
v29 = 0;
if ( pwh || *(_DWORD *)(v14 + 404) <= 0 )
{
v30 = 0;
}
else
{
waveOutPause(*(HWAVEOUT *)(v14 + 12));
v30 = 1;
}
v31 = (struct wavehdr_tag *)GetWaveBlock();
for ( j = MixerPlay(v31, 1); j; j = MixerPlay(v33, 1) )
{
if ( v30 )
{
if ( ++v29 >= *(_DWORD *)(hMem + 404) )
{
waveOutRestart(*(HWAVEOUT *)(hMem + 12));
v30 = 0;
}
}
v33 = (struct wavehdr_tag *)GetWaveBlock();
}
if ( v30 )
waveOutRestart(*(HWAVEOUT *)(hMem + 12));
goto LABEL_96;
}
}
LABEL_96:
v37 = 0;
goto LABEL_97;
}
if ( dword_1027BE4 )
MessageBoxA(0, "Wave device not allocated, call WaveMixActivate(hMixSession,TRUE)", "WavMix32", 0x30u);
v37 = 4;
LABEL_97:
--dword_1027BF8;
return v37;
}
// 1027BE4: using guessed type int dword_1027BE4;
// 1027BF8: using guessed type int dword_1027BF8;

//----- (0101E373) --------------------------------------------------------
signed int __stdcall WaveMixFlushChannel(_WORD *a1, signed int a2, char a3)
{
_DWORD *v3; // ebx
_WORD *v4; // eax
_WORD *v5; // esi
signed int v6; // ecx
int v7; // eax
_DWORD **v8; // edi
_DWORD *v9; // eax
DWORD v10; // eax
signed int v13; // [esp+8h] [ebp-4h]
int v14; // [esp+14h] [ebp+8h]

v3 = 0;
v13 = 0;
v4 = SessionToGlobalDataPtr(a1);
v5 = v4;
hMem = (LPARAM)v4;
if ( v4 )
{
if ( a3 & 1 )
{
v6 = 0;
v7 = 16;
goto LABEL_9;
}
v6 = a2;
if ( a2 < 0 || a2 >= 16 )
return 11;
if ( *(_DWORD *)&v4[2 * a2 + 122] != -1 )
{
v7 = a2 + 1;
if ( !(__OFSUB__(a2, a2 + 1) ^ 1) )
return 0;
LABEL_9:
v8 = (_DWORD **)&v5[2 * v6 + 122];
v14 = v7 - v6;
do
{
v9 = *v8;
if ( *v8 != (_DWORD *)-1 )
{
*v8 = v3;
if ( v9 != v3 )
{
v13 = 1;
do
{
v3 = (_DWORD *)*v9;
FreeChannelNode(v9);
v9 = v3;
}
while ( v3 );
}
}
++v8;
--v14;
}
while ( v14 );
if ( (_DWORD *)v13 != v3 && !(a3 & 2) && *((_DWORD **)v5 + 4) != v3 )
{
v10 = MyWaveOutGetPosition(*((HWAVEOUT *)v5 + 3), *((_DWORD *)v5 + 105));
(*((void (__stdcall **)(DWORD, _DWORD *))v5 + 108))(v10, v3);
}
return 0;
}
}
return 5;
}

//----- (0101E434) --------------------------------------------------------
signed int __stdcall WaveMixCloseChannel(_WORD *a1, signed int a2, char a3)
{
signed int result; // eax
signed int v4; // esi
int v5; // ecx
LPARAM v6; // eax
_DWORD *v7; // edx
int v8; // ecx

hMem = (LPARAM)SessionToGlobalDataPtr(a1);
if ( !hMem )
return 5;
v4 = a2;
result = WaveMixFlushChannel(a1, a2, a3 | 2);
if ( !result )
{
if ( a3 & 1 )
{
v4 = 0;
v5 = 16;
}
else
{
v5 = a2 + 1;
if ( !(__OFSUB__(a2, a2 + 1) ^ 1) )
return 0;
}
v6 = hMem;
v7 = (_DWORD *)(hMem + 4 * v4 + 244);
v8 = v5 - v4;
do
{
if ( *v7 != -1 )
{
*v7 = -1;
--*(_DWORD *)(v6 + 308);
}
++v7;
--v8;
}
while ( v8 );
return 0;
}
return result;
}

//----- (0101E4A9) --------------------------------------------------------
int __stdcall WaveMixFreeWave(int a1, LPCVOID pMem)
{
_WORD *v2; // ebx
LPCVOID *v4; // edi
_DWORD **v5; // ebx
_DWORD *v6; // esi
HGLOBAL v7; // eax
HGLOBAL v8; // eax
HGLOBAL v9; // eax
HGLOBAL v10; // eax
_DWORD *v11; // [esp+Ch] [ebp+8h]
char *pMema; // [esp+10h] [ebp+Ch]

v2 = SessionToGlobalDataPtr((_WORD *)a1);
if ( !v2 )
return 5;
v4 = (LPCVOID *)pMem;
if ( !IsValidLPMIXWAVE((int)pMem) )
return 5;
v5 = (_DWORD **)(v2 + 122);
pMema = (char *)16;
do
{
v6 = *v5;
if ( *v5 != (_DWORD *)-1 )
{
v11 = 0;
while ( v6 )
{
if ( (LPCVOID *)v6[8] == v4 )
{
if ( v11 )
{
*v11 = *v6;
FreeChannelNode(v6);
v6 = (_DWORD *)*v11;
}
else
{
v6 = (_DWORD *)*v6;
FreeChannelNode(*v5);
*v5 = v6;
}
}
else
{
v11 = v6;
v6 = (_DWORD *)*v6;
}
}
}
++v5;
--pMema;
}
while ( pMema );
if ( v4[4] )
{
v7 = GlobalHandle(v4[4]);
GlobalUnlock(v7);
v8 = GlobalHandle(v4[4]);
GlobalFree(v8);
}
*((_WORD *)v4 + 32) = 0;
v9 = GlobalHandle(v4);
GlobalUnlock(v9);
v10 = GlobalHandle(v4);
GlobalFree(v10);
return 0;
}

//----- (0101E579) --------------------------------------------------------
_WORD *__userpurge BitsPerSampleAlign@<eax>(int a1@<eax>, LPCVOID pMem, int a3, __int16 a4, int a5)
{
_WORD *v6; // edi
int v7; // edi
unsigned int v8; // esi
SIZE_T v9; // eax
HGLOBAL v10; // eax
_WORD *v11; // eax
_WORD *v12; // ecx
_WORD *v13; // ebx
_BYTE *v14; // edi
char *i; // edx
HGLOBAL v16; // eax
HGLOBAL v17; // eax
int v18; // [esp+Ch] [ebp+Ch]

if ( (_WORD)a3 == a4 )
return pMem;
if ( ((_WORD)a3 == 8 || (_WORD)a3 == 16) && (a4 == 8 || a4 == 16) )
{
LOWORD(a1) = (unsigned __int16)a3 >> 3;
v7 = a1;
v8 = *(_DWORD *)a5 / (unsigned int)((unsigned __int16)a3 >> 3);
v9 = v8 * ((unsigned __int16)a4 >> 3);
*(_DWORD *)a5 = v9;
v10 = GlobalAlloc(0x2002u, v9);
v11 = GlobalLock(v10);
v12 = v11;
if ( v11 )
{
if ( (unsigned __int16)v7 <= (unsigned __int16)((unsigned __int16)a4 >> 3) )
{
for ( i = (char *)pMem; v8; --v8 )
{
LOWORD(v7) = *i;
v7 = (v7 - 128) << 8;
*v11 = v7;
++v11;
++i;
}
}
else
{
v13 = pMem;
v14 = v11;
if ( v8 )
{
v18 = v8;
do
{
*v14++ = *v13 / 256 + -128;
++v13;
--v18;
}
while ( v18 );
}
}
v6 = v12;
}
else
{
if ( dword_1027BE4 )
MessageBoxA(
0,
"Unable to allocate memory for waveform data.  Try making more memory available by closing other applications.",
"WavMix32",
0x40u);
v6 = 0;
}
}
else
{
v6 = 0;
}
v16 = GlobalHandle(pMem);
GlobalUnlock(v16);
v17 = GlobalHandle(pMem);
GlobalFree(v17);
return v6;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101E686) --------------------------------------------------------
_BYTE *__stdcall ChannelAlign(LPCVOID pMem, __int16 a2, __int16 a3, __int16 a4, int a5)
{
unsigned int v6; // edi
SIZE_T v7; // eax
HGLOBAL v8; // eax
_BYTE *v9; // eax
_BYTE *v10; // ebx
unsigned __int8 *v11; // ecx
_BYTE *v12; // eax
_WORD *v13; // eax
_WORD *v14; // esi
HGLOBAL v15; // eax
HGLOBAL v16; // eax

if ( a2 == a3 )
return pMem;
v6 = *(_DWORD *)a5 / (unsigned int)(unsigned __int16)a4 / (unsigned __int16)a2;
v7 = v6 * (unsigned __int16)a4 * (unsigned __int16)a3;
*(_DWORD *)a5 = v7;
v8 = GlobalAlloc(0x2002u, v7);
v9 = GlobalLock(v8);
v10 = v9;
if ( v9 )
{
v11 = (unsigned __int8 *)pMem;
if ( (unsigned __int16)a2 >= (unsigned __int16)a3 )
{
v14 = v9;
if ( a4 == 1 )
{
for ( ; v6; --v6 )
{
*(_BYTE *)v14 = (*v11 + v11[1]) / 2;
v14 = (_WORD *)((char *)v14 + 1);
v11 += 2;
}
}
else
{
for ( ; v6; --v6 )
{
*v14 = (*(signed __int16 *)v11 + *((signed __int16 *)v11 + 1)) / 2;
++v14;
v11 += 4;
}
}
}
else if ( a4 == 1 )
{
for ( ; v6; --v6 )
{
*v9 = *v11;
v12 = v9 + 1;
*v12 = *v11;
v9 = v12 + 1;
++v11;
}
}
else
{
for ( ; v6; --v6 )
{
*(_WORD *)v9 = *(_WORD *)v11;
v13 = v9 + 2;
*v13 = *(_WORD *)v11;
v9 = v13 + 1;
v11 += 2;
}
}
}
else
{
if ( dword_1027BE4 )
MessageBoxA(
0,
"Unable to allocate memory for waveform data.  Try making more memory available by closing other applications.",
"WavMix32",
0x40u);
v10 = 0;
}
v15 = GlobalHandle(pMem);
GlobalUnlock(v15);
v16 = GlobalHandle(pMem);
GlobalFree(v16);
return v10;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101E7B0) --------------------------------------------------------
void __stdcall AvgSample(_WORD *a1, unsigned __int8 *a2, int a3, int a4, int a5)
{
int v5; // edi
_BYTE *v6; // esi
unsigned __int8 *v7; // ecx
int v8; // eax
int v9; // edx
int v10; // ebx
int v11; // edx
signed __int16 *v12; // edi
signed __int16 *v13; // ecx
int v14; // eax
int v15; // esi
int v16; // edx
bool v17; // zf
int v18; // [esp+18h] [ebp+Ch]

if ( a4 == 1 )
{
v5 = a5;
if ( a5 > 0 )
{
v6 = a1;
do
{
v7 = a2++;
v8 = 0;
if ( a3 > 0 )
{
v9 = a3;
do
{
v10 = *v7;
v7 += a5;
--v9;
v8 = v8 + v10 - 128;
}
while ( v9 );
}
*v6++ = (unsigned int)(v8 / a3) + -128;
--v5;
}
while ( v5 );
}
}
else
{
v11 = a5;
v12 = (signed __int16 *)a2;
if ( a5 > 0 )
{
v18 = a5;
while ( 1 )
{
v13 = v12;
v14 = 0;
++v12;
if ( a3 > 0 )
{
v15 = a3;
v16 = 2 * v11;
do
{
v14 += *v13;
v13 = (signed __int16 *)((char *)v13 + v16);
--v15;
}
while ( v15 );
}
v17 = v18-- == 1;
*a1 = v14 / a3;
if ( v17 )
break;
v11 = a5;
}
}
}
}

//----- (0101E83A) --------------------------------------------------------
int __stdcall RepSample(_BYTE *a1, unsigned __int8 *a2, signed int a3, int a4, int a5)
{
int v5; // ebx
int result; // eax
unsigned __int8 *v7; // edi
char v8; // cl
_BYTE *v9; // esi
_BYTE *v10; // esi
int v11; // edx
int v12; // ebx
_WORD *v13; // esi
_WORD *v14; // edi
int v15; // ecx
int v16; // edx
int v17; // [esp+14h] [ebp+8h]
_WORD *v18; // [esp+18h] [ebp+Ch]
unsigned __int8 *v19; // [esp+20h] [ebp+14h]

if ( a4 == 1 )
{
v5 = a5;
result = (int)a1;
if ( a5 > 0 )
{
v7 = a2;
do
{
v8 = *v7;
v9 = a1++;
result = (v7[v5] - *v7) / a3;
*v9 = *v7;
v10 = &v9[v5];
if ( a3 > 1 )
{
v11 = a3 - 1;
do
{
v8 += result;
*v10 = v8;
v10 += v5;
--v11;
}
while ( v11 );
}
++v7;
--a5;
}
while ( a5 );
}
}
else
{
v19 = a2;
v18 = a1;
result = a5;
if ( a5 > 0 )
{
v12 = a5;
v17 = a5;
do
{
v13 = v18;
LOWORD(v15) = *(_WORD *)v19;
++v18;
v14 = &v13[v12];
result = ((signed __int16)v13[v12] - *(signed __int16 *)v19) / a3;
*v13 = *(_WORD *)v19;
v15 = (signed __int16)v15;
if ( a3 > 1 )
{
v16 = a3 - 1;
do
{
v15 += result;
*v14 = v15;
v14 = (_WORD *)((char *)v14 + v12 * 2);
--v16;
}
while ( v16 );
}
v19 += 2;
--v17;
}
while ( v17 );
}
}
return result;
}

//----- (0101E8F5) --------------------------------------------------------
LPCVOID __stdcall SamplesPerSecAlign(LPCVOID pMem, int a2, int a3, __int16 a4, __int16 a5, int a6)
{
LPCVOID result; // eax
_DWORD *v7; // ecx
int v8; // edi
unsigned int v9; // eax
int v10; // esi
unsigned int v11; // eax
HGLOBAL v12; // eax
_BYTE *v13; // ebx
HGLOBAL v14; // eax
HGLOBAL v15; // eax
int v16; // ecx
_BYTE *v17; // eax
int v18; // esi
_BYTE *v19; // eax
HGLOBAL v20; // eax
HGLOBAL v21; // eax
int v22; // [esp+8h] [ebp-8h]
LPCVOID v23; // [esp+Ch] [ebp-4h]
int v24; // [esp+1Ch] [ebp+Ch]
int v25; // [esp+1Ch] [ebp+Ch]
int v26; // [esp+20h] [ebp+10h]
int v27; // [esp+20h] [ebp+10h]
unsigned int v28; // [esp+2Ch] [ebp+1Ch]

if ( a2 == a3 )
return pMem;
v7 = (_DWORD *)a6;
v8 = (unsigned __int16)a4 * (unsigned __int16)a5;
v28 = *(_DWORD *)a6 / (unsigned int)v8;
if ( a3 <= (unsigned int)a2 )
{
v11 = a2 / (unsigned int)a3;
v24 = 0;
v26 = v11;
v10 = v28 / v11;
}
else
{
v9 = a3 / (unsigned int)a2;
v26 = 0;
v24 = v9;
v10 = v28 * v9;
}
*v7 = v8 * v10;
v12 = GlobalAlloc(0x2002u, v8 * v10);
v13 = GlobalLock(v12);
if ( v13 )
{
v23 = pMem;
v22 = (int)v13;
if ( v24 <= 0 )
{
if ( v10 != 1 )
{
v25 = v10 - 1;
do
{
AvgSample(v13, (unsigned __int8 *)pMem, v26, (unsigned __int16)a4, (unsigned __int16)a5);
pMem = (char *)pMem + v8 * v26;
v13 += v8;
--v25;
}
while ( v25 );
}
if ( v8 > 0 )
{
v19 = pMem;
do
{
*v13++ = *v19++;
--v8;
}
while ( v8 );
}
}
else
{
if ( v28 != 1 )
{
v27 = v28 - 1;
do
{
RepSample(v13, (unsigned __int8 *)pMem, v24, (unsigned __int16)a4, (unsigned __int16)a5);
pMem = (char *)pMem + v8;
v13 += v8 * v24;
--v27;
}
while ( v27 );
}
v16 = v24;
if ( v24 > 0 )
{
do
{
v17 = pMem;
if ( v8 > 0 )
{
v18 = (unsigned __int16)a4 * (unsigned __int16)a5;
do
{
*v13++ = *v17++;
--v18;
}
while ( v18 );
}
--v16;
}
while ( v16 );
}
}
v20 = GlobalHandle(v23);
GlobalUnlock(v20);
v21 = GlobalHandle(v23);
GlobalFree(v21);
result = (LPCVOID)v22;
}
else
{
if ( dword_1027BE4 )
MessageBoxA(
0,
"Unable to allocate memory for waveform data.  Try making more memory available by closing other applications.",
"WavMix32",
0x40u);
v14 = GlobalHandle(pMem);
GlobalUnlock(v14);
v15 = GlobalHandle(pMem);
GlobalFree(v15);
result = 0;
}
return result;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101EA82) --------------------------------------------------------
LPCVOID __stdcall WaveFormatConvert(int a1, int a2, LPCVOID pMem, int a4)
{
LPCVOID result; // eax
_WORD *v5; // eax
_BYTE *v6; // eax

if ( *(_WORD *)(a2 + 2) == *(_WORD *)(a1 + 2)
&& *(_DWORD *)(a2 + 4) == *(_DWORD *)(a1 + 4)
&& *(_WORD *)(a2 + 14) == *(_WORD *)(a1 + 14) )
{
return pMem;
}
v5 = BitsPerSampleAlign(*(unsigned __int16 *)(a2 + 14), pMem, *(unsigned __int16 *)(a2 + 14), *(_WORD *)(a1 + 14), a4);
if ( v5 && (v6 = ChannelAlign(v5, *(_WORD *)(a2 + 2), *(_WORD *)(a1 + 2), *(_WORD *)(a1 + 14) >> 3, a4)) != 0 )
result = SamplesPerSecAlign(
v6,
*(_DWORD *)(a2 + 4),
*(_DWORD *)(a1 + 4),
*(_WORD *)(a1 + 14) >> 3,
*(_WORD *)(a1 + 2),
a4);
else
result = 0;
return result;
}

//----- (0101EB23) --------------------------------------------------------
CHAR *__stdcall WaveMixOpenWave(LPCVOID pMem, LPCSTR lpName, HMODULE hModule, LONG cch)
{
_WORD *v4; // eax
WORD v5; // cx
HGLOBAL v7; // eax
CHAR *v8; // edi
HRSRC v9; // eax
HRSRC v10; // esi
HGLOBAL v11; // eax
HGLOBAL v12; // eax
HGLOBAL v13; // eax
HGLOBAL v14; // eax
HGLOBAL v15; // eax
void *v16; // eax
const void *v17; // esi
LONG v18; // eax
LPCVOID v19; // esi
const void *v20; // ST08_4
int v21; // eax
int v22; // eax
const CHAR *v23; // [esp-10h] [ebp-A4h]
UINT v24; // [esp-Ch] [ebp-A0h]
struct _MMIOINFO pmmioinfo; // [esp+4h] [ebp-90h]
struct _MMCKINFO pmmcki; // [esp+4Ch] [ebp-48h]
HWAVEOUT phwo; // [esp+60h] [ebp-34h]
struct _MMCKINFO v28; // [esp+64h] [ebp-30h]
WAVEFORMATEX pwfx; // [esp+78h] [ebp-1Ch]
LPCVOID v30; // [esp+8Ch] [ebp-8h]
HGLOBAL hResData; // [esp+90h] [ebp-4h]
HMMIO hModulea; // [esp+A4h] [ebp+10h]

hResData = 0;
v30 = 0;
v4 = SessionToGlobalDataPtr(pMem);
pwfx.wFormatTag = v4[190];
pwfx.nChannels = v4[191];
pwfx.nSamplesPerSec = *((_DWORD *)v4 + 96);
pwfx.nAvgBytesPerSec = *((_DWORD *)v4 + 97);
v5 = v4[196];
hMem = (LPARAM)v4;
pwfx.nBlockAlign = v5;
pwfx.wBitsPerSample = v4[197];
pwfx.cbSize = 0;
if ( waveOutOpen(&phwo, 0xFFFFFFFF, &pwfx, 0, 0, 1u) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "The waveform device can't play this format.", "WavMix32", 0x30u);
return 0;
}
v7 = GlobalAlloc(0x2040u, 0x42u);
v8 = (CHAR *)GlobalLock(v7);
if ( !v8 )
{
if ( dword_1027BE4 )
MessageBoxA(
0,
"Unable to allocate memory for waveform data.  Try making more memory available by closing other applications.",
"WavMix32",
0x40u);
return 0;
}
if ( cch & 2 )
{
v9 = FindResourceA(hModule, lpName, "WAVE");
v10 = v9;
if ( !v9 || (hResData = LoadResource(hModule, v9)) == 0 )
{
if ( HIWORD(lpName) )
_wsprintfA(aWavemixV23ByAn, "Failed to open 'WAVE' resource '%s'.", lpName);
else
_wsprintfA(aWavemixV23ByAn, "Failed to open 'WAVE' resource %u.", (unsigned __int16)lpName);
if ( dword_1027BE4 )
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x30u);
goto LABEL_31;
}
memset(&pmmioinfo, 0, sizeof(pmmioinfo));
pmmioinfo.pchBuffer = (HPSTR)LockResource(hResData);
if ( !pmmioinfo.pchBuffer )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to lock 'WAVE' resource", "WavMix32", 0x30u);
FreeResource(hResData);
hResData = 0;
LABEL_31:
v11 = GlobalHandle(v8);
GlobalUnlock(v11);
v12 = GlobalHandle(v8);
GlobalFree(v12);
if ( v30 )
{
v13 = GlobalHandle(v30);
GlobalUnlock(v13);
v14 = GlobalHandle(v30);
GlobalFree(v14);
}
if ( hResData )
FreeResource(hResData);
return 0;
}
pmmioinfo.cchBuffer = SizeofResource(hModule, v10);
pmmioinfo.fccIOProc = 541934925;
pmmioinfo.adwInfo[0] = 0;
hModulea = mmioOpenA(0, &pmmioinfo, 0);
if ( !hModulea )
{
if ( !dword_1027BE4 )
goto LABEL_29;
v24 = pmmioinfo.wErrorRet;
v23 = "Failed to open resource, mmioOpen error=%u.\nMay need to make sure resource is marked read-write";
goto LABEL_28;
}
}
else if ( cch & 4 )
{
qmemcpy(&pmmioinfo, lpName, sizeof(pmmioinfo));
hModulea = mmioOpenA(0, &pmmioinfo, 0);
if ( !hModulea )
{
if ( !dword_1027BE4 )
goto LABEL_29;
v24 = pmmioinfo.wErrorRet;
v23 = "Failed to open memory file, mmioOpen error=%u.\nMay need to make sure memory is read-write";
LABEL_28:
_wsprintfA(aWavemixV23ByAn, v23, v24);
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x30u);
LABEL_29:
if ( hModulea )
mmioClose(hModulea, 0);
goto LABEL_31;
}
}
else
{
hModulea = mmioOpenA((LPSTR)lpName, 0, 0x10000u);
if ( !hModulea )
{
if ( dword_1027BE4 )
{
_wsprintfA(aWavemixV23ByAn, "Failed to open wave file %s.", lpName);
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x30u);
}
goto LABEL_29;
}
}
pmmcki.fccType = 1163280727;
if ( mmioDescend(hModulea, &pmmcki, 0, 0x20u) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "This is not a WAVE file.", "WavMix32", 0x30u);
goto LABEL_29;
}
v28.ckid = 544501094;
if ( mmioDescend(hModulea, &v28, &pmmcki, 0x10u) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "WAVE file is corrupted.", "WavMix32", 0x30u);
goto LABEL_29;
}
if ( mmioRead(hModulea, v8, 16) != 16 )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to read format chunk.", "WavMix32", 0x30u);
goto LABEL_29;
}
if ( *(_WORD *)v8 != 1 )
{
if ( dword_1027BE4 )
MessageBoxA(0, "The file is not a PCM file.", "WavMix32", 0x30u);
goto LABEL_29;
}
mmioAscend(hModulea, &v28, 0);
v28.ckid = 1635017060;
if ( mmioDescend(hModulea, &v28, &pmmcki, 0x10u) )
{
if ( dword_1027BE4 )
MessageBoxA(0, "WAVE file has no data chunk.", "WavMix32", 0x30u);
goto LABEL_29;
}
cch = v28.cksize;
if ( !v28.cksize )
{
if ( dword_1027BE4 )
MessageBoxA(0, "The data chunk has no data.", "WavMix32", 0x30u);
goto LABEL_29;
}
v15 = GlobalAlloc(0x2002u, v28.cksize);
v16 = GlobalLock(v15);
v17 = v16;
v30 = v16;
if ( !v16 )
{
if ( dword_1027BE4 )
MessageBoxA(
0,
"Unable to allocate memory for waveform data.  Try making more memory available by closing other applications.",
"WavMix32",
0x40u);
goto LABEL_29;
}
v18 = mmioRead(hModulea, (HPSTR)v16, cch);
if ( v18 != cch )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to read data chunk.", "WavMix32", 0x30u);
goto LABEL_29;
}
v19 = WaveFormatConvert(hMem + 380, (int)v8, v17, (int)&cch);
v30 = v19;
if ( !v19 )
{
if ( dword_1027BE4 )
MessageBoxA(0, "Failed to convert wave format.", "WavMix32", 0x30u);
goto LABEL_29;
}
mmioClose(hModulea, 0);
if ( hResData )
FreeResource(hResData);
*((_DWORD *)v8 + 5) = cch;
v20 = (const void *)(hMem + 380);
*((_DWORD *)v8 + 4) = v19;
*((_DWORD *)v8 + 8) = 0;
*((_DWORD *)v8 + 9) = 0;
*((_DWORD *)v8 + 7) = 0;
*((_WORD *)v8 + 32) = 21554;
_memmove(v8, v20, 0x10u);
if ( HIWORD(lpName) )
{
v21 = lstrlenA(lpName);
if ( v21 > 15 )
v22 = v21 - 15;
else
v22 = 0;
lstrcpyA(v8 + 48, &lpName[v22]);
}
else
{
_wsprintfA(v8 + 48, "res#%u", (unsigned __int16)lpName);
}
return v8;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0101F093) --------------------------------------------------------
unsigned int __stdcall FigureOutDMABufferSize(unsigned int a1, int a2)
{
unsigned int result; // eax
signed int v3; // ecx

result = a1;
if ( !a1 )
result = *(_DWORD *)(a2 + 4) * *(unsigned __int16 *)(a2 + 2) * ((unsigned int)*(unsigned __int16 *)(a2 + 14) >> 3) >> 4;
v3 = 344;
if ( result < 0x158 || (v3 = 11025, result > 0x2B11) )
result = v3;
return result;
}

//----- (0101F0D4) --------------------------------------------------------
int __stdcall RemoveInvalidIniNameCharacters(LPCSTR lpString)
{
CHAR *v1; // esi

v1 = (CHAR *)lpString;
if ( !lpString || !*lpString )
return 0;
do
{
if ( !_isalnum(*v1) && !_isspace(*v1) )
break;
++v1;
}
while ( *v1 );
do
*v1-- = 0;
while ( v1 >= lpString && _isspace(*v1) );
return lstrlenA(lpString);
}

//----- (0101F13D) --------------------------------------------------------
UINT __stdcall ShowWaveOutDevices()
{
UINT result; // eax
signed int v1; // [esp+0h] [ebp-40h]
signed int uDeviceID; // [esp+4h] [ebp-3Ch]
struct tagWAVEOUTCAPSA pwoc; // [esp+8h] [ebp-38h]

result = waveOutGetNumDevs();
v1 = result;
if ( result )
{
_wsprintfA(aWavemixV23ByAn, "%d waveOut Devices have been detected on your system.", result);
result = MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u);
for ( uDeviceID = 0; uDeviceID < v1; result = uDeviceID )
{
if ( !waveOutGetDevCapsA(uDeviceID, &pwoc, 0x34u) && RemoveInvalidIniNameCharacters(pwoc.szPname) )
_wsprintfA(
aWavemixV23ByAn,
"Device %i: %s\n\tVersion %u.%u",
uDeviceID,
pwoc.szPname,
BYTE1(pwoc.vDriverVersion),
LOBYTE(pwoc.vDriverVersion));
else
_wsprintfA(aWavemixV23ByAn, "waveOutGetDevCaps failed (err %u) for device %d", 1, uDeviceID);
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u);
++uDeviceID;
}
}
return result;
}

//----- (0101F20F) --------------------------------------------------------
const char *__stdcall GetOperatingSystemPrefix()
{
const char *result; // eax
bool v1; // cf

if ( GetVersion() < 0x80000000 )
return "WinNT:";
if ( GetVersion() >= 0x80000000 && (unsigned __int8)GetVersion() >= 4u )
return "Win95:";
if ( GetVersion() < 0x80000000 || (v1 = (unsigned __int8)GetVersion() < 4u, result = "Win31:", !v1) )
result = "OS_X:";
return result;
}

//----- (0101F25C) --------------------------------------------------------
int __stdcall ReadRegistryToGetMachineSpecificInfSection(int a1, LPSTR lpString1, int a3)
{
const char *v3; // eax
int v4; // esi
const char *v6; // eax
LONG cbData; // [esp+Ch] [ebp-44h]
int v8; // [esp+10h] [ebp-40h]
HKEY phkResult; // [esp+14h] [ebp-3Ch]
CHAR SubKey; // [esp+18h] [ebp-38h]

v8 = 0;
v3 = GetOperatingSystemPrefix();
v4 = lstrlenA(v3);
if ( a3 < v4 + 10 )
return 0;
_wsprintfA(&SubKey, "Device%u", a1);
if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\WaveMix", &phkResult) )
return 0;
v6 = GetOperatingSystemPrefix();
lstrcpyA(lpString1, v6);
cbData = a3 - v4;
if ( !RegQueryValueA(phkResult, &SubKey, &lpString1[v4], &cbData) && cbData > 0 )
v8 = 1;
RegCloseKey(phkResult);
return v8;
}

//----- (0101F315) --------------------------------------------------------
int __stdcall ReadRegistryInt(HKEY hKey, LPCSTR lpSubKey, int a3)
{
int result; // eax
LONG cbData; // [esp+0h] [ebp-14h]
CHAR Data; // [esp+4h] [ebp-10h]

if ( !hKey || (cbData = 10, RegQueryValueA(hKey, lpSubKey, &Data, &cbData)) )
result = a3;
else
result = _atol(&Data);
return result;
}

//----- (0101F36B) --------------------------------------------------------
signed int __stdcall ReadRegistryForAppSpecificConfigs(int a1)
{
int v1; // ebx
int v3; // eax
int v4; // eax
struct tagWAVEOUTCAPSA *v5; // ST04_4
UINT_PTR v6; // ST00_4
HKEY phkResult; // [esp+8h] [ebp-3Ch]
CHAR SubKey; // [esp+Ch] [ebp-38h]

v1 = *(_DWORD *)(a1 + 2);
if ( !(v1 & 0x400) || !*(_DWORD *)(a1 + 26) )
return 0;
if ( (v1 & 0x80u) == 0 )
{
*(_WORD *)(a1 + 20) = *(_WORD *)(hMem + 24);
}
else if ( *(unsigned __int16 *)(a1 + 20) >= waveOutGetNumDevs() )
{
*(_WORD *)(a1 + 20) = 0;
}
_wsprintfA(&SubKey, "WaveMix\\Device%u", *(unsigned __int16 *)(a1 + 20));
if ( RegOpenKeyA(*(HKEY *)(a1 + 26), &SubKey, &phkResult) )
return 0;
if ( !(v1 & 1) )
*(_WORD *)(a1 + 6) = ReadRegistryInt(phkResult, "Channels", 1);
if ( !(v1 & 2) )
*(_WORD *)(a1 + 8) = ReadRegistryInt(phkResult, "SamplesPerSec", 11);
if ( !(v1 & 4) )
*(_WORD *)(a1 + 10) = ReadRegistryInt(phkResult, "WaveBlocks", 3);
if ( !(v1 & 8) )
*(_WORD *)(a1 + 12) = ReadRegistryInt(phkResult, "WaveBlockLen", 0);
*(_WORD *)(a1 + 14) = 1;
if ( !(v1 & 0x20) )
*(_WORD *)(a1 + 16) = (unsigned __int16)ReadRegistryInt(phkResult, "Remix", 1) != 2;
if ( !(v1 & 0x40) )
{
v3 = DefaultGoodWavePos(*(unsigned __int16 *)(a1 + 20));
*(_WORD *)(a1 + 18) = (unsigned __int16)ReadRegistryInt(phkResult, "GoodWavePos", v3) != 0;
}
if ( !(v1 & 0x100) )
*(_WORD *)(a1 + 24) = ReadRegistryInt(phkResult, "ShowDebugDialogs", 0);
if ( !(v1 & 0x200) )
{
v4 = DefaultPauseBlocks(*(unsigned __int16 *)(a1 + 10));
*(_WORD *)(a1 + 22) = ReadRegistryInt(phkResult, "PauseBlocks", v4);
}
v5 = (struct tagWAVEOUTCAPSA *)(hMem + 124);
v6 = *(unsigned __int16 *)(a1 + 20);
*(_DWORD *)(a1 + 2) = 1023;
waveOutGetDevCapsA(v6, v5, 0x34u);
RegCloseKey(phkResult);
return 1;
}

//----- (0101F50B) --------------------------------------------------------
int __stdcall ShowCurrentSettings()
{
const char *v0; // esi
const char *v1; // edx
const char *v2; // ecx
struct tagWAVEOUTCAPSA pwoc; // [esp+0h] [ebp-38h]

if ( waveOutGetDevCapsA(*(_DWORD *)(hMem + 24), &pwoc, 0x34u) || !RemoveInvalidIniNameCharacters(pwoc.szPname) )
lstrcpyA(pwoc.szPname, "Unknown Device");
v0 = "cmixit";
if ( *(__int16 (__stdcall **)(_BYTE *, char *, char *, int, unsigned __int16))(hMem + 428) != cmixit )
v0 = "386 mixit";
v1 = "TRUE";
if ( !*(_DWORD *)(hMem + 420) )
v1 = "FALSE";
v2 = "Reset";
if ( *(signed int (__stdcall **)(int, int))(hMem + 432) != ResetRemix )
v2 = "NoReset";
_wsprintfA(
aWavemixV23ByAn,
"Using:\t%s.\n"
"\tRemix = %s\n"
"\tGoodGetPos=%s\n"
"\t%d ping pong wave blocks\n"
"\tWave block len = %lu bytes\n"
"\tpfnMixit=%s\n"
"\tSamplesPerSec=%lu,\n"
"\tChannels=%d\n"
"\tPauseBlocks=%d",
pwoc.szPname,
v2,
v1,
*(_DWORD *)(hMem + 400),
*(_DWORD *)(hMem + 396),
v0,
*(_DWORD *)(hMem + 384),
*(unsigned __int16 *)(hMem + 382),
*(_DWORD *)(hMem + 404));
return MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u);
}

//----- (0101F5F1) --------------------------------------------------------
int __stdcall Settings_OnInitDialog(HWND hWnd, int a2, int a3)
{
BOOL v3; // ST0C_4
HWND v4; // eax
BOOL v5; // ST0C_4
HWND v6; // eax
BOOL v7; // ST0C_4
HWND v8; // eax
BOOL v9; // ST0C_4
HWND v10; // eax
BOOL v11; // ST0C_4
HWND v12; // eax
HWND v13; // eax
HWND v14; // eax
HWND v15; // eax
HWND v16; // eax
HWND v17; // eax
HWND v18; // eax
HWND v19; // eax
HWND v20; // eax
HWND v21; // eax
HWND v22; // eax
HWND v23; // eax
HWND v24; // eax
HWND v25; // eax
HWND v26; // eax
HWND v27; // eax
HWND v28; // eax
HWND v29; // eax
MMRESULT v30; // eax
HWND v31; // eax
WPARAM v32; // ST0C_4
HWND v33; // eax
signed int v35; // [esp+Ch] [ebp-148h]
signed int uDeviceID; // [esp+10h] [ebp-144h]
struct tagWAVEOUTCAPSA pwoc; // [esp+1Ch] [ebp-138h]
CHAR String; // [esp+50h] [ebp-104h]

GetWindowTextA(hWnd, &String, 256);
_wsprintfA(aWavemixV23ByAn, &String, 2, 81);
SetWindowTextA(hWnd, aWavemixV23ByAn);
SetWindowLongA(hWnd, -21, a3);
v3 = *(_WORD *)(a3 + 6) > 1u;
v4 = GetDlgItem(hWnd, 1000);
SendMessageA(v4, 0xF1u, v3, 0);
v5 = *(_WORD *)(a3 + 16) != 0;
v6 = GetDlgItem(hWnd, 1001);
SendMessageA(v6, 0xF1u, v5, 0);
v7 = *(_WORD *)(a3 + 18) != 0;
v8 = GetDlgItem(hWnd, 1004);
SendMessageA(v8, 0xF1u, v7, 0);
v9 = *(_WORD *)(a3 + 14) != 0;
v10 = GetDlgItem(hWnd, 1005);
SendMessageA(v10, 0xF1u, v9, 0);
v11 = *(_WORD *)(a3 + 24) != 0;
v12 = GetDlgItem(hWnd, 1010);
SendMessageA(v12, 0xF1u, v11, 0);
v13 = GetDlgItem(hWnd, 1005);
EnableWindow(v13, 0);
v14 = GetDlgItem(hWnd, 1003);
SendMessageA(v14, 0xC5u, 2u, 0);
v15 = GetDlgItem(hWnd, 1007);
SendMessageA(v15, 0xC5u, 4u, 0);
v16 = GetDlgItem(hWnd, 1008);
SendMessageA(v16, 0xC5u, 2u, 0);
v17 = GetDlgItem(hWnd, 1011);
SendMessageA(v17, 0xC5u, 2u, 0);
v18 = GetDlgItem(hWnd, 1012);
GetWindowTextA(v18, &String, 100);
_wsprintfA(aWavemixV23ByAn, &String, 2, 10);
v19 = GetDlgItem(hWnd, 1012);
SetWindowTextA(v19, aWavemixV23ByAn);
v20 = GetDlgItem(hWnd, 1013);
GetWindowTextA(v20, &String, 100);
_wsprintfA(aWavemixV23ByAn, &String, 344, 11025);
v21 = GetDlgItem(hWnd, 1013);
SetWindowTextA(v21, aWavemixV23ByAn);
v22 = GetDlgItem(hWnd, 1014);
GetWindowTextA(v22, &String, 100);
_wsprintfA(aWavemixV23ByAn, &String, 0, 10);
v23 = GetDlgItem(hWnd, 1014);
SetWindowTextA(v23, aWavemixV23ByAn);
v24 = GetDlgItem(hWnd, 1015);
GetWindowTextA(v24, &String, 100);
_wsprintfA(aWavemixV23ByAn, &String, 16);
v25 = GetDlgItem(hWnd, 1015);
SetWindowTextA(v25, aWavemixV23ByAn);
_wsprintfA(aWavemixV23ByAn, "%d", *(unsigned __int16 *)(a3 + 10));
v26 = GetDlgItem(hWnd, 1003);
SetWindowTextA(v26, aWavemixV23ByAn);
_wsprintfA(aWavemixV23ByAn, "%d", *(unsigned __int16 *)(a3 + 12));
v27 = GetDlgItem(hWnd, 1007);
SetWindowTextA(v27, aWavemixV23ByAn);
_wsprintfA(aWavemixV23ByAn, "%d", *(unsigned __int16 *)(a3 + 8));
v28 = GetDlgItem(hWnd, 1008);
SetWindowTextA(v28, aWavemixV23ByAn);
_wsprintfA(aWavemixV23ByAn, "%d", *(unsigned __int16 *)(a3 + 22));
v29 = GetDlgItem(hWnd, 1011);
SetWindowTextA(v29, aWavemixV23ByAn);
uDeviceID = 0;
v35 = waveOutGetNumDevs();
if ( v35 > 0 )
{
do
{
v30 = waveOutGetDevCapsA(uDeviceID, &pwoc, 0x34u);
if ( v30 )
{
_wsprintfA(aWavemixV23ByAn, "waveOutGetDevCaps failed (err %u) for device %d", v30, uDeviceID);
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u);
}
else
{
_wsprintfA(aWavemixV23ByAn, "%d: %s", uDeviceID, pwoc.szPname);
v31 = GetDlgItem(hWnd, 1009);
SendMessageA(v31, 0x143u, 0, (LPARAM)aWavemixV23ByAn);
}
++uDeviceID;
}
while ( uDeviceID < v35 );
}
v32 = *(unsigned __int16 *)(a3 + 20);
v33 = GetDlgItem(hWnd, 1009);
SendMessageA(v33, 0x14Eu, v32, 0);
return 1;
}

//----- (0101FA63) --------------------------------------------------------
int __stdcall Settings_OnCommand(HWND hWnd, int a2, int a3, int a4)
{
_WORD *v4; // ebx
HWND v6; // eax
HWND v7; // eax
HWND v8; // eax
HWND v9; // eax
HWND v10; // eax
HWND v11; // eax
HWND v12; // eax
HWND v13; // eax
HWND v14; // eax
HWND v15; // eax
__int16 v16; // ax

v4 = (_WORD *)GetWindowLongA(hWnd, -21);
if ( a2 == 1 )
{
if ( v4 )
{
v6 = GetDlgItem(hWnd, 1000);
v4[3] = (SendMessageA(v6, 0xF0u, 0, 0) != 0) + 1;
v7 = GetDlgItem(hWnd, 1001);
v4[8] = SendMessageA(v7, 0xF0u, 0, 0) != 0;
v8 = GetDlgItem(hWnd, 1004);
v4[9] = SendMessageA(v8, 0xF0u, 0, 0) != 0;
v9 = GetDlgItem(hWnd, 1010);
v4[12] = SendMessageA(v9, 0xF0u, 0, 0) != 0;
v10 = GetDlgItem(hWnd, 1005);
v4[7] = SendMessageA(v10, 0xF0u, 0, 0) != 0;
v11 = GetDlgItem(hWnd, 1003);
GetWindowTextA(v11, aWavemixV23ByAn, 10);
v4[5] = _atoi(aWavemixV23ByAn);
v12 = GetDlgItem(hWnd, 1007);
GetWindowTextA(v12, aWavemixV23ByAn, 10);
v4[6] = _atoi(aWavemixV23ByAn);
v13 = GetDlgItem(hWnd, 1008);
GetWindowTextA(v13, aWavemixV23ByAn, 10);
v4[4] = _atoi(aWavemixV23ByAn);
v14 = GetDlgItem(hWnd, 1011);
GetWindowTextA(v14, aWavemixV23ByAn, 10);
v4[11] = _atoi(aWavemixV23ByAn);
v15 = GetDlgItem(hWnd, 1009);
GetWindowTextA(v15, aWavemixV23ByAn, 10);
if ( _isdigit(aWavemixV23ByAn[0]) )
v16 = _atoi(aWavemixV23ByAn);
else
v16 = 0;
v4[10] = v16;
EndDialog(hWnd, 1);
}
}
else
{
if ( a2 != 2 )
return 0;
EndDialog(hWnd, 0);
}
return 1;
}

//----- (0101FC24) --------------------------------------------------------
BOOL __stdcall SettingsDlgProc(HWND hWnd, UINT a2, WPARAM a3, LPARAM a4)
{
if ( a2 == 272 )
return Settings_OnInitDialog(hWnd, a3, a4);
if ( a2 != 273 )
return 0;
Settings_OnCommand(hWnd, (unsigned __int16)a3, a4, a3 >> 16);
return 1;
}

//----- (0101FC6D) --------------------------------------------------------
_DWORD *__stdcall MakeDlgTemplate(int a1, int a2, __int16 a3, __int16 a4, __int16 a5, __int16 a6, wchar_t *Str)
{
size_t v7; // eax
HGLOBAL v8; // eax
_DWORD *v9; // ebx

v7 = 2 * _wcslen(Str) + 24;
*(_DWORD *)a1 = v7;
if ( v7 & 3 )
*(_DWORD *)a1 = v7 - (v7 & 3) + 4;
v8 = GlobalAlloc(0x42u, *(_DWORD *)a1);
v9 = GlobalLock(v8);
if ( v9 )
{
v9[1] = 0;
*((_WORD *)v9 + 4) = 0;
*v9 = a2 | 0x10000000;
*((_WORD *)v9 + 5) = a3;
*((_WORD *)v9 + 6) = a4;
*((_WORD *)v9 + 7) = a5;
*((_WORD *)v9 + 8) = a6;
qmemcpy((char *)v9 + 22, Str, 2 * _wcslen(Str) + 2);
}
return v9;
}

//----- (0101FD0E) --------------------------------------------------------
_WORD *__stdcall AddDlgControl(int a1, LPCVOID pMem, __int16 a3, int a4, __int16 a5, __int16 a6, __int16 a7, __int16 a8, __int16 a9, wchar_t *Str)
{
const void *v10; // edi
HGLOBAL v11; // eax
SIZE_T v12; // ST04_4
HGLOBAL v13; // eax
HGLOBAL v14; // eax
int v15; // eax
char *pMema; // [esp+10h] [ebp+Ch]

v10 = pMem;
if ( pMem )
{
pMema = *(char **)a1;
*(_DWORD *)a1 += 2 * _wcslen(Str) + 25;
if ( *(_DWORD *)a1 & 3 )
*(_DWORD *)a1 = *(_DWORD *)a1 - (*(_DWORD *)a1 & 3) + 4;
v11 = GlobalHandle(v10);
GlobalUnlock(v11);
v12 = *(_DWORD *)a1;
v13 = GlobalHandle(v10);
v14 = GlobalReAlloc(v13, v12, 0x42u);
v10 = GlobalLock(v14);
if ( v10 )
{
v15 = (int)&pMema[(_DWORD)v10];
*(_DWORD *)(v15 + 4) = 0;
*(_DWORD *)v15 = a4 | 0x50000000;
*(_WORD *)(v15 + 8) = a6;
*(_WORD *)(v15 + 10) = a7;
*(_WORD *)(v15 + 12) = a8;
*(_WORD *)(v15 + 14) = a9;
*(_WORD *)(v15 + 16) = a5;
*(_DWORD *)(v15 + 18) = ((unsigned __int16)a3 << 16) | 0xFFFF;
_wcscpy((wchar_t *)&pMema[(_DWORD)v10 + 22], Str);
++*((_WORD *)v10 + 4);
}
}
return v10;
}

//----- (0101FDE1) --------------------------------------------------------
_WORD *__stdcall MakeSettingsDlgTemplate()
{
_DWORD *v0; // eax
_WORD *v1; // eax
_WORD *v2; // eax
_WORD *v3; // eax
_WORD *v4; // eax
_WORD *v5; // eax
_WORD *v6; // eax
_WORD *v7; // eax
_WORD *v8; // eax
_WORD *v9; // eax
_WORD *v10; // eax
_WORD *v11; // eax
_WORD *v12; // eax
_WORD *v13; // eax
_WORD *v14; // eax
_WORD *v15; // eax
_WORD *v16; // eax
_WORD *v17; // eax
int v19; // [esp+Ch] [ebp-4h]

v19 = 0;
v0 = MakeDlgTemplate((int)&v19, -2134376320, 0, 0, 212, 132, L"WavMix32 Settings (Ver %X.%X Static)");
v1 = AddDlgControl((int)&v19, v0, 128, 65537, 1, 155, 5, 50, 14, L"&Ok");
v2 = AddDlgControl((int)&v19, v1, 128, 0x10000, 2, 155, 25, 50, 14, L"&Cancel");
v3 = AddDlgControl((int)&v19, v2, 130, 0, 1012, 5, 5, 115, 8, L"Number of WaveBlocks (%d-%d):");
v4 = AddDlgControl((int)&v19, v3, 130, 0, 1013, 5, 20, 115, 8, L"Size of WaveBlocks (%d-%d):");
v5 = AddDlgControl((int)&v19, v4, 130, 0, 0xFFFF, 5, 35, 102, 8, L"Playback Frequency (11,22,44):");
v6 = AddDlgControl((int)&v19, v5, 130, 0, 0xFFFF, 5, 80, 57, 8, L"Playback Device:");
v7 = AddDlgControl((int)&v19, v6, 130, 0, 1014, 5, 50, 115, 8, L"Number of Pause Blocks (%d-%d):");
v8 = AddDlgControl((int)&v19, v7, 130, 0, 1015, 5, 65, 63, 8, L"Max Channels = %d");
v9 = AddDlgControl((int)&v19, v8, 129, 8454272, 1003, 125, 5, 25, 12, L"-1");
v10 = AddDlgControl((int)&v19, v9, 129, 8454272, 1007, 125, 20, 25, 12, L"-1");
v11 = AddDlgControl((int)&v19, v10, 129, 8454272, 1008, 125, 35, 25, 12, L"-1");
v12 = AddDlgControl((int)&v19, v11, 129, 8454272, 1011, 125, 50, 25, 12, L"-1");
v13 = AddDlgControl((int)&v19, v12, 133, 2162946, 1009, 65, 80, 140, 60, L"No Devices");
v14 = AddDlgControl((int)&v19, v13, 128, 65539, 1000, 5, 101, 40, 10, L"Stereo");
v15 = AddDlgControl((int)&v19, v14, 128, 65539, 1001, 55, 101, 60, 10, L"Reset Remix");
v16 = AddDlgControl((int)&v19, v15, 128, 65539, 1010, 125, 101, 78, 10, L"Show Debug Dialogs");
v17 = AddDlgControl((int)&v19, v16, 128, 65539, 1005, 5, 117, 40, 10, L"CMixit");
return AddDlgControl((int)&v19, v17, 128, 65539, 1004, 55, 117, 75, 10, L"Good Get Position");
}

//----- (01020059) --------------------------------------------------------
void __stdcall DestroySettingsDlgTemplate(LPCVOID pMem)
{
HGLOBAL v1; // eax
HGLOBAL v2; // eax

if ( pMem )
{
v1 = GlobalHandle(pMem);
GlobalUnlock(v1);
v2 = GlobalHandle(pMem);
GlobalFree(v2);
}
}

//----- (0102008D) --------------------------------------------------------
signed int __stdcall WaveMixGetConfig(_WORD *a1, int a2)
{
_WORD *v2; // eax
int v4; // ebx

v2 = SessionToGlobalDataPtr(a1);
hMem = (LPARAM)v2;
if ( !v2 )
return 5;
if ( !a2 )
return 11;
v4 = *(_DWORD *)(a2 + 2);
if ( v4 & 1 )
*(_WORD *)(a2 + 6) = v2[191];
if ( v4 & 2 )
*(_WORD *)(a2 + 8) = 11 * (*((_DWORD *)v2 + 96) / 0x2B11u);
if ( v4 & 4 )
*(_WORD *)(a2 + 10) = v2[200];
if ( v4 & 8 )
*(_WORD *)(a2 + 12) = v2[198];
if ( v4 & 0x10 )
*(_WORD *)(a2 + 14) = *((_DWORD *)v2 + 107) == (_DWORD)cmixit;
if ( v4 & 0x20 )
*(_WORD *)(a2 + 16) = *((_DWORD *)v2 + 108) == (_DWORD)ResetRemix;
if ( v4 & 0x40 )
*(_WORD *)(a2 + 18) = v2[210];
if ( (v4 & 0x80u) != 0 )
*(_WORD *)(a2 + 20) = v2[12];
if ( v4 & 0x100 )
*(_WORD *)(a2 + 24) = dword_1027BE4 != 0;
if ( v4 & 0x200 )
*(_WORD *)(a2 + 22) = v2[202];
return 0;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (0102018C) --------------------------------------------------------
BOOL __stdcall SaveConfigSettings(__int16 a1)
{
BOOL result; // eax

if ( (a1 & 0x80u) != 0 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(_DWORD *)(hMem + 24));
result = WritePrivateProfileStringA("general", "WaveOutDevice", aWavemixV23ByAn, FileName);
}
if ( a1 & 1 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(unsigned __int16 *)(hMem + 382));
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "Channels", aWavemixV23ByAn, FileName);
}
if ( a1 & 2 )
{
_wsprintfA(aWavemixV23ByAn, "%d", (unsigned __int16)(11 * (*(_DWORD *)(hMem + 384) / 0x2B11u)));
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "SamplesPerSec", aWavemixV23ByAn, FileName);
}
if ( a1 & 4 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(_DWORD *)(hMem + 400));
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "WaveBlocks", aWavemixV23ByAn, FileName);
}
if ( a1 & 8 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(unsigned __int16 *)(hMem + 396));
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "WaveBlockLen", aWavemixV23ByAn, FileName);
}
if ( a1 & 0x10 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(_DWORD *)(hMem + 428) == (_DWORD)cmixit);
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "CMixit", aWavemixV23ByAn, FileName);
}
if ( a1 & 0x20 )
{
_wsprintfA(aWavemixV23ByAn, "%d", (*(_DWORD *)(hMem + 432) != (_DWORD)ResetRemix) + 1);
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "Remix", aWavemixV23ByAn, FileName);
}
if ( a1 & 0x40 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(_DWORD *)(hMem + 420) == 0);
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "GoodWavePos", aWavemixV23ByAn, FileName);
}
if ( a1 & 0x100 )
{
_wsprintfA(aWavemixV23ByAn, "%d", dword_1027BE4 != 0);
result = WritePrivateProfileStringA("general", "ShowDebugDialogs", aWavemixV23ByAn, FileName);
}
if ( a1 & 0x200 )
{
_wsprintfA(aWavemixV23ByAn, "%d", *(_DWORD *)(hMem + 404));
result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "PauseBlocks", aWavemixV23ByAn, FileName);
}
return result;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (010203CD) --------------------------------------------------------
DWORD __stdcall SetIniFileName(HMODULE hModule)
{
DWORD result; // eax
CHAR *i; // eax

result = GetModuleFileNameA(hModule, FileName, 0x104u);
if ( result )
{
for ( i = &FileName[result]; *i != 92; --i )
;
*i = 0;
lstrcpyA(i, "\\WAVEMIX.INF");
result = 1;
}
return result;
}

//----- (01020412) --------------------------------------------------------
int __stdcall InitVolumeTable()
{
char *v0; // edi
signed int v1; // esi
int result; // eax
int v3; // [esp+Ch] [ebp-Ch]
int v4; // [esp+10h] [ebp-8h]
int v5; // [esp+14h] [ebp-4h]

v4 = 0;
v3 = 0;
v0 = (char *)&unk_10259F0;
do
{
v1 = -128;
v5 = v3;
do
{
v0[v1] = v5 / 10 + -128;
result = v4;
v5 += v4;
++v1;
}
while ( v1 < 128 );
++v4;
v3 -= 128;
v0 += 256;
}
while ( (signed int)v0 <= (signed int)&unk_10263F0 );
return result;
}

//----- (0102046F) --------------------------------------------------------
int __stdcall WaveMixStartup(HMODULE hModule)
{
WNDCLASSA WndClass; // [esp+4h] [ebp-28h]

if ( dword_1027BF4 )
return 1;
if ( !SetIniFileName(hModule) )
return 0;
InitVolumeTable();
dword_1027BE8 = GetPrivateProfileIntA("general", "debug", 0, FileName);
dword_1025968 = (int)cmixit;
dword_10257E0 = hModule;
WndClass.hCursor = LoadCursorA(0, (LPCSTR)0x7F00);
WndClass.hIcon = 0;
WndClass.lpszMenuName = 0;
WndClass.lpszClassName = "WavMix32";
WndClass.hbrBackground = (HBRUSH)GetStockObject(1);
WndClass.hInstance = dword_10257E0;
WndClass.style = 0;
WndClass.lpfnWndProc = WndProc;
WndClass.cbWndExtra = 0;
WndClass.cbClsExtra = 0;
if ( !RegisterClassA(&WndClass) )
return 0;
InitChannelNodes();
dword_1027BF4 = 1;
return 1;
}
// 1025968: using guessed type int dword_1025968;
// 1027BE8: using guessed type int dword_1027BE8;
// 1027BF4: using guessed type int dword_1027BF4;

//----- (0102053B) --------------------------------------------------------
signed int __stdcall WaveMixActivate(_WORD *a1, int a2)
{
_WORD *v2; // eax
int v3; // ecx
signed int result; // eax
unsigned int v5; // ST04_4
struct wavehdr_tag *v6; // eax
DWORD v7; // eax
bool v8; // zf

v2 = SessionToGlobalDataPtr(a1);
v3 = (int)v2;
hMem = (LPARAM)v2;
if ( !v2 )
return 5;
if ( a2 )
{
if ( dword_1025798 )
return dword_1025798 != (_DWORD)v2 ? 4 : 0;
if ( *((_DWORD *)v2 + 5) )
return 12;
dword_1025798 = (int)v2;
sndPlaySoundA(0, 0);
result = GetWaveDevice();
if ( result )
{
dword_1025798 = 0;
return result;
}
v5 = *(_DWORD *)(hMem + 412);
*(_DWORD *)(hMem + 16) = 1;
SetWaveOutPosition(v5);
do
v6 = (struct wavehdr_tag *)GetWaveBlock();
while ( MixerPlay(v6, 1) );
}
else
{
if ( *((_DWORD *)v2 + 4) )
{
v7 = MyWaveOutGetPosition(*((HWAVEOUT *)v2 + 3), *((_DWORD *)v2 + 105));
v3 = hMem;
*(_DWORD *)(hMem + 412) = v7;
}
ReleaseWaveDevice(v3);
v8 = hMem == dword_1025798;
*(_DWORD *)(hMem + 16) = 0;
if ( v8 )
dword_1025798 = 0;
}
return 0;
}
// 1025798: using guessed type int dword_1025798;

//----- (01020615) --------------------------------------------------------
MMRESULT __stdcall WaveMixConfigure(int a1, HWND hWndParent, int a3, int a4, int a5)
{
_WORD *v5; // esi
_WORD *v6; // eax
const DLGTEMPLATE *v7; // esi
INT_PTR v8; // edi
LPARAM v9; // eax
MMRESULT result; // eax
_WORD *v11; // esi
LPARAM *v12; // edi
UINT_PTR v13; // eax
LPARAM v14; // eax
bool v15; // zf
int v16; // ecx
const char *v17; // eax
int v18; // eax
int v19; // eax
int v20; // eax
_DWORD *v21; // eax
int v22; // eax
signed int v23; // eax
signed int v24; // ecx
_DWORD *v25; // eax
int v26; // ecx
int v27; // edx
unsigned __int16 v28; // ax
unsigned int v29; // edx
signed int v30; // ecx
__int16 v31; // cx
signed int (__stdcall *v32)(int, int); // eax
int v33; // ecx
_DWORD *v34; // eax
int v35; // esi
LPARAM dwInitParam; // [esp+Ch] [ebp-6Ch]
unsigned __int16 v38; // [esp+18h] [ebp-60h]
_DWORD *v39; // [esp+2Ch] [ebp-4Ch]
_WORD *v40; // [esp+30h] [ebp-48h]
int v41; // [esp+34h] [ebp-44h]
LPARAM *v42; // [esp+38h] [ebp-40h]
int v43; // [esp+3Ch] [ebp-3Ch]
struct tagWAVEOUTCAPSA pwoc; // [esp+40h] [ebp-38h]

v5 = (_WORD *)a1;
v42 = (LPARAM *)a3;
v40 = (_WORD *)a1;
v39 = (_DWORD *)a4;
v43 = 0;
v6 = SessionToGlobalDataPtr((_WORD *)a1);
hMem = (LPARAM)v6;
if ( !v6 )
return 5;
if ( *((_DWORD *)v6 + 4) )
return 4;
if ( *((_DWORD *)v6 + 5) )
return 12;
WaveMixFlushChannel((_WORD *)a1, -1, 1);
if ( !v42 )
{
LOWORD(dwInitParam) = 30;
*(LPARAM *)((char *)&dwInitParam + 2) = 1023;
WaveMixGetConfig((_WORD *)a1, (int)&dwInitParam);
v7 = (const DLGTEMPLATE *)MakeSettingsDlgTemplate();
if ( !v7 )
return 1;
*(_DWORD *)(hMem + 20) = 1;
v8 = DialogBoxIndirectParamA(dword_10257E0, v7, hWndParent, SettingsDlgProc, (LPARAM)&dwInitParam);
DestroySettingsDlgTemplate(v7);
v9 = hMem;
*(_DWORD *)(hMem + 20) = 0;
if ( v8 != 1 )
return 1;
if ( *(_DWORD *)(v9 + 396) == v38 )
*(LPARAM *)((char *)&dwInitParam + 2) &= 0xFFFFFFF7;
v5 = v40;
v42 = &dwInitParam;
}
if ( !*(LPARAM *)((char *)v42 + 2) )
return 1;
v11 = SessionToGlobalDataPtr(v5);
hMem = (LPARAM)v11;
if ( !v11 )
return 5;
v12 = v42;
v41 = *(LPARAM *)((char *)v42 + 2);
if ( v41 & 0x100 )
dword_1027BE4 = *((_WORD *)v42 + 12) != 0;
if ( (v41 & 0x80u) != 0 )
{
v13 = *((unsigned __int16 *)v42 + 10);
if ( v13 != *((_DWORD *)v11 + 6) )
{
result = waveOutGetDevCapsA(v13, &pwoc, 0x34u);
if ( result )
return result;
v14 = hMem;
qmemcpy((void *)(hMem + 124), &pwoc, 0x34u);
v15 = *(_WORD *)(v14 + 168) == 1;
*(_DWORD *)(v14 + 24) = *((unsigned __int16 *)v42 + 10);
if ( v15 && *(_WORD *)(v14 + 382) == 2 )
{
*(_WORD *)(v14 + 382) = 1;
v16 = *(_DWORD *)(v14 + 384);
v43 = 1;
*(_WORD *)(v14 + 392) = 1;
*(_DWORD *)(v14 + 388) = v16;
}
lstrcpyA((LPSTR)(v14 + 28), pwoc.szPname);
if ( !RemoveInvalidIniNameCharacters((LPCSTR)(hMem + 28)) )
lstrcpyA((LPSTR)(hMem + 28), "Unkown Device");
if ( !ReadRegistryToGetMachineSpecificInfSection(*(_DWORD *)(hMem + 24), (LPSTR)(hMem + 28), 96) )
{
v17 = GetOperatingSystemPrefix();
lstrcpyA((LPSTR)(hMem + 28), v17);
lstrcatA((LPSTR)(hMem + 28), (LPCSTR)(hMem + 132));
}
v11 = (_WORD *)hMem;
v12 = v42;
}
}
if ( v41 & 1 )
{
if ( *((_WORD *)v12 + 3) <= 1u )
{
if ( v11[191] == 2 )
v43 = 1;
v11[191] = 1;
v19 = *((_DWORD *)v11 + 96);
v11[196] = 1;
goto LABEL_39;
}
if ( v11[84] > 1u )
{
if ( v11[191] == 1 )
v43 = 1;
v11[191] = 2;
v18 = *((_DWORD *)v11 + 96);
v11[196] = 2;
v19 = 2 * v18;
LABEL_39:
*((_DWORD *)v11 + 97) = v19;
goto LABEL_40;
}
}
LABEL_40:
if ( v41 & 2 )
{
v20 = *((unsigned __int16 *)v12 + 4);
if ( v20 == 22 )
{
if ( *((_DWORD *)v11 + 96) != 22050 )
v43 = 1;
*((_DWORD *)v11 + 96) = 22050;
v22 = 22050 * (unsigned __int16)v11[191];
}
else
{
v15 = v20 == 44;
v21 = v11 + 192;
if ( v15 )
{
if ( *v21 != 44100 )
v43 = 1;
*v21 = 44100;
v22 = 44100 * (unsigned __int16)v11[191];
}
else
{
if ( *v21 != 11025 )
v43 = 1;
*v21 = 11025;
v22 = 11025 * (unsigned __int16)v11[191];
}
}
*((_DWORD *)v11 + 97) = v22;
}
if ( v41 & 4 )
{
v23 = *((unsigned __int16 *)v12 + 5);
v24 = 2;
*((_DWORD *)v11 + 100) = v23;
if ( v23 < 2 || (v24 = 10, v23 > 10) )
*((_DWORD *)v11 + 100) = v24;
v25 = v11 + 202;
v26 = *((_DWORD *)v11 + 101);
if ( v26 >= 0 )
{
v27 = *((_DWORD *)v11 + 100);
if ( v26 > v27 )
*v25 = v27;
}
else
{
*v25 = 0;
}
}
if ( v43 )
*((_DWORD *)v11 + 99) = FigureOutDMABufferSize(0, (int)(v11 + 190));
if ( v41 & 8 )
{
v28 = *((_WORD *)v12 + 6);
if ( v28 )
*((_DWORD *)v11 + 99) = v28;
}
v29 = *((_DWORD *)v11 + 99);
v30 = 344;
if ( v29 < 0x158 || (v30 = 11025, v29 > 0x2B11) )
*((_DWORD *)v11 + 99) = v30;
v31 = v41;
if ( v41 & 0x10 )
*((_DWORD *)v11 + 107) = cmixit;
if ( v31 & 0x20 )
{
v32 = ResetRemix;
if ( !*((_WORD *)v12 + 8) )
v32 = NoResetRemix;
*((_DWORD *)v11 + 108) = v32;
}
if ( v31 & 0x40 )
*((_DWORD *)v11 + 105) = *((_WORD *)v12 + 9) != 0;
if ( v31 & 0x200 )
{
v33 = *((unsigned __int16 *)v12 + 11);
v34 = v11 + 202;
*((_DWORD *)v11 + 101) = v33;
if ( v33 >= 0 )
{
v35 = *((_DWORD *)v11 + 100);
if ( v33 > v35 )
*v34 = v35;
}
else
{
*v34 = 0;
}
}
WaveMixGetConfig(v40, (int)v12);
if ( v39 )
*v39 = v43;
if ( a5 )
SaveConfigSettings(v41);
if ( dword_1027BE4 )
ShowCurrentSettings();
return 0;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (01020A36) --------------------------------------------------------
signed int __stdcall ReadConfigSettings(int a1)
{
UINT v2; // eax
UINT_PTR *v3; // ebx
const char *v4; // eax
unsigned int v5; // eax
UINT v6; // eax
signed int (__stdcall *v7)(int, int); // ecx
LPARAM v8; // eax
UINT v9; // ecx
LPARAM v10; // eax
signed int v11; // eax
LPARAM v12; // ecx
signed int v13; // edx
int v14; // eax
signed int v15; // eax
LPARAM v16; // ecx
signed int v17; // edx
unsigned __int16 v18; // ax
LPARAM v19; // ecx
int v20; // eax
int v21; // eax
unsigned int v22; // eax
int v23; // esi
const CHAR *v24; // [esp-10h] [ebp-24h]
int v25; // [esp-Ch] [ebp-20h]
UINT v26; // [esp+4h] [ebp-10h]
UINT v27; // [esp+8h] [ebp-Ch]
UINT v28; // [esp+Ch] [ebp-8h]
unsigned int nDefault; // [esp+10h] [ebp-4h]
UINT nDefaulta; // [esp+10h] [ebp-4h]
INT nDefaultb; // [esp+10h] [ebp-4h]

nDefault = waveOutGetNumDevs();
if ( !nDefault )
return 0;
if ( *(_BYTE *)(a1 + 3) & 4 && ReadRegistryForAppSpecificConfigs(a1) )
{
WaveMixConfigure(hMem, 0, a1, 0, 0);
return 1;
}
if ( *(_BYTE *)(a1 + 2) >= 0 )
{
v3 = (UINT_PTR *)(hMem + 24);
v2 = GetPrivateProfileIntA("general", "WaveOutDevice", 0, FileName);
}
else
{
v2 = *(unsigned __int16 *)(a1 + 20);
v3 = (UINT_PTR *)(hMem + 24);
}
*v3 = v2;
if ( *v3 >= nDefault )
*v3 = 0;
if ( waveOutGetDevCapsA(*v3, (LPWAVEOUTCAPSA)(hMem + 124), 0x34u)
|| !RemoveInvalidIniNameCharacters((LPCSTR)(hMem + 132)) )
{
lstrcpyA((LPSTR)(hMem + 132), "Unkown Device");
}
if ( !ReadRegistryToGetMachineSpecificInfSection(*(_DWORD *)(hMem + 24), (LPSTR)(hMem + 28), 96) )
{
v4 = GetOperatingSystemPrefix();
lstrcpyA((LPSTR)(hMem + 28), v4);
lstrcatA((LPSTR)(hMem + 28), (LPCSTR)(hMem + 132));
}
nDefaulta = GetPrivateProfileIntA("default", "Remix", 1, FileName);
v5 = DefaultGoodWavePos(*(_DWORD *)(hMem + 24));
v28 = GetPrivateProfileIntA("default", "GoodWavePos", v5, FileName);
v27 = GetPrivateProfileIntA("default", "WaveBlocks", 3, FileName);
v26 = GetPrivateProfileIntA("default", "SamplesPerSec", 11, FileName);
if ( *(_BYTE *)(hMem + 172) & 0x10 )
{
if ( !dword_1027BE4 )
return 0;
v25 = hMem + 132;
v24 = "%s is a syncronous (blocking) wave output device.  This will not permit audio to play while other applications are running.";
LABEL_19:
_wsprintfA(aWavemixV23ByAn, v24, v25);
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u);
return 0;
}
if ( GetPrivateProfileIntA("not compatible", (LPCSTR)(hMem + 28), 0, FileName) )
{
if ( !dword_1027BE4 )
return 0;
v25 = hMem + 28;
v24 = "%s is not compatible with the realtime wavemixer.";
goto LABEL_19;
}
v6 = GetPrivateProfileIntA((LPCSTR)(hMem + 28), "Remix", nDefaulta, FileName);
v7 = NoResetRemix;
if ( v6 != 2 )
v7 = ResetRemix;
v8 = hMem;
*(_DWORD *)(hMem + 432) = v7;
v9 = GetPrivateProfileIntA((LPCSTR)(v8 + 28), "GoodWavePos", v28, FileName);
v10 = hMem;
*(_DWORD *)(hMem + 420) = v9 != 0;
v11 = GetPrivateProfileIntA((LPCSTR)(v10 + 28), "WaveBlocks", v27, FileName);
v12 = hMem;
v13 = 2;
*(_DWORD *)(hMem + 400) = v11;
if ( v11 < 2 || (v13 = 10, v11 > 10) )
*(_DWORD *)(v12 + 400) = v13;
v14 = DefaultPauseBlocks(*(_DWORD *)(v12 + 400));
v15 = GetPrivateProfileIntA((LPCSTR)(hMem + 28), "PauseBlocks", v14, FileName);
v16 = hMem;
*(_DWORD *)(hMem + 404) = v15;
if ( v15 >= 0 )
{
v17 = *(_DWORD *)(v16 + 400);
if ( v15 > v17 )
*(_DWORD *)(v16 + 404) = v17;
}
else
{
*(_DWORD *)(v16 + 404) = 0;
}
nDefaultb = GetPrivateProfileIntA((LPCSTR)(v16 + 28), "SamplesPerSec", v26, FileName);
v18 = GetPrivateProfileIntA((LPCSTR)(hMem + 28), "Channels", 1, FileName);
v19 = hMem;
*(_WORD *)(hMem + 382) = v18;
if ( v18 >= 1u )
{
if ( v18 > 2u )
*(_WORD *)(v19 + 382) = 2;
}
else
{
*(_WORD *)(v19 + 382) = 1;
}
v20 = *(unsigned __int16 *)(v19 + 382);
if ( nDefaultb == 22 )
{
*(_DWORD *)(v19 + 384) = 22050;
v21 = 22050 * v20;
}
else if ( nDefaultb == 44 )
{
*(_DWORD *)(v19 + 384) = 44100;
v21 = 44100 * v20;
}
else
{
v21 = 11025 * v20;
}
*(_DWORD *)(v19 + 388) = v21;
v22 = GetPrivateProfileIntA("default", "WaveBlockLen", 0, FileName);
v23 = hMem;
*(_DWORD *)(v23 + 396) = FigureOutDMABufferSize(v22, hMem + 380);
WaveMixConfigure(v23, 0, a1, 0, 0);
return 1;
}
// 1027BE4: using guessed type int dword_1027BE4;

//----- (01020D99) --------------------------------------------------------
int __stdcall WaveMixConfigureInit(_WORD *a1)
{
unsigned int v1; // ecx
HMODULE v2; // eax
int result; // eax
BOOL v4; // eax
_DWORD *v5; // eax
_WORD *v6; // eax
void *v7; // ST0C_4
__int16 v8; // [esp+8h] [ebp-20h]
char v9; // [esp+Bh] [ebp-1Dh]
__int16 v10; // [esp+20h] [ebp-8h]
__int16 v11; // [esp+24h] [ebp-4h]

memset(&v8, 0, 0x1Cu);
v1 = 30;
v11 = 0;
v8 = 30;
if ( a1 )
{
if ( *a1 < 0x1Eu )
v1 = (unsigned __int16)*a1;
qmemcpy(&v8, a1, v1);
}
if ( dword_1027BF4 || (v2 = GetModuleHandleA(0), (result = WaveMixStartup(v2)) != 0) )
{
if ( v9 & 1 )
v4 = v10 != 0;
else
v4 = GetPrivateProfileIntA("general", "ShowDebugDialogs", 0, FileName) != 0;
dword_1027BE4 = v4;
if ( !waveOutGetNumDevs() )
{
if ( dword_1027BE4 )
{
_wsprintfA(aWavemixV23ByAn, "This system does not have a valid wave output device.");
MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u);
}
return 0;
}
if ( GetPrivateProfileIntA("general", "ShowDevices", 0, FileName) )
ShowWaveOutDevices();
v5 = LocalAlloc(0x40u, 0x1C0u);
hMem = (LPARAM)v5;
if ( !v5 )
return 0;
v5[107] = dword_1025968;
*((_WORD *)v5 + 222) = 21554;
*(_WORD *)v5 = 21554;
v5[102] = 0;
v5[5] = 0;
*((_WORD *)v5 + 88) = 10;
*((_WORD *)v5 + 89) = 10;
memset(v5 + 61, 0xFFu, 0x40u);
_memmove(v5 + 95, gpFormat, 0x10u);
if ( !ReadConfigSettings((int)&v8) )
{
v6 = (_WORD *)hMem;
v7 = (void *)hMem;
*(_WORD *)(hMem + 444) = 0;
*v6 = 0;
LocalFree(v7);
hMem = 0;
}
result = hMem;
}
return result;
}
// 10028C0: using guessed type int gpFormat[4];
// 1025968: using guessed type int dword_1025968;
// 1027BE4: using guessed type int dword_1027BE4;
// 1027BF4: using guessed type int dword_1027BF4;

//----- (01020F2D) --------------------------------------------------------
int __stdcall WaveMixInit()
{
return WaveMixConfigureInit(0);
}

//----- (01020F3A) --------------------------------------------------------
HLOCAL __stdcall WaveMixCloseSession(HLOCAL hMem)
{
void *v1; // edi
HLOCAL result; // eax

::hMem = (LPARAM)SessionToGlobalDataPtr(hMem);
if ( !::hMem
|| (WaveMixActivate(hMem, 0),
WaveMixCloseChannel(hMem, 0, 1),
v1 = (void *)::hMem,
::hMem = 0,
memset(v1, 0, 0x1C0u),
!hMem)
|| (result = LocalFree(hMem)) != 0 )
{
result = (HLOCAL)5;
}
return result;
}