#include "../pinball.h" //----- (0101CFD0) -------------------------------------------------------- WORD* 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 IsValidLPMIXWAVE(int a1) { BOOL result; // eax result = a1; if (a1) result = *(WORD*)(a1 + 64) == 21554; return result; } //----- (0101D04E) -------------------------------------------------------- bool HasCurrentOutputFormat(const void* a1) { return memcmp(a1, (const void*)(hMem + 380), 0x10u) == 0; } //----- (0101D079) -------------------------------------------------------- int DefaultPauseBlocks(int a1) { int result; // eax if (GetVersion() < 0x80000000 || (unsigned __int8)GetVersion() < 4u) result = a1; else result = 0; return result; } //----- (0101D0A5) -------------------------------------------------------- unsigned int 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 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 (**)(DWORD, DWORD))(hMem + 436))(pmmt.u.ms, *(DWORD*)(hMem + 424)); } //----- (0101D178) -------------------------------------------------------- int AddFactor(int a1, int a2) { return a1 + a2; } //----- (0101D18E) -------------------------------------------------------- int SubFactor(int a1, int a2) { return a1 - a2; } //----- (0101D1A2) -------------------------------------------------------- unsigned int 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 MyWaveOutReset(HWAVEOUT hwo) { unsigned int v1; // esi v1 = MyWaveOutGetPosition(hwo, *(DWORD*)(hMem + 420)); waveOutReset(hwo); return SetWaveOutPosition(v1); } //----- (0101D285) -------------------------------------------------------- int cmixit(_BYTE* a1, char* a2, char* a3, int a4, unsigned int 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 int* 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 int* v23; // ecx int v24; // eax int v26; // [esp+10h] [ebp-8h] int v27; // [esp+10h] [ebp-8h] unsigned int v28; // [esp+14h] [ebp-4h] unsigned int 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 int*)a3 << 8; v8 = *((unsigned int*)a3 + 1) << 8; v9 = (unsigned int)(((unsigned int)(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 int)(((unsigned int)(a5 - 1) >> 1) + 1); do { v12 = 128; v13 = 128; if (a4 > 0) { v14 = (unsigned int*)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 int*)a3 + *((unsigned int*)a3 + 1)) / 2; if (a5) { v20 = a5; v21 = a1; v5 = (unsigned int)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 int*)a3; v31 = a4; do { v24 = (unsigned __int8)byte_1025970[256 * (unsigned int)((*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* 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 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* 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* 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 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* 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* 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* 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 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 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 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 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 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 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 int*)(v4 + 396); while ((WORD)v10) { if (v9 >= v30) { v26 = 0; v29 = 0; v11 = v9 + (unsigned int)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 (**)(LPSTR, int*, int*, 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 int)v10; if ((unsigned int)v10 + v9 >= v30) v10 = v30 - v9; memset(v28, 0x80u, (unsigned int)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 int word_1025810[]; // 1027BE4: using guessed type int dword_1027BE4; //----- (0101DC8C) -------------------------------------------------------- DWORD 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 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 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 NoResetRemix(int a1, int a2) { WaveMixPump(); return 1; } //----- (0101DDE8) -------------------------------------------------------- signed int 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 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 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 int 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 int 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 int)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 (**)(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 int*)(v14 + 392); } while (*(DWORD*)(v14 + 440)); if (!v36) goto LABEL_84; if (!(*(int (**)(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 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 (**)(DWORD, DWORD*))v5 + 108))(v10, v3); } return 0; } } return 5; } //----- (0101E434) -------------------------------------------------------- signed int 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 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* BitsPerSampleAlign(int a1, LPCVOID pMem, int a3, int 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 int)a3 >> 3; v7 = a1; v8 = *(DWORD*)a5 / (unsigned int)((unsigned int)a3 >> 3); v9 = v8 * ((unsigned int)a4 >> 3); *(DWORD*)a5 = v9; v10 = GlobalAlloc(0x2002u, v9); v11 = GlobalLock(v10); v12 = v11; if (v11) { if ((unsigned int)v7 <= (unsigned int)((unsigned int)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* ChannelAlign(LPCVOID pMem, int a2, int a3, int 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 int)a4 / (unsigned int)a2; v7 = v6 * (unsigned int)a4 * (unsigned int)a3; *(DWORD*)a5 = v7; v8 = GlobalAlloc(0x2002u, v7); v9 = GlobalLock(v8); v10 = v9; if (v9) { v11 = (unsigned __int8*)pMem; if ((unsigned int)a2 >= (unsigned int)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 int*)v11 + *((signed int*)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 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 int* v12; // edi signed int* 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 int*)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 int*)((char*)v13 + v16); --v15; } while (v15); } v17 = v18-- == 1; *a1 = v14 / a3; if (v17) break; v11 = a5; } } } } //----- (0101E83A) -------------------------------------------------------- int 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 int)v13[v12] - *(signed int*)v19) / a3; *v13 = *(WORD*)v19; v15 = (signed int)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 SamplesPerSecAlign(LPCVOID pMem, int a2, int a3, int a4, int 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 int)a4 * (unsigned int)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 int)a4, (unsigned int)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 int)a4, (unsigned int)a5); pMem = (char*)pMem + v8; v13 += v8 * v24; --v27; } while (v27); } v16 = v24; if (v24 > 0) { do { v17 = pMem; if (v8 > 0) { v18 = (unsigned int)a4 * (unsigned int)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 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 int*)(a2 + 14), pMem, *(unsigned int*)(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* 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 int)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 int)lpName); } return v8; } // 1027BE4: using guessed type int dword_1027BE4; //----- (0101F093) -------------------------------------------------------- unsigned int FigureOutDMABufferSize(unsigned int a1, int a2) { unsigned int result; // eax signed int v3; // ecx result = a1; if (!a1) result = *(DWORD*)(a2 + 4) * *(unsigned int*)(a2 + 2) * ((unsigned int) * (unsigned int*)(a2 + 14) >> 3) >> 4; v3 = 344; if (result < 0x158 || (v3 = 11025, result > 0x2B11)) result = v3; return result; } //----- (0101F0D4) -------------------------------------------------------- int 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 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* 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 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 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 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 int*)(a1 + 20) >= waveOutGetNumDevs()) { *(WORD*)(a1 + 20) = 0; } _wsprintfA(&SubKey, "WaveMix\\Device%u", *(unsigned int*)(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 int)ReadRegistryInt(phkResult, "Remix", 1) != 2; if (!(v1 & 0x40)) { v3 = DefaultGoodWavePos(*(unsigned int*)(a1 + 20)); *(WORD*)(a1 + 18) = (unsigned int)ReadRegistryInt(phkResult, "GoodWavePos", v3) != 0; } if (!(v1 & 0x100)) * (WORD*)(a1 + 24) = ReadRegistryInt(phkResult, "ShowDebugDialogs", 0); if (!(v1 & 0x200)) { v4 = DefaultPauseBlocks(*(unsigned int*)(a1 + 10)); *(WORD*)(a1 + 22) = ReadRegistryInt(phkResult, "PauseBlocks", v4); } v5 = (struct tagWAVEOUTCAPSA*)(hMem + 124); v6 = *(unsigned int*)(a1 + 20); *(DWORD*)(a1 + 2) = 1023; waveOutGetDevCapsA(v6, v5, 0x34u); RegCloseKey(phkResult); return 1; } //----- (0101F50B) -------------------------------------------------------- int 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 (*(int (**)(_BYTE*, char*, char*, int, unsigned int))(hMem + 428) != cmixit) v0 = "386 mixit"; v1 = "TRUE"; if (!*(DWORD*)(hMem + 420)) v1 = "FALSE"; v2 = "Reset"; if (*(signed int (**)(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 int*)(hMem + 382), *(DWORD*)(hMem + 404)); return MessageBoxA(0, aWavemixV23ByAn, "WavMix32", 0x40u); } //----- (0101F5F1) -------------------------------------------------------- int 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 int*)(a3 + 10)); v26 = GetDlgItem(hWnd, 1003); SetWindowTextA(v26, aWavemixV23ByAn); _wsprintfA(aWavemixV23ByAn, "%d", *(unsigned int*)(a3 + 12)); v27 = GetDlgItem(hWnd, 1007); SetWindowTextA(v27, aWavemixV23ByAn); _wsprintfA(aWavemixV23ByAn, "%d", *(unsigned int*)(a3 + 8)); v28 = GetDlgItem(hWnd, 1008); SetWindowTextA(v28, aWavemixV23ByAn); _wsprintfA(aWavemixV23ByAn, "%d", *(unsigned int*)(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 int*)(a3 + 20); v33 = GetDlgItem(hWnd, 1009); SendMessageA(v33, 0x14Eu, v32, 0); return 1; } //----- (0101FA63) -------------------------------------------------------- int 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 int 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 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 int)a3, a4, a3 >> 16); return 1; } //----- (0101FC6D) -------------------------------------------------------- DWORD* MakeDlgTemplate(int a1, int a2, int a3, int a4, int a5, int 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* AddDlgControl(int a1, LPCVOID pMem, int a3, int a4, int a5, int a6, int a7, int a8, int 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 int)a3 << 16) | 0xFFFF; _wcscpy((wchar_t*)& pMema[(DWORD)v10 + 22], Str); ++* ((WORD*)v10 + 4); } } return v10; } //----- (0101FDE1) -------------------------------------------------------- WORD* 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 DestroySettingsDlgTemplate(LPCVOID pMem) { HGLOBAL v1; // eax HGLOBAL v2; // eax if (pMem) { v1 = GlobalHandle(pMem); GlobalUnlock(v1); v2 = GlobalHandle(pMem); GlobalFree(v2); } } //----- (0102008D) -------------------------------------------------------- signed int 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 SaveConfigSettings(int 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 int*)(hMem + 382)); result = WritePrivateProfileStringA((LPCSTR)(hMem + 28), "Channels", aWavemixV23ByAn, FileName); } if (a1 & 2) { _wsprintfA(aWavemixV23ByAn, "%d", (unsigned int)(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 int*)(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 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 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 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 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 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 int v28; // ax unsigned int v29; // edx signed int v30; // ecx int v31; // cx signed int (*v32)(int, int); // eax int v33; // ecx DWORD* v34; // eax int v35; // esi LPARAM dwInitParam; // [esp+Ch] [ebp-6Ch] unsigned int 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 int*)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 int*)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 int*)v12 + 4); if (v20 == 22) { if (*((DWORD*)v11 + 96) != 22050) v43 = 1; *((DWORD*)v11 + 96) = 22050; v22 = 22050 * (unsigned int)v11[191]; } else { v15 = v20 == 44; v21 = v11 + 192; if (v15) { if (*v21 != 44100) v43 = 1; *v21 = 44100; v22 = 44100 * (unsigned int)v11[191]; } else { if (*v21 != 11025) v43 = 1; *v21 = 11025; v22 = 11025 * (unsigned int)v11[191]; } } *((DWORD*)v11 + 97) = v22; } if (v41 & 4) { v23 = *((unsigned int*)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 int*)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 ReadConfigSettings(int a1) { UINT v2; // eax UINT_PTR* v3; // ebx const char* v4; // eax unsigned int v5; // eax UINT v6; // eax signed int (*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 int 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 int*)(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 int*)(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 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 int v8; // [esp+8h] [ebp-20h] char v9; // [esp+Bh] [ebp-1Dh] int v10; // [esp+20h] [ebp-8h] int v11; // [esp+24h] [ebp-4h] memset(&v8, 0, 0x1Cu); v1 = 30; v11 = 0; v8 = 30; if (a1) { if (*a1 < 0x1Eu) v1 = (unsigned int)* 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 WaveMixInit() { return WaveMixConfigureInit(0); } //----- (01020F3A) -------------------------------------------------------- HLOCAL 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; }