- rewrite MCI interfaces as Unicode interface (as it should be)
- made some winmm APIs rely on the Unicode version for the core
implementation (instead of Ansi flavor)
diff --git a/dlls/winmm/Makefile.in b/dlls/winmm/Makefile.in
index 2100c66..fe49038 100644
--- a/dlls/winmm/Makefile.in
+++ b/dlls/winmm/Makefile.in
@@ -5,6 +5,7 @@
VPATH = @srcdir@
MODULE = winmm.dll
IMPORTS = user32 advapi32 kernel32 ntdll
+EXTRALIBS = $(LIBUNICODE)
C_SRCS = \
driver.c \
diff --git a/dlls/winmm/driver.c b/dlls/winmm/driver.c
index 673f702..c4a52a5 100644
--- a/dlls/winmm/driver.c
+++ b/dlls/winmm/driver.c
@@ -1,5 +1,3 @@
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
/*
* WINE Drivers functions
*
@@ -33,15 +31,16 @@
#include "mmddk.h"
#include "winemm.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(driver);
-#define HKLM_BASE "Software\\Microsoft\\Windows NT\\CurrentVersion"
-
static LPWINE_DRIVER lpDrvItemList /* = NULL */;
+static const WCHAR HKLM_BASE[] = {'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',0};
WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16 h) /* = NULL */;
-LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */;
+LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM) /* = NULL */;
LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */;
LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */;
@@ -207,16 +206,19 @@
* DRIVER_GetLibName [internal]
*
*/
-BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
+BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz)
{
HKEY hKey, hSecKey;
DWORD bufLen, lRet;
+ static const WCHAR wszSystemIni[] = {'S','Y','S','T','E','M','.','I','N','I',0};
+ WCHAR wsznull = '\0';
- lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
+ lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS) {
- lRet = RegOpenKeyExA(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
+ lRet = RegOpenKeyExW(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
if (lRet == ERROR_SUCCESS) {
- lRet = RegQueryValueExA(hSecKey, keyName, 0, 0, buf, &bufLen);
+ bufLen = sz;
+ lRet = RegQueryValueExW(hSecKey, keyName, 0, 0, (void*)buf, &bufLen);
RegCloseKey( hSecKey );
}
RegCloseKey( hKey );
@@ -224,7 +226,7 @@
if (lRet == ERROR_SUCCESS) return TRUE;
/* default to system.ini if we can't find it in the registry,
* to support native installations where system.ini is still used */
- return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI");
+ return GetPrivateProfileStringW(sectName, keyName, &wsznull, buf, sz, wszSystemIni);
}
/**************************************************************************
@@ -232,16 +234,16 @@
*
* Tries to load a 32 bit driver whose DLL's (module) name is fn
*/
-LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
+LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
{
LPWINE_DRIVER lpDrv = NULL;
HMODULE hModule = 0;
- LPSTR ptr;
+ LPWSTR ptr;
LPCSTR cause = 0;
- TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2);
+ TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2);
- if ((ptr = strchr(fn, ' ')) != NULL) {
+ if ((ptr = strchrW(fn, ' ')) != NULL) {
*ptr++ = '\0';
while (*ptr == ' ') ptr++;
if (*ptr == '\0') ptr = NULL;
@@ -250,7 +252,7 @@
lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
if (lpDrv == NULL) {cause = "OOM"; goto exit;}
- if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
+ if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
@@ -290,7 +292,7 @@
exit:
FreeLibrary(hModule);
HeapFree(GetProcessHeap(), 0, lpDrv);
- TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
+ TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause);
return NULL;
}
@@ -301,23 +303,59 @@
* (0,1,DRV_ENABLE,0 ,0)
* (0,1,DRV_OPEN ,buf[256],0)
*/
-HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
+HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
+{
+ INT len;
+ LPWSTR dn = NULL;
+ LPWSTR sn = NULL;
+ HDRVR ret;
+
+ if (lpDriverName)
+ {
+ len = MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, NULL, 0 );
+ dn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ if (!dn) return 0;
+ MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, dn, len );
+ }
+
+ if (lpSectionName)
+ {
+ len = MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, NULL, 0 );
+ sn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ if (!sn) return 0;
+ MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, sn, len );
+ }
+
+ ret = OpenDriver(dn, sn, lParam);
+
+ if (dn) HeapFree(GetProcessHeap(), 0, dn);
+ if (sn) HeapFree(GetProcessHeap(), 0, sn);
+ return ret;
+}
+
+/**************************************************************************
+ * OpenDriver [WINMM.@]
+ * DrvOpen [WINMM.@]
+ */
+HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
{
LPWINE_DRIVER lpDrv = NULL;
- char libName[128];
- LPCSTR lsn = lpSectionName;
+ WCHAR libName[128];
+ LPCWSTR lsn = lpSectionName;
- TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
+ TRACE("(%s, %s, 0x%08lx);\n",
+ debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam);
if (lsn == NULL) {
- lstrcpynA(libName, lpDriverName, sizeof(libName));
+ static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0};
+ lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR));
- if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
+ if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
goto the_end;
- lsn = "Drivers32";
+ lsn = wszDrivers32;
}
if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
- (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
+ (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
goto the_end;
/* now we will try a 16 bit driver (and add all the glue to make it work... which
@@ -326,12 +364,13 @@
*/
WINMM_CheckForMMSystem();
if (pFnOpenDriver16 &&
- (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam2)))
+ (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam)))
{
- if (DRIVER_AddToList(lpDrv, 0, lParam2)) goto the_end;
+ if (DRIVER_AddToList(lpDrv, 0, lParam)) goto the_end;
HeapFree(GetProcessHeap(), 0, lpDrv);
}
- TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
+ TRACE("Failed to open driver %s from system.ini file, section %s\n",
+ debugstr_w(lpDriverName), debugstr_w(lpSectionName));
return 0;
the_end:
@@ -340,40 +379,6 @@
}
/**************************************************************************
- * OpenDriver [WINMM.@]
- * DrvOpen [WINMM.@]
- */
-HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
-{
- INT len;
- LPSTR dn = NULL;
- LPSTR sn = NULL;
- HDRVR ret;
-
- if (lpDriverName)
- {
- len = WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, NULL, 0, NULL, NULL );
- dn = HeapAlloc( GetProcessHeap(), 0, len );
- if (!dn) return 0;
- WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, dn, len, NULL, NULL );
- }
-
- if (lpSectionName)
- {
- len = WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, NULL, 0, NULL, NULL );
- sn = HeapAlloc( GetProcessHeap(), 0, len );
- if (!sn) return 0;
- WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, sn, len, NULL, NULL );
- }
-
- ret = OpenDriverA(dn, sn, lParam);
-
- HeapFree(GetProcessHeap(), 0, dn);
- HeapFree(GetProcessHeap(), 0, sn);
- return ret;
-}
-
-/**************************************************************************
* CloseDriver [WINMM.@]
* DrvClose [WINMM.@]
*/
diff --git a/dlls/winmm/mci.c b/dlls/winmm/mci.c
index 1db31ac..4246b46 100644
--- a/dlls/winmm/mci.c
+++ b/dlls/winmm/mci.c
@@ -31,6 +31,15 @@
* - use a default registry setting to replace the [mci] section in
* configuration file (layout of info in registry should be compatible
* with all Windows' version - which use different layouts of course)
+ * - implement automatic open
+ * + only works on string interface, on regular devices (don't work on all
+ * nor custom devices)
+ * - command table handling isn't thread safe
+ */
+
+/* to be cross checked:
+ * - heapalloc for *sizeof(WCHAR) when needed
+ * - size of string in WCHAR or bytes? (#chars for MCI_INFO, #bytes for MCI_SYSINFO)
*/
#include "config.h"
@@ -49,34 +58,41 @@
#include "winuser.h"
#include "winnls.h"
#include "winreg.h"
+#include "wownt32.h"
#include "digitalv.h"
#include "winemm.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mci);
-WINMM_MapType (*pFnMciMapMsg16To32A) (WORD,WORD,DWORD*) /* = NULL */;
-WINMM_MapType (*pFnMciUnMapMsg16To32A)(WORD,WORD,DWORD) /* = NULL */;
-WINMM_MapType (*pFnMciMapMsg32ATo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */;
-WINMM_MapType (*pFnMciUnMapMsg32ATo16)(WORD,WORD,DWORD,DWORD) /* = NULL */;
+WINMM_MapType (*pFnMciMapMsg16To32W) (WORD,WORD,DWORD*) /* = NULL */;
+WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD) /* = NULL */;
+WINMM_MapType (*pFnMciMapMsg32WTo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */;
+WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD) /* = NULL */;
/* First MCI valid device ID (0 means error) */
#define MCI_MAGIC 0x0001
/* MCI settings */
-#define HKLM_MCI "Software\\Microsoft\\Windows NT\\CurrentVersion\\MCI"
+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};
+static const WCHAR wszNull [] = {0};
+static const WCHAR wszAll [] = {'A','L','L',0};
+static const WCHAR wszMci [] = {'M','C','I',0};
+static const WCHAR wszOpen [] = {'o','p','e','n',0};
+static const WCHAR wszSystemIni[] = {'s','y','s','t','e','m','.','i','n','i',0};
/* dup a string and uppercase it */
-inline static LPSTR str_dup_upper( LPCSTR str )
+inline static LPWSTR str_dup_upper( LPCWSTR str )
{
- INT len = strlen(str) + 1;
- LPSTR p = HeapAlloc( GetProcessHeap(), 0, len );
+ INT len = (strlenW(str) + 1) * sizeof(WCHAR);
+ LPWSTR p = HeapAlloc( GetProcessHeap(), 0, len );
if (p)
{
memcpy( p, str, len );
- CharUpperA( p );
+ CharUpperW( p );
}
return p;
}
@@ -100,7 +116,7 @@
/**************************************************************************
* MCI_GetDriverFromString [internal]
*/
-UINT MCI_GetDriverFromString(LPCSTR lpstrName)
+UINT MCI_GetDriverFromString(LPCWSTR lpstrName)
{
LPWINE_MCIDRIVER wmd;
UINT ret = 0;
@@ -108,20 +124,20 @@
if (!lpstrName)
return 0;
- if (!lstrcmpiA(lpstrName, "ALL"))
+ if (!strcmpiW(lpstrName, wszAll))
return MCI_ALL_DEVICE_ID;
EnterCriticalSection(&WINMM_IData->cs);
for (wmd = WINMM_IData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
- if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
+ if (wmd->lpstrElementName && strcmpW(wmd->lpstrElementName, lpstrName) == 0) {
ret = wmd->wDeviceID;
break;
}
- if (wmd->lpstrDeviceType && strcasecmp(wmd->lpstrDeviceType, lpstrName) == 0) {
+ if (wmd->lpstrDeviceType && strcmpiW(wmd->lpstrDeviceType, lpstrName) == 0) {
ret = wmd->wDeviceID;
break;
}
- if (wmd->lpstrAlias && strcasecmp(wmd->lpstrAlias, lpstrName) == 0) {
+ if (wmd->lpstrAlias && strcmpiW(wmd->lpstrAlias, lpstrName) == 0) {
ret = wmd->wDeviceID;
break;
}
@@ -134,13 +150,26 @@
/**************************************************************************
* MCI_MessageToString [internal]
*/
-const char* MCI_MessageToString(UINT16 wMsg)
+const char* MCI_MessageToString(UINT wMsg)
{
static char buffer[100];
#define CASE(s) case (s): return #s
switch (wMsg) {
+ CASE(DRV_LOAD);
+ CASE(DRV_ENABLE);
+ CASE(DRV_OPEN);
+ CASE(DRV_CLOSE);
+ CASE(DRV_DISABLE);
+ CASE(DRV_FREE);
+ CASE(DRV_CONFIGURE);
+ CASE(DRV_QUERYCONFIGURE);
+ CASE(DRV_INSTALL);
+ CASE(DRV_REMOVE);
+ CASE(DRV_EXITSESSION);
+ CASE(DRV_EXITAPPLICATION);
+ CASE(DRV_POWER);
CASE(MCI_BREAK);
CASE(MCI_CLOSE);
CASE(MCI_CLOSE_DRIVER);
@@ -193,23 +222,350 @@
}
}
+LPWSTR MCI_strdupAtoW( LPCSTR str )
+{
+ LPWSTR ret;
+ INT len;
+
+ if (!str) return NULL;
+ len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
+ ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
+ return ret;
+}
+
+LPSTR MCI_strdupWtoA( LPCWSTR str )
+{
+ LPSTR ret;
+ INT len;
+
+ if (!str) return NULL;
+ len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
+ ret = HeapAlloc( GetProcessHeap(), 0, len );
+ if (ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
+ return ret;
+}
+
+static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
+{
+ if (msg < DRV_RESERVED) return 0;
+
+ switch (msg)
+ {
+ case MCI_CLOSE:
+ case MCI_CONFIGURE:
+ case MCI_PLAY:
+ case MCI_SEEK:
+ case MCI_STOP:
+ case MCI_PAUSE:
+ case MCI_GETDEVCAPS:
+ case MCI_SPIN:
+ case MCI_SET:
+ case MCI_STEP:
+ case MCI_RECORD:
+ case MCI_BREAK:
+ case MCI_SOUND:
+ case MCI_STATUS:
+ case MCI_CUE:
+ case MCI_REALIZE:
+ case MCI_PUT:
+ case MCI_WHERE:
+ case MCI_FREEZE:
+ case MCI_UNFREEZE:
+ case MCI_CUT:
+ case MCI_COPY:
+ case MCI_PASTE:
+ case MCI_UPDATE:
+ case MCI_RESUME:
+ case MCI_DELETE:
+ return 0;
+
+ case MCI_OPEN:
+ {
+ MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA*)*dwParam2;
+ MCI_OPEN_PARMSW *mci_openW;
+ DWORD_PTR *ptr;
+
+ ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD_PTR) + sizeof(*mci_openW) + 2 * sizeof(DWORD));
+ if (!ptr) return -1;
+
+ *ptr++ = *dwParam2; /* save the previous pointer */
+ *dwParam2 = (DWORD_PTR)ptr;
+ mci_openW = (MCI_OPEN_PARMSW *)ptr;
+
+ if (dwParam1 & MCI_NOTIFY)
+ mci_openW->dwCallback = mci_openA->dwCallback;
+
+ if (dwParam1 & MCI_OPEN_TYPE)
+ {
+ if (dwParam1 & MCI_OPEN_TYPE_ID)
+ mci_openW->lpstrDeviceType = (LPWSTR)mci_openA->lpstrDeviceType;
+ else
+ mci_openW->lpstrDeviceType = MCI_strdupAtoW(mci_openA->lpstrDeviceType);
+ }
+ if (dwParam1 & MCI_OPEN_ELEMENT)
+ {
+ if (dwParam1 & MCI_OPEN_ELEMENT_ID)
+ mci_openW->lpstrElementName = (LPWSTR)mci_openA->lpstrElementName;
+ else
+ mci_openW->lpstrElementName = MCI_strdupAtoW(mci_openA->lpstrElementName);
+ }
+ if (dwParam1 & MCI_OPEN_ALIAS)
+ mci_openW->lpstrAlias = MCI_strdupAtoW(mci_openA->lpstrAlias);
+ /* FIXME: this is only needed for specific types of MCI devices, and
+ * may cause a segfault if the two DWORD:s don't exist at the end of
+ * mci_openA
+ */
+ memcpy(mci_openW + 1, mci_openA + 1, 2 * sizeof(DWORD));
+ }
+ return 1;
+
+ case MCI_WINDOW:
+ if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
+ {
+ MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)*dwParam2;
+ MCI_ANIM_WINDOW_PARMSW *mci_windowW;
+
+ mci_windowW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowW));
+ if (!mci_windowW) return -1;
+
+ *dwParam2 = (DWORD_PTR)mci_windowW;
+
+ mci_windowW->lpstrText = MCI_strdupAtoW(mci_windowA->lpstrText);
+
+ if (dwParam1 & MCI_NOTIFY)
+ mci_windowW->dwCallback = mci_windowA->dwCallback;
+ if (dwParam1 & MCI_ANIM_WINDOW_HWND)
+ mci_windowW->hWnd = mci_windowA->hWnd;
+ if (dwParam1 & MCI_ANIM_WINDOW_STATE)
+ mci_windowW->nCmdShow = mci_windowA->nCmdShow;
+
+ return 1;
+ }
+ return 0;
+
+ case MCI_SYSINFO:
+ {
+ MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*dwParam2;
+ MCI_SYSINFO_PARMSW *mci_sysinfoW;
+ DWORD_PTR *ptr;
+
+ ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoW) + sizeof(DWORD_PTR));
+ if (!ptr) return -1;
+
+ *ptr++ = *dwParam2; /* save the previous pointer */
+ *dwParam2 = (DWORD_PTR)ptr;
+ mci_sysinfoW = (MCI_SYSINFO_PARMSW *)ptr;
+
+ if (dwParam1 & MCI_NOTIFY)
+ mci_sysinfoW->dwCallback = mci_sysinfoA->dwCallback;
+
+ mci_sysinfoW->dwRetSize = mci_sysinfoA->dwRetSize;
+ mci_sysinfoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoW->dwRetSize);
+ mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber;
+ mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType;
+ return 1;
+ }
+ case MCI_INFO:
+ {
+ MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*dwParam2;
+ MCI_INFO_PARMSW *mci_infoW;
+ DWORD_PTR *ptr;
+
+ ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_infoW) + sizeof(DWORD_PTR));
+ if (!ptr) return -1;
+
+ *ptr++ = *dwParam2; /* save the previous pointer */
+ *dwParam2 = (DWORD_PTR)ptr;
+ mci_infoW = (MCI_INFO_PARMSW *)ptr;
+
+ if (dwParam1 & MCI_NOTIFY)
+ mci_infoW->dwCallback = mci_infoA->dwCallback;
+
+ mci_infoW->dwRetSize = mci_infoA->dwRetSize * sizeof(WCHAR); /* it's not the same as SYSINFO !!! */
+ mci_infoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_infoW->dwRetSize);
+ return 1;
+ }
+ case MCI_SAVE:
+ {
+ MCI_SAVE_PARMSA *mci_saveA = (MCI_SAVE_PARMSA *)*dwParam2;
+ MCI_SAVE_PARMSW *mci_saveW;
+
+ mci_saveW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_saveW));
+ if (!mci_saveW) return -1;
+
+ *dwParam2 = (DWORD_PTR)mci_saveW;
+ if (dwParam1 & MCI_NOTIFY)
+ mci_saveW->dwCallback = mci_saveA->dwCallback;
+ mci_saveW->lpfilename = MCI_strdupAtoW(mci_saveA->lpfilename);
+ return 1;
+ }
+ case MCI_LOAD:
+ {
+ MCI_LOAD_PARMSA *mci_loadA = (MCI_LOAD_PARMSA *)*dwParam2;
+ MCI_LOAD_PARMSW *mci_loadW;
+
+ mci_loadW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_loadW));
+ if (!mci_loadW) return -1;
+
+ *dwParam2 = (DWORD_PTR)mci_loadW;
+ if (dwParam1 & MCI_NOTIFY)
+ mci_loadW->dwCallback = mci_loadA->dwCallback;
+ mci_loadW->lpfilename = MCI_strdupAtoW(mci_loadA->lpfilename);
+ return 1;
+ }
+
+ case MCI_ESCAPE:
+ {
+ MCI_VD_ESCAPE_PARMSA *mci_vd_escapeA = (MCI_VD_ESCAPE_PARMSA *)*dwParam2;
+ MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW;
+
+ mci_vd_escapeW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_vd_escapeW));
+ if (!mci_vd_escapeW) return -1;
+
+ *dwParam2 = (DWORD_PTR)mci_vd_escapeW;
+ if (dwParam1 & MCI_NOTIFY)
+ mci_vd_escapeW->dwCallback = mci_vd_escapeA->dwCallback;
+ mci_vd_escapeW->lpstrCommand = MCI_strdupAtoW(mci_vd_escapeA->lpstrCommand);
+ return 1;
+ }
+ default:
+ FIXME("Message %s needs translation\n", MCI_MessageToString(msg));
+ return -1;
+ }
+}
+
+static DWORD MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2,
+ DWORD result)
+{
+ switch (msg)
+ {
+ case MCI_OPEN:
+ {
+ DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
+ MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)*ptr;
+ MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)(ptr + 1);
+
+ mci_openA->wDeviceID = mci_openW->wDeviceID;
+
+ if (dwParam1 & MCI_OPEN_TYPE)
+ {
+ if (!(dwParam1 & MCI_OPEN_TYPE_ID))
+ HeapFree(GetProcessHeap(), 0, mci_openW->lpstrDeviceType);
+ }
+ if (dwParam1 & MCI_OPEN_ELEMENT)
+ {
+ if (!(dwParam1 & MCI_OPEN_ELEMENT_ID))
+ HeapFree(GetProcessHeap(), 0, mci_openW->lpstrElementName);
+ }
+ if (dwParam1 & MCI_OPEN_ALIAS)
+ HeapFree(GetProcessHeap(), 0, mci_openW->lpstrAlias);
+ HeapFree(GetProcessHeap(), 0, ptr);
+ }
+ break;
+ case MCI_WINDOW:
+ if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
+ {
+ MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)dwParam2;
+
+ HeapFree(GetProcessHeap(), 0, (void*)mci_windowW->lpstrText);
+ HeapFree(GetProcessHeap(), 0, mci_windowW);
+ }
+ break;
+
+ case MCI_SYSINFO:
+ {
+ DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
+ MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*ptr;
+ MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)(ptr + 1);
+
+ if (!result)
+ {
+ mci_sysinfoA->dwNumber = mci_sysinfoW->dwNumber;
+ mci_sysinfoA->wDeviceType = mci_sysinfoW->wDeviceType;
+ if (dwParam1 & MCI_SYSINFO_QUANTITY)
+ *(DWORD*)mci_sysinfoA->lpstrReturn = *(DWORD*)mci_sysinfoW->lpstrReturn;
+ else
+ WideCharToMultiByte(CP_ACP, 0,
+ mci_sysinfoW->lpstrReturn, mci_sysinfoW->dwRetSize,
+ mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize,
+ NULL, NULL);
+ }
+
+ HeapFree(GetProcessHeap(), 0, mci_sysinfoW->lpstrReturn);
+ HeapFree(GetProcessHeap(), 0, ptr);
+ }
+ break;
+ case MCI_INFO:
+ {
+ DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
+ MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*ptr;
+ MCI_INFO_PARMSW *mci_infoW = (MCI_INFO_PARMSW *)(ptr + 1);
+
+ if (!result)
+ {
+ WideCharToMultiByte(CP_ACP, 0,
+ mci_infoW->lpstrReturn, mci_infoW->dwRetSize / sizeof(WCHAR),
+ mci_infoA->lpstrReturn, mci_infoA->dwRetSize,
+ NULL, NULL);
+ }
+
+ HeapFree(GetProcessHeap(), 0, mci_infoW->lpstrReturn);
+ HeapFree(GetProcessHeap(), 0, ptr);
+ }
+ break;
+ case MCI_SAVE:
+ {
+ MCI_SAVE_PARMSW *mci_saveW = (MCI_SAVE_PARMSW *)dwParam2;
+
+ HeapFree(GetProcessHeap(), 0, (void*)mci_saveW->lpfilename);
+ HeapFree(GetProcessHeap(), 0, mci_saveW);
+ }
+ break;
+ case MCI_LOAD:
+ {
+ MCI_LOAD_PARMSW *mci_loadW = (MCI_LOAD_PARMSW *)dwParam2;
+
+ HeapFree(GetProcessHeap(), 0, (void*)mci_loadW->lpfilename);
+ HeapFree(GetProcessHeap(), 0, mci_loadW);
+ }
+ break;
+ case MCI_ESCAPE:
+ {
+ MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW = (MCI_VD_ESCAPE_PARMSW *)dwParam2;
+
+ HeapFree(GetProcessHeap(), 0, (void*)mci_vd_escapeW->lpstrCommand);
+ HeapFree(GetProcessHeap(), 0, mci_vd_escapeW);
+ }
+ break;
+
+ default:
+ FIXME("Message %s needs unmapping\n", MCI_MessageToString(msg));
+ break;
+ }
+
+ return result;
+}
+
/**************************************************************************
* MCI_GetDevTypeFromFileName [internal]
*/
-static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
+static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPCWSTR buf, UINT len)
{
- LPSTR tmp;
+ LPCWSTR tmp;
HKEY hKey;
-
- if ((tmp = strrchr(fileName, '.'))) {
- if (RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\MCI Extensions",
+ static const WCHAR keyW[] = {'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',' ','E','x','t','e','n','s','i','o','n','s',0};
+ if ((tmp = strrchrW(fileName, '.'))) {
+ if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, keyW,
0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
DWORD dwLen = len;
- LONG lRet = RegQueryValueExA( hKey, tmp + 1, 0, 0, buf, &dwLen );
+ LONG lRet = RegQueryValueExW( hKey, tmp + 1, 0, 0, (void*)buf, &dwLen );
RegCloseKey( hKey );
if (lRet == ERROR_SUCCESS) return 0;
}
- TRACE("No ...\\MCI Extensions entry for '%s' found.\n", tmp);
+ TRACE("No ...\\MCI Extensions entry for %s found.\n", debugstr_w(tmp));
}
return MCIERR_EXTENSION_NOT_FOUND;
}
@@ -219,9 +575,9 @@
typedef struct tagWINE_MCICMDTABLE {
UINT uDevType;
- LPCSTR lpTable;
+ const BYTE* lpTable;
UINT nVerbs; /* number of verbs in command table */
- LPCSTR* aVerbs; /* array of verbs to speed up the verb look up process */
+ LPCWSTR* aVerbs; /* array of verbs to speed up the verb look up process */
} WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE;
static WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE];
@@ -231,7 +587,8 @@
*/
static BOOL MCI_IsCommandTableValid(UINT uTbl)
{
- LPCSTR lmem, str;
+ const BYTE* lmem;
+ LPCWSTR str;
DWORD flg;
WORD eid;
int idx = 0;
@@ -245,28 +602,26 @@
lmem = S_MciCmdTable[uTbl].lpTable;
do {
- do {
- str = lmem;
- lmem += strlen(lmem) + 1;
- flg = *(const DWORD*)lmem;
- eid = *(const WORD*)(lmem + sizeof(DWORD));
- lmem += sizeof(DWORD) + sizeof(WORD);
- idx ++;
- /* EPP TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */
- switch (eid) {
- case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */
- case MCI_STRING: if (inCst) return FALSE; break;
- case MCI_INTEGER: if (!*str) return FALSE; break;
- case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break;
- case MCI_RETURN: if (*str || idx != 1) return FALSE; break;
- case MCI_FLAG: if (!*str) return FALSE; break;
- case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break;
- case MCI_RECT: if (!*str || inCst) return FALSE; break;
- case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break;
- case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break;
- default: return FALSE;
- }
- } while (eid != MCI_END_COMMAND_LIST);
+ str = (LPCWSTR)lmem;
+ lmem += (strlenW(str) + 1) * sizeof(WCHAR);
+ flg = *(const DWORD*)lmem;
+ eid = *(const WORD*)(lmem + sizeof(DWORD));
+ lmem += sizeof(DWORD) + sizeof(WORD);
+ idx ++;
+ /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
+ switch (eid) {
+ case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */
+ case MCI_STRING: if (inCst) return FALSE; break;
+ case MCI_INTEGER: if (!*str) return FALSE; break;
+ case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break;
+ case MCI_RETURN: if (*str || idx != 1) return FALSE; break;
+ case MCI_FLAG: if (!*str) return FALSE; break;
+ case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break;
+ case MCI_RECT: if (!*str || inCst) return FALSE; break;
+ case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break;
+ case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break;
+ default: return FALSE;
+ }
} while (eid != MCI_END_COMMAND_LIST);
return TRUE;
}
@@ -276,8 +631,8 @@
*/
static BOOL MCI_DumpCommandTable(UINT uTbl)
{
- LPCSTR lmem;
- LPCSTR str;
+ const BYTE* lmem;
+ LPCWSTR str;
DWORD flg;
WORD eid;
@@ -289,14 +644,14 @@
lmem = S_MciCmdTable[uTbl].lpTable;
do {
do {
- str = lmem;
- lmem += strlen(lmem) + 1;
+ str = (LPCWSTR)lmem;
+ lmem += (strlenW(str) + 1) * sizeof(WCHAR);
flg = *(const DWORD*)lmem;
eid = *(const WORD*)(lmem + sizeof(DWORD));
- TRACE("cmd='%s' %08lx %04x\n", str, flg, eid);
+ /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
lmem += sizeof(DWORD) + sizeof(WORD);
} while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST);
- TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : "");
+ /* EPP TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); */
} while (eid != MCI_END_COMMAND_LIST);
return TRUE;
}
@@ -308,8 +663,8 @@
static UINT MCI_GetCommandTable(UINT uDevType)
{
UINT uTbl;
- char buf[32];
- LPCSTR str = NULL;
+ WCHAR buf[32];
+ LPCWSTR str = NULL;
/* first look up existing for existing devType */
for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
@@ -319,15 +674,16 @@
/* well try to load id */
if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) {
- if (LoadStringA(WINMM_IData->hWinMM32Instance, uDevType, buf, sizeof(buf))) {
+ if (LoadStringW(WINMM_IData->hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) {
str = buf;
}
} else if (uDevType == 0) {
- str = "CORE";
+ static const WCHAR wszCore[] = {'C','O','R','E',0};
+ str = wszCore;
}
uTbl = MCI_NO_COMMAND_TABLE;
if (str) {
- HRSRC hRsrc = FindResourceA(WINMM_IData->hWinMM32Instance, str, (LPCSTR)RT_RCDATA);
+ HRSRC hRsrc = FindResourceW(WINMM_IData->hWinMM32Instance, str, (LPCWSTR)RT_RCDATA);
HANDLE hMem = 0;
if (hRsrc) hMem = LoadResource(WINMM_IData->hWinMM32Instance, hRsrc);
@@ -335,7 +691,7 @@
uTbl = MCI_SetCommandTable(LockResource(hMem), uDevType);
} else {
WARN("No command table found in resource %p[%s]\n",
- WINMM_IData->hWinMM32Instance, str);
+ WINMM_IData->hWinMM32Instance, debugstr_w(str));
}
}
TRACE("=> %d\n", uTbl);
@@ -359,10 +715,11 @@
bInitDone = TRUE;
MCI_GetCommandTable(0);
}
-
+ TRACE("(%p, %u)\n", table, uDevType);
for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
if (!S_MciCmdTable[uTbl].lpTable) {
- LPCSTR lmem, str;
+ const BYTE* lmem;
+ LPCWSTR str;
WORD eid;
WORD count;
@@ -378,21 +735,22 @@
lmem = S_MciCmdTable[uTbl].lpTable;
count = 0;
do {
- lmem += strlen(lmem) + 1;
+ str = (LPCWSTR)lmem;
+ lmem += (strlenW(str) + 1) * sizeof(WCHAR);
eid = *(const WORD*)(lmem + sizeof(DWORD));
lmem += sizeof(DWORD) + sizeof(WORD);
if (eid == MCI_COMMAND_HEAD)
count++;
} while (eid != MCI_END_COMMAND_LIST);
- S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCSTR));
+ S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCWSTR));
S_MciCmdTable[uTbl].nVerbs = count;
lmem = S_MciCmdTable[uTbl].lpTable;
count = 0;
do {
- str = lmem;
- lmem += strlen(lmem) + 1;
+ str = (LPCWSTR)lmem;
+ lmem += (strlenW(str) + 1) * sizeof(WCHAR);
eid = *(const WORD*)(lmem + sizeof(DWORD));
lmem += sizeof(DWORD) + sizeof(WORD);
if (eid == MCI_COMMAND_HEAD)
@@ -409,11 +767,12 @@
/**************************************************************************
* MCI_DeleteCommandTable [internal]
*/
-static BOOL MCI_DeleteCommandTable(UINT uTbl)
+BOOL MCI_DeleteCommandTable(UINT uTbl, BOOL delete)
{
if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].lpTable)
return FALSE;
+ if (delete) HeapFree(GetProcessHeap(), 0, (void*)S_MciCmdTable[uTbl].lpTable);
S_MciCmdTable[uTbl].lpTable = NULL;
HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs);
S_MciCmdTable[uTbl].aVerbs = 0;
@@ -455,33 +814,33 @@
/**************************************************************************
* MCI_OpenMciDriver [internal]
*/
-static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCSTR drvTyp, LPARAM lp)
+static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, LPARAM lp)
{
- char libName[128];
+ WCHAR libName[128];
- if (!DRIVER_GetLibName(drvTyp, "mci", libName, sizeof(libName)))
+ if (!DRIVER_GetLibName(drvTyp, wszMci, libName, sizeof(libName)))
return FALSE;
wmd->bIs32 = 0xFFFF;
/* First load driver */
if ((wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp))) {
wmd->bIs32 = TRUE;
- } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32ATo16) {
+ } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32WTo16) {
WINMM_MapType res;
- switch (res = pFnMciMapMsg32ATo16(0, DRV_OPEN, 0, &lp)) {
+ switch (res = pFnMciMapMsg32WTo16(0, DRV_OPEN, 0, &lp)) {
case WINMM_MAP_MSGERROR:
TRACE("Not handled yet (DRV_OPEN)\n");
break;
case WINMM_MAP_NOMEM:
- TRACE("Problem mapping msg=DRV_OPEN from 32a to 16\n");
+ TRACE("Problem mapping msg=DRV_OPEN from 32W to 16\n");
break;
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
- if ((wmd->hDriver = OpenDriverA(drvTyp, "mci", lp)))
+ if ((wmd->hDriver = OpenDriver(drvTyp, wszMci, lp)))
wmd->bIs32 = FALSE;
if (res == WINMM_MAP_OKMEM)
- pFnMciUnMapMsg32ATo16(0, DRV_OPEN, 0, lp);
+ pFnMciUnMapMsg32WTo16(0, DRV_OPEN, 0, lp);
break;
}
}
@@ -491,11 +850,11 @@
/**************************************************************************
* MCI_LoadMciDriver [internal]
*/
-static DWORD MCI_LoadMciDriver(LPCSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd)
+static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd)
{
- LPSTR strDevTyp = str_dup_upper(_strDevTyp);
+ LPWSTR strDevTyp = str_dup_upper(_strDevTyp);
LPWINE_MCIDRIVER wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
- MCI_OPEN_DRIVER_PARMSA modp;
+ MCI_OPEN_DRIVER_PARMSW modp;
DWORD dwRet = 0;
if (!wmd || !strDevTyp) {
@@ -530,13 +889,13 @@
/* silence warning if all is used... some bogus program use commands like
* 'open all'...
*/
- if (strcasecmp(strDevTyp, "all") == 0) {
+ if (strcmpiW(strDevTyp, wszAll) == 0) {
dwRet = MCIERR_CANNOT_USE_ALL;
} else {
FIXME("Couldn't load driver for type %s.\n"
"If you don't have a windows installation accessible from Wine,\n"
"you perhaps forgot to create a [mci] section in system.ini\n",
- strDevTyp);
+ debugstr_w(strDevTyp));
dwRet = MCIERR_DEVICE_NOT_INSTALLED;
}
goto errCleanUp;
@@ -551,7 +910,7 @@
wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
TRACE("Loaded driver %p (%s), type is %d, cmdTable=%08x\n",
- wmd->hDriver, strDevTyp, modp.wType, modp.wCustomCommandTable);
+ wmd->hDriver, debugstr_w(strDevTyp), modp.wType, modp.wCustomCommandTable);
wmd->lpstrDeviceType = strDevTyp;
wmd->wType = modp.wType;
@@ -570,18 +929,18 @@
/**************************************************************************
* MCI_FinishOpen [internal]
*/
-static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
+static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSW lpParms,
DWORD dwParam)
{
if (dwParam & MCI_OPEN_ELEMENT)
{
- wmd->lpstrElementName = HeapAlloc(GetProcessHeap(),0,strlen(lpParms->lpstrElementName)+1);
- strcpy( wmd->lpstrElementName, lpParms->lpstrElementName );
+ wmd->lpstrElementName = HeapAlloc(GetProcessHeap(),0,(strlenW(lpParms->lpstrElementName)+1) * sizeof(WCHAR));
+ strcpyW( wmd->lpstrElementName, lpParms->lpstrElementName );
}
if (dwParam & MCI_OPEN_ALIAS)
{
- wmd->lpstrAlias = HeapAlloc(GetProcessHeap(), 0, strlen(lpParms->lpstrAlias)+1);
- strcpy( wmd->lpstrAlias, lpParms->lpstrAlias);
+ wmd->lpstrAlias = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpParms->lpstrAlias)+1) * sizeof(WCHAR));
+ strcpyW( wmd->lpstrAlias, lpParms->lpstrAlias);
}
lpParms->wDeviceID = wmd->wDeviceID;
@@ -592,7 +951,7 @@
/**************************************************************************
* MCI_FindCommand [internal]
*/
-static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb)
+static LPCWSTR MCI_FindCommand(UINT uTbl, LPCWSTR verb)
{
UINT idx;
@@ -604,7 +963,7 @@
* array look up
*/
for (idx = 0; idx < S_MciCmdTable[uTbl].nVerbs; idx++) {
- if (strcasecmp(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0)
+ if (strcmpiW(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0)
return S_MciCmdTable[uTbl].aVerbs[idx];
}
@@ -614,9 +973,9 @@
/**************************************************************************
* MCI_GetReturnType [internal]
*/
-static DWORD MCI_GetReturnType(LPCSTR lpCmd)
+static DWORD MCI_GetReturnType(LPCWSTR lpCmd)
{
- lpCmd += strlen(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD);
+ lpCmd += strlenW(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD);
if (*lpCmd == '\0' && *(const WORD*)(lpCmd + 1 + sizeof(DWORD)) == MCI_RETURN) {
return *(const DWORD*)(lpCmd + 1);
}
@@ -626,20 +985,20 @@
/**************************************************************************
* MCI_GetMessage [internal]
*/
-static WORD MCI_GetMessage(LPCSTR lpCmd)
+static WORD MCI_GetMessage(LPCWSTR lpCmd)
{
- return (WORD)*(const DWORD*)(lpCmd + strlen(lpCmd) + 1);
+ return (WORD)*(const DWORD*)(lpCmd + strlenW(lpCmd) + 1);
}
/**************************************************************************
* MCI_GetDWord [internal]
*/
-static BOOL MCI_GetDWord(LPDWORD data, LPSTR* ptr)
+static BOOL MCI_GetDWord(LPDWORD data, LPWSTR* ptr)
{
DWORD val;
- LPSTR ret;
+ LPWSTR ret;
- val = strtoul(*ptr, &ret, 0);
+ val = strtoulW(*ptr, &ret, 0);
switch (*ret) {
case '\0': break;
@@ -655,13 +1014,13 @@
/**************************************************************************
* MCI_GetString [internal]
*/
-static DWORD MCI_GetString(LPSTR* str, LPSTR* args)
+static DWORD MCI_GetString(LPWSTR* str, LPWSTR* args)
{
- LPSTR ptr = *args;
+ LPWSTR ptr = *args;
/* see if we have a quoted string */
if (*ptr == '"') {
- ptr = strchr(*str = ptr + 1, '"');
+ ptr = strchrW(*str = ptr + 1, '"');
if (!ptr) return MCIERR_NO_CLOSING_QUOTE;
/* FIXME: shall we escape \" from string ?? */
if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
@@ -669,12 +1028,12 @@
if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS;
*ptr++ = '\0';
} else {
- ptr = strchr(ptr, ' ');
+ ptr = strchrW(ptr, ' ');
if (ptr) {
*ptr++ = '\0';
} else {
- ptr = *args + strlen(*args);
+ ptr = *args + strlenW(*args);
}
*str = *args;
}
@@ -688,32 +1047,33 @@
/**************************************************************************
* MCI_ParseOptArgs [internal]
*/
-static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd,
- LPSTR args, LPDWORD dwFlags)
+static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCWSTR lpCmd,
+ LPWSTR args, LPDWORD dwFlags)
{
int len, offset;
- LPCSTR lmem, str;
+ const char* lmem;
+ LPCWSTR str;
DWORD dwRet, flg, cflg = 0;
WORD eid;
BOOL inCst, found;
/* loop on arguments */
while (*args) {
- lmem = lpCmd;
+ lmem = (const char*)lpCmd;
found = inCst = FALSE;
offset = _offset;
/* skip any leading white space(s) */
while (*args == ' ') args++;
- TRACE("args='%s' offset=%d\n", args, offset);
+ TRACE("args=%s offset=%d\n", debugstr_w(args), offset);
do { /* loop on options for command table for the requested verb */
- str = lmem;
- lmem += (len = strlen(lmem)) + 1;
+ str = (LPCWSTR)lmem;
+ lmem += ((len = strlenW(str)) + 1) * sizeof(WCHAR);
flg = *(const DWORD*)lmem;
eid = *(const WORD*)(lmem + sizeof(DWORD));
lmem += sizeof(DWORD) + sizeof(WORD);
-/* EPP TRACE("\tcmd='%s' inCst=%c eid=%04x\n", str, inCst ? 'Y' : 'N', eid); */
+ /* TRACE("\tcmd=%s inCst=%c eid=%04x\n", debugstr_w(str), inCst ? 'Y' : 'N', eid); */
switch (eid) {
case MCI_CONSTANT:
@@ -727,7 +1087,7 @@
break;
}
- if (strncasecmp(args, str, len) == 0 &&
+ if (strncmpiW(args, str, len) == 0 &&
(args[len] == 0 || args[len] == ' ')) {
/* store good values into data[] */
args += len;
@@ -764,13 +1124,13 @@
!MCI_GetDWord(&(data[offset+1]), &args) ||
!MCI_GetDWord(&(data[offset+2]), &args) ||
!MCI_GetDWord(&(data[offset+3]), &args)) {
- ERR("Bad rect '%s'\n", args);
+ ERR("Bad rect %s\n", debugstr_w(args));
return MCIERR_BAD_INTEGER;
}
break;
case MCI_STRING:
*dwFlags |= flg;
- if ((dwRet = MCI_GetString((LPSTR*)&data[offset], &args)))
+ if ((dwRet = MCI_GetString((LPWSTR*)&data[offset], &args)))
return dwRet;
break;
default: ERR("oops\n");
@@ -795,7 +1155,7 @@
}
} while (eid != MCI_END_COMMAND);
if (!found) {
- WARN("Optarg '%s' not found\n", args);
+ WARN("Optarg %s not found\n", debugstr_w(args));
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (offset == MCI_DATA_SIZE) {
@@ -810,8 +1170,13 @@
* MCI_HandleReturnValues [internal]
*/
static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType,
- LPDWORD data, LPSTR lpstrRet, UINT uRetLen)
+ LPDWORD data, LPWSTR lpstrRet, UINT uRetLen)
{
+ static const WCHAR wszLd [] = {'%','l','d',0};
+ static const WCHAR wszLd4 [] = {'%','l','d',' ','%','l','d',' ','%','l','d',' ','%','l','d',0};
+ static const WCHAR wszCol3[] = {'%','d',':','%','d',':','%','d',0};
+ static const WCHAR wszCol4[] = {'%','d',':','%','d',':','%','d',':','%','d',0};
+
if (lpstrRet) {
switch (retType) {
case 0: /* nothing to return */
@@ -820,30 +1185,30 @@
switch (dwRet & 0xFFFF0000ul) {
case 0:
case MCI_INTEGER_RETURNED:
- snprintf(lpstrRet, uRetLen, "%ld", data[1]);
+ snprintfW(lpstrRet, uRetLen, wszLd, data[1]);
break;
case MCI_RESOURCE_RETURNED:
/* return string which ID is HIWORD(data[1]),
* string is loaded from mmsystem.dll */
- LoadStringA(WINMM_IData->hWinMM32Instance, HIWORD(data[1]),
+ LoadStringW(WINMM_IData->hWinMM32Instance, HIWORD(data[1]),
lpstrRet, uRetLen);
break;
case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
/* return string which ID is HIWORD(data[1]),
* string is loaded from driver */
/* FIXME: this is wrong for a 16 bit handle */
- LoadStringA(GetDriverModuleHandle(wmd->hDriver),
+ LoadStringW(GetDriverModuleHandle(wmd->hDriver),
HIWORD(data[1]), lpstrRet, uRetLen);
break;
case MCI_COLONIZED3_RETURN:
- snprintf(lpstrRet, uRetLen, "%d:%d:%d",
- LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
- LOBYTE(HIWORD(data[1])));
+ snprintfW(lpstrRet, uRetLen, wszCol3,
+ LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
+ LOBYTE(HIWORD(data[1])));
break;
case MCI_COLONIZED4_RETURN:
- snprintf(lpstrRet, uRetLen, "%d:%d:%d:%d",
- LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
- LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1])));
+ snprintfW(lpstrRet, uRetLen, wszCol4,
+ LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
+ LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1])));
break;
default: ERR("Ooops (%04X)\n", HIWORD(dwRet));
}
@@ -855,7 +1220,7 @@
break;
case MCI_INTEGER_RETURNED:
data[1] = *(LPDWORD)lpstrRet;
- snprintf(lpstrRet, uRetLen, "%ld", data[1]);
+ snprintfW(lpstrRet, uRetLen, wszLd, data[1]);
break;
default:
WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
@@ -865,8 +1230,8 @@
case MCI_RECT:
if (dwRet & 0xFFFF0000ul)
WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
- snprintf(lpstrRet, uRetLen, "%ld %ld %ld %ld",
- data[1], data[2], data[3], data[4]);
+ snprintfW(lpstrRet, uRetLen, wszLd4,
+ data[1], data[2], data[3], data[4]);
break;
default: ERR("oops\n");
}
@@ -875,32 +1240,35 @@
}
/**************************************************************************
- * mciSendStringA [WINMM.@]
+ * mciSendStringW [WINMM.@]
*/
-DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
+DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
UINT uRetLen, HWND hwndCallback)
{
- LPSTR verb, dev, args;
+ LPWSTR verb, dev, args;
LPWINE_MCIDRIVER wmd = 0;
DWORD dwFlags = 0, dwRet = 0;
int offset = 0;
DWORD data[MCI_DATA_SIZE];
DWORD retType;
- LPCSTR lpCmd = 0;
- LPSTR devAlias = NULL;
+ LPCWSTR lpCmd = 0;
+ LPWSTR devAlias = NULL;
BOOL bAutoOpen = FALSE;
+ static const WCHAR wszNew[] = {'n','e','w',0};
+ static const WCHAR wszSAliasS[] = {' ','a','l','i','a','s',' ',0};
- TRACE("('%s', %p, %d, %p)\n", lpstrCommand, lpstrRet, uRetLen, hwndCallback);
+ TRACE("(%s, %p, %d, %p)\n",
+ debugstr_w(lpstrCommand), lpstrRet, uRetLen, hwndCallback);
/* format is <command> <device> <optargs> */
- if (!(verb = HeapAlloc(GetProcessHeap(), 0, strlen(lpstrCommand)+1)))
+ if (!(verb = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpstrCommand)+1) * sizeof(WCHAR))))
return MCIERR_OUT_OF_MEMORY;
- strcpy( verb, lpstrCommand );
- CharLowerA(verb);
+ strcpyW( verb, lpstrCommand );
+ CharLowerW(verb);
memset(data, 0, sizeof(data));
- if (!(args = strchr(verb, ' '))) {
+ if (!(args = strchrW(verb, ' '))) {
dwRet = MCIERR_MISSING_DEVICE_NAME;
goto errCleanUp;
}
@@ -910,17 +1278,17 @@
}
/* case dev == 'new' has to be handled */
- if (!strcmp(dev, "new")) {
+ if (!strcmpW(dev, wszNew)) {
FIXME("'new': NIY as device name\n");
dwRet = MCIERR_MISSING_DEVICE_NAME;
goto errCleanUp;
}
/* otherwise, try to grab devType from open */
- if (!strcmp(verb, "open")) {
- LPSTR devType, tmp;
+ if (!strcmpW(verb, wszOpen)) {
+ LPWSTR devType, tmp;
- if ((devType = strchr(dev, '!')) != NULL) {
+ if ((devType = strchrW(dev, '!')) != NULL) {
*devType++ = '\0';
tmp = devType; devType = dev; dev = tmp;
@@ -929,23 +1297,24 @@
devType = str_dup_upper(devType);
dwFlags |= MCI_OPEN_ELEMENT;
data[3] = (DWORD)dev;
- } else if (strchr(dev, '.') == NULL) {
- tmp = strchr(dev,' ');
+ } else if (strchrW(dev, '.') == NULL) {
+ tmp = strchrW(dev,' ');
if (tmp) *tmp = '\0';
data[2] = (DWORD)dev;
devType = str_dup_upper(dev);
if (tmp) *tmp = ' ';
dwFlags |= MCI_OPEN_TYPE;
} else {
- if ((devType = strstr(args, "type ")) != NULL) {
+ static const WCHAR wszTypeS[] = {'t','y','p','e',' ',0};
+ if ((devType = strstrW(args, wszTypeS)) != NULL) {
devType += 5;
- tmp = strchr(devType, ' ');
+ tmp = strchrW(devType, ' ');
if (tmp) *tmp = '\0';
devType = str_dup_upper(devType);
if (tmp) *tmp = ' ';
/* dwFlags and data[2] will be correctly set in ParseOpt loop */
} else {
- char buf[32];
+ WCHAR buf[32];
if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf))))
goto errCleanUp;
@@ -954,13 +1323,13 @@
dwFlags |= MCI_OPEN_ELEMENT;
data[3] = (DWORD)dev;
}
- if ((devAlias = strstr(args," alias "))) {
- char *tmp2;
+ if ((devAlias = strstrW(args, wszSAliasS))) {
+ WCHAR* tmp2;
devAlias += 7;
- if (!(tmp = strchr(devAlias,' '))) tmp = devAlias + strlen(devAlias);
+ if (!(tmp = strchrW(devAlias,' '))) tmp = devAlias + strlenW(devAlias);
if (tmp) *tmp = '\0';
- tmp2 = HeapAlloc(GetProcessHeap(), 0, tmp - devAlias + 1 );
- memcpy( tmp2, devAlias, tmp - devAlias );
+ tmp2 = HeapAlloc(GetProcessHeap(), 0, (tmp - devAlias + 1) * sizeof(WCHAR) );
+ memcpy( tmp2, devAlias, (tmp - devAlias) * sizeof(WCHAR) );
tmp2[tmp - devAlias] = 0;
data[4] = (DWORD)tmp2;
/* should be done in regular options parsing */
@@ -975,15 +1344,16 @@
MCI_UnLoadMciDriver(wmd);
goto errCleanUp;
}
- } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDA(dev)))) {
+ } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDW(dev)))) {
/* auto open */
- char buf[128];
- sprintf(buf, "open %s wait", dev);
+ static WCHAR wszOpenWait[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0};
+ WCHAR buf[128];
+ sprintfW(buf, wszOpenWait, dev);
- if ((dwRet = mciSendStringA(buf, NULL, 0, 0)) != 0)
+ if ((dwRet = mciSendStringW(buf, NULL, 0, 0)) != 0)
goto errCleanUp;
- wmd = MCI_GetDriver(mciGetDeviceIDA(dev));
+ wmd = MCI_GetDriver(mciGetDeviceIDW(dev));
if (!wmd) {
/* FIXME: memory leak, MCI driver is not closed */
dwRet = MCIERR_INVALID_DEVICE_ID;
@@ -1007,7 +1377,7 @@
if (!lpCmd) lpCmd = MCI_FindCommand(MCI_GetCommandTable(0), verb);
if (!lpCmd) {
- TRACE("Command '%s' not found!\n", verb);
+ TRACE("Command %s not found!\n", debugstr_w(verb));
dwRet = MCIERR_UNRECOGNIZED_COMMAND;
goto errCleanUp;
}
@@ -1027,7 +1397,8 @@
default: ERR("oops\n");
}
- TRACE("verb='%s' on dev='%s'; offset=%d\n", verb, dev, offset);
+ TRACE("verb=%s on dev=%s; offset=%d\n",
+ debugstr_w(verb), debugstr_w(dev), offset);
if ((dwRet = MCI_ParseOptArgs(data, offset, lpCmd, args, &dwFlags)))
goto errCleanUp;
@@ -1043,20 +1414,20 @@
TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n",
wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags,
- data[0], debugstr_a((char *)data[0]), data[1], debugstr_a((char *)data[1]),
- data[2], debugstr_a((char *)data[2]), data[3], debugstr_a((char *)data[3]),
- data[4], debugstr_a((char *)data[4]), data[5], debugstr_a((char *)data[5]));
+ data[0], debugstr_w((WCHAR *)data[0]), data[1], debugstr_w((WCHAR *)data[1]),
+ data[2], debugstr_w((WCHAR *)data[2]), data[3], debugstr_w((WCHAR *)data[3]),
+ data[4], debugstr_w((WCHAR *)data[4]), data[5], debugstr_w((WCHAR *)data[5]));
- if (strcmp(verb, "open") == 0) {
- if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSA)data, dwFlags)))
+ if (strcmpW(verb, wszOpen) == 0) {
+ if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSW)data, dwFlags)))
MCI_UnLoadMciDriver(wmd);
/* FIXME: notification is not properly shared across two opens */
} else {
dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE);
}
- TRACE("=> 1/ %lx (%s)\n", dwRet, lpstrRet);
+ TRACE("=> 1/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet));
dwRet = MCI_HandleReturnValues(dwRet, wmd, retType, data, lpstrRet, uRetLen);
- TRACE("=> 2/ %lx (%s)\n", dwRet, lpstrRet);
+ TRACE("=> 2/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet));
errCleanUp:
HeapFree(GetProcessHeap(), 0, verb);
@@ -1065,30 +1436,30 @@
}
/**************************************************************************
- * mciSendStringW [WINMM.@]
+ * mciSendStringA [WINMM.@]
*/
-DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPWSTR lpwstrRet,
+DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
UINT uRetLen, HWND hwndCallback)
{
- LPSTR lpstrCommand;
- LPSTR lpstrRet = NULL;
+ LPWSTR lpwstrCommand;
+ LPWSTR lpwstrRet = NULL;
UINT ret;
INT len;
/* FIXME: is there something to do with lpstrReturnString ? */
- len = WideCharToMultiByte( CP_ACP, 0, lpwstrCommand, -1, NULL, 0, NULL, NULL );
- lpstrCommand = HeapAlloc( GetProcessHeap(), 0, len );
- WideCharToMultiByte( CP_ACP, 0, lpwstrCommand, -1, lpstrCommand, len, NULL, NULL );
- if (lpwstrRet)
+ len = MultiByteToWideChar( CP_ACP, 0, lpstrCommand, -1, NULL, 0 );
+ lpwstrCommand = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, lpstrCommand, -1, lpwstrCommand, len );
+ if (lpstrRet)
{
- lpstrRet = HeapAlloc(GetProcessHeap(), 0, uRetLen * sizeof(WCHAR));
- if (!lpstrRet) return MMSYSERR_NOMEM;
+ lpwstrRet = HeapAlloc(GetProcessHeap(), 0, uRetLen * sizeof(WCHAR));
+ if (!lpwstrRet) return MCIERR_OUT_OF_MEMORY;
}
- ret = mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
+ ret = mciSendStringW(lpwstrCommand, lpwstrRet, uRetLen, hwndCallback);
if (lpwstrRet)
- MultiByteToWideChar( CP_ACP, 0, lpstrRet, -1, lpwstrRet, uRetLen );
- HeapFree(GetProcessHeap(), 0, lpstrCommand);
- HeapFree(GetProcessHeap(), 0, lpstrRet);
+ WideCharToMultiByte( CP_ACP, 0, lpwstrRet, -1, lpstrRet, uRetLen, NULL, NULL );
+ HeapFree(GetProcessHeap(), 0, lpwstrCommand);
+ HeapFree(GetProcessHeap(), 0, lpwstrRet);
return ret;
}
@@ -1096,7 +1467,7 @@
* mciExecute [WINMM.@]
* mciExecute [MMSYSTEM.712]
*/
-DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
+BOOL WINAPI mciExecute(LPCSTR lpstrCommand)
{
char strRet[256];
DWORD ret;
@@ -1111,7 +1482,7 @@
MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
}
/* FIXME: what shall I return ? */
- return 0;
+ return TRUE;
}
/**************************************************************************
@@ -1134,7 +1505,7 @@
if (!type) {
#if 0
/* FIXME: we should put this back into order, but I never found a program
- * actually using this feature, so we not need it
+ * actually using this feature, so we may not need it
*/
char buf[128];
OFSTRUCT ofs;
@@ -1163,7 +1534,7 @@
{
TRACE("(%08x)!\n", uTable);
- return MCI_DeleteCommandTable(uTable);
+ return MCI_DeleteCommandTable(uTable, FALSE);
}
/**************************************************************************
@@ -1177,10 +1548,10 @@
if (wmd) {
if (wmd->bIs32) {
dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
- } else if (pFnMciMapMsg32ATo16) {
+ } else if (pFnMciMapMsg32WTo16) {
WINMM_MapType res;
- switch (res = pFnMciMapMsg32ATo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
+ switch (res = pFnMciMapMsg32WTo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
case WINMM_MAP_MSGERROR:
TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
dwRet = MCIERR_DRIVER_INTERNAL;
@@ -1193,7 +1564,7 @@
case WINMM_MAP_OKMEM:
dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
if (res == WINMM_MAP_OKMEM)
- pFnMciUnMapMsg32ATo16(wmd->wType, wMsg, dwParam1, dwParam2);
+ pFnMciUnMapMsg32WTo16(wmd->wType, wMsg, dwParam1, dwParam2);
break;
}
}
@@ -1212,10 +1583,10 @@
if (wmd) {
dwRet = MCIERR_INVALID_DEVICE_ID;
- if (wmd->bIs32 && pFnMciMapMsg16To32A) {
+ if (wmd->bIs32 && pFnMciMapMsg16To32W) {
WINMM_MapType res;
- switch (res = pFnMciMapMsg16To32A(wmd->wType, wMsg, &dwParam2)) {
+ switch (res = pFnMciMapMsg16To32W(wmd->wType, wMsg, &dwParam2)) {
case WINMM_MAP_MSGERROR:
TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
dwRet = MCIERR_DRIVER_INTERNAL;
@@ -1228,7 +1599,7 @@
case WINMM_MAP_OKMEM:
dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
if (res == WINMM_MAP_OKMEM)
- pFnMciUnMapMsg16To32A(wmd->wType, wMsg, dwParam2);
+ pFnMciUnMapMsg16To32W(wmd->wType, wMsg, dwParam2);
break;
}
} else {
@@ -1241,9 +1612,9 @@
/**************************************************************************
* MCI_Open [internal]
*/
-static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
+static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
{
- char strDevTyp[128];
+ WCHAR strDevTyp[128];
DWORD dwRet;
LPWINE_MCIDRIVER wmd = NULL;
@@ -1267,18 +1638,19 @@
if (uDevType < MCI_DEVTYPE_FIRST ||
uDevType > MCI_DEVTYPE_LAST ||
- !LoadStringA(WINMM_IData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) {
+ !LoadStringW(WINMM_IData->hWinMM32Instance, uDevType,
+ strDevTyp, sizeof(strDevTyp) / sizeof(WCHAR))) {
dwRet = MCIERR_BAD_INTEGER;
goto errCleanUp;
}
} else {
- LPSTR ptr;
+ LPWSTR ptr;
if (lpParms->lpstrDeviceType == NULL) {
dwRet = MCIERR_NULL_PARAMETER_BLOCK;
goto errCleanUp;
}
- strcpy(strDevTyp, lpParms->lpstrDeviceType);
- ptr = strchr(strDevTyp, '!');
+ strcpyW(strDevTyp, lpParms->lpstrDeviceType);
+ ptr = strchrW(strDevTyp, '!');
if (ptr) {
/* this behavior is not documented in windows. However, since, in
* some occasions, MCI_OPEN handling is translated by WinMM into
@@ -1286,7 +1658,8 @@
*/
if (dwParam & MCI_OPEN_ELEMENT) {
ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
- lpParms->lpstrElementName, strDevTyp);
+ debugstr_w(lpParms->lpstrElementName),
+ debugstr_w(strDevTyp));
dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
goto errCleanUp;
}
@@ -1297,11 +1670,11 @@
}
}
- TRACE("devType='%s' !\n", strDevTyp);
+ TRACE("devType=%s !\n", debugstr_w(strDevTyp));
}
if (dwParam & MCI_OPEN_ELEMENT) {
- TRACE("lpstrElementName='%s'\n", lpParms->lpstrElementName);
+ TRACE("lpstrElementName=%s\n", debugstr_w(lpParms->lpstrElementName));
if (dwParam & MCI_OPEN_ELEMENT_ID) {
FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
@@ -1318,12 +1691,13 @@
if (!strDevTyp[0] &&
MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
strDevTyp, sizeof(strDevTyp))) {
- if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
+ static const WCHAR wszCdAudio[] = {'C','D','A','U','D','I','O',0};
+ if (GetDriveTypeW(lpParms->lpstrElementName) != DRIVE_CDROM) {
dwRet = MCIERR_EXTENSION_NOT_FOUND;
goto errCleanUp;
}
/* FIXME: this will not work if several CDROM drives are installed on the machine */
- strcpy(strDevTyp, "CDAUDIO");
+ strcpyW(strDevTyp, wszCdAudio);
}
}
@@ -1334,7 +1708,7 @@
}
if (dwParam & MCI_OPEN_ALIAS) {
- TRACE("Alias='%s' !\n", lpParms->lpstrAlias);
+ TRACE("Alias=%s !\n", debugstr_w(lpParms->lpstrAlias));
if (!lpParms->lpstrAlias) {
dwRet = MCIERR_NULL_PARAMETER_BLOCK;
goto errCleanUp;
@@ -1411,16 +1785,17 @@
/**************************************************************************
* MCI_WriteString [internal]
*/
-DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
+DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr)
{
DWORD ret = 0;
if (lpSrcStr) {
- if (dstSize <= strlen(lpSrcStr)) {
- lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
+ dstSize /= sizeof(WCHAR);
+ if (dstSize <= strlenW(lpSrcStr)) {
+ lstrcpynW(lpDstStr, lpSrcStr, dstSize - 1);
ret = MCIERR_PARAM_OVERFLOW;
} else {
- strcpy(lpDstStr, lpSrcStr);
+ strcpyW(lpDstStr, lpSrcStr);
}
} else {
*lpDstStr = 0;
@@ -1431,10 +1806,10 @@
/**************************************************************************
* MCI_Sysinfo [internal]
*/
-static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
+static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParms)
{
DWORD ret = MCIERR_INVALID_DEVICE_ID, cnt = 0;
- CHAR buf[2048], *s = buf, *p;
+ WCHAR buf[2048], *s = buf, *p;
LPWINE_MCIDRIVER wmd;
HKEY hKey;
@@ -1455,13 +1830,13 @@
LeaveCriticalSection(&WINMM_IData->cs);
} else {
TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
- if (RegOpenKeyExA( HKEY_LOCAL_MACHINE, HKLM_MCI,
+ if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci,
0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
- RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
+ RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
RegCloseKey( hKey );
}
- if (GetPrivateProfileStringA("mci", 0, "", buf, sizeof(buf), "system.ini"))
- for(s = buf; *s; s += strlen(s) + 1) cnt++;
+ if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf), wszSystemIni))
+ for (s = buf; *s; s += strlenW(s) + 1) cnt++;
}
} else {
if (dwFlags & MCI_SYSINFO_OPEN) {
@@ -1490,7 +1865,7 @@
*lpParms->lpstrReturn = 0;
ret = MCIERR_INVALID_DEVICE_ID;
}
- TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
+ TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
break;
case MCI_SYSINFO_NAME:
TRACE("MCI_SYSINFO_NAME\n");
@@ -1498,22 +1873,23 @@
FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
ret = MCIERR_UNRECOGNIZED_COMMAND;
} else {
- DWORD lRet;
- s = 0;
- lRet = RegOpenKeyExA( HKEY_LOCAL_MACHINE, HKLM_MCI, 0, KEY_QUERY_VALUE, &hKey );
- if (lRet == ERROR_SUCCESS) {
- lRet = RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
- if (lRet == ERROR_SUCCESS && lpParms->dwNumber <= cnt) {
+ s = NULL;
+ if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0,
+ KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
+ if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt,
+ 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS &&
+ lpParms->dwNumber <= cnt) {
DWORD bufLen = sizeof(buf);
- lRet = RegEnumKeyExA(hKey, lpParms->dwNumber - 1, buf, &bufLen, 0, 0, 0, 0);
- if (lRet == ERROR_SUCCESS) s = buf;
+ if (RegEnumKeyExW(hKey, lpParms->dwNumber - 1,
+ buf, &bufLen, 0, 0, 0, 0) == ERROR_SUCCESS)
+ s = buf;
}
RegCloseKey( hKey );
}
if (!s) {
- if (GetPrivateProfileStringA("mci", 0, "", buf, sizeof(buf), "system.ini")) {
- for(p = buf; *p; p += strlen(p) + 1, cnt++) {
- TRACE("%ld: %s\n", cnt, p);
+ if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf), wszSystemIni)) {
+ for (p = buf; *p; p += strlenW(p) + 1, cnt++) {
+ TRACE("%ld: %s\n", cnt, debugstr_w(p));
if (cnt == lpParms->dwNumber - 1) {
s = p;
break;
@@ -1521,9 +1897,9 @@
}
}
}
- ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, s) : MCIERR_OUTOFRANGE;
+ ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize / sizeof(WCHAR), s) : MCIERR_OUTOFRANGE;
}
- TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
+ TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
break;
default:
TRACE("Unsupported flag value=%08lx\n", dwFlags);
@@ -1551,14 +1927,14 @@
/**************************************************************************
* MCI_Sound [internal]
*/
-static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMS lpParms)
+static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms)
{
DWORD dwRet = 0;
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (dwFlags & MCI_SOUND_NAME)
- dwRet = sndPlaySoundA(lpParms->lpstrSoundName, SND_SYNC) ? MMSYSERR_NOERROR : MMSYSERR_ERROR;
+ dwRet = sndPlaySoundW(lpParms->lpstrSoundName, SND_SYNC) ? MMSYSERR_NOERROR : MMSYSERR_ERROR;
else
dwRet = MMSYSERR_ERROR; /* what should be done ??? */
if (dwFlags & MCI_NOTIFY)
@@ -1579,13 +1955,13 @@
switch (wMsg) {
case MCI_OPEN:
if (bFrom32) {
- dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
- } else if (pFnMciMapMsg16To32A) {
- switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) {
+ dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
+ } else if (pFnMciMapMsg16To32W) {
+ switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) {
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
- dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
- pFnMciUnMapMsg16To32A(0, wMsg, dwParam2);
+ dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
+ pFnMciUnMapMsg16To32W(0, wMsg, dwParam2);
break;
default: break; /* so that gcc does not bark */
}
@@ -1594,12 +1970,12 @@
case MCI_CLOSE:
if (bFrom32) {
dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
- } else if (pFnMciMapMsg16To32A) {
- switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) {
+ } else if (pFnMciMapMsg16To32W) {
+ switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) {
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
- pFnMciUnMapMsg16To32A(0, wMsg, dwParam2);
+ pFnMciUnMapMsg16To32W(0, wMsg, dwParam2);
break;
default: break; /* so that gcc does not bark */
}
@@ -1607,13 +1983,13 @@
break;
case MCI_SYSINFO:
if (bFrom32) {
- dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
- } else if (pFnMciMapMsg16To32A) {
- switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) {
+ dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2);
+ } else if (pFnMciMapMsg16To32W) {
+ switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) {
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
- dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
- pFnMciUnMapMsg16To32A(0, wMsg, dwParam2);
+ dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2);
+ pFnMciUnMapMsg16To32W(0, wMsg, dwParam2);
break;
default: break; /* so that gcc does not bark */
}
@@ -1622,12 +1998,12 @@
case MCI_BREAK:
if (bFrom32) {
dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
- } else if (pFnMciMapMsg16To32A) {
- switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) {
+ } else if (pFnMciMapMsg16To32W) {
+ switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) {
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
- pFnMciUnMapMsg16To32A(0, wMsg, dwParam2);
+ pFnMciUnMapMsg16To32W(0, wMsg, dwParam2);
break;
default: break; /* so that gcc does not bark */
}
@@ -1635,13 +2011,13 @@
break;
case MCI_SOUND:
if (bFrom32) {
- dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMS)dwParam2);
- } else if (pFnMciMapMsg16To32A) {
- switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) {
+ dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2);
+ } else if (pFnMciMapMsg16To32W) {
+ switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) {
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
- dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMS)dwParam2);
- pFnMciUnMapMsg16To32A(0, wMsg, dwParam2);
+ dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2);
+ pFnMciUnMapMsg16To32W(0, wMsg, dwParam2);
break;
default: break; /* so that gcc does not bark */
}
@@ -1739,3 +2115,296 @@
}
return LOWORD(dwRet);
}
+
+/**************************************************************************
+ * mciGetErrorStringW [WINMM.@]
+ */
+BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
+{
+ BOOL ret = FALSE;
+
+ if (lpstrBuffer != NULL && uLength > 0 &&
+ wError >= MCIERR_BASE && wError <= MCIERR_CUSTOM_DRIVER_BASE) {
+
+ if (LoadStringW(WINMM_IData->hWinMM32Instance,
+ wError, lpstrBuffer, uLength) > 0) {
+ ret = TRUE;
+ }
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * mciGetErrorStringA [WINMM.@]
+ */
+BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
+{
+ BOOL ret = FALSE;
+
+ if (lpstrBuffer != NULL && uLength > 0 &&
+ dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) {
+
+ if (LoadStringA(WINMM_IData->hWinMM32Instance,
+ dwError, lpstrBuffer, uLength) > 0) {
+ ret = TRUE;
+ }
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * mciDriverNotify [WINMM.@]
+ */
+BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
+{
+ TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
+
+ return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
+}
+
+/**************************************************************************
+ * mciGetDriverData [WINMM.@]
+ */
+DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
+{
+ LPWINE_MCIDRIVER wmd;
+
+ TRACE("(%04x)\n", uDeviceID);
+
+ wmd = MCI_GetDriver(uDeviceID);
+
+ if (!wmd) {
+ WARN("Bad uDeviceID\n");
+ return 0L;
+ }
+
+ return wmd->dwPrivate;
+}
+
+/**************************************************************************
+ * mciSetDriverData [WINMM.@]
+ */
+BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data)
+{
+ LPWINE_MCIDRIVER wmd;
+
+ TRACE("(%04x, %08lx)\n", uDeviceID, data);
+
+ wmd = MCI_GetDriver(uDeviceID);
+
+ if (!wmd) {
+ WARN("Bad uDeviceID\n");
+ return FALSE;
+ }
+
+ wmd->dwPrivate = data;
+ return TRUE;
+}
+
+/**************************************************************************
+ * mciSendCommandW [WINMM.@]
+ *
+ */
+DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+ DWORD dwRet;
+
+ TRACE("(%08x, %s, %08lx, %08lx)\n",
+ wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
+
+ dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE);
+ dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2);
+ TRACE("=> %08lx\n", dwRet);
+ return dwRet;
+}
+
+/**************************************************************************
+ * mciSendCommandA [WINMM.@]
+ */
+DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+ DWORD ret;
+ int mapped;
+
+ TRACE("(%08x, %s, %08lx, %08lx)\n",
+ wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
+
+ mapped = MCI_MapMsgAtoW(wMsg, dwParam1, &dwParam2);
+ if (mapped == -1)
+ {
+ FIXME("message %04x mapping failed\n", wMsg);
+ return MMSYSERR_NOMEM;
+ }
+ ret = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
+ if (mapped)
+ MCI_UnmapMsgAtoW(wMsg, dwParam1, dwParam2, ret);
+ return ret;
+}
+
+/**************************************************************************
+ * mciGetDeviceIDA [WINMM.@]
+ */
+UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
+{
+ LPWSTR w = MCI_strdupAtoW(lpstrName);
+ UINT ret = MCIERR_OUT_OF_MEMORY;
+
+ if (w)
+ {
+ ret = mciGetDeviceIDW(w);
+ HeapFree(GetProcessHeap(), 0, w);
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * mciGetDeviceIDW [WINMM.@]
+ */
+UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
+{
+ return MCI_GetDriverFromString(lpwstrName);
+}
+
+/******************************************************************
+ * MyUserYield
+ *
+ * Internal wrapper to call USER.UserYield16 (in fact through a Wine only export from USER32).
+ */
+static void MyUserYield(void)
+{
+ HMODULE mod = GetModuleHandleA( "user32.dll" );
+ if (mod)
+ {
+ FARPROC proc = GetProcAddress( mod, "UserYield16" );
+ if (proc) proc();
+ }
+}
+
+/**************************************************************************
+ * MCI_DefYieldProc [internal]
+ */
+UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
+{
+ INT16 ret;
+
+ TRACE("(0x%04x, 0x%08lx)\n", wDevID, data);
+
+ if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
+ (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
+ MyUserYield();
+ ret = 0;
+ } else {
+ MSG msg;
+
+ msg.hwnd = HWND_32(HIWORD(data));
+ while (!PeekMessageW(&msg, msg.hwnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
+ ret = -1;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * mciSetYieldProc [WINMM.@]
+ */
+BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
+{
+ LPWINE_MCIDRIVER wmd;
+
+ TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
+
+ if (!(wmd = MCI_GetDriver(uDeviceID))) {
+ WARN("Bad uDeviceID\n");
+ return FALSE;
+ }
+
+ wmd->lpfnYieldProc = fpYieldProc;
+ wmd->dwYieldData = dwYieldData;
+ wmd->bIs32 = TRUE;
+
+ return TRUE;
+}
+
+/**************************************************************************
+ * mciGetDeviceIDFromElementIDA [WINMM.@]
+ */
+UINT WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType)
+{
+ LPWSTR w = MCI_strdupAtoW(lpstrType);
+ UINT ret = 0;
+
+ if (w)
+ {
+ ret = mciGetDeviceIDFromElementIDW(dwElementID, w);
+ HeapFree(GetProcessHeap(), 0, w);
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * mciGetDeviceIDFromElementIDW [WINMM.@]
+ */
+UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
+{
+ /* FIXME: that's rather strange, there is no
+ * mciGetDeviceIDFromElementID32A in winmm.spec
+ */
+ FIXME("(%lu, %s) stub\n", dwElementID, debugstr_w(lpstrType));
+ return 0;
+}
+
+/**************************************************************************
+ * mciGetYieldProc [WINMM.@]
+ */
+YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData)
+{
+ LPWINE_MCIDRIVER wmd;
+
+ TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
+
+ if (!(wmd = MCI_GetDriver(uDeviceID))) {
+ WARN("Bad uDeviceID\n");
+ return NULL;
+ }
+ if (!wmd->lpfnYieldProc) {
+ WARN("No proc set\n");
+ return NULL;
+ }
+ if (!wmd->bIs32) {
+ WARN("Proc is 32 bit\n");
+ return NULL;
+ }
+ return wmd->lpfnYieldProc;
+}
+
+/**************************************************************************
+ * mciGetCreatorTask [WINMM.@]
+ */
+HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
+{
+ LPWINE_MCIDRIVER wmd;
+ HTASK ret = 0;
+
+ if ((wmd = MCI_GetDriver(uDeviceID))) ret = (HTASK)wmd->CreatorThread;
+
+ TRACE("(%u) => %p\n", uDeviceID, ret);
+ return ret;
+}
+
+/**************************************************************************
+ * mciDriverYield [WINMM.@]
+ */
+UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
+{
+ LPWINE_MCIDRIVER wmd;
+ UINT ret = 0;
+
+ TRACE("(%04x)\n", uDeviceID);
+
+ if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || !wmd->bIs32) {
+ MyUserYield();
+ } else {
+ ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
+ }
+
+ return ret;
+}
diff --git a/dlls/winmm/mcianim/mcianim.c b/dlls/winmm/mcianim/mcianim.c
index b12cb9e..e10fc76 100644
--- a/dlls/winmm/mcianim/mcianim.c
+++ b/dlls/winmm/mcianim/mcianim.c
@@ -28,6 +28,7 @@
#include "wownt32.h"
#include "mmddk.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mcianim);
@@ -40,7 +41,7 @@
int nUseCount; /* Incremented for each shared open */
BOOL fShareable; /* TRUE if first open was shareable */
WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
- MCI_OPEN_PARMSA openParms;
+ MCI_OPEN_PARMSW openParms;
DWORD dwTimeFormat;
int mode;
UINT nCurTrack;
@@ -56,7 +57,7 @@
/**************************************************************************
* MCIANIM_drvOpen [internal]
*/
-static DWORD MCIANIM_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
+static DWORD MCIANIM_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
{
WINE_MCIANIM* wma;
@@ -105,7 +106,7 @@
/**************************************************************************
* MCIANIM_mciOpen [internal]
*/
-static DWORD MCIANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpOpenParms)
+static DWORD MCIANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSW lpOpenParms)
{
DWORD dwDeviceID;
WINE_MCIANIM* wma = (WINE_MCIANIM*)mciGetDriverData(wDevID);
@@ -136,8 +137,8 @@
/*TRACE("lpParms->wDevID=%04X\n", lpParms->wDeviceID);*/
if (dwFlags & MCI_OPEN_ELEMENT) {
- TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpOpenParms->lpstrElementName);
- if (lpOpenParms->lpstrElementName && strlen(lpOpenParms->lpstrElementName) > 0) {
+ TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
+ if (lpOpenParms->lpstrElementName && strlenW(lpOpenParms->lpstrElementName) > 0) {
}
FIXME("element is not opened\n");
}
@@ -343,11 +344,13 @@
/**************************************************************************
* MCIANIM_mciInfo [internal]
*/
-static DWORD MCIANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
+static DWORD MCIANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMSW lpParms)
{
WINE_MCIANIM* wma = MCIANIM_mciGetOpenDrv(wDevID);
- LPCSTR str = 0;
+ LPCWSTR str = 0;
DWORD ret = 0;
+ static const WCHAR wszAnimation[] = {'W','i','n','e','\'','s',' ','a','n','i','m','a','t','i','o','n',0};
+ static const WCHAR wszWindow [] = {'A','n','i','m','a','t','i','o','n',' ','W','i','n','d','o','w',0};
TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
@@ -360,26 +363,20 @@
TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
switch(dwFlags) {
- case MCI_INFO_PRODUCT:
- str = "Wine's animation";
- break;
- case MCI_INFO_FILE:
- str = wma->openParms.lpstrElementName;
- break;
- case MCI_ANIM_INFO_TEXT:
- str = "Animation Window";
- break;
+ case MCI_INFO_PRODUCT: str = wszAnimation; break;
+ case MCI_INFO_FILE: str = wma->openParms.lpstrElementName; break;
+ case MCI_ANIM_INFO_TEXT: str = wszWindow; break;
default:
WARN("Don't know this info command (%lu)\n", dwFlags);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (str) {
- if (lpParms->dwRetSize <= strlen(str)) {
- lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
+ if (lpParms->dwRetSize <= strlenW(str)) {
+ lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
ret = MCIERR_PARAM_OVERFLOW;
} else {
- strcpy(lpParms->lpstrReturn, str);
+ strcpyW(lpParms->lpstrReturn, str);
}
} else {
*lpParms->lpstrReturn = 0;
@@ -658,7 +655,7 @@
switch (wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
- case DRV_OPEN: return MCIANIM_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
+ case DRV_OPEN: return MCIANIM_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return MCIANIM_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
@@ -671,10 +668,10 @@
if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
switch (wMsg) {
- case MCI_OPEN_DRIVER: return MCIANIM_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
+ case MCI_OPEN_DRIVER: return MCIANIM_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
case MCI_CLOSE_DRIVER: return MCIANIM_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_GETDEVCAPS: return MCIANIM_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
- case MCI_INFO: return MCIANIM_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMSA)dwParam2);
+ case MCI_INFO: return MCIANIM_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMSW)dwParam2);
case MCI_STATUS: return MCIANIM_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_SET: return MCIANIM_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PLAY: return MCIANIM_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
diff --git a/dlls/winmm/mciavi/info.c b/dlls/winmm/mciavi/info.c
index 688d68f..69be75f 100644
--- a/dlls/winmm/mciavi/info.c
+++ b/dlls/winmm/mciavi/info.c
@@ -23,6 +23,7 @@
#include <string.h>
#include "private_mciavi.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
@@ -148,11 +149,12 @@
/***************************************************************************
* MCIAVI_mciInfo [internal]
*/
-DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSA lpParms)
+DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms)
{
- LPCSTR str = 0;
+ LPCWSTR str = 0;
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret = 0;
+ static const WCHAR wszAviPlayer[] = {'W','i','n','e','\'','s',' ','A','V','I',' ','p','l','a','y','e','r',0};
if (lpParms == NULL || lpParms->lpstrReturn == NULL)
return MCIERR_NULL_PARAMETER_BLOCK;
@@ -163,22 +165,18 @@
EnterCriticalSection(&wma->cs);
switch (dwFlags) {
- case MCI_INFO_PRODUCT:
- str = "Wine's AVI player";
- break;
- case MCI_INFO_FILE:
- str = wma->lpFileName;
- break;
+ case MCI_INFO_PRODUCT: str = wszAviPlayer; break;
+ case MCI_INFO_FILE: str = wma->lpFileName; break;
default:
WARN("Don't know this info command (%lu)\n", dwFlags);
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (str) {
- if (strlen(str) + 1 > lpParms->dwRetSize) {
+ if (strlenW(str) + 1 > lpParms->dwRetSize) {
ret = MCIERR_PARAM_OVERFLOW;
} else {
- lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize);
+ lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize);
}
} else {
lpParms->lpstrReturn[0] = 0;
@@ -325,7 +323,7 @@
/***************************************************************************
* MCIAVI_mciStatus [internal]
*/
-DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSA lpParms)
+DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret = 0;
diff --git a/dlls/winmm/mciavi/mciavi.c b/dlls/winmm/mciavi/mciavi.c
index 88d4778..6eb844c 100644
--- a/dlls/winmm/mciavi/mciavi.c
+++ b/dlls/winmm/mciavi/mciavi.c
@@ -1,4 +1,4 @@
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
/*
* Digital video MCI Wine Driver
@@ -40,6 +40,7 @@
#include <string.h>
#include "private_mciavi.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
@@ -135,12 +136,12 @@
/**************************************************************************
* MCIAVI_drvOpen [internal]
*/
-static DWORD MCIAVI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
+static DWORD MCIAVI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
{
WINE_MCIAVI* wma;
static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
- TRACE("%s, %p\n", debugstr_a(str), modp);
+ TRACE("%s, %p\n", debugstr_w(str), modp);
/* session instance */
if (!modp) return 0xFFFFFFFF;
@@ -274,7 +275,7 @@
* MCIAVI_mciOpen [internal]
*/
static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
- LPMCI_DGV_OPEN_PARMSA lpOpenParms)
+ LPMCI_DGV_OPEN_PARMSW lpOpenParms)
{
WINE_MCIAVI *wma;
LRESULT dwRet = 0;
@@ -314,20 +315,20 @@
* contains the hFile value ?
*/
dwRet = MCIERR_UNRECOGNIZED_COMMAND;
- } else if (strlen(lpOpenParms->lpstrElementName) > 0) {
+ } else if (strlenW(lpOpenParms->lpstrElementName) > 0) {
/* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
- TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpOpenParms->lpstrElementName);
+ TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
- if (lpOpenParms->lpstrElementName && (strlen(lpOpenParms->lpstrElementName) > 0))
+ if (lpOpenParms->lpstrElementName && (strlenW(lpOpenParms->lpstrElementName) > 0))
{
- wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, strlen(lpOpenParms->lpstrElementName) + 1);
- strcpy(wma->lpFileName, lpOpenParms->lpstrElementName);
+ wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
+ strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
- wma->hFile = mmioOpenA(lpOpenParms->lpstrElementName, NULL,
+ wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
if (wma->hFile == 0) {
- WARN("can't find file='%s' !\n", lpOpenParms->lpstrElementName);
+ WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
dwRet = MCIERR_FILE_NOT_FOUND;
} else {
if (!MCIAVI_GetInfo(wma))
@@ -750,7 +751,7 @@
/*****************************************************************************
* MCIAVI_mciLoad [internal]
*/
-static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSA lpParms)
+static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -769,7 +770,7 @@
/******************************************************************************
* MCIAVI_mciSave [internal]
*/
-static DWORD MCIAVI_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSA lpParms)
+static DWORD MCIAVI_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -983,7 +984,7 @@
/******************************************************************************
* MCIAVI_mciCapture [internal]
*/
-static DWORD MCIAVI_mciCapture(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSA lpParms)
+static DWORD MCIAVI_mciCapture(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1021,7 +1022,7 @@
/******************************************************************************
* MCIAVI_mciReserve [internal]
*/
-static DWORD MCIAVI_mciReserve(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSA lpParms)
+static DWORD MCIAVI_mciReserve(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1040,7 +1041,7 @@
/******************************************************************************
* MCIAVI_mciSetAudio [internal]
*/
-static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSA lpParms)
+static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1078,7 +1079,7 @@
/******************************************************************************
* MCIAVI_mciSetVideo [internal]
*/
-static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSA lpParms)
+static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1097,7 +1098,7 @@
/******************************************************************************
* MCIAVI_mciQuality [internal]
*/
-static DWORD MCIAVI_mciQuality(UINT wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSA lpParms)
+static DWORD MCIAVI_mciQuality(UINT wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1116,7 +1117,7 @@
/******************************************************************************
* MCIAVI_mciList [internal]
*/
-static DWORD MCIAVI_mciList(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSA lpParms)
+static DWORD MCIAVI_mciList(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1173,7 +1174,7 @@
/******************************************************************************
* MCIAVI_mciRestore [internal]
*/
-static DWORD MCIAVI_mciRestore(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSA lpParms)
+static DWORD MCIAVI_mciRestore(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSW lpParms)
{
WINE_MCIAVI *wma;
@@ -1205,7 +1206,7 @@
switch (wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
- case DRV_OPEN: return MCIAVI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
+ case DRV_OPEN: return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return MCIAVI_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
@@ -1219,7 +1220,7 @@
if (dwDevID == 0xFFFFFFFF) return 1;
switch (wMsg) {
- case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSA) dwParam2);
+ case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
case MCI_RECORD: return MCIAVI_mciRecord (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS) dwParam2);
@@ -1227,14 +1228,14 @@
case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_RESUME: return MCIAVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
- case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSA) dwParam2);
+ case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
case MCI_GETDEVCAPS: return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
- case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSA) dwParam2);
+ case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW) dwParam2);
case MCI_SEEK: return MCIAVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
- case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSA) dwParam2);
- case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSA) dwParam2);
- case MCI_SAVE: return MCIAVI_mciSave (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSA) dwParam2);
+ case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW) dwParam2);
+ case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW) dwParam2);
+ case MCI_SAVE: return MCIAVI_mciSave (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSW) dwParam2);
case MCI_FREEZE: return MCIAVI_mciFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_UNFREEZE: return MCIAVI_mciUnFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
@@ -1247,17 +1248,17 @@
case MCI_PASTE: return MCIAVI_mciPaste (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS) dwParam2);
case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
/* Digital Video specific */
- case MCI_CAPTURE: return MCIAVI_mciCapture (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSA) dwParam2);
+ case MCI_CAPTURE: return MCIAVI_mciCapture (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSW) dwParam2);
case MCI_MONITOR: return MCIAVI_mciMonitor (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS) dwParam2);
- case MCI_RESERVE: return MCIAVI_mciReserve (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSA) dwParam2);
- case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSA) dwParam2);
+ case MCI_RESERVE: return MCIAVI_mciReserve (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSW) dwParam2);
+ case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
- case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSA) dwParam2);
- case MCI_QUALITY: return MCIAVI_mciQuality (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSA) dwParam2);
- case MCI_LIST: return MCIAVI_mciList (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSA) dwParam2);
+ case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
+ case MCI_QUALITY: return MCIAVI_mciQuality (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSW) dwParam2);
+ case MCI_LIST: return MCIAVI_mciList (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSW) dwParam2);
case MCI_UNDO: return MCIAVI_mciUndo (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
- case MCI_RESTORE: return MCIAVI_mciRestore (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSA) dwParam2);
+ case MCI_RESTORE: return MCIAVI_mciRestore (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSW) dwParam2);
case MCI_SPIN:
case MCI_ESCAPE:
diff --git a/dlls/winmm/mciavi/mciavi_res.rc b/dlls/winmm/mciavi/mciavi_res.rc
index 14fe2e0..a620d69 100644
--- a/dlls/winmm/mciavi/mciavi_res.rc
+++ b/dlls/winmm/mciavi/mciavi_res.rc
@@ -23,543 +23,543 @@
MCIAVI RCDATA
BEGIN
-"play\0", 0x00000806L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"repeat\0", 0x00010000L, MCI_FLAG,
-"reverse\0", 0x00020000L, MCI_FLAG,
-"window\0", 0x01000000L, MCI_FLAG,
-"fullscreen by 2\0", 0x04000000L, MCI_FLAG,
-"fullscreen\0", 0x02000000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"can record\0", 0x00000001L, MCI_INTEGER,
-"has audio\0", 0x00000002L, MCI_INTEGER,
-"has video\0", 0x00000003L, MCI_INTEGER,
-"uses files\0", 0x00000005L, MCI_INTEGER,
-"compound device\0", 0x00000006L, MCI_INTEGER,
-"device type\0", 0x00000004L, MCI_INTEGER,
-"can eject\0", 0x00000007L, MCI_INTEGER,
-"can play\0", 0x00000008L, MCI_INTEGER,
-"can save\0", 0x00000009L, MCI_INTEGER,
-"can lock\0", 0x00004000L, MCI_INTEGER,
-"can reverse\0", 0x00004004L, MCI_INTEGER,
-"can stretch input\0", 0x00004008L, MCI_INTEGER,
-"can stretch\0", 0x00004001L, MCI_INTEGER,
-"can test\0", 0x00004009L, MCI_INTEGER,
-"has still\0", 0x00004005L, MCI_INTEGER,
-"can freeze\0", 0x00004002L, MCI_INTEGER,
-"uses palettes\0", 0x00004006L, MCI_INTEGER,
-"windows\0", 0x00004003L, MCI_INTEGER,
-"maximum play rate\0", 0x0000400aL, MCI_INTEGER,
-"minimum play rate\0", 0x0000400bL, MCI_INTEGER,
-"can colorkey\0", 0x00004100L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capture\0", 0x00000870L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"as\0", 0x00010000L, MCI_STRING,
-"at\0", 0x00020000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"close\0", 0x00000804L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"configure\0", 0x0000087aL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"copy\0", 0x00000852L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"at\0", 0x00010000L, MCI_RECT,
-"audio stream\0", 0x00020000L, MCI_INTEGER,
-"video stream\0", 0x00040000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"cue\0", 0x00000830L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"input\0", 0x00010000L, MCI_FLAG,
-"output\0", 0x00020000L, MCI_FLAG,
-"to\0", 0x00000008L, MCI_INTEGER,
-"noshow\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"cut\0", 0x00000851L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"at\0", 0x00010000L, MCI_RECT,
-"audio stream\0", 0x00020000L, MCI_INTEGER,
-"video stream\0", 0x00040000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"delete\0", 0x00000856L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"at\0", 0x00010000L, MCI_RECT,
-"audio stream\0", 0x00020000L, MCI_INTEGER,
-"video stream\0", 0x00040000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"freeze\0", 0x00000844L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"outside\0", 0x00020000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"file\0", 0x00000200L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"window text\0", 0x00010000L, MCI_FLAG,
-"usage\0", 0x00004000L, MCI_FLAG,
-"version\0", 0x00000400L, MCI_FLAG,
-"\0", 0x00020000L, MCI_CONSTANT,
-"audio algorithm\0", 0x00004004L, MCI_INTEGER,
-"audio quality\0", 0x00004001L, MCI_INTEGER,
-"still algorithm\0", 0x00004005L, MCI_INTEGER,
-"still quality\0", 0x00004002L, MCI_INTEGER,
-"video algorithm\0", 0x00004006L, MCI_INTEGER,
-"video quality\0", 0x00004003L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"list\0", 0x00000878L, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"count\0", 0x00020000L, MCI_FLAG,
-"number\0", 0x00040000L, MCI_INTEGER,
-"\0", 0x00010000L, MCI_CONSTANT,
-"audio algorithm\0", 0x00004000L, MCI_INTEGER,
-"audio quality\0", 0x00004001L, MCI_INTEGER,
-"audio stream\0", 0x00004002L, MCI_INTEGER,
-"still algorithm\0", 0x00004003L, MCI_INTEGER,
-"still quality\0", 0x00004004L, MCI_INTEGER,
-"video algorithm\0", 0x00004005L, MCI_INTEGER,
-"video quality\0", 0x00004006L, MCI_INTEGER,
-"video source\0", 0x00004008L, MCI_INTEGER,
-"video stream\0", 0x00004007L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"algorithm\0", 0x00080000L, MCI_STRING,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"load\0", 0x00000850L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"monitor\0", 0x00000871L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00020000L, MCI_CONSTANT,
-"input\0", 0x00004000L, MCI_INTEGER,
-"file\0", 0x00004001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"method\0", 0x00010000L, MCI_CONSTANT,
-"pre\0", 0x0000a000L, MCI_INTEGER,
-"post\0", 0x0000a001L, MCI_INTEGER,
-"direct\0", 0x0000a002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"open\0", 0x00000803L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"type\0", 0x00002000L, MCI_STRING,
-"element\0", 0x00000200L, MCI_STRING,
-"alias\0", 0x00000400L, MCI_STRING,
-"shareable\0", 0x00000100L, MCI_FLAG,
-"style\0", 0x00010000L, MCI_CONSTANT,
-"overlapped\0", 0x00cf0000L, MCI_INTEGER,
-"popup\0", 0x80880000L, MCI_INTEGER,
-"child\0", 0x40000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"parent\0", 0x00020000L, MCI_INTEGER,
-"nostatic\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"paste\0", 0x00000853L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"to\0", 0x00000008L, MCI_INTEGER,
-"at\0", 0x00010000L, MCI_RECT,
-"insert\0", 0x00080000L, MCI_FLAG,
-"overwrite\0", 0x00100000L, MCI_FLAG,
-"audio stream\0", 0x00020000L, MCI_INTEGER,
-"video stream\0", 0x00040000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"pause\0", 0x00000809L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"put\0", 0x00000842L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"source\0", 0x00020000L, MCI_FLAG,
-"destination\0", 0x00040000L, MCI_FLAG,
-"frame\0", 0x00080000L, MCI_FLAG,
-"video\0", 0x00100000L, MCI_FLAG,
-"window\0", 0x00200000L, MCI_FLAG,
-"client\0", 0x00400000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"quality\0", 0x00000877L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00010000L, MCI_CONSTANT,
-"audio\0", 0x00004000L, MCI_INTEGER,
-"still\0", 0x00004001L, MCI_INTEGER,
-"video\0", 0x00004002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"name\0", 0x00020000L, MCI_STRING,
-"algorithm\0", 0x00040000L, MCI_STRING,
-"dialog\0", 0x00080000L, MCI_FLAG,
-"handle\0", 0x00100000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"realize\0", 0x00000840L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"normal\0", 0x00010000L, MCI_FLAG,
-"background\0", 0x00020000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"record\0", 0x0000080fL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"insert\0", 0x00000100L, MCI_FLAG,
-"overwrite\0", 0x00000200L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"hold\0", 0x00020000L, MCI_FLAG,
-"audio stream\0", 0x00040000L, MCI_INTEGER,
-"video stream\0", 0x00080000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"reserve\0", 0x00000872L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"in\0", 0x00010000L, MCI_STRING,
-"size\0", 0x00020000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"restore\0", 0x0000087bL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"from\0", 0x00010000L, MCI_STRING,
-"at\0", 0x00020000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"resume\0", 0x00000855L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"save\0", 0x00000813L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"at\0", 0x00010000L, MCI_RECT,
-"abort\0", 0x00020000L, MCI_FLAG,
-"keepreserve\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"to start\0", 0x00000100L, MCI_FLAG,
-"to end\0", 0x00000200L, MCI_FLAG,
-"to\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"frames\0", 0x00000003L, MCI_INTEGER,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"bytes\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"seek exactly\0", 0x00010000L, MCI_FLAG,
-"file format\0", 0x00080000L, MCI_CONSTANT,
-"avss\0", 0x00004000L, MCI_INTEGER,
-"avi\0", 0x00004001L, MCI_INTEGER,
-"dib\0", 0x00004002L, MCI_INTEGER,
-"rdib\0", 0x00004003L, MCI_INTEGER,
-"jpeg\0", 0x00004004L, MCI_INTEGER,
-"rjpeg\0", 0x00004005L, MCI_INTEGER,
-"jfif\0", 0x00004006L, MCI_INTEGER,
-"mpeg\0", 0x00004007L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"still\0", 0x00040000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"speed\0", 0x00020000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"setaudio\0", 0x00000873L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00800000L, MCI_CONSTANT,
-"bass\0", 0x00004001L, MCI_INTEGER,
-"treble\0", 0x00004000L, MCI_INTEGER,
-"volume\0", 0x00004002L, MCI_INTEGER,
-"stream\0", 0x00004003L, MCI_INTEGER,
-"source\0", 0x00004004L, MCI_INTEGER,
-"samplespersec\0", 0x00004005L, MCI_INTEGER,
-"bytespersec\0", 0x00004006L, MCI_INTEGER,
-"alignment\0", 0x00004007L, MCI_INTEGER,
-"bitspersample\0", 0x00004008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"to\0", 0x01000000L, MCI_CONSTANT,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"average\0", 0x00004000L, MCI_INTEGER,
-"stereo\0", 0x00000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"over\0", 0x00010000L, MCI_INTEGER,
-"algorithm\0", 0x00040000L, MCI_STRING,
-"quality\0", 0x00080000L, MCI_STRING,
-"record\0", 0x00100000L, MCI_FLAG,
-"left\0", 0x00200000L, MCI_FLAG,
-"clocktime\0", 0x00020000L, MCI_FLAG,
-"right\0", 0x00400000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"input\0", 0x02000000L, MCI_FLAG,
-"output\0", 0x04000000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"setvideo\0", 0x00000876L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00100000L, MCI_CONSTANT,
-"frame rate\0", 0x00004008L, MCI_INTEGER,
-"brightness\0", 0x00004000L, MCI_INTEGER,
-"color\0", 0x00004001L, MCI_INTEGER,
-"contrast\0", 0x00004002L, MCI_INTEGER,
-"tint\0", 0x00004003L, MCI_INTEGER,
-"sharpness\0", 0x00004004L, MCI_INTEGER,
-"gamma\0", 0x00004005L, MCI_INTEGER,
-"palette handle\0", 0x00004007L, MCI_INTEGER,
-"stream\0", 0x00004006L, MCI_INTEGER,
-"source\0", 0x00004009L, MCI_INTEGER,
-"key index\0", 0x0000400aL, MCI_INTEGER,
-"key color\0", 0x0000400bL, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"to\0", 0x01000000L, MCI_CONSTANT,
-"ntsc\0", 0x00004000L, MCI_INTEGER,
-"rgb\0", 0x00004001L, MCI_INTEGER,
-"svideo\0", 0x00004002L, MCI_INTEGER,
-"pal\0", 0x00004003L, MCI_INTEGER,
-"secam\0", 0x00004004L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"quality\0", 0x00010000L, MCI_STRING,
-"algorithm\0", 0x00020000L, MCI_STRING,
-"number\0", 0x00080000L, MCI_INTEGER,
-"over\0", 0x00200000L, MCI_INTEGER,
-"record\0", 0x00400000L, MCI_FLAG,
-"still\0", 0x00800000L, MCI_FLAG,
-"clocktime\0", 0x00040000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"input\0", 0x02000000L, MCI_FLAG,
-"output\0", 0x04000000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"signal\0", 0x00000875L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_INTEGER,
-"every\0", 0x00020000L, MCI_INTEGER,
-"uservalue\0", 0x00040000L, MCI_INTEGER,
-"cancel\0", 0x00080000L, MCI_FLAG,
-"return position\0", 0x00100000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"frames skipped\0", 0x00008001L, MCI_INTEGER,
-"play speed\0", 0x00008002L, MCI_INTEGER,
-"audio breaks\0", 0x00008003L, MCI_INTEGER,
-"alignment\0", 0x00004029L, MCI_INTEGER,
-"audio input\0", 0x00004000L, MCI_INTEGER,
-"audio record\0", 0x0000401aL, MCI_INTEGER,
-"audio source\0", 0x00004009L, MCI_INTEGER,
-"audio stream\0", 0x0000402dL, MCI_INTEGER,
-"bass\0", 0x0000400fL, MCI_INTEGER,
-"bitsperpel\0", 0x0000402bL, MCI_INTEGER,
-"bitspersample\0", 0x0000402aL, MCI_INTEGER,
-"brightness\0", 0x00004005L, MCI_INTEGER,
-"bytespersec\0", 0x00004028L, MCI_INTEGER,
-"color\0", 0x00004006L, MCI_INTEGER,
-"contrast\0", 0x00004007L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"file format\0", 0x00004008L, MCI_INTEGER,
-"still file format\0", 0x0000401dL, MCI_INTEGER,
-"file mode\0", 0x0000401fL, MCI_INTEGER,
-"file completion\0", 0x00004020L, MCI_INTEGER,
-"forward\0", 0x0000402cL, MCI_INTEGER,
-"gamma\0", 0x0000400aL, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"monitor method\0", 0x0000400cL, MCI_INTEGER,
-"monitor\0", 0x0000400bL, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"palette handle\0", 0x00004004L, MCI_INTEGER,
-"pause mode\0", 0x00004026L, MCI_INTEGER,
-"position\0", 0x00000002L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"frame rate\0", 0x0000400eL, MCI_INTEGER,
-"reserved size\0", 0x00004010L, MCI_INTEGER,
-"samplespersec\0", 0x00004027L, MCI_INTEGER,
-"seek exactly\0", 0x00004011L, MCI_INTEGER,
-"sharpness\0", 0x00004012L, MCI_INTEGER,
-"smpte\0", 0x00004013L, MCI_INTEGER,
-"speed\0", 0x00004003L, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"tint\0", 0x00004015L, MCI_INTEGER,
-"treble\0", 0x00004016L, MCI_INTEGER,
-"unsaved\0", 0x00004017L, MCI_INTEGER,
-"video key color\0", 0x00004025L, MCI_INTEGER,
-"video key index\0", 0x00004024L, MCI_INTEGER,
-"video source\0", 0x0000401bL, MCI_INTEGER,
-"video source number\0", 0x0000401eL, MCI_INTEGER,
-"video record\0", 0x0000401cL, MCI_INTEGER,
-"video stream\0", 0x0000402eL, MCI_INTEGER,
-"volume\0", 0x00004019L, MCI_INTEGER,
-"window handle\0", 0x00004001L, MCI_INTEGER,
-"window visible\0", 0x00004021L, MCI_INTEGER,
-"window minimized\0", 0x00004022L, MCI_INTEGER,
-"window maximized\0", 0x00004023L, MCI_INTEGER,
-"video streams\0", 0x00004100L, MCI_INTEGER,
-"video bitrate\0", 0x00004101L, MCI_INTEGER,
-"video maxbitrate\0", 0x00004102L, MCI_INTEGER,
-"audio streams\0", 0x00004103L, MCI_INTEGER,
-"audio bitrate\0", 0x00004104L, MCI_INTEGER,
-"video brush\0", 0x00004105L, MCI_INTEGER,
-"audio\0", 0x00004014L, MCI_INTEGER,
-"video\0", 0x00004018L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"left\0", 0x00080000L, MCI_FLAG,
-"right\0", 0x00100000L, MCI_FLAG,
-"nominal\0", 0x00020000L, MCI_FLAG,
-"record\0", 0x01000000L, MCI_FLAG,
-"input\0", 0x00400000L, MCI_FLAG,
-"output\0", 0x00800000L, MCI_FLAG,
-"disk space\0", 0x00200000L, MCI_STRING,
-"reference\0", 0x00040000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"reverse\0", 0x00010000L, MCI_FLAG,
-"by\0", 0x00020000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"stop\0", 0x00000808L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"hold\0", 0x00010000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"undo\0", 0x00000879L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"unfreeze\0", 0x00000845L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"update\0", 0x00000854L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"hdc\0", 0x00020000L, MCI_INTEGER,
-"paint\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"where\0", 0x00000843L, MCI_COMMAND_HEAD,
-"\0", 0x00000007L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"source\0", 0x00020000L, MCI_FLAG,
-"destination\0", 0x00040000L, MCI_FLAG,
-"frame\0", 0x00080000L, MCI_FLAG,
-"video\0", 0x00100000L, MCI_FLAG,
-"window\0", 0x00200000L, MCI_FLAG,
-"max\0", 0x00400000L, MCI_FLAG,
-"min\0", 0x00800000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"window\0", 0x00000841L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"test\0", 0x00000020L, MCI_FLAG,
-"handle\0", 0x00010000L, MCI_CONSTANT,
-"default\0", 0x00000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"state\0", 0x00040000L, MCI_CONSTANT,
-"hide\0", 0x00000000L, MCI_INTEGER,
-"minimize\0", 0x00000006L, MCI_INTEGER,
-"restore\0", 0x00000009L, MCI_INTEGER,
-"show maximized\0", 0x00000003L, MCI_INTEGER,
-"show min noactive\0", 0x00000007L, MCI_INTEGER,
-"show minimized\0", 0x00000002L, MCI_INTEGER,
-"show na\0", 0x00000008L, MCI_INTEGER,
-"show noactivate\0", 0x00000004L, MCI_INTEGER,
-"show normal\0", 0x00000001L, MCI_INTEGER,
-"show\0", 0x00000005L, MCI_INTEGER,
-"no action\0", 0x00000008L, MCI_INTEGER,
-"minimized\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"text\0", 0x00080000L, MCI_STRING,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"repeat\0", 0x00010000L, MCI_FLAG,
+L"reverse\0", 0x00020000L, MCI_FLAG,
+L"window\0", 0x01000000L, MCI_FLAG,
+L"fullscreen by 2\0", 0x04000000L, MCI_FLAG,
+L"fullscreen\0", 0x02000000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"can record\0", 0x00000001L, MCI_INTEGER,
+L"has audio\0", 0x00000002L, MCI_INTEGER,
+L"has video\0", 0x00000003L, MCI_INTEGER,
+L"uses files\0", 0x00000005L, MCI_INTEGER,
+L"compound device\0", 0x00000006L, MCI_INTEGER,
+L"device type\0", 0x00000004L, MCI_INTEGER,
+L"can eject\0", 0x00000007L, MCI_INTEGER,
+L"can play\0", 0x00000008L, MCI_INTEGER,
+L"can save\0", 0x00000009L, MCI_INTEGER,
+L"can lock\0", 0x00004000L, MCI_INTEGER,
+L"can reverse\0", 0x00004004L, MCI_INTEGER,
+L"can stretch input\0", 0x00004008L, MCI_INTEGER,
+L"can stretch\0", 0x00004001L, MCI_INTEGER,
+L"can test\0", 0x00004009L, MCI_INTEGER,
+L"has still\0", 0x00004005L, MCI_INTEGER,
+L"can freeze\0", 0x00004002L, MCI_INTEGER,
+L"uses palettes\0", 0x00004006L, MCI_INTEGER,
+L"windows\0", 0x00004003L, MCI_INTEGER,
+L"maximum play rate\0", 0x0000400aL, MCI_INTEGER,
+L"minimum play rate\0", 0x0000400bL, MCI_INTEGER,
+L"can colorkey\0", 0x00004100L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capture\0", 0x00000870L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"as\0", 0x00010000L, MCI_STRING,
+L"at\0", 0x00020000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"close\0", 0x00000804L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"configure\0", 0x0000087aL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"copy\0", 0x00000852L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"at\0", 0x00010000L, MCI_RECT,
+L"audio stream\0", 0x00020000L, MCI_INTEGER,
+L"video stream\0", 0x00040000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"cue\0", 0x00000830L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"input\0", 0x00010000L, MCI_FLAG,
+L"output\0", 0x00020000L, MCI_FLAG,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"noshow\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"cut\0", 0x00000851L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"at\0", 0x00010000L, MCI_RECT,
+L"audio stream\0", 0x00020000L, MCI_INTEGER,
+L"video stream\0", 0x00040000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"delete\0", 0x00000856L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"at\0", 0x00010000L, MCI_RECT,
+L"audio stream\0", 0x00020000L, MCI_INTEGER,
+L"video stream\0", 0x00040000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"freeze\0", 0x00000844L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"outside\0", 0x00020000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"file\0", 0x00000200L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"window text\0", 0x00010000L, MCI_FLAG,
+L"usage\0", 0x00004000L, MCI_FLAG,
+L"version\0", 0x00000400L, MCI_FLAG,
+L"\0", 0x00020000L, MCI_CONSTANT,
+L"audio algorithm\0", 0x00004004L, MCI_INTEGER,
+L"audio quality\0", 0x00004001L, MCI_INTEGER,
+L"still algorithm\0", 0x00004005L, MCI_INTEGER,
+L"still quality\0", 0x00004002L, MCI_INTEGER,
+L"video algorithm\0", 0x00004006L, MCI_INTEGER,
+L"video quality\0", 0x00004003L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"list\0", 0x00000878L, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"count\0", 0x00020000L, MCI_FLAG,
+L"number\0", 0x00040000L, MCI_INTEGER,
+L"\0", 0x00010000L, MCI_CONSTANT,
+L"audio algorithm\0", 0x00004000L, MCI_INTEGER,
+L"audio quality\0", 0x00004001L, MCI_INTEGER,
+L"audio stream\0", 0x00004002L, MCI_INTEGER,
+L"still algorithm\0", 0x00004003L, MCI_INTEGER,
+L"still quality\0", 0x00004004L, MCI_INTEGER,
+L"video algorithm\0", 0x00004005L, MCI_INTEGER,
+L"video quality\0", 0x00004006L, MCI_INTEGER,
+L"video source\0", 0x00004008L, MCI_INTEGER,
+L"video stream\0", 0x00004007L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"algorithm\0", 0x00080000L, MCI_STRING,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"load\0", 0x00000850L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"monitor\0", 0x00000871L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00020000L, MCI_CONSTANT,
+L"input\0", 0x00004000L, MCI_INTEGER,
+L"file\0", 0x00004001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"method\0", 0x00010000L, MCI_CONSTANT,
+L"pre\0", 0x0000a000L, MCI_INTEGER,
+L"post\0", 0x0000a001L, MCI_INTEGER,
+L"direct\0", 0x0000a002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"type\0", 0x00002000L, MCI_STRING,
+L"element\0", 0x00000200L, MCI_STRING,
+L"alias\0", 0x00000400L, MCI_STRING,
+L"shareable\0", 0x00000100L, MCI_FLAG,
+L"style\0", 0x00010000L, MCI_CONSTANT,
+L"overlapped\0", 0x00cf0000L, MCI_INTEGER,
+L"popup\0", 0x80880000L, MCI_INTEGER,
+L"child\0", 0x40000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"parent\0", 0x00020000L, MCI_INTEGER,
+L"nostatic\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"paste\0", 0x00000853L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"at\0", 0x00010000L, MCI_RECT,
+L"insert\0", 0x00080000L, MCI_FLAG,
+L"overwrite\0", 0x00100000L, MCI_FLAG,
+L"audio stream\0", 0x00020000L, MCI_INTEGER,
+L"video stream\0", 0x00040000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"pause\0", 0x00000809L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"put\0", 0x00000842L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"source\0", 0x00020000L, MCI_FLAG,
+L"destination\0", 0x00040000L, MCI_FLAG,
+L"frame\0", 0x00080000L, MCI_FLAG,
+L"video\0", 0x00100000L, MCI_FLAG,
+L"window\0", 0x00200000L, MCI_FLAG,
+L"client\0", 0x00400000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"quality\0", 0x00000877L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00010000L, MCI_CONSTANT,
+L"audio\0", 0x00004000L, MCI_INTEGER,
+L"still\0", 0x00004001L, MCI_INTEGER,
+L"video\0", 0x00004002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"name\0", 0x00020000L, MCI_STRING,
+L"algorithm\0", 0x00040000L, MCI_STRING,
+L"dialog\0", 0x00080000L, MCI_FLAG,
+L"handle\0", 0x00100000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"realize\0", 0x00000840L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"normal\0", 0x00010000L, MCI_FLAG,
+L"background\0", 0x00020000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"record\0", 0x0000080fL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"insert\0", 0x00000100L, MCI_FLAG,
+L"overwrite\0", 0x00000200L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"hold\0", 0x00020000L, MCI_FLAG,
+L"audio stream\0", 0x00040000L, MCI_INTEGER,
+L"video stream\0", 0x00080000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"reserve\0", 0x00000872L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"in\0", 0x00010000L, MCI_STRING,
+L"size\0", 0x00020000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"restore\0", 0x0000087bL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"from\0", 0x00010000L, MCI_STRING,
+L"at\0", 0x00020000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"resume\0", 0x00000855L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"save\0", 0x00000813L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"at\0", 0x00010000L, MCI_RECT,
+L"abort\0", 0x00020000L, MCI_FLAG,
+L"keepreserve\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"to start\0", 0x00000100L, MCI_FLAG,
+L"to end\0", 0x00000200L, MCI_FLAG,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"frames\0", 0x00000003L, MCI_INTEGER,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"bytes\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"seek exactly\0", 0x00010000L, MCI_FLAG,
+L"file format\0", 0x00080000L, MCI_CONSTANT,
+L"avss\0", 0x00004000L, MCI_INTEGER,
+L"avi\0", 0x00004001L, MCI_INTEGER,
+L"dib\0", 0x00004002L, MCI_INTEGER,
+L"rdib\0", 0x00004003L, MCI_INTEGER,
+L"jpeg\0", 0x00004004L, MCI_INTEGER,
+L"rjpeg\0", 0x00004005L, MCI_INTEGER,
+L"jfif\0", 0x00004006L, MCI_INTEGER,
+L"mpeg\0", 0x00004007L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"still\0", 0x00040000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"speed\0", 0x00020000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"setaudio\0", 0x00000873L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00800000L, MCI_CONSTANT,
+L"bass\0", 0x00004001L, MCI_INTEGER,
+L"treble\0", 0x00004000L, MCI_INTEGER,
+L"volume\0", 0x00004002L, MCI_INTEGER,
+L"stream\0", 0x00004003L, MCI_INTEGER,
+L"source\0", 0x00004004L, MCI_INTEGER,
+L"samplespersec\0", 0x00004005L, MCI_INTEGER,
+L"bytespersec\0", 0x00004006L, MCI_INTEGER,
+L"alignment\0", 0x00004007L, MCI_INTEGER,
+L"bitspersample\0", 0x00004008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"to\0", 0x01000000L, MCI_CONSTANT,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"average\0", 0x00004000L, MCI_INTEGER,
+L"stereo\0", 0x00000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"over\0", 0x00010000L, MCI_INTEGER,
+L"algorithm\0", 0x00040000L, MCI_STRING,
+L"quality\0", 0x00080000L, MCI_STRING,
+L"record\0", 0x00100000L, MCI_FLAG,
+L"left\0", 0x00200000L, MCI_FLAG,
+L"clocktime\0", 0x00020000L, MCI_FLAG,
+L"right\0", 0x00400000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"input\0", 0x02000000L, MCI_FLAG,
+L"output\0", 0x04000000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"setvideo\0", 0x00000876L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00100000L, MCI_CONSTANT,
+L"frame rate\0", 0x00004008L, MCI_INTEGER,
+L"brightness\0", 0x00004000L, MCI_INTEGER,
+L"color\0", 0x00004001L, MCI_INTEGER,
+L"contrast\0", 0x00004002L, MCI_INTEGER,
+L"tint\0", 0x00004003L, MCI_INTEGER,
+L"sharpness\0", 0x00004004L, MCI_INTEGER,
+L"gamma\0", 0x00004005L, MCI_INTEGER,
+L"palette handle\0", 0x00004007L, MCI_INTEGER,
+L"stream\0", 0x00004006L, MCI_INTEGER,
+L"source\0", 0x00004009L, MCI_INTEGER,
+L"key index\0", 0x0000400aL, MCI_INTEGER,
+L"key color\0", 0x0000400bL, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"to\0", 0x01000000L, MCI_CONSTANT,
+L"ntsc\0", 0x00004000L, MCI_INTEGER,
+L"rgb\0", 0x00004001L, MCI_INTEGER,
+L"svideo\0", 0x00004002L, MCI_INTEGER,
+L"pal\0", 0x00004003L, MCI_INTEGER,
+L"secam\0", 0x00004004L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"quality\0", 0x00010000L, MCI_STRING,
+L"algorithm\0", 0x00020000L, MCI_STRING,
+L"number\0", 0x00080000L, MCI_INTEGER,
+L"over\0", 0x00200000L, MCI_INTEGER,
+L"record\0", 0x00400000L, MCI_FLAG,
+L"still\0", 0x00800000L, MCI_FLAG,
+L"clocktime\0", 0x00040000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"input\0", 0x02000000L, MCI_FLAG,
+L"output\0", 0x04000000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"signal\0", 0x00000875L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_INTEGER,
+L"every\0", 0x00020000L, MCI_INTEGER,
+L"uservalue\0", 0x00040000L, MCI_INTEGER,
+L"cancel\0", 0x00080000L, MCI_FLAG,
+L"return position\0", 0x00100000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"frames skipped\0", 0x00008001L, MCI_INTEGER,
+L"play speed\0", 0x00008002L, MCI_INTEGER,
+L"audio breaks\0", 0x00008003L, MCI_INTEGER,
+L"alignment\0", 0x00004029L, MCI_INTEGER,
+L"audio input\0", 0x00004000L, MCI_INTEGER,
+L"audio record\0", 0x0000401aL, MCI_INTEGER,
+L"audio source\0", 0x00004009L, MCI_INTEGER,
+L"audio stream\0", 0x0000402dL, MCI_INTEGER,
+L"bass\0", 0x0000400fL, MCI_INTEGER,
+L"bitsperpel\0", 0x0000402bL, MCI_INTEGER,
+L"bitspersample\0", 0x0000402aL, MCI_INTEGER,
+L"brightness\0", 0x00004005L, MCI_INTEGER,
+L"bytespersec\0", 0x00004028L, MCI_INTEGER,
+L"color\0", 0x00004006L, MCI_INTEGER,
+L"contrast\0", 0x00004007L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"file format\0", 0x00004008L, MCI_INTEGER,
+L"still file format\0", 0x0000401dL, MCI_INTEGER,
+L"file mode\0", 0x0000401fL, MCI_INTEGER,
+L"file completion\0", 0x00004020L, MCI_INTEGER,
+L"forward\0", 0x0000402cL, MCI_INTEGER,
+L"gamma\0", 0x0000400aL, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"monitor method\0", 0x0000400cL, MCI_INTEGER,
+L"monitor\0", 0x0000400bL, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"palette handle\0", 0x00004004L, MCI_INTEGER,
+L"pause mode\0", 0x00004026L, MCI_INTEGER,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"frame rate\0", 0x0000400eL, MCI_INTEGER,
+L"reserved size\0", 0x00004010L, MCI_INTEGER,
+L"samplespersec\0", 0x00004027L, MCI_INTEGER,
+L"seek exactly\0", 0x00004011L, MCI_INTEGER,
+L"sharpness\0", 0x00004012L, MCI_INTEGER,
+L"smpte\0", 0x00004013L, MCI_INTEGER,
+L"speed\0", 0x00004003L, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"tint\0", 0x00004015L, MCI_INTEGER,
+L"treble\0", 0x00004016L, MCI_INTEGER,
+L"unsaved\0", 0x00004017L, MCI_INTEGER,
+L"video key color\0", 0x00004025L, MCI_INTEGER,
+L"video key index\0", 0x00004024L, MCI_INTEGER,
+L"video source\0", 0x0000401bL, MCI_INTEGER,
+L"video source number\0", 0x0000401eL, MCI_INTEGER,
+L"video record\0", 0x0000401cL, MCI_INTEGER,
+L"video stream\0", 0x0000402eL, MCI_INTEGER,
+L"volume\0", 0x00004019L, MCI_INTEGER,
+L"window handle\0", 0x00004001L, MCI_INTEGER,
+L"window visible\0", 0x00004021L, MCI_INTEGER,
+L"window minimized\0", 0x00004022L, MCI_INTEGER,
+L"window maximized\0", 0x00004023L, MCI_INTEGER,
+L"video streams\0", 0x00004100L, MCI_INTEGER,
+L"video bitrate\0", 0x00004101L, MCI_INTEGER,
+L"video maxbitrate\0", 0x00004102L, MCI_INTEGER,
+L"audio streams\0", 0x00004103L, MCI_INTEGER,
+L"audio bitrate\0", 0x00004104L, MCI_INTEGER,
+L"video brush\0", 0x00004105L, MCI_INTEGER,
+L"audio\0", 0x00004014L, MCI_INTEGER,
+L"video\0", 0x00004018L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"left\0", 0x00080000L, MCI_FLAG,
+L"right\0", 0x00100000L, MCI_FLAG,
+L"nominal\0", 0x00020000L, MCI_FLAG,
+L"record\0", 0x01000000L, MCI_FLAG,
+L"input\0", 0x00400000L, MCI_FLAG,
+L"output\0", 0x00800000L, MCI_FLAG,
+L"disk space\0", 0x00200000L, MCI_STRING,
+L"reference\0", 0x00040000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"reverse\0", 0x00010000L, MCI_FLAG,
+L"by\0", 0x00020000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"stop\0", 0x00000808L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"hold\0", 0x00010000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"undo\0", 0x00000879L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"unfreeze\0", 0x00000845L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"update\0", 0x00000854L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"hdc\0", 0x00020000L, MCI_INTEGER,
+L"paint\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"where\0", 0x00000843L, MCI_COMMAND_HEAD,
+L"\0", 0x00000007L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"source\0", 0x00020000L, MCI_FLAG,
+L"destination\0", 0x00040000L, MCI_FLAG,
+L"frame\0", 0x00080000L, MCI_FLAG,
+L"video\0", 0x00100000L, MCI_FLAG,
+L"window\0", 0x00200000L, MCI_FLAG,
+L"max\0", 0x00400000L, MCI_FLAG,
+L"min\0", 0x00800000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"window\0", 0x00000841L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"test\0", 0x00000020L, MCI_FLAG,
+L"handle\0", 0x00010000L, MCI_CONSTANT,
+L"default\0", 0x00000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"state\0", 0x00040000L, MCI_CONSTANT,
+L"hide\0", 0x00000000L, MCI_INTEGER,
+L"minimize\0", 0x00000006L, MCI_INTEGER,
+L"restore\0", 0x00000009L, MCI_INTEGER,
+L"show maximized\0", 0x00000003L, MCI_INTEGER,
+L"show min noactive\0", 0x00000007L, MCI_INTEGER,
+L"show minimized\0", 0x00000002L, MCI_INTEGER,
+L"show na\0", 0x00000008L, MCI_INTEGER,
+L"show noactivate\0", 0x00000004L, MCI_INTEGER,
+L"show normal\0", 0x00000001L, MCI_INTEGER,
+L"show\0", 0x00000005L, MCI_INTEGER,
+L"no action\0", 0x00000008L, MCI_INTEGER,
+L"minimized\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"text\0", 0x00080000L, MCI_STRING,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
diff --git a/dlls/winmm/mciavi/private_mciavi.h b/dlls/winmm/mciavi/private_mciavi.h
index afdcc7f..1241c4b 100644
--- a/dlls/winmm/mciavi/private_mciavi.h
+++ b/dlls/winmm/mciavi/private_mciavi.h
@@ -41,12 +41,12 @@
};
typedef struct {
- MCIDEVICEID wDevID;
+ MCIDEVICEID wDevID;
int nUseCount; /* Incremented for each shared open */
BOOL fShareable; /* TRUE if first open was shareable */
WORD wCommandTable; /* custom MCI command table */
- DWORD dwStatus; /* One of MCI_MODE_XXX */
- LPSTR lpFileName;
+ DWORD dwStatus; /* One of MCI_MODE_XXX */
+ LPWSTR lpFileName;
DWORD dwMciTimeFormat; /* current time format */
DWORD dwSet; /* what's turned on: video & audio l&r */
/* information on the loaded AVI file */
@@ -90,9 +90,9 @@
DWORD MCIAVI_ConvertFrameToTimeFormat(WINE_MCIAVI* wma, DWORD val, LPDWORD lpRet);
DWORD MCIAVI_ConvertTimeFormatToFrame(WINE_MCIAVI* wma, DWORD val);
DWORD MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms);
-DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSA lpParms);
+DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms);
DWORD MCIAVI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms);
-DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSA lpParms);
+DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms);
/* mmoutput.c */
BOOL MCIAVI_GetInfo(WINE_MCIAVI* wma);
@@ -108,9 +108,9 @@
/* wnd.c */
BOOL MCIAVI_RegisterClass(void);
BOOL MCIAVI_UnregisterClass(void);
-BOOL MCIAVI_CreateWindow(WINE_MCIAVI* wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSA lpOpenParms);
+BOOL MCIAVI_CreateWindow(WINE_MCIAVI* wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms);
DWORD MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms);
DWORD MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms);
-DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSA lpParms);
+DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms);
#endif /* __WINE_PRIVATE_MCIAVI_H */
diff --git a/dlls/winmm/mciavi/wnd.c b/dlls/winmm/mciavi/wnd.c
index 8b24730..639f057 100644
--- a/dlls/winmm/mciavi/wnd.c
+++ b/dlls/winmm/mciavi/wnd.c
@@ -85,7 +85,6 @@
default:
return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}
- return 0;
}
BOOL MCIAVI_UnregisterClass(void)
@@ -112,13 +111,13 @@
return FALSE;
}
-BOOL MCIAVI_CreateWindow(WINE_MCIAVI* wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSA lpOpenParms)
+BOOL MCIAVI_CreateWindow(WINE_MCIAVI* wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms)
{
static const WCHAR captionW[] = {'W','i','n','e',' ','M','C','I','-','A','V','I',' ','p','l','a','y','e','r',0};
HWND hParent = 0;
DWORD dwStyle = WS_OVERLAPPEDWINDOW;
int p = CW_USEDEFAULT;
- RECT rc;
+ RECT rc;
/* what should be done ? */
if (wma->hWnd) return TRUE;
@@ -134,9 +133,9 @@
AdjustWindowRect(&rc, dwStyle, FALSE);
wma->hWnd = CreateWindowW(mciaviW, captionW,
- dwStyle, rc.left, rc.top,
- rc.right, rc.bottom,
- hParent, 0, MCIAVI_hInstance,
+ dwStyle, rc.left, rc.top,
+ rc.right, rc.bottom,
+ hParent, 0, MCIAVI_hInstance,
(LPVOID)wma->wDevID);
wma->hWndPaint = wma->hWnd;
return (BOOL)wma->hWnd;
@@ -264,7 +263,7 @@
/***************************************************************************
* MCIAVI_mciWindow [internal]
*/
-DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSA lpParms)
+DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
@@ -288,8 +287,8 @@
ShowWindow(wma->hWndPaint, lpParms->nCmdShow);
}
if (dwFlags & MCI_DGV_WINDOW_TEXT) {
- TRACE("Setting caption to '%s'\n", lpParms->lpstrText);
- SetWindowTextA(wma->hWndPaint, lpParms->lpstrText);
+ TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
+ SetWindowTextW(wma->hWndPaint, lpParms->lpstrText);
}
LeaveCriticalSection(&wma->cs);
diff --git a/dlls/winmm/mcicda/Makefile.in b/dlls/winmm/mcicda/Makefile.in
index 72a2134..74d499b 100644
--- a/dlls/winmm/mcicda/Makefile.in
+++ b/dlls/winmm/mcicda/Makefile.in
@@ -4,6 +4,7 @@
VPATH = @srcdir@
MODULE = mcicda.drv
IMPORTS = winmm user32 kernel32
+EXTRALIBS = $(LIBUNICODE)
C_SRCS = \
mcicda.c
diff --git a/dlls/winmm/mcicda/mcicda.c b/dlls/winmm/mcicda/mcicda.c
index 3c3570f..0b0fa0a 100644
--- a/dlls/winmm/mcicda/mcicda.c
+++ b/dlls/winmm/mcicda/mcicda.c
@@ -37,6 +37,7 @@
#include "ntddstor.h"
#include "ntddcdrm.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mcicda);
@@ -60,13 +61,13 @@
/**************************************************************************
* MCICDA_drvOpen [internal]
*/
-static DWORD MCICDA_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
+static DWORD MCICDA_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
{
WINE_MCICDAUDIO* wmcda;
if (!modp) return 0xFFFFFFFF;
- wmcda = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCICDAUDIO));
+ wmcda = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCICDAUDIO));
if (!wmcda)
return 0;
@@ -264,14 +265,13 @@
/**************************************************************************
* MCICDA_Open [internal]
*/
-static DWORD MCICDA_Open(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpOpenParms)
+static DWORD MCICDA_Open(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSW lpOpenParms)
{
DWORD dwDeviceID;
DWORD ret = MCIERR_HARDWARE;
WINE_MCICDAUDIO* wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
- char root[7];
+ WCHAR root[7], drive = 0;
int count;
- char drive = 0;
TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpOpenParms);
@@ -297,18 +297,18 @@
WARN("MCI_OPEN_ELEMENT_ID %8lx ! Abort\n", (DWORD)lpOpenParms->lpstrElementName);
return MCIERR_NO_ELEMENT_ALLOWED;
}
- TRACE("MCI_OPEN_ELEMENT element name: %s\n", debugstr_a(lpOpenParms->lpstrElementName));
+ TRACE("MCI_OPEN_ELEMENT element name: %s\n", debugstr_w(lpOpenParms->lpstrElementName));
if (!isalpha(lpOpenParms->lpstrElementName[0]) || lpOpenParms->lpstrElementName[1] != ':' ||
(lpOpenParms->lpstrElementName[2] && lpOpenParms->lpstrElementName[2] != '\\'))
{
- WARN("MCI_OPEN_ELEMENT unsupported format: %s\n", lpOpenParms->lpstrElementName);
+ WARN("MCI_OPEN_ELEMENT unsupported format: %s\n",
+ debugstr_w(lpOpenParms->lpstrElementName));
ret = MCIERR_NO_ELEMENT_ALLOWED;
goto the_error;
}
drive = toupper(lpOpenParms->lpstrElementName[0]);
- strcpy(root, "A:\\");
- root[0] = drive;
- if (GetDriveTypeA(root) != DRIVE_CDROM)
+ root[0] = drive; root[1] = ':'; root[2] = '\\'; root[3] = '\0';
+ if (GetDriveTypeW(root) != DRIVE_CDROM)
{
ret = MCIERR_INVALID_DEVICE_NAME;
goto the_error;
@@ -317,10 +317,10 @@
else
{
/* drive letter isn't passed... get the dwDeviceID'th cdrom in the system */
- strcpy(root, "A:\\");
+ root[0] = 'A'; root[1] = ':'; root[2] = '\\'; root[3] = '\0';
for (count = 0; root[0] <= 'Z'; root[0]++)
{
- if (GetDriveTypeA(root) == DRIVE_CDROM && ++count >= dwDeviceID)
+ if (GetDriveTypeW(root) == DRIVE_CDROM && ++count >= dwDeviceID)
{
drive = root[0];
break;
@@ -337,9 +337,8 @@
wmcda->dwTimeFormat = MCI_FORMAT_MSF;
/* now, open the handle */
- strcpy(root, "\\\\.\\A:");
- root[4] = drive;
- wmcda->handle = CreateFileA(root, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
+ root[0] = root[1] = '\\'; root[2] = '.'; root[3] = '\\'; root[4] = drive; root[5] = ':'; root[6] = '\0';
+ wmcda->handle = CreateFileW(root, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
if (wmcda->handle != INVALID_HANDLE_VALUE)
return 0;
@@ -462,12 +461,12 @@
/**************************************************************************
* MCICDA_Info [internal]
*/
-static DWORD MCICDA_Info(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
+static DWORD MCICDA_Info(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSW lpParms)
{
- LPCSTR str = NULL;
+ LPCWSTR str = NULL;
WINE_MCICDAUDIO* wmcda = MCICDA_GetOpenDrv(wDevID);
DWORD ret = 0;
- char buffer[16];
+ WCHAR buffer[16];
TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
@@ -478,13 +477,15 @@
TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
if (dwFlags & MCI_INFO_PRODUCT) {
- str = "Wine's audio CD";
+ static const WCHAR wszAudioCd[] = {'W','i','n','e','\'','s',' ','a','u','d','i','o',' ','C','D',0};
+ str = wszAudioCd;
} else if (dwFlags & MCI_INFO_MEDIA_UPC) {
ret = MCIERR_NO_IDENTITY;
} else if (dwFlags & MCI_INFO_MEDIA_IDENTITY) {
DWORD res = 0;
CDROM_TOC toc;
DWORD br;
+ static const WCHAR wszLu[] = {'%','l','u',0};
if (!DeviceIoControl(wmcda->handle, IOCTL_CDROM_READ_TOC, NULL, 0,
&toc, sizeof(toc), &br, NULL)) {
@@ -492,23 +493,23 @@
}
res = CDROM_Audio_GetSerial(&toc);
- sprintf(buffer, "%lu", res);
+ sprintfW(buffer, wszLu, res);
str = buffer;
} else {
WARN("Don't know this info command (%lu)\n", dwFlags);
ret = MCIERR_UNRECOGNIZED_COMMAND;
}
if (str) {
- if (lpParms->dwRetSize <= strlen(str)) {
- lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
+ if (lpParms->dwRetSize <= strlenW(str)) {
+ lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
ret = MCIERR_PARAM_OVERFLOW;
} else {
- strcpy(lpParms->lpstrReturn, str);
+ strcpyW(lpParms->lpstrReturn, str);
}
} else {
*lpParms->lpstrReturn = 0;
}
- TRACE("=> %s (%ld)\n", lpParms->lpstrReturn, ret);
+ TRACE("=> %s (%ld)\n", debugstr_w(lpParms->lpstrReturn), ret);
return ret;
}
@@ -992,7 +993,7 @@
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
- case DRV_OPEN: return MCICDA_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
+ case DRV_OPEN: return MCICDA_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return MCICDA_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
@@ -1005,10 +1006,10 @@
if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
switch (wMsg) {
- case MCI_OPEN_DRIVER: return MCICDA_Open(dwDevID, dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
+ case MCI_OPEN_DRIVER: return MCICDA_Open(dwDevID, dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
case MCI_CLOSE_DRIVER: return MCICDA_Close(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_GETDEVCAPS: return MCICDA_GetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
- case MCI_INFO: return MCICDA_Info(dwDevID, dwParam1, (LPMCI_INFO_PARMSA)dwParam2);
+ case MCI_INFO: return MCICDA_Info(dwDevID, dwParam1, (LPMCI_INFO_PARMSW)dwParam2);
case MCI_STATUS: return MCICDA_Status(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_SET: return MCICDA_Set(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PLAY: return MCICDA_Play(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
diff --git a/dlls/winmm/mciseq/mcimidi.c b/dlls/winmm/mciseq/mcimidi.c
index 99c6406..22f26f7 100644
--- a/dlls/winmm/mciseq/mcimidi.c
+++ b/dlls/winmm/mciseq/mcimidi.c
@@ -48,6 +48,7 @@
#include "wownt32.h"
#include "mmddk.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mcimidi);
@@ -74,9 +75,9 @@
WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
HANDLE hCallback; /* Callback handle for pending notification */
HMMIO hFile; /* mmio file handle open as Element */
- LPSTR lpstrElementName; /* Name of file (if any) */
- LPSTR lpstrCopyright;
- LPSTR lpstrName;
+ LPWSTR lpstrElementName; /* Name of file (if any) */
+ LPWSTR lpstrCopyright;
+ LPWSTR lpstrName;
WORD dwStatus; /* one from MCI_MODE_xxxx */
DWORD dwMciTimeFormat; /* One of the supported MCI_FORMAT_xxxx */
WORD wFormat; /* Format of MIDI hFile (0, 1 or 2) */
@@ -171,7 +172,7 @@
/**************************************************************************
* MIDI_drvOpen [internal]
*/
-static DWORD MIDI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
+static DWORD MIDI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
{
WINE_MCIMIDI* wmm;
@@ -416,18 +417,20 @@
switch (HIBYTE(LOWORD(mmt->dwEventData))) {
case 0x02:
if (wmm->lpstrCopyright) {
- WARN("Two copyright notices (%s|%s)\n", wmm->lpstrCopyright, buf);
+ WARN("Two copyright notices (%s|%s)\n", debugstr_w(wmm->lpstrCopyright), buf);
} else {
- wmm->lpstrCopyright = HeapAlloc( GetProcessHeap(), 0, strlen(buf)+1 );
- strcpy( wmm->lpstrCopyright, buf );
+ len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
+ wmm->lpstrCopyright = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ len = MultiByteToWideChar( CP_ACP, 0, buf, -1, wmm->lpstrCopyright, len );
}
break;
case 0x03:
if (wmm->lpstrName) {
- WARN("Two names (%s|%s)\n", wmm->lpstrName, buf);
+ WARN("Two names (%s|%s)\n", debugstr_w(wmm->lpstrName), buf);
} else {
- wmm->lpstrName = HeapAlloc( GetProcessHeap(), 0, strlen(buf)+1 );
- strcpy( wmm->lpstrName, buf );
+ len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
+ wmm->lpstrName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ len = MultiByteToWideChar( CP_ACP, 0, buf, -1, wmm->lpstrName, len );
}
break;
}
@@ -712,7 +715,7 @@
/**************************************************************************
* MIDI_mciOpen [internal]
*/
-static DWORD MIDI_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSA lpParms)
+static DWORD MIDI_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMSW lpParms)
{
DWORD dwRet = 0;
DWORD dwDeviceID;
@@ -742,17 +745,18 @@
/* lpParms->wDeviceID = wDevID;*/
if (dwFlags & MCI_OPEN_ELEMENT) {
- TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpParms->lpstrElementName);
- if (lpParms->lpstrElementName && strlen(lpParms->lpstrElementName) > 0) {
- wmm->hFile = mmioOpenA(lpParms->lpstrElementName, NULL,
+ TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpParms->lpstrElementName));
+ if (lpParms->lpstrElementName && strlenW(lpParms->lpstrElementName) > 0) {
+ wmm->hFile = mmioOpenW(lpParms->lpstrElementName, NULL,
MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
if (wmm->hFile == 0) {
- WARN("Can't find file '%s' !\n", lpParms->lpstrElementName);
+ WARN("Can't find file %s!\n", debugstr_w(lpParms->lpstrElementName));
wmm->nUseCount--;
return MCIERR_FILE_NOT_FOUND;
}
- wmm->lpstrElementName = HeapAlloc(GetProcessHeap(), 0, strlen(lpParms->lpstrElementName) + 1);
- strcpy(wmm->lpstrElementName, lpParms->lpstrElementName);
+ wmm->lpstrElementName = HeapAlloc(GetProcessHeap(), 0,
+ (strlenW(lpParms->lpstrElementName) + 1) * sizeof(WCHAR));
+ strcpyW(wmm->lpstrElementName, lpParms->lpstrElementName);
}
}
TRACE("hFile=%p\n", wmm->hFile);
@@ -868,7 +872,7 @@
TRACE("hFile closed !\n");
}
HeapFree(GetProcessHeap(), 0, wmm->tracks);
- HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrElementName);
+ HeapFree(GetProcessHeap(), 0, (LPWSTR)wmm->lpstrElementName);
HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrCopyright);
HeapFree(GetProcessHeap(), 0, (LPSTR)wmm->lpstrName);
} else {
@@ -925,7 +929,7 @@
if (wmm == NULL) return MCIERR_INVALID_DEVICE_ID;
if (wmm->hFile == 0) {
- WARN("Can't play: no file '%s' !\n", debugstr_a(wmm->lpstrElementName));
+ WARN("Can't play: no file %s!\n", debugstr_w(wmm->lpstrElementName));
return MCIERR_FILE_NOT_FOUND;
}
@@ -1141,7 +1145,7 @@
if (sf >= 0x80) TRACE("%d flats\n", -(char)sf);
else if (sf > 0) TRACE("%d sharps\n", (char)sf);
else TRACE("Key of C\n");
- TRACE("Mode: %s\n", (mm = 0) ? "major" : "minor");
+ TRACE("Mode: %s\n", (mm == 0) ? "major" : "minor");
}
break;
default:
@@ -1203,7 +1207,7 @@
if (wmm == 0) return MCIERR_INVALID_DEVICE_ID;
if (wmm->hFile == 0) {
- WARN("Can't find file='%s' !\n", debugstr_a(wmm->lpstrElementName));
+ WARN("Can't find file=%s!\n", debugstr_w(wmm->lpstrElementName));
return MCIERR_FILE_NOT_FOUND;
}
start = 1; end = 99999;
@@ -1356,12 +1360,13 @@
return MCIERR_BAD_INTEGER;
}
- if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
- TRACE("MCI_SET_AUDIO_ALL !\n");
- if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
- TRACE("MCI_SET_AUDIO_LEFT !\n");
- if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
- TRACE("MCI_SET_AUDIO_RIGHT !\n");
+ switch (lpParms->dwAudio)
+ {
+ case MCI_SET_AUDIO_ALL: TRACE("MCI_SET_AUDIO_ALL !\n"); break;
+ case MCI_SET_AUDIO_LEFT: TRACE("MCI_SET_AUDIO_LEFT !\n"); break;
+ case MCI_SET_AUDIO_RIGHT: TRACE("MCI_SET_AUDIO_RIGHT !\n"); break;
+ default: WARN("Unknown audio channel %lu\n", lpParms->dwAudio); break;
+ }
}
if (dwFlags & MCI_SEQ_SET_MASTER)
@@ -1568,11 +1573,12 @@
/**************************************************************************
* MIDI_mciInfo [internal]
*/
-static DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
+static DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSW lpParms)
{
- LPCSTR str = 0;
+ LPCWSTR str = 0;
WINE_MCIMIDI* wmm = MIDI_mciGetOpenDev(wDevID);
DWORD ret = 0;
+ static const WCHAR wszMidiSeq[] = {'W','i','n','e','\'','s',' ','M','I','D','I',' ','s','e','q','u','e','n','c','e','r',0};
TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
@@ -1583,28 +1589,20 @@
TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
switch (dwFlags & ~(MCI_WAIT|MCI_NOTIFY)) {
- case MCI_INFO_PRODUCT:
- str = "Wine's MIDI sequencer";
- break;
- case MCI_INFO_FILE:
- str = wmm->lpstrElementName;
- break;
- case MCI_INFO_COPYRIGHT:
- str = wmm->lpstrCopyright;
- break;
- case MCI_INFO_NAME:
- str = wmm->lpstrName;
- break;
+ case MCI_INFO_PRODUCT: str = wszMidiSeq; break;
+ case MCI_INFO_FILE: str = wmm->lpstrElementName; break;
+ case MCI_INFO_COPYRIGHT: str = wmm->lpstrCopyright; break;
+ case MCI_INFO_NAME: str = wmm->lpstrName; break;
default:
WARN("Don't know this info command (%lu)\n", dwFlags);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (str) {
- if (lpParms->dwRetSize <= strlen(str)) {
- lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
+ if (lpParms->dwRetSize <= strlenW(str)) {
+ lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
ret = MCIERR_PARAM_OVERFLOW;
} else {
- strcpy(lpParms->lpstrReturn, str);
+ strcpyW(lpParms->lpstrReturn, str);
}
} else {
*lpParms->lpstrReturn = 0;
@@ -1670,14 +1668,14 @@
case DRV_CONFIGURE: MessageBoxA(0, "Sample Midi Driver !", "OSS Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
- case DRV_OPEN: return MIDI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
+ case DRV_OPEN: return MIDI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return MIDI_drvClose(dwDevID);
}
if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
switch (wMsg) {
- case MCI_OPEN_DRIVER: return MIDI_mciOpen (dwDevID, dwParam1, (LPMCI_OPEN_PARMSA) dwParam2);
+ case MCI_OPEN_DRIVER: return MIDI_mciOpen (dwDevID, dwParam1, (LPMCI_OPEN_PARMSW) dwParam2);
case MCI_CLOSE_DRIVER: return MIDI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_PLAY: return MIDI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
case MCI_RECORD: return MIDI_mciRecord (dwDevID, dwParam1, (LPMCI_RECORD_PARMS) dwParam2);
@@ -1687,7 +1685,7 @@
case MCI_RESUME: return MIDI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_STATUS: return MIDI_mciStatus (dwDevID, dwParam1, (LPMCI_STATUS_PARMS) dwParam2);
case MCI_GETDEVCAPS: return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
- case MCI_INFO: return MIDI_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSA) dwParam2);
+ case MCI_INFO: return MIDI_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSW) dwParam2);
case MCI_SEEK: return MIDI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
/* commands that should be supported */
case MCI_LOAD:
diff --git a/dlls/winmm/mciwave/mciwave.c b/dlls/winmm/mciwave/mciwave.c
index b89f4c1..25492f9 100644
--- a/dlls/winmm/mciwave/mciwave.c
+++ b/dlls/winmm/mciwave/mciwave.c
@@ -32,6 +32,7 @@
#include "wownt32.h"
#include "digitalv.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mciwave);
@@ -41,7 +42,7 @@
int nUseCount; /* Incremented for each shared open */
BOOL fShareable; /* TRUE if first open was shareable */
HMMIO hFile; /* mmio file handle open as Element */
- MCI_WAVE_OPEN_PARMSA openParms;
+ MCI_WAVE_OPEN_PARMSW openParms;
WAVEFORMATEX wfxRef;
LPWAVEFORMATEX lpWaveFormat;
BOOL fInput; /* FALSE = Output, TRUE = Input */
@@ -134,7 +135,7 @@
/**************************************************************************
* MCIWAVE_drvOpen [internal]
*/
-static DWORD WAVE_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
+static DWORD WAVE_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
{
WINE_MCIWAVE* wmw;
@@ -344,11 +345,11 @@
/**************************************************************************
* WAVE_mciOpen [internal]
*/
-static DWORD WAVE_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMSA lpOpenParms)
+static DWORD WAVE_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMSW lpOpenParms)
{
DWORD dwRet = 0;
WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(wDevID);
- CHAR* pszTmpFileName = 0;
+ WCHAR* pszTmpFileName = 0;
TRACE("(%04X, %08lX, %p)\n", wDevID, dwFlags, lpOpenParms);
if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
@@ -379,18 +380,18 @@
*/
dwRet = MCIERR_UNRECOGNIZED_COMMAND;
} else {
- if (strlen(lpOpenParms->lpstrElementName) > 0) {
+ if (strlenW(lpOpenParms->lpstrElementName) > 0) {
lpOpenParms->lpstrElementName = lpOpenParms->lpstrElementName;
/* FIXME : what should be done id wmw->hFile is already != 0, or the driver is playin' */
- TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpOpenParms->lpstrElementName);
+ TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
- if (lpOpenParms->lpstrElementName && (strlen(lpOpenParms->lpstrElementName) > 0)) {
- wmw->hFile = mmioOpenA((LPSTR)lpOpenParms->lpstrElementName, NULL,
- MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READWRITE);
+ if (lpOpenParms->lpstrElementName && (strlenW(lpOpenParms->lpstrElementName) > 0)) {
+ wmw->hFile = mmioOpenW((LPWSTR)lpOpenParms->lpstrElementName, NULL,
+ MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READWRITE);
if (wmw->hFile == 0) {
- WARN("can't find file='%s' !\n", lpOpenParms->lpstrElementName);
+ WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
dwRet = MCIERR_FILE_NOT_FOUND;
}
else
@@ -423,38 +424,42 @@
}
}
else {
- CHAR szTmpPath[MAX_PATH];
- CHAR szPrefix[4] = "TMP\0";
+ WCHAR szTmpPath[MAX_PATH];
+ WCHAR szPrefix[4];
+ szPrefix[0] = 'T';
+ szPrefix[1] = 'M';
+ szPrefix[2] = 'P';
+ szPrefix[3] = '\0';
pszTmpFileName = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
MAX_PATH * sizeof(*pszTmpFileName));
- if (!GetTempPathA(sizeof(szTmpPath), szTmpPath)) {
+ if (!GetTempPathW(sizeof(szTmpPath), szTmpPath)) {
WARN("can't retrieve temp path!\n");
HeapFree(GetProcessHeap(), 0, pszTmpFileName);
return MCIERR_FILE_NOT_FOUND;
}
- if (!GetTempFileNameA(szTmpPath, szPrefix, 0, pszTmpFileName)) {
- WARN("can't retrieve temp file name!\n");
- HeapFree(GetProcessHeap(), 0, pszTmpFileName);
- return MCIERR_FILE_NOT_FOUND;
+ if (!GetTempFileNameW(szTmpPath, szPrefix, 0, pszTmpFileName)) {
+ WARN("can't retrieve temp file name!\n");
+ HeapFree(GetProcessHeap(), 0, pszTmpFileName);
+ return MCIERR_FILE_NOT_FOUND;
}
wmw->bTemporaryFile = TRUE;
- TRACE("MCI_OPEN_ELEMENT '%s' !\n", pszTmpFileName);
+ TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(pszTmpFileName));
- if (pszTmpFileName && (strlen(pszTmpFileName) > 0)) {
+ if (pszTmpFileName && (strlenW(pszTmpFileName) > 0)) {
- wmw->hFile = mmioOpenA(pszTmpFileName, NULL,
+ wmw->hFile = mmioOpenW(pszTmpFileName, NULL,
MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE);
if (wmw->hFile == 0) {
+ WARN("can't create file=%s!\n", debugstr_w(pszTmpFileName));
/* temporary file could not be created. clean filename. */
HeapFree(GetProcessHeap(), 0, pszTmpFileName);
- WARN("can't create file='%s' !\n", pszTmpFileName);
dwRet = MCIERR_FILE_NOT_FOUND;
}
}
@@ -617,7 +622,7 @@
*/
if (wmw->bTemporaryFile)
{
- HeapFree(GetProcessHeap(), 0, (char*)wmw->openParms.lpstrElementName);
+ HeapFree(GetProcessHeap(), 0, (WCHAR*)wmw->openParms.lpstrElementName);
wmw->openParms.lpstrElementName = NULL;
}
@@ -702,7 +707,7 @@
}
if (wmw->hFile == 0) {
- WARN("Can't play: no file='%s' !\n", wmw->openParms.lpstrElementName);
+ WARN("Can't play: no file=%s!\n", debugstr_w(wmw->openParms.lpstrElementName));
return MCIERR_FILE_NOT_FOUND;
}
@@ -1230,12 +1235,13 @@
return MCIERR_BAD_INTEGER;
}
- if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
- TRACE("MCI_SET_AUDIO_ALL !\n");
- if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
- TRACE("MCI_SET_AUDIO_LEFT !\n");
- if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
- TRACE("MCI_SET_AUDIO_RIGHT !\n");
+ switch (lpParms->dwAudio)
+ {
+ case MCI_SET_AUDIO_ALL: TRACE("MCI_SET_AUDIO_ALL !\n"); break;
+ case MCI_SET_AUDIO_LEFT: TRACE("MCI_SET_AUDIO_LEFT !\n"); break;
+ case MCI_SET_AUDIO_RIGHT: TRACE("MCI_SET_AUDIO_RIGHT !\n"); break;
+ default: WARN("Unknown audio channel %lu\n", lpParms->dwAudio); break;
+ }
}
if (dwFlags & MCI_WAVE_INPUT)
TRACE("MCI_WAVE_INPUT !\n");
@@ -1275,7 +1281,7 @@
/**************************************************************************
* WAVE_mciSave [internal]
*/
-static DWORD WAVE_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_SAVE_PARMS lpParms)
+static DWORD WAVE_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_SAVE_PARMSW lpParms)
{
WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
DWORD ret = MCIERR_FILE_NOT_SAVED, tmpRet;
@@ -1306,10 +1312,10 @@
careful not to lose our previous error code.
*/
tmpRet = GetLastError();
- DeleteFileA (lpParms->lpfilename);
+ DeleteFileW (lpParms->lpfilename);
SetLastError(tmpRet);
- if (0 == mmioRenameA(wmw->openParms.lpstrElementName, lpParms->lpfilename, 0, 0 )) {
+ if (0 == mmioRenameW(wmw->openParms.lpstrElementName, lpParms->lpfilename, 0, 0 )) {
ret = ERROR_SUCCESS;
}
@@ -1541,10 +1547,10 @@
/**************************************************************************
* WAVE_mciInfo [internal]
*/
-static DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
+static DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSW lpParms)
{
DWORD ret = 0;
- LPCSTR str = 0;
+ LPCWSTR str = 0;
WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
@@ -1554,31 +1560,27 @@
} else if (wmw == NULL) {
ret = MCIERR_INVALID_DEVICE_ID;
} else {
+ static const WCHAR wszAudio [] = {'W','i','n','e','\'','s',' ','a','u','d','i','o',' ','p','l','a','y','e','r',0};
+ static const WCHAR wszWaveIn [] = {'W','i','n','e',' ','W','a','v','e',' ','I','n',0};
+ static const WCHAR wszWaveOut[] = {'W','i','n','e',' ','W','a','v','e',' ','O','u','t',0};
+
TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
switch (dwFlags & ~(MCI_WAIT|MCI_NOTIFY)) {
- case MCI_INFO_PRODUCT:
- str = "Wine's audio player";
- break;
- case MCI_INFO_FILE:
- str = wmw->openParms.lpstrElementName;
- break;
- case MCI_WAVE_INPUT:
- str = "Wine Wave In";
- break;
- case MCI_WAVE_OUTPUT:
- str = "Wine Wave Out";
- break;
+ case MCI_INFO_PRODUCT: str = wszAudio; break;
+ case MCI_INFO_FILE: str = wmw->openParms.lpstrElementName; break;
+ case MCI_WAVE_INPUT: str = wszWaveIn; break;
+ case MCI_WAVE_OUTPUT: str = wszWaveOut; break;
default:
WARN("Don't know this info command (%lu)\n", dwFlags);
ret = MCIERR_UNRECOGNIZED_COMMAND;
}
}
if (str) {
- if (strlen(str) + 1 > lpParms->dwRetSize) {
+ if (strlenW(str) + 1 > lpParms->dwRetSize) {
ret = MCIERR_PARAM_OVERFLOW;
} else {
- lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize);
+ lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize);
}
} else {
lpParms->lpstrReturn[0] = 0;
@@ -1599,7 +1601,7 @@
switch (wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
- case DRV_OPEN: return WAVE_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
+ case DRV_OPEN: return WAVE_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
case DRV_CLOSE: return WAVE_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
@@ -1612,7 +1614,7 @@
if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
switch (wMsg) {
- case MCI_OPEN_DRIVER: return WAVE_mciOpen (dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMSA) dwParam2);
+ case MCI_OPEN_DRIVER: return WAVE_mciOpen (dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMSW) dwParam2);
case MCI_CLOSE_DRIVER: return WAVE_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_CUE: return WAVE_mciCue (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_PLAY: return WAVE_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
@@ -1623,9 +1625,9 @@
case MCI_RESUME: return WAVE_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
case MCI_STATUS: return WAVE_mciStatus (dwDevID, dwParam1, (LPMCI_STATUS_PARMS) dwParam2);
case MCI_GETDEVCAPS: return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
- case MCI_INFO: return WAVE_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSA) dwParam2);
+ case MCI_INFO: return WAVE_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSW) dwParam2);
case MCI_SEEK: return WAVE_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
- case MCI_SAVE: return WAVE_mciSave (dwDevID, dwParam1, (LPMCI_SAVE_PARMS) dwParam2);
+ case MCI_SAVE: return WAVE_mciSave (dwDevID, dwParam1, (LPMCI_SAVE_PARMSW) dwParam2);
/* commands that should be supported */
case MCI_LOAD:
case MCI_FREEZE:
diff --git a/dlls/winmm/message16.c b/dlls/winmm/message16.c
index 5eff2ca..f95de2e 100644
--- a/dlls/winmm/message16.c
+++ b/dlls/winmm/message16.c
@@ -1,5 +1,3 @@
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
/*
* MMSYSTEM MCI and low level mapping functions
*
@@ -70,33 +68,33 @@
* ================================= */
/**************************************************************************
- * MMDRV_Aux_Map16To32A [internal]
+ * MMDRV_Aux_Map16To32W [internal]
*/
-static WINMM_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_Aux_UnMap16To32A [internal]
+ * MMDRV_Aux_UnMap16To32W [internal]
*/
-static WINMM_MapType MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_Aux_Map32ATo16 [internal]
+ * MMDRV_Aux_Map32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_Aux_UnMap32ATo16 [internal]
+ * MMDRV_Aux_UnMap32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
#if 0
case AUXDM_GETDEVCAPS:
@@ -126,17 +124,17 @@
* ================================= */
/**************************************************************************
- * xMMDRV_Mixer_Map16To32A [internal]
+ * xMMDRV_Mixer_Map16To32W [internal]
*/
-static WINMM_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_Mixer_UnMap16To32A [internal]
+ * MMDRV_Mixer_UnMap16To32W [internal]
*/
-static WINMM_MapType MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
#if 0
MIXERCAPSA micA;
@@ -156,17 +154,17 @@
}
/**************************************************************************
- * MMDRV_Mixer_Map32ATo16 [internal]
+ * MMDRV_Mixer_Map32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_Mixer_UnMap32ATo16 [internal]
+ * MMDRV_Mixer_UnMap32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
@@ -187,33 +185,33 @@
* ================================= */
/**************************************************************************
- * MMDRV_MidiIn_Map16To32A [internal]
+ * MMDRV_MidiIn_Map16To32W [internal]
*/
-static WINMM_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_MidiIn_UnMap16To32A [internal]
+ * MMDRV_MidiIn_UnMap16To32W [internal]
*/
-static WINMM_MapType MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_MidiIn_Map32ATo16 [internal]
+ * MMDRV_MidiIn_Map32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
- * MMDRV_MidiIn_UnMap32ATo16 [internal]
+ * MMDRV_MidiIn_UnMap32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
@@ -275,9 +273,9 @@
* ================================= */
/**************************************************************************
- * MMDRV_MidiOut_Map16To32A [internal]
+ * MMDRV_MidiOut_Map16To32W [internal]
*/
-static WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -368,9 +366,9 @@
}
/**************************************************************************
- * MMDRV_MidiOut_UnMap16To32A [internal]
+ * MMDRV_MidiOut_UnMap16To32W [internal]
*/
-static WINMM_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -440,9 +438,9 @@
}
/**************************************************************************
- * MMDRV_MidiOut_Map32ATo16 [internal]
+ * MMDRV_MidiOut_Map32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -580,9 +578,9 @@
}
/**************************************************************************
- * MMDRV_MidiOut_UnMap32ATo16 [internal]
+ * MMDRV_MidiOut_UnMap32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -706,9 +704,9 @@
* ================================= */
/**************************************************************************
- * MMDRV_WaveIn_Map16To32A [internal]
+ * MMDRV_WaveIn_Map16To32W [internal]
*/
-static WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -815,9 +813,9 @@
}
/**************************************************************************
- * MMDRV_WaveIn_UnMap16To32A [internal]
+ * MMDRV_WaveIn_UnMap16To32W [internal]
*/
-static WINMM_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -888,9 +886,9 @@
}
/**************************************************************************
- * MMDRV_WaveIn_Map32ATo16 [internal]
+ * MMDRV_WaveIn_Map32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -1058,9 +1056,9 @@
}
/**************************************************************************
- * MMDRV_WaveIn_UnMap32ATo16 [internal]
+ * MMDRV_WaveIn_UnMap32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -1197,9 +1195,9 @@
* ================================= */
/**************************************************************************
- * MMDRV_WaveOut_Map16To32A [internal]
+ * MMDRV_WaveOut_Map16To32W [internal]
*/
-static WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -1315,9 +1313,9 @@
}
/**************************************************************************
- * MMDRV_WaveOut_UnMap16To32A [internal]
+ * MMDRV_WaveOut_UnMap16To32W [internal]
*/
-static WINMM_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
@@ -1399,9 +1397,9 @@
}
/**************************************************************************
- * MMDRV_WaveOut_Map32ATo16 [internal]
+ * MMDRV_WaveOut_Map32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
+static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
{
WINMM_MapType ret;
@@ -1588,9 +1586,9 @@
}
/**************************************************************************
- * MMDRV_WaveOut_UnMap32ATo16 [internal]
+ * MMDRV_WaveOut_UnMap32WTo16 [internal]
*/
-static WINMM_MapType MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
+static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret;
@@ -1855,270 +1853,13 @@
* M C I
* ================================= */
-/**************************************************************************
- * MCI_MapMsg16To32A [internal]
+#if 0
+/* FIXME: this code is kept for not yet implemented optimisation for an application
+ * using the 32A MCI interface and calling a 16 bit driver.
+ * For now, we're doing two conversions:
+ * - 32A => 32W (in 32 bit MCI code)
+ * - 32W => 16 in this file
*/
-static WINMM_MapType MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
-{
- if (*lParam == 0)
- return WINMM_MAP_OK;
- /* FIXME: to add also (with seg/linear modifications to do):
- * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
- * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
- */
- switch (wMsg) {
- /* case MCI_CAPTURE */
- case MCI_CLOSE:
- case MCI_CLOSE_DRIVER:
- case MCI_CONFIGURE:
- case MCI_COPY:
- case MCI_CUE:
- case MCI_CUT:
- case MCI_DELETE:
- case MCI_FREEZE:
- case MCI_GETDEVCAPS:
- /* case MCI_INDEX: */
- /* case MCI_MARK: */
- /* case MCI_MONITOR: */
- case MCI_PASTE:
- case MCI_PAUSE:
- case MCI_PLAY:
- case MCI_PUT:
- case MCI_REALIZE:
- case MCI_RECORD:
- case MCI_RESUME:
- case MCI_SEEK:
- case MCI_SET:
- /* case MCI_SETTIMECODE:*/
- /* case MCI_SIGNAL:*/
- case MCI_SPIN:
- case MCI_STATUS: /* FIXME: is wrong for digital video */
- case MCI_STEP:
- case MCI_STOP:
- /* case MCI_UNDO: */
- case MCI_UNFREEZE:
- case MCI_UPDATE:
- case MCI_WHERE:
- *lParam = (DWORD)MapSL(*lParam);
- return WINMM_MAP_OK;
- case MCI_WINDOW:
- /* in fact, I would also need the dwFlags... to see
- * which members of lParam are effectively used
- */
- *lParam = (DWORD)MapSL(*lParam);
- FIXME("Current mapping may be wrong\n");
- break;
- case MCI_BREAK:
- {
- LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
- LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
-
- if (mbp32) {
- mbp32->dwCallback = mbp16->dwCallback;
- mbp32->nVirtKey = mbp16->nVirtKey;
- mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
- } else {
- return WINMM_MAP_NOMEM;
- }
- *lParam = (DWORD)mbp32;
- }
- return WINMM_MAP_OKMEM;
- case MCI_ESCAPE:
- {
- LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
- LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
-
- if (mvep32a) {
- mvep32a->dwCallback = mvep16->dwCallback;
- mvep32a->lpstrCommand = MapSL(mvep16->lpstrCommand);
- } else {
- return WINMM_MAP_NOMEM;
- }
- *lParam = (DWORD)mvep32a;
- }
- return WINMM_MAP_OKMEM;
- case MCI_INFO:
- {
- LPMCI_INFO_PARMSA mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
- LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
-
- /* FIXME this is wrong if device is of type
- * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
- */
- if (mip32a) {
- mip32a->dwCallback = mip16->dwCallback;
- mip32a->lpstrReturn = MapSL(mip16->lpstrReturn);
- mip32a->dwRetSize = mip16->dwRetSize;
- } else {
- return WINMM_MAP_NOMEM;
- }
- *lParam = (DWORD)mip32a;
- }
- return WINMM_MAP_OKMEM;
- case MCI_OPEN:
- case MCI_OPEN_DRIVER:
- {
- LPMCI_OPEN_PARMSA mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
- LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
-
- if (mop32a) {
- *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
- mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
- mop32a->dwCallback = mop16->dwCallback;
- mop32a->wDeviceID = mop16->wDeviceID;
- mop32a->lpstrDeviceType = MapSL(mop16->lpstrDeviceType);
- mop32a->lpstrElementName = MapSL(mop16->lpstrElementName);
- mop32a->lpstrAlias = MapSL(mop16->lpstrAlias);
- /* copy extended information if any...
- * FIXME: this may seg fault if initial structure does not contain them and
- * the reads after msip16 fail under LDT limits...
- * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
- * should not take care of extended parameters, and should be used by MCI_Open
- * to fetch uDevType. When, this is known, the mapping for sending the
- * MCI_OPEN_DRIVER shall be done depending on uDevType.
- */
- memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
- } else {
- return WINMM_MAP_NOMEM;
- }
- *lParam = (DWORD)mop32a;
- }
- return WINMM_MAP_OKMEM;
- case MCI_SYSINFO:
- {
- LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
- LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
-
- if (msip32a) {
- msip32a->dwCallback = msip16->dwCallback;
- msip32a->lpstrReturn = MapSL(msip16->lpstrReturn);
- msip32a->dwRetSize = msip16->dwRetSize;
- msip32a->dwNumber = msip16->dwNumber;
- msip32a->wDeviceType = msip16->wDeviceType;
- } else {
- return WINMM_MAP_NOMEM;
- }
- *lParam = (DWORD)msip32a;
- }
- return WINMM_MAP_OKMEM;
- case MCI_SOUND:
- {
- LPMCI_SOUND_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMS));
- LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
-
- if (mbp32) {
- mbp32->dwCallback = mbp16->dwCallback;
- mbp32->lpstrSoundName = MapSL(mbp16->lpstrSoundName);
- } else {
- return WINMM_MAP_NOMEM;
- }
- *lParam = (DWORD)mbp32;
- }
- return WINMM_MAP_OKMEM;
- case DRV_LOAD:
- case DRV_ENABLE:
- case DRV_OPEN:
- case DRV_CLOSE:
- case DRV_DISABLE:
- case DRV_FREE:
- case DRV_CONFIGURE:
- case DRV_QUERYCONFIGURE:
- case DRV_INSTALL:
- case DRV_REMOVE:
- case DRV_EXITSESSION:
- case DRV_EXITAPPLICATION:
- case DRV_POWER:
- FIXME("This is a hack\n");
- return WINMM_MAP_OK;
-
- default:
- WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
- }
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MCI_UnMapMsg16To32A [internal]
- */
-static WINMM_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
-{
- switch (wMsg) {
- /* case MCI_CAPTURE */
- case MCI_CLOSE:
- case MCI_CLOSE_DRIVER:
- case MCI_CONFIGURE:
- case MCI_COPY:
- case MCI_CUE:
- case MCI_CUT:
- case MCI_DELETE:
- case MCI_FREEZE:
- case MCI_GETDEVCAPS:
- /* case MCI_INDEX: */
- /* case MCI_MARK: */
- /* case MCI_MONITOR: */
- case MCI_PASTE:
- case MCI_PAUSE:
- case MCI_PLAY:
- case MCI_PUT:
- case MCI_REALIZE:
- case MCI_RECORD:
- case MCI_RESUME:
- case MCI_SEEK:
- case MCI_SET:
- /* case MCI_SETTIMECODE:*/
- /* case MCI_SIGNAL:*/
- case MCI_SPIN:
- case MCI_STATUS:
- case MCI_STEP:
- case MCI_STOP:
- /* case MCI_UNDO: */
- case MCI_UNFREEZE:
- case MCI_UPDATE:
- case MCI_WHERE:
- return WINMM_MAP_OK;
-
- case MCI_WINDOW:
- /* FIXME ?? see Map function */
- return WINMM_MAP_OK;
-
- case MCI_BREAK:
- case MCI_ESCAPE:
- case MCI_INFO:
- case MCI_SYSINFO:
- case MCI_SOUND:
- HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
- return WINMM_MAP_OK;
- case MCI_OPEN:
- case MCI_OPEN_DRIVER:
- if (lParam) {
- LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)lParam;
- LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16));
-
- mop16->wDeviceID = mop32a->wDeviceID;
- if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
- FIXME("bad free line=%d\n", __LINE__);
- }
- return WINMM_MAP_OK;
- case DRV_LOAD:
- case DRV_ENABLE:
- case DRV_OPEN:
- case DRV_CLOSE:
- case DRV_DISABLE:
- case DRV_FREE:
- case DRV_CONFIGURE:
- case DRV_QUERYCONFIGURE:
- case DRV_INSTALL:
- case DRV_REMOVE:
- case DRV_EXITSESSION:
- case DRV_EXITAPPLICATION:
- case DRV_POWER:
- FIXME("This is a hack\n");
- return WINMM_MAP_OK;
- default:
- FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
- }
- return WINMM_MAP_MSGERROR;
-}
/*
* 0000 stop
@@ -2132,7 +1873,7 @@
*/
/**************************************************************************
- * MCI_MsgMapper32To16_Create [internal]
+ * MCI_MsgMapper32ATo16_Create [internal]
*
* Helper for MCI_MapMsg32ATo16.
* Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
@@ -2141,7 +1882,7 @@
* above)
* if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
*/
-static WINMM_MapType MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
+static WINMM_MapType MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
{
void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
LPBYTE p16, p32;
@@ -2212,11 +1953,11 @@
}
/**************************************************************************
- * MCI_MsgMapper32To16_Destroy [internal]
+ * MCI_MsgMapper32ATo16_Destroy [internal]
*
* Helper for MCI_UnMapMsg32ATo16.
*/
-static WINMM_MapType MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
+static WINMM_MapType MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
{
if (ptr) {
void* msg16 = MapSL((SEGPTR)ptr);
@@ -2558,7 +2299,7 @@
LPMCI_OPEN_DRIVER_PARMSA modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
LPMCI_OPEN_DRIVER_PARMS16 modp16;
char *ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
+ sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
if (ptr) {
*(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
@@ -2587,10 +2328,10 @@
return WINMM_MAP_OK;
default:
- WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
+ FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
return WINMM_MAP_MSGERROR;
}
- return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
+ return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep);
}
/**************************************************************************
@@ -2774,14 +2515,1000 @@
FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
return WINMM_MAP_MSGERROR;
}
- return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
+ return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept);
+}
+#endif
+
+/**************************************************************************
+ * MCI_MapMsg16To32W [internal]
+ */
+static WINMM_MapType MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD* lParam)
+{
+ if (*lParam == 0)
+ return WINMM_MAP_OK;
+ /* FIXME: to add also (with seg/linear modifications to do):
+ * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
+ * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
+ */
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CONFIGURE:
+ case MCI_COPY:
+ case MCI_CUE:
+ case MCI_CUT:
+ case MCI_DELETE:
+ case MCI_FREEZE:
+ case MCI_GETDEVCAPS:
+ /* case MCI_INDEX: */
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_PASTE:
+ case MCI_PAUSE:
+ case MCI_PLAY:
+ case MCI_PUT:
+ case MCI_REALIZE:
+ case MCI_RECORD:
+ case MCI_RESUME:
+ case MCI_SEEK:
+ case MCI_SET:
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ case MCI_STATUS: /* FIXME: is wrong for digital video */
+ case MCI_STEP:
+ case MCI_STOP:
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ case MCI_UPDATE:
+ case MCI_WHERE:
+ *lParam = (DWORD)MapSL(*lParam);
+ return WINMM_MAP_OK;
+ case MCI_WINDOW:
+ /* in fact, I would also need the dwFlags... to see
+ * which members of lParam are effectively used
+ */
+ *lParam = (DWORD)MapSL(*lParam);
+ FIXME("Current mapping may be wrong\n");
+ break;
+ case MCI_BREAK:
+ {
+ LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
+ LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
+
+ if (mbp32) {
+ mbp32->dwCallback = mbp16->dwCallback;
+ mbp32->nVirtKey = mbp16->nVirtKey;
+ mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mbp32;
+ }
+ return WINMM_MAP_OKMEM;
+ case MCI_ESCAPE:
+ {
+ LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
+ LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
+
+ if (mvep32w) {
+ mvep32w->dwCallback = mvep16->dwCallback;
+ mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mvep32w;
+ }
+ return WINMM_MAP_OKMEM;
+ case MCI_INFO:
+ {
+ LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
+ LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
+
+ /* FIXME this is wrong if device is of type
+ * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
+ */
+ if (mip32w) {
+ *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
+ mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
+ mip32w->dwCallback = mip16->dwCallback;
+ mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
+ mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mip32w;
+ }
+ return WINMM_MAP_OKMEM;
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ {
+ LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
+ LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
+
+ if (mop32w) {
+ *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
+ mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
+ mop32w->dwCallback = mop16->dwCallback;
+ mop32w->wDeviceID = mop16->wDeviceID;
+ mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
+ mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
+ mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
+ /* copy extended information if any...
+ * FIXME: this may seg fault if initial structure does not contain them and
+ * the reads after msip16 fail under LDT limits...
+ * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
+ * should not take care of extended parameters, and should be used by MCI_Open
+ * to fetch uDevType. When, this is known, the mapping for sending the
+ * MCI_OPEN_DRIVER shall be done depending on uDevType.
+ */
+ memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mop32w;
+ }
+ return WINMM_MAP_OKMEM;
+ case MCI_SYSINFO:
+ {
+ LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
+ LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
+
+ if (msip32w) {
+ *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
+ msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
+ msip32w->dwCallback = msip16->dwCallback;
+ msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
+ msip32w->dwRetSize = msip16->dwRetSize;
+ msip32w->dwNumber = msip16->dwNumber;
+ msip32w->wDeviceType = msip16->wDeviceType;
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)msip32w;
+ }
+ return WINMM_MAP_OKMEM;
+ case MCI_SOUND:
+ {
+ LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
+ LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
+
+ if (mbp32) {
+ mbp32->dwCallback = mbp16->dwCallback;
+ mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mbp32;
+ }
+ return WINMM_MAP_OKMEM;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME("This is a hack\n");
+ return WINMM_MAP_OK;
+ default:
+ FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
+ }
+ return WINMM_MAP_MSGERROR;
+}
+
+/**************************************************************************
+ * MCI_UnMapMsg16To32W [internal]
+ */
+static WINMM_MapType MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD lParam)
+{
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CONFIGURE:
+ case MCI_COPY:
+ case MCI_CUE:
+ case MCI_CUT:
+ case MCI_DELETE:
+ case MCI_FREEZE:
+ case MCI_GETDEVCAPS:
+ /* case MCI_INDEX: */
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_PASTE:
+ case MCI_PAUSE:
+ case MCI_PLAY:
+ case MCI_PUT:
+ case MCI_REALIZE:
+ case MCI_RECORD:
+ case MCI_RESUME:
+ case MCI_SEEK:
+ case MCI_SET:
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ case MCI_STATUS:
+ case MCI_STEP:
+ case MCI_STOP:
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ case MCI_UPDATE:
+ case MCI_WHERE:
+ return WINMM_MAP_OK;
+
+ case MCI_WINDOW:
+ /* FIXME ?? see Map function */
+ return WINMM_MAP_OK;
+
+ case MCI_BREAK:
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ return WINMM_MAP_OK;
+ case MCI_ESCAPE:
+ if (lParam) {
+ LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
+ HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return WINMM_MAP_OK;
+ case MCI_INFO:
+ if (lParam) {
+ LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
+ LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
+
+ WideCharToMultiByte(CP_ACP, 0,
+ mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
+ MapSL(mip16->lpstrReturn), mip16->dwRetSize,
+ NULL, NULL);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return WINMM_MAP_OK;
+ case MCI_SYSINFO:
+ if (lParam) {
+ LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
+ LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
+
+ WideCharToMultiByte(CP_ACP, 0,
+ msip32w->lpstrReturn, msip32w->dwRetSize,
+ MapSL(msip16->lpstrReturn), msip16->dwRetSize,
+ NULL, NULL);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return WINMM_MAP_OK;
+ case MCI_SOUND:
+ if (lParam) {
+ LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
+ HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return WINMM_MAP_OK;
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ if (lParam) {
+ LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
+ LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
+
+ mop16->wDeviceID = mop32w->wDeviceID;
+ HeapFree(GetProcessHeap(), 0, mop32w->lpstrDeviceType);
+ HeapFree(GetProcessHeap(), 0, mop32w->lpstrElementName);
+ HeapFree(GetProcessHeap(), 0, mop32w->lpstrAlias);
+ if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
+ FIXME("bad free line=%d\n", __LINE__);
+ }
+ return WINMM_MAP_OK;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME("This is a hack\n");
+ return WINMM_MAP_OK;
+ default:
+ FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
+ }
+ return WINMM_MAP_MSGERROR;
+}
+
+/*
+ * 0000 stop
+ * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
+ * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
+ * 0100
+ * 0101
+ * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
+ * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
+ * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
+ */
+
+/**************************************************************************
+ * MCI_MsgMapper32WTo16_Create [internal]
+ *
+ * Helper for MCI_MapMsg32WTo16.
+ * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
+ * segmented pointer.
+ * map contains a list of action to be performed for the mapping (see list
+ * above)
+ * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
+ */
+static WINMM_MapType MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
+{
+ void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
+ LPBYTE p16, p32;
+
+ if (!lp) {
+ return WINMM_MAP_NOMEM;
+ }
+ p32 = (LPBYTE)(*ptr);
+ if (keep) {
+ *(void**)lp = *ptr;
+ p16 = (LPBYTE)lp + sizeof(void**);
+ *ptr = (char*)MapLS(lp) + sizeof(void**);
+ } else {
+ p16 = lp;
+ *ptr = (void*)MapLS(lp);
+ }
+
+ if (map == 0) {
+ memcpy(p16, p32, size16);
+ } else {
+ unsigned nibble;
+ unsigned sz;
+
+ while (map & 0xF) {
+ nibble = map & 0xF;
+ if (nibble & 0x8) {
+ sz = (nibble & 7) + 1;
+ memcpy(p16, p32, sz);
+ p16 += sz;
+ p32 += sz;
+ size16 -= sz; /* DEBUG only */
+ } else {
+ switch (nibble) {
+ case 0x1:
+ *(LPINT16)p16 = *(LPINT)p32;
+ p16 += sizeof(INT16);
+ p32 += sizeof(INT);
+ size16 -= sizeof(INT16);
+ break;
+ case 0x2:
+ *(LPUINT16)p16 = *(LPUINT)p32;
+ p16 += sizeof(UINT16);
+ p32 += sizeof(UINT);
+ size16 -= sizeof(UINT16);
+ break;
+ case 0x6:
+ *(LPDWORD)p16 = 0;
+ p16 += sizeof(DWORD);
+ p32 += sizeof(DWORD);
+ size16 -= sizeof(DWORD);
+ break;
+ case 0x7:
+ *(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) );
+ p16 += sizeof(SEGPTR);
+ p32 += sizeof(LPSTR);
+ size16 -= sizeof(SEGPTR);
+ break;
+ default:
+ FIXME("Unknown nibble for mapping (%x)\n", nibble);
+ }
+ }
+ map >>= 4;
+ }
+ if (size16 != 0) /* DEBUG only */
+ FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
+ }
+ return WINMM_MAP_OKMEM;
+}
+
+/**************************************************************************
+ * MCI_MsgMapper32WTo16_Destroy [internal]
+ *
+ * Helper for MCI_UnMapMsg32WTo16.
+ */
+static WINMM_MapType MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
+{
+ if (ptr) {
+ void* msg16 = MapSL((SEGPTR)ptr);
+ void* alloc;
+ LPBYTE p32, p16;
+ unsigned nibble;
+
+ UnMapLS( (SEGPTR)ptr );
+ if (kept) {
+ alloc = (char*)msg16 - sizeof(void**);
+ p32 = *(void**)alloc;
+ p16 = msg16;
+
+ if (map == 0) {
+ memcpy(p32, p16, size16);
+ } else {
+ while (map & 0xF) {
+ nibble = map & 0xF;
+ if (nibble & 0x8) {
+ memcpy(p32, p16, (nibble & 7) + 1);
+ p16 += (nibble & 7) + 1;
+ p32 += (nibble & 7) + 1;
+ size16 -= (nibble & 7) + 1;
+ } else {
+ switch (nibble) {
+ case 0x1:
+ *(LPINT)p32 = *(LPINT16)p16;
+ p16 += sizeof(INT16);
+ p32 += sizeof(INT);
+ size16 -= sizeof(INT16);
+ break;
+ case 0x2:
+ *(LPUINT)p32 = *(LPUINT16)p16;
+ p16 += sizeof(UINT16);
+ p32 += sizeof(UINT);
+ size16 -= sizeof(UINT16);
+ break;
+ case 0x6:
+ p16 += sizeof(UINT);
+ p32 += sizeof(UINT);
+ size16 -= sizeof(UINT);
+ break;
+ case 0x7:
+ HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16));
+ UnMapLS( *(SEGPTR *)p16 );
+ p16 += sizeof(SEGPTR);
+ p32 += sizeof(char*);
+ size16 -= sizeof(SEGPTR);
+ break;
+ default:
+ FIXME("Unknown nibble for mapping (%x)\n", nibble);
+ }
+ }
+ map >>= 4;
+ }
+ if (size16 != 0) /* DEBUG only */
+ FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
+ }
+ } else {
+ alloc = msg16;
+ }
+
+ HeapFree( GetProcessHeap(), 0, alloc );
+ }
+ return WINMM_MAP_OK;
+}
+
+/**************************************************************************
+ * MCI_MapMsg32WTo16 [internal]
+ *
+ * Map a 32W bit MCI message to a 16 bit MCI message.
+ */
+static WINMM_MapType MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
+{
+ int size;
+ BOOLEAN keep = FALSE;
+ DWORD map = 0;
+
+ if (*lParam == 0)
+ return WINMM_MAP_OK;
+
+ /* FIXME: to add also (with seg/linear modifications to do):
+ * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
+ * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
+ */
+ switch (wMsg) {
+ case MCI_BREAK:
+ size = sizeof(MCI_BREAK_PARMS);
+ break;
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CONFIGURE:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ /* case MCI_COPY: */
+ case MCI_CUE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ /* case MCI_CUT:*/
+ case MCI_DELETE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
+ case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ /* case MCI_ESCAPE: */
+ case MCI_FREEZE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_GETDEVCAPS:
+ keep = TRUE;
+ size = sizeof(MCI_GETDEVCAPS_PARMS);
+ break;
+ /* case MCI_INDEX: */
+ case MCI_INFO:
+ {
+ LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)(*lParam);
+ char* ptr;
+ LPMCI_INFO_PARMS16 mip16;
+
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
+ default: size = sizeof(MCI_INFO_PARMS16); break;
+ }
+ ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size);
+ if (ptr)
+ {
+ *(LPMCI_INFO_PARMSW*)ptr = mip32w;
+ mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW));
+ mip16->dwCallback = mip32w->dwCallback;
+ mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) );
+ mip16->dwRetSize = mip32w->dwRetSize / sizeof(WCHAR);
+ if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
+ ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem;
+ }
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW);
+ }
+ return WINMM_MAP_OKMEM;
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ {
+ LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)(*lParam);
+ char* ptr = HeapAlloc( GetProcessHeap(), 0,
+ sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
+ LPMCI_OPEN_PARMS16 mop16;
+
+
+ if (ptr) {
+ *(LPMCI_OPEN_PARMSW*)(ptr) = mop32w;
+ mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW));
+ mop16->dwCallback = mop32w->dwCallback;
+ mop16->wDeviceID = mop32w->wDeviceID;
+ if (dwFlags & MCI_OPEN_TYPE) {
+ if (dwFlags & MCI_OPEN_TYPE_ID) {
+ /* dword "transparent" value */
+ mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType;
+ } else {
+ /* string */
+ mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) );
+ }
+ } else {
+ /* nuthin' */
+ mop16->lpstrDeviceType = 0;
+ }
+ if (dwFlags & MCI_OPEN_ELEMENT) {
+ if (dwFlags & MCI_OPEN_ELEMENT_ID) {
+ mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName;
+ } else {
+ mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) );
+ }
+ } else {
+ mop16->lpstrElementName = 0;
+ }
+ if (dwFlags & MCI_OPEN_ALIAS) {
+ mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) );
+ } else {
+ mop16->lpstrAlias = 0;
+ }
+ /* copy extended information if any...
+ * FIXME: this may seg fault if initial structure does not contain them and
+ * the reads after msip16 fail under LDT limits...
+ * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
+ * should not take care of extended parameters, and should be used by MCI_Open
+ * to fetch uDevType. When, this is known, the mapping for sending the
+ * MCI_OPEN_DRIVER shall be done depending on uDevType.
+ */
+ memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD));
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW);
+ }
+ return WINMM_MAP_OKMEM;
+ /* case MCI_PASTE:*/
+ case MCI_PAUSE:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ case MCI_PLAY:
+ size = sizeof(MCI_PLAY_PARMS);
+ break;
+ case MCI_PUT:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_REALIZE:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ case MCI_RECORD:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ default: size = sizeof(MCI_RECORD_PARMS); break;
+ }
+ break;
+ case MCI_RESUME:
+ size = sizeof(MCI_GENERIC_PARMS);
+ break;
+ case MCI_SEEK:
+ switch (uDevType) {
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ default: size = sizeof(MCI_SEEK_PARMS); break;
+ }
+ break;
+ case MCI_SET:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
+ /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
+ * so not doing anything should work...
+ */
+ case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
+ default: size = sizeof(MCI_SET_PARMS); break;
+ }
+ break;
+ case MCI_SETAUDIO:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ /* case MCI_SOUND:*/
+ case MCI_SPIN:
+ size = sizeof(MCI_SET_PARMS);
+ break;
+ case MCI_STATUS:
+ keep = TRUE;
+ switch (uDevType) {
+ /* FIXME:
+ * don't know if buffer for value is the one passed through lpstrDevice
+ * or is provided by MCI driver.
+ * Assuming solution 2: provided by MCI driver, so zeroing on entry
+ */
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ default: size = sizeof(MCI_STATUS_PARMS); break;
+ }
+ break;
+ case MCI_STEP:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_STOP:
+ size = sizeof(MCI_SET_PARMS);
+ break;
+ case MCI_SYSINFO:
+ {
+ LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam);
+ LPMCI_SYSINFO_PARMS16 msip16;
+ char* ptr = HeapAlloc( GetProcessHeap(), 0,
+ sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) );
+
+ if (ptr) {
+ *(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w;
+ msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW));
+
+ msip16->dwCallback = msip32w->dwCallback;
+ msip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) );
+ msip16->dwRetSize = msip32w->dwRetSize;
+ msip16->dwNumber = msip32w->dwNumber;
+ msip16->wDeviceType = msip32w->wDeviceType;
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW);
+ }
+ return WINMM_MAP_OKMEM;
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_UPDATE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_WHERE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case MCI_WINDOW:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
+ default: size = sizeof(MCI_GENERIC_PARMS); break;
+ }
+ break;
+ case DRV_OPEN:
+ {
+ LPMCI_OPEN_DRIVER_PARMSW modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam);
+ LPMCI_OPEN_DRIVER_PARMS16 modp16;
+ char *ptr = HeapAlloc( GetProcessHeap(), 0,
+ sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16));
+
+ if (ptr) {
+ *(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w;
+ modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW));
+ modp16->wDeviceID = modp32w->wDeviceID;
+ modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) );
+ /* other fields are gonna be filled by the driver, don't copy them */
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW);
+ }
+ return WINMM_MAP_OKMEM;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ return WINMM_MAP_OK;
+
+ default:
+ FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
+ return WINMM_MAP_MSGERROR;
+ }
+ return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep);
+}
+
+/**************************************************************************
+ * MCI_UnMapMsg32WTo16 [internal]
+ */
+static WINMM_MapType MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
+{
+ int size = 0;
+ BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
+ DWORD map = 0;
+
+ switch (wMsg) {
+ case MCI_BREAK:
+ break;
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CONFIGURE:
+ break;
+ /* case MCI_COPY: */
+ case MCI_CUE:
+ break;
+ /* case MCI_CUT: */
+ case MCI_DELETE:
+ break;
+ /* case MCI_ESCAPE: */
+ case MCI_FREEZE:
+ break;
+ case MCI_GETDEVCAPS:
+ kept = TRUE;
+ size = sizeof(MCI_GETDEVCAPS_PARMS);
+ break;
+ /* case MCI_INDEX: */
+ case MCI_INFO:
+ if (lParam) {
+ LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam);
+ LPMCI_INFO_PARMSW mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW));
+
+ MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize,
+ mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR));
+ UnMapLS( lParam );
+ UnMapLS( mip16->lpstrReturn );
+ HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) );
+ HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) );
+ }
+ return WINMM_MAP_OK;
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ if (lParam) {
+ LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam);
+ LPMCI_OPEN_PARMSW mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW));
+ UnMapLS( lParam );
+ mop32w->wDeviceID = mop16->wDeviceID;
+ if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
+ {
+ HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType));
+ UnMapLS( mop16->lpstrDeviceType );
+ }
+ if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
+ {
+ HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName));
+ UnMapLS( mop16->lpstrElementName );
+ }
+ if (dwFlags & MCI_OPEN_ALIAS)
+ {
+ HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias));
+ UnMapLS( mop16->lpstrAlias );
+ }
+ HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) );
+ }
+ return WINMM_MAP_OK;
+ /* case MCI_PASTE:*/
+ case MCI_PAUSE:
+ break;
+ case MCI_PLAY:
+ break;
+ case MCI_PUT:
+ break;
+ case MCI_REALIZE:
+ break;
+ case MCI_RECORD:
+ break;
+ case MCI_RESUME:
+ break;
+ case MCI_SEEK:
+ break;
+ case MCI_SET:
+ break;
+ case MCI_SETAUDIO:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ }
+ break;
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ /* case MCI_SOUND:*/
+ case MCI_SPIN:
+ break;
+ case MCI_STATUS:
+ kept = TRUE;
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO:
+ if (lParam) {
+ LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
+ LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
+
+ UnMapLS( lParam );
+ if (mdsp16) {
+ mdsp32a->dwReturn = mdsp16->dwReturn;
+ if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
+ TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
+ TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
+ UnMapLS( mdsp16->lpstrDrive );
+ }
+ HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ }
+ return WINMM_MAP_OKMEM;
+ case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
+ default: size = sizeof(MCI_STATUS_PARMS); break;
+ }
+ break;
+ case MCI_STEP:
+ break;
+ case MCI_STOP:
+ break;
+ case MCI_SYSINFO:
+ if (lParam) {
+ LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
+ LPMCI_SYSINFO_PARMSW msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW));
+
+ UnMapLS( lParam );
+ if (msip16) {
+ MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize,
+ msip32w->lpstrReturn, msip32w->dwRetSize);
+ UnMapLS( msip16->lpstrReturn );
+ HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) );
+ HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) );
+ } else {
+ return WINMM_MAP_NOMEM;
+ }
+ }
+ return WINMM_MAP_OKMEM;
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ break;
+ case MCI_UPDATE:
+ break;
+ case MCI_WHERE:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
+ default: break;
+ }
+ break;
+ case MCI_WINDOW:
+ switch (uDevType) {
+ case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
+ case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
+ default: break;
+ }
+ /* FIXME: see map function */
+ break;
+ case DRV_OPEN:
+ if (lParam) {
+ LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
+ LPMCI_OPEN_DRIVER_PARMSW modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW));
+
+ UnMapLS( lParam );
+ modp32w->wCustomCommandTable = modp16->wCustomCommandTable;
+ modp32w->wType = modp16->wType;
+ HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams));
+ UnMapLS( modp16->lpstrParams );
+ HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) );
+ }
+ return WINMM_MAP_OK;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME("This is a hack\n");
+ return WINMM_MAP_OK;
+
+ default:
+ FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
+ return WINMM_MAP_MSGERROR;
+ }
+ return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept);
}
void MMDRV_Init16(void)
{
#define A(_x,_y) MMDRV_InstallMap(_x, \
-MMDRV_##_y##_Map16To32A, MMDRV_##_y##_UnMap16To32A, \
-MMDRV_##_y##_Map32ATo16, MMDRV_##_y##_UnMap32ATo16, \
+MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \
+MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \
MMDRV_##_y##_Callback)
A(MMDRV_AUX, Aux);
A(MMDRV_MIXER, Mixer);
@@ -2794,8 +3521,8 @@
pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
- pFnMciMapMsg16To32A = MCI_MapMsg16To32A;
- pFnMciUnMapMsg16To32A = MCI_UnMapMsg16To32A;
- pFnMciMapMsg32ATo16 = MCI_MapMsg32ATo16;
- pFnMciUnMapMsg32ATo16 = MCI_UnMapMsg32ATo16;
+ pFnMciMapMsg16To32W = MCI_MapMsg16To32W;
+ pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W;
+ pFnMciMapMsg32WTo16 = MCI_MapMsg32WTo16;
+ pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16;
}
diff --git a/dlls/winmm/mmio.c b/dlls/winmm/mmio.c
index 673ed39..ba44606 100644
--- a/dlls/winmm/mmio.c
+++ b/dlls/winmm/mmio.c
@@ -1,4 +1,3 @@
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* MMIO functions
*
@@ -221,8 +220,6 @@
FIXME("unexpected message %u\n", uMessage);
return 0;
}
-
- return 0;
}
/* This array will be the entire list for most apps
@@ -1351,7 +1348,7 @@
/* FIXME: should we actually pass lpmmioinfo down the drain ???
* or make a copy of it because it's const ???
*/
- return send_message(ioProc, (LPMMIOINFO)lpmmioinfo, MMIOM_RENAME,
+ return send_message(ioProc, (MMIOINFO*)lpmmioinfo, MMIOM_RENAME,
(LPARAM)szFileName, (LPARAM)szNewFileName, MMIO_PROC_32A);
}
diff --git a/dlls/winmm/mmsystem.c b/dlls/winmm/mmsystem.c
index 02e34c0..3fd754f 100644
--- a/dlls/winmm/mmsystem.c
+++ b/dlls/winmm/mmsystem.c
@@ -48,7 +48,7 @@
WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16);
-static LPWINE_DRIVER DRIVER_OpenDriver16(LPCSTR, LPCSTR, LPARAM);
+static LPWINE_DRIVER DRIVER_OpenDriver16(LPCWSTR, LPCWSTR, LPARAM);
static LRESULT DRIVER_CloseDriver16(HDRVR16, LPARAM, LPARAM);
static LRESULT DRIVER_SendMessage16(HDRVR16, UINT, LPARAM, LPARAM);
static LRESULT MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM);
@@ -597,7 +597,7 @@
{
TRACE("(\"%s\")\n", lpstrName);
- return MCI_GetDriverFromString(lpstrName);
+ return mciGetDeviceIDA(lpstrName);
}
/**************************************************************************
@@ -731,6 +731,7 @@
/**************************************************************************
* midiOutGetErrorText [MMSYSTEM.203]
+ * midiInGetErrorText [MMSYSTEM.203]
*/
UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
{
@@ -949,14 +950,6 @@
}
/**************************************************************************
- * midiInGetErrorText [MMSYSTEM.303]
- */
-UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
-{
- return midiInGetErrorTextA(uError, lpText, uSize);
-}
-
-/**************************************************************************
* midiInOpen [MMSYSTEM.304]
*/
UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
@@ -1238,6 +1231,7 @@
/**************************************************************************
* waveOutGetErrorText [MMSYSTEM.403]
+ * waveInGetErrorText [MMSYSTEM.403]
*/
UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
{
@@ -1536,14 +1530,6 @@
}
/**************************************************************************
- * waveInGetErrorText [MMSYSTEM.503]
- */
-UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
-{
- return waveInGetErrorTextA(uError, lpText, uSize);
-}
-
-/**************************************************************************
* waveInOpen [MMSYSTEM.504]
*/
UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
@@ -2371,30 +2357,52 @@
*
* Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
*/
-static LPWINE_DRIVER DRIVER_OpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
+static LPWINE_DRIVER DRIVER_OpenDriver16(LPCWSTR fn, LPCWSTR sn, LPARAM lParam2)
{
LPWINE_DRIVER lpDrv = NULL;
- LPCSTR cause = 0;
+ LPCSTR cause = NULL;
+ LPSTR fnA = NULL, snA = NULL;
+ unsigned len;
- TRACE("(%s, %08lX);\n", debugstr_a(sn), lParam2);
+ TRACE("(%s, %s, %08lX);\n", debugstr_w(fn), debugstr_w(sn), lParam2);
lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
if (lpDrv == NULL) {cause = "OOM"; goto exit;}
+ if (fn)
+ {
+ len = WideCharToMultiByte( CP_ACP, 0, fn, -1, NULL, 0, NULL, NULL );
+ fnA = HeapAlloc(GetProcessHeap(), 0, len);
+ if (fnA == NULL) {cause = "OOM"; goto exit;}
+ WideCharToMultiByte( CP_ACP, 0, fn, -1, fnA, len, NULL, NULL );
+ }
+
+ if (sn)
+ {
+ len = WideCharToMultiByte( CP_ACP, 0, sn, -1, NULL, 0, NULL, NULL );
+ snA = HeapAlloc(GetProcessHeap(), 0, len);
+ if (snA == NULL) {cause = "OOM"; goto exit;}
+ WideCharToMultiByte( CP_ACP, 0, sn, -1, snA, len, NULL, NULL );
+ }
+
/* FIXME: shall we do some black magic here on sn ?
* drivers32 => drivers
* mci32 => mci
* ...
*/
- lpDrv->d.d16.hDriver16 = OpenDriver16(fn, sn, lParam2);
+ lpDrv->d.d16.hDriver16 = OpenDriver16(fnA, snA, lParam2);
if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
lpDrv->dwFlags = WINE_GDF_16BIT;
TRACE("=> %p\n", lpDrv);
return lpDrv;
- exit:
+
+exit:
HeapFree(GetProcessHeap(), 0, lpDrv);
- TRACE("Unable to load 16 bit module %s: %s\n", debugstr_a(fn), cause);
+ HeapFree(GetProcessHeap(), 0, fnA);
+ HeapFree(GetProcessHeap(), 0, snA);
+ TRACE("Unable to load 16 bit module %s[%s]: %s\n",
+ debugstr_w(fn), debugstr_w(sn), cause);
return NULL;
}
@@ -2612,15 +2620,45 @@
*/
UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
{
- HRSRC16 res;
- HGLOBAL16 handle;
- void *ptr;
+ HRSRC16 res;
+ HGLOBAL16 handle;
+ const BYTE* ptr16;
+ BYTE* ptr32;
+ unsigned pos = 0, size = 1024, len;
+ const char* str;
+ DWORD flg;
+ WORD eid;
+ UINT16 ret = MCIERR_OUT_OF_MEMORY;
if (!(res = FindResource16( hInst, resname, (LPSTR)RT_RCDATA))) return MCI_NO_COMMAND_TABLE;
if (!(handle = LoadResource16( hInst, res ))) return MCI_NO_COMMAND_TABLE;
- ptr = LockResource16(handle);
- return MCI_SetCommandTable(ptr, type);
- /* FIXME: FreeResource */
+ ptr16 = LockResource16(handle);
+ /* converting the 16 bit resource table into a 32W one */
+ if ((ptr32 = HeapAlloc(GetProcessHeap(), 0, size)))
+ {
+ do {
+ str = (LPCSTR)ptr16;
+ ptr16 += strlen(str) + 1;
+ flg = *(const DWORD*)ptr16;
+ eid = *(const WORD*)(ptr16 + sizeof(DWORD));
+ ptr16 += sizeof(DWORD) + sizeof(WORD);
+ len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0) * sizeof(WCHAR);
+ if (pos + len + sizeof(DWORD) + sizeof(WORD) > size)
+ {
+ while (pos + len * sizeof(WCHAR) + sizeof(DWORD) + sizeof(WORD) > size) size += 1024;
+ ptr32 = HeapReAlloc(GetProcessHeap(), 0, ptr32, size);
+ if (!ptr32) goto the_end;
+ }
+ MultiByteToWideChar(CP_ACP, 0, str, -1, (LPWSTR)(ptr32 + pos), len / sizeof(WCHAR));
+ *(DWORD*)(ptr32 + pos + len) = flg;
+ *(WORD*)(ptr32 + pos + len + sizeof(DWORD)) = eid;
+ pos += len + sizeof(DWORD) + sizeof(WORD);
+ } while (eid != MCI_END_COMMAND_LIST);
+ }
+the_end:
+ FreeResource16( handle );
+ if (ptr32) ret = MCI_SetCommandTable(ptr32, type);
+ return ret;
}
/**************************************************************************
@@ -2630,7 +2668,7 @@
{
TRACE("(%04x)!\n", uTable);
- return mciFreeCommandResource(uTable);
+ return MCI_DeleteCommandTable(uTable, TRUE);
}
/* ###################################################
diff --git a/dlls/winmm/mmsystem.spec b/dlls/winmm/mmsystem.spec
index e260dd0..502f401 100644
--- a/dlls/winmm/mmsystem.spec
+++ b/dlls/winmm/mmsystem.spec
@@ -45,7 +45,7 @@
257 pascal midiStreamStop(word) midiStreamStop16
301 pascal midiInGetNumDevs() midiInGetNumDevs16
302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16
-303 pascal midiInGetErrorText(word ptr word) midiInGetErrorText16
+303 pascal midiInGetErrorText(word ptr word) midiOutGetErrorText16
304 pascal midiInOpen(ptr word long long long) midiInOpen16
305 pascal midiInClose(word) midiInClose16
306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16
@@ -84,7 +84,7 @@
421 pascal waveOutMessage(word word long long) waveOutMessage16
501 pascal waveInGetNumDevs() waveInGetNumDevs16
502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16
-503 pascal waveInGetErrorText(word ptr word) waveInGetErrorText16
+503 pascal waveInGetErrorText(word ptr word) waveOutGetErrorText16
504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16
505 pascal waveInClose(word) waveInClose16
506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16
diff --git a/dlls/winmm/winemm.h b/dlls/winmm/winemm.h
index 3c3741c..a558c76 100644
--- a/dlls/winmm/winemm.h
+++ b/dlls/winmm/winemm.h
@@ -87,7 +87,7 @@
typedef struct tagWINE_MM_DRIVER {
HDRVR hDriver;
LPSTR drvname; /* name of the driver */
- BOOL bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */
+ unsigned bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */
bIsMapper : 1; /* TRUE if mapper */
WINE_MM_DRIVER_PART parts[MMDRV_MAX];/* Information for all known types */
} WINE_MM_DRIVER, *LPWINE_MM_DRIVER;
@@ -139,9 +139,9 @@
typedef struct tagWINE_MCIDRIVER {
UINT wDeviceID;
UINT wType;
- LPSTR lpstrElementName;
- LPSTR lpstrDeviceType;
- LPSTR lpstrAlias;
+ LPWSTR lpstrElementName;
+ LPWSTR lpstrDeviceType;
+ LPWSTR lpstrAlias;
HDRVR hDriver;
DWORD dwPrivate;
YIELDPROC lpfnYieldProc;
@@ -181,14 +181,14 @@
MMIOINFO info;
struct tagWINE_MMIO* lpNext;
struct IOProcList* ioProc;
- BOOL bTmpIOProc : 1,
+ unsigned bTmpIOProc : 1,
bBufferLoaded : 1;
DWORD segBuffer16;
DWORD dwFileSize;
} WINE_MMIO, *LPWINE_MMIO;
typedef struct tagWINE_PLAYSOUND {
- BOOL bLoop : 1,
+ unsigned bLoop : 1,
bAlloc : 1;
LPCWSTR pszSound;
HMODULE hMod;
@@ -223,8 +223,8 @@
typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT ret);
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr);
-BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz);
-LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2);
+BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz);
+LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2);
void DRIVER_UnloadAll(void);
BOOL MMDRV_Init(void);
@@ -244,15 +244,18 @@
MMDRV_MAPFUNC, MMDRV_UNMAPFUNC, LPDRVCALLBACK);
WINE_MCIDRIVER* MCI_GetDriver(UINT16 uDevID);
-UINT MCI_GetDriverFromString(LPCSTR str);
-DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr);
-const char* MCI_MessageToString(UINT16 wMsg);
+UINT MCI_GetDriverFromString(LPCWSTR str);
+DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr);
+const char* MCI_MessageToString(UINT wMsg);
UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data);
LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2);
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32);
DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
UINT MCI_SetCommandTable(void *table, UINT uDevType);
+BOOL MCI_DeleteCommandTable(UINT uTbl, BOOL delete);
+LPWSTR MCI_strdupAtoW(LPCSTR str);
+LPSTR MCI_strdupWtoA(LPCWSTR str);
BOOL WINMM_CheckForMMSystem(void);
const char* WINMM_ErrorToString(MMRESULT error);
@@ -290,13 +293,13 @@
* NULL otherwise
*/
extern WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16);
-extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM);
+extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM);
extern LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM);
extern LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM);
-extern WINMM_MapType (*pFnMciMapMsg16To32A)(WORD,WORD,DWORD*);
-extern WINMM_MapType (*pFnMciUnMapMsg16To32A)(WORD,WORD,DWORD);
-extern WINMM_MapType (*pFnMciMapMsg32ATo16)(WORD,WORD,DWORD,DWORD*);
-extern WINMM_MapType (*pFnMciUnMapMsg32ATo16)(WORD,WORD,DWORD,DWORD);
+extern WINMM_MapType (*pFnMciMapMsg16To32W)(WORD,WORD,DWORD*);
+extern WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD);
+extern WINMM_MapType (*pFnMciMapMsg32WTo16)(WORD,WORD,DWORD,DWORD*);
+extern WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD);
extern LRESULT (*pFnCallMMDrvFunc16)(DWORD /* in fact FARPROC16 */,WORD,WORD,LONG,LONG,LONG);
extern unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER);
extern LRESULT (*pFnMmioCallback16)(DWORD,LPMMIOINFO,UINT,LPARAM,LPARAM);
diff --git a/dlls/winmm/winmm.c b/dlls/winmm/winmm.c
index 69ca68f..5c2f3a7 100644
--- a/dlls/winmm/winmm.c
+++ b/dlls/winmm/winmm.c
@@ -53,27 +53,11 @@
#include "winreg.h"
#include "winternl.h"
#include "winemm.h"
-#include "wownt32.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
-/******************************************************************
- * MyUserYield
- *
- * Internal wrapper to call USER.UserYield16 (in fact through a Wine only export from USER32).
- */
-static void MyUserYield(void)
-{
- HMODULE mod = GetModuleHandleA( "user32.dll" );
- if (mod)
- {
- FARPROC proc = GetProcAddress( mod, "UserYield16" );
- if (proc) proc();
- }
-}
-
void (WINAPI *pFnReleaseThunkLock)(DWORD*);
void (WINAPI *pFnRestoreThunkLock)(DWORD);
@@ -776,469 +760,6 @@
}
/**************************************************************************
- * mciGetErrorStringW [WINMM.@]
- */
-BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
-{
- char bufstr[MAXERRORLENGTH];
- BOOL ret = mciGetErrorStringA(wError, bufstr, MAXERRORLENGTH);
-
- MultiByteToWideChar( CP_ACP, 0, bufstr, -1, lpstrBuffer, uLength );
- return ret;
-}
-
-/**************************************************************************
- * mciGetErrorStringA [WINMM.@]
- */
-BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
-{
- BOOL ret = FALSE;
-
- if (lpstrBuffer != NULL && uLength > 0 &&
- dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) {
-
- if (LoadStringA(WINMM_IData->hWinMM32Instance,
- dwError, lpstrBuffer, uLength) > 0) {
- ret = TRUE;
- }
- }
- return ret;
-}
-
-/**************************************************************************
- * mciDriverNotify [WINMM.@]
- */
-BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
-{
- TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
-
- return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
-}
-
-/**************************************************************************
- * mciGetDriverData [WINMM.@]
- */
-DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
-{
- LPWINE_MCIDRIVER wmd;
-
- TRACE("(%04x)\n", uDeviceID);
-
- wmd = MCI_GetDriver(uDeviceID);
-
- if (!wmd) {
- WARN("Bad uDeviceID\n");
- return 0L;
- }
-
- return wmd->dwPrivate;
-}
-
-/**************************************************************************
- * mciSetDriverData [WINMM.@]
- */
-BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data)
-{
- LPWINE_MCIDRIVER wmd;
-
- TRACE("(%04x, %08lx)\n", uDeviceID, data);
-
- wmd = MCI_GetDriver(uDeviceID);
-
- if (!wmd) {
- WARN("Bad uDeviceID\n");
- return FALSE;
- }
-
- wmd->dwPrivate = data;
- return TRUE;
-}
-
-/**************************************************************************
- * mciSendCommandA [WINMM.@]
- */
-DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- DWORD dwRet;
-
- TRACE("(%08x, %s, %08lx, %08lx)\n",
- wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
-
- dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE);
- dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2);
- TRACE("=> %08lx\n", dwRet);
- return dwRet;
-}
-
-inline static LPSTR strdupWtoA( LPCWSTR str )
-{
- LPSTR ret;
- INT len;
-
- if (!str) return NULL;
- len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
- ret = HeapAlloc( GetProcessHeap(), 0, len );
- if(ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
- return ret;
-}
-
-static int MCI_MapMsgWtoA(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
-{
- switch(msg)
- {
- case MCI_CLOSE:
- case MCI_PLAY:
- case MCI_SEEK:
- case MCI_STOP:
- case MCI_PAUSE:
- case MCI_GETDEVCAPS:
- case MCI_SPIN:
- case MCI_SET:
- case MCI_STEP:
- case MCI_RECORD:
- case MCI_BREAK:
- case MCI_SOUND:
- case MCI_STATUS:
- case MCI_CUE:
- case MCI_REALIZE:
- case MCI_PUT:
- case MCI_WHERE:
- case MCI_FREEZE:
- case MCI_UNFREEZE:
- case MCI_CUT:
- case MCI_COPY:
- case MCI_PASTE:
- case MCI_UPDATE:
- case MCI_RESUME:
- case MCI_DELETE:
- return 0;
-
- case MCI_OPEN:
- {
- MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)*dwParam2;
- MCI_OPEN_PARMSA *mci_openA;
- DWORD_PTR *ptr;
-
- ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_openA) + sizeof(DWORD_PTR));
- if (!ptr) return -1;
-
- *ptr++ = *dwParam2; /* save the previous pointer */
- *dwParam2 = (DWORD_PTR)ptr;
- mci_openA = (MCI_OPEN_PARMSA *)ptr;
-
- if (dwParam1 & MCI_NOTIFY)
- mci_openA->dwCallback = mci_openW->dwCallback;
-
- if (dwParam1 & MCI_OPEN_TYPE)
- {
- if (dwParam1 & MCI_OPEN_TYPE_ID)
- mci_openA->lpstrDeviceType = (LPSTR)mci_openW->lpstrDeviceType;
- else
- mci_openA->lpstrDeviceType = strdupWtoA(mci_openW->lpstrDeviceType);
- }
- if (dwParam1 & MCI_OPEN_ELEMENT)
- {
- if (dwParam1 & MCI_OPEN_ELEMENT_ID)
- mci_openA->lpstrElementName = (LPSTR)mci_openW->lpstrElementName;
- else
- mci_openA->lpstrElementName = strdupWtoA(mci_openW->lpstrElementName);
- }
- if (dwParam1 & MCI_OPEN_ALIAS)
- mci_openA->lpstrAlias = strdupWtoA(mci_openW->lpstrAlias);
- }
- return 1;
-
- case MCI_WINDOW:
- if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
- {
- MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)*dwParam2;
- MCI_ANIM_WINDOW_PARMSA *mci_windowA;
-
- mci_windowA = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowA));
- if (!mci_windowA) return -1;
-
- *dwParam2 = (DWORD_PTR)mci_windowA;
-
- mci_windowA->lpstrText = strdupWtoA(mci_windowW->lpstrText);
-
- if (dwParam1 & MCI_NOTIFY)
- mci_windowA->dwCallback = mci_windowW->dwCallback;
- if (dwParam1 & MCI_ANIM_WINDOW_HWND)
- mci_windowA->hWnd = mci_windowW->hWnd;
- if (dwParam1 & MCI_ANIM_WINDOW_STATE)
- mci_windowA->nCmdShow = mci_windowW->nCmdShow;
-
- return 1;
- }
- return 0;
-
- case MCI_SYSINFO:
- {
- MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)*dwParam2;
- MCI_SYSINFO_PARMSA *mci_sysinfoA;
- DWORD_PTR *ptr;
-
- ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoA) + sizeof(DWORD_PTR));
- if (!ptr) return -1;
-
- *ptr++ = *dwParam2; /* save the previous pointer */
- *dwParam2 = (DWORD_PTR)ptr;
- mci_sysinfoA = (MCI_SYSINFO_PARMSA *)ptr;
-
- if (dwParam1 & MCI_NOTIFY)
- mci_sysinfoA->dwCallback = mci_sysinfoW->dwCallback;
-
- mci_sysinfoA->dwRetSize = mci_sysinfoW->dwRetSize; /* FIXME */
- mci_sysinfoA->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoA->dwRetSize);
-
- return 1;
- }
-
- case MCI_INFO:
- case MCI_SAVE:
- case MCI_LOAD:
- case MCI_ESCAPE:
- default:
- FIXME("Message 0x%04x needs translation\n", msg);
- return -1;
- }
-}
-
-static DWORD MCI_UnmapMsgWtoA(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2,
- DWORD result)
-{
- switch(msg)
- {
- case MCI_OPEN:
- {
- DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
- MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)*ptr;
- MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)(ptr + 1);
-
- mci_openW->wDeviceID = mci_openA->wDeviceID;
-
- if (dwParam1 & MCI_OPEN_TYPE)
- {
- if (!(dwParam1 & MCI_OPEN_TYPE_ID))
- HeapFree(GetProcessHeap(), 0, mci_openA->lpstrDeviceType);
- }
- if (dwParam1 & MCI_OPEN_ELEMENT)
- {
- if (!(dwParam1 & MCI_OPEN_ELEMENT_ID))
- HeapFree(GetProcessHeap(), 0, mci_openA->lpstrElementName);
- }
- if (dwParam1 & MCI_OPEN_ALIAS)
- HeapFree(GetProcessHeap(), 0, mci_openA->lpstrAlias);
- HeapFree(GetProcessHeap(), 0, ptr);
- }
- break;
-
- case MCI_WINDOW:
- if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
- {
- MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)dwParam2;
-
- HeapFree(GetProcessHeap(), 0, (void *)mci_windowA->lpstrText);
- HeapFree(GetProcessHeap(), 0, mci_windowA);
- }
- break;
-
- case MCI_SYSINFO:
- {
- DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
- MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)*ptr;
- MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)(ptr + 1);
-
- if (!result)
- {
- mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber;
- mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType;
- MultiByteToWideChar(CP_ACP, 0,
- mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize,
- mci_sysinfoW->lpstrReturn, mci_sysinfoW->dwRetSize);
- }
-
- HeapFree(GetProcessHeap(), 0, mci_sysinfoA->lpstrReturn);
- HeapFree(GetProcessHeap(), 0, ptr);
- }
- break;
-
- default:
- FIXME("Message 0x%04x needs unmapping\n", msg);
- break;
- }
-
- return result;
-}
-
-
-/**************************************************************************
- * mciSendCommandW [WINMM.@]
- *
- * FIXME: we should do the things other way around, but since our
- * MM subsystem is not unicode aware...
- */
-DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- DWORD ret;
- int mapped;
-
- TRACE("(%08x, %s, %08lx, %08lx)\n",
- wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
-
- mapped = MCI_MapMsgWtoA(wMsg, dwParam1, &dwParam2);
- if (mapped == -1)
- {
- FIXME("message %04x mapping failed\n", wMsg);
- return MMSYSERR_NOMEM;
- }
- ret = mciSendCommandA(wDevID, wMsg, dwParam1, dwParam2);
- if (mapped)
- MCI_UnmapMsgWtoA(wMsg, dwParam1, dwParam2, ret);
- return ret;
-}
-
-/**************************************************************************
- * mciGetDeviceIDA [WINMM.@]
- */
-UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
-{
- return MCI_GetDriverFromString(lpstrName);
-}
-
-/**************************************************************************
- * mciGetDeviceIDW [WINMM.@]
- */
-UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
-{
- LPSTR lpstrName = NULL;
- UINT ret;
- INT len;
-
- if (lpwstrName) {
- len = WideCharToMultiByte( CP_ACP, 0, lpwstrName, -1, NULL, 0, NULL, NULL );
- lpstrName = HeapAlloc( GetProcessHeap(), 0, len );
- if (lpstrName) WideCharToMultiByte( CP_ACP, 0, lpwstrName, -1, lpstrName, len, NULL, NULL );
- }
- ret = MCI_GetDriverFromString(lpstrName);
- HeapFree(GetProcessHeap(), 0, lpstrName);
- return ret;
-}
-
-/**************************************************************************
- * MCI_DefYieldProc [internal]
- */
-UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
-{
- INT16 ret;
-
- TRACE("(0x%04x, 0x%08lx)\n", wDevID, data);
-
- if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
- (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
- MyUserYield();
- ret = 0;
- } else {
- MSG msg;
-
- msg.hwnd = HWND_32(HIWORD(data));
- while (!PeekMessageA(&msg, msg.hwnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
- ret = -1;
- }
- return ret;
-}
-
-/**************************************************************************
- * mciSetYieldProc [WINMM.@]
- */
-BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
-{
- LPWINE_MCIDRIVER wmd;
-
- TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
-
- if (!(wmd = MCI_GetDriver(uDeviceID))) {
- WARN("Bad uDeviceID\n");
- return FALSE;
- }
-
- wmd->lpfnYieldProc = fpYieldProc;
- wmd->dwYieldData = dwYieldData;
- wmd->bIs32 = TRUE;
-
- return TRUE;
-}
-
-/**************************************************************************
- * mciGetDeviceIDFromElementIDW [WINMM.@]
- */
-UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
-{
- /* FIXME: that's rather strange, there is no
- * mciGetDeviceIDFromElementID32A in winmm.spec
- */
- FIXME("(%lu, %p) stub\n", dwElementID, lpstrType);
- return 0;
-}
-
-/**************************************************************************
- * mciGetYieldProc [WINMM.@]
- */
-YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData)
-{
- LPWINE_MCIDRIVER wmd;
-
- TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
-
- if (!(wmd = MCI_GetDriver(uDeviceID))) {
- WARN("Bad uDeviceID\n");
- return NULL;
- }
- if (!wmd->lpfnYieldProc) {
- WARN("No proc set\n");
- return NULL;
- }
- if (!wmd->bIs32) {
- WARN("Proc is 32 bit\n");
- return NULL;
- }
- return wmd->lpfnYieldProc;
-}
-
-/**************************************************************************
- * mciGetCreatorTask [WINMM.@]
- */
-HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
-{
- LPWINE_MCIDRIVER wmd;
- HTASK ret = 0;
-
- if ((wmd = MCI_GetDriver(uDeviceID))) ret = (HTASK)wmd->CreatorThread;
-
- TRACE("(%u) => %p\n", uDeviceID, ret);
- return ret;
-}
-
-/**************************************************************************
- * mciDriverYield [WINMM.@]
- */
-UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
-{
- LPWINE_MCIDRIVER wmd;
- UINT ret = 0;
-
- TRACE("(%04x)\n", uDeviceID);
-
- if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || !wmd->bIs32) {
- MyUserYield();
- } else {
- ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
- }
-
- return ret;
-}
-
-/**************************************************************************
* midiOutGetNumDevs [WINMM.@]
*/
UINT WINAPI midiOutGetNumDevs(void)
@@ -1295,49 +816,50 @@
}
/**************************************************************************
- * MIDI_GetErrorText [internal]
+ * midiOutGetErrorTextA [WINMM.@]
+ * midiInGetErrorTextA [WINMM.@]
*/
-static UINT16 MIDI_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
+UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
{
- UINT16 ret = MMSYSERR_BADERRNUM;
+ UINT ret;
- if (lpText == NULL) {
- ret = MMSYSERR_INVALPARAM;
- } else if (uSize == 0) {
- ret = MMSYSERR_NOERROR;
- } else if (
- /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
- * a warning for the test was always true */
- (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
- (uError >= MIDIERR_BASE && uError <= MIDIERR_LASTERROR)) {
-
- if (LoadStringA(WINMM_IData->hWinMM32Instance,
- uError, lpText, uSize) > 0) {
- ret = MMSYSERR_NOERROR;
- }
+ if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
+ else if (uSize == 0) ret = MMSYSERR_NOERROR;
+ else
+ {
+ LPWSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR));
+ if (!xstr) ret = MMSYSERR_NOMEM;
+ else
+ {
+ ret = midiOutGetErrorTextW(uError, xstr, uSize);
+ if (ret == MMSYSERR_NOERROR)
+ WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL);
+ HeapFree(GetProcessHeap(), 0, xstr);
+ }
}
return ret;
}
/**************************************************************************
- * midiOutGetErrorTextA [WINMM.@]
- */
-UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
-{
- return MIDI_GetErrorText(uError, lpText, uSize);
-}
-
-/**************************************************************************
* midiOutGetErrorTextW [WINMM.@]
+ * midiInGetErrorTextW [WINMM.@]
*/
UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
{
- LPSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
- UINT ret;
+ UINT ret = MMSYSERR_BADERRNUM;
- ret = MIDI_GetErrorText(uError, xstr, uSize);
- MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
- HeapFree(GetProcessHeap(), 0, xstr);
+ if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
+ else if (uSize == 0) ret = MMSYSERR_NOERROR;
+ else if (
+ /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
+ * a warning for the test was always true */
+ (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
+ (uError >= MIDIERR_BASE && uError <= MIDIERR_LASTERROR)) {
+ if (LoadStringW(WINMM_IData->hWinMM32Instance,
+ uError, lpText, uSize) > 0) {
+ ret = MMSYSERR_NOERROR;
+ }
+ }
return ret;
}
@@ -1670,27 +1192,6 @@
return ret;
}
-/**************************************************************************
- * midiInGetErrorTextW [WINMM.@]
- */
-UINT WINAPI midiInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
-{
- LPSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
- UINT ret = MIDI_GetErrorText(uError, xstr, uSize);
-
- MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
- HeapFree(GetProcessHeap(), 0, xstr);
- return ret;
-}
-
-/**************************************************************************
- * midiInGetErrorTextA [WINMM.@]
- */
-UINT WINAPI midiInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
-{
- return MIDI_GetErrorText(uError, lpText, uSize);
-}
-
UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
{
@@ -2625,48 +2126,50 @@
}
/**************************************************************************
- * WAVE_GetErrorText [internal]
+ * waveOutGetErrorTextA [WINMM.@]
+ * waveInGetErrorTextA [WINMM.@]
*/
-static UINT16 WAVE_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
+UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
{
- UINT16 ret = MMSYSERR_BADERRNUM;
+ UINT ret;
- if (lpText == NULL) {
- ret = MMSYSERR_INVALPARAM;
- } else if (uSize == 0) {
- ret = MMSYSERR_NOERROR;
- } else if (
- /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
- * a warning for the test was always true */
- (/*uError >= MMSYSERR_BASE && */uError <= MMSYSERR_LASTERROR) ||
- (uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) {
-
- if (LoadStringA(WINMM_IData->hWinMM32Instance,
- uError, lpText, uSize) > 0) {
- ret = MMSYSERR_NOERROR;
- }
+ if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
+ else if (uSize == 0) ret = MMSYSERR_NOERROR;
+ else
+ {
+ LPWSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR));
+ if (!xstr) ret = MMSYSERR_NOMEM;
+ else
+ {
+ ret = waveOutGetErrorTextW(uError, xstr, uSize);
+ if (ret == MMSYSERR_NOERROR)
+ WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL);
+ HeapFree(GetProcessHeap(), 0, xstr);
+ }
}
return ret;
}
/**************************************************************************
- * waveOutGetErrorTextA [WINMM.@]
- */
-UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
-{
- return WAVE_GetErrorText(uError, lpText, uSize);
-}
-
-/**************************************************************************
* waveOutGetErrorTextW [WINMM.@]
+ * waveInGetErrorTextW [WINMM.@]
*/
UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
{
- LPSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
- UINT ret = WAVE_GetErrorText(uError, xstr, uSize);
+ UINT ret = MMSYSERR_BADERRNUM;
- MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
- HeapFree(GetProcessHeap(), 0, xstr);
+ if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
+ else if (uSize == 0) ret = MMSYSERR_NOERROR;
+ else if (
+ /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
+ * a warning for the test was always true */
+ (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
+ (uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) {
+ if (LoadStringW(WINMM_IData->hWinMM32Instance,
+ uError, lpText, uSize) > 0) {
+ ret = MMSYSERR_NOERROR;
+ }
+ }
return ret;
}
@@ -3037,27 +2540,6 @@
}
/**************************************************************************
- * waveInGetErrorTextA [WINMM.@]
- */
-UINT WINAPI waveInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
-{
- return WAVE_GetErrorText(uError, lpText, uSize);
-}
-
-/**************************************************************************
- * waveInGetErrorTextW [WINMM.@]
- */
-UINT WINAPI waveInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
-{
- LPSTR txt = HeapAlloc(GetProcessHeap(), 0, uSize);
- UINT ret = WAVE_GetErrorText(uError, txt, uSize);
-
- MultiByteToWideChar( CP_ACP, 0, txt, -1, lpText, uSize );
- HeapFree(GetProcessHeap(), 0, txt);
- return ret;
-}
-
-/**************************************************************************
* waveInOpen [WINMM.@]
*/
MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
diff --git a/dlls/winmm/winmm.spec b/dlls/winmm/winmm.spec
index 003d467..215296e 100644
--- a/dlls/winmm/winmm.spec
+++ b/dlls/winmm/winmm.spec
@@ -10,12 +10,12 @@
@ stdcall DrvClose(long long long) CloseDriver
@ stdcall DrvDefDriverProc(long long long long long) DefDriverProc
@ stdcall DrvGetModuleHandle(long) GetDriverModuleHandle
-@ stdcall DrvOpen(wstr wstr long) OpenDriverW
+@ stdcall DrvOpen(wstr wstr long) OpenDriver
@ stdcall DrvOpenA(str str long) OpenDriverA
@ stdcall DrvSendMessage(long long long long) SendDriverMessage
@ stdcall GetDriverFlags(long)
@ stdcall GetDriverModuleHandle(long)
-@ stdcall OpenDriver(wstr wstr long) OpenDriverW
+@ stdcall OpenDriver(wstr wstr long)
@ stdcall OpenDriverA(str str long)
@ stdcall PlaySound(ptr long long) PlaySoundA
@ stdcall PlaySoundW(ptr long long)
@@ -42,8 +42,9 @@
@ stdcall mciFreeCommandResource(long)
@ stdcall mciGetCreatorTask(long)
@ stdcall mciGetDeviceIDA(str)
-@ stdcall mciGetDeviceIDFromElementIDW(long str)
-@ stdcall mciGetDeviceIDW(str)
+@ stdcall mciGetDeviceIDW(wstr)
+@ stdcall mciGetDeviceIDFromElementIDA(long str)
+@ stdcall mciGetDeviceIDFromElementIDW(long wstr)
@ stdcall mciGetDriverData(long)
@ stdcall mciGetErrorStringA(long ptr long)
@ stdcall mciGetErrorStringW(long ptr long)
@@ -61,8 +62,8 @@
@ stdcall midiInClose(long)
@ stdcall midiInGetDevCapsA(long ptr long)
@ stdcall midiInGetDevCapsW(long ptr long)
-@ stdcall midiInGetErrorTextA(long ptr long)
-@ stdcall midiInGetErrorTextW(long ptr long)
+@ stdcall midiInGetErrorTextA(long ptr long) midiOutGetErrorTextA
+@ stdcall midiInGetErrorTextW(long ptr long) midiOutGetErrorTextW
@ stdcall midiInGetID(long ptr)
@ stdcall midiInGetNumDevs()
@ stdcall midiInMessage(long long long long)
@@ -153,8 +154,8 @@
@ stdcall waveInClose(long)
@ stdcall waveInGetDevCapsA(long ptr long)
@ stdcall waveInGetDevCapsW(long ptr long)
-@ stdcall waveInGetErrorTextA(long ptr long)
-@ stdcall waveInGetErrorTextW(long ptr long)
+@ stdcall waveInGetErrorTextA(long ptr long) waveOutGetErrorTextA
+@ stdcall waveInGetErrorTextW(long ptr long) waveOutGetErrorTextW
@ stdcall waveInGetID(long ptr)
@ stdcall waveInGetNumDevs()
@ stdcall waveInGetPosition(long ptr long)
@@ -188,3 +189,23 @@
@ stdcall waveOutSetVolume(long long)
@ stdcall waveOutUnprepareHeader(long ptr long)
@ stdcall waveOutWrite(long ptr long)
+# MigrateAllDrivers
+# MigrateSoundEvents
+# NotifyCallbackData
+# WOW32DriverCallback
+# WOW32ResolveMultiMediaHandle
+# WOWAppExit
+# WinmmLogoff
+# WinmmLogon
+# mid32Message
+# mmDrvInstall
+# aux32Message
+# joy32Message
+# mci32Message
+# mod32Message
+# mxd32Message
+# tid32Message
+# wid32Message
+# winmmDbgOut
+# winmmSetDebugLevel
+# wod32Message
diff --git a/dlls/winmm/winmm_res.rc b/dlls/winmm/winmm_res.rc
index eec7881..eeee8a0 100644
--- a/dlls/winmm/winmm_res.rc
+++ b/dlls/winmm/winmm_res.rc
@@ -47,773 +47,773 @@
CORE RCDATA
BEGIN
-"open\0", 0x00000803L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"type\0", 0x00002000L, MCI_STRING,
-"element\0", 0x00000200L, MCI_STRING,
-"alias\0", 0x00000400L, MCI_STRING,
-"shareable\0", 0x00000100L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"close\0", 0x00000804L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"play\0", 0x00000806L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"record\0", 0x0000080fL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"insert\0", 0x00000100L, MCI_FLAG,
-"overwrite\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"to start\0", 0x00000100L, MCI_FLAG,
-"to end\0", 0x00000200L, MCI_FLAG,
-"to\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"stop\0", 0x00000808L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"pause\0", 0x00000809L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"can record\0", 0x00000001L, MCI_INTEGER,
-"has audio\0", 0x00000002L, MCI_INTEGER,
-"has video\0", 0x00000003L, MCI_INTEGER,
-"uses files\0", 0x00000005L, MCI_INTEGER,
-"compound device\0", 0x00000006L, MCI_INTEGER,
-"device type\0", 0x00000004L, MCI_INTEGER,
-"can eject\0", 0x00000007L, MCI_INTEGER,
-"can play\0", 0x00000008L, MCI_INTEGER,
-"can save\0", 0x00000009L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"sysinfo\0", 0x00000810L, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"quantity\0", 0x00000100L, MCI_FLAG,
-"open\0", 0x00000200L, MCI_FLAG,
-"installname\0", 0x00000800L, MCI_FLAG,
-"name\0", 0x00000400L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"break\0", 0x00000811L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"on\0", 0x00000100L, MCI_INTEGER,
-"off\0", 0x00000400L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"sound\0", 0x00000812L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"save\0", 0x00000813L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"load\0", 0x00000850L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"resume\0", 0x00000855L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"type\0", 0x00002000L, MCI_STRING,
+L"element\0", 0x00000200L, MCI_STRING,
+L"alias\0", 0x00000400L, MCI_STRING,
+L"shareable\0", 0x00000100L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"close\0", 0x00000804L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"record\0", 0x0000080fL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"insert\0", 0x00000100L, MCI_FLAG,
+L"overwrite\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"to start\0", 0x00000100L, MCI_FLAG,
+L"to end\0", 0x00000200L, MCI_FLAG,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"stop\0", 0x00000808L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"pause\0", 0x00000809L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"can record\0", 0x00000001L, MCI_INTEGER,
+L"has audio\0", 0x00000002L, MCI_INTEGER,
+L"has video\0", 0x00000003L, MCI_INTEGER,
+L"uses files\0", 0x00000005L, MCI_INTEGER,
+L"compound device\0", 0x00000006L, MCI_INTEGER,
+L"device type\0", 0x00000004L, MCI_INTEGER,
+L"can eject\0", 0x00000007L, MCI_INTEGER,
+L"can play\0", 0x00000008L, MCI_INTEGER,
+L"can save\0", 0x00000009L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"sysinfo\0", 0x00000810L, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"quantity\0", 0x00000100L, MCI_FLAG,
+L"open\0", 0x00000200L, MCI_FLAG,
+L"installname\0", 0x00000800L, MCI_FLAG,
+L"name\0", 0x00000400L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"break\0", 0x00000811L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"on\0", 0x00000100L, MCI_INTEGER,
+L"off\0", 0x00000400L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"sound\0", 0x00000812L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"save\0", 0x00000813L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"load\0", 0x00000850L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"resume\0", 0x00000855L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
VIDEODISC RCDATA
BEGIN
-"play\0", 0x00000806L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"fast\0", 0x00020000L, MCI_FLAG,
-"slow\0", 0x00100000L, MCI_FLAG,
-"speed\0", 0x00040000L, MCI_INTEGER,
-"reverse\0", 0x00010000L, MCI_FLAG,
-"scan\0", 0x00080000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"reverse\0", 0x00010000L, MCI_FLAG,
-"to start\0", 0x00000100L, MCI_FLAG,
-"to end\0", 0x00000200L, MCI_FLAG,
-"to\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"spin\0", 0x0000080cL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"up\0", 0x00010000L, MCI_FLAG,
-"down\0", 0x00020000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"reverse\0", 0x00020000L, MCI_FLAG,
-"by\0", 0x00010000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"frames\0", 0x00000003L, MCI_INTEGER,
-"hms\0", 0x00000001L, MCI_INTEGER,
-"track\0", 0x00004001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"speed\0", 0x00004002L, MCI_INTEGER,
-"forward\0", 0x00004003L, MCI_INTEGER,
-"media type\0", 0x00004004L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"side\0", 0x00004005L, MCI_INTEGER,
-"disc size\0", 0x00004006L, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"clv\0", 0x00010000L, MCI_FLAG,
-"cav\0", 0x00020000L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"can record\0", 0x00000001L, MCI_INTEGER,
-"has audio\0", 0x00000002L, MCI_INTEGER,
-"has video\0", 0x00000003L, MCI_INTEGER,
-"device type\0", 0x00000004L, MCI_INTEGER,
-"uses files\0", 0x00000005L, MCI_INTEGER,
-"compound device\0", 0x00000006L, MCI_INTEGER,
-"can eject\0", 0x00000007L, MCI_INTEGER,
-"can reverse\0", 0x00004002L, MCI_INTEGER,
-"can play\0", 0x00000008L, MCI_INTEGER,
-"can save\0", 0x00000009L, MCI_INTEGER,
-"fast play rate\0", 0x00004003L, MCI_INTEGER,
-"slow play rate\0", 0x00004004L, MCI_INTEGER,
-"normal play rate\0", 0x00004005L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"escape\0", 0x00000805L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"identity\0", 0x00000800L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"fast\0", 0x00020000L, MCI_FLAG,
+L"slow\0", 0x00100000L, MCI_FLAG,
+L"speed\0", 0x00040000L, MCI_INTEGER,
+L"reverse\0", 0x00010000L, MCI_FLAG,
+L"scan\0", 0x00080000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"reverse\0", 0x00010000L, MCI_FLAG,
+L"to start\0", 0x00000100L, MCI_FLAG,
+L"to end\0", 0x00000200L, MCI_FLAG,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"spin\0", 0x0000080cL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"up\0", 0x00010000L, MCI_FLAG,
+L"down\0", 0x00020000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"reverse\0", 0x00020000L, MCI_FLAG,
+L"by\0", 0x00010000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"frames\0", 0x00000003L, MCI_INTEGER,
+L"hms\0", 0x00000001L, MCI_INTEGER,
+L"track\0", 0x00004001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"speed\0", 0x00004002L, MCI_INTEGER,
+L"forward\0", 0x00004003L, MCI_INTEGER,
+L"media type\0", 0x00004004L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"side\0", 0x00004005L, MCI_INTEGER,
+L"disc size\0", 0x00004006L, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"clv\0", 0x00010000L, MCI_FLAG,
+L"cav\0", 0x00020000L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"can record\0", 0x00000001L, MCI_INTEGER,
+L"has audio\0", 0x00000002L, MCI_INTEGER,
+L"has video\0", 0x00000003L, MCI_INTEGER,
+L"device type\0", 0x00000004L, MCI_INTEGER,
+L"uses files\0", 0x00000005L, MCI_INTEGER,
+L"compound device\0", 0x00000006L, MCI_INTEGER,
+L"can eject\0", 0x00000007L, MCI_INTEGER,
+L"can reverse\0", 0x00004002L, MCI_INTEGER,
+L"can play\0", 0x00000008L, MCI_INTEGER,
+L"can save\0", 0x00000009L, MCI_INTEGER,
+L"fast play rate\0", 0x00004003L, MCI_INTEGER,
+L"slow play rate\0", 0x00004004L, MCI_INTEGER,
+L"normal play rate\0", 0x00004005L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"escape\0", 0x00000805L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"identity\0", 0x00000800L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
WAVEAUDIO RCDATA
BEGIN
-"open\0", 0x00000803L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"type\0", 0x00002000L, MCI_STRING,
-"element\0", 0x00000200L, MCI_STRING,
-"alias\0", 0x00000400L, MCI_STRING,
-"shareable\0", 0x00000100L, MCI_FLAG,
-"buffer\0", 0x00010000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"format tag\0", 0x00004001L, MCI_INTEGER,
-"channels\0", 0x00004002L, MCI_INTEGER,
-"samplespersec\0", 0x00004003L, MCI_INTEGER,
-"bytespersec\0", 0x00004004L, MCI_INTEGER,
-"alignment\0", 0x00004005L, MCI_INTEGER,
-"bitspersample\0", 0x00004006L, MCI_INTEGER,
-"input\0", 0x00400000L, MCI_INTEGER,
-"output\0", 0x00800000L, MCI_INTEGER,
-"level\0", 0x00004007L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"any input\0", 0x04000000L, MCI_FLAG,
-"any output\0", 0x08000000L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"bytes\0", 0x00000008L, MCI_INTEGER,
-"samples\0", 0x00000009L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"input\0", 0x00400000L, MCI_INTEGER,
-"output\0", 0x00800000L, MCI_INTEGER,
-"format tag\0", 0x00010000L, MCI_CONSTANT,
-"pcm\0", 0x00000001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"channels\0", 0x00020000L, MCI_INTEGER,
-"samplespersec\0", 0x00040000L, MCI_INTEGER,
-"bytespersec\0", 0x00080000L, MCI_INTEGER,
-"alignment\0", 0x00100000L, MCI_INTEGER,
-"bitspersample\0", 0x00200000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"can record\0", 0x00000001L, MCI_INTEGER,
-"has audio\0", 0x00000002L, MCI_INTEGER,
-"has video\0", 0x00000003L, MCI_INTEGER,
-"device type\0", 0x00000004L, MCI_INTEGER,
-"uses files\0", 0x00000005L, MCI_INTEGER,
-"compound device\0", 0x00000006L, MCI_INTEGER,
-"can eject\0", 0x00000007L, MCI_INTEGER,
-"can play\0", 0x00000008L, MCI_INTEGER,
-"can save\0", 0x00000009L, MCI_INTEGER,
-"inputs\0", 0x00004001L, MCI_INTEGER,
-"outputs\0", 0x00004002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"input\0", 0x00400000L, MCI_FLAG,
-"output\0", 0x00800000L, MCI_FLAG,
-"file\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"cue\0", 0x00000830L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"input\0", 0x00400000L, MCI_FLAG,
-"output\0", 0x00800000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"delete\0", 0x00000856L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"type\0", 0x00002000L, MCI_STRING,
+L"element\0", 0x00000200L, MCI_STRING,
+L"alias\0", 0x00000400L, MCI_STRING,
+L"shareable\0", 0x00000100L, MCI_FLAG,
+L"buffer\0", 0x00010000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"format tag\0", 0x00004001L, MCI_INTEGER,
+L"channels\0", 0x00004002L, MCI_INTEGER,
+L"samplespersec\0", 0x00004003L, MCI_INTEGER,
+L"bytespersec\0", 0x00004004L, MCI_INTEGER,
+L"alignment\0", 0x00004005L, MCI_INTEGER,
+L"bitspersample\0", 0x00004006L, MCI_INTEGER,
+L"input\0", 0x00400000L, MCI_INTEGER,
+L"output\0", 0x00800000L, MCI_INTEGER,
+L"level\0", 0x00004007L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"any input\0", 0x04000000L, MCI_FLAG,
+L"any output\0", 0x08000000L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"bytes\0", 0x00000008L, MCI_INTEGER,
+L"samples\0", 0x00000009L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"input\0", 0x00400000L, MCI_INTEGER,
+L"output\0", 0x00800000L, MCI_INTEGER,
+L"format tag\0", 0x00010000L, MCI_CONSTANT,
+L"pcm\0", 0x00000001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"channels\0", 0x00020000L, MCI_INTEGER,
+L"samplespersec\0", 0x00040000L, MCI_INTEGER,
+L"bytespersec\0", 0x00080000L, MCI_INTEGER,
+L"alignment\0", 0x00100000L, MCI_INTEGER,
+L"bitspersample\0", 0x00200000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"can record\0", 0x00000001L, MCI_INTEGER,
+L"has audio\0", 0x00000002L, MCI_INTEGER,
+L"has video\0", 0x00000003L, MCI_INTEGER,
+L"device type\0", 0x00000004L, MCI_INTEGER,
+L"uses files\0", 0x00000005L, MCI_INTEGER,
+L"compound device\0", 0x00000006L, MCI_INTEGER,
+L"can eject\0", 0x00000007L, MCI_INTEGER,
+L"can play\0", 0x00000008L, MCI_INTEGER,
+L"can save\0", 0x00000009L, MCI_INTEGER,
+L"inputs\0", 0x00004001L, MCI_INTEGER,
+L"outputs\0", 0x00004002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"input\0", 0x00400000L, MCI_FLAG,
+L"output\0", 0x00800000L, MCI_FLAG,
+L"file\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"cue\0", 0x00000830L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"input\0", 0x00400000L, MCI_FLAG,
+L"output\0", 0x00800000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"delete\0", 0x00000856L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
CDAUDIO RCDATA
BEGIN
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"type\0", 0x00004001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"msf\0", 0x00000002L, MCI_INTEGER,
-"tmsf\0", 0x0000000aL, MCI_INTEGER,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"upc\0", 0x00000400L, MCI_FLAG,
-"identity\0", 0x00000800L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"type\0", 0x00004001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"msf\0", 0x00000002L, MCI_INTEGER,
+L"tmsf\0", 0x0000000aL, MCI_INTEGER,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"upc\0", 0x00000400L, MCI_FLAG,
+L"identity\0", 0x00000800L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
SEQUENCER RCDATA
BEGIN
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"tempo\0", 0x00004002L, MCI_INTEGER,
-"port\0", 0x00004003L, MCI_INTEGER,
-"slave\0", 0x00004007L, MCI_INTEGER,
-"master\0", 0x00004008L, MCI_INTEGER,
-"offset\0", 0x00004009L, MCI_INTEGER,
-"division type\0", 0x0000400aL, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"smpte 30 drop\0", 0x00000007L, MCI_INTEGER,
-"smpte 30\0", 0x00000006L, MCI_INTEGER,
-"smpte 25\0", 0x00000005L, MCI_INTEGER,
-"smpte 24\0", 0x00000004L, MCI_INTEGER,
-"song pointer\0", 0x00004001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"tempo\0", 0x00010000L, MCI_INTEGER,
-"port\0", 0x00020000L, MCI_CONSTANT,
-"none\0", 0x0000fffdL, MCI_INTEGER,
-"mapper\0", 0x0000ffffL, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"slave\0", 0x00040000L, MCI_CONSTANT,
-"smpte\0", 0x00004004L, MCI_INTEGER,
-"midi\0", 0x00004003L, MCI_INTEGER,
-"none\0", 0x0000fffdL, MCI_INTEGER,
-"file\0", 0x00004002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"master\0", 0x00080000L, MCI_CONSTANT,
-"smpte\0", 0x00004004L, MCI_INTEGER,
-"midi\0", 0x00004003L, MCI_INTEGER,
-"none\0", 0x0000fffdL, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"offset\0", 0x01000000L, MCI_INTEGER,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"file\0", 0x00000200L, MCI_FLAG,
-"name\0", 0x00001000L, MCI_FLAG,
-"copyright\0", 0x00002000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"tempo\0", 0x00004002L, MCI_INTEGER,
+L"port\0", 0x00004003L, MCI_INTEGER,
+L"slave\0", 0x00004007L, MCI_INTEGER,
+L"master\0", 0x00004008L, MCI_INTEGER,
+L"offset\0", 0x00004009L, MCI_INTEGER,
+L"division type\0", 0x0000400aL, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"smpte 30 drop\0", 0x00000007L, MCI_INTEGER,
+L"smpte 30\0", 0x00000006L, MCI_INTEGER,
+L"smpte 25\0", 0x00000005L, MCI_INTEGER,
+L"smpte 24\0", 0x00000004L, MCI_INTEGER,
+L"song pointer\0", 0x00004001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"tempo\0", 0x00010000L, MCI_INTEGER,
+L"port\0", 0x00020000L, MCI_CONSTANT,
+L"none\0", 0x0000fffdL, MCI_INTEGER,
+L"mapper\0", 0x0000ffffL, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"slave\0", 0x00040000L, MCI_CONSTANT,
+L"smpte\0", 0x00004004L, MCI_INTEGER,
+L"midi\0", 0x00004003L, MCI_INTEGER,
+L"none\0", 0x0000fffdL, MCI_INTEGER,
+L"file\0", 0x00004002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"master\0", 0x00080000L, MCI_CONSTANT,
+L"smpte\0", 0x00004004L, MCI_INTEGER,
+L"midi\0", 0x00004003L, MCI_INTEGER,
+L"none\0", 0x0000fffdL, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"offset\0", 0x01000000L, MCI_INTEGER,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"file\0", 0x00000200L, MCI_FLAG,
+L"name\0", 0x00001000L, MCI_FLAG,
+L"copyright\0", 0x00002000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
ANIMATION RCDATA
BEGIN
-"open\0", 0x00000803L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"type\0", 0x00002000L, MCI_STRING,
-"element\0", 0x00000200L, MCI_STRING,
-"alias\0", 0x00000400L, MCI_STRING,
-"shareable\0", 0x00000100L, MCI_FLAG,
-"style\0", 0x00010000L, MCI_CONSTANT,
-"overlapped\0", 0x00cf0000L, MCI_INTEGER,
-"popup\0", 0x80880000L, MCI_INTEGER,
-"child\0", 0x40000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"parent\0", 0x00020000L, MCI_INTEGER,
-"nostatic\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"play\0", 0x00000806L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"from\0", 0x00000004L, MCI_INTEGER,
-"to\0", 0x00000008L, MCI_INTEGER,
-"fast\0", 0x00040000L, MCI_FLAG,
-"slow\0", 0x00080000L, MCI_FLAG,
-"scan\0", 0x00100000L, MCI_FLAG,
-"reverse\0", 0x00020000L, MCI_FLAG,
-"speed\0", 0x00010000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"reverse\0", 0x00010000L, MCI_FLAG,
-"by\0", 0x00020000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"time format\0", 0x00000400L, MCI_CONSTANT,
-"milliseconds\0", 0x00000000L, MCI_INTEGER,
-"ms\0", 0x00000000L, MCI_INTEGER,
-"frames\0", 0x00000003L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"audio\0", 0x00000800L, MCI_CONSTANT,
-"all\0", 0x00000000L, MCI_INTEGER,
-"left\0", 0x00000001L, MCI_INTEGER,
-"right\0", 0x00000002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"video\0", 0x00001000L, MCI_FLAG,
-"on\0", 0x00002000L, MCI_FLAG,
-"off\0", 0x00004000L, MCI_FLAG,
-"door open\0", 0x00000100L, MCI_FLAG,
-"door closed\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"speed\0", 0x00004001L, MCI_INTEGER,
-"forward\0", 0x00004002L, MCI_INTEGER,
-"window handle\0", 0x00004003L, MCI_INTEGER,
-"palette handle\0", 0x00004004L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"time format\0", 0x00000006L, MCI_INTEGER,
-"current track\0", 0x00000008L, MCI_INTEGER,
-"stretch\0", 0x00004005L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"file\0", 0x00000200L, MCI_FLAG,
-"window text\0", 0x00010000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"can record\0", 0x00000001L, MCI_INTEGER,
-"has audio\0", 0x00000002L, MCI_INTEGER,
-"has video\0", 0x00000003L, MCI_INTEGER,
-"device type\0", 0x00000004L, MCI_INTEGER,
-"uses files\0", 0x00000005L, MCI_INTEGER,
-"compound device\0", 0x00000006L, MCI_INTEGER,
-"can eject\0", 0x00000007L, MCI_INTEGER,
-"can play\0", 0x00000008L, MCI_INTEGER,
-"can save\0", 0x00000009L, MCI_INTEGER,
-"can reverse\0", 0x00004001L, MCI_INTEGER,
-"fast play rate\0", 0x00004002L, MCI_INTEGER,
-"slow play rate\0", 0x00004003L, MCI_INTEGER,
-"normal play rate\0", 0x00004004L, MCI_INTEGER,
-"uses palettes\0", 0x00004006L, MCI_INTEGER,
-"can stretch\0", 0x00004007L, MCI_INTEGER,
-"windows\0", 0x00004008L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"realize\0", 0x00000840L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"normal\0", 0x00010000L, MCI_FLAG,
-"background\0", 0x00020000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"window\0", 0x00000841L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"handle\0", 0x00010000L, MCI_CONSTANT,
-"default\0", 0x00000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"state\0", 0x00040000L, MCI_CONSTANT,
-"hide\0", 0x00000000L, MCI_INTEGER,
-"minimize\0", 0x00000006L, MCI_INTEGER,
-"show\0", 0x00000005L, MCI_INTEGER,
-"maximized\0", 0x00000003L, MCI_INTEGER,
-"minimized\0", 0x00000002L, MCI_INTEGER,
-"iconic\0", 0x00000007L, MCI_INTEGER,
-"no action\0", 0x00000008L, MCI_INTEGER,
-"no activate\0", 0x00000004L, MCI_INTEGER,
-"normal\0", 0x00000001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"text\0", 0x00080000L, MCI_STRING,
-"stretch\0", 0x00100000L, MCI_FLAG,
-"fixed\0", 0x00200000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"put\0", 0x00000842L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"source\0", 0x00020000L, MCI_FLAG,
-"destination\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"where\0", 0x00000843L, MCI_COMMAND_HEAD,
-"\0", 0x00000007L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"source\0", 0x00020000L, MCI_FLAG,
-"destination\0", 0x00040000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"update\0", 0x00000854L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"hdc\0", 0x00020000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"type\0", 0x00002000L, MCI_STRING,
+L"element\0", 0x00000200L, MCI_STRING,
+L"alias\0", 0x00000400L, MCI_STRING,
+L"shareable\0", 0x00000100L, MCI_FLAG,
+L"style\0", 0x00010000L, MCI_CONSTANT,
+L"overlapped\0", 0x00cf0000L, MCI_INTEGER,
+L"popup\0", 0x80880000L, MCI_INTEGER,
+L"child\0", 0x40000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"parent\0", 0x00020000L, MCI_INTEGER,
+L"nostatic\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"from\0", 0x00000004L, MCI_INTEGER,
+L"to\0", 0x00000008L, MCI_INTEGER,
+L"fast\0", 0x00040000L, MCI_FLAG,
+L"slow\0", 0x00080000L, MCI_FLAG,
+L"scan\0", 0x00100000L, MCI_FLAG,
+L"reverse\0", 0x00020000L, MCI_FLAG,
+L"speed\0", 0x00010000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"reverse\0", 0x00010000L, MCI_FLAG,
+L"by\0", 0x00020000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"time format\0", 0x00000400L, MCI_CONSTANT,
+L"milliseconds\0", 0x00000000L, MCI_INTEGER,
+L"ms\0", 0x00000000L, MCI_INTEGER,
+L"frames\0", 0x00000003L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"audio\0", 0x00000800L, MCI_CONSTANT,
+L"all\0", 0x00000000L, MCI_INTEGER,
+L"left\0", 0x00000001L, MCI_INTEGER,
+L"right\0", 0x00000002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"video\0", 0x00001000L, MCI_FLAG,
+L"on\0", 0x00002000L, MCI_FLAG,
+L"off\0", 0x00004000L, MCI_FLAG,
+L"door open\0", 0x00000100L, MCI_FLAG,
+L"door closed\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"speed\0", 0x00004001L, MCI_INTEGER,
+L"forward\0", 0x00004002L, MCI_INTEGER,
+L"window handle\0", 0x00004003L, MCI_INTEGER,
+L"palette handle\0", 0x00004004L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"time format\0", 0x00000006L, MCI_INTEGER,
+L"current track\0", 0x00000008L, MCI_INTEGER,
+L"stretch\0", 0x00004005L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"file\0", 0x00000200L, MCI_FLAG,
+L"window text\0", 0x00010000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"can record\0", 0x00000001L, MCI_INTEGER,
+L"has audio\0", 0x00000002L, MCI_INTEGER,
+L"has video\0", 0x00000003L, MCI_INTEGER,
+L"device type\0", 0x00000004L, MCI_INTEGER,
+L"uses files\0", 0x00000005L, MCI_INTEGER,
+L"compound device\0", 0x00000006L, MCI_INTEGER,
+L"can eject\0", 0x00000007L, MCI_INTEGER,
+L"can play\0", 0x00000008L, MCI_INTEGER,
+L"can save\0", 0x00000009L, MCI_INTEGER,
+L"can reverse\0", 0x00004001L, MCI_INTEGER,
+L"fast play rate\0", 0x00004002L, MCI_INTEGER,
+L"slow play rate\0", 0x00004003L, MCI_INTEGER,
+L"normal play rate\0", 0x00004004L, MCI_INTEGER,
+L"uses palettes\0", 0x00004006L, MCI_INTEGER,
+L"can stretch\0", 0x00004007L, MCI_INTEGER,
+L"windows\0", 0x00004008L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"realize\0", 0x00000840L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"normal\0", 0x00010000L, MCI_FLAG,
+L"background\0", 0x00020000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"window\0", 0x00000841L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"handle\0", 0x00010000L, MCI_CONSTANT,
+L"default\0", 0x00000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"state\0", 0x00040000L, MCI_CONSTANT,
+L"hide\0", 0x00000000L, MCI_INTEGER,
+L"minimize\0", 0x00000006L, MCI_INTEGER,
+L"show\0", 0x00000005L, MCI_INTEGER,
+L"maximized\0", 0x00000003L, MCI_INTEGER,
+L"minimized\0", 0x00000002L, MCI_INTEGER,
+L"iconic\0", 0x00000007L, MCI_INTEGER,
+L"no action\0", 0x00000008L, MCI_INTEGER,
+L"no activate\0", 0x00000004L, MCI_INTEGER,
+L"normal\0", 0x00000001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"text\0", 0x00080000L, MCI_STRING,
+L"stretch\0", 0x00100000L, MCI_FLAG,
+L"fixed\0", 0x00200000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"put\0", 0x00000842L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"source\0", 0x00020000L, MCI_FLAG,
+L"destination\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"where\0", 0x00000843L, MCI_COMMAND_HEAD,
+L"\0", 0x00000007L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"source\0", 0x00020000L, MCI_FLAG,
+L"destination\0", 0x00040000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"update\0", 0x00000854L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"hdc\0", 0x00020000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
OVERLAY RCDATA
BEGIN
-"open\0", 0x00000803L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"type\0", 0x00002000L, MCI_STRING,
-"element\0", 0x00000200L, MCI_STRING,
-"alias\0", 0x00000400L, MCI_STRING,
-"shareable\0", 0x00000100L, MCI_FLAG,
-"style\0", 0x00010000L, MCI_CONSTANT,
-"overlapped\0", 0x00cf0000L, MCI_INTEGER,
-"popup\0", 0x80880000L, MCI_INTEGER,
-"child\0", 0x40000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"parent\0", 0x00020000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"status\0", 0x00000814L, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"position\0", 0x00000002L, MCI_INTEGER,
-"length\0", 0x00000001L, MCI_INTEGER,
-"number of tracks\0", 0x00000003L, MCI_INTEGER,
-"mode\0", 0x00000004L, MCI_INTEGER,
-"ready\0", 0x00000007L, MCI_INTEGER,
-"window handle\0", 0x00004001L, MCI_INTEGER,
-"media present\0", 0x00000005L, MCI_INTEGER,
-"stretch\0", 0x00004002L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"track\0", 0x00000010L, MCI_INTEGER,
-"start\0", 0x00000200L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
-"\0", 0x00000001L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"product\0", 0x00000100L, MCI_FLAG,
-"file\0", 0x00000200L, MCI_FLAG,
-"window text\0", 0x00010000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
-"\0", 0x00000002L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_CONSTANT,
-"can record\0", 0x00000001L, MCI_INTEGER,
-"has audio\0", 0x00000002L, MCI_INTEGER,
-"has video\0", 0x00000003L, MCI_INTEGER,
-"device type\0", 0x00000004L, MCI_INTEGER,
-"uses files\0", 0x00000005L, MCI_INTEGER,
-"compound device\0", 0x00000006L, MCI_INTEGER,
-"can eject\0", 0x00000007L, MCI_INTEGER,
-"can play\0", 0x00000008L, MCI_INTEGER,
-"can save\0", 0x00000009L, MCI_INTEGER,
-"can stretch\0", 0x00004001L, MCI_INTEGER,
-"can freeze\0", 0x00004002L, MCI_INTEGER,
-"windows\0", 0x00004003L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"window\0", 0x00000841L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"handle\0", 0x00010000L, MCI_CONSTANT,
-"default\0", 0x00000000L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"state\0", 0x00040000L, MCI_CONSTANT,
-"hide\0", 0x00000000L, MCI_INTEGER,
-"minimize\0", 0x00000006L, MCI_INTEGER,
-"show\0", 0x00000005L, MCI_INTEGER,
-"maximized\0", 0x00000003L, MCI_INTEGER,
-"minimized\0", 0x00000002L, MCI_INTEGER,
-"iconic\0", 0x00000007L, MCI_INTEGER,
-"no action\0", 0x00000008L, MCI_INTEGER,
-"no activate\0", 0x00000004L, MCI_INTEGER,
-"normal\0", 0x00000001L, MCI_INTEGER,
-"\0", 0x00000000L, MCI_END_CONSTANT,
-"text\0", 0x00080000L, MCI_STRING,
-"stretch\0", 0x00100000L, MCI_FLAG,
-"fixed\0", 0x00200000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"put\0", 0x00000842L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"source\0", 0x00020000L, MCI_FLAG,
-"destination\0", 0x00040000L, MCI_FLAG,
-"frame\0", 0x00080000L, MCI_FLAG,
-"video\0", 0x00100000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"where\0", 0x00000843L, MCI_COMMAND_HEAD,
-"\0", 0x00000007L, MCI_RETURN,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"source\0", 0x00020000L, MCI_FLAG,
-"destination\0", 0x00040000L, MCI_FLAG,
-"frame\0", 0x00080000L, MCI_FLAG,
-"video\0", 0x00100000L, MCI_FLAG,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"save\0", 0x00000813L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"at\0", 0x00010000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"load\0", 0x00000850L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"\0", 0x00000100L, MCI_STRING,
-"at\0", 0x00010000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"freeze\0", 0x00000844L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"unfreeze\0", 0x00000845L, MCI_COMMAND_HEAD,
-"notify\0", 0x00000001L, MCI_FLAG,
-"wait\0", 0x00000002L, MCI_FLAG,
-"at\0", 0x00010000L, MCI_RECT,
-"\0", 0x00000000L, MCI_END_COMMAND,
-"\0", 0x00000000L, MCI_END_COMMAND_LIST
+L"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"type\0", 0x00002000L, MCI_STRING,
+L"element\0", 0x00000200L, MCI_STRING,
+L"alias\0", 0x00000400L, MCI_STRING,
+L"shareable\0", 0x00000100L, MCI_FLAG,
+L"style\0", 0x00010000L, MCI_CONSTANT,
+L"overlapped\0", 0x00cf0000L, MCI_INTEGER,
+L"popup\0", 0x80880000L, MCI_INTEGER,
+L"child\0", 0x40000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"parent\0", 0x00020000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"position\0", 0x00000002L, MCI_INTEGER,
+L"length\0", 0x00000001L, MCI_INTEGER,
+L"number of tracks\0", 0x00000003L, MCI_INTEGER,
+L"mode\0", 0x00000004L, MCI_INTEGER,
+L"ready\0", 0x00000007L, MCI_INTEGER,
+L"window handle\0", 0x00004001L, MCI_INTEGER,
+L"media present\0", 0x00000005L, MCI_INTEGER,
+L"stretch\0", 0x00004002L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"track\0", 0x00000010L, MCI_INTEGER,
+L"start\0", 0x00000200L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+L"\0", 0x00000001L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"product\0", 0x00000100L, MCI_FLAG,
+L"file\0", 0x00000200L, MCI_FLAG,
+L"window text\0", 0x00010000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+L"\0", 0x00000002L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_CONSTANT,
+L"can record\0", 0x00000001L, MCI_INTEGER,
+L"has audio\0", 0x00000002L, MCI_INTEGER,
+L"has video\0", 0x00000003L, MCI_INTEGER,
+L"device type\0", 0x00000004L, MCI_INTEGER,
+L"uses files\0", 0x00000005L, MCI_INTEGER,
+L"compound device\0", 0x00000006L, MCI_INTEGER,
+L"can eject\0", 0x00000007L, MCI_INTEGER,
+L"can play\0", 0x00000008L, MCI_INTEGER,
+L"can save\0", 0x00000009L, MCI_INTEGER,
+L"can stretch\0", 0x00004001L, MCI_INTEGER,
+L"can freeze\0", 0x00004002L, MCI_INTEGER,
+L"windows\0", 0x00004003L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"window\0", 0x00000841L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"handle\0", 0x00010000L, MCI_CONSTANT,
+L"default\0", 0x00000000L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"state\0", 0x00040000L, MCI_CONSTANT,
+L"hide\0", 0x00000000L, MCI_INTEGER,
+L"minimize\0", 0x00000006L, MCI_INTEGER,
+L"show\0", 0x00000005L, MCI_INTEGER,
+L"maximized\0", 0x00000003L, MCI_INTEGER,
+L"minimized\0", 0x00000002L, MCI_INTEGER,
+L"iconic\0", 0x00000007L, MCI_INTEGER,
+L"no action\0", 0x00000008L, MCI_INTEGER,
+L"no activate\0", 0x00000004L, MCI_INTEGER,
+L"normal\0", 0x00000001L, MCI_INTEGER,
+L"\0", 0x00000000L, MCI_END_CONSTANT,
+L"text\0", 0x00080000L, MCI_STRING,
+L"stretch\0", 0x00100000L, MCI_FLAG,
+L"fixed\0", 0x00200000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"put\0", 0x00000842L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"source\0", 0x00020000L, MCI_FLAG,
+L"destination\0", 0x00040000L, MCI_FLAG,
+L"frame\0", 0x00080000L, MCI_FLAG,
+L"video\0", 0x00100000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"where\0", 0x00000843L, MCI_COMMAND_HEAD,
+L"\0", 0x00000007L, MCI_RETURN,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"source\0", 0x00020000L, MCI_FLAG,
+L"destination\0", 0x00040000L, MCI_FLAG,
+L"frame\0", 0x00080000L, MCI_FLAG,
+L"video\0", 0x00100000L, MCI_FLAG,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"save\0", 0x00000813L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"at\0", 0x00010000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"load\0", 0x00000850L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"\0", 0x00000100L, MCI_STRING,
+L"at\0", 0x00010000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"freeze\0", 0x00000844L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"unfreeze\0", 0x00000845L, MCI_COMMAND_HEAD,
+L"notify\0", 0x00000001L, MCI_FLAG,
+L"wait\0", 0x00000002L, MCI_FLAG,
+L"at\0", 0x00010000L, MCI_RECT,
+L"\0", 0x00000000L, MCI_END_COMMAND,
+L"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
STRINGTABLE
diff --git a/include/mmsystem.h b/include/mmsystem.h
index a9f6e09..09620aa 100644
--- a/include/mmsystem.h
+++ b/include/mmsystem.h
@@ -1649,21 +1649,25 @@
typedef UINT (CALLBACK *YIELDPROC)(MCIDEVICEID,DWORD);
-DWORD WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
-DWORD WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
+BOOL WINAPI mciExecute(LPCSTR);
+DWORD WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
+DWORD WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
#define mciSendCommand WINELIB_NAME_AW(mciSendCommand)
DWORD WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
DWORD WINAPI mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND);
#define mciSendString WINELIB_NAME_AW(mciSendString)
-UINT WINAPI mciGetDeviceIDA(LPCSTR);
-UINT WINAPI mciGetDeviceIDW(LPCWSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDW(LPCWSTR);
#define mciGetDeviceID WINELIB_NAME_AW(mciGetDeviceID)
-BOOL WINAPI mciGetErrorStringA(MCIERROR,LPSTR,UINT);
-BOOL WINAPI mciGetErrorStringW(MCIERROR,LPWSTR,UINT);
+MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(DWORD,LPCSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(DWORD,LPCWSTR);
+#define mciGetDeviceIDFromElementID WINELIB_NAME_AW(mciGetDeviceIDFromElementID)
+BOOL WINAPI mciGetErrorStringA(MCIERROR,LPSTR,UINT);
+BOOL WINAPI mciGetErrorStringW(MCIERROR,LPWSTR,UINT);
#define mciGetErrorString WINELIB_NAME_AW(mciGetErrorString)
-BOOL WINAPI mciSetYieldProc(MCIDEVICEID,YIELDPROC,DWORD);
-HTASK WINAPI mciGetCreatorTask(MCIDEVICEID);
-YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID,DWORD*);
+BOOL WINAPI mciSetYieldProc(MCIDEVICEID,YIELDPROC,DWORD);
+HTASK WINAPI mciGetCreatorTask(MCIDEVICEID);
+YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID,DWORD*);
#define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1)
#define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3)
@@ -1971,15 +1975,15 @@
} MCI_STATUS_PARMS, *LPMCI_STATUS_PARMS;
typedef struct tagMCI_INFO_PARMSA {
- DWORD_PTR dwCallback;
- LPSTR lpstrReturn;
- DWORD dwRetSize;
+ DWORD_PTR dwCallback;
+ LPSTR lpstrReturn;
+ DWORD dwRetSize;
} MCI_INFO_PARMSA, *LPMCI_INFO_PARMSA;
typedef struct tagMCI_INFO_PARMSW {
- DWORD_PTR dwCallback;
- LPSTR lpstrReturn;
- DWORD dwRetSize;
+ DWORD_PTR dwCallback;
+ LPWSTR lpstrReturn;
+ DWORD dwRetSize;
} MCI_INFO_PARMSW, *LPMCI_INFO_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_INFO_PARMS)
@@ -1991,20 +1995,20 @@
DWORD dwItem;
} MCI_GETDEVCAPS_PARMS, *LPMCI_GETDEVCAPS_PARMS;
-typedef struct tagMCI_GETDEVCAPS_PARMSA {
- DWORD_PTR dwCallback;
- LPSTR lpstrReturn;
- DWORD dwRetSize;
- DWORD dwNumber;
- UINT wDeviceType;
+typedef struct tagMCI_SYSINFO_PARMSA {
+ DWORD_PTR dwCallback;
+ LPSTR lpstrReturn;
+ DWORD dwRetSize;
+ DWORD dwNumber;
+ UINT wDeviceType;
} MCI_SYSINFO_PARMSA, *LPMCI_SYSINFO_PARMSA;
-typedef struct tagMCI_GETDEVCAPS_PARMSW {
- DWORD_PTR dwCallback;
- LPWSTR lpstrReturn;
- DWORD dwRetSize;
- DWORD dwNumber;
- UINT wDeviceType;
+typedef struct tagMCI_SYSINFO_PARMSW {
+ DWORD_PTR dwCallback;
+ LPWSTR lpstrReturn;
+ DWORD dwRetSize;
+ DWORD dwNumber;
+ UINT wDeviceType;
} MCI_SYSINFO_PARMSW, *LPMCI_SYSINFO_PARMSW;
DECL_WINELIB_TYPE_AW(MCI_SYSINFO_PARMS)
@@ -2023,15 +2027,31 @@
} MCI_BREAK_PARMS, *LPMCI_BREAK_PARMS;
-typedef struct tagMCI_SOUND_PARMS {
- DWORD_PTR dwCallback;
- LPCSTR lpstrSoundName;
-} MCI_SOUND_PARMS, *LPMCI_SOUND_PARMS;
+typedef struct tagMCI_SOUND_PARMSA {
+ DWORD_PTR dwCallback;
+ LPCSTR lpstrSoundName;
+} MCI_SOUND_PARMSA, *LPMCI_SOUND_PARMSA;
-typedef struct tagMCI_SAVE_PARMS {
- DWORD_PTR dwCallback;
- LPCSTR lpfilename;
-} MCI_SAVE_PARMS, *LPMCI_SAVE_PARMS;
+typedef struct tagMCI_SOUND_PARMSW {
+ DWORD_PTR dwCallback;
+ LPCWSTR lpstrSoundName;
+} MCI_SOUND_PARMSW, *LPMCI_SOUND_PARMSW;
+
+DECL_WINELIB_TYPE_AW(MCI_SOUND_PARMS);
+DECL_WINELIB_TYPE_AW(LPMCI_SOUND_PARMS);
+
+typedef struct tagMCI_SAVE_PARMSA {
+ DWORD_PTR dwCallback;
+ LPCSTR lpfilename;
+} MCI_SAVE_PARMSA, *LPMCI_SAVE_PARMSA;
+
+typedef struct tagMCI_SAVE_PARMSW {
+ DWORD_PTR dwCallback;
+ LPCWSTR lpfilename;
+} MCI_SAVE_PARMSW, *LPMCI_SAVE_PARMSW;
+
+DECL_WINELIB_TYPE_AW(MCI_SAVE_PARMS);
+DECL_WINELIB_TYPE_AW(LPMCI_SAVE_PARMS);
typedef struct tagMCI_LOAD_PARMSA {
DWORD_PTR dwCallback;
