Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-08-07 19:58:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Sync Winmm with Wine-20040215 and silence some non-error messages.

Browse source 
svn path=/trunk/; revision=8376
This commit is contained in:
Steven Edwards 2004-02-25 20:00:42 +00:00
parent 9744443ac8
commit 99866ef3a0
22 changed files with 7050 additions and 578 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/lib/winmm/.cvsignore
View file

@ -4,3 +4,4 @@
*.d
*.sym
*.map
*.spec.def

47
reactos/lib/winmm/Makefile
View file

@ -1,51 +1,8 @@
# $Id: makefile
# $Id: Makefile,v 1.12 2004/02/25 20:00:41 sedwards Exp $
PATH_TO_TOP = ../..
TARGET_TYPE = dynlink
TARGET_NAME = winmm
TARGET_BASE = 0x777c0000
WINE_RC = winmm_res
TARGET_CFLAGS = \
-Wall \
-fno-builtin
# Compile definitions usage:
# __USE_W32API - Compilation with w32api headers
# __REACTOS__ - Compilation of Wine sources for ReactOS
# _WIN32_IE=0x600 - Internet Explorer 6 compatible defintions
# WINVER=0x501 - Windows XP definitions
# __need_offsetof - Force definition of macro offsetof in stddef.h
#
DEFINES = \
-D_DISABLE_TIDENTS \
-D__USE_W32API \
-D__REACTOS__ \
-D_WIN32_IE=0x600 \
-D_WIN32_WINNT=0x501 \
-DWINVER=0x501
TARGET_CFLAGS += \
$(DEFINES) \
-I$(PATH_TO_TOP)/include/wine
TARGET_RCFLAGS += -D__REACTOS__ -D_WIN32_IE=0x600 -D_WIN32_WINNT=0x501
TARGET_SDKLIBS = libwine.a ntdll.a kernel32.a
TARGET_OBJECTS = \
driver.o \
joystick.o \
lolvldrv.o \
mci.o \
mmio.o \
playsound.o \
time.o \
winmm.o
TARGET_TYPE = winedll
include $(PATH_TO_TOP)/rules.mak

33
reactos/lib/winmm/Makefile.in Normal file
View file

@ -0,0 +1,33 @@
EXTRADEFS = -D_WINMM_
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = winmm.dll
IMPORTS = user32 advapi32 kernel32 ntdll
ALTNAMES = mmsystem.dll sound.dll
SPEC_SRCS16 = $(ALTNAMES:.dll=.spec)
C_SRCS = \
driver.c \
joystick.c \
lolvldrv.c \
mci.c \
mmio.c \
playsound.c \
time.c \
winmm.c
C_SRCS16 = \
message16.c \
mmsystem.c \
sound16.c
RC_SRCS = winmm_res.rc
SUBDIRS = tests
@MAKE_DLL_RULES@
### Dependencies:

21
reactos/lib/winmm/Makefile.ros Normal file
View file

@ -0,0 +1,21 @@
# $Id: Makefile.ros,v 1.1 2004/02/25 20:00:41 sedwards Exp $
TARGET_NAME = winmm
TARGET_OBJECTS = driver.o joystick.o lolvldrv.o mci.o mmio.o playsound.o time.o winmm.o
TARGET_CFLAGS = -D_WINMM_ -D__REACTOS__
TARGET_SDKLIBS = user32.a advapi32.a kernel32.a ntdll.a libwine.a wine_uuid.a ntdll.a
TARGET_BASE = 0x76160000
TARGET_RC_SRCS = winmm_res.rc
TARGET_RC_BINSRC =
TARGET_RC_BINARIES =
default: all
DEP_OBJECTS = $(TARGET_OBJECTS)
include $(TOOLS_PATH)/depend.mk

21
reactos/lib/winmm/Makefile.ros-template Normal file
View file

@ -0,0 +1,21 @@
# $Id: Makefile.ros-template,v 1.1 2004/02/25 20:00:41 sedwards Exp $
TARGET_NAME = winmm
TARGET_OBJECTS = @C_SRCS@
TARGET_CFLAGS = @EXTRADEFS@ -D__REACTOS__
TARGET_SDKLIBS = @IMPORTS@ libwine.a wine_uuid.a ntdll.a
TARGET_BASE = 0x76160000
TARGET_RC_SRCS = @RC_SRCS@
TARGET_RC_BINSRC = @RC_BINSRC@
TARGET_RC_BINARIES = @RC_BINARIES@
default: all
DEP_OBJECTS = $(TARGET_OBJECTS)
include $(TOOLS_PATH)/depend.mk

2
reactos/lib/winmm/driver.c
View file

@ -389,7 +389,7 @@ LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
lpDrv0->d.d32.dwDriverID = 0;
DRIVER_RemoveFromList(lpDrv0);
FreeLibrary(lpDrv->d.d32.hModule);
FreeLibrary(lpDrv0->d.d32.hModule);
HeapFree(GetProcessHeap(), 0, lpDrv0);
}
FreeLibrary(lpDrv->d.d32.hModule);

4
reactos/lib/winmm/joystick.c
View file

@ -139,7 +139,7 @@ UINT WINAPI joyGetNumDevs(void)
/**************************************************************************
* joyGetDevCapsA [WINMM.@]
*/
MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
MMRESULT WINAPI joyGetDevCapsA(UINT_PTR wID, LPJOYCAPSA lpCaps, UINT wSize)
{
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
@ -153,7 +153,7 @@ MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
/**************************************************************************
* joyGetDevCapsW [WINMM.@]
*/
MMRESULT WINAPI joyGetDevCapsW(UINT wID, LPJOYCAPSW lpCaps, UINT wSize)
MMRESULT WINAPI joyGetDevCapsW(UINT_PTR wID, LPJOYCAPSW lpCaps, UINT wSize)
{
JOYCAPSA jca;
MMRESULT ret = joyGetDevCapsA(wID, &jca, sizeof(jca));

10
reactos/lib/winmm/lolvldrv.c
View file

@ -171,8 +171,8 @@ UINT MMDRV_GetNum(UINT type)
/**************************************************************************
* MMDRV_Message [internal]
*/
DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1,
DWORD dwParam2, BOOL bFrom32)
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
DWORD_PTR dwParam2, BOOL bFrom32)
{
LPWINE_MM_DRIVER lpDrv;
DWORD ret;
@ -502,7 +502,8 @@ UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1,
case DRV_QUERYDSOUNDDESC: /* Wine-specific: Retrieve DirectSound driver description*/
case DRV_QUERYDSOUNDGUID: /* Wine-specific: Retrieve DirectSound driver GUID */
return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE);
#endif /* __REACTOS__ */
#endif
default:
WARN("Unknown call %04x\n", uMsg);
return MMSYSERR_INVALPARAM;
@ -742,8 +743,9 @@ static BOOL MMDRV_InitFromRegistry(void)
static BOOL MMDRV_InitHardcoded(void)
{
/* first load hardware drivers */
#ifndef __REACTOS__
MMDRV_Install("wineoss.drv", "wineoss.drv", FALSE);
#endif /* __REACTOS__ */
/* finish with mappers */
MMDRV_Install("wavemapper", "msacm.drv", TRUE);
MMDRV_Install("midimapper", "midimap.drv", TRUE);

12
reactos/lib/winmm/mci.c
View file

@ -1027,13 +1027,11 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
*/
if (lpstrRet && uRetLen) *lpstrRet = '\0';
#define STR_OF(_x) (IsBadReadPtr((char*)_x,1)?"?":(char*)(_x))
TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n",
wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags,
data[0], STR_OF(data[0]), data[1], STR_OF(data[1]),
data[2], STR_OF(data[2]), data[3], STR_OF(data[3]),
data[4], STR_OF(data[4]), data[5], STR_OF(data[5]));
#undef STR_OF
data[0], debugstr_a((char *)data[0]), data[1], debugstr_a((char *)data[1]),
data[2], debugstr_a((char *)data[2]), data[3], debugstr_a((char *)data[3]),
data[4], debugstr_a((char *)data[4]), data[5], debugstr_a((char *)data[5]));
if (strcmp(verb, "open") == 0) {
if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSA)data, dwFlags)))
@ -1157,7 +1155,7 @@ BOOL WINAPI mciFreeCommandResource(UINT uTable)
/**************************************************************************
* MCI_SendCommandFrom32 [internal]
*/
DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
DWORD dwRet = MCIERR_INVALID_DEVICE_ID;
LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
@ -1192,7 +1190,7 @@ DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwPa
/**************************************************************************
* MCI_SendCommandFrom16 [internal]
*/
DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
DWORD dwRet = MCIERR_INVALID_DEVICE_ID;
LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);

2778
reactos/lib/winmm/message16.c Normal file
View file

File diff suppressed because it is too large Load diff

3175
reactos/lib/winmm/mmsystem.c Normal file
View file

File diff suppressed because it is too large Load diff

176
reactos/lib/winmm/mmsystem.spec Normal file
View file

