49 #define MCI_MAGIC 0x0001 52 static const WCHAR wszHklmMci [] = {
'S',
'o',
'f',
't',
'w',
'a',
'r',
'e',
'\\',
'M',
'i',
'c',
'r',
'o',
's',
'o',
'f',
't',
'\\',
'W',
'i',
'n',
'd',
'o',
'w',
's',
' ',
'N',
'T',
'\\',
'C',
'u',
'r',
'r',
'e',
'n',
't',
'V',
'e',
'r',
's',
'i',
'o',
'n',
'\\',
'M',
'C',
'I',0};
57 static const WCHAR wszSystemIni[] = {
's',
'y',
's',
't',
'e',
'm',
'.',
'i',
'n',
'i',0};
134 #define CASE(s) case (s): return #s 148 CASE(DRV_EXITAPPLICATION);
301 memcpy(mci_openW + 1, mci_openA + 1, 2 *
sizeof(
DWORD));
312 if (!mci_windowW)
return -1;
321 mci_windowW->
hWnd = mci_windowA->
hWnd;
377 if (!mci_saveW)
return -1;
391 if (!mci_loadW)
return -1;
406 if (!mci_vd_escapeW)
return -1;
539 static const WCHAR keyW[] = {
'S',
'O',
'F',
'T',
'W',
'A',
'R',
'E',
'\\',
'M',
'i',
'c',
'r',
'o',
's',
'o',
'f',
't',
'\\',
540 'W',
'i',
'n',
'd',
'o',
'w',
's',
' ',
'N',
'T',
'\\',
'C',
'u',
'r',
'r',
'e',
'n',
't',
'V',
'e',
'r',
's',
'i',
'o',
'n',
'\\',
541 'M',
'C',
'I',
' ',
'E',
'x',
't',
'e',
'n',
's',
'i',
'o',
'n',
's',0};
542 if ((tmp =
strrchrW(fileName,
'.'))) {
550 TRACE(
"No ...\\MCI Extensions entry for %s found.\n",
debugstr_w(tmp));
555 #define MAX_MCICMDTABLE 20 556 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE 580 TRACE(
"Dumping cmdTbl=%d [lpTable=%p devType=%d]\n",
590 flg = *(
const DWORD*)lmem;
591 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
606 default:
return FALSE;
623 ERR(
"Ooops: %d is not valid\n", uTbl);
632 flg = *(
const DWORD*)lmem;
633 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
663 }
else if (uDevType == 0) {
664 static const WCHAR wszCore[] = {
'C',
'O',
'R',
'E',0};
676 WARN(
"No command table found in resource %p[%s]\n",
680 TRACE(
"=> %d\n", uTbl);
701 TRACE(
"(%p, %u)\n", hMem, uDevType);
724 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
738 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
764 WARN(
"Unloading mci driver with non nul dwPrivate field\n");
808 if (!wmd || !strDevTyp) {
843 FIXME(
"Couldn't load driver for type %s.\n",
858 TRACE(
"Loaded driver %p (%s), type is %d, cmdTable=%08x\n",
862 wmd->
wType = modp.wType;
864 TRACE(
"mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
865 modp.wDeviceID, modp.wType, modp.wDeviceID);
940 return *(
const DWORD*)(lpCmd + 1);
965 case ' ':
ret++;
break;
966 default:
return FALSE;
986 if (
ptr[-1] ==
'\\')
TRACE(
"Ooops: un-escaped \"\n");
1004 #define MCI_DATA_SIZE 16 1015 DWORD dwRet, flg, cflg = 0;
1021 lmem = (
const char*)lpCmd;
1022 found = inCst =
FALSE;
1032 flg = *(
const DWORD*)lmem;
1033 eid = *(
const WORD*)(lmem +
sizeof(
DWORD));
1039 inCst =
TRUE; cflg = flg;
break;
1045 inCst =
FALSE; cflg = 0;
1095 default:
ERR(
"oops\n");
1112 default:
ERR(
"oops\n");
1121 ERR(
"Internal data[] buffer overflow\n");
1134 static const WCHAR wszLd [] = {
'%',
'l',
'd',0};
1135 static const WCHAR wszLd4 [] = {
'%',
'l',
'd',
' ',
'%',
'l',
'd',
' ',
'%',
'l',
'd',
' ',
'%',
'l',
'd',0};
1136 static const WCHAR wszCol3[] = {
'%',
'd',
':',
'%',
'd',
':',
'%',
'd',0};
1137 static const WCHAR wszCol4[] = {
'%',
'd',
':',
'%',
'd',
':',
'%',
'd',
':',
'%',
'd',0};
1144 switch (dwRet & 0xFFFF0000ul) {
1171 default:
ERR(
"Ooops (%04X)\n",
HIWORD(dwRet));
1175 switch (dwRet & 0xFFFF0000ul) {
1184 WARN(
"Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n",
HIWORD(dwRet));
1189 if (dwRet & 0xFFFF0000ul)
1190 WARN(
"Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n",
HIWORD(dwRet));
1194 default:
ERR(
"oops\n");
1214 static const WCHAR wszNew[] = {
'n',
'e',
'w',0};
1215 static const WCHAR wszSAliasS[] = {
' ',
'a',
'l',
'i',
'a',
's',
' ',0};
1216 static const WCHAR wszTypeS[] = {
't',
'y',
'p',
'e',
' ',0};
1218 TRACE(
"(%s, %p, %d, %p)\n",
1219 debugstr_w(lpstrCommand), lpstrRet, uRetLen, hwndCallback);
1224 strcpyW( verb, lpstrCommand );
1249 if (tmp) *tmp =
'\0';
1251 if (tmp) *tmp =
' ';
1254 WARN(
"open new requires device type\n");
1260 tmp = devType; devType =
dev;
dev = tmp;
1270 if (tmp) *tmp =
'\0';
1273 if (tmp) *tmp =
' ';
1279 if (tmp) *tmp =
'\0';
1281 if (tmp) *tmp =
' ';
1295 if (!(tmp =
strchrW(devAlias,
' '))) tmp = devAlias +
strlenW(devAlias);
1296 if (tmp) *tmp =
'\0';
1298 memcpy( tmp2, devAlias, (tmp - devAlias) *
sizeof(
WCHAR) );
1299 tmp2[tmp - devAlias] = 0;
1303 }
else if (
dev == 0) {
1319 static const WCHAR wszOpenWait[] = {
'o',
'p',
'e',
'n',
' ',
'%',
's',
' ',
'w',
'a',
'i',
't',0};
1357 case 0:
offset = 1;
break;
1361 default:
ERR(
"oops\n");
1364 TRACE(
"verb=%s on dev=%s; offset=%d\n",
1378 if (lpstrRet && uRetLen) *lpstrRet =
'\0';
1380 TRACE(
"[%d, %s, %08x, %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s]\n",
1421 WARN(
"no memory\n");
1427 if (!
ret && lpwstrRet)
1442 TRACE(
"(%s)!\n", lpstrCommand);
1447 sprintf(strRet,
"Unknown MCI error (%lu)",
ret);
1491 else WARN(
"No command table found in module for %s\n",
debugstr_w(resNameW));
1502 TRACE(
"(%08x)!\n", uTable);
1521 WCHAR strDevTyp[128];
1525 TRACE(
"(%08X, %p)\n", dwParam, lpParms);
1529 #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \ 1530 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \ 1531 MCI_NOTIFY|MCI_WAIT) 1535 #undef WINE_MCIDRIVER_SUPP 1546 strDevTyp,
sizeof(strDevTyp) /
sizeof(
WCHAR))) {
1564 ERR(
"Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
1584 FIXME(
"Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
1595 if (!strDevTyp[0] &&
1597 strDevTyp,
sizeof(strDevTyp))) {
1598 static const WCHAR wszCdAudio[] = {
'C',
'D',
'A',
'U',
'D',
'I',
'O',0};
1604 strcpyW(strDevTyp, wszCdAudio);
1608 if (strDevTyp[0] == 0) {
1609 FIXME(
"Couldn't load driver\n");
1627 TRACE(
"Failed to open driver (MCI_OPEN_DRIVER) [%08x], closing\n", dwRet);
1655 TRACE(
"(%04x, %08X, %p)\n", wDevID, dwParam, lpParms);
1705 dstSize /=
sizeof(
WCHAR);
1706 if (dstSize <=
strlenW(lpSrcStr)) {
1707 lstrcpynW(lpDstStr, lpSrcStr, dstSize - 1);
1731 TRACE(
"(%08x, %08X, %p[num=%d, wDevTyp=%u])\n",
1744 TRACE(
"MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1751 TRACE(
"MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1754 RegQueryInfoKeyW(
hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
1762 TRACE(
"MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %d\n", lpParms->
wDeviceType);
1769 TRACE(
"MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %d\n", lpParms->
wDeviceType);
1770 FIXME(
"Don't know how to get # of MCI devices of a given type\n");
1790 TRACE(
"MCI_SYSINFO_INSTALLNAME\n");
1804 TRACE(
"MCI_SYSINFO_NAME: nth alias of type %d\n",
1838 if (cnt == lpParms->
dwNumber - 1) {
1926 dwRet =
MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2);
1930 FIXME(
"unhandled MCI_ALL_DEVICE_ID\n");
1954 switch (dwRet & 0xFFFF0000ul) {
1972 FIXME(
"Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
1977 switch (dwRet & 0xFFFF0000ul) {
1995 FIXME(
"Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2000 switch (dwRet & 0xFFFF0000ul) {
2006 FIXME(
"Unsupported value for hiword (%04x)\n",
HIWORD(dwRet));
2011 FIXME(
"Got non null hiword for dwRet=0x%08lx for command %s\n",
2026 if (lpstrBuffer !=
NULL && uLength > 0 &&
2043 if (lpstrBuffer !=
NULL && uLength > 0 &&
2058 TRACE(
"(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
2070 TRACE(
"(%04x)\n", uDeviceID);
2075 WARN(
"Bad uDeviceID\n");
2089 TRACE(
"(%04x, %08lx)\n", uDeviceID,
data);
2094 WARN(
"Bad uDeviceID\n");
2110 TRACE(
"(%08x, %s, %08lx, %08lx)\n",
2115 TRACE(
"=> %08x\n", dwRet);
2127 TRACE(
"(%08x, %s, %08lx, %08lx)\n",
2133 FIXME(
"message %04x mapping failed\n", wMsg);
2188 TRACE(
"(0x%04x, 0x%08x)\n", wDevID,
data);
2211 TRACE(
"(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
2214 WARN(
"Bad uDeviceID\n");
2259 TRACE(
"(%u, %p)\n", uDeviceID, lpdwYieldData);
2262 WARN(
"Bad uDeviceID\n");
2266 WARN(
"No proc set\n");
2269 if (lpdwYieldData) *lpdwYieldData = wmd->
dwYieldData;
2283 TRACE(
"(%u) => %p\n", uDeviceID,
ret);
2295 TRACE(
"(%04x)\n", uDeviceID);
#define MCI_NO_COMMAND_TABLE
LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1, LPARAM lParam2)
BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
static BOOL MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd)
INT WINAPI GetPrivateProfileStringW(LPCWSTR section, LPCWSTR entry, LPCWSTR def_val, LPWSTR buffer, UINT len, LPCWSTR filename)
static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSW lpParms, DWORD dwParam)
GLubyte GLubyte GLubyte GLubyte w
#define MCI_RESOURCE_DRIVER
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
BOOL WINAPI mciExecute(LPCSTR lpstrCommand)
#define WideCharToMultiByte
static DWORD MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, DWORD result)
char * strcat(char *DstString, const char *SrcString)
DWORD_PTR WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
#define MCI_COLONIZED3_RETURN
static DWORD MCI_GetString(LPWSTR *str, LPWSTR *args)
WINE_UNICODE_INLINE WCHAR * strchrW(const WCHAR *str, WCHAR ch)
#define MCI_ANIM_WINDOW_STATE
GLuint GLuint GLsizei count
TW_UINT32 TW_UINT16 TW_UINT16 MSG
static const WCHAR wszHklmMci[]
int WINAPI LoadStringA(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPSTR lpBuffer, _In_ int cchBufferMax)
LPWSTR WINAPI CharLowerW(_Inout_ LPWSTR)
static const WCHAR wszAll[]
LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
BOOL WINAPI sndPlaySoundW(LPCWSTR pszSound, UINT uFlags)
LPVOID WINAPI LockResource(HGLOBAL handle)
static const WCHAR wszNull[]
static WORD MCI_GetMessage(LPCWSTR lpCmd)
#define MCI_RESOURCE_RETURNED
#define strncmpiW(s1, s2, n)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define MCIERR_CUSTOM_DRIVER_BASE
HINSTANCE hWinMM32Instance
static const WCHAR wszSystemIni[]
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
LPWSTR WINAPI CharUpperW(_Inout_ LPWSTR)
struct tagWINE_MCICMDTABLE WINE_MCICMDTABLE
static LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2)
#define DRV_QUERYCONFIGURE
int WINAPI MessageBoxA(_In_opt_ HWND, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ UINT)
#define sprintf(buf, format,...)
static LPWINE_MCIDRIVER MCI_GetDriver(UINT wDevID)
GLenum GLuint GLenum GLsizei const GLchar * buf
UINT WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType)
struct tagMCI_GETDEVCAPS_PARMS * LPMCI_GETDEVCAPS_PARMS
LONG WINAPI RegCloseKey(HKEY hKey)
static LPCWSTR MCI_FindCommand(UINT uTbl, LPCWSTR verb)
static BOOL MCI_GetDWord(DWORD_PTR *data, LPWSTR *ptr)
#define MCI_SYSINFO_QUANTITY
#define MCI_OPEN_ELEMENT_ID
static UINT MCI_GetDriverFromString(LPCWSTR lpstrName)
static DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD_PTR data)
static BOOL MCI_IsCommandTableValid(UINT uTbl)
BOOL WINAPI FreeResource(HGLOBAL handle)
DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, UINT uRetLen, HWND hwndCallback)
UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
static DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr)
static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
#define MCIERR_MISSING_DEVICE_NAME
static DWORD MCI_ParseOptArgs(DWORD_PTR *data, int _offset, LPCWSTR lpCmd, LPWSTR args, LPDWORD dwFlags)
#define MCI_ALL_DEVICE_ID
const char * MCI_MessageToString(UINT wMsg)
DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, UINT uRetLen, HWND hwndCallback)
#define MCI_NOTIFY_FAILURE
#define MCI_ANIM_WINDOW_TEXT
DWORD WINAPI GetCurrentThreadId(VOID)
#define MCI_COMMAND_TABLE_NOT_LOADED
static UINT MCI_SetCommandTable(HGLOBAL hMem, UINT uDevType)
#define MCIERR_PARAM_OVERFLOW
static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParms)
static LPWSTR str_dup_upper(LPCWSTR str)
HFILE WINAPI OpenFile(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle)
#define MCIERR_OUT_OF_MEMORY
#define MCIERR_DEVICE_NOT_INSTALLED
static BOOL MCI_DumpCommandTable(UINT uTbl)
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct tagWINE_MCICMDTABLE * LPWINE_MCICMDTABLE
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
#define MCIERR_BAD_INTEGER
static WINE_MCIDRIVER * MciDrivers
CRITICAL_SECTION WINMM_cs
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
WINE_DEFAULT_DEBUG_CHANNEL(mci)
static const WCHAR keyW[]
BOOL WINAPI mciFreeCommandResource(UINT uTable)
DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
static void MyUserYield(void)
#define MCIERR_INVALID_DEVICE_NAME
#define WINE_MCIDRIVER_SUPP
UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type)
static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
static DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
#define MCI_ANIM_WINDOW_HWND
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
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)
UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
#define MCI_NOTIFY_SUCCESSFUL
static const WCHAR wszOpen[]
struct tagWINE_MCIDRIVER * lpNext
#define MCIERR_CANNOT_USE_ALL
#define MCIERR_PARSER_INTERNAL
UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPWSTR buf, UINT len)
SHORT WINAPI GetAsyncKeyState(_In_ int)
#define memcpy(s1, s2, n)
BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER *lpwmd)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
#define MCI_DEVTYPE_CD_AUDIO
#define MCIERR_OUTOFRANGE
#define MCI_END_COMMAND_LIST
#define MCI_DEVTYPE_FIRST
UINT WINAPI GetDriveTypeW(IN LPCWSTR lpRootPathName)
struct tagMCI_STATUS_PARMS * LPMCI_STATUS_PARMS
WINE_UNICODE_INLINE WCHAR * strrchrW(const WCHAR *str, WCHAR ch)
#define MCI_SYSINFO_INSTALLNAME
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
static DWORD MCI_GetReturnType(LPCWSTR lpCmd)
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz)
LPWSTR MCI_strdupAtoW(LPCSTR str)
HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
static const WCHAR wszMci[]
#define MCIERR_NO_CLOSING_QUOTE
#define MCI_INTEGER_RETURNED
#define MCIERR_UNRECOGNIZED_KEYWORD
#define MCIERR_NEW_REQUIRES_ALIAS
#define MultiByteToWideChar
#define MCIERR_EXTENSION_NOT_FOUND
#define MCI_COLONIZED4_RETURN
#define MCIERR_UNRECOGNIZED_COMMAND
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
WINE_UNICODE_INLINE int strcmpW(const WCHAR *str1, const WCHAR *str2)
char * strcpy(char *DstString, const char *SrcString)
#define MCIERR_EXTRA_CHARACTERS
DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
#define MCI_DEVTYPE_SEQUENCER
static WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE]
#define MCI_DEVTYPE_WAVEFORM_AUDIO
#define GetProcAddress(x, y)
CHAR szPathName[OFS_MAXPATHNAME]
LPSTR MCI_strdupWtoA(LPCWSTR str)
#define strtoulW(s1, s2, b)
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)
GLuint GLuint GLsizei GLenum type
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType, DWORD_PTR *data, LPWSTR lpstrRet, UINT uRetLen)
#define MCIERR_INVALID_DEVICE_ID
HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
#define MCIERR_NULL_PARAMETER_BLOCK
static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, DWORD_PTR lp)
HWND WINAPI GetActiveWindow(void)
UINT(CALLBACK * YIELDPROC)(MCIDEVICEID, DWORD)
#define HeapFree(x, y, z)
static UINT MCI_GetCommandTable(UINT uDevType)
static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms)
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
#define HKEY_LOCAL_MACHINE
YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD *lpdwYieldData)