/* $Id: mci.cpp,v 1.10 2004-01-20 18:09:42 sandervl Exp $ */ /* * MCI functions * * Copyright 1998 Joel Troster * Copyright 1998/1999 Eric Pouech * Copyright 2000 Chris Wohlgemuth * * Contains portions of Wine (dlls\winmm\mci.c, winmm.c) * Copyright 1998/1999 Eric Pouech * * Project Odin Software License can be found in LICENSE.TXT * */ /**************************************************************************** * Includes * ****************************************************************************/ #define INCL_BASE #define INCL_OS2MM #include #include #include #include #include #include "debugtools.h" #include #include #include "mcimm.h" #include "winmm.h" #define DBG_LOCALLOG DBG_mci #include "dbglocal.h" /**************************************************************************** * Local functions * ****************************************************************************/ /* forward declaration */ static DWORD MCI_SendCommand(UINT mciId, UINT16 uMsg, DWORD dwParam1, DWORD dwParam2); static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) ; static UINT MCI_GetDriverFromString(LPCSTR lpstrName); /****************************************************************************/ BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus) { TRACE("Entering mciDriverNotify (%08X, %04x, %04X)\n", hwndCallback, uDeviceID, uStatus); if (!IsWindow(hwndCallback)) { WARN("bad hwnd for call back (0x%04x)\n", hwndCallback); return FALSE; } TRACE("before PostMessage\n"); PostMessageA(hwndCallback, MM_MCINOTIFY, uStatus, uDeviceID); return TRUE; } UINT WINAPI mciDriverYield(UINT uDeviceID) { dprintf(("WINMM:mciDriverYield - stub\n")); return 0; } BOOL WINAPI mciExecute(LPCSTR pszCommand) { dprintf(("WINMM:mciExecute(%s) - stub\n", pszCommand)); return FALSE; } BOOL WINAPI mciFreeCommandResource(UINT uTable) { dprintf(("WINMM:mciFreeCommandResource - stub\n")); return FALSE; } HTASK mciGetCreatorTask(MCIDEVICEID mciId) { dprintf(("WINMM:mciGetCreatorTask - stub\n")); return 0; } MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR pszDevice) { WARN(("WINMM:mciGetDeviceIDA - untested\n")); return MCI_GetDriverFromString(pszDevice); } MCIDEVICEID WINAPI mciGetDeviceIDW(LPCWSTR pszDevice) { dprintf(("WINMM:mciGetDeviceIDW - stub\n")); return 0; } MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType) { dprintf(("WINMM:mciGetDeviceIDFromElementIDA - stub\n")); return 0; } MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType) { dprintf(("WINMM:mciGetDeviceIDFromElementIDW - stub\n")); return 0; } /***************************************************************************** * Queries driver data * Parameters: UINT uDeviceID * Variables : * @return : Pointer to driver data (as a DWORD) * Remark : * @status : Completely * * @author : Chris Wohlgemuth [Sun, 2000/11/19] *****************************************************************************/ DWORD WINAPI mciGetDriverData(UINT uDeviceID) { LPWINE_MCIDRIVER wmd; wmd = MCI_GetDriver(uDeviceID); if (!wmd) { dprintf(("WARNING: Bad uDeviceID (mciGetDriverData (mci.cpp line %d)\n",__LINE__)); return 0L; /* Error */ } return wmd->dwPrivate; } /***************************************************************************** * Converts an error to an error string * Parameters: MCIERROR mcierr, * LPSTR pszText, * UINT cchText * Variables : * @return : API returncode (TRUE/FALSE) * Remark : * @status : Completely * * @author : Wine *****************************************************************************/ BOOL WINAPI mciGetErrorStringA(MCIERROR mcierr, LPSTR pszText, UINT cchText) { dprintf(("WINMM:mciGetErrorStringA(%d)\n", mcierr )); const char * theMsg = getWinmmMsg( mcierr ); if ( theMsg ) strncpy( pszText, theMsg, cchText ); else { char errMsg[100]; sprintf( errMsg, "Unknown error number %d", mcierr ); strncpy( pszText, errMsg, cchText ); } return TRUE; } /***************************************************************************** * Converts an error to an error string * Parameters: MCIERROR mcierr, * LPSTR pszText, * UINT cchText * Variables : * @return : API returncode (TRUE/FALSE) * Remark : * @status : Completely * * @author : Wine *****************************************************************************/ BOOL WINAPI mciGetErrorStringW(MCIERROR mcierr, LPWSTR pszText, UINT cchText) { dprintf(("WINMM:mciGetErrorStringW(%d)\n", mcierr )); const char * theMsg = getWinmmMsg( mcierr ); if ( theMsg ) AsciiToUnicodeN( theMsg, pszText, cchText ); else { char errMsg[100]; sprintf( errMsg, "Unknown error number %d", mcierr ); AsciiToUnicodeN( errMsg, pszText, cchText ); } return TRUE; } /***************************************************************************** * Converts an error to an error string * Parameters: MCIERROR mcierr, * LPSTR pszText, * UINT cchText * Variables : * @return : API returncode * Remark : * @status : Completely * * @author : Wine *****************************************************************************/ YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID mciId, LPDWORD pdwYieldData) { LPWINE_MCIDRIVER wmd; TRACE("Entering mciGetYieldProc (%u, %p) - untested\n", mciId, pdwYieldData); if (!(wmd = MCI_GetDriver(mciId))) { 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; } UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance, LPCWSTR lpResName, UINT uType) { dprintf(("WINMM:mciLoadCOmmandResource - stub\n")); return 0; } MCIERROR WINAPI mciSendCommandA(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1, DWORD dwParam2) { DWORD dwRet; // dprintf(("WINMM:mciSendCommandA - entering %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2)); dwRet= MCI_SendCommand((UINT) mciId, uMsg, dwParam1, dwParam2) & 0xFFFF; return(dwRet); } /************************************************************************** * MCI_MessageToString [internal] */ const char* MCI_MessageToString(UINT16 wMsg) { static char buffer[100]; #define CASE(s) case (s): return #s switch (wMsg) { CASE(MCI_BREAK); CASE(MCI_CLOSE); CASE(MCI_CLOSE_DRIVER); CASE(MCI_COPY); CASE(MCI_CUE); CASE(MCI_CUT); CASE(MCI_DELETE); CASE(MCI_ESCAPE); CASE(MCI_FREEZE); CASE(MCI_PAUSE); CASE(MCI_PLAY); CASE(MCI_GETDEVCAPS); CASE(MCI_INFO); CASE(MCI_LOAD); CASE(MCI_OPEN); CASE(MCI_OPEN_DRIVER); CASE(MCI_PASTE); CASE(MCI_PUT); CASE(MCI_REALIZE); CASE(MCI_RECORD); CASE(MCI_RESUME); CASE(MCI_SAVE); CASE(MCI_SEEK); CASE(MCI_SET); CASE(MCI_SPIN); CASE(MCI_STATUS); CASE(MCI_STEP); CASE(MCI_STOP); CASE(MCI_SYSINFO); CASE(MCI_UNFREEZE); CASE(MCI_UPDATE); CASE(MCI_WHERE); CASE(MCI_WINDOW); /* constants for digital video */ /* CASE(MCI_CAPTURE); CASE(MCI_MONITOR); CASE(MCI_RESERVE); CASE(MCI_SETAUDIO); CASE(MCI_SIGNAL); CASE(MCI_SETVIDEO); CASE(MCI_QUALITY); CASE(MCI_LIST); CASE(MCI_UNDO); CASE(MCI_CONFIGURE); CASE(MCI_RESTORE); */ #undef CASE default: sprintf(buffer, "MCI_<<%04X>>", wMsg); return buffer; } } 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 = (LPSTR)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 dwParam1, DWORD *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 = (DWORD *)HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_openA) + sizeof(DWORD)); if (!ptr) return -1; *ptr++ = *dwParam2; /* save the previous pointer */ *dwParam2 = (DWORD)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 = (MCI_ANIM_WINDOW_PARMSA *)HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowA)); if (!mci_windowA) return -1; *dwParam2 = (DWORD)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 = (DWORD *)HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoA) + sizeof(DWORD)); if (!ptr) return -1; *ptr++ = *dwParam2; /* save the previous pointer */ *dwParam2 = (DWORD)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 = (CHAR *)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; } return 0; } static DWORD MCI_UnmapMsgWtoA(UINT msg, DWORD dwParam1, DWORD dwParam2, DWORD result) { switch(msg) { case MCI_OPEN: { DWORD *ptr = (DWORD *)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, (LPVOID)mci_openA->lpstrDeviceType); } if (dwParam1 & MCI_OPEN_ELEMENT) { if (!(dwParam1 & MCI_OPEN_ELEMENT_ID)) HeapFree(GetProcessHeap(), 0, (LPVOID)mci_openA->lpstrElementName); } if (dwParam1 & MCI_OPEN_ALIAS) HeapFree(GetProcessHeap(), 0, (LPVOID)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 = (DWORD *)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 dwParam1, DWORD dwParam2) { DWORD ret; int mapped; dprintf(("(%08x, %s, %08lx, %08lx)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2)); mapped = MCI_MapMsgWtoA(wMsg, dwParam1, &dwParam2); if (mapped == -1) { dprintf(("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; } MCIERROR WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback) { dprintf(("WINMM:mciSendStringA - stub\n")); if(lpstrCommand) dprintf(("WINMM:mciSendStringA command: %s\n",lpstrCommand)); return(MMSYSERR_NODRIVER); } MCIERROR WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback) { dprintf(("WINMM:mciSendStringW - stub\n")); return(MMSYSERR_NODRIVER); } BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData) { LPWINE_MCIDRIVER wmd; wmd = MCI_GetDriver(uDeviceID); if (!wmd) { dprintf(("WARNING: Bad uDeviceID (mciSetDriverData line %d)\n",__LINE__)); return FALSE; } wmd->dwPrivate = dwData; return TRUE; } BOOL WINAPI mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData) { LPWINE_MCIDRIVER wmd; TRACE("WINMM:mciSetYieldProc (%u, %p, %08lx) - untested\n", mciId, fpYieldProc, dwYieldData); if (!(wmd = MCI_GetDriver(mciId))) { WARN("Bad uDeviceID\n"); return FALSE; } wmd->lpfnYieldProc = fpYieldProc; wmd->dwYieldData = dwYieldData; wmd->bIs32 = TRUE; return TRUE; } /**************************************************************************/ /* heap.c */ /**************************************************************************/ #ifdef __GNUC__ #define GET_EIP() (__builtin_return_address(0)) #define SET_EIP(ptr) ((ARENA_INUSE*)(ptr) - 1)->callerEIP = GET_EIP() #else #define GET_EIP() 0 #define SET_EIP(ptr) /* nothing */ #endif /* __GNUC__ */ /**************************************************************************/ /* mmmsystem.c */ /**************************************************************************/ static LPWINE_MM_IDATA lpFirstIData = NULL; static LPWINE_MM_IDATA MULTIMEDIA_GetIDataNoCheck(void) { DWORD pid = GetCurrentProcessId(); LPWINE_MM_IDATA iData; for (iData = lpFirstIData; iData; iData = iData->lpNextIData) { if (iData->dwThisProcess == pid) break; } return iData; } /************************************************************************** * MULTIMEDIA_GetIData [internal] */ LPWINE_MM_IDATA MULTIMEDIA_GetIData(void) { LPWINE_MM_IDATA iData = MULTIMEDIA_GetIDataNoCheck(); if (!iData) { dprintf(("MULTIMEDIA_GetIData: IData not found for pid=%08lx. Suicide !!!\n", GetCurrentProcessId())); ExitProcess(0); } return iData; } /************************************************************************** * MULTIMEDIA_CreateIData [internal] */ BOOL MULTIMEDIA_CreateIData(HINSTANCE hInstDLL) { LPWINE_MM_IDATA iData; iData = (LPWINE_MM_IDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MM_IDATA)); if (!iData) return FALSE; iData->hWinMM32Instance = hInstDLL; iData->dwThisProcess = GetCurrentProcessId(); iData->lpNextIData = lpFirstIData; lpFirstIData = iData; InitializeCriticalSection(&iData->cs); dprintf(("Created IData (%p) for pid %08lx\n", iData, iData->dwThisProcess)); return TRUE; } /************************************************************************** * MULTIMEDIA_DeleteIData [internal] */ void MULTIMEDIA_DeleteIData(void) { LPWINE_MM_IDATA iData = MULTIMEDIA_GetIDataNoCheck(); LPWINE_MM_IDATA* ppid; if (iData) { for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) { if (*ppid == iData) { *ppid = iData->lpNextIData; break; } } /* FIXME: should also free content and resources allocated * inside iData */ HeapFree(GetProcessHeap(), 0, iData); } } /**************************************************************************/ /* mmmsystem.c */ /**************************************************************************/ static int MCI_InstalledCount; static LPSTR MCI_lpInstallNames = NULL; /* First MCI valid device ID (0 means error) */ #define MCI_MAGIC 0x0001 /************************************************************************** * MCI_GetDriver [internal] */ static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) { LPWINE_MCIDRIVER wmd = 0; LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData(); EnterCriticalSection(&iData->cs); for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) { if (wmd->wDeviceID == wDevID) break; } LeaveCriticalSection(&iData->cs); return wmd; } /************************************************************************** * MCI_GetDriverFromString [internal] */ static UINT MCI_GetDriverFromString(LPCSTR lpstrName) { LPWINE_MCIDRIVER wmd; LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData(); UINT ret = 0; if (!lpstrName) return 0; if (!lstrcmpiA(lpstrName, "ALL")) return MCI_ALL_DEVICE_ID; EnterCriticalSection(&iData->cs); for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) { if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) { ret = wmd->wDeviceID; break; } if (wmd->lpstrDeviceType && strcmp(wmd->lpstrDeviceType, lpstrName) == 0) { ret = wmd->wDeviceID; break; } if (wmd->lpstrAlias && strcmp(wmd->lpstrAlias, lpstrName) == 0) { ret = wmd->wDeviceID; break; } } LeaveCriticalSection(&iData->cs); return ret; } /************************************************************************** * MCI_GetDevTypeFromFileName [internal] */ static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len) { LPSTR tmp; if ((tmp = strrchr(fileName, '.'))) { GetProfileStringA("mci extensions", tmp + 1, "*", buf, len); if (strcmp(buf, "*") != 0) { return 0; } dprintf(("No [mci extensions] entry for '%s' found. MCI_GetDevTypeFromFileName: line %d, file 'mci.cpp'\n", tmp, __LINE__)); } return MCIERR_EXTENSION_NOT_FOUND; } #define MAX_MCICMDTABLE 20 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE /************************************************************************** * MCI_DefYieldProc [internal] */ //UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data) UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data) { INT16 ret; #if 0 dprintf(("(0x%04x, 0x%08lx)\n", wDevID, data)); #endif if ((HIWORD(data) != 0 && GetActiveWindow() != HIWORD(data)) || (GetAsyncKeyState(LOWORD(data)) & 1) == 0) { /* WINE stuff removed: UserYield16();*/ ret = 0; } else { MSG msg; msg.hwnd = HIWORD(data); while (!PeekMessageA(&msg, HIWORD(data), WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); ret = -1; } return ret; } /************************************************************************** * MCI_UnLoadMciDriver [internal] */ static BOOL MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd) { LPWINE_MCIDRIVER* tmp; #if 0 dprintf(("Entering MCI_UnLoadMciDriver...\n")); #endif if (!wmd) return TRUE; if (wmd->hDrv) CloseDriver(wmd->hDrv, 0, 0); if (wmd->dwPrivate != 0) dprintf(("Unloading mci driver with non nul dwPrivate field\n")); EnterCriticalSection(&iData->cs); for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) { if (*tmp == wmd) { *tmp = wmd->lpNext; break; } } LeaveCriticalSection(&iData->cs); HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType); HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias); HeapFree(GetProcessHeap(), 0, wmd->lpstrElementName); HeapFree(GetProcessHeap(), 0, wmd); //dprintf(("Leaving MCI_UnLoadMciDriver...\n")); return TRUE; } /************************************************************************** * MCI_LoadMciDriver [internal] */ static DWORD MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) { LPSTR strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp)); LPWINE_MCIDRIVER wmd = (LPWINE_MCIDRIVER)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd)); MCI_OPEN_DRIVER_PARMSA modp; DWORD dwRet = 0; HDRVR hDrv = 0; dprintf(("Entering MCI_LoadMciDriver...\n")); if (!wmd || !strDevTyp) { dwRet = MCIERR_OUT_OF_MEMORY; goto errCleanUp; } wmd->lpstrDeviceType = strDevTyp; wmd->lpfnYieldProc = MCI_DefYieldProc; wmd->dwYieldData = VK_CANCEL; wmd->hCreatorTask = NULL; EnterCriticalSection(&iData->cs); /* wmd must be inserted in list before sending opening the driver, coz' it * may want to lookup at wDevID */ wmd->lpNext = iData->lpMciDrvs; iData->lpMciDrvs = wmd; for (modp.wDeviceID = MCI_MAGIC; MCI_GetDriver(modp.wDeviceID) != 0; modp.wDeviceID++); wmd->wDeviceID = modp.wDeviceID; LeaveCriticalSection(&iData->cs); dprintf(("wDevID=%04X strDevTyp: %s\n", modp.wDeviceID, strDevTyp)); modp.lpstrParams = NULL; hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp); if (!hDrv) { dprintf(("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)); dwRet = MCIERR_DEVICE_NOT_INSTALLED; goto errCleanUp; } /* FIXME: should also check that module's description is of the form * MODULENAME:[MCI] comment */ wmd->hDrv = hDrv; /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */ wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable); wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED; dprintf(("Loaded driver %x (%s), type is %d, cmdTable=%08x\n", hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable)); wmd->wType = modp.wType; #if 0 dprintf(("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n", modp.wDeviceID, modp.wType, modp.wDeviceID)); #endif *lpwmd = wmd; #if 0 dprintf(("Leaving MCI_LoadMciDriver succesful...\n")); #endif return 0; errCleanUp: MCI_UnLoadMciDriver(iData, wmd); // HeapFree(GetProcessHeap(), 0, strDevTyp);<-- done in MCI_UnloadMciDriver *lpwmd = 0; dprintf(("Leaving MCI_LoadMciDriver on error...\n")); return dwRet; } /************************************************************************** * MCI_SendCommandFrom32 [internal] */ static DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2) { DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED; LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID); if (!wmd) { dwRet = MCIERR_INVALID_DEVICE_ID; } else { switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST)) { case WINE_GDF_EXIST: dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2); break; default: dprintf(("Unknown driver %u\n", wmd->hDrv)); dwRet = MCIERR_DRIVER_INTERNAL; } } return dwRet; } /************************************************************************** * MCI_FinishOpen [internal] */ static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms, DWORD dwParam) { if (dwParam & MCI_OPEN_ELEMENT) wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrElementName); if (dwParam & MCI_OPEN_ALIAS) wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias); lpParms->wDeviceID = wmd->wDeviceID; return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam, (DWORD)lpParms); } /************************************************************************** * MCI_Open [internal] */ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms) { char strDevTyp[128]; DWORD dwRet; LPWINE_MCIDRIVER wmd = NULL; LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData(); dprintf(("Entering MCI_OPEN...\n")); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; /* only two low bytes are generic, the other ones are dev type specific */ #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \ MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \ MCI_NOTIFY|MCI_WAIT) if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) { dprintf(("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP)); } #undef WINE_MCIDRIVER_SUPP strDevTyp[0] = 0; if (dwParam & MCI_OPEN_TYPE) { if (dwParam & MCI_OPEN_TYPE_ID) { WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType); if (uDevType < MCI_DEVTYPE_FIRST || uDevType > MCI_DEVTYPE_LAST || !LoadStringA(iData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) /* This gets a name for the device e.g 'cdaudio' */ { dwRet = MCIERR_BAD_INTEGER; goto errCleanUp; } } else { LPSTR ptr; if (lpParms->lpstrDeviceType == NULL) { dwRet = MCIERR_NULL_PARAMETER_BLOCK; goto errCleanUp; } strcpy(strDevTyp, lpParms->lpstrDeviceType); ptr = strchr(strDevTyp, '!'); if (ptr) { /* this behavior is not documented in windows. However, since, in * some occasions, MCI_OPEN handling is translated by WinMM into * a call to mciSendString("open "); this code shall be correct */ if (dwParam & MCI_OPEN_ELEMENT) { dprintf(("Both MCI_OPEN_ELEMENT(%s) and %s are used\n", lpParms->lpstrElementName, strDevTyp)); dwRet = MCIERR_UNRECOGNIZED_KEYWORD; goto errCleanUp; } dwParam |= MCI_OPEN_ELEMENT; *ptr++ = 0; /* FIXME: not a good idea to write in user supplied buffer */ lpParms->lpstrElementName = ptr; } } dprintf(("MCI_OPEN (MCI_OPEN_TYPE): devType='%s' !\n", strDevTyp)); } if (dwParam & MCI_OPEN_ELEMENT) { dprintf(("lpstrElementName='%s'\n", lpParms->lpstrElementName)); if (dwParam & MCI_OPEN_ELEMENT_ID) { dprintf(("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n")); dwRet = MCIERR_UNRECOGNIZED_KEYWORD; goto errCleanUp; } if (!lpParms->lpstrElementName) { dwRet = MCIERR_NULL_PARAMETER_BLOCK; goto errCleanUp; } #if 0 /* Only working on my machine!! CW */ if(lpParms->lpstrElementName[0]=='N') { dprintf(("Discarding drive N:\n")); dwRet = MCIERR_UNRECOGNIZED_KEYWORD; goto errCleanUp; } #endif /* type, if given as a parameter, supersedes file extension */ if (!strDevTyp[0] && MCI_GetDevTypeFromFileName(lpParms->lpstrElementName, strDevTyp, sizeof(strDevTyp))) { if (GetDriveTypeA(lpParms->lpstrElementName) == DRIVE_CDROM) { /* FIXME: this will not work if several CDROM drives are installed on the machine */ strcpy(strDevTyp, "CDAUDIO"); } else if (GetFileAttributesA(lpParms->lpstrElementName) != INVALID_FILE_ATTRIBUTES) { // TODO: Assuming wave file here strcpy(strDevTyp, "WAVEAUDIO"); } else { dwRet = MCIERR_EXTENSION_NOT_FOUND; goto errCleanUp; } } } if (strDevTyp[0] == 0) { dprintf(("Couldn't load driver (MCI_Open line %d)\n",__LINE__)); dwRet = MCIERR_INVALID_DEVICE_NAME; goto errCleanUp; } if (dwParam & MCI_OPEN_ALIAS) { dprintf(("MCI_OPEN_ALIAS requested\n")); if (!lpParms->lpstrAlias) { dwRet = MCIERR_NULL_PARAMETER_BLOCK; goto errCleanUp; } dprintf(("Alias='%s' !\n", lpParms->lpstrAlias)); } if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) { goto errCleanUp; } if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) { dprintf(("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet)); /* FIXME: is dwRet the correct ret code ? */ goto errCleanUp; } /* only handled devices fall through */ dprintf(("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet)); if (dwParam & MCI_NOTIFY) // mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL); dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__)); return 0; errCleanUp: if (wmd) MCI_UnLoadMciDriver(iData, wmd); if (dwParam & MCI_NOTIFY) // mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE); dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__)); dprintf(("Leaving MCI_Open on error...\n")); return dwRet; } /************************************************************************** * MCI_Close [internal] */ static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { DWORD dwRet; LPWINE_MCIDRIVER wmd; LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData(); //dprintf(("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms)); if (wDevID == MCI_ALL_DEVICE_ID) { LPWINE_MCIDRIVER next; EnterCriticalSection(&iData->cs); /* FIXME: shall I notify once after all is done, or for * each of the open drivers ? if the latest, which notif * to return when only one fails ? */ for (wmd = iData->lpMciDrvs; wmd; ) { next = wmd->lpNext; MCI_Close(wmd->wDeviceID, dwParam, lpParms); wmd = next; } LeaveCriticalSection(&iData->cs); return 0; } if (!(wmd = MCI_GetDriver(wDevID))) { return MCIERR_INVALID_DEVICE_ID; } dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms); MCI_UnLoadMciDriver(iData, wmd); if (dwParam & MCI_NOTIFY) dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Close (line %d)\n",__LINE__)); // mciDriverNotify16(lpParms->dwCallback, wDevID, // (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE); return dwRet; } /************************************************************************** * MCI_WriteString [internal] */ DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr) { DWORD ret = 0; if (lpSrcStr) { if (dstSize <= strlen(lpSrcStr)) { lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1); ret = MCIERR_PARAM_OVERFLOW; } else { strcpy(lpDstStr, lpSrcStr); } } else { *lpDstStr = 0; } return ret; } /************************************************************************** * MCI_Sysinfo [internal] */ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms) { DWORD ret = MCIERR_INVALID_DEVICE_ID; LPWINE_MCIDRIVER wmd; LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData(); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n", uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType); switch (dwFlags & ~MCI_SYSINFO_OPEN) { case MCI_SYSINFO_QUANTITY: { DWORD cnt = 0; if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) { if (dwFlags & MCI_SYSINFO_OPEN) { TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n"); EnterCriticalSection(&iData->cs); for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) { cnt++; } LeaveCriticalSection(&iData->cs); } else { TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n"); cnt = MCI_InstalledCount; } } else { if (dwFlags & MCI_SYSINFO_OPEN) { TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType); EnterCriticalSection(&iData->cs); for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) { if (wmd->wType == lpParms->wDeviceType) cnt++; } LeaveCriticalSection(&iData->cs); } else { TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType); FIXME("Don't know how to get # of MCI devices of a given type\n"); cnt = 1; } } *(DWORD*)lpParms->lpstrReturn = cnt; } TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn); ret = MCI_INTEGER_RETURNED; break; case MCI_SYSINFO_INSTALLNAME: TRACE("MCI_SYSINFO_INSTALLNAME \n"); if ((wmd = MCI_GetDriver(uDevID))) { ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, wmd->lpstrDeviceType); } else { *lpParms->lpstrReturn = 0; ret = MCIERR_INVALID_DEVICE_ID; } TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn); break; case MCI_SYSINFO_NAME: TRACE("MCI_SYSINFO_NAME\n"); if (dwFlags & MCI_SYSINFO_OPEN) { FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n"); ret = MCIERR_UNRECOGNIZED_COMMAND; } else if (lpParms->dwNumber > MCI_InstalledCount) { ret = MCIERR_OUTOFRANGE; } else { DWORD count = lpParms->dwNumber; LPSTR ptr = MCI_lpInstallNames; while (--count > 0) ptr += strlen(ptr) + 1; ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr); } TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn); break; default: TRACE("Unsupported flag value=%08lx\n", dwFlags); ret = MCIERR_UNRECOGNIZED_COMMAND; } return ret; } /************************************************************************** * MCI_Break [internal] */ static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms) { DWORD dwRet = 0; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (dwFlags & MCI_NOTIFY) dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Break (line %d)\n",__LINE__)); // mciDriverNotify16(lpParms->dwCallback, wDevID, // (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE); return dwRet; } /************************************************************************** * MCI_SendCommand [internal] */ static DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2) { DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND; switch (wMsg) { case MCI_OPEN: dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2); break; case MCI_CLOSE: dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); break; case MCI_SYSINFO: dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2); break; case MCI_BREAK: dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2); break; // case MCI_SOUND: /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK * but I couldn't get any doc on this MCI message */ // break; default: if (wDevID == MCI_ALL_DEVICE_ID) { dprintf(("MCI_SendCommand: unhandled MCI_ALL_DEVICE_ID\n")); dwRet = MCIERR_CANNOT_USE_ALL; } else { dwRet=MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2); } break; } return dwRet; } /************************************************************************** * MULTIMEDIA_MciInit [internal] * * Initializes the MCI internal variables. * */ BOOL MULTIMEDIA_MciInit(void) { LPSTR ptr1, ptr2; HKEY hWineConf; HKEY hkey; DWORD err; DWORD type; DWORD count = 2048; MCI_InstalledCount = 0; ptr1 = MCI_lpInstallNames = (char*) HeapAlloc(GetProcessHeap(), 0, count); if (!MCI_lpInstallNames) return FALSE; #if 0 /* FIXME: should do also some registry diving here ? */ if (!(err = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) && !(err = RegOpenKeyA(hWineConf, "options", &hkey))) { err = RegQueryValueExA(hkey, "mci", 0, &type, MCI_lpInstallNames, &count); RegCloseKey(hkey); FIXME("Registry handling for mci drivers not changed for odin yet. Verbatim copy from WINE (line %d)",__LINE__); } FIXME("No Registry querying for mci drivers yet! (line %d)",__LINE__); err=1; if (!err) { TRACE("Wine => '%s' \n", ptr1); while ((ptr2 = strchr(ptr1, ':')) != 0) { *ptr2++ = 0; TRACE("---> '%s' \n", ptr1); MCI_InstalledCount++; ptr1 = ptr2; } MCI_InstalledCount++; TRACE("---> '%s' \n", ptr1); ptr1 += strlen(ptr1) + 1; } else { GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, count, "SYSTEM.INI"); while (strlen(ptr1) > 0) { TRACE("---> '%s' \n", ptr1); ptr1 += strlen(ptr1) + 1; MCI_InstalledCount++; } } //RegCloseKey(hWineConf); #else //Just used hardcoded names here strcpy(MCI_lpInstallNames, "CDAUDIO=MCICDA"); strcpy(MCI_lpInstallNames+strlen(MCI_lpInstallNames)+1, "WAVEAUDIO=MCIWAVE"); MCI_InstalledCount = 2; #endif return TRUE; }