@ -0,0 +1,176 @@
#1 pascal MMSYSTEM_WEP(word word word ptr) MMSYSTEM_WEP
2 pascal sndPlaySound(ptr word) sndPlaySound16
3 pascal PlaySound(ptr word long) PlaySound16
5 pascal mmsystemGetVersion() mmsystemGetVersion16
6 pascal DriverProc(long word word long long) DriverProc16
8 pascal WMMMidiRunOnce() WMMMidiRunOnce16
30 pascal -ret16 OutputDebugStr(str) OutputDebugStr16
31 pascal DriverCallback(long word word word long long long) DriverCallback16
32 pascal StackEnter() StackEnter16
33 pascal StackLeave() StackLeave16
34 stub MMDRVINSTALL
101 pascal joyGetNumDevs() joyGetNumDevs16
102 pascal joyGetDevCaps(word ptr word) joyGetDevCaps16
103 pascal joyGetPos(word ptr) joyGetPos16
104 pascal joyGetThreshold(word ptr) joyGetThreshold16
105 pascal joyReleaseCapture(word) joyReleaseCapture16
106 pascal joySetCapture(word word word word) joySetCapture16
107 pascal joySetThreshold(word word) joySetThreshold16
109 pascal joySetCalibration(word) joySetCalibration16
110 pascal joyGetPosEx(word ptr) joyGetPosEx16
111 stub JOYCONFIGCHANGED
201 pascal midiOutGetNumDevs() midiOutGetNumDevs16
202 pascal midiOutGetDevCaps(word ptr word) midiOutGetDevCaps16
203 pascal midiOutGetErrorText(word ptr word) midiOutGetErrorText16
204 pascal midiOutOpen(ptr word long long long) midiOutOpen16
205 pascal midiOutClose(word) midiOutClose16
206 pascal midiOutPrepareHeader(word segptr word) midiOutPrepareHeader16
207 pascal midiOutUnprepareHeader(word segptr word) midiOutUnprepareHeader16
208 pascal midiOutShortMsg(word long) midiOutShortMsg16
209 pascal midiOutLongMsg(word segptr word) midiOutLongMsg16
210 pascal midiOutReset(word) midiOutReset16
211 pascal midiOutGetVolume(word ptr) midiOutGetVolume16
212 pascal midiOutSetVolume(word long) midiOutSetVolume16
213 pascal midiOutCachePatches(word word ptr word) midiOutCachePatches16
214 pascal midiOutCacheDrumPatches(word word ptr word) midiOutCacheDrumPatches16
215 pascal midiOutGetID(word ptr) midiOutGetID16
216 pascal midiOutMessage(word word long long) midiOutMessage16
250 pascal midiStreamProperty(word ptr long) midiStreamProperty16
251 pascal midiStreamOpen(ptr ptr long long long long) midiStreamOpen16
252 pascal midiStreamClose(word) midiStreamClose16
253 pascal midiStreamPosition(word ptr word) midiStreamPosition16
254 pascal midiStreamOut(word ptr word) midiStreamOut16
255 pascal midiStreamPause(word) midiStreamPause16
256 pascal midiStreamRestart(word) midiStreamRestart16
257 pascal midiStreamStop(word) midiStreamStop16
301 pascal midiInGetNumDevs() midiInGetNumDevs16
302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16
303 pascal midiInGetErrorText(word ptr word) midiInGetErrorText16
304 pascal midiInOpen(ptr word long long long) midiInOpen16
305 pascal midiInClose(word) midiInClose16
306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16
307 pascal midiInUnprepareHeader(word segptr word) midiInUnprepareHeader16
308 pascal midiInAddBuffer(word segptr word) midiInAddBuffer16
309 pascal midiInStart(word) midiInStart16
310 pascal midiInStop(word) midiInStop16
311 pascal midiInReset(word) midiInReset16
312 pascal midiInGetID(word ptr) midiInGetID16
313 pascal midiInMessage(word word long long) midiInMessage16
350 pascal auxGetNumDevs() auxGetNumDevs16
351 pascal auxGetDevCaps(word ptr word) auxGetDevCaps16
352 pascal auxGetVolume(word ptr) auxGetVolume16
353 pascal auxSetVolume(word long) auxSetVolume16
354 pascal auxOutMessage(word word long long) auxOutMessage16
401 pascal waveOutGetNumDevs() waveOutGetNumDevs16
402 pascal waveOutGetDevCaps(word ptr word) waveOutGetDevCaps16
403 pascal waveOutGetErrorText(word ptr word) waveOutGetErrorText16
404 pascal waveOutOpen(ptr word ptr long long long) waveOutOpen16
405 pascal waveOutClose(word) waveOutClose16
406 pascal waveOutPrepareHeader(word segptr word) waveOutPrepareHeader16
407 pascal waveOutUnprepareHeader(word segptr word) waveOutUnprepareHeader16
408 pascal waveOutWrite(word segptr word) waveOutWrite16
409 pascal waveOutPause(word) waveOutPause16
410 pascal waveOutRestart(word) waveOutRestart16
411 pascal waveOutReset(word) waveOutReset16
412 pascal waveOutGetPosition(word ptr word) waveOutGetPosition16
413 pascal waveOutGetPitch(word ptr) waveOutGetPitch16
414 pascal waveOutSetPitch(word long) waveOutSetPitch16
415 pascal waveOutGetVolume(word ptr) waveOutGetVolume16
416 pascal waveOutSetVolume(word long) waveOutSetVolume16
417 pascal waveOutGetPlaybackRate(word ptr) waveOutGetPlaybackRate16
418 pascal waveOutSetPlaybackRate(word long) waveOutSetPlaybackRate16
419 pascal waveOutBreakLoop(word) waveOutBreakLoop16
420 pascal waveOutGetID(word ptr) waveOutGetID16
421 pascal waveOutMessage(word word long long) waveOutMessage16
501 pascal waveInGetNumDevs() waveInGetNumDevs16
502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16
503 pascal waveInGetErrorText(word ptr word) waveInGetErrorText16
504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16
505 pascal waveInClose(word) waveInClose16
506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16
507 pascal waveInUnprepareHeader(word segptr word) waveInUnprepareHeader16
508 pascal waveInAddBuffer(word segptr word) waveInAddBuffer16
509 pascal waveInStart(word) waveInStart16
510 pascal waveInStop(word) waveInStop16
511 pascal waveInReset(word) waveInReset16
512 pascal waveInGetPosition(word ptr word) waveInGetPosition16
513 pascal waveInGetID(word ptr) waveInGetID16
514 pascal waveInMessage(word word long long) waveInMessage16
601 pascal timeGetSystemTime(ptr word) timeGetSystemTime16
602 pascal timeSetEvent(word word segptr long word) timeSetEvent16
603 pascal timeKillEvent(word) timeKillEvent16
604 pascal timeGetDevCaps(ptr word) timeGetDevCaps16
605 pascal timeBeginPeriod(word) timeBeginPeriod16
606 pascal timeEndPeriod(word) timeEndPeriod16
607 pascal timeGetTime() timeGetTime
701 pascal mciSendCommand(word word long long) mciSendCommand16
702 pascal mciSendString(str ptr word word) mciSendString16
703 pascal mciGetDeviceID(ptr) mciGetDeviceID16
705 pascal mciLoadCommandResource(word str word) mciLoadCommandResource16
706 pascal mciGetErrorString(long ptr word) mciGetErrorString16
707 pascal mciSetDriverData(word long) mciSetDriverData16
708 pascal mciGetDriverData(word) mciGetDriverData16
710 pascal mciDriverYield(word) mciDriverYield16
711 pascal mciDriverNotify(word word word) mciDriverNotify16
712 pascal mciExecute(ptr) mciExecute
713 pascal mciFreeCommandResource(word) mciFreeCommandResource16
714 pascal mciSetYieldProc(word ptr long) mciSetYieldProc16
715 pascal mciGetDeviceIDFromElementID(long ptr) mciGetDeviceIDFromElementID16
716 pascal mciGetYieldProc(word ptr) mciGetYieldProc16
717 pascal mciGetCreatorTask(word) mciGetCreatorTask16
800 pascal mixerGetNumDevs() mixerGetNumDevs16
801 pascal mixerGetDevCaps(word ptr word) mixerGetDevCaps16
802 pascal mixerOpen(ptr word long long long) mixerOpen16
803 pascal mixerClose(word) mixerClose16
804 pascal mixerMessage(word word long long) mixerMessage16
805 pascal mixerGetLineInfo(word ptr long) mixerGetLineInfo16
806 pascal mixerGetID(word ptr long) mixerGetID16
807 pascal mixerGetLineControls(word ptr long) mixerGetLineControls16
808 pascal mixerGetControlDetails(word ptr long) mixerGetControlDetails16
809 pascal mixerSetControlDetails(word ptr long) mixerSetControlDetails16
900 pascal mmTaskCreate(long ptr long) mmTaskCreate16
902 pascal mmTaskBlock(word) mmTaskBlock16
903 pascal mmTaskSignal(word) mmTaskSignal16
904 pascal -ret16 mmGetCurrentTask() mmGetCurrentTask16
905 pascal mmTaskYield() mmTaskYield16
1100 pascal DrvOpen(str str long) DrvOpen16
1101 pascal DrvClose(word long long) DrvClose16
1102 pascal DrvSendMessage(word word long long) DrvSendMessage16
1103 pascal DrvGetModuleHandle(word) DrvGetModuleHandle16
1104 pascal DrvDefDriverProc(long word word long long) DrvDefDriverProc16
1120 pascal mmThreadCreate(segptr ptr long long) mmThreadCreate16
1121 pascal mmThreadSignal(word) mmThreadSignal16
1122 pascal mmThreadBlock(word) mmThreadBlock16
1123 pascal mmThreadIsCurrent(word) mmThreadIsCurrent16
1124 pascal mmThreadIsValid(word) mmThreadIsValid16
1125 pascal mmThreadGetTask(word) mmThreadGetTask16
1150 pascal mmShowMMCPLPropertySheet(word str str str) mmShowMMCPLPropertySheet16
1210 pascal mmioOpen(str ptr long) mmioOpen16
1211 pascal mmioClose(word word) mmioClose16
1212 pascal mmioRead(word ptr long) mmioRead16
1213 pascal mmioWrite(word ptr long) mmioWrite16
1214 pascal mmioSeek(word long word) mmioSeek16
1215 pascal mmioGetInfo(word ptr word) mmioGetInfo16
1216 pascal mmioSetInfo(word ptr word) mmioSetInfo16
1217 pascal mmioSetBuffer(word segptr long word) mmioSetBuffer16
1218 pascal mmioFlush(word word) mmioFlush16
1219 pascal mmioAdvance(word ptr word) mmioAdvance16
1220 pascal mmioStringToFOURCC(str word) mmioStringToFOURCC16
1221 pascal mmioInstallIOProc(long ptr long) mmioInstallIOProc16
1222 pascal mmioSendMessage(word word long long) mmioSendMessage16
1223 pascal mmioDescend(word ptr ptr word) mmioDescend16
1224 pascal mmioAscend(word ptr word) mmioAscend16
1225 pascal mmioCreateChunk(word ptr word) mmioCreateChunk16
1226 pascal mmioRename(ptr ptr ptr long) mmioRename16
#2000 stub WINMMF_THUNKDATA16
#2001 stub RING3_DEVLOADER
#2002 stub WINMMTILEBUFFER
#2003 stub WINMMUNTILEBUFFER
#2005 stub MCIGETTHUNKTABLE
#2006 stub WINMMSL_THUNKDATA16
2046 pascal DllEntryPoint(long word word word long word) MMSYSTEM_LibMain
# these are Wine only exported functions. Is there another way to do it ?
2047 pascal __wine_mmThreadEntryPoint(long) WINE_mmThreadEntryPoint

6
reactos/lib/winmm/playsound.c
View file

@ -190,6 +190,7 @@ static void PlaySound_Free(WINE_PLAYSOUND* wps)
if (WINMM_IData->lpPlaySound == NULL) SetEvent(WINMM_IData->psLastEvent);
LeaveCriticalSection(&WINMM_IData->cs);
if (wps->bAlloc) HeapFree(GetProcessHeap(), 0, (void*)wps->pszSound);
if (wps->hThread) CloseHandle(wps->hThread);
HeapFree(GetProcessHeap(), 0, wps);
}
@ -456,9 +457,12 @@ BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSound, BO
if (fdwSound & SND_ASYNC)
{
DWORD id;
HANDLE handle;
wps->bLoop = (fdwSound & SND_LOOP) ? TRUE : FALSE;
if (CreateThread(NULL, 0, proc_PlaySound, wps, 0, &id) != 0)
if ((handle = CreateThread(NULL, 0, proc_PlaySound, wps, 0, &id)) != 0) {
wps->hThread = handle;
return TRUE;
}
}
else return proc_PlaySound(wps);

18
reactos/lib/winmm/sound.spec Normal file
View file

