| /* -*- 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 <stdarg.h> | |
| #include <string.h> | |
| #define NONAMELESSUNION | |
| #define NONAMELESSSTRUCT | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "mmsystem.h" | |
| #include "winternl.h" | |
| #include "wownt32.h" | |
| #include "winnls.h" | |
| #include "wine/list.h" | |
| #include "wine/winuser16.h" | |
| #include "winemm16.h" | |
| #include "wine/debug.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(mmsys); | |
| static CRITICAL_SECTION_DEBUG mmdrv_critsect_debug = | |
| { | |
| 0, 0, &mmdrv_cs, | |
| { &mmdrv_critsect_debug.ProcessLocksList, &mmdrv_critsect_debug.ProcessLocksList }, | |
| 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmdrv_cs") } | |
| }; | |
| CRITICAL_SECTION mmdrv_cs = { &mmdrv_critsect_debug, -1, 0, 0, 0, 0 }; | |
| /* ################################################### | |
| * # LIBRARY # | |
| * ################################################### | |
| */ | |
| /************************************************************************** | |
| * DllEntryPoint (MMSYSTEM.4) | |
| * | |
| * MMSYSTEM DLL entry point | |
| * | |
| */ | |
| BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds, | |
| WORD wHeapSize, DWORD dwReserved1, WORD wReserved2) | |
| { | |
| static int done; | |
| if (!done++) LoadLibrary16( "sound.drv" ); | |
| 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; | |
| } | |
| /* ################################################### | |
| * # 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 | |
| * | |
| * | |
| */ | |
| static 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; | |
| } | |
| struct timer_entry { | |
| struct list entry; | |
| UINT id; | |
| LPTIMECALLBACK16 func16; | |
| DWORD user; | |
| }; | |
| static struct list timer_list = LIST_INIT(timer_list); | |
| static void CALLBACK timeCB3216(UINT id, UINT uMsg, DWORD_PTR user, DWORD_PTR dw1, DWORD_PTR dw2) | |
| { | |
| struct timer_entry* te = (void*)user; | |
| WORD args[8]; | |
| DWORD ret; | |
| args[7] = LOWORD(id); | |
| args[6] = LOWORD(uMsg); | |
| args[5] = HIWORD(te->user); | |
| args[4] = LOWORD(te->user); | |
| args[3] = HIWORD(dw1); | |
| args[2] = LOWORD(dw2); | |
| args[1] = HIWORD(dw2); | |
| args[0] = LOWORD(dw2); | |
| WOWCallback16Ex((DWORD)te->func16, WCB16_PASCAL, sizeof(args), args, &ret); | |
| } | |
| /************************************************************************** | |
| * timeSetEvent [MMSYSTEM.602] | |
| */ | |
| MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc, | |
| DWORD dwUser, UINT16 wFlags) | |
| { | |
| MMRESULT16 id; | |
| struct timer_entry* te; | |
| switch (wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE)) | |
| { | |
| case TIME_CALLBACK_EVENT_SET: | |
| case TIME_CALLBACK_EVENT_PULSE: | |
| id = timeSetEvent(wDelay, wResol, (LPTIMECALLBACK)lpFunc, dwUser, wFlags); | |
| break; | |
| case TIME_CALLBACK_FUNCTION: | |
| te = HeapAlloc(GetProcessHeap(), 0, sizeof(*te)); | |
| if (!te) return 0; | |
| te->func16 = lpFunc; | |
| te->user = dwUser; | |
| id = te->id = timeSetEvent(wDelay, wResol, timeCB3216, (DWORD_PTR)te, wFlags); | |
| if (id) | |
| { | |
| EnterCriticalSection(&mmdrv_cs); | |
| list_add_tail(&timer_list, &te->entry); | |
| LeaveCriticalSection(&mmdrv_cs); | |
| } | |
| else HeapFree(GetProcessHeap(), 0, te); | |
| break; | |
| default: | |
| id = 0; | |
| break; | |
| } | |
| return id; | |
| } | |
| /************************************************************************** | |
| * timeKillEvent [MMSYSTEM.603] | |
| */ | |
| MMRESULT16 WINAPI timeKillEvent16(UINT16 wID) | |
| { | |
| MMRESULT16 ret = timeKillEvent(wID); | |
| struct timer_entry* te; | |
| if (ret == TIMERR_NOERROR) | |
| { | |
| EnterCriticalSection(&mmdrv_cs); | |
| LIST_FOR_EACH_ENTRY(te, &timer_list, struct timer_entry, entry) | |
| { | |
| if (wID == te->id) | |
| { | |
| list_remove(&te->entry); | |
| HeapFree(GetProcessHeap(), 0, te); | |
| break; | |
| } | |
| } | |
| LeaveCriticalSection(&mmdrv_cs); | |
| } | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * 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); | |
| } | |
| /************************************************************************** | |
| * timeGetTime [MMSYSTEM.607] | |
| */ | |
| DWORD WINAPI timeGetTime16(void) | |
| { | |
| return timeGetTime(); | |
| } | |
| /* ################################################### | |
| * # 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 mixerGetNumDevs(); | |
| } | |
| /************************************************************************** | |
| * 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; | |
| struct mmsystdrv_thunk* thunk; | |
| if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIXER))) | |
| { | |
| return MMSYSERR_NOMEM; | |
| } | |
| if ((fdwOpen & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) | |
| { | |
| dwCallback = (DWORD)thunk; | |
| } | |
| ret = mixerOpen(&hmix, uDeviceID, dwCallback, dwInstance, fdwOpen); | |
| if (ret == MMSYSERR_NOERROR) | |
| { | |
| if (lphmix) *lphmix = HMIXER_16(hmix); | |
| if (thunk) MMSYSTDRV_SetHandle(thunk, hmix); | |
| } | |
| else MMSYSTDRV_DeleteThunk(thunk); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * mixerClose [MMSYSTEM.803] | |
| */ | |
| UINT16 WINAPI mixerClose16(HMIXER16 hMix) | |
| { | |
| UINT ret = mixerClose(HMIXER_32(hMix)); | |
| if (ret == MMSYSERR_NOERROR) | |
| MMSYSTDRV_CloseHandle((void*)HMIXER_32(hMix)); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * 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); | |
| } | |
| /* ################################################### | |
| * # AUX # | |
| * ################################################### | |
| */ | |
| /************************************************************************** | |
| * auxGetNumDevs [MMSYSTEM.350] | |
| */ | |
| UINT16 WINAPI auxGetNumDevs16(void) | |
| { | |
| return auxGetNumDevs(); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| return auxGetVolume(uDeviceID, lpdwVolume); | |
| } | |
| /************************************************************************** | |
| * auxSetVolume [MMSYSTEM.353] | |
| */ | |
| UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume) | |
| { | |
| return auxSetVolume(uDeviceID, dwVolume); | |
| } | |
| /************************************************************************** | |
| * auxOutMessage [MMSYSTEM.354] | |
| */ | |
| DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2) | |
| { | |
| 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 auxGetVolume(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; | |
| } | |
| return auxOutMessage(uDeviceID, uMessage, dw1, dw2); | |
| } | |
| /* ################################################### | |
| * # MIDI # | |
| * ################################################### | |
| */ | |
| /************************************************************************** | |
| * midiOutGetNumDevs [MMSYSTEM.201] | |
| */ | |
| UINT16 WINAPI midiOutGetNumDevs16(void) | |
| { | |
| return midiOutGetNumDevs(); | |
| } | |
| /************************************************************************** | |
| * 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; | |
| struct mmsystdrv_thunk* thunk; | |
| if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIOUT))) | |
| { | |
| return MMSYSERR_NOMEM; | |
| } | |
| if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) | |
| { | |
| dwCallback = (DWORD)thunk; | |
| } | |
| ret = midiOutOpen(&hmo, uDeviceID, dwCallback, dwInstance, dwFlags); | |
| if (ret == MMSYSERR_NOERROR) | |
| { | |
| if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo); | |
| MMSYSTDRV_SetHandle(thunk, (void*)hmo); | |
| } | |
| else MMSYSTDRV_DeleteThunk(thunk); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiOutClose [MMSYSTEM.205] | |
| */ | |
| UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut) | |
| { | |
| UINT ret = midiOutClose(HMIDIOUT_32(hMidiOut)); | |
| if (ret == MMSYSERR_NOERROR) | |
| MMSYSTDRV_CloseHandle((void*)HMIDIOUT_32(hMidiOut)); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiOutPrepareHeader [MMSYSTEM.206] | |
| */ | |
| UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */ | |
| SEGPTR lpsegMidiOutHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); | |
| return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_PREPARE, lpsegMidiOutHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * midiOutUnprepareHeader [MMSYSTEM.207] | |
| */ | |
| UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */ | |
| SEGPTR lpsegMidiOutHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr); | |
| TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); | |
| if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) { | |
| return MMSYSERR_NOERROR; | |
| } | |
| return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_UNPREPARE, lpsegMidiOutHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * 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] */ | |
| { | |
| TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); | |
| return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| UINT devid; | |
| UINT16 ret; | |
| ret = midiOutGetID(HMIDIOUT_32(hMidiOut), &devid); | |
| if (ret != MMSYSERR_NOERROR) return ret; | |
| *lpuDeviceID = devid; | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiOutMessage [MMSYSTEM.216] | |
| */ | |
| DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage, | |
| DWORD dwParam1, DWORD dwParam2) | |
| { | |
| TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2); | |
| 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 MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), uMessage, dwParam1, dwParam2); | |
| } | |
| /************************************************************************** | |
| * midiInGetNumDevs [MMSYSTEM.301] | |
| */ | |
| UINT16 WINAPI midiInGetNumDevs16(void) | |
| { | |
| return midiInGetNumDevs(); | |
| } | |
| /************************************************************************** | |
| * 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 hmid; | |
| UINT ret; | |
| struct mmsystdrv_thunk* thunk; | |
| if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIIN))) | |
| { | |
| return MMSYSERR_NOMEM; | |
| } | |
| if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) | |
| { | |
| dwCallback = (DWORD)thunk; | |
| } | |
| ret = midiInOpen(&hmid, uDeviceID, dwCallback, dwInstance, dwFlags); | |
| if (ret == MMSYSERR_NOERROR) | |
| { | |
| if (lphMidiIn) *lphMidiIn = HMIDIIN_16(hmid); | |
| MMSYSTDRV_SetHandle(thunk, (void*)hmid); | |
| } | |
| else MMSYSTDRV_DeleteThunk(thunk); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiInClose [MMSYSTEM.305] | |
| */ | |
| UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn) | |
| { | |
| UINT ret = midiInClose(HMIDIIN_32(hMidiIn)); | |
| if (ret == MMSYSERR_NOERROR) | |
| MMSYSTDRV_CloseHandle((void*)HMIDIIN_32(hMidiIn)); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiInPrepareHeader [MMSYSTEM.306] | |
| */ | |
| UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */ | |
| SEGPTR lpsegMidiInHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); | |
| return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_PREPARE, lpsegMidiInHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * midiInUnprepareHeader [MMSYSTEM.307] | |
| */ | |
| UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */ | |
| SEGPTR lpsegMidiInHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr); | |
| TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); | |
| if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) { | |
| return MMSYSERR_NOERROR; | |
| } | |
| return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_UNPREPARE, lpsegMidiInHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * midiInAddBuffer [MMSYSTEM.308] | |
| */ | |
| UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, /* [in] */ | |
| MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); | |
| return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| UINT devid; | |
| UINT16 ret; | |
| ret = midiInGetID(HMIDIIN_32(hMidiIn), &devid); | |
| if (ret != MMSYSERR_NOERROR) return ret; | |
| *lpuDeviceID = devid; | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiInMessage [MMSYSTEM.313] | |
| */ | |
| DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage, | |
| DWORD dwParam1, DWORD dwParam2) | |
| { | |
| 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); | |
| } | |
| return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), uMessage, dwParam1, dwParam2); | |
| } | |
| /************************************************************************** | |
| * midiStreamClose [MMSYSTEM.252] | |
| */ | |
| MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm) | |
| { | |
| UINT ret = midiStreamClose(HMIDISTRM_32(hMidiStrm)); | |
| if (ret == MMSYSERR_NOERROR) | |
| MMSYSTDRV_CloseHandle((void*)HMIDISTRM_32(hMidiStrm)); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * midiStreamOpen [MMSYSTEM.251] | |
| */ | |
| MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid, | |
| DWORD cMidi, DWORD dwCallback, | |
| DWORD dwInstance, DWORD fdwOpen) | |
| { | |
| HMIDISTRM hMidiStrm32; | |
| MMRESULT ret; | |
| UINT devid32; | |
| struct mmsystdrv_thunk* thunk; | |
| if (!phMidiStrm || !devid) | |
| return MMSYSERR_INVALPARAM; | |
| devid32 = *devid; | |
| if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIOUT))) | |
| { | |
| return MMSYSERR_NOMEM; | |
| } | |
| if ((fdwOpen & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) | |
| { | |
| dwCallback = (DWORD)thunk; | |
| } | |
| ret = midiStreamOpen(&hMidiStrm32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen); | |
| if (ret == MMSYSERR_NOERROR) | |
| { | |
| *phMidiStrm = HMIDISTRM_16(hMidiStrm32); | |
| *devid = devid32; | |
| MMSYSTDRV_SetHandle(thunk, hMidiStrm32); | |
| } | |
| else MMSYSTDRV_DeleteThunk(thunk); | |
| 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 waveOutGetNumDevs(); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| HWAVEOUT hWaveOut; | |
| UINT ret; | |
| struct mmsystdrv_thunk* thunk; | |
| if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_WAVEOUT))) | |
| { | |
| return MMSYSERR_NOMEM; | |
| } | |
| if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) | |
| { | |
| dwCallback = (DWORD)thunk; | |
| } | |
| /* 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 = waveOutOpen(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID, | |
| lpFormat, dwCallback, dwInstance, dwFlags); | |
| if (ret == MMSYSERR_NOERROR) | |
| { | |
| if (lphWaveOut != NULL) *lphWaveOut = HWAVEOUT_16(hWaveOut); | |
| MMSYSTDRV_SetHandle(thunk, (void*)hWaveOut); | |
| } | |
| else MMSYSTDRV_DeleteThunk(thunk); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveOutClose [MMSYSTEM.405] | |
| */ | |
| UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut) | |
| { | |
| DWORD level; | |
| UINT16 ret; | |
| ReleaseThunkLock(&level); | |
| ret = waveOutClose(HWAVEOUT_32(hWaveOut)); | |
| RestoreThunkLock(level); | |
| if (ret == MMSYSERR_NOERROR) | |
| MMSYSTDRV_CloseHandle((void*)HWAVEOUT_32(hWaveOut)); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveOutPrepareHeader [MMSYSTEM.406] | |
| */ | |
| UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */ | |
| SEGPTR lpsegWaveOutHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr); | |
| UINT16 result; | |
| TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); | |
| if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM; | |
| if ((result = MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_PREPARE, lpsegWaveOutHdr, | |
| uSize)) != MMSYSERR_NOTSUPPORTED) | |
| return result; | |
| if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE) | |
| return WAVERR_STILLPLAYING; | |
| lpWaveOutHdr->dwFlags |= WHDR_PREPARED; | |
| lpWaveOutHdr->dwFlags &= ~WHDR_DONE; | |
| return MMSYSERR_NOERROR; | |
| } | |
| /************************************************************************** | |
| * waveOutUnprepareHeader [MMSYSTEM.407] | |
| */ | |
| UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */ | |
| SEGPTR lpsegWaveOutHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr); | |
| TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); | |
| if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) { | |
| return MMSYSERR_NOERROR; | |
| } | |
| return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_UNPREPARE, lpsegWaveOutHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * waveOutWrite [MMSYSTEM.408] | |
| */ | |
| UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, /* [in] */ | |
| LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); | |
| return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| UINT devid; | |
| UINT16 ret; | |
| ret = waveOutGetID(HWAVEOUT_32(hWaveOut), &devid); | |
| if (ret != MMSYSERR_NOERROR) return ret; | |
| *lpuDeviceID = devid; | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveOutMessage [MMSYSTEM.421] | |
| */ | |
| DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage, | |
| DWORD dwParam1, DWORD dwParam2) | |
| { | |
| TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2); | |
| if ((DWORD_PTR)hWaveOut < waveOutGetNumDevs()) | |
| { | |
| if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE) | |
| dwParam1 = (DWORD)MapSL(dwParam1); | |
| } | |
| else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER)) | |
| /* from M$ KB */ | |
| return MMSYSERR_INVALPARAM; | |
| return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), uMessage, dwParam1, dwParam2); | |
| } | |
| /************************************************************************** | |
| * waveInGetNumDevs [MMSYSTEM.501] | |
| */ | |
| UINT16 WINAPI waveInGetNumDevs16(void) | |
| { | |
| return waveInGetNumDevs(); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| HWAVEIN hWaveIn; | |
| UINT ret; | |
| struct mmsystdrv_thunk* thunk; | |
| if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_WAVEIN))) | |
| { | |
| return MMSYSERR_NOMEM; | |
| } | |
| if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) | |
| { | |
| dwCallback = (DWORD)thunk; | |
| } | |
| /* 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 = waveInOpen(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID, | |
| lpFormat, dwCallback, dwInstance, dwFlags); | |
| if (ret == MMSYSERR_NOERROR) | |
| { | |
| if (lphWaveIn != NULL) *lphWaveIn = HWAVEIN_16(hWaveIn); | |
| MMSYSTDRV_SetHandle(thunk, (void*)hWaveIn); | |
| } | |
| else MMSYSTDRV_DeleteThunk(thunk); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveInClose [MMSYSTEM.505] | |
| */ | |
| UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn) | |
| { | |
| DWORD level; | |
| UINT16 ret; | |
| ReleaseThunkLock(&level); | |
| ret = waveInClose(HWAVEIN_32(hWaveIn)); | |
| RestoreThunkLock(level); | |
| if (ret == MMSYSERR_NOERROR) | |
| MMSYSTDRV_CloseHandle((void*)HWAVEIN_32(hWaveIn)); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveInPrepareHeader [MMSYSTEM.506] | |
| */ | |
| UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, /* [in] */ | |
| SEGPTR lpsegWaveInHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr); | |
| UINT16 ret; | |
| TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); | |
| if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; | |
| lpWaveInHdr->dwBytesRecorded = 0; | |
| ret = MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_PREPARE, lpsegWaveInHdr, uSize); | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveInUnprepareHeader [MMSYSTEM.507] | |
| */ | |
| UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */ | |
| SEGPTR lpsegWaveInHdr, /* [???] */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| 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; | |
| } | |
| return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_UNPREPARE, lpsegWaveInHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * waveInAddBuffer [MMSYSTEM.508] | |
| */ | |
| UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, /* [in] */ | |
| WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */ | |
| UINT16 uSize) /* [in] */ | |
| { | |
| TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize); | |
| if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM; | |
| return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize); | |
| } | |
| /************************************************************************** | |
| * 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) | |
| { | |
| UINT devid; | |
| UINT16 ret; | |
| ret = waveInGetID(HWAVEIN_32(hWaveIn), &devid); | |
| if (ret != MMSYSERR_NOERROR) return ret; | |
| *lpuDeviceID = devid; | |
| return ret; | |
| } | |
| /************************************************************************** | |
| * waveInMessage [MMSYSTEM.514] | |
| */ | |
| DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage, | |
| DWORD dwParam1, DWORD dwParam2) | |
| { | |
| TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2); | |
| if ((DWORD_PTR)hWaveIn < waveInGetNumDevs()) | |
| { | |
| if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE) | |
| dwParam1 = (DWORD)MapSL(dwParam1); | |
| } | |
| else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER)) | |
| /* from M$ KB */ | |
| return MMSYSERR_INVALPARAM; | |
| return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), uMessage, dwParam1, dwParam2); | |
| } | |
| /* ################################################### | |
| * # 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(); | |
| } | |
| } | |
| /****************************************************************** | |
| * WINMM_GetmmThread | |
| * | |
| * | |
| */ | |
| static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16 h) | |
| { | |
| return MapSL(MAKESEGPTR(h, 0)); | |
| } | |
| 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"); | |
| } | |
| /************************************************************************** | |
| * __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; | |
| } | |
| extern DWORD WINAPI GetProcessFlags(DWORD); | |
| /************************************************************************** | |
| * 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 */ | |
| MSG msg; | |
| PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE ); | |
| } | |
| } | |
| } | |
| 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--; | |
| } | |
| } | |
| /************************************************************************** | |
| * 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; | |
| } | |
| 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"); | |
| } | |
| /* ################################################### | |
| * # 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; | |
| } |