VPATH = @srcdir@
MODULE = winmm.dll
IMPORTS = user32 advapi32 kernel32 ntdll
+EXTRALIBS = $(LIBUNICODE)
C_SRCS = \
driver.c \
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
/*
* WINE Drivers functions
*
#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 */;
* 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 );
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);
}
/**************************************************************************
*
* 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;
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;}
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;
}
* (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
*/
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:
return (HDRVR)lpDrv;
}
-/**************************************************************************
- * 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.@]
* - 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"
#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;
}
/**************************************************************************
* MCI_GetDriverFromString [internal]
*/
-UINT MCI_GetDriverFromString(LPCSTR lpstrName)
+UINT MCI_GetDriverFromString(LPCWSTR lpstrName)
{
LPWINE_MCIDRIVER wmd;
UINT ret = 0;
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;
}
/**************************************************************************
* 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);
}
}
+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;
}
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];
*/
static BOOL MCI_IsCommandTableValid(UINT uTbl)
{
- LPCSTR lmem, str;
+ const BYTE* lmem;
+ LPCWSTR str;
DWORD flg;
WORD eid;
int idx = 0;
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;
}
*/
static BOOL MCI_DumpCommandTable(UINT uTbl)
{
- LPCSTR lmem;
- LPCSTR str;
+ const BYTE* lmem;
+ LPCWSTR str;
DWORD flg;
WORD eid;
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;
}
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++) {
/* 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);
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);
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;
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)
/**************************************************************************
* 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;
/**************************************************************************
* 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;
}
}
/**************************************************************************
* 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) {
/* 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;
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;
/**************************************************************************
* 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;
/**************************************************************************
* MCI_FindCommand [internal]
*/
-static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb)
+static LPCWSTR MCI_FindCommand(UINT uTbl, LPCWSTR verb)
{
UINT idx;
* 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];
}
/**************************************************************************
* 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);
}
/**************************************************************************
* 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;
/**************************************************************************
* 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");
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;
}
/**************************************************************************
* 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:
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;
!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");
}
} 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) {
* 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 */
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));
}
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));
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");
}
}
/**************************************************************************
- * 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;
}
}
/* 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;
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;
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 */
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;
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;
}
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;
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);
}
/**************************************************************************
- * 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;
}
* mciExecute [WINMM.@]
* mciExecute [MMSYSTEM.712]
*/
-DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
+BOOL WINAPI mciExecute(LPCSTR lpstrCommand)
{
char strRet[256];
DWORD ret;
MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
}
/* FIXME: what shall I return ? */
- return 0;
+ return TRUE;
}
/**************************************************************************
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;
{
TRACE("(%08x)!\n", uTable);
- return MCI_DeleteCommandTable(uTable);
+ return MCI_DeleteCommandTable(uTable, FALSE);
}
/**************************************************************************
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;
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;
}
}
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;
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 {
/**************************************************************************
* 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;
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
*/
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;
}
}
}
- 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");
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);
}
}
}
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;
/**************************************************************************
* 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;
/**************************************************************************
* 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;
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) {
*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");
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;
}
}
}
- 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);
/**************************************************************************
* 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)
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 */
}
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 */
}
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 */
}
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 */
}
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 */
}
}
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;
+}
#include "wownt32.h"
#include "mmddk.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mcianim);
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;
/**************************************************************************
* 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;
/**************************************************************************
* 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);
/*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");
}
/**************************************************************************
* 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);
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;
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;
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);
#include <string.h>
#include "private_mciavi.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
/***************************************************************************
* 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;
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;
/***************************************************************************
* 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;
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
/*
* Digital video MCI Wine Driver
#include <string.h>
#include "private_mciavi.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
/**************************************************************************
* 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;
* 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;
* 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))
/*****************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
/******************************************************************************
* 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;
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;
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);
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);
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:
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
};
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 */
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);
/* 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 */
default:
return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}
- return 0;
}
BOOL MCIAVI_UnregisterClass(void)
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;
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;
/***************************************************************************
* 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);
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);
VPATH = @srcdir@
MODULE = mcicda.drv
IMPORTS = winmm user32 kernel32
+EXTRALIBS = $(LIBUNICODE)
C_SRCS = \
mcicda.c
#include "ntddstor.h"
#include "ntddcdrm.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mcicda);
/**************************************************************************
* 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;
/**************************************************************************
* 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);
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;
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;
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;
/**************************************************************************
* 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);
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)) {
}
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;
}
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;
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);
#include "wownt32.h"
#include "mmddk.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mcimidi);
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) */
/**************************************************************************
* 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;
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;
}
/**************************************************************************
* 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;
/* 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);
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 {
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;
}
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:
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;
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)
/**************************************************************************
* 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);
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;
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);
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:
#include "wownt32.h"
#include "digitalv.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(mciwave);
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 */
/**************************************************************************
* 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;
/**************************************************************************
* 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;
*/
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
}
}
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;
}
}
*/
if (wmw->bTemporaryFile)
{
- HeapFree(GetProcessHeap(), 0, (char*)wmw->openParms.lpstrElementName);
+ HeapFree(GetProcessHeap(), 0, (WCHAR*)wmw->openParms.lpstrElementName);
wmw->openParms.lpstrElementName = NULL;
}
}
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;
}
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");
/**************************************************************************
* 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;
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;
}
/**************************************************************************
* 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);
} 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;
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;
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);
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:
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
/*
* MMSYSTEM MCI and low level mapping functions
*
* ================================= */
/**************************************************************************
- * 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:
* ================================= */
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
* ================================= */
/**************************************************************************
- * 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;
}
* ================================= */
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
* ================================= */
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
* ================================= */
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
}
/**************************************************************************
- * 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;
* M C I
* ================================= */
-/**************************************************************************
- * MCI_MapMsg16To32A [internal]
- */
-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]
+#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_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
*/
/**************************************************************************
- * 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
* 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;
}
/**************************************************************************
- * 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);
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;
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);
}
/**************************************************************************
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);
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;
}
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* MMIO functions
*
FIXME("unexpected message %u\n", uMessage);
return 0;
}
-
- return 0;
}
/* This array will be the entire list for most apps
/* 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);
}
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);
{
TRACE("(\"%s\")\n", lpstrName);
- return MCI_GetDriverFromString(lpstrName);
+ return mciGetDeviceIDA(lpstrName);
}
/**************************************************************************
/**************************************************************************
* midiOutGetErrorText [MMSYSTEM.203]
+ * midiInGetErrorText [MMSYSTEM.203]
*/
UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
{
return ret;
}
-/**************************************************************************
- * midiInGetErrorText [MMSYSTEM.303]
- */
-UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
-{
- return midiInGetErrorTextA(uError, lpText, uSize);
-}
-
/**************************************************************************
* midiInOpen [MMSYSTEM.304]
*/
/**************************************************************************
* waveOutGetErrorText [MMSYSTEM.403]
+ * waveInGetErrorText [MMSYSTEM.403]
*/
UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
{
return ret;
}
-/**************************************************************************
- * waveInGetErrorText [MMSYSTEM.503]
- */
-UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
-{
- return waveInGetErrorTextA(uError, lpText, uSize);
-}
-
/**************************************************************************
* waveInOpen [MMSYSTEM.504]
*/
*
* 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;
}
*/
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;
}
/**************************************************************************
{
TRACE("(%04x)!\n", uTable);
- return mciFreeCommandResource(uTable);
+ return MCI_DeleteCommandTable(uTable, TRUE);
}
/* ###################################################
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
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
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;
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;
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;
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);
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);
* 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);
#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);
return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
}
-/**************************************************************************
- * 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.@]
*/
}
/**************************************************************************
- * 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;
-
- 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)) {
+ UINT ret;
- 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;
}
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)
{
}
/**************************************************************************
- * 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;
-
- 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)) {
+ UINT ret;
- 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;
}
return ret;
}
-/**************************************************************************
- * 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.@]
*/
@ 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)
@ 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)
@ 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)
@ 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)
@ 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
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
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)
} 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)
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)
} 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;
http://git.etersoft.ru/projects / wine / eterwine.git / commitdiff