@ -0,0 +1,18 @@
1 pascal -ret16 OpenSound() OpenSound16
2 pascal -ret16 CloseSound() CloseSound16
3 pascal -ret16 SetVoiceQueueSize(word word) SetVoiceQueueSize16
4 pascal -ret16 SetVoiceNote(word word word word) SetVoiceNote16
5 pascal -ret16 SetVoiceAccent(word word word word word) SetVoiceAccent16
6 pascal -ret16 SetVoiceEnvelope(word word word) SetVoiceEnvelope16
7 pascal -ret16 SetSoundNoise(word word) SetSoundNoise16
8 pascal -ret16 SetVoiceSound(word long word) SetVoiceSound16
9 pascal -ret16 StartSound() StartSound16
10 pascal -ret16 StopSound() StopSound16
11 pascal -ret16 WaitSoundState(word) WaitSoundState16
12 pascal -ret16 SyncAllVoices() SyncAllVoices16
13 pascal -ret16 CountVoiceNotes(word) CountVoiceNotes16
14 pascal GetThresholdEvent() GetThresholdEvent16
15 pascal -ret16 GetThresholdStatus() GetThresholdStatus16
16 pascal -ret16 SetVoiceThreshold(word word) SetVoiceThreshold16
17 pascal -ret16 DoBeep() DoBeep16
18 stub MYOPENSOUND # W1.1, W2.0

184
reactos/lib/winmm/sound16.c Normal file
View file

@ -0,0 +1,184 @@
/*
* 16-bit sound support
*
* Copyright Robert J. Amstadt, 1993
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wine/windef16.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(sound);
/***********************************************************************
* OpenSound (SOUND.1)
*/
INT16 WINAPI OpenSound16(void)
{
FIXME("(void): stub\n");
return -1;
}
/***********************************************************************
* CloseSound (SOUND.2)
*/
void WINAPI CloseSound16(void)
{
FIXME("(void): stub\n");
}
/***********************************************************************
* SetVoiceQueueSize (SOUND.3)
*/
INT16 WINAPI SetVoiceQueueSize16(INT16 nVoice, INT16 nBytes)
{
FIXME("(%d,%d): stub\n",nVoice,nBytes);
return 0;
}
/***********************************************************************
* SetVoiceNote (SOUND.4)
*/
INT16 WINAPI SetVoiceNote16(INT16 nVoice, INT16 nValue, INT16 nLength,
INT16 nCdots)
{
FIXME("(%d,%d,%d,%d): stub\n",nVoice,nValue,nLength,nCdots);
return 0;
}
/***********************************************************************
* SetVoiceAccent (SOUND.5)
*/
INT16 WINAPI SetVoiceAccent16(INT16 nVoice, INT16 nTempo, INT16 nVolume,
INT16 nMode, INT16 nPitch)
{
FIXME("(%d,%d,%d,%d,%d): stub\n", nVoice, nTempo,
nVolume, nMode, nPitch);
return 0;
}
/***********************************************************************
* SetVoiceEnvelope (SOUND.6)
*/
INT16 WINAPI SetVoiceEnvelope16(INT16 nVoice, INT16 nShape, INT16 nRepeat)
{
FIXME("(%d,%d,%d): stub\n",nVoice,nShape,nRepeat);
return 0;
}
/***********************************************************************
* SetSoundNoise (SOUND.7)
*/
INT16 WINAPI SetSoundNoise16(INT16 nSource, INT16 nDuration)
{
FIXME("(%d,%d): stub\n",nSource,nDuration);
return 0;
}
/***********************************************************************
* SetVoiceSound (SOUND.8)
*/
INT16 WINAPI SetVoiceSound16(INT16 nVoice, DWORD lFrequency, INT16 nDuration)
{
FIXME("(%d, %ld, %d): stub\n",nVoice,lFrequency, nDuration);
return 0;
}
/***********************************************************************
* StartSound (SOUND.9)
*/
INT16 WINAPI StartSound16(void)
{
return 0;
}
/***********************************************************************
* StopSound (SOUND.10)
*/
INT16 WINAPI StopSound16(void)
{
return 0;
}
/***********************************************************************
* WaitSoundState (SOUND.11)
*/
INT16 WINAPI WaitSoundState16(INT16 x)
{
FIXME("(%d): stub\n", x);
return 0;
}
/***********************************************************************
* SyncAllVoices (SOUND.12)
*/
INT16 WINAPI SyncAllVoices16(void)
{
FIXME("(void): stub\n");
return 0;
}
/***********************************************************************
* CountVoiceNotes (SOUND.13)
*/
INT16 WINAPI CountVoiceNotes16(INT16 x)
{
FIXME("(%d): stub\n", x);
return 0;
}
/***********************************************************************
* GetThresholdEvent (SOUND.14)
*/
LPINT16 WINAPI GetThresholdEvent16(void)
{
FIXME("(void): stub\n");
return NULL;
}
/***********************************************************************
* GetThresholdStatus (SOUND.15)
*/
INT16 WINAPI GetThresholdStatus16(void)
{
FIXME("(void): stub\n");
return 0;
}
/***********************************************************************
* SetVoiceThreshold (SOUND.16)
*/
INT16 WINAPI SetVoiceThreshold16(INT16 a, INT16 b)
{
FIXME("(%d,%d): stub\n", a, b);
return 0;
}
/***********************************************************************
* DoBeep (SOUND.17)
*/
void WINAPI DoBeep16(void)
{
FIXME("(void): stub!\n");
}

128
reactos/lib/winmm/time.c
View file

