diff --git a/reactos/lib/winmm/Makefile.in b/reactos/lib/winmm/Makefile.in index de41d268018..238e4e8b4a4 100644 --- a/reactos/lib/winmm/Makefile.in +++ b/reactos/lib/winmm/Makefile.in @@ -5,6 +5,7 @@ SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = winmm.dll IMPORTS = user32 advapi32 kernel32 ntdll +EXTRALIBS = $(LIBUNICODE) C_SRCS = \ driver.c \ diff --git a/reactos/lib/winmm/driver.c b/reactos/lib/winmm/driver.c index dfc0f0791ce..f03902712eb 100644 --- a/reactos/lib/winmm/driver.c +++ b/reactos/lib/winmm/driver.c @@ -1,5 +1,3 @@ -/* -*- tab-width: 8; c-basic-offset: 4 -*- */ - /* * WINE Drivers functions * @@ -33,15 +31,16 @@ #include "mmddk.h" #include "winemm.h" #include "wine/debug.h" +#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(driver); -#define HKLM_BASE "Software\\Microsoft\\Windows NT\\CurrentVersion" - static LPWINE_DRIVER lpDrvItemList /* = NULL */; +static const WCHAR HKLM_BASE[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\', + 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0}; WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16 h) /* = NULL */; -LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */; +LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM) /* = NULL */; LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */; LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */; @@ -207,16 +206,19 @@ static BOOL DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lPar * DRIVER_GetLibName [internal] * */ -BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz) +BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz) { HKEY hKey, hSecKey; DWORD bufLen, lRet; + static const WCHAR wszSystemIni[] = {'S','Y','S','T','E','M','.','I','N','I',0}; + WCHAR wsznull = '\0'; - lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey); + lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey); if (lRet == ERROR_SUCCESS) { - lRet = RegOpenKeyExA(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey); + lRet = RegOpenKeyExW(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey); if (lRet == ERROR_SUCCESS) { - lRet = RegQueryValueExA(hSecKey, keyName, 0, 0, buf, &bufLen); + bufLen = sz; + lRet = RegQueryValueExW(hSecKey, keyName, 0, 0, (void*)buf, &bufLen); RegCloseKey( hSecKey ); } RegCloseKey( hKey ); @@ -224,7 +226,7 @@ BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz) if (lRet == ERROR_SUCCESS) return TRUE; /* default to system.ini if we can't find it in the registry, * to support native installations where system.ini is still used */ - return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI"); + return GetPrivateProfileStringW(sectName, keyName, &wsznull, buf, sz, wszSystemIni); } /************************************************************************** @@ -232,16 +234,16 @@ BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz) * * Tries to load a 32 bit driver whose DLL's (module) name is fn */ -LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2) +LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2) { LPWINE_DRIVER lpDrv = NULL; HMODULE hModule = 0; - LPSTR ptr; + LPWSTR ptr; LPCSTR cause = 0; - TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2); + TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2); - if ((ptr = strchr(fn, ' ')) != NULL) { + if ((ptr = strchrW(fn, ' ')) != NULL) { *ptr++ = '\0'; while (*ptr == ' ') ptr++; if (*ptr == '\0') ptr = NULL; @@ -250,7 +252,7 @@ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2) lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER)); if (lpDrv == NULL) {cause = "OOM"; goto exit;} - if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;} + if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;} lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc"); if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;} @@ -290,7 +292,7 @@ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2) exit: FreeLibrary(hModule); HeapFree(GetProcessHeap(), 0, lpDrv); - TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause); + TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause); return NULL; } @@ -301,23 +303,59 @@ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2) * (0,1,DRV_ENABLE,0 ,0) * (0,1,DRV_OPEN ,buf[256],0) */ -HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2) +HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam) +{ + INT len; + LPWSTR dn = NULL; + LPWSTR sn = NULL; + HDRVR ret; + + if (lpDriverName) + { + len = MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, NULL, 0 ); + dn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + if (!dn) return 0; + MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, dn, len ); + } + + if (lpSectionName) + { + len = MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, NULL, 0 ); + sn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + if (!sn) return 0; + MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, sn, len ); + } + + ret = OpenDriver(dn, sn, lParam); + + if (dn) HeapFree(GetProcessHeap(), 0, dn); + if (sn) HeapFree(GetProcessHeap(), 0, sn); + return ret; +} + +/************************************************************************** + * OpenDriver [WINMM.@] + * DrvOpen [WINMM.@] + */ +HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam) { LPWINE_DRIVER lpDrv = NULL; - char libName[128]; - LPCSTR lsn = lpSectionName; + WCHAR libName[128]; + LPCWSTR lsn = lpSectionName; - TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2); + TRACE("(%s, %s, 0x%08lx);\n", + debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam); if (lsn == NULL) { - lstrcpynA(libName, lpDriverName, sizeof(libName)); + static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0}; + lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR)); - if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2))) + if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam))) goto the_end; - lsn = "Drivers32"; + lsn = wszDrivers32; } if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) && - (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2))) + (lpDrv = DRIVER_TryOpenDriver32(libName, lParam))) goto the_end; /* now we will try a 16 bit driver (and add all the glue to make it work... which @@ -326,12 +364,13 @@ HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lPara */ 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: @@ -339,40 +378,6 @@ HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lPara 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.@] diff --git a/reactos/lib/winmm/mci.c b/reactos/lib/winmm/mci.c index ddf0a59770a..0ebeaa6b9e8 100644 --- a/reactos/lib/winmm/mci.c +++ b/reactos/lib/winmm/mci.c @@ -31,6 +31,15 @@ * - use a default registry setting to replace the [mci] section in * configuration file (layout of info in registry should be compatible * with all Windows' version - which use different layouts of course) + * - implement automatic open + * + only works on string interface, on regular devices (don't work on all + * nor custom devices) + * - command table handling isn't thread safe + */ + +/* to be cross checked: + * - heapalloc for *sizeof(WCHAR) when needed + * - size of string in WCHAR or bytes? (#chars for MCI_INFO, #bytes for MCI_SYSINFO) */ #include "config.h" @@ -49,34 +58,41 @@ #include "winuser.h" #include "winnls.h" #include "winreg.h" +#include "wownt32.h" #include "digitalv.h" #include "winemm.h" #include "wine/debug.h" +#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(mci); -WINMM_MapType (*pFnMciMapMsg16To32A) (WORD,WORD,DWORD*) /* = NULL */; -WINMM_MapType (*pFnMciUnMapMsg16To32A)(WORD,WORD,DWORD) /* = NULL */; -WINMM_MapType (*pFnMciMapMsg32ATo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */; -WINMM_MapType (*pFnMciUnMapMsg32ATo16)(WORD,WORD,DWORD,DWORD) /* = NULL */; +WINMM_MapType (*pFnMciMapMsg16To32W) (WORD,WORD,DWORD*) /* = NULL */; +WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD) /* = NULL */; +WINMM_MapType (*pFnMciMapMsg32WTo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */; +WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD) /* = NULL */; /* First MCI valid device ID (0 means error) */ #define MCI_MAGIC 0x0001 /* MCI settings */ -#define HKLM_MCI "Software\\Microsoft\\Windows NT\\CurrentVersion\\MCI" +static const WCHAR wszHklmMci [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','M','C','I',0}; +static const WCHAR wszNull [] = {0}; +static const WCHAR wszAll [] = {'A','L','L',0}; +static const WCHAR wszMci [] = {'M','C','I',0}; +static const WCHAR wszOpen [] = {'o','p','e','n',0}; +static const WCHAR wszSystemIni[] = {'s','y','s','t','e','m','.','i','n','i',0}; /* dup a string and uppercase it */ -inline static LPSTR str_dup_upper( LPCSTR str ) +inline static LPWSTR str_dup_upper( LPCWSTR str ) { - INT len = strlen(str) + 1; - LPSTR p = HeapAlloc( GetProcessHeap(), 0, len ); + INT len = (strlenW(str) + 1) * sizeof(WCHAR); + LPWSTR p = HeapAlloc( GetProcessHeap(), 0, len ); if (p) { memcpy( p, str, len ); - CharUpperA( p ); + CharUpperW( p ); } return p; } @@ -100,7 +116,7 @@ LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) /************************************************************************** * MCI_GetDriverFromString [internal] */ -UINT MCI_GetDriverFromString(LPCSTR lpstrName) +UINT MCI_GetDriverFromString(LPCWSTR lpstrName) { LPWINE_MCIDRIVER wmd; UINT ret = 0; @@ -108,20 +124,20 @@ UINT MCI_GetDriverFromString(LPCSTR lpstrName) if (!lpstrName) return 0; - if (!lstrcmpiA(lpstrName, "ALL")) + if (!strcmpiW(lpstrName, wszAll)) return MCI_ALL_DEVICE_ID; EnterCriticalSection(&WINMM_IData->cs); for (wmd = WINMM_IData->lpMciDrvs; wmd; wmd = wmd->lpNext) { - if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) { + if (wmd->lpstrElementName && strcmpW(wmd->lpstrElementName, lpstrName) == 0) { ret = wmd->wDeviceID; break; } - if (wmd->lpstrDeviceType && strcasecmp(wmd->lpstrDeviceType, lpstrName) == 0) { + if (wmd->lpstrDeviceType && strcmpiW(wmd->lpstrDeviceType, lpstrName) == 0) { ret = wmd->wDeviceID; break; } - if (wmd->lpstrAlias && strcasecmp(wmd->lpstrAlias, lpstrName) == 0) { + if (wmd->lpstrAlias && strcmpiW(wmd->lpstrAlias, lpstrName) == 0) { ret = wmd->wDeviceID; break; } @@ -134,13 +150,26 @@ UINT MCI_GetDriverFromString(LPCSTR lpstrName) /************************************************************************** * MCI_MessageToString [internal] */ -const char* MCI_MessageToString(UINT16 wMsg) +const char* MCI_MessageToString(UINT wMsg) { static char buffer[100]; #define CASE(s) case (s): return #s switch (wMsg) { + CASE(DRV_LOAD); + CASE(DRV_ENABLE); + CASE(DRV_OPEN); + CASE(DRV_CLOSE); + CASE(DRV_DISABLE); + CASE(DRV_FREE); + CASE(DRV_CONFIGURE); + CASE(DRV_QUERYCONFIGURE); + CASE(DRV_INSTALL); + CASE(DRV_REMOVE); + CASE(DRV_EXITSESSION); + CASE(DRV_EXITAPPLICATION); + CASE(DRV_POWER); CASE(MCI_BREAK); CASE(MCI_CLOSE); CASE(MCI_CLOSE_DRIVER); @@ -193,23 +222,350 @@ const char* MCI_MessageToString(UINT16 wMsg) } } +LPWSTR MCI_strdupAtoW( LPCSTR str ) +{ + LPWSTR ret; + INT len; + + if (!str) return NULL; + len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 ); + ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len ); + return ret; +} + +LPSTR MCI_strdupWtoA( LPCWSTR str ) +{ + LPSTR ret; + INT len; + + if (!str) return NULL; + len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL ); + ret = HeapAlloc( GetProcessHeap(), 0, len ); + if (ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL ); + return ret; +} + +static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2) +{ + if (msg < DRV_RESERVED) return 0; + + switch (msg) + { + case MCI_CLOSE: + case MCI_CONFIGURE: + case MCI_PLAY: + case MCI_SEEK: + case MCI_STOP: + case MCI_PAUSE: + case MCI_GETDEVCAPS: + case MCI_SPIN: + case MCI_SET: + case MCI_STEP: + case MCI_RECORD: + case MCI_BREAK: + case MCI_SOUND: + case MCI_STATUS: + case MCI_CUE: + case MCI_REALIZE: + case MCI_PUT: + case MCI_WHERE: + case MCI_FREEZE: + case MCI_UNFREEZE: + case MCI_CUT: + case MCI_COPY: + case MCI_PASTE: + case MCI_UPDATE: + case MCI_RESUME: + case MCI_DELETE: + return 0; + + case MCI_OPEN: + { + MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA*)*dwParam2; + MCI_OPEN_PARMSW *mci_openW; + DWORD_PTR *ptr; + + ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD_PTR) + sizeof(*mci_openW) + 2 * sizeof(DWORD)); + if (!ptr) return -1; + + *ptr++ = *dwParam2; /* save the previous pointer */ + *dwParam2 = (DWORD_PTR)ptr; + mci_openW = (MCI_OPEN_PARMSW *)ptr; + + if (dwParam1 & MCI_NOTIFY) + mci_openW->dwCallback = mci_openA->dwCallback; + + if (dwParam1 & MCI_OPEN_TYPE) + { + if (dwParam1 & MCI_OPEN_TYPE_ID) + mci_openW->lpstrDeviceType = (LPWSTR)mci_openA->lpstrDeviceType; + else + mci_openW->lpstrDeviceType = MCI_strdupAtoW(mci_openA->lpstrDeviceType); + } + if (dwParam1 & MCI_OPEN_ELEMENT) + { + if (dwParam1 & MCI_OPEN_ELEMENT_ID) + mci_openW->lpstrElementName = (LPWSTR)mci_openA->lpstrElementName; + else + mci_openW->lpstrElementName = MCI_strdupAtoW(mci_openA->lpstrElementName); + } + if (dwParam1 & MCI_OPEN_ALIAS) + mci_openW->lpstrAlias = MCI_strdupAtoW(mci_openA->lpstrAlias); + /* FIXME: this is only needed for specific types of MCI devices, and + * may cause a segfault if the two DWORD:s don't exist at the end of + * mci_openA + */ + memcpy(mci_openW + 1, mci_openA + 1, 2 * sizeof(DWORD)); + } + return 1; + + case MCI_WINDOW: + if (dwParam1 & MCI_ANIM_WINDOW_TEXT) + { + MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)*dwParam2; + MCI_ANIM_WINDOW_PARMSW *mci_windowW; + + mci_windowW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowW)); + if (!mci_windowW) return -1; + + *dwParam2 = (DWORD_PTR)mci_windowW; + + mci_windowW->lpstrText = MCI_strdupAtoW(mci_windowA->lpstrText); + + if (dwParam1 & MCI_NOTIFY) + mci_windowW->dwCallback = mci_windowA->dwCallback; + if (dwParam1 & MCI_ANIM_WINDOW_HWND) + mci_windowW->hWnd = mci_windowA->hWnd; + if (dwParam1 & MCI_ANIM_WINDOW_STATE) + mci_windowW->nCmdShow = mci_windowA->nCmdShow; + + return 1; + } + return 0; + + case MCI_SYSINFO: + { + MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*dwParam2; + MCI_SYSINFO_PARMSW *mci_sysinfoW; + DWORD_PTR *ptr; + + ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoW) + sizeof(DWORD_PTR)); + if (!ptr) return -1; + + *ptr++ = *dwParam2; /* save the previous pointer */ + *dwParam2 = (DWORD_PTR)ptr; + mci_sysinfoW = (MCI_SYSINFO_PARMSW *)ptr; + + if (dwParam1 & MCI_NOTIFY) + mci_sysinfoW->dwCallback = mci_sysinfoA->dwCallback; + + mci_sysinfoW->dwRetSize = mci_sysinfoA->dwRetSize; + mci_sysinfoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoW->dwRetSize); + mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber; + mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType; + return 1; + } + case MCI_INFO: + { + MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*dwParam2; + MCI_INFO_PARMSW *mci_infoW; + DWORD_PTR *ptr; + + ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_infoW) + sizeof(DWORD_PTR)); + if (!ptr) return -1; + + *ptr++ = *dwParam2; /* save the previous pointer */ + *dwParam2 = (DWORD_PTR)ptr; + mci_infoW = (MCI_INFO_PARMSW *)ptr; + + if (dwParam1 & MCI_NOTIFY) + mci_infoW->dwCallback = mci_infoA->dwCallback; + + mci_infoW->dwRetSize = mci_infoA->dwRetSize * sizeof(WCHAR); /* it's not the same as SYSINFO !!! */ + mci_infoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_infoW->dwRetSize); + return 1; + } + case MCI_SAVE: + { + MCI_SAVE_PARMSA *mci_saveA = (MCI_SAVE_PARMSA *)*dwParam2; + MCI_SAVE_PARMSW *mci_saveW; + + mci_saveW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_saveW)); + if (!mci_saveW) return -1; + + *dwParam2 = (DWORD_PTR)mci_saveW; + if (dwParam1 & MCI_NOTIFY) + mci_saveW->dwCallback = mci_saveA->dwCallback; + mci_saveW->lpfilename = MCI_strdupAtoW(mci_saveA->lpfilename); + return 1; + } + case MCI_LOAD: + { + MCI_LOAD_PARMSA *mci_loadA = (MCI_LOAD_PARMSA *)*dwParam2; + MCI_LOAD_PARMSW *mci_loadW; + + mci_loadW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_loadW)); + if (!mci_loadW) return -1; + + *dwParam2 = (DWORD_PTR)mci_loadW; + if (dwParam1 & MCI_NOTIFY) + mci_loadW->dwCallback = mci_loadA->dwCallback; + mci_loadW->lpfilename = MCI_strdupAtoW(mci_loadA->lpfilename); + return 1; + } + + case MCI_ESCAPE: + { + MCI_VD_ESCAPE_PARMSA *mci_vd_escapeA = (MCI_VD_ESCAPE_PARMSA *)*dwParam2; + MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW; + + mci_vd_escapeW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_vd_escapeW)); + if (!mci_vd_escapeW) return -1; + + *dwParam2 = (DWORD_PTR)mci_vd_escapeW; + if (dwParam1 & MCI_NOTIFY) + mci_vd_escapeW->dwCallback = mci_vd_escapeA->dwCallback; + mci_vd_escapeW->lpstrCommand = MCI_strdupAtoW(mci_vd_escapeA->lpstrCommand); + return 1; + } + default: + FIXME("Message %s needs translation\n", MCI_MessageToString(msg)); + return -1; + } +} + +static DWORD MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, + DWORD result) +{ + switch (msg) + { + case MCI_OPEN: + { + DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1; + MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)*ptr; + MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)(ptr + 1); + + mci_openA->wDeviceID = mci_openW->wDeviceID; + + if (dwParam1 & MCI_OPEN_TYPE) + { + if (!(dwParam1 & MCI_OPEN_TYPE_ID)) + HeapFree(GetProcessHeap(), 0, mci_openW->lpstrDeviceType); + } + if (dwParam1 & MCI_OPEN_ELEMENT) + { + if (!(dwParam1 & MCI_OPEN_ELEMENT_ID)) + HeapFree(GetProcessHeap(), 0, mci_openW->lpstrElementName); + } + if (dwParam1 & MCI_OPEN_ALIAS) + HeapFree(GetProcessHeap(), 0, mci_openW->lpstrAlias); + HeapFree(GetProcessHeap(), 0, ptr); + } + break; + case MCI_WINDOW: + if (dwParam1 & MCI_ANIM_WINDOW_TEXT) + { + MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_windowW->lpstrText); + HeapFree(GetProcessHeap(), 0, mci_windowW); + } + break; + + case MCI_SYSINFO: + { + DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1; + MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*ptr; + MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)(ptr + 1); + + if (!result) + { + mci_sysinfoA->dwNumber = mci_sysinfoW->dwNumber; + mci_sysinfoA->wDeviceType = mci_sysinfoW->wDeviceType; + if (dwParam1 & MCI_SYSINFO_QUANTITY) + *(DWORD*)mci_sysinfoA->lpstrReturn = *(DWORD*)mci_sysinfoW->lpstrReturn; + else + WideCharToMultiByte(CP_ACP, 0, + mci_sysinfoW->lpstrReturn, mci_sysinfoW->dwRetSize, + mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize, + NULL, NULL); + } + + HeapFree(GetProcessHeap(), 0, mci_sysinfoW->lpstrReturn); + HeapFree(GetProcessHeap(), 0, ptr); + } + break; + case MCI_INFO: + { + DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1; + MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*ptr; + MCI_INFO_PARMSW *mci_infoW = (MCI_INFO_PARMSW *)(ptr + 1); + + if (!result) + { + WideCharToMultiByte(CP_ACP, 0, + mci_infoW->lpstrReturn, mci_infoW->dwRetSize / sizeof(WCHAR), + mci_infoA->lpstrReturn, mci_infoA->dwRetSize, + NULL, NULL); + } + + HeapFree(GetProcessHeap(), 0, mci_infoW->lpstrReturn); + HeapFree(GetProcessHeap(), 0, ptr); + } + break; + case MCI_SAVE: + { + MCI_SAVE_PARMSW *mci_saveW = (MCI_SAVE_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_saveW->lpfilename); + HeapFree(GetProcessHeap(), 0, mci_saveW); + } + break; + case MCI_LOAD: + { + MCI_LOAD_PARMSW *mci_loadW = (MCI_LOAD_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_loadW->lpfilename); + HeapFree(GetProcessHeap(), 0, mci_loadW); + } + break; + case MCI_ESCAPE: + { + MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW = (MCI_VD_ESCAPE_PARMSW *)dwParam2; + + HeapFree(GetProcessHeap(), 0, (void*)mci_vd_escapeW->lpstrCommand); + HeapFree(GetProcessHeap(), 0, mci_vd_escapeW); + } + break; + + default: + FIXME("Message %s needs unmapping\n", MCI_MessageToString(msg)); + break; + } + + return result; +} + /************************************************************************** * MCI_GetDevTypeFromFileName [internal] */ -static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len) +static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPCWSTR buf, UINT len) { - LPSTR tmp; + LPCWSTR tmp; HKEY hKey; - - if ((tmp = strrchr(fileName, '.'))) { - if (RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\MCI Extensions", + static const WCHAR keyW[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\', + 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', + 'M','C','I',' ','E','x','t','e','n','s','i','o','n','s',0}; + if ((tmp = strrchrW(fileName, '.'))) { + if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, keyW, 0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) { DWORD dwLen = len; - LONG lRet = RegQueryValueExA( hKey, tmp + 1, 0, 0, buf, &dwLen ); + LONG lRet = RegQueryValueExW( hKey, tmp + 1, 0, 0, (void*)buf, &dwLen ); RegCloseKey( hKey ); if (lRet == ERROR_SUCCESS) return 0; } - TRACE("No ...\\MCI Extensions entry for '%s' found.\n", tmp); + TRACE("No ...\\MCI Extensions entry for %s found.\n", debugstr_w(tmp)); } return MCIERR_EXTENSION_NOT_FOUND; } @@ -219,9 +575,9 @@ static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len) typedef struct tagWINE_MCICMDTABLE { UINT uDevType; - LPCSTR lpTable; + const BYTE* lpTable; UINT nVerbs; /* number of verbs in command table */ - LPCSTR* aVerbs; /* array of verbs to speed up the verb look up process */ + LPCWSTR* aVerbs; /* array of verbs to speed up the verb look up process */ } WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE; static WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE]; @@ -231,7 +587,8 @@ static 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; @@ -245,28 +602,26 @@ static BOOL MCI_IsCommandTableValid(UINT uTbl) lmem = S_MciCmdTable[uTbl].lpTable; do { - do { - str = lmem; - lmem += strlen(lmem) + 1; - flg = *(const DWORD*)lmem; - eid = *(const WORD*)(lmem + sizeof(DWORD)); - lmem += sizeof(DWORD) + sizeof(WORD); - idx ++; - /* EPP TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */ - switch (eid) { - case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */ - case MCI_STRING: if (inCst) return FALSE; break; - case MCI_INTEGER: if (!*str) return FALSE; break; - case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break; - case MCI_RETURN: if (*str || idx != 1) return FALSE; break; - case MCI_FLAG: if (!*str) return FALSE; break; - case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break; - case MCI_RECT: if (!*str || inCst) return FALSE; break; - case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break; - case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break; - default: return FALSE; - } - } while (eid != MCI_END_COMMAND_LIST); + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); + flg = *(const DWORD*)lmem; + eid = *(const WORD*)(lmem + sizeof(DWORD)); + lmem += sizeof(DWORD) + sizeof(WORD); + idx ++; + /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */ + switch (eid) { + case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */ + case MCI_STRING: if (inCst) return FALSE; break; + case MCI_INTEGER: if (!*str) return FALSE; break; + case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break; + case MCI_RETURN: if (*str || idx != 1) return FALSE; break; + case MCI_FLAG: if (!*str) return FALSE; break; + case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break; + case MCI_RECT: if (!*str || inCst) return FALSE; break; + case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break; + case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break; + default: return FALSE; + } } while (eid != MCI_END_COMMAND_LIST); return TRUE; } @@ -276,8 +631,8 @@ static BOOL MCI_IsCommandTableValid(UINT uTbl) */ static BOOL MCI_DumpCommandTable(UINT uTbl) { - LPCSTR lmem; - LPCSTR str; + const BYTE* lmem; + LPCWSTR str; DWORD flg; WORD eid; @@ -289,14 +644,14 @@ static BOOL MCI_DumpCommandTable(UINT uTbl) lmem = S_MciCmdTable[uTbl].lpTable; do { do { - str = lmem; - lmem += strlen(lmem) + 1; + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); flg = *(const DWORD*)lmem; eid = *(const WORD*)(lmem + sizeof(DWORD)); - TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); + /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */ lmem += sizeof(DWORD) + sizeof(WORD); } while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST); - TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); + /* EPP TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); */ } while (eid != MCI_END_COMMAND_LIST); return TRUE; } @@ -308,8 +663,8 @@ static BOOL MCI_DumpCommandTable(UINT uTbl) static UINT MCI_GetCommandTable(UINT uDevType) { UINT uTbl; - char buf[32]; - LPCSTR str = NULL; + WCHAR buf[32]; + LPCWSTR str = NULL; /* first look up existing for existing devType */ for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) { @@ -319,15 +674,16 @@ static UINT MCI_GetCommandTable(UINT uDevType) /* well try to load id */ if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) { - if (LoadStringA(WINMM_IData->hWinMM32Instance, uDevType, buf, sizeof(buf))) { + if (LoadStringW(WINMM_IData->hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) { str = buf; } } else if (uDevType == 0) { - str = "CORE"; + static const WCHAR wszCore[] = {'C','O','R','E',0}; + str = wszCore; } uTbl = MCI_NO_COMMAND_TABLE; if (str) { - HRSRC hRsrc = FindResourceA(WINMM_IData->hWinMM32Instance, str, (LPCSTR)RT_RCDATA); + HRSRC hRsrc = FindResourceW(WINMM_IData->hWinMM32Instance, str, (LPCWSTR)RT_RCDATA); HANDLE hMem = 0; if (hRsrc) hMem = LoadResource(WINMM_IData->hWinMM32Instance, hRsrc); @@ -335,7 +691,7 @@ static UINT MCI_GetCommandTable(UINT uDevType) uTbl = MCI_SetCommandTable(LockResource(hMem), uDevType); } else { WARN("No command table found in resource %p[%s]\n", - WINMM_IData->hWinMM32Instance, str); + WINMM_IData->hWinMM32Instance, debugstr_w(str)); } } TRACE("=> %d\n", uTbl); @@ -359,10 +715,11 @@ UINT MCI_SetCommandTable(void *table, UINT uDevType) bInitDone = TRUE; MCI_GetCommandTable(0); } - + TRACE("(%p, %u)\n", table, uDevType); for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) { if (!S_MciCmdTable[uTbl].lpTable) { - LPCSTR lmem, str; + const BYTE* lmem; + LPCWSTR str; WORD eid; WORD count; @@ -378,21 +735,22 @@ UINT MCI_SetCommandTable(void *table, UINT uDevType) lmem = S_MciCmdTable[uTbl].lpTable; count = 0; do { - lmem += strlen(lmem) + 1; + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); eid = *(const WORD*)(lmem + sizeof(DWORD)); lmem += sizeof(DWORD) + sizeof(WORD); if (eid == MCI_COMMAND_HEAD) count++; } while (eid != MCI_END_COMMAND_LIST); - S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCSTR)); + S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCWSTR)); S_MciCmdTable[uTbl].nVerbs = count; lmem = S_MciCmdTable[uTbl].lpTable; count = 0; do { - str = lmem; - lmem += strlen(lmem) + 1; + str = (LPCWSTR)lmem; + lmem += (strlenW(str) + 1) * sizeof(WCHAR); eid = *(const WORD*)(lmem + sizeof(DWORD)); lmem += sizeof(DWORD) + sizeof(WORD); if (eid == MCI_COMMAND_HEAD) @@ -409,11 +767,12 @@ UINT MCI_SetCommandTable(void *table, UINT uDevType) /************************************************************************** * MCI_DeleteCommandTable [internal] */ -static BOOL MCI_DeleteCommandTable(UINT uTbl) +BOOL MCI_DeleteCommandTable(UINT uTbl, BOOL delete) { if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].lpTable) return FALSE; + if (delete) HeapFree(GetProcessHeap(), 0, (void*)S_MciCmdTable[uTbl].lpTable); S_MciCmdTable[uTbl].lpTable = NULL; HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs); S_MciCmdTable[uTbl].aVerbs = 0; @@ -455,33 +814,33 @@ static BOOL MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd) /************************************************************************** * MCI_OpenMciDriver [internal] */ -static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCSTR drvTyp, LPARAM lp) +static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, LPARAM lp) { - char libName[128]; + WCHAR libName[128]; - if (!DRIVER_GetLibName(drvTyp, "mci", libName, sizeof(libName))) + if (!DRIVER_GetLibName(drvTyp, wszMci, libName, sizeof(libName))) return FALSE; wmd->bIs32 = 0xFFFF; /* First load driver */ if ((wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp))) { wmd->bIs32 = TRUE; - } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32ATo16) { + } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32WTo16) { WINMM_MapType res; - switch (res = pFnMciMapMsg32ATo16(0, DRV_OPEN, 0, &lp)) { + switch (res = pFnMciMapMsg32WTo16(0, DRV_OPEN, 0, &lp)) { case WINMM_MAP_MSGERROR: TRACE("Not handled yet (DRV_OPEN)\n"); break; case WINMM_MAP_NOMEM: - TRACE("Problem mapping msg=DRV_OPEN from 32a to 16\n"); + TRACE("Problem mapping msg=DRV_OPEN from 32W to 16\n"); break; case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - if ((wmd->hDriver = OpenDriverA(drvTyp, "mci", lp))) + if ((wmd->hDriver = OpenDriver(drvTyp, wszMci, lp))) wmd->bIs32 = FALSE; if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg32ATo16(0, DRV_OPEN, 0, lp); + pFnMciUnMapMsg32WTo16(0, DRV_OPEN, 0, lp); break; } } @@ -491,11 +850,11 @@ static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCSTR drvTyp, LPARAM lp) /************************************************************************** * MCI_LoadMciDriver [internal] */ -static DWORD MCI_LoadMciDriver(LPCSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) +static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) { - LPSTR strDevTyp = str_dup_upper(_strDevTyp); + LPWSTR strDevTyp = str_dup_upper(_strDevTyp); LPWINE_MCIDRIVER wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd)); - MCI_OPEN_DRIVER_PARMSA modp; + MCI_OPEN_DRIVER_PARMSW modp; DWORD dwRet = 0; if (!wmd || !strDevTyp) { @@ -530,13 +889,13 @@ static DWORD MCI_LoadMciDriver(LPCSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) /* silence warning if all is used... some bogus program use commands like * 'open all'... */ - if (strcasecmp(strDevTyp, "all") == 0) { + if (strcmpiW(strDevTyp, wszAll) == 0) { dwRet = MCIERR_CANNOT_USE_ALL; } else { FIXME("Couldn't load driver for type %s.\n" "If you don't have a windows installation accessible from Wine,\n" "you perhaps forgot to create a [mci] section in system.ini\n", - strDevTyp); + debugstr_w(strDevTyp)); dwRet = MCIERR_DEVICE_NOT_INSTALLED; } goto errCleanUp; @@ -551,7 +910,7 @@ static DWORD MCI_LoadMciDriver(LPCSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED; TRACE("Loaded driver %p (%s), type is %d, cmdTable=%08x\n", - wmd->hDriver, strDevTyp, modp.wType, modp.wCustomCommandTable); + wmd->hDriver, debugstr_w(strDevTyp), modp.wType, modp.wCustomCommandTable); wmd->lpstrDeviceType = strDevTyp; wmd->wType = modp.wType; @@ -570,18 +929,18 @@ errCleanUp: /************************************************************************** * MCI_FinishOpen [internal] */ -static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms, +static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSW lpParms, DWORD dwParam) { if (dwParam & MCI_OPEN_ELEMENT) { - wmd->lpstrElementName = HeapAlloc(GetProcessHeap(),0,strlen(lpParms->lpstrElementName)+1); - strcpy( wmd->lpstrElementName, lpParms->lpstrElementName ); + wmd->lpstrElementName = HeapAlloc(GetProcessHeap(),0,(strlenW(lpParms->lpstrElementName)+1) * sizeof(WCHAR)); + strcpyW( wmd->lpstrElementName, lpParms->lpstrElementName ); } if (dwParam & MCI_OPEN_ALIAS) { - wmd->lpstrAlias = HeapAlloc(GetProcessHeap(), 0, strlen(lpParms->lpstrAlias)+1); - strcpy( wmd->lpstrAlias, lpParms->lpstrAlias); + wmd->lpstrAlias = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpParms->lpstrAlias)+1) * sizeof(WCHAR)); + strcpyW( wmd->lpstrAlias, lpParms->lpstrAlias); } lpParms->wDeviceID = wmd->wDeviceID; @@ -592,7 +951,7 @@ static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms, /************************************************************************** * MCI_FindCommand [internal] */ -static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb) +static LPCWSTR MCI_FindCommand(UINT uTbl, LPCWSTR verb) { UINT idx; @@ -604,7 +963,7 @@ static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb) * array look up */ for (idx = 0; idx < S_MciCmdTable[uTbl].nVerbs; idx++) { - if (strcasecmp(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0) + if (strcmpiW(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0) return S_MciCmdTable[uTbl].aVerbs[idx]; } @@ -614,9 +973,9 @@ static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb) /************************************************************************** * MCI_GetReturnType [internal] */ -static DWORD MCI_GetReturnType(LPCSTR lpCmd) +static DWORD MCI_GetReturnType(LPCWSTR lpCmd) { - lpCmd += strlen(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD); + lpCmd += strlenW(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD); if (*lpCmd == '\0' && *(const WORD*)(lpCmd + 1 + sizeof(DWORD)) == MCI_RETURN) { return *(const DWORD*)(lpCmd + 1); } @@ -626,20 +985,20 @@ static DWORD MCI_GetReturnType(LPCSTR lpCmd) /************************************************************************** * MCI_GetMessage [internal] */ -static WORD MCI_GetMessage(LPCSTR lpCmd) +static WORD MCI_GetMessage(LPCWSTR lpCmd) { - return (WORD)*(const DWORD*)(lpCmd + strlen(lpCmd) + 1); + return (WORD)*(const DWORD*)(lpCmd + strlenW(lpCmd) + 1); } /************************************************************************** * MCI_GetDWord [internal] */ -static BOOL MCI_GetDWord(LPDWORD data, LPSTR* ptr) +static BOOL MCI_GetDWord(LPDWORD data, LPWSTR* ptr) { DWORD val; - LPSTR ret; + LPWSTR ret; - val = strtoul(*ptr, &ret, 0); + val = strtoulW(*ptr, &ret, 0); switch (*ret) { case '\0': break; @@ -655,13 +1014,13 @@ static BOOL MCI_GetDWord(LPDWORD data, LPSTR* ptr) /************************************************************************** * MCI_GetString [internal] */ -static DWORD MCI_GetString(LPSTR* str, LPSTR* args) +static DWORD MCI_GetString(LPWSTR* str, LPWSTR* args) { - LPSTR ptr = *args; + LPWSTR ptr = *args; /* see if we have a quoted string */ if (*ptr == '"') { - ptr = strchr(*str = ptr + 1, '"'); + ptr = strchrW(*str = ptr + 1, '"'); if (!ptr) return MCIERR_NO_CLOSING_QUOTE; /* FIXME: shall we escape \" from string ?? */ if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n"); @@ -669,12 +1028,12 @@ static DWORD MCI_GetString(LPSTR* str, LPSTR* args) if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS; *ptr++ = '\0'; } else { - ptr = strchr(ptr, ' '); + ptr = strchrW(ptr, ' '); if (ptr) { *ptr++ = '\0'; } else { - ptr = *args + strlen(*args); + ptr = *args + strlenW(*args); } *str = *args; } @@ -688,32 +1047,33 @@ static DWORD MCI_GetString(LPSTR* str, LPSTR* 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: @@ -727,7 +1087,7 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd, break; } - if (strncasecmp(args, str, len) == 0 && + if (strncmpiW(args, str, len) == 0 && (args[len] == 0 || args[len] == ' ')) { /* store good values into data[] */ args += len; @@ -764,13 +1124,13 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd, !MCI_GetDWord(&(data[offset+1]), &args) || !MCI_GetDWord(&(data[offset+2]), &args) || !MCI_GetDWord(&(data[offset+3]), &args)) { - ERR("Bad rect '%s'\n", args); + ERR("Bad rect %s\n", debugstr_w(args)); return MCIERR_BAD_INTEGER; } break; case MCI_STRING: *dwFlags |= flg; - if ((dwRet = MCI_GetString((LPSTR*)&data[offset], &args))) + if ((dwRet = MCI_GetString((LPWSTR*)&data[offset], &args))) return dwRet; break; default: ERR("oops\n"); @@ -795,7 +1155,7 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd, } } while (eid != MCI_END_COMMAND); if (!found) { - WARN("Optarg '%s' not found\n", args); + WARN("Optarg %s not found\n", debugstr_w(args)); return MCIERR_UNRECOGNIZED_COMMAND; } if (offset == MCI_DATA_SIZE) { @@ -810,8 +1170,13 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd, * MCI_HandleReturnValues [internal] */ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType, - LPDWORD data, LPSTR lpstrRet, UINT uRetLen) + LPDWORD data, LPWSTR lpstrRet, UINT uRetLen) { + static const WCHAR wszLd [] = {'%','l','d',0}; + static const WCHAR wszLd4 [] = {'%','l','d',' ','%','l','d',' ','%','l','d',' ','%','l','d',0}; + static const WCHAR wszCol3[] = {'%','d',':','%','d',':','%','d',0}; + static const WCHAR wszCol4[] = {'%','d',':','%','d',':','%','d',':','%','d',0}; + if (lpstrRet) { switch (retType) { case 0: /* nothing to return */ @@ -820,30 +1185,30 @@ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD ret switch (dwRet & 0xFFFF0000ul) { case 0: case MCI_INTEGER_RETURNED: - snprintf(lpstrRet, uRetLen, "%ld", data[1]); + snprintfW(lpstrRet, uRetLen, wszLd, data[1]); break; case MCI_RESOURCE_RETURNED: /* return string which ID is HIWORD(data[1]), * string is loaded from mmsystem.dll */ - LoadStringA(WINMM_IData->hWinMM32Instance, HIWORD(data[1]), + LoadStringW(WINMM_IData->hWinMM32Instance, HIWORD(data[1]), lpstrRet, uRetLen); break; case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER: /* return string which ID is HIWORD(data[1]), * string is loaded from driver */ /* FIXME: this is wrong for a 16 bit handle */ - LoadStringA(GetDriverModuleHandle(wmd->hDriver), + LoadStringW(GetDriverModuleHandle(wmd->hDriver), HIWORD(data[1]), lpstrRet, uRetLen); break; case MCI_COLONIZED3_RETURN: - snprintf(lpstrRet, uRetLen, "%d:%d:%d", - LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])), - LOBYTE(HIWORD(data[1]))); + snprintfW(lpstrRet, uRetLen, wszCol3, + LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])), + LOBYTE(HIWORD(data[1]))); break; case MCI_COLONIZED4_RETURN: - snprintf(lpstrRet, uRetLen, "%d:%d:%d:%d", - LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])), - LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1]))); + snprintfW(lpstrRet, uRetLen, wszCol4, + LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])), + LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1]))); break; default: ERR("Ooops (%04X)\n", HIWORD(dwRet)); } @@ -855,7 +1220,7 @@ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD ret break; case MCI_INTEGER_RETURNED: data[1] = *(LPDWORD)lpstrRet; - snprintf(lpstrRet, uRetLen, "%ld", data[1]); + snprintfW(lpstrRet, uRetLen, wszLd, data[1]); break; default: WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet)); @@ -865,8 +1230,8 @@ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD ret case MCI_RECT: if (dwRet & 0xFFFF0000ul) WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet)); - snprintf(lpstrRet, uRetLen, "%ld %ld %ld %ld", - data[1], data[2], data[3], data[4]); + snprintfW(lpstrRet, uRetLen, wszLd4, + data[1], data[2], data[3], data[4]); break; default: ERR("oops\n"); } @@ -875,32 +1240,35 @@ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD ret } /************************************************************************** - * 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 */ - if (!(verb = HeapAlloc(GetProcessHeap(), 0, strlen(lpstrCommand)+1))) + if (!(verb = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpstrCommand)+1) * sizeof(WCHAR)))) return MCIERR_OUT_OF_MEMORY; - strcpy( verb, lpstrCommand ); - CharLowerA(verb); + strcpyW( verb, lpstrCommand ); + CharLowerW(verb); memset(data, 0, sizeof(data)); - if (!(args = strchr(verb, ' '))) { + if (!(args = strchrW(verb, ' '))) { dwRet = MCIERR_MISSING_DEVICE_NAME; goto errCleanUp; } @@ -910,17 +1278,17 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, } /* case dev == 'new' has to be handled */ - if (!strcmp(dev, "new")) { + if (!strcmpW(dev, wszNew)) { FIXME("'new': NIY as device name\n"); dwRet = MCIERR_MISSING_DEVICE_NAME; goto errCleanUp; } /* otherwise, try to grab devType from open */ - if (!strcmp(verb, "open")) { - LPSTR devType, tmp; + if (!strcmpW(verb, wszOpen)) { + LPWSTR devType, tmp; - if ((devType = strchr(dev, '!')) != NULL) { + if ((devType = strchrW(dev, '!')) != NULL) { *devType++ = '\0'; tmp = devType; devType = dev; dev = tmp; @@ -929,23 +1297,24 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, devType = str_dup_upper(devType); dwFlags |= MCI_OPEN_ELEMENT; data[3] = (DWORD)dev; - } else if (strchr(dev, '.') == NULL) { - tmp = strchr(dev,' '); + } else if (strchrW(dev, '.') == NULL) { + tmp = strchrW(dev,' '); if (tmp) *tmp = '\0'; data[2] = (DWORD)dev; devType = str_dup_upper(dev); if (tmp) *tmp = ' '; dwFlags |= MCI_OPEN_TYPE; } else { - if ((devType = strstr(args, "type ")) != NULL) { + static const WCHAR wszTypeS[] = {'t','y','p','e',' ',0}; + if ((devType = strstrW(args, wszTypeS)) != NULL) { devType += 5; - tmp = strchr(devType, ' '); + tmp = strchrW(devType, ' '); if (tmp) *tmp = '\0'; devType = str_dup_upper(devType); if (tmp) *tmp = ' '; /* dwFlags and data[2] will be correctly set in ParseOpt loop */ } else { - char buf[32]; + WCHAR buf[32]; if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf)))) goto errCleanUp; @@ -954,13 +1323,13 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, dwFlags |= MCI_OPEN_ELEMENT; data[3] = (DWORD)dev; } - if ((devAlias = strstr(args," alias "))) { - char *tmp2; + if ((devAlias = strstrW(args, wszSAliasS))) { + WCHAR* tmp2; devAlias += 7; - if (!(tmp = strchr(devAlias,' '))) tmp = devAlias + strlen(devAlias); + if (!(tmp = strchrW(devAlias,' '))) tmp = devAlias + strlenW(devAlias); if (tmp) *tmp = '\0'; - tmp2 = HeapAlloc(GetProcessHeap(), 0, tmp - devAlias + 1 ); - memcpy( tmp2, devAlias, tmp - devAlias ); + tmp2 = HeapAlloc(GetProcessHeap(), 0, (tmp - devAlias + 1) * sizeof(WCHAR) ); + memcpy( tmp2, devAlias, (tmp - devAlias) * sizeof(WCHAR) ); tmp2[tmp - devAlias] = 0; data[4] = (DWORD)tmp2; /* should be done in regular options parsing */ @@ -975,15 +1344,16 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, MCI_UnLoadMciDriver(wmd); goto errCleanUp; } - } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDA(dev)))) { + } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDW(dev)))) { /* auto open */ - char buf[128]; - sprintf(buf, "open %s wait", dev); + static WCHAR wszOpenWait[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0}; + WCHAR buf[128]; + sprintfW(buf, wszOpenWait, dev); - if ((dwRet = mciSendStringA(buf, NULL, 0, 0)) != 0) + if ((dwRet = mciSendStringW(buf, NULL, 0, 0)) != 0) goto errCleanUp; - wmd = MCI_GetDriver(mciGetDeviceIDA(dev)); + wmd = MCI_GetDriver(mciGetDeviceIDW(dev)); if (!wmd) { /* FIXME: memory leak, MCI driver is not closed */ dwRet = MCIERR_INVALID_DEVICE_ID; @@ -1007,7 +1377,7 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, if (!lpCmd) lpCmd = MCI_FindCommand(MCI_GetCommandTable(0), verb); if (!lpCmd) { - TRACE("Command '%s' not found!\n", verb); + TRACE("Command %s not found!\n", debugstr_w(verb)); dwRet = MCIERR_UNRECOGNIZED_COMMAND; goto errCleanUp; } @@ -1027,7 +1397,8 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, default: ERR("oops\n"); } - TRACE("verb='%s' on dev='%s'; offset=%d\n", verb, dev, offset); + TRACE("verb=%s on dev=%s; offset=%d\n", + debugstr_w(verb), debugstr_w(dev), offset); if ((dwRet = MCI_ParseOptArgs(data, offset, lpCmd, args, &dwFlags))) goto errCleanUp; @@ -1043,20 +1414,20 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n", wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags, - data[0], debugstr_a((char *)data[0]), data[1], debugstr_a((char *)data[1]), - data[2], debugstr_a((char *)data[2]), data[3], debugstr_a((char *)data[3]), - data[4], debugstr_a((char *)data[4]), data[5], debugstr_a((char *)data[5])); + data[0], debugstr_w((WCHAR *)data[0]), data[1], debugstr_w((WCHAR *)data[1]), + data[2], debugstr_w((WCHAR *)data[2]), data[3], debugstr_w((WCHAR *)data[3]), + data[4], debugstr_w((WCHAR *)data[4]), data[5], debugstr_w((WCHAR *)data[5])); - if (strcmp(verb, "open") == 0) { - if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSA)data, dwFlags))) + if (strcmpW(verb, wszOpen) == 0) { + if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSW)data, dwFlags))) MCI_UnLoadMciDriver(wmd); /* FIXME: notification is not properly shared across two opens */ } else { dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE); } - TRACE("=> 1/ %lx (%s)\n", dwRet, lpstrRet); + TRACE("=> 1/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet)); dwRet = MCI_HandleReturnValues(dwRet, wmd, retType, data, lpstrRet, uRetLen); - TRACE("=> 2/ %lx (%s)\n", dwRet, lpstrRet); + TRACE("=> 2/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet)); errCleanUp: HeapFree(GetProcessHeap(), 0, verb); @@ -1065,30 +1436,30 @@ errCleanUp: } /************************************************************************** - * mciSendStringW [WINMM.@] + * mciSendStringA [WINMM.@] */ -DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPWSTR lpwstrRet, +DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, UINT uRetLen, HWND hwndCallback) { - LPSTR lpstrCommand; - LPSTR lpstrRet = NULL; + LPWSTR lpwstrCommand; + LPWSTR lpwstrRet = NULL; UINT ret; INT len; /* FIXME: is there something to do with lpstrReturnString ? */ - len = WideCharToMultiByte( CP_ACP, 0, lpwstrCommand, -1, NULL, 0, NULL, NULL ); - lpstrCommand = HeapAlloc( GetProcessHeap(), 0, len ); - WideCharToMultiByte( CP_ACP, 0, lpwstrCommand, -1, lpstrCommand, len, NULL, NULL ); - if (lpwstrRet) + len = MultiByteToWideChar( CP_ACP, 0, lpstrCommand, -1, NULL, 0 ); + lpwstrCommand = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); + MultiByteToWideChar( CP_ACP, 0, lpstrCommand, -1, lpwstrCommand, len ); + if (lpstrRet) { - lpstrRet = HeapAlloc(GetProcessHeap(), 0, uRetLen * sizeof(WCHAR)); - if (!lpstrRet) return MMSYSERR_NOMEM; + lpwstrRet = HeapAlloc(GetProcessHeap(), 0, uRetLen * sizeof(WCHAR)); + if (!lpwstrRet) return MCIERR_OUT_OF_MEMORY; } - ret = mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback); + ret = mciSendStringW(lpwstrCommand, lpwstrRet, uRetLen, hwndCallback); if (lpwstrRet) - MultiByteToWideChar( CP_ACP, 0, lpstrRet, -1, lpwstrRet, uRetLen ); - HeapFree(GetProcessHeap(), 0, lpstrCommand); - HeapFree(GetProcessHeap(), 0, lpstrRet); + WideCharToMultiByte( CP_ACP, 0, lpwstrRet, -1, lpstrRet, uRetLen, NULL, NULL ); + HeapFree(GetProcessHeap(), 0, lpwstrCommand); + HeapFree(GetProcessHeap(), 0, lpwstrRet); return ret; } @@ -1096,7 +1467,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPWSTR lpwstrRet, * mciExecute [WINMM.@] * mciExecute [MMSYSTEM.712] */ -DWORD WINAPI mciExecute(LPCSTR lpstrCommand) +BOOL WINAPI mciExecute(LPCSTR lpstrCommand) { char strRet[256]; DWORD ret; @@ -1111,7 +1482,7 @@ DWORD WINAPI mciExecute(LPCSTR lpstrCommand) MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK); } /* FIXME: what shall I return ? */ - return 0; + return TRUE; } /************************************************************************** @@ -1134,7 +1505,7 @@ UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type) if (!type) { #if 0 /* FIXME: we should put this back into order, but I never found a program - * actually using this feature, so we not need it + * actually using this feature, so we may not need it */ char buf[128]; OFSTRUCT ofs; @@ -1163,7 +1534,7 @@ BOOL WINAPI mciFreeCommandResource(UINT uTable) { TRACE("(%08x)!\n", uTable); - return MCI_DeleteCommandTable(uTable); + return MCI_DeleteCommandTable(uTable, FALSE); } /************************************************************************** @@ -1177,10 +1548,10 @@ DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, if (wmd) { if (wmd->bIs32) { dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); - } else if (pFnMciMapMsg32ATo16) { + } else if (pFnMciMapMsg32WTo16) { WINMM_MapType res; - switch (res = pFnMciMapMsg32ATo16(wmd->wType, wMsg, dwParam1, &dwParam2)) { + switch (res = pFnMciMapMsg32WTo16(wmd->wType, wMsg, dwParam1, &dwParam2)) { case WINMM_MAP_MSGERROR: TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg)); dwRet = MCIERR_DRIVER_INTERNAL; @@ -1193,7 +1564,7 @@ DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, case WINMM_MAP_OKMEM: dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg32ATo16(wmd->wType, wMsg, dwParam1, dwParam2); + pFnMciUnMapMsg32WTo16(wmd->wType, wMsg, dwParam1, dwParam2); break; } } @@ -1212,10 +1583,10 @@ DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, if (wmd) { dwRet = MCIERR_INVALID_DEVICE_ID; - if (wmd->bIs32 && pFnMciMapMsg16To32A) { + if (wmd->bIs32 && pFnMciMapMsg16To32W) { WINMM_MapType res; - switch (res = pFnMciMapMsg16To32A(wmd->wType, wMsg, &dwParam2)) { + switch (res = pFnMciMapMsg16To32W(wmd->wType, wMsg, &dwParam2)) { case WINMM_MAP_MSGERROR: TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg)); dwRet = MCIERR_DRIVER_INTERNAL; @@ -1228,7 +1599,7 @@ DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, case WINMM_MAP_OKMEM: dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg16To32A(wmd->wType, wMsg, dwParam2); + pFnMciUnMapMsg16To32W(wmd->wType, wMsg, dwParam2); break; } } else { @@ -1241,9 +1612,9 @@ DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, /************************************************************************** * MCI_Open [internal] */ -static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) +static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) { - char strDevTyp[128]; + WCHAR strDevTyp[128]; DWORD dwRet; LPWINE_MCIDRIVER wmd = NULL; @@ -1267,18 +1638,19 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) if (uDevType < MCI_DEVTYPE_FIRST || uDevType > MCI_DEVTYPE_LAST || - !LoadStringA(WINMM_IData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) { + !LoadStringW(WINMM_IData->hWinMM32Instance, uDevType, + strDevTyp, sizeof(strDevTyp) / sizeof(WCHAR))) { dwRet = MCIERR_BAD_INTEGER; goto errCleanUp; } } else { - LPSTR ptr; + LPWSTR ptr; if (lpParms->lpstrDeviceType == NULL) { dwRet = MCIERR_NULL_PARAMETER_BLOCK; goto errCleanUp; } - strcpy(strDevTyp, lpParms->lpstrDeviceType); - ptr = strchr(strDevTyp, '!'); + strcpyW(strDevTyp, lpParms->lpstrDeviceType); + ptr = strchrW(strDevTyp, '!'); if (ptr) { /* this behavior is not documented in windows. However, since, in * some occasions, MCI_OPEN handling is translated by WinMM into @@ -1286,7 +1658,8 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) */ if (dwParam & MCI_OPEN_ELEMENT) { ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n", - lpParms->lpstrElementName, strDevTyp); + debugstr_w(lpParms->lpstrElementName), + debugstr_w(strDevTyp)); dwRet = MCIERR_UNRECOGNIZED_KEYWORD; goto errCleanUp; } @@ -1297,11 +1670,11 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) } } - TRACE("devType='%s' !\n", strDevTyp); + TRACE("devType=%s !\n", debugstr_w(strDevTyp)); } if (dwParam & MCI_OPEN_ELEMENT) { - TRACE("lpstrElementName='%s'\n", lpParms->lpstrElementName); + TRACE("lpstrElementName=%s\n", debugstr_w(lpParms->lpstrElementName)); if (dwParam & MCI_OPEN_ELEMENT_ID) { FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n"); @@ -1318,12 +1691,13 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) if (!strDevTyp[0] && MCI_GetDevTypeFromFileName(lpParms->lpstrElementName, strDevTyp, sizeof(strDevTyp))) { - if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) { + static const WCHAR wszCdAudio[] = {'C','D','A','U','D','I','O',0}; + if (GetDriveTypeW(lpParms->lpstrElementName) != DRIVE_CDROM) { dwRet = MCIERR_EXTENSION_NOT_FOUND; goto errCleanUp; } /* FIXME: this will not work if several CDROM drives are installed on the machine */ - strcpy(strDevTyp, "CDAUDIO"); + strcpyW(strDevTyp, wszCdAudio); } } @@ -1334,7 +1708,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) } if (dwParam & MCI_OPEN_ALIAS) { - TRACE("Alias='%s' !\n", lpParms->lpstrAlias); + TRACE("Alias=%s !\n", debugstr_w(lpParms->lpstrAlias)); if (!lpParms->lpstrAlias) { dwRet = MCIERR_NULL_PARAMETER_BLOCK; goto errCleanUp; @@ -1411,16 +1785,17 @@ static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms /************************************************************************** * MCI_WriteString [internal] */ -DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr) +DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr) { DWORD ret = 0; if (lpSrcStr) { - if (dstSize <= strlen(lpSrcStr)) { - lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1); + dstSize /= sizeof(WCHAR); + if (dstSize <= strlenW(lpSrcStr)) { + lstrcpynW(lpDstStr, lpSrcStr, dstSize - 1); ret = MCIERR_PARAM_OVERFLOW; } else { - strcpy(lpDstStr, lpSrcStr); + strcpyW(lpDstStr, lpSrcStr); } } else { *lpDstStr = 0; @@ -1431,10 +1806,10 @@ DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr) /************************************************************************** * MCI_Sysinfo [internal] */ -static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms) +static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParms) { DWORD ret = MCIERR_INVALID_DEVICE_ID, cnt = 0; - CHAR buf[2048], *s = buf, *p; + WCHAR buf[2048], *s = buf, *p; LPWINE_MCIDRIVER wmd; HKEY hKey; @@ -1455,13 +1830,13 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParm LeaveCriticalSection(&WINMM_IData->cs); } else { TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n"); - if (RegOpenKeyExA( HKEY_LOCAL_MACHINE, HKLM_MCI, + if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) { - RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); + RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); RegCloseKey( hKey ); } - if (GetPrivateProfileStringA("mci", 0, "", buf, sizeof(buf), "system.ini")) - for(s = buf; *s; s += strlen(s) + 1) cnt++; + if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf), wszSystemIni)) + for (s = buf; *s; s += strlenW(s) + 1) cnt++; } } else { if (dwFlags & MCI_SYSINFO_OPEN) { @@ -1490,7 +1865,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParm *lpParms->lpstrReturn = 0; ret = MCIERR_INVALID_DEVICE_ID; } - TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn); + TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); break; case MCI_SYSINFO_NAME: TRACE("MCI_SYSINFO_NAME\n"); @@ -1498,22 +1873,23 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParm FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n"); ret = MCIERR_UNRECOGNIZED_COMMAND; } else { - DWORD lRet; - s = 0; - lRet = RegOpenKeyExA( HKEY_LOCAL_MACHINE, HKLM_MCI, 0, KEY_QUERY_VALUE, &hKey ); - if (lRet == ERROR_SUCCESS) { - lRet = RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); - if (lRet == ERROR_SUCCESS && lpParms->dwNumber <= cnt) { + s = NULL; + if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0, + KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) { + if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, + 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS && + lpParms->dwNumber <= cnt) { DWORD bufLen = sizeof(buf); - lRet = RegEnumKeyExA(hKey, lpParms->dwNumber - 1, buf, &bufLen, 0, 0, 0, 0); - if (lRet == ERROR_SUCCESS) s = buf; + if (RegEnumKeyExW(hKey, lpParms->dwNumber - 1, + buf, &bufLen, 0, 0, 0, 0) == ERROR_SUCCESS) + s = buf; } RegCloseKey( hKey ); } if (!s) { - if (GetPrivateProfileStringA("mci", 0, "", buf, sizeof(buf), "system.ini")) { - for(p = buf; *p; p += strlen(p) + 1, cnt++) { - TRACE("%ld: %s\n", cnt, p); + if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf), wszSystemIni)) { + for (p = buf; *p; p += strlenW(p) + 1, cnt++) { + TRACE("%ld: %s\n", cnt, debugstr_w(p)); if (cnt == lpParms->dwNumber - 1) { s = p; break; @@ -1521,9 +1897,9 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParm } } } - ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, s) : MCIERR_OUTOFRANGE; + ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize / sizeof(WCHAR), s) : MCIERR_OUTOFRANGE; } - TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn); + TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); break; default: TRACE("Unsupported flag value=%08lx\n", dwFlags); @@ -1551,14 +1927,14 @@ static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms) /************************************************************************** * MCI_Sound [internal] */ -static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMS lpParms) +static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms) { DWORD dwRet = 0; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (dwFlags & MCI_SOUND_NAME) - dwRet = sndPlaySoundA(lpParms->lpstrSoundName, SND_SYNC) ? MMSYSERR_NOERROR : MMSYSERR_ERROR; + dwRet = sndPlaySoundW(lpParms->lpstrSoundName, SND_SYNC) ? MMSYSERR_NOERROR : MMSYSERR_ERROR; else dwRet = MMSYSERR_ERROR; /* what should be done ??? */ if (dwFlags & MCI_NOTIFY) @@ -1579,13 +1955,13 @@ DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, switch (wMsg) { case MCI_OPEN: if (bFrom32) { - dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2); - } else if (pFnMciMapMsg16To32A) { - switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) { + dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2); + } else if (pFnMciMapMsg16To32W) { + switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) { case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2); - pFnMciUnMapMsg16To32A(0, wMsg, dwParam2); + dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2); + pFnMciUnMapMsg16To32W(0, wMsg, dwParam2); break; default: break; /* so that gcc does not bark */ } @@ -1594,12 +1970,12 @@ DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, case MCI_CLOSE: if (bFrom32) { dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); - } else if (pFnMciMapMsg16To32A) { - switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) { + } else if (pFnMciMapMsg16To32W) { + switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) { case WINMM_MAP_OK: case WINMM_MAP_OKMEM: dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); - pFnMciUnMapMsg16To32A(0, wMsg, dwParam2); + pFnMciUnMapMsg16To32W(0, wMsg, dwParam2); break; default: break; /* so that gcc does not bark */ } @@ -1607,13 +1983,13 @@ DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, break; case MCI_SYSINFO: if (bFrom32) { - dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2); - } else if (pFnMciMapMsg16To32A) { - switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) { + dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2); + } else if (pFnMciMapMsg16To32W) { + switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) { case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2); - pFnMciUnMapMsg16To32A(0, wMsg, dwParam2); + dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2); + pFnMciUnMapMsg16To32W(0, wMsg, dwParam2); break; default: break; /* so that gcc does not bark */ } @@ -1622,12 +1998,12 @@ DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, case MCI_BREAK: if (bFrom32) { dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2); - } else if (pFnMciMapMsg16To32A) { - switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) { + } else if (pFnMciMapMsg16To32W) { + switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) { case WINMM_MAP_OK: case WINMM_MAP_OKMEM: dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2); - pFnMciUnMapMsg16To32A(0, wMsg, dwParam2); + pFnMciUnMapMsg16To32W(0, wMsg, dwParam2); break; default: break; /* so that gcc does not bark */ } @@ -1635,13 +2011,13 @@ DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, break; case MCI_SOUND: if (bFrom32) { - dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMS)dwParam2); - } else if (pFnMciMapMsg16To32A) { - switch (pFnMciMapMsg16To32A(0, wMsg, &dwParam2)) { + dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2); + } else if (pFnMciMapMsg16To32W) { + switch (pFnMciMapMsg16To32W(0, wMsg, &dwParam2)) { case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMS)dwParam2); - pFnMciUnMapMsg16To32A(0, wMsg, dwParam2); + dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2); + pFnMciUnMapMsg16To32W(0, wMsg, dwParam2); break; default: break; /* so that gcc does not bark */ } @@ -1739,3 +2115,296 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2) } return LOWORD(dwRet); } + +/************************************************************************** + * mciGetErrorStringW [WINMM.@] + */ +BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength) +{ + BOOL ret = FALSE; + + if (lpstrBuffer != NULL && uLength > 0 && + wError >= MCIERR_BASE && wError <= MCIERR_CUSTOM_DRIVER_BASE) { + + if (LoadStringW(WINMM_IData->hWinMM32Instance, + wError, lpstrBuffer, uLength) > 0) { + ret = TRUE; + } + } + return ret; +} + +/************************************************************************** + * mciGetErrorStringA [WINMM.@] + */ +BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength) +{ + BOOL ret = FALSE; + + if (lpstrBuffer != NULL && uLength > 0 && + dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) { + + if (LoadStringA(WINMM_IData->hWinMM32Instance, + dwError, lpstrBuffer, uLength) > 0) { + ret = TRUE; + } + } + return ret; +} + +/************************************************************************** + * mciDriverNotify [WINMM.@] + */ +BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus) +{ + TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus); + + return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID); +} + +/************************************************************************** + * mciGetDriverData [WINMM.@] + */ +DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID) +{ + LPWINE_MCIDRIVER wmd; + + TRACE("(%04x)\n", uDeviceID); + + wmd = MCI_GetDriver(uDeviceID); + + if (!wmd) { + WARN("Bad uDeviceID\n"); + return 0L; + } + + return wmd->dwPrivate; +} + +/************************************************************************** + * mciSetDriverData [WINMM.@] + */ +BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data) +{ + LPWINE_MCIDRIVER wmd; + + TRACE("(%04x, %08lx)\n", uDeviceID, data); + + wmd = MCI_GetDriver(uDeviceID); + + if (!wmd) { + WARN("Bad uDeviceID\n"); + return FALSE; + } + + wmd->dwPrivate = data; + return TRUE; +} + +/************************************************************************** + * mciSendCommandW [WINMM.@] + * + */ +DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) +{ + DWORD dwRet; + + TRACE("(%08x, %s, %08lx, %08lx)\n", + wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); + + dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE); + dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2); + TRACE("=> %08lx\n", dwRet); + return dwRet; +} + +/************************************************************************** + * mciSendCommandA [WINMM.@] + */ +DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) +{ + DWORD ret; + int mapped; + + TRACE("(%08x, %s, %08lx, %08lx)\n", + wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); + + mapped = MCI_MapMsgAtoW(wMsg, dwParam1, &dwParam2); + if (mapped == -1) + { + FIXME("message %04x mapping failed\n", wMsg); + return MMSYSERR_NOMEM; + } + ret = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2); + if (mapped) + MCI_UnmapMsgAtoW(wMsg, dwParam1, dwParam2, ret); + return ret; +} + +/************************************************************************** + * mciGetDeviceIDA [WINMM.@] + */ +UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName) +{ + LPWSTR w = MCI_strdupAtoW(lpstrName); + UINT ret = MCIERR_OUT_OF_MEMORY; + + if (w) + { + ret = mciGetDeviceIDW(w); + HeapFree(GetProcessHeap(), 0, w); + } + return ret; +} + +/************************************************************************** + * mciGetDeviceIDW [WINMM.@] + */ +UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName) +{ + return MCI_GetDriverFromString(lpwstrName); +} + +/****************************************************************** + * MyUserYield + * + * Internal wrapper to call USER.UserYield16 (in fact through a Wine only export from USER32). + */ +static void MyUserYield(void) +{ + HMODULE mod = GetModuleHandleA( "user32.dll" ); + if (mod) + { + FARPROC proc = GetProcAddress( mod, "UserYield16" ); + if (proc) proc(); + } +} + +/************************************************************************** + * MCI_DefYieldProc [internal] + */ +UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data) +{ + INT16 ret; + + TRACE("(0x%04x, 0x%08lx)\n", wDevID, data); + + if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) || + (GetAsyncKeyState(LOWORD(data)) & 1) == 0) { + MyUserYield(); + ret = 0; + } else { + MSG msg; + + msg.hwnd = HWND_32(HIWORD(data)); + while (!PeekMessageW(&msg, msg.hwnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); + ret = -1; + } + return ret; +} + +/************************************************************************** + * mciSetYieldProc [WINMM.@] + */ +BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData) +{ + LPWINE_MCIDRIVER wmd; + + TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData); + + if (!(wmd = MCI_GetDriver(uDeviceID))) { + WARN("Bad uDeviceID\n"); + return FALSE; + } + + wmd->lpfnYieldProc = fpYieldProc; + wmd->dwYieldData = dwYieldData; + wmd->bIs32 = TRUE; + + return TRUE; +} + +/************************************************************************** + * mciGetDeviceIDFromElementIDA [WINMM.@] + */ +UINT WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType) +{ + LPWSTR w = MCI_strdupAtoW(lpstrType); + UINT ret = 0; + + if (w) + { + ret = mciGetDeviceIDFromElementIDW(dwElementID, w); + HeapFree(GetProcessHeap(), 0, w); + } + return ret; +} + +/************************************************************************** + * mciGetDeviceIDFromElementIDW [WINMM.@] + */ +UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType) +{ + /* FIXME: that's rather strange, there is no + * mciGetDeviceIDFromElementID32A in winmm.spec + */ + FIXME("(%lu, %s) stub\n", dwElementID, debugstr_w(lpstrType)); + return 0; +} + +/************************************************************************** + * mciGetYieldProc [WINMM.@] + */ +YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData) +{ + LPWINE_MCIDRIVER wmd; + + TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData); + + if (!(wmd = MCI_GetDriver(uDeviceID))) { + WARN("Bad uDeviceID\n"); + return NULL; + } + if (!wmd->lpfnYieldProc) { + WARN("No proc set\n"); + return NULL; + } + if (!wmd->bIs32) { + WARN("Proc is 32 bit\n"); + return NULL; + } + return wmd->lpfnYieldProc; +} + +/************************************************************************** + * mciGetCreatorTask [WINMM.@] + */ +HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID) +{ + LPWINE_MCIDRIVER wmd; + HTASK ret = 0; + + if ((wmd = MCI_GetDriver(uDeviceID))) ret = (HTASK)wmd->CreatorThread; + + TRACE("(%u) => %p\n", uDeviceID, ret); + return ret; +} + +/************************************************************************** + * mciDriverYield [WINMM.@] + */ +UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID) +{ + LPWINE_MCIDRIVER wmd; + UINT ret = 0; + + TRACE("(%04x)\n", uDeviceID); + + if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || !wmd->bIs32) { + MyUserYield(); + } else { + ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData); + } + + return ret; +} diff --git a/reactos/lib/winmm/message16.c b/reactos/lib/winmm/message16.c index 03a8fb6335f..edeb65e77c9 100644 --- a/reactos/lib/winmm/message16.c +++ b/reactos/lib/winmm/message16.c @@ -1,5 +1,3 @@ -/* -*- tab-width: 8; c-basic-offset: 4 -*- */ - /* * MMSYSTEM MCI and low level mapping functions * @@ -70,33 +68,33 @@ static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam * ================================= */ /************************************************************************** - * MMDRV_Aux_Map16To32A [internal] + * MMDRV_Aux_Map16To32W [internal] */ -static WINMM_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_Aux_UnMap16To32A [internal] + * MMDRV_Aux_UnMap16To32W [internal] */ -static WINMM_MapType MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_Aux_Map32ATo16 [internal] + * MMDRV_Aux_Map32WTo16 [internal] */ -static WINMM_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_Aux_UnMap32ATo16 [internal] + * MMDRV_Aux_UnMap32WTo16 [internal] */ -static WINMM_MapType MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { #if 0 case AUXDM_GETDEVCAPS: @@ -126,17 +124,17 @@ static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance * ================================= */ /************************************************************************** - * xMMDRV_Mixer_Map16To32A [internal] + * xMMDRV_Mixer_Map16To32W [internal] */ -static WINMM_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_Mixer_UnMap16To32A [internal] + * MMDRV_Mixer_UnMap16To32W [internal] */ -static WINMM_MapType MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { #if 0 MIXERCAPSA micA; @@ -156,17 +154,17 @@ static WINMM_MapType MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDW } /************************************************************************** - * MMDRV_Mixer_Map32ATo16 [internal] + * MMDRV_Mixer_Map32WTo16 [internal] */ -static WINMM_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_Mixer_UnMap32ATo16 [internal] + * MMDRV_Mixer_UnMap32WTo16 [internal] */ -static WINMM_MapType MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { return WINMM_MAP_MSGERROR; } @@ -187,33 +185,33 @@ static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstan * ================================= */ /************************************************************************** - * MMDRV_MidiIn_Map16To32A [internal] + * MMDRV_MidiIn_Map16To32W [internal] */ -static WINMM_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_MidiIn_UnMap16To32A [internal] + * MMDRV_MidiIn_UnMap16To32W [internal] */ -static WINMM_MapType MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_MidiIn_Map32ATo16 [internal] + * MMDRV_MidiIn_Map32WTo16 [internal] */ -static WINMM_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return WINMM_MAP_MSGERROR; } /************************************************************************** - * MMDRV_MidiIn_UnMap32ATo16 [internal] + * MMDRV_MidiIn_UnMap32WTo16 [internal] */ -static WINMM_MapType MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { return WINMM_MAP_MSGERROR; } @@ -275,9 +273,9 @@ static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInsta * ================================= */ /************************************************************************** - * MMDRV_MidiOut_Map16To32A [internal] + * MMDRV_MidiOut_Map16To32W [internal] */ -static WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -368,9 +366,9 @@ static WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LP } /************************************************************************** - * MMDRV_MidiOut_UnMap16To32A [internal] + * MMDRV_MidiOut_UnMap16To32W [internal] */ -static WINMM_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -440,9 +438,9 @@ static WINMM_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LP } /************************************************************************** - * MMDRV_MidiOut_Map32ATo16 [internal] + * MMDRV_MidiOut_Map32WTo16 [internal] */ -static WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -580,9 +578,9 @@ static WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LP } /************************************************************************** - * MMDRV_MidiOut_UnMap32ATo16 [internal] + * MMDRV_MidiOut_UnMap32WTo16 [internal] */ -static WINMM_MapType MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -706,9 +704,9 @@ static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInst * ================================= */ /************************************************************************** - * MMDRV_WaveIn_Map16To32A [internal] + * MMDRV_WaveIn_Map16To32W [internal] */ -static WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -815,9 +813,9 @@ static WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPD } /************************************************************************** - * MMDRV_WaveIn_UnMap16To32A [internal] + * MMDRV_WaveIn_UnMap16To32W [internal] */ -static WINMM_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -888,9 +886,9 @@ static WINMM_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPD } /************************************************************************** - * MMDRV_WaveIn_Map32ATo16 [internal] + * MMDRV_WaveIn_Map32WTo16 [internal] */ -static WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -1058,9 +1056,9 @@ static WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPD } /************************************************************************** - * MMDRV_WaveIn_UnMap32ATo16 [internal] + * MMDRV_WaveIn_UnMap32WTo16 [internal] */ -static WINMM_MapType MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -1197,9 +1195,9 @@ static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInsta * ================================= */ /************************************************************************** - * MMDRV_WaveOut_Map16To32A [internal] + * MMDRV_WaveOut_Map16To32W [internal] */ -static WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -1315,9 +1313,9 @@ static WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LP } /************************************************************************** - * MMDRV_WaveOut_UnMap16To32A [internal] + * MMDRV_WaveOut_UnMap16To32W [internal] */ -static WINMM_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { WINMM_MapType ret = WINMM_MAP_MSGERROR; @@ -1399,9 +1397,9 @@ static WINMM_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LP } /************************************************************************** - * MMDRV_WaveOut_Map32ATo16 [internal] + * MMDRV_WaveOut_Map32WTo16 [internal] */ -static WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { WINMM_MapType ret; @@ -1588,9 +1586,9 @@ static WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LP } /************************************************************************** - * MMDRV_WaveOut_UnMap32ATo16 [internal] + * MMDRV_WaveOut_UnMap32WTo16 [internal] */ -static WINMM_MapType MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) +static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) { WINMM_MapType ret; @@ -1855,270 +1853,13 @@ unsigned MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d, * M C I * ================================= */ -/************************************************************************** - * MCI_MapMsg16To32A [internal] +#if 0 +/* FIXME: this code is kept for not yet implemented optimisation for an application + * using the 32A MCI interface and calling a 16 bit driver. + * For now, we're doing two conversions: + * - 32A => 32W (in 32 bit MCI code) + * - 32W => 16 in this file */ -static WINMM_MapType MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam) -{ - if (*lParam == 0) - return WINMM_MAP_OK; - /* FIXME: to add also (with seg/linear modifications to do): - * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE - * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO - */ - switch (wMsg) { - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - case MCI_COPY: - case MCI_CUE: - case MCI_CUT: - case MCI_DELETE: - case MCI_FREEZE: - case MCI_GETDEVCAPS: - /* case MCI_INDEX: */ - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_PASTE: - case MCI_PAUSE: - case MCI_PLAY: - case MCI_PUT: - case MCI_REALIZE: - case MCI_RECORD: - case MCI_RESUME: - case MCI_SEEK: - case MCI_SET: - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - case MCI_SPIN: - case MCI_STATUS: /* FIXME: is wrong for digital video */ - case MCI_STEP: - case MCI_STOP: - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - case MCI_UPDATE: - case MCI_WHERE: - *lParam = (DWORD)MapSL(*lParam); - return WINMM_MAP_OK; - case MCI_WINDOW: - /* in fact, I would also need the dwFlags... to see - * which members of lParam are effectively used - */ - *lParam = (DWORD)MapSL(*lParam); - FIXME("Current mapping may be wrong\n"); - break; - case MCI_BREAK: - { - LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS)); - LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam); - - if (mbp32) { - mbp32->dwCallback = mbp16->dwCallback; - mbp32->nVirtKey = mbp16->nVirtKey; - mbp32->hwndBreak = HWND_32(mbp16->hwndBreak); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mbp32; - } - return WINMM_MAP_OKMEM; - case MCI_ESCAPE: - { - LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA)); - LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam); - - if (mvep32a) { - mvep32a->dwCallback = mvep16->dwCallback; - mvep32a->lpstrCommand = MapSL(mvep16->lpstrCommand); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mvep32a; - } - return WINMM_MAP_OKMEM; - case MCI_INFO: - { - LPMCI_INFO_PARMSA mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA)); - LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam); - - /* FIXME this is wrong if device is of type - * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped - */ - if (mip32a) { - mip32a->dwCallback = mip16->dwCallback; - mip32a->lpstrReturn = MapSL(mip16->lpstrReturn); - mip32a->dwRetSize = mip16->dwRetSize; - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mip32a; - } - return WINMM_MAP_OKMEM; - case MCI_OPEN: - case MCI_OPEN_DRIVER: - { - LPMCI_OPEN_PARMSA mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD)); - LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam); - - if (mop32a) { - *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16; - mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16)); - mop32a->dwCallback = mop16->dwCallback; - mop32a->wDeviceID = mop16->wDeviceID; - mop32a->lpstrDeviceType = MapSL(mop16->lpstrDeviceType); - mop32a->lpstrElementName = MapSL(mop16->lpstrElementName); - mop32a->lpstrAlias = MapSL(mop16->lpstrAlias); - /* copy extended information if any... - * FIXME: this may seg fault if initial structure does not contain them and - * the reads after msip16 fail under LDT limits... - * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and - * should not take care of extended parameters, and should be used by MCI_Open - * to fetch uDevType. When, this is known, the mapping for sending the - * MCI_OPEN_DRIVER shall be done depending on uDevType. - */ - memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD)); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mop32a; - } - return WINMM_MAP_OKMEM; - case MCI_SYSINFO: - { - LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA)); - LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam); - - if (msip32a) { - msip32a->dwCallback = msip16->dwCallback; - msip32a->lpstrReturn = MapSL(msip16->lpstrReturn); - msip32a->dwRetSize = msip16->dwRetSize; - msip32a->dwNumber = msip16->dwNumber; - msip32a->wDeviceType = msip16->wDeviceType; - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)msip32a; - } - return WINMM_MAP_OKMEM; - case MCI_SOUND: - { - LPMCI_SOUND_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMS)); - LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam); - - if (mbp32) { - mbp32->dwCallback = mbp16->dwCallback; - mbp32->lpstrSoundName = MapSL(mbp16->lpstrSoundName); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mbp32; - } - return WINMM_MAP_OKMEM; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_OPEN: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - FIXME("This is a hack\n"); - return WINMM_MAP_OK; - - default: - WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); - } - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MCI_UnMapMsg16To32A [internal] - */ -static WINMM_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam) -{ - switch (wMsg) { - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - case MCI_COPY: - case MCI_CUE: - case MCI_CUT: - case MCI_DELETE: - case MCI_FREEZE: - case MCI_GETDEVCAPS: - /* case MCI_INDEX: */ - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_PASTE: - case MCI_PAUSE: - case MCI_PLAY: - case MCI_PUT: - case MCI_REALIZE: - case MCI_RECORD: - case MCI_RESUME: - case MCI_SEEK: - case MCI_SET: - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - case MCI_SPIN: - case MCI_STATUS: - case MCI_STEP: - case MCI_STOP: - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - case MCI_UPDATE: - case MCI_WHERE: - return WINMM_MAP_OK; - - case MCI_WINDOW: - /* FIXME ?? see Map function */ - return WINMM_MAP_OK; - - case MCI_BREAK: - case MCI_ESCAPE: - case MCI_INFO: - case MCI_SYSINFO: - case MCI_SOUND: - HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); - return WINMM_MAP_OK; - case MCI_OPEN: - case MCI_OPEN_DRIVER: - if (lParam) { - LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)lParam; - LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16)); - - mop16->wDeviceID = mop32a->wDeviceID; - if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16)))) - FIXME("bad free line=%d\n", __LINE__); - } - return WINMM_MAP_OK; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_OPEN: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - FIXME("This is a hack\n"); - return WINMM_MAP_OK; - default: - FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); - } - return WINMM_MAP_MSGERROR; -} /* * 0000 stop @@ -2132,7 +1873,7 @@ static WINMM_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam */ /************************************************************************** - * MCI_MsgMapper32To16_Create [internal] + * MCI_MsgMapper32ATo16_Create [internal] * * Helper for MCI_MapMsg32ATo16. * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit @@ -2141,7 +1882,7 @@ static WINMM_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam * above) * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area. */ -static WINMM_MapType MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep) +static WINMM_MapType MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep) { void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 ); LPBYTE p16, p32; @@ -2212,11 +1953,11 @@ static WINMM_MapType MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD ma } /************************************************************************** - * MCI_MsgMapper32To16_Destroy [internal] + * MCI_MsgMapper32ATo16_Destroy [internal] * * Helper for MCI_UnMapMsg32ATo16. */ -static WINMM_MapType MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept) +static WINMM_MapType MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept) { if (ptr) { void* msg16 = MapSL((SEGPTR)ptr); @@ -2558,7 +2299,7 @@ static WINMM_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, LPMCI_OPEN_DRIVER_PARMSA modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam); LPMCI_OPEN_DRIVER_PARMS16 modp16; char *ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16)); + sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16)); if (ptr) { *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a; @@ -2587,10 +2328,10 @@ static WINMM_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, return WINMM_MAP_OK; default: - WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); + FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); return WINMM_MAP_MSGERROR; } - return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep); + return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep); } /************************************************************************** @@ -2774,14 +2515,1000 @@ static WINMM_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlag FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); return WINMM_MAP_MSGERROR; } - return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept); + return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept); +} +#endif + +/************************************************************************** + * MCI_MapMsg16To32W [internal] + */ +static WINMM_MapType MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD* lParam) +{ + if (*lParam == 0) + return WINMM_MAP_OK; + /* FIXME: to add also (with seg/linear modifications to do): + * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE + * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO + */ + switch (wMsg) { + /* case MCI_CAPTURE */ + case MCI_CLOSE: + case MCI_CLOSE_DRIVER: + case MCI_CONFIGURE: + case MCI_COPY: + case MCI_CUE: + case MCI_CUT: + case MCI_DELETE: + case MCI_FREEZE: + case MCI_GETDEVCAPS: + /* case MCI_INDEX: */ + /* case MCI_MARK: */ + /* case MCI_MONITOR: */ + case MCI_PASTE: + case MCI_PAUSE: + case MCI_PLAY: + case MCI_PUT: + case MCI_REALIZE: + case MCI_RECORD: + case MCI_RESUME: + case MCI_SEEK: + case MCI_SET: + /* case MCI_SETTIMECODE:*/ + /* case MCI_SIGNAL:*/ + case MCI_SPIN: + case MCI_STATUS: /* FIXME: is wrong for digital video */ + case MCI_STEP: + case MCI_STOP: + /* case MCI_UNDO: */ + case MCI_UNFREEZE: + case MCI_UPDATE: + case MCI_WHERE: + *lParam = (DWORD)MapSL(*lParam); + return WINMM_MAP_OK; + case MCI_WINDOW: + /* in fact, I would also need the dwFlags... to see + * which members of lParam are effectively used + */ + *lParam = (DWORD)MapSL(*lParam); + FIXME("Current mapping may be wrong\n"); + break; + case MCI_BREAK: + { + LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS)); + LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam); + + if (mbp32) { + mbp32->dwCallback = mbp16->dwCallback; + mbp32->nVirtKey = mbp16->nVirtKey; + mbp32->hwndBreak = HWND_32(mbp16->hwndBreak); + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (DWORD)mbp32; + } + return WINMM_MAP_OKMEM; + case MCI_ESCAPE: + { + LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW)); + LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam); + + if (mvep32w) { + mvep32w->dwCallback = mvep16->dwCallback; + mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand)); + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (DWORD)mvep32w; + } + return WINMM_MAP_OKMEM; + case MCI_INFO: + { + LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW)); + LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam); + + /* FIXME this is wrong if device is of type + * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped + */ + if (mip32w) { + *(LPMCI_INFO_PARMS16*)(mip32w) = mip16; + mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16)); + mip32w->dwCallback = mip16->dwCallback; + mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR)); + mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR); + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (DWORD)mip32w; + } + return WINMM_MAP_OKMEM; + case MCI_OPEN: + case MCI_OPEN_DRIVER: + { + LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD)); + LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam); + + if (mop32w) { + *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16; + mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16)); + mop32w->dwCallback = mop16->dwCallback; + mop32w->wDeviceID = mop16->wDeviceID; + mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType)); + mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName)); + mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias)); + /* copy extended information if any... + * FIXME: this may seg fault if initial structure does not contain them and + * the reads after msip16 fail under LDT limits... + * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and + * should not take care of extended parameters, and should be used by MCI_Open + * to fetch uDevType. When, this is known, the mapping for sending the + * MCI_OPEN_DRIVER shall be done depending on uDevType. + */ + memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD)); + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (DWORD)mop32w; + } + return WINMM_MAP_OKMEM; + case MCI_SYSINFO: + { + LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW)); + LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam); + + if (msip32w) { + *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16; + msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16)); + msip32w->dwCallback = msip16->dwCallback; + msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR)); + msip32w->dwRetSize = msip16->dwRetSize; + msip32w->dwNumber = msip16->dwNumber; + msip32w->wDeviceType = msip16->wDeviceType; + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (DWORD)msip32w; + } + return WINMM_MAP_OKMEM; + case MCI_SOUND: + { + LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW)); + LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam); + + if (mbp32) { + mbp32->dwCallback = mbp16->dwCallback; + mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName)); + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (DWORD)mbp32; + } + return WINMM_MAP_OKMEM; + case DRV_LOAD: + case DRV_ENABLE: + case DRV_OPEN: + case DRV_CLOSE: + case DRV_DISABLE: + case DRV_FREE: + case DRV_CONFIGURE: + case DRV_QUERYCONFIGURE: + case DRV_INSTALL: + case DRV_REMOVE: + case DRV_EXITSESSION: + case DRV_EXITAPPLICATION: + case DRV_POWER: + FIXME("This is a hack\n"); + return WINMM_MAP_OK; + default: + FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); + } + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MCI_UnMapMsg16To32W [internal] + */ +static WINMM_MapType MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD lParam) +{ + switch (wMsg) { + /* case MCI_CAPTURE */ + case MCI_CLOSE: + case MCI_CLOSE_DRIVER: + case MCI_CONFIGURE: + case MCI_COPY: + case MCI_CUE: + case MCI_CUT: + case MCI_DELETE: + case MCI_FREEZE: + case MCI_GETDEVCAPS: + /* case MCI_INDEX: */ + /* case MCI_MARK: */ + /* case MCI_MONITOR: */ + case MCI_PASTE: + case MCI_PAUSE: + case MCI_PLAY: + case MCI_PUT: + case MCI_REALIZE: + case MCI_RECORD: + case MCI_RESUME: + case MCI_SEEK: + case MCI_SET: + /* case MCI_SETTIMECODE:*/ + /* case MCI_SIGNAL:*/ + case MCI_SPIN: + case MCI_STATUS: + case MCI_STEP: + case MCI_STOP: + /* case MCI_UNDO: */ + case MCI_UNFREEZE: + case MCI_UPDATE: + case MCI_WHERE: + return WINMM_MAP_OK; + + case MCI_WINDOW: + /* FIXME ?? see Map function */ + return WINMM_MAP_OK; + + case MCI_BREAK: + HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); + return WINMM_MAP_OK; + case MCI_ESCAPE: + if (lParam) { + LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam; + HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand); + HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); + } + return WINMM_MAP_OK; + case MCI_INFO: + if (lParam) { + LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam; + LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16)); + + WideCharToMultiByte(CP_ACP, 0, + mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR), + MapSL(mip16->lpstrReturn), mip16->dwRetSize, + NULL, NULL); + HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn); + HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); + } + return WINMM_MAP_OK; + case MCI_SYSINFO: + if (lParam) { + LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam; + LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16)); + + WideCharToMultiByte(CP_ACP, 0, + msip32w->lpstrReturn, msip32w->dwRetSize, + MapSL(msip16->lpstrReturn), msip16->dwRetSize, + NULL, NULL); + HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn); + HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); + } + return WINMM_MAP_OK; + case MCI_SOUND: + if (lParam) { + LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam; + HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName); + HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); + } + return WINMM_MAP_OK; + case MCI_OPEN: + case MCI_OPEN_DRIVER: + if (lParam) { + LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam; + LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16)); + + mop16->wDeviceID = mop32w->wDeviceID; + HeapFree(GetProcessHeap(), 0, mop32w->lpstrDeviceType); + HeapFree(GetProcessHeap(), 0, mop32w->lpstrElementName); + HeapFree(GetProcessHeap(), 0, mop32w->lpstrAlias); + if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16)))) + FIXME("bad free line=%d\n", __LINE__); + } + return WINMM_MAP_OK; + case DRV_LOAD: + case DRV_ENABLE: + case DRV_OPEN: + case DRV_CLOSE: + case DRV_DISABLE: + case DRV_FREE: + case DRV_CONFIGURE: + case DRV_QUERYCONFIGURE: + case DRV_INSTALL: + case DRV_REMOVE: + case DRV_EXITSESSION: + case DRV_EXITAPPLICATION: + case DRV_POWER: + FIXME("This is a hack\n"); + return WINMM_MAP_OK; + default: + FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); + } + return WINMM_MAP_MSGERROR; +} + +/* + * 0000 stop + * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4 + * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4 + * 0100 + * 0101 + * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4 + * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4 + * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1 + */ + +/************************************************************************** + * MCI_MsgMapper32WTo16_Create [internal] + * + * Helper for MCI_MapMsg32WTo16. + * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit + * segmented pointer. + * map contains a list of action to be performed for the mapping (see list + * above) + * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area. + */ +static WINMM_MapType MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep) +{ + void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 ); + LPBYTE p16, p32; + + if (!lp) { + return WINMM_MAP_NOMEM; + } + p32 = (LPBYTE)(*ptr); + if (keep) { + *(void**)lp = *ptr; + p16 = (LPBYTE)lp + sizeof(void**); + *ptr = (char*)MapLS(lp) + sizeof(void**); + } else { + p16 = lp; + *ptr = (void*)MapLS(lp); + } + + if (map == 0) { + memcpy(p16, p32, size16); + } else { + unsigned nibble; + unsigned sz; + + while (map & 0xF) { + nibble = map & 0xF; + if (nibble & 0x8) { + sz = (nibble & 7) + 1; + memcpy(p16, p32, sz); + p16 += sz; + p32 += sz; + size16 -= sz; /* DEBUG only */ + } else { + switch (nibble) { + case 0x1: + *(LPINT16)p16 = *(LPINT)p32; + p16 += sizeof(INT16); + p32 += sizeof(INT); + size16 -= sizeof(INT16); + break; + case 0x2: + *(LPUINT16)p16 = *(LPUINT)p32; + p16 += sizeof(UINT16); + p32 += sizeof(UINT); + size16 -= sizeof(UINT16); + break; + case 0x6: + *(LPDWORD)p16 = 0; + p16 += sizeof(DWORD); + p32 += sizeof(DWORD); + size16 -= sizeof(DWORD); + break; + case 0x7: + *(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) ); + p16 += sizeof(SEGPTR); + p32 += sizeof(LPSTR); + size16 -= sizeof(SEGPTR); + break; + default: + FIXME("Unknown nibble for mapping (%x)\n", nibble); + } + } + map >>= 4; + } + if (size16 != 0) /* DEBUG only */ + FIXME("Mismatch between 16 bit struct size and map nibbles serie\n"); + } + return WINMM_MAP_OKMEM; +} + +/************************************************************************** + * MCI_MsgMapper32WTo16_Destroy [internal] + * + * Helper for MCI_UnMapMsg32WTo16. + */ +static WINMM_MapType MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept) +{ + if (ptr) { + void* msg16 = MapSL((SEGPTR)ptr); + void* alloc; + LPBYTE p32, p16; + unsigned nibble; + + UnMapLS( (SEGPTR)ptr ); + if (kept) { + alloc = (char*)msg16 - sizeof(void**); + p32 = *(void**)alloc; + p16 = msg16; + + if (map == 0) { + memcpy(p32, p16, size16); + } else { + while (map & 0xF) { + nibble = map & 0xF; + if (nibble & 0x8) { + memcpy(p32, p16, (nibble & 7) + 1); + p16 += (nibble & 7) + 1; + p32 += (nibble & 7) + 1; + size16 -= (nibble & 7) + 1; + } else { + switch (nibble) { + case 0x1: + *(LPINT)p32 = *(LPINT16)p16; + p16 += sizeof(INT16); + p32 += sizeof(INT); + size16 -= sizeof(INT16); + break; + case 0x2: + *(LPUINT)p32 = *(LPUINT16)p16; + p16 += sizeof(UINT16); + p32 += sizeof(UINT); + size16 -= sizeof(UINT16); + break; + case 0x6: + p16 += sizeof(UINT); + p32 += sizeof(UINT); + size16 -= sizeof(UINT); + break; + case 0x7: + HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16)); + UnMapLS( *(SEGPTR *)p16 ); + p16 += sizeof(SEGPTR); + p32 += sizeof(char*); + size16 -= sizeof(SEGPTR); + break; + default: + FIXME("Unknown nibble for mapping (%x)\n", nibble); + } + } + map >>= 4; + } + if (size16 != 0) /* DEBUG only */ + FIXME("Mismatch between 16 bit struct size and map nibbles serie\n"); + } + } else { + alloc = msg16; + } + + HeapFree( GetProcessHeap(), 0, alloc ); + } + return WINMM_MAP_OK; +} + +/************************************************************************** + * MCI_MapMsg32WTo16 [internal] + * + * Map a 32W bit MCI message to a 16 bit MCI message. + */ +static WINMM_MapType MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam) +{ + int size; + BOOLEAN keep = FALSE; + DWORD map = 0; + + if (*lParam == 0) + return WINMM_MAP_OK; + + /* FIXME: to add also (with seg/linear modifications to do): + * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE + * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO + */ + switch (wMsg) { + case MCI_BREAK: + size = sizeof(MCI_BREAK_PARMS); + break; + /* case MCI_CAPTURE */ + case MCI_CLOSE: + case MCI_CLOSE_DRIVER: + case MCI_CONFIGURE: + size = sizeof(MCI_GENERIC_PARMS); + break; + /* case MCI_COPY: */ + case MCI_CUE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + /* case MCI_CUT:*/ + case MCI_DELETE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break; + case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + /* case MCI_ESCAPE: */ + case MCI_FREEZE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case MCI_GETDEVCAPS: + keep = TRUE; + size = sizeof(MCI_GETDEVCAPS_PARMS); + break; + /* case MCI_INDEX: */ + case MCI_INFO: + { + LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)(*lParam); + char* ptr; + LPMCI_INFO_PARMS16 mip16; + + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break; + default: size = sizeof(MCI_INFO_PARMS16); break; + } + ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size); + if (ptr) + { + *(LPMCI_INFO_PARMSW*)ptr = mip32w; + mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW)); + mip16->dwCallback = mip32w->dwCallback; + mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) ); + mip16->dwRetSize = mip32w->dwRetSize / sizeof(WCHAR); + if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) { + ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem; + } + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW); + } + return WINMM_MAP_OKMEM; + /* case MCI_MARK: */ + /* case MCI_MONITOR: */ + case MCI_OPEN: + case MCI_OPEN_DRIVER: + { + LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)(*lParam); + char* ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD)); + LPMCI_OPEN_PARMS16 mop16; + + + if (ptr) { + *(LPMCI_OPEN_PARMSW*)(ptr) = mop32w; + mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW)); + mop16->dwCallback = mop32w->dwCallback; + mop16->wDeviceID = mop32w->wDeviceID; + if (dwFlags & MCI_OPEN_TYPE) { + if (dwFlags & MCI_OPEN_TYPE_ID) { + /* dword "transparent" value */ + mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType; + } else { + /* string */ + mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) ); + } + } else { + /* nuthin' */ + mop16->lpstrDeviceType = 0; + } + if (dwFlags & MCI_OPEN_ELEMENT) { + if (dwFlags & MCI_OPEN_ELEMENT_ID) { + mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName; + } else { + mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) ); + } + } else { + mop16->lpstrElementName = 0; + } + if (dwFlags & MCI_OPEN_ALIAS) { + mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) ); + } else { + mop16->lpstrAlias = 0; + } + /* copy extended information if any... + * FIXME: this may seg fault if initial structure does not contain them and + * the reads after msip16 fail under LDT limits... + * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and + * should not take care of extended parameters, and should be used by MCI_Open + * to fetch uDevType. When, this is known, the mapping for sending the + * MCI_OPEN_DRIVER shall be done depending on uDevType. + */ + memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD)); + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW); + } + return WINMM_MAP_OKMEM; + /* case MCI_PASTE:*/ + case MCI_PAUSE: + size = sizeof(MCI_GENERIC_PARMS); + break; + case MCI_PLAY: + size = sizeof(MCI_PLAY_PARMS); + break; + case MCI_PUT: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case MCI_REALIZE: + size = sizeof(MCI_GENERIC_PARMS); + break; + case MCI_RECORD: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + default: size = sizeof(MCI_RECORD_PARMS); break; + } + break; + case MCI_RESUME: + size = sizeof(MCI_GENERIC_PARMS); + break; + case MCI_SEEK: + switch (uDevType) { + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + default: size = sizeof(MCI_SEEK_PARMS); break; + } + break; + case MCI_SET: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break; + /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned, + * so not doing anything should work... + */ + case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break; + default: size = sizeof(MCI_SET_PARMS); break; + } + break; + case MCI_SETAUDIO: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + /* case MCI_SETTIMECODE:*/ + /* case MCI_SIGNAL:*/ + /* case MCI_SOUND:*/ + case MCI_SPIN: + size = sizeof(MCI_SET_PARMS); + break; + case MCI_STATUS: + keep = TRUE; + switch (uDevType) { + /* FIXME: + * don't know if buffer for value is the one passed through lpstrDevice + * or is provided by MCI driver. + * Assuming solution 2: provided by MCI driver, so zeroing on entry + */ + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + default: size = sizeof(MCI_STATUS_PARMS); break; + } + break; + case MCI_STEP: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case MCI_STOP: + size = sizeof(MCI_SET_PARMS); + break; + case MCI_SYSINFO: + { + LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam); + LPMCI_SYSINFO_PARMS16 msip16; + char* ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) ); + + if (ptr) { + *(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w; + msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW)); + + msip16->dwCallback = msip32w->dwCallback; + msip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) ); + msip16->dwRetSize = msip32w->dwRetSize; + msip16->dwNumber = msip32w->dwNumber; + msip16->wDeviceType = msip32w->wDeviceType; + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW); + } + return WINMM_MAP_OKMEM; + /* case MCI_UNDO: */ + case MCI_UNFREEZE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case MCI_UPDATE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case MCI_WHERE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case MCI_WINDOW: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break; + default: size = sizeof(MCI_GENERIC_PARMS); break; + } + break; + case DRV_OPEN: + { + LPMCI_OPEN_DRIVER_PARMSW modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam); + LPMCI_OPEN_DRIVER_PARMS16 modp16; + char *ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16)); + + if (ptr) { + *(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w; + modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW)); + modp16->wDeviceID = modp32w->wDeviceID; + modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) ); + /* other fields are gonna be filled by the driver, don't copy them */ + } else { + return WINMM_MAP_NOMEM; + } + *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW); + } + return WINMM_MAP_OKMEM; + case DRV_LOAD: + case DRV_ENABLE: + case DRV_CLOSE: + case DRV_DISABLE: + case DRV_FREE: + case DRV_CONFIGURE: + case DRV_QUERYCONFIGURE: + case DRV_INSTALL: + case DRV_REMOVE: + case DRV_EXITSESSION: + case DRV_EXITAPPLICATION: + case DRV_POWER: + return WINMM_MAP_OK; + + default: + FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); + return WINMM_MAP_MSGERROR; + } + return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep); +} + +/************************************************************************** + * MCI_UnMapMsg32WTo16 [internal] + */ +static WINMM_MapType MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam) +{ + int size = 0; + BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */ + DWORD map = 0; + + switch (wMsg) { + case MCI_BREAK: + break; + /* case MCI_CAPTURE */ + case MCI_CLOSE: + case MCI_CLOSE_DRIVER: + case MCI_CONFIGURE: + break; + /* case MCI_COPY: */ + case MCI_CUE: + break; + /* case MCI_CUT: */ + case MCI_DELETE: + break; + /* case MCI_ESCAPE: */ + case MCI_FREEZE: + break; + case MCI_GETDEVCAPS: + kept = TRUE; + size = sizeof(MCI_GETDEVCAPS_PARMS); + break; + /* case MCI_INDEX: */ + case MCI_INFO: + if (lParam) { + LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam); + LPMCI_INFO_PARMSW mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW)); + + MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize, + mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR)); + UnMapLS( lParam ); + UnMapLS( mip16->lpstrReturn ); + HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) ); + HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) ); + } + return WINMM_MAP_OK; + /* case MCI_MARK: */ + /* case MCI_MONITOR: */ + case MCI_OPEN: + case MCI_OPEN_DRIVER: + if (lParam) { + LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam); + LPMCI_OPEN_PARMSW mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW)); + UnMapLS( lParam ); + mop32w->wDeviceID = mop16->wDeviceID; + if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID)) + { + HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType)); + UnMapLS( mop16->lpstrDeviceType ); + } + if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID)) + { + HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName)); + UnMapLS( mop16->lpstrElementName ); + } + if (dwFlags & MCI_OPEN_ALIAS) + { + HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias)); + UnMapLS( mop16->lpstrAlias ); + } + HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) ); + } + return WINMM_MAP_OK; + /* case MCI_PASTE:*/ + case MCI_PAUSE: + break; + case MCI_PLAY: + break; + case MCI_PUT: + break; + case MCI_REALIZE: + break; + case MCI_RECORD: + break; + case MCI_RESUME: + break; + case MCI_SEEK: + break; + case MCI_SET: + break; + case MCI_SETAUDIO: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + } + break; + /* case MCI_SETTIMECODE:*/ + /* case MCI_SIGNAL:*/ + /* case MCI_SOUND:*/ + case MCI_SPIN: + break; + case MCI_STATUS: + kept = TRUE; + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: + if (lParam) { + LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam); + LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA)); + + UnMapLS( lParam ); + if (mdsp16) { + mdsp32a->dwReturn = mdsp16->dwReturn; + if (dwFlags & MCI_DGV_STATUS_DISKSPACE) { + TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive); + TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive)); + UnMapLS( mdsp16->lpstrDrive ); + } + HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) ); + } else { + return WINMM_MAP_NOMEM; + } + } + return WINMM_MAP_OKMEM; + case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; + default: size = sizeof(MCI_STATUS_PARMS); break; + } + break; + case MCI_STEP: + break; + case MCI_STOP: + break; + case MCI_SYSINFO: + if (lParam) { + LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam); + LPMCI_SYSINFO_PARMSW msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW)); + + UnMapLS( lParam ); + if (msip16) { + MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize, + msip32w->lpstrReturn, msip32w->dwRetSize); + UnMapLS( msip16->lpstrReturn ); + HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) ); + HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) ); + } else { + return WINMM_MAP_NOMEM; + } + } + return WINMM_MAP_OKMEM; + /* case MCI_UNDO: */ + case MCI_UNFREEZE: + break; + case MCI_UPDATE: + break; + case MCI_WHERE: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break; + default: break; + } + break; + case MCI_WINDOW: + switch (uDevType) { + case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break; + case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break; + default: break; + } + /* FIXME: see map function */ + break; + case DRV_OPEN: + if (lParam) { + LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam); + LPMCI_OPEN_DRIVER_PARMSW modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW)); + + UnMapLS( lParam ); + modp32w->wCustomCommandTable = modp16->wCustomCommandTable; + modp32w->wType = modp16->wType; + HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams)); + UnMapLS( modp16->lpstrParams ); + HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) ); + } + return WINMM_MAP_OK; + case DRV_LOAD: + case DRV_ENABLE: + case DRV_CLOSE: + case DRV_DISABLE: + case DRV_FREE: + case DRV_CONFIGURE: + case DRV_QUERYCONFIGURE: + case DRV_INSTALL: + case DRV_REMOVE: + case DRV_EXITSESSION: + case DRV_EXITAPPLICATION: + case DRV_POWER: + FIXME("This is a hack\n"); + return WINMM_MAP_OK; + + default: + FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); + return WINMM_MAP_MSGERROR; + } + return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept); } void MMDRV_Init16(void) { #define A(_x,_y) MMDRV_InstallMap(_x, \ -MMDRV_##_y##_Map16To32A, MMDRV_##_y##_UnMap16To32A, \ -MMDRV_##_y##_Map32ATo16, MMDRV_##_y##_UnMap32ATo16, \ +MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \ +MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \ MMDRV_##_y##_Callback) A(MMDRV_AUX, Aux); A(MMDRV_MIXER, Mixer); @@ -2794,8 +3521,8 @@ MMDRV_##_y##_Callback) pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16; pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16; - pFnMciMapMsg16To32A = MCI_MapMsg16To32A; - pFnMciUnMapMsg16To32A = MCI_UnMapMsg16To32A; - pFnMciMapMsg32ATo16 = MCI_MapMsg32ATo16; - pFnMciUnMapMsg32ATo16 = MCI_UnMapMsg32ATo16; + pFnMciMapMsg16To32W = MCI_MapMsg16To32W; + pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W; + pFnMciMapMsg32WTo16 = MCI_MapMsg32WTo16; + pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16; } diff --git a/reactos/lib/winmm/mmio.c b/reactos/lib/winmm/mmio.c index 4b1ed8573fb..9a05f1fc4cd 100644 --- a/reactos/lib/winmm/mmio.c +++ b/reactos/lib/winmm/mmio.c @@ -1,4 +1,3 @@ -/* -*- tab-width: 8; c-basic-offset: 4 -*- */ /* * MMIO functions * @@ -221,8 +220,6 @@ static LRESULT CALLBACK mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage, FIXME("unexpected message %u\n", uMessage); return 0; } - - return 0; } /* This array will be the entire list for most apps @@ -1351,7 +1348,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName, /* FIXME: should we actually pass lpmmioinfo down the drain ??? * or make a copy of it because it's const ??? */ - return send_message(ioProc, (LPMMIOINFO)lpmmioinfo, MMIOM_RENAME, + return send_message(ioProc, (MMIOINFO*)lpmmioinfo, MMIOM_RENAME, (LPARAM)szFileName, (LPARAM)szNewFileName, MMIO_PROC_32A); } diff --git a/reactos/lib/winmm/mmsystem.c b/reactos/lib/winmm/mmsystem.c index 1221878ffa9..1e4e41de1d8 100644 --- a/reactos/lib/winmm/mmsystem.c +++ b/reactos/lib/winmm/mmsystem.c @@ -48,7 +48,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(mmsys); static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16); -static LPWINE_DRIVER DRIVER_OpenDriver16(LPCSTR, LPCSTR, LPARAM); +static LPWINE_DRIVER DRIVER_OpenDriver16(LPCWSTR, LPCWSTR, LPARAM); static LRESULT DRIVER_CloseDriver16(HDRVR16, LPARAM, LPARAM); static LRESULT DRIVER_SendMessage16(HDRVR16, UINT, LPARAM, LPARAM); static LRESULT MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM); @@ -597,7 +597,7 @@ UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName) { TRACE("(\"%s\")\n", lpstrName); - return MCI_GetDriverFromString(lpstrName); + return mciGetDeviceIDA(lpstrName); } /************************************************************************** @@ -731,6 +731,7 @@ UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps, /************************************************************************** * midiOutGetErrorText [MMSYSTEM.203] + * midiInGetErrorText [MMSYSTEM.203] */ UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { @@ -948,14 +949,6 @@ UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps, return ret; } -/************************************************************************** - * midiInGetErrorText [MMSYSTEM.303] - */ -UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) -{ - return midiInGetErrorTextA(uError, lpText, uSize); -} - /************************************************************************** * midiInOpen [MMSYSTEM.304] */ @@ -1238,6 +1231,7 @@ UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, /************************************************************************** * waveOutGetErrorText [MMSYSTEM.403] + * waveInGetErrorText [MMSYSTEM.403] */ UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { @@ -1535,14 +1529,6 @@ UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, return ret; } -/************************************************************************** - * waveInGetErrorText [MMSYSTEM.503] - */ -UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) -{ - return waveInGetErrorTextA(uError, lpText, uSize); -} - /************************************************************************** * waveInOpen [MMSYSTEM.504] */ @@ -2371,30 +2357,52 @@ static WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lPara * * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName. */ -static LPWINE_DRIVER DRIVER_OpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2) +static LPWINE_DRIVER DRIVER_OpenDriver16(LPCWSTR fn, LPCWSTR sn, LPARAM lParam2) { LPWINE_DRIVER lpDrv = NULL; - LPCSTR cause = 0; + LPCSTR cause = NULL; + LPSTR fnA = NULL, snA = NULL; + unsigned len; - TRACE("(%s, %08lX);\n", debugstr_a(sn), lParam2); + TRACE("(%s, %s, %08lX);\n", debugstr_w(fn), debugstr_w(sn), lParam2); lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER)); if (lpDrv == NULL) {cause = "OOM"; goto exit;} + if (fn) + { + len = WideCharToMultiByte( CP_ACP, 0, fn, -1, NULL, 0, NULL, NULL ); + fnA = HeapAlloc(GetProcessHeap(), 0, len); + if (fnA == NULL) {cause = "OOM"; goto exit;} + WideCharToMultiByte( CP_ACP, 0, fn, -1, fnA, len, NULL, NULL ); + } + + if (sn) + { + len = WideCharToMultiByte( CP_ACP, 0, sn, -1, NULL, 0, NULL, NULL ); + snA = HeapAlloc(GetProcessHeap(), 0, len); + if (snA == NULL) {cause = "OOM"; goto exit;} + WideCharToMultiByte( CP_ACP, 0, sn, -1, snA, len, NULL, NULL ); + } + /* FIXME: shall we do some black magic here on sn ? * drivers32 => drivers * mci32 => mci * ... */ - lpDrv->d.d16.hDriver16 = OpenDriver16(fn, sn, lParam2); + lpDrv->d.d16.hDriver16 = OpenDriver16(fnA, snA, lParam2); if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;} lpDrv->dwFlags = WINE_GDF_16BIT; TRACE("=> %p\n", lpDrv); return lpDrv; - exit: + +exit: HeapFree(GetProcessHeap(), 0, lpDrv); - TRACE("Unable to load 16 bit module %s: %s\n", debugstr_a(fn), cause); + HeapFree(GetProcessHeap(), 0, fnA); + HeapFree(GetProcessHeap(), 0, snA); + TRACE("Unable to load 16 bit module %s[%s]: %s\n", + debugstr_w(fn), debugstr_w(sn), cause); return NULL; } @@ -2612,15 +2620,45 @@ DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet, */ UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type) { - HRSRC16 res; - HGLOBAL16 handle; - void *ptr; + HRSRC16 res; + HGLOBAL16 handle; + const BYTE* ptr16; + BYTE* ptr32; + unsigned pos = 0, size = 1024, len; + const char* str; + DWORD flg; + WORD eid; + UINT16 ret = MCIERR_OUT_OF_MEMORY; if (!(res = FindResource16( hInst, resname, (LPSTR)RT_RCDATA))) return MCI_NO_COMMAND_TABLE; if (!(handle = LoadResource16( hInst, res ))) return MCI_NO_COMMAND_TABLE; - ptr = LockResource16(handle); - return MCI_SetCommandTable(ptr, type); - /* FIXME: FreeResource */ + ptr16 = LockResource16(handle); + /* converting the 16 bit resource table into a 32W one */ + if ((ptr32 = HeapAlloc(GetProcessHeap(), 0, size))) + { + do { + str = (LPCSTR)ptr16; + ptr16 += strlen(str) + 1; + flg = *(const DWORD*)ptr16; + eid = *(const WORD*)(ptr16 + sizeof(DWORD)); + ptr16 += sizeof(DWORD) + sizeof(WORD); + len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0) * sizeof(WCHAR); + if (pos + len + sizeof(DWORD) + sizeof(WORD) > size) + { + while (pos + len * sizeof(WCHAR) + sizeof(DWORD) + sizeof(WORD) > size) size += 1024; + ptr32 = HeapReAlloc(GetProcessHeap(), 0, ptr32, size); + if (!ptr32) goto the_end; + } + MultiByteToWideChar(CP_ACP, 0, str, -1, (LPWSTR)(ptr32 + pos), len / sizeof(WCHAR)); + *(DWORD*)(ptr32 + pos + len) = flg; + *(WORD*)(ptr32 + pos + len + sizeof(DWORD)) = eid; + pos += len + sizeof(DWORD) + sizeof(WORD); + } while (eid != MCI_END_COMMAND_LIST); + } +the_end: + FreeResource16( handle ); + if (ptr32) ret = MCI_SetCommandTable(ptr32, type); + return ret; } /************************************************************************** @@ -2630,7 +2668,7 @@ BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable) { TRACE("(%04x)!\n", uTable); - return mciFreeCommandResource(uTable); + return MCI_DeleteCommandTable(uTable, TRUE); } /* ################################################### diff --git a/reactos/lib/winmm/mmsystem.spec b/reactos/lib/winmm/mmsystem.spec index 768e52ff66e..151e63f26f4 100644 --- a/reactos/lib/winmm/mmsystem.spec +++ b/reactos/lib/winmm/mmsystem.spec @@ -45,7 +45,7 @@ 257 pascal midiStreamStop(word) midiStreamStop16 301 pascal midiInGetNumDevs() midiInGetNumDevs16 302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16 -303 pascal midiInGetErrorText(word ptr word) midiInGetErrorText16 +303 pascal midiInGetErrorText(word ptr word) midiOutGetErrorText16 304 pascal midiInOpen(ptr word long long long) midiInOpen16 305 pascal midiInClose(word) midiInClose16 306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16 @@ -84,7 +84,7 @@ 421 pascal waveOutMessage(word word long long) waveOutMessage16 501 pascal waveInGetNumDevs() waveInGetNumDevs16 502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16 -503 pascal waveInGetErrorText(word ptr word) waveInGetErrorText16 +503 pascal waveInGetErrorText(word ptr word) waveOutGetErrorText16 504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16 505 pascal waveInClose(word) waveInClose16 506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16 diff --git a/reactos/lib/winmm/winemm.h b/reactos/lib/winmm/winemm.h index e5661712c9e..b26a5c1a012 100644 --- a/reactos/lib/winmm/winemm.h +++ b/reactos/lib/winmm/winemm.h @@ -87,7 +87,7 @@ typedef struct tagWINE_MM_DRIVER_PART { typedef struct tagWINE_MM_DRIVER { HDRVR hDriver; LPSTR drvname; /* name of the driver */ - BOOL bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */ + unsigned bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */ bIsMapper : 1; /* TRUE if mapper */ WINE_MM_DRIVER_PART parts[MMDRV_MAX];/* Information for all known types */ } WINE_MM_DRIVER, *LPWINE_MM_DRIVER; @@ -139,9 +139,9 @@ typedef struct { typedef struct tagWINE_MCIDRIVER { UINT wDeviceID; UINT wType; - LPSTR lpstrElementName; - LPSTR lpstrDeviceType; - LPSTR lpstrAlias; + LPWSTR lpstrElementName; + LPWSTR lpstrDeviceType; + LPWSTR lpstrAlias; HDRVR hDriver; DWORD dwPrivate; YIELDPROC lpfnYieldProc; @@ -181,14 +181,14 @@ typedef struct tagWINE_MMIO { 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; @@ -224,8 +224,8 @@ typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LP HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2); 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); @@ -245,15 +245,18 @@ void MMDRV_InstallMap(unsigned int, MMDRV_MAPFUNC, MMDRV_UNMAPFUNC, 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); @@ -291,13 +294,13 @@ extern LPWINE_MM_IDATA WINMM_IData; * NULL otherwise */ extern WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16); -extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM); +extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM); extern LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM); extern LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM); -extern WINMM_MapType (*pFnMciMapMsg16To32A)(WORD,WORD,DWORD*); -extern WINMM_MapType (*pFnMciUnMapMsg16To32A)(WORD,WORD,DWORD); -extern WINMM_MapType (*pFnMciMapMsg32ATo16)(WORD,WORD,DWORD,DWORD*); -extern WINMM_MapType (*pFnMciUnMapMsg32ATo16)(WORD,WORD,DWORD,DWORD); +extern WINMM_MapType (*pFnMciMapMsg16To32W)(WORD,WORD,DWORD*); +extern WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD); +extern WINMM_MapType (*pFnMciMapMsg32WTo16)(WORD,WORD,DWORD,DWORD*); +extern WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD); extern LRESULT (*pFnCallMMDrvFunc16)(DWORD /* in fact FARPROC16 */,WORD,WORD,LONG,LONG,LONG); extern unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER); extern LRESULT (*pFnMmioCallback16)(DWORD,LPMMIOINFO,UINT,LPARAM,LPARAM); diff --git a/reactos/lib/winmm/winmm.c b/reactos/lib/winmm/winmm.c index f589c505146..76e4ef74dc6 100644 --- a/reactos/lib/winmm/winmm.c +++ b/reactos/lib/winmm/winmm.c @@ -53,27 +53,11 @@ #include "winreg.h" #include "winternl.h" #include "winemm.h" -#include "wownt32.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(winmm); -/****************************************************************** - * MyUserYield - * - * Internal wrapper to call USER.UserYield16 (in fact through a Wine only export from USER32). - */ -static void MyUserYield(void) -{ - HMODULE mod = GetModuleHandleA( "user32.dll" ); - if (mod) - { - FARPROC proc = GetProcAddress( mod, "UserYield16" ); - if (proc) proc(); - } -} - void (WINAPI *pFnReleaseThunkLock)(DWORD*); void (WINAPI *pFnRestoreThunkLock)(DWORD); @@ -779,469 +763,6 @@ UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PT 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.@] */ @@ -1299,49 +820,50 @@ UINT WINAPI midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA lpCaps, } /************************************************************************** - * MIDI_GetErrorText [internal] + * midiOutGetErrorTextA [WINMM.@] + * midiInGetErrorTextA [WINMM.@] */ -static UINT16 MIDI_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) +UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize) { - UINT16 ret = MMSYSERR_BADERRNUM; + UINT ret; - if (lpText == NULL) { - ret = MMSYSERR_INVALPARAM; - } else if (uSize == 0) { - ret = MMSYSERR_NOERROR; - } else if ( - /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit - * a warning for the test was always true */ - (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) || - (uError >= MIDIERR_BASE && uError <= MIDIERR_LASTERROR)) { - - if (LoadStringA(WINMM_IData->hWinMM32Instance, - uError, lpText, uSize) > 0) { - ret = MMSYSERR_NOERROR; - } + if (lpText == NULL) ret = MMSYSERR_INVALPARAM; + else if (uSize == 0) ret = MMSYSERR_NOERROR; + else + { + LPWSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR)); + if (!xstr) ret = MMSYSERR_NOMEM; + else + { + ret = midiOutGetErrorTextW(uError, xstr, uSize); + if (ret == MMSYSERR_NOERROR) + WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL); + HeapFree(GetProcessHeap(), 0, xstr); + } } return ret; } -/************************************************************************** - * midiOutGetErrorTextA [WINMM.@] - */ -UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize) -{ - return MIDI_GetErrorText(uError, lpText, uSize); -} - /************************************************************************** * midiOutGetErrorTextW [WINMM.@] + * midiInGetErrorTextW [WINMM.@] */ UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize) { - LPSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize); - UINT ret; + UINT ret = MMSYSERR_BADERRNUM; - ret = MIDI_GetErrorText(uError, xstr, uSize); - MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize ); - HeapFree(GetProcessHeap(), 0, xstr); + if (lpText == NULL) ret = MMSYSERR_INVALPARAM; + else if (uSize == 0) ret = MMSYSERR_NOERROR; + else if ( + /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit + * a warning for the test was always true */ + (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) || + (uError >= MIDIERR_BASE && uError <= MIDIERR_LASTERROR)) { + if (LoadStringW(WINMM_IData->hWinMM32Instance, + uError, lpText, uSize) > 0) { + ret = MMSYSERR_NOERROR; + } + } return ret; } @@ -1674,27 +1196,6 @@ UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSi 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) { @@ -2629,48 +2130,50 @@ UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps, } /************************************************************************** - * WAVE_GetErrorText [internal] + * waveOutGetErrorTextA [WINMM.@] + * waveInGetErrorTextA [WINMM.@] */ -static UINT16 WAVE_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) +UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize) { - UINT16 ret = MMSYSERR_BADERRNUM; + UINT ret; - if (lpText == NULL) { - ret = MMSYSERR_INVALPARAM; - } else if (uSize == 0) { - ret = MMSYSERR_NOERROR; - } else if ( - /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit - * a warning for the test was always true */ - (/*uError >= MMSYSERR_BASE && */uError <= MMSYSERR_LASTERROR) || - (uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) { - - if (LoadStringA(WINMM_IData->hWinMM32Instance, - uError, lpText, uSize) > 0) { - ret = MMSYSERR_NOERROR; - } + if (lpText == NULL) ret = MMSYSERR_INVALPARAM; + else if (uSize == 0) ret = MMSYSERR_NOERROR; + else + { + LPWSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR)); + if (!xstr) ret = MMSYSERR_NOMEM; + else + { + ret = waveOutGetErrorTextW(uError, xstr, uSize); + if (ret == MMSYSERR_NOERROR) + WideCharToMultiByte(CP_ACP, 0, xstr, -1, lpText, uSize, NULL, NULL); + HeapFree(GetProcessHeap(), 0, xstr); + } } return ret; } -/************************************************************************** - * waveOutGetErrorTextA [WINMM.@] - */ -UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize) -{ - return WAVE_GetErrorText(uError, lpText, uSize); -} - /************************************************************************** * waveOutGetErrorTextW [WINMM.@] + * waveInGetErrorTextW [WINMM.@] */ UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize) { - LPSTR xstr = HeapAlloc(GetProcessHeap(), 0, uSize); - UINT ret = WAVE_GetErrorText(uError, xstr, uSize); + UINT ret = MMSYSERR_BADERRNUM; - MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize ); - HeapFree(GetProcessHeap(), 0, xstr); + if (lpText == NULL) ret = MMSYSERR_INVALPARAM; + else if (uSize == 0) ret = MMSYSERR_NOERROR; + else if ( + /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit + * a warning for the test was always true */ + (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) || + (uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) { + if (LoadStringW(WINMM_IData->hWinMM32Instance, + uError, lpText, uSize) > 0) { + ret = MMSYSERR_NOERROR; + } + } return ret; } @@ -3040,27 +2543,6 @@ UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSi 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.@] */ diff --git a/reactos/lib/winmm/winmm.spec b/reactos/lib/winmm/winmm.spec index ffaad29dd40..c9e4577a37f 100644 --- a/reactos/lib/winmm/winmm.spec +++ b/reactos/lib/winmm/winmm.spec @@ -10,12 +10,12 @@ @ stdcall DrvClose(long long long) CloseDriver @ stdcall DrvDefDriverProc(long long long long long) DefDriverProc @ stdcall DrvGetModuleHandle(long) GetDriverModuleHandle -@ stdcall DrvOpen(wstr wstr long) OpenDriverW +@ stdcall DrvOpen(wstr wstr long) OpenDriver @ stdcall DrvOpenA(str str long) OpenDriverA @ stdcall DrvSendMessage(long long long long) SendDriverMessage @ stdcall GetDriverFlags(long) @ stdcall GetDriverModuleHandle(long) -@ stdcall OpenDriver(wstr wstr long) OpenDriverW +@ stdcall OpenDriver(wstr wstr long) @ stdcall OpenDriverA(str str long) @ stdcall PlaySound(ptr long long) PlaySoundA @ stdcall PlaySoundW(ptr long long) @@ -42,8 +42,9 @@ @ stdcall mciFreeCommandResource(long) @ stdcall mciGetCreatorTask(long) @ stdcall mciGetDeviceIDA(str) -@ stdcall mciGetDeviceIDFromElementIDW(long str) -@ stdcall mciGetDeviceIDW(str) +@ stdcall mciGetDeviceIDW(wstr) +@ stdcall mciGetDeviceIDFromElementIDA(long str) +@ stdcall mciGetDeviceIDFromElementIDW(long wstr) @ stdcall mciGetDriverData(long) @ stdcall mciGetErrorStringA(long ptr long) @ stdcall mciGetErrorStringW(long ptr long) @@ -61,8 +62,8 @@ @ stdcall midiInClose(long) @ stdcall midiInGetDevCapsA(long ptr long) @ stdcall midiInGetDevCapsW(long ptr long) -@ stdcall midiInGetErrorTextA(long ptr long) -@ stdcall midiInGetErrorTextW(long ptr long) +@ stdcall midiInGetErrorTextA(long ptr long) midiOutGetErrorTextA +@ stdcall midiInGetErrorTextW(long ptr long) midiOutGetErrorTextW @ stdcall midiInGetID(long ptr) @ stdcall midiInGetNumDevs() @ stdcall midiInMessage(long long long long) @@ -153,8 +154,8 @@ @ stdcall waveInClose(long) @ stdcall waveInGetDevCapsA(long ptr long) @ stdcall waveInGetDevCapsW(long ptr long) -@ stdcall waveInGetErrorTextA(long ptr long) -@ stdcall waveInGetErrorTextW(long ptr long) +@ stdcall waveInGetErrorTextA(long ptr long) waveOutGetErrorTextA +@ stdcall waveInGetErrorTextW(long ptr long) waveOutGetErrorTextW @ stdcall waveInGetID(long ptr) @ stdcall waveInGetNumDevs() @ stdcall waveInGetPosition(long ptr long) @@ -188,3 +189,23 @@ @ stdcall waveOutSetVolume(long long) @ stdcall waveOutUnprepareHeader(long ptr long) @ stdcall waveOutWrite(long ptr long) +# MigrateAllDrivers +# MigrateSoundEvents +# NotifyCallbackData +# WOW32DriverCallback +# WOW32ResolveMultiMediaHandle +# WOWAppExit +# WinmmLogoff +# WinmmLogon +# mid32Message +# mmDrvInstall +# aux32Message +# joy32Message +# mci32Message +# mod32Message +# mxd32Message +# tid32Message +# wid32Message +# winmmDbgOut +# winmmSetDebugLevel +# wod32Message diff --git a/reactos/lib/winmm/winmm_De.rc b/reactos/lib/winmm/winmm_De.rc index 24aa8224ae8..0474a427ff5 100644 --- a/reactos/lib/winmm/winmm_De.rc +++ b/reactos/lib/winmm/winmm_De.rc @@ -71,8 +71,8 @@ MCIERR_DRIVER, "Es gibt ein Problem mit dem Ger MCIERR_CANNOT_USE_ALL, "Der Gerätename 'all' ist nicht in diesem Befehl erlaubt." MCIERR_MULTIPLE, "Es traten Fehler in mehr als einem Gerät auf. Geben Sie jeden Befehl für jedes Gerät einzeln an, um zu bestimmen, welches Gerät die Fehler verursachte." MCIERR_EXTENSION_NOT_FOUND, "Kann keinen Gerätetyp aus der angegebenen Dateinamenerweiterung ermitteln." -MCIERR_OUTOFRANGE, "Der angegebene Paramter liegt außerhalb des zulässigen Bereichs für diesen Befehl." -MCIERR_FLAGS_NOT_COMPATIBLE, "Die Paramter können nicht zusammen verwendet werden." +MCIERR_OUTOFRANGE, "Der angegebene Parameter liegt außerhalb des zulässigen Bereichs für diesen Befehl." +MCIERR_FLAGS_NOT_COMPATIBLE, "Die Parameter können nicht zusammen verwendet werden." MCIERR_FILE_NOT_SAVED, "Die Datei kann nicht gespeichert werden. Stellen Sie sicher, dass genügend Platz auf dem Datenträger verfügbar ist oder Ihre Netzwerkverbindung noch besteht." MCIERR_DEVICE_TYPE_REQUIRED, "Das angegebene Gerät wurde nicht gefunden. Stellen Sie sicher, dass es installiert ist oder der Gerätename richtig geschrieben ist." MCIERR_DEVICE_LOCKED, "Das angegebene Gerät wird geschlossen. Warten Sie einige Sekunden, und versuchen Sie es erneut." diff --git a/reactos/lib/winmm/winmm_res.rc b/reactos/lib/winmm/winmm_res.rc index bd0b37dea30..9b09d28c66c 100644 --- a/reactos/lib/winmm/winmm_res.rc +++ b/reactos/lib/winmm/winmm_res.rc @@ -47,773 +47,773 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL 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