/* -*- tab-width: 8; c-basic-offset: 4 -*- */ /* * MMSYSTEM functions * * Copyright 1993 Martin Ayotte * 1998-2003 Eric Pouech * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* * Eric POUECH : * 99/4 added mmTask and mmThread functions support */ #include #include #define NONAMELESSUNION #define NONAMELESSSTRUCT #include "windef.h" #include "winbase.h" #include "mmsystem.h" #include "winternl.h" #include "wownt32.h" #include "winnls.h" #include "wine/winuser16.h" #include "winemm16.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(mmsys); static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16); 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); /* ################################################### * # LIBRARY # * ################################################### */ /************************************************************************** * DllEntryPoint (MMSYSTEM.4) * * MMSYSTEM DLL entry point * */ BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds, WORD wHeapSize, DWORD dwReserved1, WORD wReserved2) { TRACE("%p 0x%x\n", hinstDLL, fdwReason); switch (fdwReason) { case DLL_PROCESS_ATTACH: /* need to load WinMM in order to: * - initiate correctly shared variables (WINMM_Init()) */ if (!GetModuleHandleA("WINMM.DLL")) { ERR("Could not load sibling WinMM.dll\n"); return FALSE; } /* hook in our 16 bit function pointers */ pFnGetMMThread16 = WINMM_GetmmThread; pFnOpenDriver16 = DRIVER_OpenDriver16; pFnCloseDriver16 = DRIVER_CloseDriver16; pFnSendMessage16 = DRIVER_SendMessage16; pFnMmioCallback16 = MMIO_Callback16; pFnReleaseThunkLock = ReleaseThunkLock; pFnRestoreThunkLock = RestoreThunkLock; MMDRV_Init16(); break; case DLL_PROCESS_DETACH: pFnGetMMThread16 = NULL; pFnOpenDriver16 = NULL; pFnCloseDriver16 = NULL; pFnSendMessage16 = NULL; pFnMmioCallback16 = NULL; pFnReleaseThunkLock = NULL; pFnRestoreThunkLock = NULL; /* FIXME: add equivalent for MMDRV_Init16() */ break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: break; } return TRUE; } /************************************************************************** * WEP [MMSYSTEM.1] */ int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg, WORD cbHeapSize, LPSTR lpCmdLine) { TRACE("STUB: Unloading MMSystem DLL ... hInst=%04X\n", hInstance); return TRUE; } /* ################################################### * # PlaySound # * ################################################### */ /************************************************************************** * PlaySound [MMSYSTEM.3] */ BOOL16 WINAPI PlaySound16(LPCSTR pszSound, HMODULE16 hmod, DWORD fdwSound) { BOOL16 retv; DWORD lc; if ((fdwSound & SND_RESOURCE) == SND_RESOURCE) { HGLOBAL16 handle; HRSRC16 res; if (!(res = FindResource16( hmod, pszSound, "WAVE" ))) return FALSE; if (!(handle = LoadResource16( hmod, res ))) return FALSE; pszSound = LockResource16(handle); fdwSound = (fdwSound & ~SND_RESOURCE) | SND_MEMORY; /* FIXME: FreeResource16 */ } ReleaseThunkLock(&lc); retv = PlaySoundA(pszSound, 0, fdwSound); RestoreThunkLock(lc); return retv; } /************************************************************************** * sndPlaySound [MMSYSTEM.2] */ BOOL16 WINAPI sndPlaySound16(LPCSTR lpszSoundName, UINT16 uFlags) { BOOL16 retv; DWORD lc; ReleaseThunkLock(&lc); retv = sndPlaySoundA(lpszSoundName, uFlags); RestoreThunkLock(lc); return retv; } /* ################################################### * # MISC # * ################################################### */ /************************************************************************** * mmsystemGetVersion [MMSYSTEM.5] * */ UINT16 WINAPI mmsystemGetVersion16(void) { return mmsystemGetVersion(); } /************************************************************************** * DriverCallback [MMSYSTEM.31] */ BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HDRVR16 hDev, WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2) { return DriverCallback(dwCallBack, uFlags, HDRVR_32(hDev), wMsg, dwUser, dwParam1, dwParam2); } /************************************************************************** * OutputDebugStr [MMSYSTEM.30] */ void WINAPI OutputDebugStr16(LPCSTR str) { OutputDebugStringA( str ); } /* ################################################### * # MIXER # * ################################################### */ /************************************************************************** * Mixer devices. New to Win95 */ /************************************************************************** * mixerGetNumDevs [MMSYSTEM.800] */ UINT16 WINAPI mixerGetNumDevs16(void) { return MMDRV_GetNum(MMDRV_MIXER); } /************************************************************************** * mixerGetDevCaps [MMSYSTEM.801] */ UINT16 WINAPI mixerGetDevCaps16(UINT16 uDeviceID, LPMIXERCAPS16 lpCaps, UINT16 uSize) { MIXERCAPSA micA; UINT ret; if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA)); if (ret == MMSYSERR_NOERROR) { MIXERCAPS16 mic16; mic16.wMid = micA.wMid; mic16.wPid = micA.wPid; mic16.vDriverVersion = micA.vDriverVersion; strcpy(mic16.szPname, micA.szPname); mic16.fdwSupport = micA.fdwSupport; mic16.cDestinations = micA.cDestinations; memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16))); } return ret; } /************************************************************************** * mixerOpen [MMSYSTEM.802] */ UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen) { HMIXER hmix; UINT ret; ret = MIXER_Open(&hmix, uDeviceID, dwCallback, dwInstance, fdwOpen, FALSE); if (lphmix) *lphmix = HMIXER_16(hmix); return ret; } /************************************************************************** * mixerClose [MMSYSTEM.803] */ UINT16 WINAPI mixerClose16(HMIXER16 hMix) { return mixerClose(HMIXER_32(hMix)); } /************************************************************************** * mixerGetID (MMSYSTEM.806) */ UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID) { UINT xid; UINT ret = mixerGetID(HMIXEROBJ_32(hmix), &xid, fdwID); if (lpid) *lpid = xid; return ret; } /************************************************************************** * mixerGetControlDetails [MMSYSTEM.808] */ UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails) { DWORD ret = MMSYSERR_NOTENABLED; SEGPTR sppaDetails; TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails); if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd)) return MMSYSERR_INVALPARAM; sppaDetails = (SEGPTR)lpmcd->paDetails; lpmcd->paDetails = MapSL(sppaDetails); ret = mixerGetControlDetailsA(HMIXEROBJ_32(hmix), (LPMIXERCONTROLDETAILS)lpmcd, fdwDetails); lpmcd->paDetails = (LPVOID)sppaDetails; return ret; } /************************************************************************** * mixerGetLineControls [MMSYSTEM.807] */ UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix, LPMIXERLINECONTROLS16 lpmlc16, DWORD fdwControls) { MIXERLINECONTROLSA mlcA; DWORD ret; unsigned int i; LPMIXERCONTROL16 lpmc16; TRACE("(%04x, %p, %08x)\n", hmix, lpmlc16, fdwControls); if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) || lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16)) return MMSYSERR_INVALPARAM; mlcA.cbStruct = sizeof(mlcA); mlcA.dwLineID = lpmlc16->dwLineID; mlcA.u.dwControlID = lpmlc16->u.dwControlID; mlcA.u.dwControlType = lpmlc16->u.dwControlType; mlcA.cControls = lpmlc16->cControls; mlcA.cbmxctrl = sizeof(MIXERCONTROLA); mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0, mlcA.cControls * mlcA.cbmxctrl); ret = mixerGetLineControlsA(HMIXEROBJ_32(hmix), &mlcA, fdwControls); if (ret == MMSYSERR_NOERROR) { lpmlc16->dwLineID = mlcA.dwLineID; lpmlc16->u.dwControlID = mlcA.u.dwControlID; lpmlc16->u.dwControlType = mlcA.u.dwControlType; lpmlc16->cControls = mlcA.cControls; lpmc16 = MapSL(lpmlc16->pamxctrl); for (i = 0; i < mlcA.cControls; i++) { lpmc16[i].cbStruct = sizeof(MIXERCONTROL16); lpmc16[i].dwControlID = mlcA.pamxctrl[i].dwControlID; lpmc16[i].dwControlType = mlcA.pamxctrl[i].dwControlType; lpmc16[i].fdwControl = mlcA.pamxctrl[i].fdwControl; lpmc16[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems; strcpy(lpmc16[i].szShortName, mlcA.pamxctrl[i].szShortName); strcpy(lpmc16[i].szName, mlcA.pamxctrl[i].szName); /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */ memcpy(&lpmc16[i].Bounds, &mlcA.pamxctrl[i].Bounds, sizeof(mlcA.pamxctrl[i].Bounds)); /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */ memcpy(&lpmc16[i].Metrics, &mlcA.pamxctrl[i].Metrics, sizeof(mlcA.pamxctrl[i].Metrics)); } } HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl); return ret; } /************************************************************************** * mixerGetLineInfo [MMSYSTEM.805] */ UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16, DWORD fdwInfo) { MIXERLINEA mliA; UINT ret; TRACE("(%04x, %p, %08x)\n", hmix, lpmli16, fdwInfo); if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16)) return MMSYSERR_INVALPARAM; mliA.cbStruct = sizeof(mliA); switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) { case MIXER_GETLINEINFOF_COMPONENTTYPE: mliA.dwComponentType = lpmli16->dwComponentType; break; case MIXER_GETLINEINFOF_DESTINATION: mliA.dwDestination = lpmli16->dwDestination; break; case MIXER_GETLINEINFOF_LINEID: mliA.dwLineID = lpmli16->dwLineID; break; case MIXER_GETLINEINFOF_SOURCE: mliA.dwDestination = lpmli16->dwDestination; mliA.dwSource = lpmli16->dwSource; break; case MIXER_GETLINEINFOF_TARGETTYPE: mliA.Target.dwType = lpmli16->Target.dwType; mliA.Target.wMid = lpmli16->Target.wMid; mliA.Target.wPid = lpmli16->Target.wPid; mliA.Target.vDriverVersion = lpmli16->Target.vDriverVersion; strcpy(mliA.Target.szPname, lpmli16->Target.szPname); break; default: FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo); } ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo); lpmli16->dwDestination = mliA.dwDestination; lpmli16->dwSource = mliA.dwSource; lpmli16->dwLineID = mliA.dwLineID; lpmli16->fdwLine = mliA.fdwLine; lpmli16->dwUser = mliA.dwUser; lpmli16->dwComponentType = mliA.dwComponentType; lpmli16->cChannels = mliA.cChannels; lpmli16->cConnections = mliA.cConnections; lpmli16->cControls = mliA.cControls; strcpy(lpmli16->szShortName, mliA.szShortName); strcpy(lpmli16->szName, mliA.szName); lpmli16->Target.dwType = mliA.Target.dwType; lpmli16->Target.dwDeviceID = mliA.Target.dwDeviceID; lpmli16->Target.wMid = mliA.Target.wMid; lpmli16->Target.wPid = mliA.Target.wPid; lpmli16->Target.vDriverVersion = mliA.Target.vDriverVersion; strcpy(lpmli16->Target.szPname, mliA.Target.szPname); return ret; } /************************************************************************** * mixerSetControlDetails [MMSYSTEM.809] */ UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails) { TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerMessage [MMSYSTEM.804] */ DWORD WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1, DWORD dwParam2) { return mixerMessage(HMIXER_32(hmix), uMsg, dwParam1, dwParam2); } /************************************************************************** * auxGetNumDevs [MMSYSTEM.350] */ UINT16 WINAPI auxGetNumDevs16(void) { return MMDRV_GetNum(MMDRV_AUX); } /* ################################################### * # AUX # * ################################################### */ /************************************************************************** * auxGetDevCaps [MMSYSTEM.351] */ UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize) { AUXCAPSA acA; UINT ret; if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA)); if (ret == MMSYSERR_NOERROR) { AUXCAPS16 ac16; ac16.wMid = acA.wMid; ac16.wPid = acA.wPid; ac16.vDriverVersion = acA.vDriverVersion; strcpy(ac16.szPname, acA.szPname); ac16.wTechnology = acA.wTechnology; ac16.dwSupport = acA.dwSupport; memcpy(lpCaps, &ac16, min(uSize, sizeof(ac16))); } return ret; } /************************************************************************** * auxGetVolume [MMSYSTEM.352] */ UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume) { LPWINE_MLD wmld; TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume); if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE); } /************************************************************************** * auxSetVolume [MMSYSTEM.353] */ UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume) { LPWINE_MLD wmld; TRACE("(%04X, %u) !\n", uDeviceID, dwVolume); if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE); } /************************************************************************** * auxOutMessage [MMSYSTEM.354] */ DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2) { LPWINE_MLD wmld; TRACE("(%04X, %04X, %08X, %08X)\n", uDeviceID, uMessage, dw1, dw2); switch (uMessage) { case AUXDM_GETNUMDEVS: case AUXDM_SETVOLUME: /* no argument conversion needed */ break; case AUXDM_GETVOLUME: return auxGetVolume16(uDeviceID, MapSL(dw1)); case AUXDM_GETDEVCAPS: return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2); default: TRACE("(%04x, %04x, %08x, %08x): unhandled message\n", uDeviceID, uMessage, dw1, dw2); break; } if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE); } /* ################################################### * # MCI # * ################################################### */ /************************************************************************** * mciGetErrorString [MMSYSTEM.706] */ BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength) { return mciGetErrorStringA(wError, lpstrBuffer, uLength); } /************************************************************************** * mciDriverNotify [MMSYSTEM.711] */ BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus) { TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus); return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID); } /************************************************************************** * mciGetDriverData [MMSYSTEM.708] */ DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID) { return mciGetDriverData(uDeviceID); } /************************************************************************** * mciSetDriverData [MMSYSTEM.707] */ BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data) { return mciSetDriverData(uDeviceID, data); } /************************************************************************** * mciSendCommand [MMSYSTEM.701] */ DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2) { DWORD dwRet; TRACE("(%04X, %s, %08X, %08X)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE); dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2)); TRACE("=> %d\n", dwRet); return dwRet; } /************************************************************************** * mciGetDeviceID [MMSYSTEM.703] */ UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName) { TRACE("(\"%s\")\n", lpstrName); return mciGetDeviceIDA(lpstrName); } /************************************************************************** * mciSetYieldProc [MMSYSTEM.714] */ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData) { LPWINE_MCIDRIVER wmd; TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData); if (!(wmd = MCI_GetDriver(uDeviceID))) { WARN("Bad uDeviceID\n"); return FALSE; } wmd->lpfnYieldProc = (YIELDPROC)fpYieldProc; wmd->dwYieldData = dwYieldData; wmd->bIs32 = FALSE; return TRUE; } /************************************************************************** * mciGetDeviceIDFromElementID [MMSYSTEM.715] */ UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType) { FIXME("(%u, %s) stub\n", dwElementID, lpstrType); return 0; } /************************************************************************** * mciGetYieldProc [MMSYSTEM.716] */ YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 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 (YIELDPROC16)wmd->lpfnYieldProc; } /************************************************************************** * mciGetCreatorTask [MMSYSTEM.717] */ HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID) { LPWINE_MCIDRIVER wmd; HTASK16 ret = 0; if ((wmd = MCI_GetDriver(uDeviceID))) ret = HTASK_16(wmd->CreatorThread); TRACE("(%u) => %04x\n", uDeviceID, ret); return ret; } /************************************************************************** * mciDriverYield [MMSYSTEM.710] */ UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID) { LPWINE_MCIDRIVER wmd; UINT16 ret = 0; /* TRACE("(%04x)\n", uDeviceID); */ if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || wmd->bIs32) { UserYield16(); } else { ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData); } return ret; } /* ################################################### * # MIDI # * ################################################### */ /************************************************************************** * midiOutGetNumDevs [MMSYSTEM.201] */ UINT16 WINAPI midiOutGetNumDevs16(void) { return MMDRV_GetNum(MMDRV_MIDIOUT); } /************************************************************************** * midiOutGetDevCaps [MMSYSTEM.202] */ UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps, UINT16 uSize) { MIDIOUTCAPSA mocA; UINT ret; if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(mocA)); if (ret == MMSYSERR_NOERROR) { MIDIOUTCAPS16 moc16; moc16.wMid = mocA.wMid; moc16.wPid = mocA.wPid; moc16.vDriverVersion = mocA.vDriverVersion; strcpy(moc16.szPname, mocA.szPname); moc16.wTechnology = mocA.wTechnology; moc16.wVoices = mocA.wVoices; moc16.wNotes = mocA.wNotes; moc16.wChannelMask = mocA.wChannelMask; moc16.dwSupport = mocA.dwSupport; memcpy(lpCaps, &moc16, min(uSize, sizeof(moc16))); } return ret; } /************************************************************************** * midiOutGetErrorText [MMSYSTEM.203] * midiInGetErrorText [MMSYSTEM.303] */ UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { return midiOutGetErrorTextA(uError, lpText, uSize); } /************************************************************************** * midiOutOpen [MMSYSTEM.204] */ UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HMIDIOUT hmo; UINT ret; ret = MIDI_OutOpen(&hmo, uDeviceID, dwCallback, dwInstance, dwFlags, FALSE); if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo); return ret; } /************************************************************************** * midiOutClose [MMSYSTEM.205] */ UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut) { return midiOutClose(HMIDIOUT_32(hMidiOut)); } /************************************************************************** * midiOutPrepareHeader [MMSYSTEM.206] */ UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */ SEGPTR lpsegMidiOutHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, MODM_PREPARE, lpsegMidiOutHdr, uSize, FALSE); } /************************************************************************** * midiOutUnprepareHeader [MMSYSTEM.207] */ UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */ SEGPTR lpsegMidiOutHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr); TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) { return MMSYSERR_NOERROR; } if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, MODM_UNPREPARE, lpsegMidiOutHdr, uSize, FALSE); } /************************************************************************** * midiOutShortMsg [MMSYSTEM.208] */ UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg) { return midiOutShortMsg(HMIDIOUT_32(hMidiOut), dwMsg); } /************************************************************************** * midiOutLongMsg [MMSYSTEM.209] */ UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut, /* [in] */ LPMIDIHDR16 lpsegMidiOutHdr, /* [???] NOTE: SEGPTR */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize, FALSE); } /************************************************************************** * midiOutReset [MMSYSTEM.210] */ UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut) { return midiOutReset(HMIDIOUT_32(hMidiOut)); } /************************************************************************** * midiOutGetVolume [MMSYSTEM.211] */ UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume) { return midiOutGetVolume(HMIDIOUT_32(uDeviceID), lpdwVolume); } /************************************************************************** * midiOutSetVolume [MMSYSTEM.212] */ UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume) { return midiOutSetVolume(HMIDIOUT_32(uDeviceID), dwVolume); } /************************************************************************** * midiOutCachePatches [MMSYSTEM.213] */ UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank, WORD* lpwPatchArray, UINT16 uFlags) { return midiOutCachePatches(HMIDIOUT_32(hMidiOut), uBank, lpwPatchArray, uFlags); } /************************************************************************** * midiOutCacheDrumPatches [MMSYSTEM.214] */ UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch, WORD* lpwKeyArray, UINT16 uFlags) { return midiOutCacheDrumPatches(HMIDIOUT_32(hMidiOut), uPatch, lpwKeyArray, uFlags); } /************************************************************************** * midiOutGetID [MMSYSTEM.215] */ UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID) { LPWINE_MLD wmld; TRACE("(%04X, %p)\n", hMidiOut, lpuDeviceID); if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = wmld->uDeviceID; return MMSYSERR_NOERROR; } /************************************************************************** * midiOutMessage [MMSYSTEM.216] */ DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWINE_MLD wmld; TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2); if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case MODM_OPEN: case MODM_CLOSE: FIXME("can't handle OPEN or CLOSE message!\n"); return MMSYSERR_NOTSUPPORTED; case MODM_GETVOLUME: return midiOutGetVolume16(hMidiOut, MapSL(dwParam1)); case MODM_LONGDATA: return midiOutLongMsg16(hMidiOut, MapSL(dwParam1), dwParam2); case MODM_PREPARE: /* lpMidiOutHdr is still a segmented pointer for this function */ return midiOutPrepareHeader16(hMidiOut, dwParam1, dwParam2); case MODM_UNPREPARE: return midiOutUnprepareHeader16(hMidiOut, dwParam1, dwParam2); } return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE); } /************************************************************************** * midiInGetNumDevs [MMSYSTEM.301] */ UINT16 WINAPI midiInGetNumDevs16(void) { return MMDRV_GetNum(MMDRV_MIDIIN); } /************************************************************************** * midiInGetDevCaps [MMSYSTEM.302] */ UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps, UINT16 uSize) { MIDIINCAPSA micA; UINT ret; if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = midiInGetDevCapsA(uDeviceID, &micA, uSize); if (ret == MMSYSERR_NOERROR) { MIDIINCAPS16 mic16; mic16.wMid = micA.wMid; mic16.wPid = micA.wPid; mic16.vDriverVersion = micA.vDriverVersion; strcpy(mic16.szPname, micA.szPname); mic16.dwSupport = micA.dwSupport; memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16))); } return ret; } /************************************************************************** * midiInOpen [MMSYSTEM.304] */ UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HMIDIIN xhmid; UINT ret; ret = MIDI_InOpen(&xhmid, uDeviceID, dwCallback, dwInstance, dwFlags, FALSE); if (lphMidiIn) *lphMidiIn = HMIDIIN_16(xhmid); return ret; } /************************************************************************** * midiInClose [MMSYSTEM.305] */ UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn) { return midiInClose(HMIDIIN_32(hMidiIn)); } /************************************************************************** * midiInPrepareHeader [MMSYSTEM.306] */ UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */ SEGPTR lpsegMidiInHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, MIDM_PREPARE, lpsegMidiInHdr, uSize, FALSE); } /************************************************************************** * midiInUnprepareHeader [MMSYSTEM.307] */ UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */ SEGPTR lpsegMidiInHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr); TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) { return MMSYSERR_NOERROR; } if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, MIDM_UNPREPARE, lpsegMidiInHdr, uSize, FALSE); } /************************************************************************** * midiInAddBuffer [MMSYSTEM.308] */ UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, /* [in] */ MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize, FALSE); } /************************************************************************** * midiInStart [MMSYSTEM.309] */ UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn) { return midiInStart(HMIDIIN_32(hMidiIn)); } /************************************************************************** * midiInStop [MMSYSTEM.310] */ UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn) { return midiInStop(HMIDIIN_32(hMidiIn)); } /************************************************************************** * midiInReset [MMSYSTEM.311] */ UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn) { return midiInReset(HMIDIIN_32(hMidiIn)); } /************************************************************************** * midiInGetID [MMSYSTEM.312] */ UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID) { LPWINE_MLD wmld; TRACE("(%04X, %p)\n", hMidiIn, lpuDeviceID); if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = wmld->uDeviceID; return MMSYSERR_NOERROR; } /************************************************************************** * midiInMessage [MMSYSTEM.313] */ DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWINE_MLD wmld; TRACE("(%04X, %04X, %08X, %08X)\n", hMidiIn, uMessage, dwParam1, dwParam2); switch (uMessage) { case MIDM_OPEN: case MIDM_CLOSE: FIXME("can't handle OPEN or CLOSE message!\n"); return MMSYSERR_NOTSUPPORTED; case MIDM_GETDEVCAPS: return midiInGetDevCaps16(hMidiIn, MapSL(dwParam1), dwParam2); case MIDM_PREPARE: return midiInPrepareHeader16(hMidiIn, dwParam1, dwParam2); case MIDM_UNPREPARE: return midiInUnprepareHeader16(hMidiIn, dwParam1, dwParam2); case MIDM_ADDBUFFER: return midiInAddBuffer16(hMidiIn, MapSL(dwParam1), dwParam2); } if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE); } /************************************************************************** * midiStreamClose [MMSYSTEM.252] */ MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm) { return midiStreamClose(HMIDISTRM_32(hMidiStrm)); } /************************************************************************** * midiStreamOpen [MMSYSTEM.251] */ MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid, DWORD cMidi, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen) { HMIDISTRM hMidiStrm32; MMRESULT ret; UINT devid32; if (!phMidiStrm || !devid) return MMSYSERR_INVALPARAM; devid32 = *devid; ret = MIDI_StreamOpen(&hMidiStrm32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen, FALSE); *phMidiStrm = HMIDISTRM_16(hMidiStrm32); *devid = devid32; return ret; } /************************************************************************** * midiStreamOut [MMSYSTEM.254] */ MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hMidiStrm, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr) { return midiStreamOut(HMIDISTRM_32(hMidiStrm), (LPMIDIHDR)lpMidiHdr, cbMidiHdr); } /************************************************************************** * midiStreamPause [MMSYSTEM.255] */ MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hMidiStrm) { return midiStreamPause(HMIDISTRM_32(hMidiStrm)); } /************************************************************************** * midiStreamPosition [MMSYSTEM.253] */ MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hMidiStrm, LPMMTIME16 lpmmt16, UINT16 cbmmt) { MMTIME mmt32; MMRESULT ret; if (!lpmmt16) return MMSYSERR_INVALPARAM; MMSYSTEM_MMTIME16to32(&mmt32, lpmmt16); ret = midiStreamPosition(HMIDISTRM_32(hMidiStrm), &mmt32, sizeof(MMTIME)); MMSYSTEM_MMTIME32to16(lpmmt16, &mmt32); return ret; } /************************************************************************** * midiStreamProperty [MMSYSTEM.250] */ MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hMidiStrm, LPBYTE lpPropData, DWORD dwProperty) { return midiStreamProperty(HMIDISTRM_32(hMidiStrm), lpPropData, dwProperty); } /************************************************************************** * midiStreamRestart [MMSYSTEM.256] */ MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hMidiStrm) { return midiStreamRestart(HMIDISTRM_32(hMidiStrm)); } /************************************************************************** * midiStreamStop [MMSYSTEM.257] */ MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hMidiStrm) { return midiStreamStop(HMIDISTRM_32(hMidiStrm)); } /* ################################################### * # WAVE # * ################################################### */ /************************************************************************** * waveOutGetNumDevs [MMSYSTEM.401] */ UINT16 WINAPI waveOutGetNumDevs16(void) { return MMDRV_GetNum(MMDRV_WAVEOUT); } /************************************************************************** * waveOutGetDevCaps [MMSYSTEM.402] */ UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, LPWAVEOUTCAPS16 lpCaps, UINT16 uSize) { WAVEOUTCAPSA wocA; UINT ret; TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA)); if (ret == MMSYSERR_NOERROR) { WAVEOUTCAPS16 woc16; woc16.wMid = wocA.wMid; woc16.wPid = wocA.wPid; woc16.vDriverVersion = wocA.vDriverVersion; strcpy(woc16.szPname, wocA.szPname); woc16.dwFormats = wocA.dwFormats; woc16.wChannels = wocA.wChannels; woc16.dwSupport = wocA.dwSupport; memcpy(lpCaps, &woc16, min(uSize, sizeof(woc16))); } return ret; } /************************************************************************** * waveOutGetErrorText [MMSYSTEM.403] * waveInGetErrorText [MMSYSTEM.503] */ UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { return waveOutGetErrorTextA(uError, lpText, uSize); } /************************************************************************** * waveOutOpen [MMSYSTEM.404] */ UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID, LPCWAVEFORMATEX lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HANDLE hWaveOut; UINT ret; /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly * call the 32 bit version * however, we need to promote correctly the wave mapper id * (0xFFFFFFFF and not 0x0000FFFF) */ ret = WAVE_Open(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID, MMDRV_WAVEOUT, lpFormat, dwCallback, dwInstance, dwFlags, FALSE); if (lphWaveOut != NULL) *lphWaveOut = HWAVEOUT_16(hWaveOut); return ret; } /************************************************************************** * waveOutClose [MMSYSTEM.405] */ UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveOutClose(HWAVEOUT_32(hWaveOut)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveOutPrepareHeader [MMSYSTEM.406] */ UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */ SEGPTR lpsegWaveOutHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr); TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, WODM_PREPARE, lpsegWaveOutHdr, uSize, FALSE); } /************************************************************************** * waveOutUnprepareHeader [MMSYSTEM.407] */ UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */ SEGPTR lpsegWaveOutHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr); TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) { return MMSYSERR_NOERROR; } if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, WODM_UNPREPARE, lpsegWaveOutHdr, uSize, FALSE); } /************************************************************************** * waveOutWrite [MMSYSTEM.408] */ UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, /* [in] */ LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize, FALSE); } /************************************************************************** * waveOutBreakLoop [MMSYSTEM.419] */ UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveOutBreakLoop(HWAVEOUT_32(hWaveOut16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveOutPause [MMSYSTEM.409] */ UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveOutPause(HWAVEOUT_32(hWaveOut16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveOutReset [MMSYSTEM.411] */ UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveOutReset(HWAVEOUT_32(hWaveOut16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveOutRestart [MMSYSTEM.410] */ UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveOutRestart(HWAVEOUT_32(hWaveOut16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveOutGetPosition [MMSYSTEM.412] */ UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime, UINT16 uSize) { UINT ret; MMTIME mmt; mmt.wType = lpTime->wType; ret = waveOutGetPosition(HWAVEOUT_32(hWaveOut), &mmt, sizeof(mmt)); MMSYSTEM_MMTIME32to16(lpTime, &mmt); return ret; } /************************************************************************** * waveOutGetPitch [MMSYSTEM.413] */ UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw) { return waveOutGetPitch(HWAVEOUT_32(hWaveOut16), lpdw); } /************************************************************************** * waveOutSetPitch [MMSYSTEM.414] */ UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16 hWaveOut16, DWORD dw) { return waveOutSetPitch(HWAVEOUT_32(hWaveOut16), dw); } /************************************************************************** * waveOutGetPlaybackRate [MMSYSTEM.417] */ UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw) { return waveOutGetPlaybackRate(HWAVEOUT_32(hWaveOut16), lpdw); } /************************************************************************** * waveOutSetPlaybackRate [MMSYSTEM.418] */ UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16 hWaveOut16, DWORD dw) { return waveOutSetPlaybackRate(HWAVEOUT_32(hWaveOut16), dw); } /************************************************************************** * waveOutGetVolume [MMSYSTEM.415] */ UINT16 WINAPI waveOutGetVolume16(UINT16 devid, LPDWORD lpdw) { return waveOutGetVolume(HWAVEOUT_32(devid), lpdw); } /************************************************************************** * waveOutSetVolume [MMSYSTEM.416] */ UINT16 WINAPI waveOutSetVolume16(UINT16 devid, DWORD dw) { return waveOutSetVolume(HWAVEOUT_32(devid), dw); } /************************************************************************** * waveOutGetID [MMSYSTEM.420] */ UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID) { LPWINE_MLD wmld; TRACE("(%04X, %p);\n", hWaveOut, lpuDeviceID); if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = wmld->uDeviceID; return 0; } /************************************************************************** * waveOutMessage [MMSYSTEM.421] */ DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWINE_MLD wmld; TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2); if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) { if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, TRUE)) != NULL) { if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE) dwParam1 = (DWORD)MapSL(dwParam1); return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2); } return MMSYSERR_INVALHANDLE; } /* from M$ KB */ if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER)) return MMSYSERR_INVALPARAM; return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE); } /************************************************************************** * waveInGetNumDevs [MMSYSTEM.501] */ UINT16 WINAPI waveInGetNumDevs16(void) { return MMDRV_GetNum(MMDRV_WAVEIN); } /************************************************************************** * waveInGetDevCaps [MMSYSTEM.502] */ UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize) { WAVEINCAPSA wicA; UINT ret; if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(wicA)); if (ret == MMSYSERR_NOERROR) { WAVEINCAPS16 wic16; wic16.wMid = wicA.wMid; wic16.wPid = wicA.wPid; wic16.vDriverVersion = wicA.vDriverVersion; strcpy(wic16.szPname, wicA.szPname); wic16.dwFormats = wicA.dwFormats; wic16.wChannels = wicA.wChannels; memcpy(lpCaps, &wic16, min(uSize, sizeof(wic16))); } return ret; } /************************************************************************** * waveInOpen [MMSYSTEM.504] */ UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID, LPCWAVEFORMATEX lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HANDLE hWaveIn; UINT ret; /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly * call the 32 bit version * however, we need to promote correctly the wave mapper id * (0xFFFFFFFF and not 0x0000FFFF) */ ret = WAVE_Open(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID, MMDRV_WAVEIN, lpFormat, dwCallback, dwInstance, dwFlags, FALSE); if (lphWaveIn != NULL) *lphWaveIn = HWAVEIN_16(hWaveIn); return ret; } /************************************************************************** * waveInClose [MMSYSTEM.505] */ UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveInClose(HWAVEIN_32(hWaveIn)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveInPrepareHeader [MMSYSTEM.506] */ UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, /* [in] */ SEGPTR lpsegWaveInHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr); UINT16 ret; TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; lpWaveInHdr->dwBytesRecorded = 0; ret = MMDRV_Message(wmld, WIDM_PREPARE, lpsegWaveInHdr, uSize, FALSE); return ret; } /************************************************************************** * waveInUnprepareHeader [MMSYSTEM.507] */ UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */ SEGPTR lpsegWaveInHdr, /* [???] */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr); TRACE("(%04X, %08x, %u);\n", hWaveIn, lpsegWaveInHdr, uSize); if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM; if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) { return MMSYSERR_NOERROR; } if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, WIDM_UNPREPARE, lpsegWaveInHdr, uSize, FALSE); } /************************************************************************** * waveInAddBuffer [MMSYSTEM.508] */ UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, /* [in] */ WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */ UINT16 uSize) /* [in] */ { LPWINE_MLD wmld; TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize); if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize, FALSE); } /************************************************************************** * waveInReset [MMSYSTEM.511] */ UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveInReset(HWAVEIN_32(hWaveIn16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveInStart [MMSYSTEM.509] */ UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveInStart(HWAVEIN_32(hWaveIn16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveInStop [MMSYSTEM.510] */ UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn16) { DWORD level; UINT16 ret; ReleaseThunkLock(&level); ret = waveInStop(HWAVEIN_32(hWaveIn16)); RestoreThunkLock(level); return ret; } /************************************************************************** * waveInGetPosition [MMSYSTEM.512] */ UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime, UINT16 uSize) { UINT ret; MMTIME mmt; mmt.wType = lpTime->wType; ret = waveInGetPosition(HWAVEIN_32(hWaveIn), &mmt, sizeof(mmt)); MMSYSTEM_MMTIME32to16(lpTime, &mmt); return ret; } /************************************************************************** * waveInGetID [MMSYSTEM.513] */ UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID) { LPWINE_MLD wmld; TRACE("(%04X, %p);\n", hWaveIn, lpuDeviceID); if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = wmld->uDeviceID; return MMSYSERR_NOERROR; } /************************************************************************** * waveInMessage [MMSYSTEM.514] */ DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWINE_MLD wmld; TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2); if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) { if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, TRUE)) != NULL) { if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE) dwParam1 = (DWORD)MapSL(dwParam1); return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2); } return MMSYSERR_INVALHANDLE; } /* from M$ KB */ if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER)) return MMSYSERR_INVALPARAM; return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE); } /* ################################################### * # TASK # * ################################################### */ /*#define USE_MM_TSK_WINE*/ /************************************************************************** * mmTaskCreate [MMSYSTEM.900] * * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be * called upon creation with dwPmt as parameter. */ HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt) { HINSTANCE16 ret; HINSTANCE16 handle; char cmdline[16]; DWORD showCmd = 0x40002; LOADPARAMS16 lp; TRACE("(%08x, %p, %08x);\n", spProc, lphMmTask, dwPmt); /* This to work requires NE modules to be started with a binary command line * which is not currently the case. A patch exists but has never been committed. * A workaround would be to integrate code for mmtask.tsk into Wine, but * this requires tremendous work (starting with patching tools/build to * create NE executables (and not only DLLs) for builtins modules. * EP 99/04/25 */ FIXME("This is currently broken. It will fail\n"); cmdline[0] = 0x0d; *(LPDWORD)(cmdline + 1) = (DWORD)spProc; *(LPDWORD)(cmdline + 5) = dwPmt; *(LPDWORD)(cmdline + 9) = 0; lp.hEnvironment = 0; lp.cmdLine = MapLS(cmdline); lp.showCmd = MapLS(&showCmd); lp.reserved = 0; #ifndef USE_MM_TSK_WINE handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", &lp); #else handle = LoadModule16("mmtask.tsk", &lp); #endif if (handle < 32) { ret = (handle) ? 1 : 2; handle = 0; } else { ret = 0; } if (lphMmTask) *lphMmTask = handle; UnMapLS( lp.cmdLine ); UnMapLS( lp.showCmd ); TRACE("=> 0x%04x/%d\n", handle, ret); return ret; } #ifdef USE_MM_TSK_WINE /* C equivalent to mmtask.tsk binary content */ void mmTaskEntryPoint16(LPSTR cmdLine, WORD di, WORD si) { int len = cmdLine[0x80]; if (len / 2 == 6) { void (*fpProc)(DWORD) = MapSL(*((DWORD*)(cmdLine + 1))); DWORD dwPmt = *((DWORD*)(cmdLine + 5)); #if 0 InitTask16(); /* FIXME: pmts / from context ? */ InitApp(di); #endif if (SetMessageQueue16(0x40)) { WaitEvent16(0); if (HIWORD(fpProc)) { OldYield16(); /* EPP StackEnter16(); */ (fpProc)(dwPmt); } } } OldYield16(); OldYield16(); OldYield16(); ExitProcess(0); } #endif /************************************************************************** * mmTaskBlock [MMSYSTEM.902] */ void WINAPI mmTaskBlock16(HINSTANCE16 hInst) { MSG msg; do { GetMessageA(&msg, 0, 0, 0); if (msg.hwnd) { TranslateMessage(&msg); DispatchMessageA(&msg); } } while (msg.message < 0x3A0); } /************************************************************************** * mmTaskSignal [MMSYSTEM.903] */ LRESULT WINAPI mmTaskSignal16(HTASK16 ht) { TRACE("(%04x);\n", ht); return PostThreadMessageW( HTASK_32(ht), WM_USER, 0, 0 ); } /************************************************************************** * mmGetCurrentTask [MMSYSTEM.904] */ HTASK16 WINAPI mmGetCurrentTask16(void) { return GetCurrentTask(); } /************************************************************************** * mmTaskYield [MMSYSTEM.905] */ void WINAPI mmTaskYield16(void) { MSG msg; if (PeekMessageA(&msg, 0, 0, 0, 0)) { WOWYield16(); } } extern DWORD WINAPI GetProcessFlags(DWORD); /****************************************************************** * WINMM_GetmmThread * * */ static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16 h) { return (WINE_MMTHREAD*)MapSL( MAKESEGPTR(h, 0) ); } DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID); /************************************************************************** * mmThreadCreate [MMSYSTEM.1120] * * undocumented * Creates a MM thread, calling fpThreadAddr(dwPmt). * dwFlags: * bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc * bit.1 set means to open a VxD for this thread (unsupported) */ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD dwPmt, DWORD dwFlags) { HANDLE16 hndl; LRESULT ret; TRACE("(%p, %p, %08x, %08x)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags); hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT); if (hndl == 0) { ret = 2; } else { WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); #if 0 /* force mmtask routines even if mmthread is required */ /* this will work only if the patch about binary cmd line and NE tasks * is committed */ dwFlags |= 1; #endif lpMMThd->dwSignature = WINE_MMTHREAD_CREATED; lpMMThd->dwCounter = 0; lpMMThd->hThread = 0; lpMMThd->dwThreadID = 0; lpMMThd->fpThread = (DWORD)fpThreadAddr; lpMMThd->dwThreadPmt = dwPmt; lpMMThd->dwSignalCount = 0; lpMMThd->hEvent = 0; lpMMThd->hVxD = 0; lpMMThd->dwStatus = 0; lpMMThd->dwFlags = dwFlags; lpMMThd->hTask = 0; if ((dwFlags & 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) { lpMMThd->hEvent = CreateEventW(NULL, FALSE, TRUE, NULL); TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd); if (lpMMThd->dwFlags & 2) { /* as long as we don't support MM VxD in wine, we don't need * to care about this flag */ /* FIXME("Don't know how to properly open VxD handles\n"); */ /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */ } lpMMThd->hThread = CreateThread(0, 0, WINE_mmThreadEntryPoint, (LPVOID)(DWORD_PTR)hndl, CREATE_SUSPENDED, &lpMMThd->dwThreadID); if (lpMMThd->hThread == 0) { WARN("Couldn't create thread\n"); /* clean-up(VxDhandle...); devicedirectio... */ if (lpMMThd->hEvent != 0) CloseHandle(lpMMThd->hEvent); ret = 2; } else { SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL); TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID); ret = 0; } } else { /* get WINE_mmThreadEntryPoint() * 2047 is its ordinal in mmsystem.spec */ FARPROC16 fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047); TRACE("farproc seg=0x%p lin=%p\n", fp, MapSL((SEGPTR)fp)); ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl); } if (ret == 0) { if (lpMMThd->hThread && !ResumeThread(lpMMThd->hThread)) WARN("Couldn't resume thread\n"); while (lpMMThd->dwStatus != 0x10) { /* test also HIWORD of dwStatus */ UserYield16(); } } } if (ret != 0) { GlobalFree16(hndl); hndl = 0; } if (lpHndl) *lpHndl = hndl; TRACE("ok => %ld\n", ret); return ret; } /************************************************************************** * mmThreadSignal [MMSYSTEM.1121] */ void WINAPI mmThreadSignal16(HANDLE16 hndl) { TRACE("(%04x)!\n", hndl); if (hndl) { WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); lpMMThd->dwCounter++; if (lpMMThd->hThread != 0) { InterlockedIncrement(&lpMMThd->dwSignalCount); SetEvent(lpMMThd->hEvent); } else { mmTaskSignal16(lpMMThd->hTask); } lpMMThd->dwCounter--; } } static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd) { MSG msg; DWORD ret; if (lpMMThd->dwThreadID != GetCurrentThreadId()) ERR("Not called by thread itself\n"); for (;;) { ResetEvent(lpMMThd->hEvent); if (InterlockedDecrement(&lpMMThd->dwSignalCount) >= 0) break; InterlockedIncrement(&lpMMThd->dwSignalCount); TRACE("S1\n"); ret = MsgWaitForMultipleObjects(1, &lpMMThd->hEvent, FALSE, INFINITE, QS_ALLINPUT); switch (ret) { case WAIT_OBJECT_0: /* Event */ TRACE("S2.1\n"); break; case WAIT_OBJECT_0 + 1: /* Msg */ TRACE("S2.2\n"); if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessageA(&msg); } break; default: WARN("S2.x unsupported ret val 0x%08x\n", ret); } TRACE("S3\n"); } } /************************************************************************** * mmThreadBlock [MMSYSTEM.1122] */ void WINAPI mmThreadBlock16(HANDLE16 hndl) { TRACE("(%04x)!\n", hndl); if (hndl) { WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); if (lpMMThd->hThread != 0) { DWORD lc; ReleaseThunkLock(&lc); MMSYSTEM_ThreadBlock(lpMMThd); RestoreThunkLock(lc); } else { mmTaskBlock16(lpMMThd->hTask); } } TRACE("done\n"); } /************************************************************************** * mmThreadIsCurrent [MMSYSTEM.1123] */ BOOL16 WINAPI mmThreadIsCurrent16(HANDLE16 hndl) { BOOL16 ret = FALSE; TRACE("(%04x)!\n", hndl); if (hndl && mmThreadIsValid16(hndl)) { WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); ret = (GetCurrentThreadId() == lpMMThd->dwThreadID); } TRACE("=> %d\n", ret); return ret; } /************************************************************************** * mmThreadIsValid [MMSYSTEM.1124] */ BOOL16 WINAPI mmThreadIsValid16(HANDLE16 hndl) { BOOL16 ret = FALSE; TRACE("(%04x)!\n", hndl); if (hndl) { WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); if (!IsBadWritePtr(lpMMThd, sizeof(WINE_MMTHREAD)) && lpMMThd->dwSignature == WINE_MMTHREAD_CREATED && IsTask16(lpMMThd->hTask)) { lpMMThd->dwCounter++; if (lpMMThd->hThread != 0) { DWORD dwThreadRet; if (GetExitCodeThread(lpMMThd->hThread, &dwThreadRet) && dwThreadRet == STATUS_PENDING) { ret = TRUE; } } else { ret = TRUE; } lpMMThd->dwCounter--; } } TRACE("=> %d\n", ret); return ret; } /************************************************************************** * mmThreadGetTask [MMSYSTEM.1125] */ HANDLE16 WINAPI mmThreadGetTask16(HANDLE16 hndl) { HANDLE16 ret = 0; TRACE("(%04x)\n", hndl); if (mmThreadIsValid16(hndl)) { WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); ret = lpMMThd->hTask; } return ret; } /************************************************************************** * __wine_mmThreadEntryPoint (MMSYSTEM.2047) */ DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID p) { HANDLE16 hndl = (HANDLE16)(DWORD_PTR)p; WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl); TRACE("(%04x %p)\n", hndl, lpMMThd); lpMMThd->hTask = LOWORD(GetCurrentTask()); TRACE("[10-%p] setting hTask to 0x%08x\n", lpMMThd->hThread, lpMMThd->hTask); lpMMThd->dwStatus = 0x10; MMSYSTEM_ThreadBlock(lpMMThd); TRACE("[20-%p]\n", lpMMThd->hThread); lpMMThd->dwStatus = 0x20; if (lpMMThd->fpThread) { WOWCallback16(lpMMThd->fpThread, lpMMThd->dwThreadPmt); } lpMMThd->dwStatus = 0x30; TRACE("[30-%p]\n", lpMMThd->hThread); while (lpMMThd->dwCounter) { Sleep(1); /* WOWYield16();*/ } TRACE("[XX-%p]\n", lpMMThd->hThread); /* paranoia */ lpMMThd->dwSignature = WINE_MMTHREAD_DELETED; /* close lpMMThread->hVxD directIO */ if (lpMMThd->hEvent) CloseHandle(lpMMThd->hEvent); GlobalFree16(hndl); TRACE("done\n"); return 0; } typedef BOOL16 (WINAPI *MMCPLCALLBACK)(HWND, LPCSTR, LPCSTR, LPCSTR); /************************************************************************** * mmShowMMCPLPropertySheet [MMSYSTEM.1150] */ BOOL16 WINAPI mmShowMMCPLPropertySheet16(HWND hWnd, LPCSTR lpStrDevice, LPCSTR lpStrTab, LPCSTR lpStrTitle) { HANDLE hndl; BOOL16 ret = FALSE; TRACE("(%p \"%s\" \"%s\" \"%s\")\n", hWnd, lpStrDevice, lpStrTab, lpStrTitle); hndl = LoadLibraryA("MMSYS.CPL"); if (hndl != 0) { MMCPLCALLBACK fp = (MMCPLCALLBACK)GetProcAddress(hndl, "ShowMMCPLPropertySheet"); if (fp != NULL) { DWORD lc; ReleaseThunkLock(&lc); ret = (fp)(hWnd, lpStrDevice, lpStrTab, lpStrTitle); RestoreThunkLock(lc); } FreeLibrary(hndl); } return ret; } /************************************************************************** * StackEnter [MMSYSTEM.32] */ void WINAPI StackEnter16(void) { #ifdef __i386__ /* mmsystem.dll from Win 95 does only this: so does Wine */ __asm__("stc"); #endif } /************************************************************************** * StackLeave [MMSYSTEM.33] */ void WINAPI StackLeave16(void) { #ifdef __i386__ /* mmsystem.dll from Win 95 does only this: so does Wine */ __asm__("stc"); #endif } /************************************************************************** * WMMMidiRunOnce [MMSYSTEM.8] */ void WINAPI WMMMidiRunOnce16(void) { FIXME("(), stub!\n"); } /* ################################################### * # DRIVER # * ################################################### */ /************************************************************************** * DRIVER_MapMsg32To16 [internal] * * Map a 32 bit driver message to a 16 bit driver message. */ static WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, LPARAM *lParam1, LPARAM *lParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; switch (wMsg) { case DRV_LOAD: case DRV_ENABLE: case DRV_DISABLE: case DRV_FREE: case DRV_QUERYCONFIGURE: case DRV_REMOVE: case DRV_EXITSESSION: case DRV_EXITAPPLICATION: case DRV_POWER: case DRV_CLOSE: /* should be 0/0 */ case DRV_OPEN: /* pass through */ /* lParam1 and lParam2 are not used */ ret = WINMM_MAP_OK; break; case DRV_CONFIGURE: case DRV_INSTALL: /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used, * lParam2 is a pointer to DRVCONFIGINFO */ if (*lParam2) { LPDRVCONFIGINFO16 dci16 = HeapAlloc( GetProcessHeap(), 0, sizeof(*dci16) ); LPDRVCONFIGINFO dci32 = (LPDRVCONFIGINFO)(*lParam2); if (dci16) { LPSTR str1 = NULL,str2; INT len; dci16->dwDCISize = sizeof(DRVCONFIGINFO16); if (dci32->lpszDCISectionName) { len = WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCISectionName, -1, NULL, 0, NULL, NULL ); str1 = HeapAlloc( GetProcessHeap(), 0, len ); if (str1) { WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCISectionName, -1, str1, len, NULL, NULL ); dci16->lpszDCISectionName = MapLS( str1 ); } else { HeapFree( GetProcessHeap(), 0, dci16); return WINMM_MAP_NOMEM; } } else { dci16->lpszDCISectionName = 0L; } if (dci32->lpszDCIAliasName) { len = WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCIAliasName, -1, NULL, 0, NULL, NULL ); str2 = HeapAlloc( GetProcessHeap(), 0, len ); if (str2) { WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCIAliasName, -1, str2, len, NULL, NULL ); dci16->lpszDCIAliasName = MapLS( str2 ); } else { HeapFree( GetProcessHeap(), 0, str1); HeapFree( GetProcessHeap(), 0, dci16); return WINMM_MAP_NOMEM; } } else { dci16->lpszDCISectionName = 0L; } } else { return WINMM_MAP_NOMEM; } *lParam2 = MapLS( dci16 ); ret = WINMM_MAP_OKMEM; } else { ret = WINMM_MAP_OK; } break; default: if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) { FIXME("Unknown message 0x%04x\n", wMsg); } ret = WINMM_MAP_OK; } return ret; } /************************************************************************** * DRIVER_UnMapMsg32To16 [internal] * * UnMap a 32 bit driver message to a 16 bit driver message. */ static WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2) { WINMM_MapType ret = WINMM_MAP_MSGERROR; switch (wMsg) { case DRV_LOAD: case DRV_ENABLE: case DRV_DISABLE: case DRV_FREE: case DRV_QUERYCONFIGURE: case DRV_REMOVE: case DRV_EXITSESSION: case DRV_EXITAPPLICATION: case DRV_POWER: case DRV_OPEN: case DRV_CLOSE: /* lParam1 and lParam2 are not used */ break; case DRV_CONFIGURE: case DRV_INSTALL: /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */ if (lParam2) { LPDRVCONFIGINFO16 dci16 = MapSL(lParam2); HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCISectionName) ); HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCIAliasName) ); UnMapLS( lParam2 ); UnMapLS( dci16->lpszDCISectionName ); UnMapLS( dci16->lpszDCIAliasName ); HeapFree( GetProcessHeap(), 0, dci16 ); } ret = WINMM_MAP_OK; break; default: if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) { FIXME("Unknown message 0x%04x\n", wMsg); } ret = WINMM_MAP_OK; } return ret; } /************************************************************************** * DRIVER_TryOpenDriver16 [internal] * * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName. */ static LPWINE_DRIVER DRIVER_OpenDriver16(LPCWSTR fn, LPCWSTR sn, LPARAM lParam2) { LPWINE_DRIVER lpDrv = NULL; LPCSTR cause = NULL; LPSTR fnA = NULL, snA = NULL; unsigned len; 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(fnA, snA, lParam2); if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;} lpDrv->dwFlags = WINE_GDF_16BIT; exit: HeapFree(GetProcessHeap(), 0, fnA); HeapFree(GetProcessHeap(), 0, snA); if (cause) { TRACE("Unable to load 16 bit module %s[%s]: %s\n", debugstr_w(fn), debugstr_w(sn), cause); HeapFree(GetProcessHeap(), 0, lpDrv); return NULL; } TRACE("=> %p\n", lpDrv); return lpDrv; } /****************************************************************** * DRIVER_SendMessage16 * * */ static LRESULT DRIVER_SendMessage16(HDRVR16 hDrv16, UINT msg, LPARAM lParam1, LPARAM lParam2) { LRESULT ret = 0; WINMM_MapType map; TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n", hDrv16, msg, lParam1, lParam2); switch (map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) { case WINMM_MAP_OKMEM: case WINMM_MAP_OK: ret = SendDriverMessage16(hDrv16, msg, lParam1, lParam2); if (map == WINMM_MAP_OKMEM) DRIVER_UnMapMsg32To16(msg, lParam1, lParam2); default: break; } return ret; } /****************************************************************** * DRIVER_CloseDriver16 * * */ static LRESULT DRIVER_CloseDriver16(HDRVR16 hDrv16, LPARAM lParam1, LPARAM lParam2) { return CloseDriver16(hDrv16, lParam1, lParam2); } /************************************************************************** * DrvOpen [MMSYSTEM.1100] */ HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam) { return OpenDriver16(lpDriverName, lpSectionName, lParam); } /************************************************************************** * DrvClose [MMSYSTEM.1101] */ LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2) { return CloseDriver16(hDrv, lParam1, lParam2); } /************************************************************************** * DrvSendMessage [MMSYSTEM.1102] */ LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1, LPARAM lParam2) { return SendDriverMessage16(hDrv, msg, lParam1, lParam2); } /************************************************************************** * DrvGetModuleHandle [MMSYSTEM.1103] */ HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv) { return GetDriverModuleHandle16(hDrv); } /************************************************************************** * DrvDefDriverProc [MMSYSTEM.1104] */ LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg, DWORD dwParam1, DWORD dwParam2) { return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2); } /************************************************************************** * DriverProc [MMSYSTEM.6] */ LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg, DWORD dwParam1, DWORD dwParam2) { TRACE("dwDevID=%08x hDrv=%04x wMsg=%04x dwParam1=%08x dwParam2=%08x\n", dwDevID, hDrv, wMsg, dwParam1, dwParam2); return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2); } /* ################################################### * # TIME # * ################################################### */ /****************************************************************** * MMSYSTEM_MMTIME32to16 * * */ void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32) { mmt16->wType = mmt32->wType; /* layout of rest is the same for 32/16, * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding */ memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u)); } /****************************************************************** * MMSYSTEM_MMTIME16to32 * * */ void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16) { mmt32->wType = mmt16->wType; /* layout of rest is the same for 32/16, * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding */ memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u)); } /************************************************************************** * timeGetSystemTime [MMSYSTEM.601] */ MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize) { if (wSize >= sizeof(*lpTime)) { lpTime->wType = TIME_MS; lpTime->u.ms = GetTickCount(); TRACE("=> %u\n", lpTime->u.ms); } return 0; } /************************************************************************** * timeSetEvent [MMSYSTEM.602] */ MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc, DWORD dwUser, UINT16 wFlags) { if (wFlags & WINE_TIMER_IS32) WARN("Unknown windows flag... wine internally used.. ooch\n"); return TIME_SetEventInternal(wDelay, wResol, (LPTIMECALLBACK)lpFunc, dwUser, wFlags & ~WINE_TIMER_IS32); } /************************************************************************** * timeKillEvent [MMSYSTEM.603] */ MMRESULT16 WINAPI timeKillEvent16(UINT16 wID) { return timeKillEvent(wID); } /************************************************************************** * timeGetDevCaps [MMSYSTEM.604] */ MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16 lpCaps, UINT16 wSize) { TIMECAPS caps; MMRESULT ret; TRACE("(%p, %u) !\n", lpCaps, wSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = timeGetDevCaps(&caps, sizeof(caps)); if (ret == MMSYSERR_NOERROR) { TIMECAPS16 tc16; tc16.wPeriodMin = caps.wPeriodMin; tc16.wPeriodMax = caps.wPeriodMax; memcpy(lpCaps, &tc16, min(wSize, sizeof(tc16))); } return ret; } /************************************************************************** * timeBeginPeriod [MMSYSTEM.605] */ MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod) { TRACE("(%u) !\n", wPeriod); return timeBeginPeriod(wPeriod); } /************************************************************************** * timeEndPeriod [MMSYSTEM.606] */ MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod) { TRACE("(%u) !\n", wPeriod); return timeEndPeriod(wPeriod); } /************************************************************************** * mciSendString [MMSYSTEM.702] */ DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet, UINT16 uRetLen, HWND16 hwndCallback) { return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback)); } /************************************************************************** * mciLoadCommandResource [MMSYSTEM.705] */ UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type) { 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; 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; } /************************************************************************** * mciFreeCommandResource [MMSYSTEM.713] */ BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable) { TRACE("(%04x)!\n", uTable); return MCI_DeleteCommandTable(uTable, TRUE); } /* ################################################### * # MMIO # * ################################################### */ /**************************************************************** * MMIO_Map32To16 [INTERNAL] */ static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2) { switch (wMsg) { case MMIOM_CLOSE: case MMIOM_SEEK: /* nothing to do */ break; case MMIOM_OPEN: case MMIOM_READ: case MMIOM_WRITE: case MMIOM_WRITEFLUSH: *lp1 = MapLS( (void *)*lp1 ); break; case MMIOM_RENAME: *lp1 = MapLS( (void *)*lp1 ); *lp2 = MapLS( (void *)*lp2 ); break; default: if (wMsg < MMIOM_USER) TRACE("Not a mappable message (%d)\n", wMsg); } return MMSYSERR_NOERROR; } /**************************************************************** * MMIO_UnMap32To16 [INTERNAL] */ static LRESULT MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2, LPARAM lp1, LPARAM lp2) { switch (wMsg) { case MMIOM_CLOSE: case MMIOM_SEEK: /* nothing to do */ break; case MMIOM_OPEN: case MMIOM_READ: case MMIOM_WRITE: case MMIOM_WRITEFLUSH: UnMapLS( lp1 ); break; case MMIOM_RENAME: UnMapLS( lp1 ); UnMapLS( lp2 ); break; default: if (wMsg < MMIOM_USER) TRACE("Not a mappable message (%d)\n", wMsg); } return MMSYSERR_NOERROR; } /****************************************************************** * MMIO_Callback16 * * */ static LRESULT MMIO_Callback16(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage, LPARAM lParam1, LPARAM lParam2) { DWORD result; MMIOINFO16 mmioInfo16; SEGPTR segmmioInfo16; LPARAM lp1 = lParam1, lp2 = lParam2; WORD args[7]; memset(&mmioInfo16, 0, sizeof(MMIOINFO16)); mmioInfo16.lDiskOffset = lpmmioinfo->lDiskOffset; mmioInfo16.adwInfo[0] = lpmmioinfo->adwInfo[0]; mmioInfo16.adwInfo[1] = lpmmioinfo->adwInfo[1]; mmioInfo16.adwInfo[2] = lpmmioinfo->adwInfo[2]; /* map (lParam1, lParam2) into (lp1, lp2) 32=>16 */ if ((result = MMIO_Map32To16(uMessage, &lp1, &lp2)) != MMSYSERR_NOERROR) return result; segmmioInfo16 = MapLS(&mmioInfo16); args[6] = HIWORD(segmmioInfo16); args[5] = LOWORD(segmmioInfo16); args[4] = uMessage; args[3] = HIWORD(lp1); args[2] = LOWORD(lp1); args[1] = HIWORD(lp2); args[0] = LOWORD(lp2); WOWCallback16Ex( cb16, WCB16_PASCAL, sizeof(args), args, &result ); UnMapLS(segmmioInfo16); MMIO_UnMap32To16(uMessage, lParam1, lParam2, lp1, lp2); lpmmioinfo->lDiskOffset = mmioInfo16.lDiskOffset; lpmmioinfo->adwInfo[0] = mmioInfo16.adwInfo[0]; lpmmioinfo->adwInfo[1] = mmioInfo16.adwInfo[1]; lpmmioinfo->adwInfo[2] = mmioInfo16.adwInfo[2]; return result; } /****************************************************************** * MMIO_ResetSegmentedData * */ static LRESULT MMIO_SetSegmentedBuffer(HMMIO hmmio, SEGPTR ptr, BOOL release) { LPWINE_MMIO wm; if ((wm = MMIO_Get(hmmio)) == NULL) return MMSYSERR_INVALHANDLE; if (release) UnMapLS(wm->segBuffer16); wm->segBuffer16 = ptr; return MMSYSERR_NOERROR; } /************************************************************************** * mmioOpen [MMSYSTEM.1210] */ HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16, DWORD dwOpenFlags) { HMMIO ret; if (lpmmioinfo16) { MMIOINFO mmioinfo; memset(&mmioinfo, 0, sizeof(mmioinfo)); mmioinfo.dwFlags = lpmmioinfo16->dwFlags; mmioinfo.fccIOProc = lpmmioinfo16->fccIOProc; mmioinfo.pIOProc = (LPMMIOPROC)lpmmioinfo16->pIOProc; mmioinfo.cchBuffer = lpmmioinfo16->cchBuffer; mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo16->pchBuffer); mmioinfo.adwInfo[0] = lpmmioinfo16->adwInfo[0]; /* if we don't have a file name, it's likely a passed open file descriptor */ if (!szFileName) mmioinfo.adwInfo[0] = (DWORD)DosFileHandleToWin32Handle(mmioinfo.adwInfo[0]); mmioinfo.adwInfo[1] = lpmmioinfo16->adwInfo[1]; mmioinfo.adwInfo[2] = lpmmioinfo16->adwInfo[2]; ret = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags, MMIO_PROC_16); MMIO_SetSegmentedBuffer(mmioinfo.hmmio, (SEGPTR)lpmmioinfo16->pchBuffer, FALSE); lpmmioinfo16->wErrorRet = mmioinfo.wErrorRet; lpmmioinfo16->hmmio = HMMIO_16(mmioinfo.hmmio); } else { ret = MMIO_Open(szFileName, NULL, dwOpenFlags, MMIO_PROC_32A); } return HMMIO_16(ret); } /************************************************************************** * mmioClose [MMSYSTEM.1211] */ MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags) { MMIO_SetSegmentedBuffer(HMMIO_32(hmmio), (SEGPTR)NULL, TRUE); return mmioClose(HMMIO_32(hmmio), uFlags); } /************************************************************************** * mmioRead [MMSYSTEM.1212] */ LONG WINAPI mmioRead16(HMMIO16 hmmio, HPSTR pch, LONG cch) { return mmioRead(HMMIO_32(hmmio), pch, cch); } /************************************************************************** * mmioWrite [MMSYSTEM.1213] */ LONG WINAPI mmioWrite16(HMMIO16 hmmio, HPCSTR pch, LONG cch) { return mmioWrite(HMMIO_32(hmmio),pch,cch); } /************************************************************************** * mmioSeek [MMSYSTEM.1214] */ LONG WINAPI mmioSeek16(HMMIO16 hmmio, LONG lOffset, INT16 iOrigin) { return mmioSeek(HMMIO_32(hmmio), lOffset, iOrigin); } /************************************************************************** * mmioGetInfo [MMSYSTEM.1215] */ MMRESULT16 WINAPI mmioGetInfo16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags) { MMIOINFO mmioinfo; MMRESULT ret; LPWINE_MMIO wm; TRACE("(0x%04x,%p,0x%08x)\n", hmmio, lpmmioinfo, uFlags); if ((wm = MMIO_Get(HMMIO_32(hmmio))) == NULL) return MMSYSERR_INVALHANDLE; ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags); if (ret != MMSYSERR_NOERROR) return ret; lpmmioinfo->dwFlags = mmioinfo.dwFlags; lpmmioinfo->fccIOProc = mmioinfo.fccIOProc; lpmmioinfo->pIOProc = (wm->ioProc->type == MMIO_PROC_16) ? (LPMMIOPROC16)wm->ioProc->pIOProc : NULL; lpmmioinfo->wErrorRet = mmioinfo.wErrorRet; lpmmioinfo->hTask = HTASK_16(mmioinfo.hTask); lpmmioinfo->cchBuffer = mmioinfo.cchBuffer; lpmmioinfo->pchBuffer = (void*)wm->segBuffer16; lpmmioinfo->pchNext = (void*)(wm->segBuffer16 + (mmioinfo.pchNext - mmioinfo.pchBuffer)); lpmmioinfo->pchEndRead = (void*)(wm->segBuffer16 + (mmioinfo.pchEndRead - mmioinfo.pchBuffer)); lpmmioinfo->pchEndWrite = (void*)(wm->segBuffer16 + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer)); lpmmioinfo->lBufOffset = mmioinfo.lBufOffset; lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset; lpmmioinfo->adwInfo[0] = mmioinfo.adwInfo[0]; lpmmioinfo->adwInfo[1] = mmioinfo.adwInfo[1]; lpmmioinfo->adwInfo[2] = mmioinfo.adwInfo[2]; lpmmioinfo->dwReserved1 = 0; lpmmioinfo->dwReserved2 = 0; lpmmioinfo->hmmio = HMMIO_16(mmioinfo.hmmio); return MMSYSERR_NOERROR; } /************************************************************************** * mmioSetInfo [MMSYSTEM.1216] */ MMRESULT16 WINAPI mmioSetInfo16(HMMIO16 hmmio, const MMIOINFO16* lpmmioinfo, UINT16 uFlags) { MMIOINFO mmioinfo; MMRESULT ret; TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags); ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0); if (ret != MMSYSERR_NOERROR) return ret; /* check if seg and lin buffers are the same */ if (mmioinfo.cchBuffer != lpmmioinfo->cchBuffer || mmioinfo.pchBuffer != MapSL((DWORD)lpmmioinfo->pchBuffer)) return MMSYSERR_INVALPARAM; /* check pointers coherence */ if (lpmmioinfo->pchNext < lpmmioinfo->pchBuffer || lpmmioinfo->pchNext > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer || lpmmioinfo->pchEndRead < lpmmioinfo->pchBuffer || lpmmioinfo->pchEndRead > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer || lpmmioinfo->pchEndWrite < lpmmioinfo->pchBuffer || lpmmioinfo->pchEndWrite > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer) return MMSYSERR_INVALPARAM; mmioinfo.pchNext = mmioinfo.pchBuffer + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer); mmioinfo.pchEndRead = mmioinfo.pchBuffer + (lpmmioinfo->pchEndRead - lpmmioinfo->pchBuffer); mmioinfo.pchEndWrite = mmioinfo.pchBuffer + (lpmmioinfo->pchEndWrite - lpmmioinfo->pchBuffer); return mmioSetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags); } /************************************************************************** * mmioSetBuffer [MMSYSTEM.1217] */ MMRESULT16 WINAPI mmioSetBuffer16(HMMIO16 hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT16 uFlags) { MMRESULT ret = mmioSetBuffer(HMMIO_32(hmmio), MapSL((DWORD)pchBuffer), cchBuffer, uFlags); if (ret == MMSYSERR_NOERROR) MMIO_SetSegmentedBuffer(HMMIO_32(hmmio), (DWORD)pchBuffer, TRUE); else UnMapLS((DWORD)pchBuffer); return ret; } /************************************************************************** * mmioFlush [MMSYSTEM.1218] */ MMRESULT16 WINAPI mmioFlush16(HMMIO16 hmmio, UINT16 uFlags) { return mmioFlush(HMMIO_32(hmmio), uFlags); } /*********************************************************************** * mmioAdvance [MMSYSTEM.1219] */ MMRESULT16 WINAPI mmioAdvance16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags) { MMIOINFO mmioinfo; LRESULT ret; /* WARNING: this heavily relies on mmioAdvance implementation (for choosing which * fields to init */ if (lpmmioinfo) { mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo->pchBuffer); mmioinfo.pchNext = MapSL((DWORD)lpmmioinfo->pchNext); mmioinfo.dwFlags = lpmmioinfo->dwFlags; mmioinfo.lBufOffset = lpmmioinfo->lBufOffset; ret = mmioAdvance(HMMIO_32(hmmio), &mmioinfo, uFlags); } else ret = mmioAdvance(HMMIO_32(hmmio), NULL, uFlags); if (ret != MMSYSERR_NOERROR) return ret; if (lpmmioinfo) { lpmmioinfo->dwFlags = mmioinfo.dwFlags; lpmmioinfo->pchNext = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer)); lpmmioinfo->pchEndRead = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer)); lpmmioinfo->pchEndWrite = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer)); lpmmioinfo->lBufOffset = mmioinfo.lBufOffset; lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset; } return MMSYSERR_NOERROR; } /************************************************************************** * mmioStringToFOURCC [MMSYSTEM.1220] */ FOURCC WINAPI mmioStringToFOURCC16(LPCSTR sz, UINT16 uFlags) { return mmioStringToFOURCCA(sz, uFlags); } /************************************************************************** * mmioInstallIOProc [MMSYSTEM.1221] */ LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc, DWORD dwFlags) { return (LPMMIOPROC16)MMIO_InstallIOProc(fccIOProc, (LPMMIOPROC)pIOProc, dwFlags, MMIO_PROC_16); } /************************************************************************** * mmioSendMessage [MMSYSTEM.1222] */ LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage, LPARAM lParam1, LPARAM lParam2) { return MMIO_SendMessage(HMMIO_32(hmmio), uMessage, lParam1, lParam2, MMIO_PROC_16); } /************************************************************************** * mmioDescend [MMSYSTEM.1223] */ MMRESULT16 WINAPI mmioDescend16(HMMIO16 hmmio, LPMMCKINFO lpck, const MMCKINFO* lpckParent, UINT16 uFlags) { return mmioDescend(HMMIO_32(hmmio), lpck, lpckParent, uFlags); } /************************************************************************** * mmioAscend [MMSYSTEM.1224] */ MMRESULT16 WINAPI mmioAscend16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags) { return mmioAscend(HMMIO_32(hmmio),lpck,uFlags); } /************************************************************************** * mmioCreateChunk [MMSYSTEM.1225] */ MMRESULT16 WINAPI mmioCreateChunk16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags) { return mmioCreateChunk(HMMIO_32(hmmio), lpck, uFlags); } /************************************************************************** * mmioRename [MMSYSTEM.1226] */ MMRESULT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName, MMIOINFO16* lpmmioinfo, DWORD dwRenameFlags) { BOOL inst = FALSE; MMRESULT ret; MMIOINFO mmioinfo; if (lpmmioinfo != NULL && lpmmioinfo->pIOProc != NULL && lpmmioinfo->fccIOProc == 0) { FIXME("Can't handle this case yet\n"); return MMSYSERR_ERROR; } /* this is a bit hacky, but it'll work if we get a fourCC code or nothing. * but a non installed ioproc without a fourcc won't do */ if (lpmmioinfo && lpmmioinfo->fccIOProc && lpmmioinfo->pIOProc) { MMIO_InstallIOProc(lpmmioinfo->fccIOProc, (LPMMIOPROC)lpmmioinfo->pIOProc, MMIO_INSTALLPROC, MMIO_PROC_16); inst = TRUE; } memset(&mmioinfo, 0, sizeof(mmioinfo)); mmioinfo.fccIOProc = lpmmioinfo->fccIOProc; ret = mmioRenameA(szFileName, szNewFileName, &mmioinfo, dwRenameFlags); if (inst) { MMIO_InstallIOProc(lpmmioinfo->fccIOProc, NULL, MMIO_REMOVEPROC, MMIO_PROC_16); } return ret; } /* ################################################### * # JOYSTICK # * ################################################### */ /************************************************************************** * joyGetNumDevs [MMSYSTEM.101] */ UINT16 WINAPI joyGetNumDevs16(void) { return joyGetNumDevs(); } /************************************************************************** * joyGetDevCaps [MMSYSTEM.102] */ MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize) { JOYCAPSA jca; MMRESULT ret; if (lpCaps == NULL) return MMSYSERR_INVALPARAM; ret = joyGetDevCapsA(wID, &jca, sizeof(jca)); if (ret != JOYERR_NOERROR) return ret; lpCaps->wMid = jca.wMid; lpCaps->wPid = jca.wPid; strcpy(lpCaps->szPname, jca.szPname); lpCaps->wXmin = jca.wXmin; lpCaps->wXmax = jca.wXmax; lpCaps->wYmin = jca.wYmin; lpCaps->wYmax = jca.wYmax; lpCaps->wZmin = jca.wZmin; lpCaps->wZmax = jca.wZmax; lpCaps->wNumButtons = jca.wNumButtons; lpCaps->wPeriodMin = jca.wPeriodMin; lpCaps->wPeriodMax = jca.wPeriodMax; if (wSize >= sizeof(JOYCAPS16)) { /* Win95 extensions ? */ lpCaps->wRmin = jca.wRmin; lpCaps->wRmax = jca.wRmax; lpCaps->wUmin = jca.wUmin; lpCaps->wUmax = jca.wUmax; lpCaps->wVmin = jca.wVmin; lpCaps->wVmax = jca.wVmax; lpCaps->wCaps = jca.wCaps; lpCaps->wMaxAxes = jca.wMaxAxes; lpCaps->wNumAxes = jca.wNumAxes; lpCaps->wMaxButtons = jca.wMaxButtons; strcpy(lpCaps->szRegKey, jca.szRegKey); strcpy(lpCaps->szOEMVxD, jca.szOEMVxD); } return ret; } /************************************************************************** * joyGetPosEx [MMSYSTEM.110] */ MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo) { return joyGetPosEx(wID, lpInfo); } /************************************************************************** * joyGetPos [MMSYSTEM.103] */ MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo) { JOYINFO ji; MMRESULT ret; TRACE("(%d, %p);\n", wID, lpInfo); if ((ret = joyGetPos(wID, &ji)) == JOYERR_NOERROR) { lpInfo->wXpos = ji.wXpos; lpInfo->wYpos = ji.wYpos; lpInfo->wZpos = ji.wZpos; lpInfo->wButtons = ji.wButtons; } return ret; } /************************************************************************** * joyGetThreshold [MMSYSTEM.104] */ MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold) { UINT t; MMRESULT ret; ret = joyGetThreshold(wID, &t); if (ret == JOYERR_NOERROR) *lpThreshold = t; return ret; } /************************************************************************** * joyReleaseCapture [MMSYSTEM.105] */ MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID) { return joyReleaseCapture(wID); } /************************************************************************** * joySetCapture [MMSYSTEM.106] */ MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL16 bChanged) { return joySetCapture(HWND_32(hWnd), wID, wPeriod, bChanged); } /************************************************************************** * joySetThreshold [MMSYSTEM.107] */ MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold) { return joySetThreshold(wID,wThreshold); } /************************************************************************** * joySetCalibration [MMSYSTEM.109] */ MMRESULT16 WINAPI joySetCalibration16(UINT16 wID) { FIXME("(%04X): stub.\n", wID); return JOYERR_NOCANDO; }