@ -42,6 +42,11 @@
WINE_DEFAULT_DEBUG_CHANNEL(mmtime);
static HANDLE TIME_hMMTimer;
static LPWINE_TIMERENTRY TIME_TimersList;
static HANDLE TIME_hKillEvent;
DWORD WINMM_SysTimeMS;
/*
* FIXME
* We're using "1" as the mininum resolution to the timer,
@ -90,15 +95,18 @@ static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer)
*/
static void CALLBACK TIME_MMSysTimeCallback(LPWINE_MM_IDATA iData)
{
LPWINE_TIMERENTRY lpTimer, lpNextTimer;
DWORD delta = GetTickCount() - iData->mmSysTimeMS;
static int nSizeLpTimers;
static LPWINE_TIMERENTRY lpTimers;
LPWINE_TIMERENTRY timer, *ptimer, *next_ptimer;
DWORD delta = GetTickCount() - WINMM_SysTimeMS;
int idx;
TRACE("Time delta: %ld\n", delta);
while (delta >= MMSYSTIME_MININTERVAL) {
delta -= MMSYSTIME_MININTERVAL;
iData->mmSysTimeMS += MMSYSTIME_MININTERVAL;
WINMM_SysTimeMS += MMSYSTIME_MININTERVAL;
/* since timeSetEvent() and timeKillEvent() can be called
* from 16 bit code, there are cases where win16 lock is
@ -109,48 +117,52 @@ static void CALLBACK TIME_MMSysTimeCallback(LPWINE_MM_IDATA iData)
* situation).
* To cope with that, we just copy the WINE_TIMERENTRY struct
* that need to trigger the callback, and call it without the
* mm timer crit sect locked. The bad side of this
* implementation is that, in some cases, the callback may be
* invoked *after* a timer has been destroyed...
* EPP 99/07/13
* mm timer crit sect locked.
* the hKillTimeEvent is used to mark the section where we
* handle the callbacks so we can do synchronous kills.
* EPP 99/07/13, updated 04/01/10
*/
idx = 0;
EnterCriticalSection(&iData->cs);
for (lpTimer = iData->lpTimerList; lpTimer != NULL; ) {
lpNextTimer = lpTimer->lpNext;
if (lpTimer->uCurTime < MMSYSTIME_MININTERVAL) {
for (ptimer = &TIME_TimersList; *ptimer != NULL; ) {
timer = *ptimer;
next_ptimer = &timer->lpNext;
if (timer->uCurTime < MMSYSTIME_MININTERVAL) {
/* since lpTimer->wDelay is >= MININTERVAL, wCurTime value
* shall be correct (>= 0)
*/
lpTimer->uCurTime += lpTimer->wDelay - MMSYSTIME_MININTERVAL;
if (lpTimer->lpFunc) {
if (idx == iData->nSizeLpTimers) {
if (iData->lpTimers)
iData->lpTimers = (LPWINE_TIMERENTRY)
HeapReAlloc(GetProcessHeap(), 0,
iData->lpTimers,
++iData->nSizeLpTimers * sizeof(WINE_TIMERENTRY));
timer->uCurTime += timer->wDelay - MMSYSTIME_MININTERVAL;
if (timer->lpFunc) {
if (idx == nSizeLpTimers) {
if (lpTimers)
lpTimers = (LPWINE_TIMERENTRY)
HeapReAlloc(GetProcessHeap(), 0, lpTimers,
++nSizeLpTimers * sizeof(WINE_TIMERENTRY));
else
iData->lpTimers = (LPWINE_TIMERENTRY)
lpTimers = (LPWINE_TIMERENTRY)
HeapAlloc(GetProcessHeap(), 0,
++iData->nSizeLpTimers * sizeof(WINE_TIMERENTRY));
++nSizeLpTimers * sizeof(WINE_TIMERENTRY));
}
iData->lpTimers[idx++] = *lpTimer;
lpTimers[idx++] = *timer;
}
/* TIME_ONESHOT is defined as 0 */
if (!(lpTimer->wFlags & TIME_PERIODIC))
timeKillEvent(lpTimer->wTimerID);
if (!(timer->wFlags & TIME_PERIODIC))
{
/* unlink timer from timers list */
*ptimer = *next_ptimer;
HeapFree(GetProcessHeap(), 0, timer);
}
} else {
lpTimer->uCurTime -= MMSYSTIME_MININTERVAL;
timer->uCurTime -= MMSYSTIME_MININTERVAL;
}
lpTimer = lpNextTimer;
ptimer = next_ptimer;
}
if (TIME_hKillEvent) ResetEvent(TIME_hKillEvent);
LeaveCriticalSection(&iData->cs);
while (idx > 0) {
TIME_TriggerCallBack(&iData->lpTimers[--idx]);
}
while (idx > 0) TIME_TriggerCallBack(&lpTimers[--idx]);
if (TIME_hKillEvent) SetEvent(TIME_hKillEvent);
}
}
@ -160,12 +172,13 @@ static void CALLBACK TIME_MMSysTimeCallback(LPWINE_MM_IDATA iData)
static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg)
{
LPWINE_MM_IDATA iData = (LPWINE_MM_IDATA)arg;
volatile HANDLE *pActive = (volatile HANDLE *)&iData->hMMTimer;
volatile HANDLE *pActive = (volatile HANDLE *)&TIME_hMMTimer;
DWORD last_time, cur_time;
#ifndef __REACTOS__
usleep(MMSYSTIME_STDINTERVAL * 1000);
#endif /* __REACTOS__ */
last_time = GetTickCount();
while (*pActive) {
TIME_MMSysTimeCallback(iData);
@ -188,10 +201,10 @@ void TIME_MMTimeStart(void)
* mm timers are active, but this would require to keep mmSysTimeMS up-to-date
* without being incremented within the service thread callback.
*/
if (!WINMM_IData->hMMTimer) {
WINMM_IData->mmSysTimeMS = GetTickCount();
WINMM_IData->lpTimerList = NULL;
WINMM_IData->hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, WINMM_IData, 0, NULL);
if (!TIME_hMMTimer) {
WINMM_SysTimeMS = GetTickCount();
TIME_TimersList = NULL;
TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, WINMM_IData, 0, NULL);
}
}
@ -200,9 +213,10 @@ void TIME_MMTimeStart(void)
*/
void TIME_MMTimeStop(void)
{
if (WINMM_IData->hMMTimer) {
HANDLE hMMTimer = WINMM_IData->hMMTimer;
WINMM_IData->hMMTimer = 0;
/* FIXME: in the worst case, we're going to wait 65 seconds here :-( */
if (TIME_hMMTimer) {
HANDLE hMMTimer = TIME_hMMTimer;
TIME_hMMTimer = 0;
WaitForSingleObject(hMMTimer, INFINITE);
CloseHandle(hMMTimer);
}
@ -218,7 +232,7 @@ MMRESULT WINAPI timeGetSystemTime(LPMMTIME lpTime, UINT wSize)
if (wSize >= sizeof(*lpTime)) {
TIME_MMTimeStart();
lpTime->wType = TIME_MS;
lpTime->u.ms = WINMM_IData->mmSysTimeMS;
lpTime->u.ms = WINMM_SysTimeMS;
TRACE("=> %lu\n", lpTime->u.ms);
}
@ -256,12 +270,15 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol,
EnterCriticalSection(&WINMM_IData->cs);
for (lpTimer = WINMM_IData->lpTimerList; lpTimer != NULL; lpTimer = lpTimer->lpNext) {
if ((wFlags & TIME_KILL_SYNCHRONOUS) && !TIME_hKillEvent)
TIME_hKillEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
for (lpTimer = TIME_TimersList; lpTimer != NULL; lpTimer = lpTimer->lpNext) {
wNewID = max(wNewID, lpTimer->wTimerID);
}
lpNewTimer->lpNext = WINMM_IData->lpTimerList;
WINMM_IData->lpTimerList = lpNewTimer;
lpNewTimer->lpNext = TIME_TimersList;
TIME_TimersList = lpNewTimer;
lpNewTimer->wTimerID = wNewID + 1;
LeaveCriticalSection(&WINMM_IData->cs);
@ -275,7 +292,7 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol,
* timeSetEvent [WINMM.@]
*/
MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
DWORD dwUser, UINT wFlags)
DWORD_PTR dwUser, UINT wFlags)
{
if (wFlags & WINE_TIMER_IS32)
WARN("Unknown windows flag... wine internally used.. ooch\n");
@ -289,31 +306,30 @@ MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
*/
MMRESULT WINAPI timeKillEvent(UINT wID)
{
LPWINE_TIMERENTRY* lpTimer;
MMRESULT ret = MMSYSERR_INVALPARAM;
LPWINE_TIMERENTRY lpSelf = NULL, *lpTimer;
TRACE("(%u)\n", wID);
EnterCriticalSection(&WINMM_IData->cs);
/* remove WINE_TIMERENTRY from list */
for (lpTimer = &WINMM_IData->lpTimerList; *lpTimer; lpTimer = &(*lpTimer)->lpNext) {
for (lpTimer = &TIME_TimersList; *lpTimer; lpTimer = &(*lpTimer)->lpNext) {
if (wID == (*lpTimer)->wTimerID) {
lpSelf = *lpTimer;
/* unlink timer of id 'wID' */
*lpTimer = (*lpTimer)->lpNext;
break;
}
}
LeaveCriticalSection(&WINMM_IData->cs);
if (*lpTimer) {
LPWINE_TIMERENTRY lpTemp = *lpTimer;
/* unlink timer of id 'wID' */
*lpTimer = (*lpTimer)->lpNext;
HeapFree(GetProcessHeap(), 0, lpTemp);
ret = TIMERR_NOERROR;
} else {
WARN("wID=%u is not a valid timer ID\n", wID);
if (!lpSelf)
{
WARN("wID=%u is not a valid timer ID\n", wID);
return MMSYSERR_INVALPARAM;
}
return ret;
if (lpSelf->wFlags & TIME_KILL_SYNCHRONOUS)
WaitForSingleObject(TIME_hKillEvent, INFINITE);
HeapFree(GetProcessHeap(), 0, lpSelf);
return TIMERR_NOERROR;
}
/**************************************************************************
@ -365,5 +381,5 @@ DWORD WINAPI timeGetTime(void)
if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
TIME_MMTimeStart();
if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
return WINMM_IData->mmSysTimeMS;
return WINMM_SysTimeMS;
}

16
reactos/lib/winmm/winemm.h
View file

@ -22,10 +22,6 @@
*****************************************************************************
*/
#include "config.h"
#include "wine/port.h"
#include "wine/debug.h"
#include <stdarg.h>
#include "windef.h"
@ -74,7 +70,7 @@ typedef struct tagWINE_MM_DRIVER_PART {
int nIDMin; /* lower bound of global indexes for this type */
int nIDMax; /* hhigher bound of global indexes for this type */
union {
WINEMM_msgFunc32 fnMessage32; /* pointer to fonction */
WINEMM_msgFunc32 fnMessage32; /* pointer to function */
WINEMM_msgFunc16 fnMessage16;
} u;
} WINE_MM_DRIVER_PART;
@ -197,6 +193,7 @@ typedef struct tagWINE_PLAYSOUND {
LPCWSTR pszSound;
HMODULE hMod;
DWORD fdwSound;
HANDLE hThread;
struct tagWINE_PLAYSOUND* lpNext;
} WINE_PLAYSOUND, *LPWINE_PLAYSOUND;
@ -205,12 +202,6 @@ typedef struct tagWINE_MM_IDATA {
HANDLE hWinMM32Instance;
HANDLE hWinMM16Instance;
CRITICAL_SECTION cs;
/* mm timer part */
HANDLE hMMTimer;
DWORD mmSysTimeMS;
LPWINE_TIMERENTRY lpTimerList;
int nSizeLpTimers;
LPWINE_TIMERENTRY lpTimers;
/* mci part */
LPWINE_MCIDRIVER lpMciDrvs;
/* low level drivers (unused yet) */
@ -246,7 +237,7 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2);
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg);
LPWINE_MLD MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID);
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstTyped);
DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32);
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, BOOL bFrom32);
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2);
BOOL MMDRV_Is32(unsigned int);
void MMDRV_InstallMap(unsigned int, MMDRV_MAPFUNC, MMDRV_UNMAPFUNC,
@ -294,6 +285,7 @@ void TIME_MMTimeStop(void);
/* Global variables */
extern LPWINE_MM_IDATA WINMM_IData;
extern DWORD WINMM_SysTimeMS;
/* pointers to 16 bit functions (if sibling MMSYSTEM.DLL is loaded
* NULL otherwise

59
reactos/lib/winmm/winemm16.h Normal file
View file

@ -0,0 +1,59 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*****************************************************************************
* Copyright 1998, Luiz Otavio L. Zorzella
* 1999, Eric Pouech
*
* Purpose: multimedia declarations (internal to WINMM & MMSYSTEM DLLs)
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************
*/
#include "winemm.h"
#include "wine/mmsystem16.h"
#include "wownt32.h"
/* mmsystem (16 bit files) only functions */
void MMDRV_Init16(void);
void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16);
void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32);
typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD);
/* HANDLE16 -> HANDLE conversions */
#define HDRVR_32(h16) ((HDRVR)(ULONG_PTR)(h16))
#define HMIDI_32(h16) ((HMIDI)(ULONG_PTR)(h16))
#define HMIDIIN_32(h16) ((HMIDIIN)(ULONG_PTR)(h16))
#define HMIDIOUT_32(h16) ((HMIDIOUT)(ULONG_PTR)(h16))
#define HMIDISTRM_32(h16) ((HMIDISTRM)(ULONG_PTR)(h16))
#define HMIXER_32(h16) ((HMIXER)(ULONG_PTR)(h16))
#define HMIXEROBJ_32(h16) ((HMIXEROBJ)(ULONG_PTR)(h16))
#define HMMIO_32(h16) ((HMMIO)(ULONG_PTR)(h16))
#define HWAVE_32(h16) ((HWAVE)(ULONG_PTR)(h16))
#define HWAVEIN_32(h16) ((HWAVEIN)(ULONG_PTR)(h16))
#define HWAVEOUT_32(h16) ((HWAVEOUT)(ULONG_PTR)(h16))
/* HANDLE -> HANDLE16 conversions */
#define HDRVR_16(h32) (LOWORD(h32))
#define HMIDI_16(h32) (LOWORD(h32))
#define HMIDIIN_16(h32) (LOWORD(h32))
#define HMIDIOUT_16(h32) (LOWORD(h32))
#define HMIDISTRM_16(h32) (LOWORD(h32))
#define HMIXER_16(h32) (LOWORD(h32))
#define HMIXEROBJ_16(h32) (LOWORD(h32))
#define HMMIO_16(h32) (LOWORD(h32))
#define HWAVE_16(h32) (LOWORD(h32))
#define HWAVEIN_16(h32) (LOWORD(h32))
#define HWAVEOUT_16(h32) (LOWORD(h32))

388
reactos/lib/winmm/winmm.c
View file

