62#define MCI_MAGIC 0x0001
65static const WCHAR wszHklmMci [] =
L"Software\\Microsoft\\Windows NT\\CurrentVersion\\MCI";
132#define CASE(s) case (s): return #s
146 CASE(DRV_EXITAPPLICATION);
295 if (!mci_windowW)
return -1;
304 mci_windowW->
hWnd = mci_windowA->
hWnd;
369 if (!mci_loadW)
return -1;
379 mci_loadW->
rc = mci_loadA->
rc;
389 if (!mci_vd_escapeW)
return -1;
521 if ((tmp =
wcsrchr(fileName,
'.'))) {
523 L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\MCI Extensions",
530 TRACE(
"No ...\\MCI Extensions entry for %s found.\n",
debugstr_w(tmp));
552#define MAX_MCICMDTABLE 20
553#define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
577 TRACE(
"Dumping cmdTbl=%d [lpTable=%p devType=%d]\n",
587 flg = *(
const DWORD*)lmem;
588 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
606 default:
return FALSE;
622 ERR(
"Ooops: %d is not valid\n", uTbl);
633 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
663 }
else if (uDevType == 0) {
675 WARN(
"No command table found in resource %p[%s]\n",
679 TRACE(
"=> %d\n", uTbl);
700 TRACE(
"(%p, %u)\n", hMem, uDevType);
723 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
737 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
763 WARN(
"Unloading mci driver with non nul dwPrivate field\n");
806 if (!wmd || !strDevTyp) {
838 if (
wcsicmp(strDevTyp,
L"ALL") == 0) {
841 FIXME(
"Couldn't load driver for type %s.\n",
856 TRACE(
"Loaded driver %p (%s), type is %d, cmdTable=%08x\n",
862 TRACE(
"mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
960 return *(
const DWORD*)(lpCmd + 1);
985 while (*
ret ==
' ' || *
ret ==
'\t')
ret++;
992 while (
'0' <= *
ret && *
ret <=
'9') {
999 case ' ':
ret++;
break;
1000 default:
return FALSE;
1030 if (
ptr[-1] ==
'\\')
TRACE(
"Ooops: un-escaped \"\n");
1048#define MCI_DATA_SIZE 16
1059 DWORD dwRet, flg, cflg = 0;
1065 lmem = (
const char*)lpCmd;
1066 found = inCst =
FALSE;
1076 flg = *(
const DWORD*)lmem;
1077 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
1083 inCst =
TRUE; cflg = flg;
break;
1089 inCst =
FALSE; cflg = 0;
1093 FIXME(
"MCI_RETURN not in first position\n");
1115 TRACE(
"flag=%08lx\n", flg);
1125 TRACE(
"flag=%08lx constant=%08lx\n", cflg, flg);
1143 TRACE(
"flag=%08lx for rectangle\n", flg);
1151 default:
ERR(
"oops\n");
1171 default:
ERR(
"oops\n");
1180 FIXME(
"Internal data[] buffer overflow\n");
1200 switch (dwRet & 0xFFFF0000ul) {
1218 swprintf(lpstrRet, uRetLen,
L"%02d:%02d:%02d",
1223 swprintf(lpstrRet, uRetLen,
L"%02d:%02d:%02d:%02d",
1227 default:
ERR(
"Ooops (%04X)\n",
HIWORD(dwRet));
1234 switch (dwRet & 0xFFFF0000ul) {
1252 swprintf(lpstrRet, uRetLen,
L"%02d:%02d:%02d",
1257 swprintf(lpstrRet, uRetLen,
L"%02d:%02d:%02d:%02d",
1261 default:
ERR(
"Ooops (%04X)\n",
HIWORD(dwRet));
1266 switch (dwRet & 0xFFFF0000ul) {
1278 WARN(
"Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n",
HIWORD(dwRet));
1285 if (dwRet & 0xFFFF0000ul)
1286 WARN(
"Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n",
HIWORD(dwRet));
1290 default:
FIXME(
"Unknown MCI return type %ld\n", retType);
1314 MCI_SOUND_PARMSW sound;
1319 TRACE(
"(%s, %p, %d, %p)\n",
1320 debugstr_w(lpstrCommand), lpstrRet, uRetLen, hwndCallback);
1321 if (lpstrRet && uRetLen) *lpstrRet =
'\0';
1323 if (!lpstrCommand[0])
1354 tmp =
wcschr(devType,
' ');
1355 if (tmp) *tmp =
'\0';
1357 if (tmp) *tmp =
' ';
1360 WARN(
"open new requires device type\n");
1365 data.open.lpstrElementName = &
L""[0];
1368 tmp = devType; devType =
dev;
dev = tmp;
1371 data.open.lpstrDeviceType = devType;
1374 data.open.lpstrElementName =
dev;
1378 if (tmp) *tmp =
'\0';
1379 data.open.lpstrDeviceType =
dev;
1381 if (tmp) *tmp =
' ';
1386 tmp =
wcschr(devType,
' ');
1387 if (tmp) *tmp =
'\0';
1389 if (tmp) *tmp =
' ';
1398 data.open.lpstrElementName =
dev;
1439 ERR(
"No auto-open device %u\n", auto_open);
1478 data.sysinfo.lpstrReturn = lpstrRet;
1479 data.sysinfo.dwRetSize = uRetLen;
1489 FIXME(
"Unknown MCI return type %ld\n", retType);
1494 TRACE(
"verb=%s on dev=%s; offset=%d\n",
1544 data.sound.lpstrSoundName =
dev;
1549 TRACE(
"[%d, %s, %08lx, %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx]\n",
1566 TRACE(
"=> %lx\n", dwRet);
1574 FIXME(
"leaking auto-open device %u\n", auto_open);
1600 if (uRetLen) *lpstrRet =
'\0';
1608 if (!
ret && lpwstrRet)
1623 TRACE(
"(%s)!\n", lpstrCommand);
1628 sprintf(strRet,
"Unknown MCI error (%ld)",
ret);
1672 else WARN(
"No command table found in module for %s\n",
debugstr_w(resNameW));
1683 TRACE(
"(%08x)!\n", uTable);
1702 WCHAR strDevTyp[128];
1706 TRACE(
"(%08lX, %p)\n", dwParam, lpParms);
1710#define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
1711 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
1712 MCI_NOTIFY|MCI_WAIT)
1714 FIXME(
"Unsupported yet dwFlags=%08lX\n", dwParam);
1715#undef WINE_MCIDRIVER_SUPP
1742 ERR(
"Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
1762 FIXME(
"Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
1773 if (!strDevTyp[0] &&
1775 strDevTyp,
sizeof(strDevTyp))) {
1785 if (strDevTyp[0] == 0) {
1786 FIXME(
"Couldn't load driver\n");
1804 TRACE(
"Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet);
1826 TRACE(
"(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
1870 if (dstSize <=
lstrlenW(lpSrcStr)) {
1894 TRACE(
"(%08x, %08lX, %p[num=%ld, wDevTyp=%u])\n",
1907 TRACE(
"MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1914 TRACE(
"MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1917 RegQueryInfoKeyW(
hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
1925 TRACE(
"MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %d\n", lpParms->
wDeviceType);
1932 TRACE(
"MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %d\n", lpParms->
wDeviceType);
1933 FIXME(
"Don't know how to get # of MCI devices of a given type\n");
1953 TRACE(
"MCI_SYSINFO_INSTALLNAME\n");
1967 TRACE(
"MCI_SYSINFO_NAME: nth alias of type %d\n",
1984 TRACE(
"MCI_SYSINFO_NAME: device #%ld\n", lpParms->
dwNumber);
2001 if (cnt == lpParms->
dwNumber - 1) {
2039 if (lpParms ==
NULL)
2042 TRACE(
"(%08x, %08lX, vkey %04X, hwnd %p)\n", wDevID,
dwFlags,
2058 if (
dwFlags & MCI_SOUND_NAME) {
2093 dwRet =
MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2);
2097 FIXME(
"unhandled MCI_ALL_DEVICE_ID\n");
2121 switch (dwRet & 0xFFFF0000ul) {
2139 FIXME(
"Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2144 switch (dwRet & 0xFFFF0000ul) {
2162 FIXME(
"Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2167 switch (dwRet & 0xFFFF0000ul) {
2173 FIXME(
"Unsupported value for hiword (%04x)\n",
HIWORD(dwRet));
2178 FIXME(
"Got non null hiword for dwRet=0x%08Ix for command %s\n",
2193 if (lpstrBuffer !=
NULL && uLength > 0 &&
2210 if (lpstrBuffer !=
NULL && uLength > 0 &&
2225 TRACE(
"(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
2237 TRACE(
"(%04x)\n", uDeviceID);
2242 WARN(
"Bad uDeviceID\n");
2256 TRACE(
"(%04x, %08Ix)\n", uDeviceID,
data);
2261 WARN(
"Bad uDeviceID\n");
2277 TRACE(
"(%08x, %s, %08Ix, %08Ix)\n",
2282 TRACE(
"=> %08lx\n", dwRet);
2294 TRACE(
"(%08x, %s, %08Ix, %08Ix)\n",
2300 FIXME(
"message %04x mapping failed\n", wMsg);
2341 TRACE(
"(0x%04x, 0x%08lx)\n", wDevID,
data);
2362 TRACE(
"(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
2365 WARN(
"Bad uDeviceID\n");
2410 TRACE(
"(%u, %p)\n", uDeviceID, lpdwYieldData);
2413 WARN(
"Bad uDeviceID\n");
2417 WARN(
"No proc set\n");
2420 if (lpdwYieldData) *lpdwYieldData = wmd->
dwYieldData;
2434 TRACE(
"(%u) => %p\n", uDeviceID,
ret);
2446 TRACE(
"(%04x)\n", uDeviceID);
char * strcat(char *DstString, const char *SrcString)
char * strcpy(char *DstString, const char *SrcString)
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
#define RegCloseKey(hKey)
#define MCI_DGV_SETAUDIO_QUALITY
#define MCI_DGV_SETVIDEO_QUALITY
#define MCI_DGV_SETAUDIO_ALG
#define MCI_DGV_RESTORE_AT
#define MCI_DGV_CAPTURE_AT
#define MCI_DGV_SETVIDEO_ALG
#define MCI_DGV_INFO_ITEM
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
LONG WINAPI RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
const char * wine_dbg_sprintf(const char *format,...)
#define HeapFree(x, y, z)
#define WideCharToMultiByte
#define MultiByteToWideChar
HFILE WINAPI OpenFile(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle)
UINT WINAPI GetDriveTypeW(IN LPCWSTR lpRootPathName)
INT WINAPI GetPrivateProfileStringW(LPCWSTR section, LPCWSTR entry, LPCWSTR def_val, LPWSTR buffer, UINT len, LPCWSTR filename)
BOOL WINAPI FreeResource(HGLOBAL handle)
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
LPVOID WINAPI LockResource(HGLOBAL handle)
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
#define MCI_NO_COMMAND_TABLE
#define MCI_INTEGER_RETURNED
#define MCI_END_COMMAND_LIST
#define MCI_RESOURCE_RETURNED
#define MCI_COLONIZED3_RETURN
#define MCI_RESOURCE_DRIVER
#define MCI_COLONIZED4_RETURN
BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz)
LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1, LPARAM lParam2)
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
BOOL WINAPI mciFreeCommandResource(UINT uTable)
static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
static const char * MCI_MessageToString(UINT wMsg)
static UINT MCI_GetDevTypeFromResource(LPCWSTR lpstrName)
#define MCI_COMMAND_TABLE_NOT_LOADED
static WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE]
static BOOL MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd)
DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
static UINT MCI_SetCommandTable(HGLOBAL hMem, UINT uDevType)
static UINT MCI_GetDriverFromString(LPCWSTR lpstrName)
DWORD_PTR WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
static LPWSTR MCI_strdupAtoW(LPCSTR str)
static BOOL MCI_GetDWord(DWORD *data, LPWSTR *ptr)
static LPWSTR str_dup_upper(LPCWSTR str)
DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, UINT uRetLen, HWND hwndCallback)
static DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr)
UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
BOOL WINAPI mciExecute(LPCSTR lpstrCommand)
static DWORD MCI_GetString(LPWSTR *str, LPWSTR *args)
#define WINE_MCIDRIVER_SUPP
static LPWINE_MCIDRIVER MCI_GetDriver(UINT wDevID)
static LPCWSTR MCI_FindCommand(UINT uTbl, LPCWSTR verb)
UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSW lpParms, DWORD dwParam)
HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type)
static const WCHAR wszHklmMci[]
DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType, MCI_GENERIC_PARMS *params, LPWSTR lpstrRet, UINT uRetLen)
static WORD MCI_GetMessage(LPCWSTR lpCmd)
BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParms)
static DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
struct tagWINE_MCICMDTABLE * LPWINE_MCICMDTABLE
UINT WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType)
static DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
static void MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, DWORD result)
static DWORD MCI_ParseOptArgs(DWORD *data, int _offset, LPCWSTR lpCmd, LPWSTR args, LPDWORD dwFlags)
BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD_PTR data)
static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER *lpwmd)
UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
static UINT MCI_GetCommandTable(UINT uDevType)
DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, UINT uRetLen, HWND hwndCallback)
static BOOL MCI_IsCommandTableValid(UINT uTbl)
BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, DWORD_PTR lp)
static BOOL MCI_DumpCommandTable(UINT uTbl)
static DWORD MCI_GetReturnType(LPCWSTR lpCmd)
static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms)
static WINE_MCIDRIVER * MciDrivers
static LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2)
struct tagWINE_MCICMDTABLE WINE_MCICMDTABLE
static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPWSTR buf, UINT len)
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD *lpdwYieldData)
static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
GLuint GLuint GLsizei GLenum type
GLuint GLuint GLsizei count
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
GLenum const GLfloat * params
GLenum GLuint GLenum GLsizei const GLchar * buf
GLubyte GLubyte GLubyte GLubyte w
_Check_return_ unsigned long __cdecl wcstoul(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
REFIID LPVOID DWORD_PTR dw
static const int digits[]
#define memcpy(s1, s2, n)
#define MCIERR_NOTIFY_ON_AUTO_OPEN
#define MCIERR_NEW_REQUIRES_ALIAS
UINT(CALLBACK * YIELDPROC)(MCIDEVICEID, DWORD)
#define MCIERR_INVALID_DEVICE_NAME
#define MCIERR_EXTRA_CHARACTERS
#define DRV_QUERYCONFIGURE
#define MCI_OPEN_ELEMENT_ID
#define MCIERR_MISSING_DEVICE_NAME
#define MCIERR_DEVICE_TYPE_REQUIRED
#define SND_ALIAS_SYSTEMDEFAULT
#define MCIERR_NO_CLOSING_QUOTE
#define MCIERR_UNRECOGNIZED_COMMAND
#define MCIERR_BAD_INTEGER
#define MCIERR_CUSTOM_DRIVER_BASE
#define MCIERR_EXTENSION_NOT_FOUND
#define MCI_ALL_DEVICE_ID
#define MCIERR_PARAM_OVERFLOW
#define MCIERR_INVALID_DEVICE_ID
struct tagMCI_STATUS_PARMS * LPMCI_STATUS_PARMS
#define MCIERR_DEVICE_OPEN
#define MCIERR_NULL_PARAMETER_BLOCK
struct tagMCI_GETDEVCAPS_PARMS * LPMCI_GETDEVCAPS_PARMS
#define MCIERR_DRIVER_INTERNAL
#define MCIERR_OUTOFRANGE
#define MCIERR_CANNOT_USE_ALL
#define MCIERR_OUT_OF_MEMORY
#define MCI_ANIM_WINDOW_STATE
#define MCI_DEVTYPE_SEQUENCER
#define MCI_SYSINFO_INSTALLNAME
#define MCIERR_UNRECOGNIZED_KEYWORD
#define MCI_DEVTYPE_WAVEFORM_AUDIO
#define MCIERR_DEVICE_NOT_INSTALLED
#define MCIERR_DUPLICATE_ALIAS
#define MCI_DEVTYPE_FIRST
#define MCI_NOTIFY_SUCCESSFUL
#define MCIERR_MISSING_COMMAND_STRING
#define MCIERR_PARSER_INTERNAL
#define MCI_ANIM_WINDOW_TEXT
#define MCI_DEVTYPE_CD_AUDIO
#define MCI_SYSINFO_QUANTITY
#define MCI_ANIM_WINDOW_HWND
#define sprintf(buf, format,...)
BOOL WINAPI PlaySoundW(LPCWSTR pszSoundW, HMODULE hmod, DWORD fdwSound)
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
CHAR szPathName[OFS_MAXPATHNAME]
struct tagWINE_MCIDRIVER * lpNext
TW_UINT32 TW_UINT16 TW_UINT16 MSG
#define FIELD_OFFSET(t, f)
DWORD WINAPI GetCurrentThreadId(void)
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
HINSTANCE hWinMM32Instance
CRITICAL_SECTION WINMM_cs
#define HKEY_LOCAL_MACHINE
HWND WINAPI GetActiveWindow(void)
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
int WINAPI MessageBoxA(_In_opt_ HWND hWnd, _In_opt_ LPCSTR lpText, _In_opt_ LPCSTR lpCaption, _In_ UINT uType)
LPWSTR WINAPI CharLowerW(_Inout_ LPWSTR)
int WINAPI LoadStringA(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPSTR lpBuffer, _In_ int cchBufferMax)
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
SHORT WINAPI GetAsyncKeyState(_In_ int)
LPWSTR WINAPI CharUpperW(_Inout_ LPWSTR)