@ -28,15 +28,11 @@
* 99/9 added support for loadable low level drivers
*/
#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include <string.h>
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#define NOGDI
#include "windef.h"
#include "winbase.h"
#include "mmsystem.h"
@ -45,7 +41,7 @@
#include "winreg.h"
#include "winternl.h"
#include "winemm.h"
//#include "wownt32.h"
#include "wownt32.h"
#include "wine/debug.h"
@ -129,10 +125,12 @@ BOOL WINMM_CheckForMMSystem(void)
loaded = -1;
if (h)
{
#ifndef __REACTOS__
pGetModuleHandle16 = (void*)GetProcAddress(h, "GetModuleHandle16");
pLoadLibrary16 = (void*)GetProcAddress(h, "LoadLibrary16");
if (pGetModuleHandle16 && pLoadLibrary16 &&
(pGetModuleHandle16("MMSYSTEM.DLL") || pLoadLibrary16("MMSYSTEM.DLL")))
#endif /* __REACTOS__ */
loaded = 1;
}
}
@ -236,7 +234,7 @@ UINT WINAPI mixerGetNumDevs(void)
/**************************************************************************
* mixerGetDevCapsA [WINMM.@]
*/
UINT WINAPI mixerGetDevCapsA(UINT uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -245,13 +243,13 @@ UINT WINAPI mixerGetDevCapsA(UINT uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIXER, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
* mixerGetDevCapsW [WINMM.@]
*/
UINT WINAPI mixerGetDevCapsW(UINT uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
{
MIXERCAPSA micA;
UINT ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA));
@ -270,8 +268,8 @@ UINT WINAPI mixerGetDevCapsW(UINT uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
return ret;
}
UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32)
UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
{
HANDLE hMix;
LPWINE_MLD wmld;
@ -304,8 +302,8 @@ UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
/**************************************************************************
* mixerOpen [WINMM.@]
*/
UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen)
UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen)
{
return MIXER_Open(lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen, TRUE);
}
@ -363,7 +361,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA
if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
return MMSYSERR_INVALPARAM;
return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD)lpmcdA,
return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD_PTR)lpmcdA,
fdwDetails, TRUE);
}
@ -441,7 +439,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA))
return MMSYSERR_INVALPARAM;
return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD)lpmlcA,
return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD_PTR)lpmlcA,
fdwControls, TRUE);
}
@ -518,7 +516,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliW, DWORD fdwInfo
if ((lpwm = MIXER_GetDev(hmix, fdwInfo)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD)lpmliW,
return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD_PTR)lpmliW,
fdwInfo, TRUE);
}
@ -601,14 +599,14 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
if ((lpwm = MIXER_GetDev(hmix, fdwDetails)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD)lpmcdA,
return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD_PTR)lpmcdA,
fdwDetails, TRUE);
}
/**************************************************************************
* mixerMessage [WINMM.@]
*/
UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -632,7 +630,7 @@ UINT WINAPI auxGetNumDevs(void)
/**************************************************************************
* auxGetDevCapsW [WINMM.@]
*/
UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
{
AUXCAPSA acA;
UINT ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
@ -654,7 +652,7 @@ UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
/**************************************************************************
* auxGetDevCapsA [WINMM.@]
*/
UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
UINT WINAPI auxGetDevCapsA(UINT_PTR uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -664,7 +662,7 @@ UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -678,7 +676,7 @@ UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
}
/**************************************************************************
@ -698,7 +696,7 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
/**************************************************************************
* auxOutMessage [WINMM.@]
*/
UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2)
UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PTR dw2)
{
LPWINE_MLD wmld;
@ -711,20 +709,19 @@ UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2)
/**************************************************************************
* mciGetErrorStringW [WINMM.@]
*/
BOOL WINAPI mciGetErrorStringW(DWORD wError, LPWSTR lpstrBuffer, UINT uLength)
BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
{
LPSTR bufstr = HeapAlloc(GetProcessHeap(), 0, uLength);
BOOL ret = mciGetErrorStringA(wError, bufstr, uLength);
char bufstr[MAXERRORLENGTH];
BOOL ret = mciGetErrorStringA(wError, bufstr, MAXERRORLENGTH);
MultiByteToWideChar( CP_ACP, 0, bufstr, -1, lpstrBuffer, uLength );
HeapFree(GetProcessHeap(), 0, bufstr);
return ret;
}
/**************************************************************************
* mciGetErrorStringA [WINMM.@]
*/
BOOL WINAPI mciGetErrorStringA(DWORD dwError, LPSTR lpstrBuffer, UINT uLength)
BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
{
BOOL ret = FALSE;
@ -742,18 +739,17 @@ BOOL WINAPI mciGetErrorStringA(DWORD dwError, LPSTR lpstrBuffer, UINT uLength)
/**************************************************************************
* mciDriverNotify [WINMM.@]
*/
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, UINT wDevID, UINT wStatus)
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
{
TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
return PostMessageA(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
}
/**************************************************************************
* mciGetDriverData [WINMM.@]
*/
DWORD WINAPI mciGetDriverData(UINT uDeviceID)
DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
{
LPWINE_MCIDRIVER wmd;
@ -772,7 +768,7 @@ DWORD WINAPI mciGetDriverData(UINT uDeviceID)
/**************************************************************************
* mciSetDriverData [WINMM.@]
*/
BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD data)
BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data)
{
LPWINE_MCIDRIVER wmd;
@ -792,7 +788,7 @@ BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD data)
/**************************************************************************
* mciSendCommandA [WINMM.@]
*/
DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
DWORD dwRet;
@ -805,14 +801,233 @@ DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwPar
return dwRet;
}
inline static LPSTR strdupWtoA( LPCWSTR str )
{
LPSTR ret;
INT len;
if (!str) return NULL;
len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
ret = HeapAlloc( GetProcessHeap(), 0, len );
if(ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
return ret;
}
static int MCI_MapMsgWtoA(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
{
switch(msg)
{
case MCI_CLOSE:
case MCI_PLAY:
case MCI_SEEK:
case MCI_STOP:
case MCI_PAUSE:
case MCI_GETDEVCAPS:
case MCI_SPIN:
case MCI_SET:
case MCI_STEP:
case MCI_RECORD:
case MCI_BREAK:
case MCI_SOUND:
case MCI_STATUS:
case MCI_CUE:
case MCI_REALIZE:
case MCI_PUT:
case MCI_WHERE:
case MCI_FREEZE:
case MCI_UNFREEZE:
case MCI_CUT:
case MCI_COPY:
case MCI_PASTE:
case MCI_UPDATE:
case MCI_RESUME:
case MCI_DELETE:
return 0;
case MCI_OPEN:
{
MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)*dwParam2;
MCI_OPEN_PARMSA *mci_openA;
DWORD_PTR *ptr;
ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_openA) + sizeof(DWORD_PTR));
if (!ptr) return -1;
*ptr++ = *dwParam2; /* save the previous pointer */
*dwParam2 = (DWORD_PTR)ptr;
mci_openA = (MCI_OPEN_PARMSA *)ptr;
if (dwParam1 & MCI_NOTIFY)
mci_openA->dwCallback = mci_openW->dwCallback;
if (dwParam1 & MCI_OPEN_TYPE)
{
if (dwParam1 & MCI_OPEN_TYPE_ID)
mci_openA->lpstrDeviceType = (LPSTR)mci_openW->lpstrDeviceType;
else
mci_openA->lpstrDeviceType = strdupWtoA(mci_openW->lpstrDeviceType);
}
if (dwParam1 & MCI_OPEN_ELEMENT)
{
if (dwParam1 & MCI_OPEN_ELEMENT_ID)
mci_openA->lpstrElementName = (LPSTR)mci_openW->lpstrElementName;
else
mci_openA->lpstrElementName = strdupWtoA(mci_openW->lpstrElementName);
}
if (dwParam1 & MCI_OPEN_ALIAS)
mci_openA->lpstrAlias = strdupWtoA(mci_openW->lpstrAlias);
}
return 1;
case MCI_WINDOW:
if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
{
MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)*dwParam2;
MCI_ANIM_WINDOW_PARMSA *mci_windowA;
mci_windowA = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowA));
if (!mci_windowA) return -1;
*dwParam2 = (DWORD_PTR)mci_windowA;
mci_windowA->lpstrText = strdupWtoA(mci_windowW->lpstrText);
if (dwParam1 & MCI_NOTIFY)
mci_windowA->dwCallback = mci_windowW->dwCallback;
if (dwParam1 & MCI_ANIM_WINDOW_HWND)
mci_windowA->hWnd = mci_windowW->hWnd;
if (dwParam1 & MCI_ANIM_WINDOW_STATE)
mci_windowA->nCmdShow = mci_windowW->nCmdShow;
return 1;
}
return 0;
case MCI_SYSINFO:
{
MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)*dwParam2;
MCI_SYSINFO_PARMSA *mci_sysinfoA;
DWORD_PTR *ptr;
ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoA) + sizeof(DWORD_PTR));
if (!ptr) return -1;
*ptr++ = *dwParam2; /* save the previous pointer */
*dwParam2 = (DWORD_PTR)ptr;
mci_sysinfoA = (MCI_SYSINFO_PARMSA *)ptr;
if (dwParam1 & MCI_NOTIFY)
mci_sysinfoA->dwCallback = mci_sysinfoW->dwCallback;
mci_sysinfoA->dwRetSize = mci_sysinfoW->dwRetSize; /* FIXME */
mci_sysinfoA->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoA->dwRetSize);
return 1;
}
case MCI_INFO:
case MCI_SAVE:
case MCI_LOAD:
case MCI_ESCAPE:
default:
FIXME("Message 0x%04x needs translation\n", msg);
return -1;
}
return 0;
}
static DWORD MCI_UnmapMsgWtoA(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2,
DWORD result)
{
switch(msg)
{
case MCI_OPEN:
{
DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)*ptr;
MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)(ptr + 1);
mci_openW->wDeviceID = mci_openA->wDeviceID;
if (dwParam1 & MCI_OPEN_TYPE)
{
if (!(dwParam1 & MCI_OPEN_TYPE_ID))
HeapFree(GetProcessHeap(), 0, mci_openA->lpstrDeviceType);
}
if (dwParam1 & MCI_OPEN_ELEMENT)
{
if (!(dwParam1 & MCI_OPEN_ELEMENT_ID))
HeapFree(GetProcessHeap(), 0, mci_openA->lpstrElementName);
}
if (dwParam1 & MCI_OPEN_ALIAS)
HeapFree(GetProcessHeap(), 0, mci_openA->lpstrAlias);
HeapFree(GetProcessHeap(), 0, ptr);
}
break;
case MCI_WINDOW:
if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
{
MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)dwParam2;
HeapFree(GetProcessHeap(), 0, (void *)mci_windowA->lpstrText);
HeapFree(GetProcessHeap(), 0, mci_windowA);
}
break;
case MCI_SYSINFO:
{
DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)*ptr;
MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)(ptr + 1);
if (!result)
{
mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber;
mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType;
MultiByteToWideChar(CP_ACP, 0,
mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize,
mci_sysinfoW->lpstrReturn, mci_sysinfoW->dwRetSize);
}
HeapFree(GetProcessHeap(), 0, mci_sysinfoA->lpstrReturn);
HeapFree(GetProcessHeap(), 0, ptr);
}
break;
default:
FIXME("Message 0x%04x needs unmapping\n", msg);
break;
}
return result;
}
/**************************************************************************
* mciSendCommandW [WINMM.@]
*
* FIXME: we should do the things other way around, but since our
* MM subsystem is not unicode aware...
*/
DWORD WINAPI mciSendCommandW(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
FIXME("(%08x, %s, %08lx, %08lx): stub\n",
DWORD ret;
int mapped;
TRACE("(%08x, %s, %08lx, %08lx)\n",
wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
return MCIERR_UNSUPPORTED_FUNCTION;
mapped = MCI_MapMsgWtoA(wMsg, dwParam1, &dwParam2);
if (mapped == -1)
{
FIXME("message %04x mapping failed\n", wMsg);
return MMSYSERR_NOMEM;
}
ret = mciSendCommandA(wDevID, wMsg, dwParam1, dwParam2);
if (mapped)
MCI_UnmapMsgWtoA(wMsg, dwParam1, dwParam2, ret);
return ret;
}
/**************************************************************************
@ -850,18 +1065,15 @@ UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
INT16 ret;
TRACE("(0x%04x, 0x%08lx)\n", wDevID, data);
#ifndef __REACTOS__
if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
(GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
MyUserYield();
ret = 0;
} else
#endif
{
} else {
MSG msg;
msg.hwnd = HIWORD(data);
//msg.hwnd = HWND_32(HIWORD(data));
msg.hwnd = HWND_32(HIWORD(data));
while (!PeekMessageA(&msg, msg.hwnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
ret = -1;
}
@ -871,7 +1083,7 @@ UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
/**************************************************************************
* mciSetYieldProc [WINMM.@]
*/
BOOL WINAPI mciSetYieldProc(UINT uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
{
LPWINE_MCIDRIVER wmd;
@ -904,7 +1116,7 @@ UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
/**************************************************************************
* mciGetYieldProc [WINMM.@]
*/
YIELDPROC WINAPI mciGetYieldProc(UINT uDeviceID, DWORD* lpdwYieldData)
YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData)
{
LPWINE_MCIDRIVER wmd;
@ -928,7 +1140,7 @@ YIELDPROC WINAPI mciGetYieldProc(UINT uDeviceID, DWORD* lpdwYieldData)
/**************************************************************************
* mciGetCreatorTask [WINMM.@]
*/
HTASK WINAPI mciGetCreatorTask(UINT uDeviceID)
HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
{
LPWINE_MCIDRIVER wmd;
HTASK ret = 0;
@ -942,7 +1154,7 @@ HTASK WINAPI mciGetCreatorTask(UINT uDeviceID)
/**************************************************************************
* mciDriverYield [WINMM.@]
*/
UINT WINAPI mciDriverYield(UINT uDeviceID)
UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
{
LPWINE_MCIDRIVER wmd;
UINT ret = 0;
@ -969,7 +1181,7 @@ UINT WINAPI midiOutGetNumDevs(void)
/**************************************************************************
* midiOutGetDevCapsW [WINMM.@]
*/
UINT WINAPI midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps,
UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps,
UINT uSize)
{
MIDIOUTCAPSA mocA;
@ -995,7 +1207,7 @@ UINT WINAPI midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps,
/**************************************************************************
* midiOutGetDevCapsA [WINMM.@]
*/
UINT WINAPI midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps,
UINT WINAPI midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA lpCaps,
UINT uSize)
{
LPWINE_MLD wmld;
@ -1007,7 +1219,7 @@ UINT WINAPI midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps,
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -1088,8 +1300,8 @@ static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback,
return lpwm;
}
UINT MIDI_OutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags, BOOL bFrom32)
UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
{
HMIDIOUT hMidiOut;
LPWINE_MIDI lpwm;
@ -1124,8 +1336,8 @@ UINT MIDI_OutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback,
/**************************************************************************
* midiOutOpen [WINMM.@]
*/
UINT WINAPI midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID,
DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
{
return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
}
@ -1162,7 +1374,7 @@ UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_PREPARE, (DWORD)lpMidiOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -1182,7 +1394,7 @@ UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD)lpMidiOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -1213,7 +1425,7 @@ UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD)lpMidiOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -1243,7 +1455,7 @@ UINT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, DWORD* lpdwVolume)
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
}
/**************************************************************************
@ -1303,7 +1515,7 @@ UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
* midiOutMessage [WINMM.@]
*/
UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -1341,7 +1553,7 @@ UINT WINAPI midiInGetNumDevs(void)
/**************************************************************************
* midiInGetDevCapsW [WINMM.@]
*/
UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
{
MIDIINCAPSA micA;
UINT ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
@ -1362,7 +1574,7 @@ UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
/**************************************************************************
* midiInGetDevCapsA [WINMM.@]
*/
UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -1373,7 +1585,7 @@ UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -1472,7 +1684,7 @@ UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD)lpMidiInHdr, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
}
/**************************************************************************
@ -1492,7 +1704,7 @@ UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD)lpMidiInHdr, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
}
/**************************************************************************
@ -1508,7 +1720,7 @@ UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD)lpMidiInHdr, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
}
/**************************************************************************
@ -1579,7 +1791,7 @@ UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT* lpuDeviceID)
* midiInMessage [WINMM.@]
*/
UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -2269,7 +2481,7 @@ UINT WINAPI waveOutGetNumDevs(void)
/**************************************************************************
* waveOutGetDevCapsA [WINMM.@]
*/
UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
UINT uSize)
{
LPWINE_MLD wmld;
@ -2281,14 +2493,14 @@ UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
* waveOutGetDevCapsW [WINMM.@]
*/
UINT WINAPI waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW lpCaps,
UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
UINT uSize)
{
WAVEOUTCAPSA wocA;
@ -2359,9 +2571,9 @@ UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
* waveOutOpen [WINMM.@]
* All the args/structs have the same layout as the win16 equivalents
*/
UINT WINAPI waveOutOpen(HWAVEOUT* lphWaveOut, UINT uDeviceID,
const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags)
UINT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
const LPWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags)
{
return WAVE_Open((HANDLE*)lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat,
dwCallback, dwInstance, dwFlags, TRUE);
@ -2402,7 +2614,7 @@ UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_PREPARE, (DWORD)lpWaveOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, WODM_PREPARE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -2422,7 +2634,7 @@ UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD)lpWaveOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -2438,7 +2650,7 @@ UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_WRITE, (DWORD)lpWaveOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -2510,7 +2722,7 @@ UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETPOS, (DWORD)lpTime, uSize, TRUE);
return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
}
/**************************************************************************
@ -2524,7 +2736,7 @@ UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD)lpdw, 0L, TRUE);
return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L, TRUE);
}
/**************************************************************************
@ -2552,7 +2764,7 @@ UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD)lpdw, 0L, TRUE);
return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L, TRUE);
}
/**************************************************************************
@ -2581,7 +2793,7 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD)lpdw, 0L, TRUE);
return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L, TRUE);
}
/**************************************************************************
@ -2621,7 +2833,7 @@ UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
* waveOutMessage [WINMM.@]
*/
UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -2652,7 +2864,7 @@ UINT WINAPI waveInGetNumDevs(void)
/**************************************************************************
* waveInGetDevCapsW [WINMM.@]
*/
UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
{
WAVEINCAPSA wicA;
UINT ret = waveInGetDevCapsA(uDeviceID, &wicA, uSize);
@ -2674,7 +2886,7 @@ UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
/**************************************************************************
* waveInGetDevCapsA [WINMM.@]
*/
UINT WINAPI waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -2685,7 +2897,7 @@ UINT WINAPI waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEIN, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -2755,7 +2967,7 @@ UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
lpWaveInHdr->dwBytesRecorded = 0;
return MMDRV_Message(wmld, WIDM_PREPARE, (DWORD)lpWaveInHdr, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_PREPARE, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
}
/**************************************************************************
@ -2776,7 +2988,7 @@ UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD)lpWaveInHdr, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
}
/**************************************************************************
@ -2793,7 +3005,7 @@ UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD)lpWaveInHdr, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
}
/**************************************************************************
@ -2854,7 +3066,7 @@ UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD)lpTime, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
}
/**************************************************************************
@ -2879,7 +3091,7 @@ UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
* waveInMessage [WINMM.@]
*/
UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;

181
reactos/lib/winmm/winmm.def
View file

@ -1,181 +0,0 @@
; File generated automatically from winmm.spec; do not edit!
LIBRARY winmm.dll
EXPORTS
PlaySoundA@12 @18
CloseDriver@12 @2
DefDriverProc@20 @5
DriverCallback@28 @6
;DrvClose@12=CloseDriver@12 @7
;DrvDefDriverProc@20=DefDriverProc@20 @8
;DrvGetModuleHandle@4=GetDriverModuleHandle@4 @9
;DrvOpen@12=OpenDriverW@12 @10
;DrvOpenA@12=OpenDriverA@12 @11
;DrvSendMessage@16=SendDriverMessage@16 @12
GetDriverFlags@4 @13
GetDriverModuleHandle@4 @14
;OpenDriver@12=OpenDriverW@12 @15
OpenDriverA@12 @16
;PlaySound@12=PlaySoundA@12 @17
PlaySoundW@12 @19
SendDriverMessage@16 @20
auxGetDevCapsA@12 @21
auxGetDevCapsW@12 @22
auxGetNumDevs@0 @23
auxGetVolume@8 @24
auxOutMessage@16 @25
auxSetVolume@8 @26
joyGetDevCapsA@12 @28
joyGetDevCapsW@12 @29
joyGetNumDevs@0 @30
joyGetPos@8 @31
joyGetPosEx@8 @32
joyGetThreshold@8 @33
joyReleaseCapture@4 @34
joySetCapture@16 @35
joySetThreshold@8 @36
mciDriverNotify@12 @37
mciDriverYield@4 @38
mciExecute@4 @39
mciFreeCommandResource@4 @40
mciGetCreatorTask@4 @41
mciGetDeviceIDA@4 @42
mciGetDeviceIDFromElementIDW@8 @43
mciGetDeviceIDW@4 @44
mciGetDriverData@4 @45
mciGetErrorStringA@12 @46
mciGetErrorStringW@12 @47
mciGetYieldProc@8 @48
mciLoadCommandResource@12 @49
mciSendCommandA@16 @50
mciSendCommandW@16 @51
mciSendStringA@16 @52
mciSendStringW@16 @53
mciSetDriverData@8 @54
mciSetYieldProc@12 @55
midiInAddBuffer@12 @58
midiInClose@4 @59
midiInGetDevCapsA@12 @60
midiInGetDevCapsW@12 @61
midiInGetErrorTextA@12 @62
midiInGetErrorTextW@12 @63
midiInGetID@8 @64
midiInGetNumDevs@0 @65
midiInMessage@16 @66
midiInOpen@20 @67
midiInPrepareHeader@12 @68
midiInReset@4 @69
midiInStart@4 @70
midiInStop@4 @71
midiInUnprepareHeader@12 @72
midiOutCacheDrumPatches@16 @73
midiOutCachePatches@16 @74
midiOutClose@4 @75
midiOutGetDevCapsA@12 @76
midiOutGetDevCapsW@12 @77
midiOutGetErrorTextA@12 @78
midiOutGetErrorTextW@12 @79
midiOutGetID@8 @80
midiOutGetNumDevs@0 @81
midiOutGetVolume@8 @82
midiOutLongMsg@12 @83
midiOutMessage@16 @84
midiOutOpen@20 @85
midiOutPrepareHeader@12 @86
midiOutReset@4 @87
midiOutSetVolume@8 @88
midiOutShortMsg@8 @89
midiOutUnprepareHeader@12 @90
midiStreamClose@4 @91
midiStreamOpen@24 @92
midiStreamOut@12 @93
midiStreamPause@4 @94
midiStreamPosition@12 @95
midiStreamProperty@12 @96
midiStreamRestart@4 @97
midiStreamStop@4 @98
mixerClose@4 @99
mixerGetControlDetailsA@12 @100
mixerGetControlDetailsW@12 @101
mixerGetDevCapsA@12 @102
mixerGetDevCapsW@12 @103
mixerGetID@12 @104
mixerGetLineControlsA@12 @105
mixerGetLineControlsW@12 @106
mixerGetLineInfoA@12 @107
mixerGetLineInfoW@12 @108
mixerGetNumDevs@0 @109
mixerMessage@16 @110
mixerOpen@20 @111
mixerSetControlDetails@12 @112
mmioAdvance@12 @113
mmioAscend@12 @114
mmioClose@8 @115
mmioCreateChunk@12 @116
mmioDescend@16 @117
mmioFlush@8 @118
mmioGetInfo@12 @119
mmioInstallIOProcA@12 @121
mmioInstallIOProcW@12 @122
mmioOpenA@12 @123
mmioOpenW@12 @124
mmioRead@12 @125
mmioRenameA@16 @126
mmioRenameW@16 @127
mmioSeek@12 @128
mmioSendMessage@16 @129
mmioSetBuffer@16 @130
mmioSetInfo@12 @131
mmioStringToFOURCCA@8 @132
mmioStringToFOURCCW@8 @133
mmioWrite@12 @134
mmsystemGetVersion@0 @135
sndPlaySoundA@8 @136
sndPlaySoundW@8 @137
timeBeginPeriod@4 @138
timeEndPeriod@4 @139
timeGetDevCaps@8 @140
timeGetSystemTime@8 @141
timeGetTime@0 @142
timeKillEvent@4 @143
timeSetEvent@20 @144
waveInAddBuffer@12 @145
waveInClose@4 @146
waveInGetDevCapsA@12 @147
waveInGetDevCapsW@12 @148
waveInGetErrorTextA@12 @149
waveInGetErrorTextW@12 @150
waveInGetID@8 @151
waveInGetNumDevs@0 @152
waveInGetPosition@12 @153
waveInMessage@16 @154
waveInOpen@24 @155
waveInPrepareHeader@12 @156
waveInReset@4 @157
waveInStart@4 @158
waveInStop@4 @159
waveInUnprepareHeader@12 @160
waveOutBreakLoop@4 @161
waveOutClose@4 @162
waveOutGetDevCapsA@12 @163
waveOutGetDevCapsW@12 @164
waveOutGetErrorTextA@12 @165
waveOutGetErrorTextW@12 @166
waveOutGetID@8 @167
waveOutGetNumDevs@0 @168
waveOutGetPitch@8 @169
waveOutGetPlaybackRate@8 @170
waveOutGetPosition@12 @171
waveOutGetVolume@8 @172
waveOutMessage@16 @173
waveOutOpen@24 @174
waveOutPause@4 @175
waveOutPrepareHeader@12 @176
waveOutReset@4 @177
waveOutRestart@4 @178
waveOutSetPitch@8 @179
waveOutSetPlaybackRate@8 @180
waveOutSetVolume@8 @181
waveOutUnprepareHeader@12 @182
waveOutWrite@12 @183

181
reactos/lib/winmm/winmm.edf
View file

@ -1,181 +0,0 @@
; File generated automatically from winmm.spec; do not edit!
LIBRARY winmm.dll
EXPORTS
PlaySoundA=PlaySoundA@12 @18
CloseDriver=CloseDriver@12 @2
DefDriverProc=DefDriverProc@20 @5
DriverCallback=DriverCallback@28 @6
DrvClose=CloseDriver@12 @7
DrvDefDriverProc=DefDriverProc@20 @8
DrvGetModuleHandle=GetDriverModuleHandle@4 @9
DrvOpen=OpenDriverW@12 @10
DrvOpenA=OpenDriverA@12 @11
DrvSendMessage=SendDriverMessage@16 @12
GetDriverFlags=GetDriverFlags@4 @13
GetDriverModuleHandle=GetDriverModuleHandle@4 @14
OpenDriver=OpenDriverW@12 @15
OpenDriverA=OpenDriverA@12 @16
PlaySound=PlaySoundA@12 @17
PlaySoundW=PlaySoundW@12 @19
SendDriverMessage=SendDriverMessage@16 @20
auxGetDevCapsA=auxGetDevCapsA@12 @21
auxGetDevCapsW=auxGetDevCapsW@12 @22
auxGetNumDevs=auxGetNumDevs@0 @23
auxGetVolume=auxGetVolume@8 @24
auxOutMessage=auxOutMessage@16 @25
auxSetVolume=auxSetVolume@8 @26
joyGetDevCapsA=joyGetDevCapsA@12 @28
joyGetDevCapsW=joyGetDevCapsW@12 @29
joyGetNumDevs=joyGetNumDevs@0 @30
joyGetPos=joyGetPos@8 @31
joyGetPosEx=joyGetPosEx@8 @32
joyGetThreshold=joyGetThreshold@8 @33
joyReleaseCapture=joyReleaseCapture@4 @34
joySetCapture=joySetCapture@16 @35
joySetThreshold=joySetThreshold@8 @36
mciDriverNotify=mciDriverNotify@12 @37
mciDriverYield=mciDriverYield@4 @38
mciExecute=mciExecute@4 @39
mciFreeCommandResource=mciFreeCommandResource@4 @40
mciGetCreatorTask=mciGetCreatorTask@4 @41
mciGetDeviceIDA=mciGetDeviceIDA@4 @42
mciGetDeviceIDFromElementIDW=mciGetDeviceIDFromElementIDW@8 @43
mciGetDeviceIDW=mciGetDeviceIDW@4 @44
mciGetDriverData=mciGetDriverData@4 @45
mciGetErrorStringA=mciGetErrorStringA@12 @46
mciGetErrorStringW=mciGetErrorStringW@12 @47
mciGetYieldProc=mciGetYieldProc@8 @48
mciLoadCommandResource=mciLoadCommandResource@12 @49
mciSendCommandA=mciSendCommandA@16 @50
mciSendCommandW=mciSendCommandW@16 @51
mciSendStringA=mciSendStringA@16 @52
mciSendStringW=mciSendStringW@16 @53
mciSetDriverData=mciSetDriverData@8 @54
mciSetYieldProc=mciSetYieldProc@12 @55
midiInAddBuffer=midiInAddBuffer@12 @58
midiInClose=midiInClose@4 @59
midiInGetDevCapsA=midiInGetDevCapsA@12 @60
midiInGetDevCapsW=midiInGetDevCapsW@12 @61
midiInGetErrorTextA=midiInGetErrorTextA@12 @62
midiInGetErrorTextW=midiInGetErrorTextW@12 @63
midiInGetID=midiInGetID@8 @64
midiInGetNumDevs=midiInGetNumDevs@0 @65
midiInMessage=midiInMessage@16 @66
midiInOpen=midiInOpen@20 @67
midiInPrepareHeader=midiInPrepareHeader@12 @68
midiInReset=midiInReset@4 @69
midiInStart=midiInStart@4 @70
midiInStop=midiInStop@4 @71
midiInUnprepareHeader=midiInUnprepareHeader@12 @72
midiOutCacheDrumPatches=midiOutCacheDrumPatches@16 @73
midiOutCachePatches=midiOutCachePatches@16 @74
midiOutClose=midiOutClose@4 @75
midiOutGetDevCapsA=midiOutGetDevCapsA@12 @76
midiOutGetDevCapsW=midiOutGetDevCapsW@12 @77
midiOutGetErrorTextA=midiOutGetErrorTextA@12 @78
midiOutGetErrorTextW=midiOutGetErrorTextW@12 @79
midiOutGetID=midiOutGetID@8 @80
midiOutGetNumDevs=midiOutGetNumDevs@0 @81
midiOutGetVolume=midiOutGetVolume@8 @82
midiOutLongMsg=midiOutLongMsg@12 @83
midiOutMessage=midiOutMessage@16 @84
midiOutOpen=midiOutOpen@20 @85
midiOutPrepareHeader=midiOutPrepareHeader@12 @86
midiOutReset=midiOutReset@4 @87
midiOutSetVolume=midiOutSetVolume@8 @88
midiOutShortMsg=midiOutShortMsg@8 @89
midiOutUnprepareHeader=midiOutUnprepareHeader@12 @90
midiStreamClose=midiStreamClose@4 @91
midiStreamOpen=midiStreamOpen@24 @92
midiStreamOut=midiStreamOut@12 @93
midiStreamPause=midiStreamPause@4 @94
midiStreamPosition=midiStreamPosition@12 @95
midiStreamProperty=midiStreamProperty@12 @96
midiStreamRestart=midiStreamRestart@4 @97
midiStreamStop=midiStreamStop@4 @98
mixerClose=mixerClose@4 @99
mixerGetControlDetailsA=mixerGetControlDetailsA@12 @100
mixerGetControlDetailsW=mixerGetControlDetailsW@12 @101
mixerGetDevCapsA=mixerGetDevCapsA@12 @102
mixerGetDevCapsW=mixerGetDevCapsW@12 @103
mixerGetID=mixerGetID@12 @104
mixerGetLineControlsA=mixerGetLineControlsA@12 @105
mixerGetLineControlsW=mixerGetLineControlsW@12 @106
mixerGetLineInfoA=mixerGetLineInfoA@12 @107
mixerGetLineInfoW=mixerGetLineInfoW@12 @108
mixerGetNumDevs=mixerGetNumDevs@0 @109
mixerMessage=mixerMessage@16 @110
mixerOpen=mixerOpen@20 @111
mixerSetControlDetails=mixerSetControlDetails@12 @112
mmioAdvance=mmioAdvance@12 @113
mmioAscend=mmioAscend@12 @114
mmioClose=mmioClose@8 @115
mmioCreateChunk=mmioCreateChunk@12 @116
mmioDescend=mmioDescend@16 @117
mmioFlush=mmioFlush@8 @118
mmioGetInfo=mmioGetInfo@12 @119
mmioInstallIOProcA=mmioInstallIOProcA@12 @121
mmioInstallIOProcW=mmioInstallIOProcW@12 @122
mmioOpenA=mmioOpenA@12 @123
mmioOpenW=mmioOpenW@12 @124
mmioRead=mmioRead@12 @125
mmioRenameA=mmioRenameA@16 @126
mmioRenameW=mmioRenameW@16 @127
mmioSeek=mmioSeek@12 @128
mmioSendMessage=mmioSendMessage@16 @129
mmioSetBuffer=mmioSetBuffer@16 @130
mmioSetInfo=mmioSetInfo@12 @131
mmioStringToFOURCCA=mmioStringToFOURCCA@8 @132
mmioStringToFOURCCW=mmioStringToFOURCCW@8 @133
mmioWrite=mmioWrite@12 @134
mmsystemGetVersion=mmsystemGetVersion@0 @135
sndPlaySoundA=sndPlaySoundA@8 @136
sndPlaySoundW=sndPlaySoundW@8 @137
timeBeginPeriod=timeBeginPeriod@4 @138
timeEndPeriod=timeEndPeriod@4 @139
timeGetDevCaps=timeGetDevCaps@8 @140
timeGetSystemTime=timeGetSystemTime@8 @141
timeGetTime=timeGetTime@0 @142
timeKillEvent=timeKillEvent@4 @143
timeSetEvent=timeSetEvent@20 @144
waveInAddBuffer=waveInAddBuffer@12 @145
waveInClose=waveInClose@4 @146
waveInGetDevCapsA=waveInGetDevCapsA@12 @147
waveInGetDevCapsW=waveInGetDevCapsW@12 @148
waveInGetErrorTextA=waveInGetErrorTextA@12 @149
waveInGetErrorTextW=waveInGetErrorTextW@12 @150
waveInGetID=waveInGetID@8 @151
waveInGetNumDevs=waveInGetNumDevs@0 @152
waveInGetPosition=waveInGetPosition@12 @153
waveInMessage=waveInMessage@16 @154
waveInOpen=waveInOpen@24 @155
waveInPrepareHeader=waveInPrepareHeader@12 @156
waveInReset=waveInReset@4 @157
waveInStart=waveInStart@4 @158
waveInStop=waveInStop@4 @159
waveInUnprepareHeader=waveInUnprepareHeader@12 @160
waveOutBreakLoop=waveOutBreakLoop@4 @161
waveOutClose=waveOutClose@4 @162
waveOutGetDevCapsA=waveOutGetDevCapsA@12 @163
waveOutGetDevCapsW=waveOutGetDevCapsW@12 @164
waveOutGetErrorTextA=waveOutGetErrorTextA@12 @165
waveOutGetErrorTextW=waveOutGetErrorTextW@12 @166
waveOutGetID=waveOutGetID@8 @167
waveOutGetNumDevs=waveOutGetNumDevs@0 @168
waveOutGetPitch=waveOutGetPitch@8 @169
waveOutGetPlaybackRate=waveOutGetPlaybackRate@8 @170
waveOutGetPosition=waveOutGetPosition@12 @171
waveOutGetVolume=waveOutGetVolume@8 @172
waveOutMessage=waveOutMessage@16 @173
waveOutOpen=waveOutOpen@24 @174
waveOutPause=waveOutPause@4 @175
waveOutPrepareHeader=waveOutPrepareHeader@12 @176
waveOutReset=waveOutReset@4 @177
waveOutRestart=waveOutRestart@4 @178
waveOutSetPitch=waveOutSetPitch@8 @179
waveOutSetPlaybackRate=waveOutSetPlaybackRate@8 @180
waveOutSetVolume=waveOutSetVolume@8 @181
waveOutUnprepareHeader=waveOutUnprepareHeader@12 @182
waveOutWrite=waveOutWrite@12 @183

187
reactos/lib/winmm/winmm.spec Normal file
View file

@ -0,0 +1,187 @@
# ordinal exports
1 stdcall @(ptr long long) PlaySoundA
3 stub @
4 stub @
@ stdcall PlaySoundA(ptr long long)
@ stdcall CloseDriver(long long long)
@ stdcall DefDriverProc(long long long long long)
@ stdcall DriverCallback(long long long long long long long)
@ stdcall DrvClose(long long long) CloseDriver
@ stdcall DrvDefDriverProc(long long long long long) DefDriverProc
@ stdcall DrvGetModuleHandle(long) GetDriverModuleHandle
@ stdcall DrvOpen(wstr wstr long) OpenDriverW
@ stdcall DrvOpenA(str str long) OpenDriverA
@ stdcall DrvSendMessage(long long long long) SendDriverMessage
@ stdcall GetDriverFlags(long)
@ stdcall GetDriverModuleHandle(long)
@ stdcall OpenDriver(wstr wstr long) OpenDriverW
@ stdcall OpenDriverA(str str long)
@ stdcall PlaySound(ptr long long) PlaySoundA
@ stdcall PlaySoundW(ptr long long)
@ stdcall SendDriverMessage(long long long long)
@ stdcall auxGetDevCapsA(long ptr long)
@ stdcall auxGetDevCapsW(long ptr long)
@ stdcall auxGetNumDevs()
@ stdcall auxGetVolume(long ptr)
@ stdcall auxOutMessage(long long long long)
@ stdcall auxSetVolume(long long)
@ stub joyConfigChanged
@ stdcall joyGetDevCapsA(long ptr long)
@ stdcall joyGetDevCapsW(long ptr long)
@ stdcall joyGetNumDevs()
@ stdcall joyGetPos(long ptr)
@ stdcall joyGetPosEx(long ptr)
@ stdcall joyGetThreshold(long ptr)
@ stdcall joyReleaseCapture(long)
@ stdcall joySetCapture(long long long long)
@ stdcall joySetThreshold(long long)
@ stdcall mciDriverNotify(long long long)
@ stdcall mciDriverYield(long)
@ stdcall mciExecute(str)
@ stdcall mciFreeCommandResource(long)
@ stdcall mciGetCreatorTask(long)
@ stdcall mciGetDeviceIDA(str)
@ stdcall mciGetDeviceIDFromElementIDW(long str)
@ stdcall mciGetDeviceIDW(str)
@ stdcall mciGetDriverData(long)
@ stdcall mciGetErrorStringA(long ptr long)
@ stdcall mciGetErrorStringW(long ptr long)
@ stdcall mciGetYieldProc(long ptr)
@ stdcall mciLoadCommandResource(long wstr long)
@ stdcall mciSendCommandA(long long long long)
@ stdcall mciSendCommandW(long long long long)
@ stdcall mciSendStringA(str ptr long long)
@ stdcall mciSendStringW(wstr ptr long long)
@ stdcall mciSetDriverData(long long)
@ stdcall mciSetYieldProc(long ptr long)
@ stub midiConnect
@ stub midiDisconnect
@ stdcall midiInAddBuffer(long ptr long)
@ stdcall midiInClose(long)
@ stdcall midiInGetDevCapsA(long ptr long)
@ stdcall midiInGetDevCapsW(long ptr long)
@ stdcall midiInGetErrorTextA(long ptr long)
@ stdcall midiInGetErrorTextW(long ptr long)
@ stdcall midiInGetID(long ptr)
@ stdcall midiInGetNumDevs()
@ stdcall midiInMessage(long long long long)
@ stdcall midiInOpen(ptr long long long long)
@ stdcall midiInPrepareHeader(long ptr long)
@ stdcall midiInReset(long)
@ stdcall midiInStart(long)
@ stdcall midiInStop(long)
@ stdcall midiInUnprepareHeader(long ptr long)
@ stdcall midiOutCacheDrumPatches(long long ptr long)
@ stdcall midiOutCachePatches(long long ptr long)
@ stdcall midiOutClose(long)
@ stdcall midiOutGetDevCapsA(long ptr long)
@ stdcall midiOutGetDevCapsW(long ptr long)
@ stdcall midiOutGetErrorTextA(long ptr long)
@ stdcall midiOutGetErrorTextW(long ptr long)
@ stdcall midiOutGetID(long ptr)
@ stdcall midiOutGetNumDevs()
@ stdcall midiOutGetVolume(long ptr)
@ stdcall midiOutLongMsg(long ptr long)
@ stdcall midiOutMessage(long long long long)
@ stdcall midiOutOpen(ptr long long long long)
@ stdcall midiOutPrepareHeader(long ptr long)
@ stdcall midiOutReset(long)
@ stdcall midiOutSetVolume(long ptr)
@ stdcall midiOutShortMsg(long long)
@ stdcall midiOutUnprepareHeader(long ptr long)
@ stdcall midiStreamClose(long)
@ stdcall midiStreamOpen(ptr ptr long long long long)
@ stdcall midiStreamOut(long ptr long)
@ stdcall midiStreamPause(long)
@ stdcall midiStreamPosition(long ptr long)
@ stdcall midiStreamProperty(long ptr long)
@ stdcall midiStreamRestart(long)
@ stdcall midiStreamStop(long)
@ stdcall mixerClose(long)
@ stdcall mixerGetControlDetailsA(long ptr long)
@ stdcall mixerGetControlDetailsW(long ptr long)
@ stdcall mixerGetDevCapsA(long ptr long)
@ stdcall mixerGetDevCapsW(long ptr long)
@ stdcall mixerGetID(long ptr long)
@ stdcall mixerGetLineControlsA(long ptr long)
@ stdcall mixerGetLineControlsW(long ptr long)
@ stdcall mixerGetLineInfoA(long ptr long)
@ stdcall mixerGetLineInfoW(long ptr long)
@ stdcall mixerGetNumDevs()
@ stdcall mixerMessage(long long long long)
@ stdcall mixerOpen(ptr long long long long)
@ stdcall mixerSetControlDetails(long ptr long)
@ stdcall mmioAdvance(long ptr long)
@ stdcall mmioAscend(long ptr long)
@ stdcall mmioClose(long long)
@ stdcall mmioCreateChunk(long ptr long)
@ stdcall mmioDescend(long ptr ptr long)
@ stdcall mmioFlush(long long)
@ stdcall mmioGetInfo(long ptr long)
@ stub mmioInstallIOProc16
@ stdcall mmioInstallIOProcA(long ptr long)
@ stdcall mmioInstallIOProcW(long ptr long)
@ stdcall mmioOpenA(str ptr long)
@ stdcall mmioOpenW(wstr ptr long)
@ stdcall mmioRead(long ptr long)
@ stdcall mmioRenameA(str str ptr long)
@ stdcall mmioRenameW(wstr wstr ptr long)
@ stdcall mmioSeek(long long long)
@ stdcall mmioSendMessage(long long long long)
@ stdcall mmioSetBuffer(long ptr long long)
@ stdcall mmioSetInfo(long ptr long)
@ stdcall mmioStringToFOURCCA(str long)
@ stdcall mmioStringToFOURCCW(wstr long)
@ stdcall mmioWrite(long ptr long)
@ stdcall mmsystemGetVersion()
@ stdcall sndPlaySoundA(ptr long)
@ stdcall sndPlaySoundW(ptr long)
@ stdcall timeBeginPeriod(long)
@ stdcall timeEndPeriod(long)
@ stdcall timeGetDevCaps(ptr long)
@ stdcall timeGetSystemTime(ptr long)
@ stdcall timeGetTime()
@ stdcall timeKillEvent(long)
@ stdcall timeSetEvent(long long ptr long long)
@ stdcall waveInAddBuffer(long ptr long)
@ stdcall waveInClose(long)
@ stdcall waveInGetDevCapsA(long ptr long)
@ stdcall waveInGetDevCapsW(long ptr long)
@ stdcall waveInGetErrorTextA(long ptr long)
@ stdcall waveInGetErrorTextW(long ptr long)
@ stdcall waveInGetID(long ptr)
@ stdcall waveInGetNumDevs()
@ stdcall waveInGetPosition(long ptr long)
@ stdcall waveInMessage(long long long long)
@ stdcall waveInOpen(ptr long ptr long long long)
@ stdcall waveInPrepareHeader(long ptr long)
@ stdcall waveInReset(long)
@ stdcall waveInStart(long)
@ stdcall waveInStop(long)
@ stdcall waveInUnprepareHeader(long ptr long)
@ stdcall waveOutBreakLoop(long)
@ stdcall waveOutClose(long)
@ stdcall waveOutGetDevCapsA(long ptr long)
@ stdcall waveOutGetDevCapsW(long ptr long)
@ stdcall waveOutGetErrorTextA(long ptr long)
@ stdcall waveOutGetErrorTextW(long ptr long)
@ stdcall waveOutGetID(long ptr)
@ stdcall waveOutGetNumDevs()
@ stdcall waveOutGetPitch(long ptr)
@ stdcall waveOutGetPlaybackRate(long ptr)
@ stdcall waveOutGetPosition(long ptr long)
@ stdcall waveOutGetVolume(long ptr)
@ stdcall waveOutMessage(long long long long)
@ stdcall waveOutOpen(ptr long ptr long long long)
@ stdcall waveOutPause(long)
@ stdcall waveOutPrepareHeader(long ptr long)
@ stdcall waveOutReset(long)
@ stdcall waveOutRestart(long)
@ stdcall waveOutSetPitch(long long)
@ stdcall waveOutSetPlaybackRate(long long)
@ stdcall waveOutSetVolume(long long)
@ stdcall waveOutUnprepareHeader(long ptr long)
@ stdcall waveOutWrite(long ptr long)
@ stub winmmf_ThunkData32
@ stub winmmsl_ThunkData32