*
* 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
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
/*
#include "mmsystem.h"
#include "winuser.h"
#include "winnls.h"
-#include "winreg.h"
#include "winternl.h"
#include "winemm.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
-void (WINAPI *pFnReleaseThunkLock)(DWORD*);
-void (WINAPI *pFnRestoreThunkLock)(DWORD);
-
/* ========================================================================
* G L O B A L S E T T I N G S
* ========================================================================*/
-WINE_MM_IDATA WINMM_IData;
+HINSTANCE hWinMM32Instance;
+HANDLE psLastEvent;
+HANDLE psStopEvent;
+
+static CRITICAL_SECTION_DEBUG critsect_debug =
+{
+ 0, 0, &WINMM_cs,
+ { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": WINMM_cs") }
+};
+CRITICAL_SECTION WINMM_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
/**************************************************************************
* WINMM_CreateIData [internal]
*/
static BOOL WINMM_CreateIData(HINSTANCE hInstDLL)
{
- memset( &WINMM_IData, 0, sizeof WINMM_IData );
-
- WINMM_IData.hWinMM32Instance = hInstDLL;
- InitializeCriticalSection(&WINMM_IData.cs);
-/* FIXME crashes in ReactOS
- WINMM_IData.cs.DebugInfo->Spare[1] = (DWORD)"WINMM_IData";
-*/
- WINMM_IData.psStopEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
- WINMM_IData.psLastEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
- TRACE("Initialized IData (%p)\n", &WINMM_IData);
+ hWinMM32Instance = hInstDLL;
+ psStopEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
+ psLastEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
return TRUE;
}
/* FIXME: should also free content and resources allocated
* inside WINMM_IData */
- CloseHandle(WINMM_IData.psStopEvent);
- CloseHandle(WINMM_IData.psLastEvent);
- DeleteCriticalSection(&WINMM_IData.cs);
+ CloseHandle(psStopEvent);
+ CloseHandle(psLastEvent);
+ DeleteCriticalSection(&WINMM_cs);
}
/******************************************************************
* WINMM_LoadMMSystem
*
*/
-#ifndef __REACTOS__
static HANDLE (WINAPI *pGetModuleHandle16)(LPCSTR);
static DWORD (WINAPI *pLoadLibrary16)(LPCSTR);
-#endif
BOOL WINMM_CheckForMMSystem(void)
{
loaded = -1;
if (h)
{
-#ifndef __REACTOS__
pGetModuleHandle16 = (void*)GetProcAddress(h, "GetModuleHandle16");
- pLoadLibrary16 = (void*)GetProcAddress(h, "LoadLibrary16");
+ pLoadLibrary16 = (void*)GetProcAddress(h, (LPCSTR)35); /* ordinal for LoadLibrary16 */
if (pGetModuleHandle16 && pLoadLibrary16 &&
(pGetModuleHandle16("MMSYSTEM.DLL") || pLoadLibrary16("MMSYSTEM.DLL")))
-#endif /* __REACTOS__ */
loaded = 1;
}
}
*/
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
{
- TRACE("%p 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
+ TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad);
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
/* close all opened MCI drivers */
- MCI_SendCommand(MCI_ALL_DEVICE_ID, MCI_CLOSE, MCI_WAIT, 0L, TRUE);
+ MCI_SendCommand(MCI_ALL_DEVICE_ID, MCI_CLOSE, MCI_WAIT, 0L);
MMDRV_Exit();
- /* now unload all remaining drivers... */
- DRIVER_UnloadAll();
+ /* There's no guarantee the drivers haven't already been unloaded on
+ * process shutdown.
+ */
+ if (!fImpLoad)
+ {
+ /* now unload all remaining drivers... */
+ DRIVER_UnloadAll();
+ }
WINMM_DeleteIData();
break;
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIXER, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
- return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
+ return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
}
-UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
+static void CALLBACK MIXER_WCallback(HMIXEROBJ hmx, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam, DWORD_PTR param2)
+{
+ HWND hWnd = (HWND)dwInstance;
+
+ if (!dwInstance)
+ return;
+
+ PostMessageW(hWnd, uMsg, (WPARAM)hmx, (LPARAM)dwParam);
+}
+
+/**************************************************************************
+ * mixerOpen [WINMM.@]
+ */
+UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
+ DWORD_PTR dwInstance, DWORD fdwOpen)
{
HANDLE hMix;
LPWINE_MLD wmld;
DWORD dwRet = 0;
MIXEROPENDESC mod;
- TRACE("(%p, %d, %08lx, %08lx, %08lx)\n",
+ TRACE("(%p, %d, %08lx, %08lx, %08x)\n",
lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen);
- wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen,
- &dwCallback, &dwInstance, bFrom32);
+ mod.dwCallback = (DWORD_PTR)MIXER_WCallback;
+ mod.dwInstance = 0;
+
+/* If callback is a function,
+ * dwCallback contains function pointer
+ * dwInstance private data
+ *
+ * if callback is a window
+ * dwCallback contains a window handle
+ */
+ switch (fdwOpen & CALLBACK_TYPEMASK) {
+ default:
+ return MMSYSERR_INVALFLAG;
+ case CALLBACK_NULL:
+ break;
+
+ case CALLBACK_WINDOW:
+ mod.dwInstance = dwCallback;
+ if (dwCallback && !IsWindow((HWND)dwCallback))
+ return MMSYSERR_INVALPARAM;
+ break;
+ }
+
+ wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen,
+ &dwCallback, &dwInstance);
wmld->uDeviceID = uDeviceID;
- mod.hmx = (HMIXEROBJ)hMix;
- mod.dwCallback = dwCallback;
- mod.dwInstance = dwInstance;
+ mod.hmx = hMix;
- dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD)&mod, fdwOpen);
+ dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD_PTR)&mod, CALLBACK_FUNCTION);
if (dwRet != MMSYSERR_NOERROR) {
MMDRV_Free(hMix, wmld);
hMix = 0;
}
if (lphMix) *lphMix = hMix;
- TRACE("=> %ld hMixer=%p\n", dwRet, hMix);
+ TRACE("=> %d hMixer=%p\n", dwRet, hMix);
return dwRet;
}
-/**************************************************************************
- * mixerOpen [WINMM.@]
- */
-MMRESULT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD fdwOpen)
-{
- return MIXER_Open(lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen, TRUE);
-}
-
/**************************************************************************
* mixerClose [WINMM.@]
*/
LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR;
- TRACE("(%p %p %08lx)\n", hmix, lpid, fdwID);
+ TRACE("(%p %p %08x)\n", hmix, lpid, fdwID);
if ((uRet = MIXER_GetDev(hmix, fdwID, &lpwm)) != MMSYSERR_NOERROR)
return uRet;
LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmcdW, fdwDetails);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmcdW, fdwDetails);
if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR)
return uRet;
return MMSYSERR_INVALPARAM;
return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD_PTR)lpmcdW,
- fdwDetails, TRUE);
+ fdwDetails);
}
/**************************************************************************
{
DWORD ret = MMSYSERR_NOTENABLED;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmcdA, fdwDetails);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails);
if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
return MMSYSERR_INVALPARAM;
switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
case MIXER_GETCONTROLDETAILSF_VALUE:
- /* can savely use A structure as it is, no string inside */
+ /* can safely use A structure as it is, no string inside */
ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
break;
case MIXER_GETCONTROLDETAILSF_LISTTEXT:
{
- MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = (MIXERCONTROLDETAILS_LISTTEXTA *)lpmcdA->paDetails;
+ MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = lpmcdA->paDetails;
MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW;
int size = max(1, lpmcdA->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
unsigned int i;
}
break;
default:
- ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails);
+ ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails);
}
return ret;
DWORD ret;
unsigned int i;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmlcA, fdwControls);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmlcA, fdwControls);
if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
/* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
the control count is assumed to be 1 - This is relied upon by a game,
"Dynomite Deluze" */
- if (MIXER_GETLINECONTROLSF_ONEBYTYPE == fdwControls) {
+ if (MIXER_GETLINECONTROLSF_ONEBYTYPE == (fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)) {
mlcW.cControls = 1;
} else {
mlcW.cControls = lpmlcA->cControls;
lpmlcA->dwLineID = mlcW.dwLineID;
lpmlcA->u.dwControlID = mlcW.u.dwControlID;
lpmlcA->u.dwControlType = mlcW.u.dwControlType;
- lpmlcA->cControls = mlcW.cControls;
for (i = 0; i < mlcW.cControls; i++) {
lpmlcA->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLA);
LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmlcW, fdwControls);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls);
if ((uRet = MIXER_GetDev(hmix, fdwControls, &lpwm)) != MMSYSERR_NOERROR)
return uRet;
return MMSYSERR_INVALPARAM;
return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD_PTR)lpmlcW,
- fdwControls, TRUE);
+ fdwControls);
}
/**************************************************************************
LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmliW, fdwInfo);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmliW, fdwInfo);
+ if (lpmliW == NULL || lpmliW->cbStruct != sizeof(*lpmliW))
+ return MMSYSERR_INVALPARAM;
+
if ((uRet = MIXER_GetDev(hmix, fdwInfo, &lpwm)) != MMSYSERR_NOERROR)
return uRet;
return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD_PTR)lpmliW,
- fdwInfo, TRUE);
+ fdwInfo);
}
/**************************************************************************
MIXERLINEW mliW;
UINT ret;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmliA, fdwInfo);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmliA, fdwInfo);
if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
return MMSYSERR_INVALPARAM;
mliW.Target.wMid = lpmliA->Target.wMid;
mliW.Target.wPid = lpmliA->Target.wPid;
mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion;
- MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname));
+ MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR));
break;
default:
- WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo);
+ WARN("Unsupported fdwControls=0x%08x\n", fdwInfo);
return MMSYSERR_INVALFLAG;
}
ret = mixerGetLineInfoW(hmix, &mliW, fdwInfo);
- lpmliA->dwDestination = mliW.dwDestination;
- lpmliA->dwSource = mliW.dwSource;
- lpmliA->dwLineID = mliW.dwLineID;
- lpmliA->fdwLine = mliW.fdwLine;
- lpmliA->dwUser = mliW.dwUser;
- lpmliA->dwComponentType = mliW.dwComponentType;
- lpmliA->cChannels = mliW.cChannels;
- lpmliA->cConnections = mliW.cConnections;
- lpmliA->cControls = mliW.cControls;
- WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName,
- sizeof(lpmliA->szShortName), NULL, NULL);
- WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName,
- sizeof(lpmliA->szName), NULL, NULL );
- lpmliA->Target.dwType = mliW.Target.dwType;
- lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID;
- lpmliA->Target.wMid = mliW.Target.wMid;
- lpmliA->Target.wPid = mliW.Target.wPid;
- lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion;
- WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname,
- sizeof(lpmliA->Target.szPname), NULL, NULL );
-
+ if(ret == MMSYSERR_NOERROR)
+ {
+ lpmliA->dwDestination = mliW.dwDestination;
+ lpmliA->dwSource = mliW.dwSource;
+ lpmliA->dwLineID = mliW.dwLineID;
+ lpmliA->fdwLine = mliW.fdwLine;
+ lpmliA->dwUser = mliW.dwUser;
+ lpmliA->dwComponentType = mliW.dwComponentType;
+ lpmliA->cChannels = mliW.cChannels;
+ lpmliA->cConnections = mliW.cConnections;
+ lpmliA->cControls = mliW.cControls;
+ WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName,
+ sizeof(lpmliA->szShortName), NULL, NULL);
+ WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName,
+ sizeof(lpmliA->szName), NULL, NULL );
+ lpmliA->Target.dwType = mliW.Target.dwType;
+ lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID;
+ lpmliA->Target.wMid = mliW.Target.wMid;
+ lpmliA->Target.wPid = mliW.Target.wPid;
+ lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion;
+ WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname,
+ sizeof(lpmliA->Target.szPname), NULL, NULL );
+ }
return ret;
}
LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR;
- TRACE("(%p, %p, %08lx)\n", hmix, lpmcd, fdwDetails);
+ TRACE("(%p, %p, %08x)\n", hmix, lpmcd, fdwDetails);
if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR)
return uRet;
return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD_PTR)lpmcd,
- fdwDetails, TRUE);
+ fdwDetails);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%04lx, %d, %08lx, %08lx): semi-stub?\n",
- (DWORD)hmix, uMsg, dwParam1, dwParam2);
+ TRACE("(%p, %d, %08lx, %08lx): semi-stub?\n",
+ hmix, uMsg, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, uMsg, dwParam1, dwParam2, TRUE);
+ return MMDRV_Message(wmld, uMsg, dwParam1, dwParam2);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
+ TRACE("(%04lX, %p, %d) !\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
+ return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
+ return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume);
+ TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
+ return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
+ return MMDRV_Message(wmld, uMessage, dw1, dw2);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%u, %p, %u);\n", uDeviceID, lpCaps, uSize);
+ TRACE("(%lu, %p, %u);\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
+ return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
}
/**************************************************************************
if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
else if (uSize == 0) ret = MMSYSERR_NOERROR;
else if (
- /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
+ /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
* a warning for the test was always true */
(/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
(uError >= MIDIERR_BASE && uError <= MIDIERR_LASTERROR)) {
- if (LoadStringW(WINMM_IData.hWinMM32Instance,
- uError, lpText, uSize) > 0) {
+ if (LoadStringW(hWinMM32Instance, uError, lpText, uSize) > 0) {
ret = MMSYSERR_NOERROR;
}
}
/**************************************************************************
* MIDI_OutAlloc [internal]
*/
-static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback,
- LPDWORD lpdwInstance, LPDWORD lpdwFlags,
- DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32)
+static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, DWORD_PTR* lpdwCallback,
+ DWORD_PTR* lpdwInstance, LPDWORD lpdwFlags,
+ DWORD cIDs, MIDIOPENSTRMID* lpIDs)
{
HANDLE hMidiOut;
LPWINE_MIDI lpwm;
size = sizeof(WINE_MIDI) + (cIDs ? (cIDs-1) : 0) * sizeof(MIDIOPENSTRMID);
lpwm = (LPWINE_MIDI)MMDRV_Alloc(size, MMDRV_MIDIOUT, &hMidiOut, lpdwFlags,
- lpdwCallback, lpdwInstance, bFrom32);
+ lpdwCallback, lpdwInstance);
if (lphMidiOut != NULL)
*lphMidiOut = hMidiOut;
if (lpwm) {
- lpwm->mod.hMidi = (HMIDI) hMidiOut;
+ lpwm->mod.hMidi = hMidiOut;
lpwm->mod.dwCallback = *lpdwCallback;
lpwm->mod.dwInstance = *lpdwInstance;
lpwm->mod.dnDevNode = 0;
return lpwm;
}
-UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
+/**************************************************************************
+ * midiOutOpen [WINMM.@]
+ */
+UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
+ DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
{
HMIDIOUT hMidiOut;
LPWINE_MIDI lpwm;
UINT dwRet = 0;
- TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
+ TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
if (lphMidiOut != NULL) *lphMidiOut = 0;
- lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags,
- 0, NULL, bFrom32);
+ lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags, 0, NULL);
if (lpwm == NULL)
return MMSYSERR_NOMEM;
lpwm->mld.uDeviceID = uDeviceID;
- dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD)&lpwm->mod, dwFlags);
+ dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags);
if (dwRet != MMSYSERR_NOERROR) {
MMDRV_Free(hMidiOut, (LPWINE_MLD)lpwm);
return dwRet;
}
-/**************************************************************************
- * midiOutOpen [WINMM.@]
- */
-MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT_PTR uDeviceID,
- DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
-{
- return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
-}
-
/**************************************************************************
* midiOutClose [WINMM.@]
*/
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lX)\n", hMidiOut, dwMsg);
+ TRACE("(%p, %08X)\n", hMidiOut, dwMsg);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L, TRUE);
+ return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_RESET, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, MODM_RESET, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
+ return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %ld);\n", hMidiOut, dwVolume);
+ TRACE("(%p, %d);\n", hMidiOut, dwVolume);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L, TRUE);
+ return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L);
}
/**************************************************************************
FIXME("can't handle OPEN or CLOSE message!\n");
return MMSYSERR_NOTSUPPORTED;
}
- return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
+ return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%d, %p, %d);\n", uDeviceID, lpCaps, uSize);
+ TRACE("(%ld, %p, %d);\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
+ return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
}
/**************************************************************************
return ret;
}
-UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
+/**************************************************************************
+ * midiInOpen [WINMM.@]
+ */
+UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
+ DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
{
HANDLE hMidiIn;
LPWINE_MIDI lpwm;
DWORD dwRet = 0;
- TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
+ TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
if (lphMidiIn != NULL) *lphMidiIn = 0;
lpwm = (LPWINE_MIDI)MMDRV_Alloc(sizeof(WINE_MIDI), MMDRV_MIDIIN, &hMidiIn,
- &dwFlags, &dwCallback, &dwInstance, bFrom32);
+ &dwFlags, &dwCallback, &dwInstance);
if (lpwm == NULL)
return MMSYSERR_NOMEM;
- lpwm->mod.hMidi = (HMIDI) hMidiIn;
+ lpwm->mod.hMidi = hMidiIn;
lpwm->mod.dwCallback = dwCallback;
lpwm->mod.dwInstance = dwInstance;
lpwm->mld.uDeviceID = uDeviceID;
- dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD)&lpwm->mod, dwFlags);
+ dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags);
if (dwRet != MMSYSERR_NOERROR) {
MMDRV_Free(hMidiIn, &lpwm->mld);
hMidiIn = 0;
}
if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
- TRACE("=> %ld hMidi=%p\n", dwRet, hMidiIn);
+ TRACE("=> %d hMidi=%p\n", dwRet, hMidiIn);
return dwRet;
}
-/**************************************************************************
- * midiInOpen [WINMM.@]
- */
-MMRESULT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT_PTR uDeviceID,
- DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
-{
- return MIDI_InOpen(lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
-}
-
/**************************************************************************
* midiInClose [WINMM.@]
*/
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_START, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, MIDM_START, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L);
}
/**************************************************************************
FIXME("can't handle OPEN or CLOSE message!\n");
return MMSYSERR_NOTSUPPORTED;
}
- return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
+ return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2);
+}
+
+/**************************************************************************
+ * midiConnect [WINMM.@]
+ */
+MMRESULT WINAPI midiConnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved)
+{
+ FIXME("(%p, %p, %p): Stub\n", hMidi, hmo, pReserved);
+ return MMSYSERR_ERROR;
+}
+
+/**************************************************************************
+ * midiDisconnect [WINMM.@]
+ */
+MMRESULT WINAPI midiDisconnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved)
+{
+ FIXME("(%p, %p, %p): Stub\n", hMidi, hmo, pReserved);
+ return MMSYSERR_ERROR;
}
typedef struct WINE_MIDIStream {
/* this is not quite what MS doc says... */
midiOutReset(lpMidiStrm->hDevice);
/* empty list of already submitted buffers */
- for (lpMidiHdr = lpMidiStrm->lpMidiHdr; lpMidiHdr; lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext) {
+ for (lpMidiHdr = lpMidiStrm->lpMidiHdr; lpMidiHdr; lpMidiHdr = lpMidiHdr->lpNext) {
lpMidiHdr->dwFlags |= MHDR_DONE;
lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
(HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
- lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
+ lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0);
}
lpMidiStrm->lpMidiHdr = 0;
SetEvent(lpMidiStrm->hEvent);
*/
lpMidiHdr = (LPMIDIHDR)msg->lParam;
lpData = (LPBYTE)lpMidiHdr->lpData;
- TRACE("Adding %s lpMidiHdr=%p [lpData=0x%08lx dwBufferLength=%lu/%lu dwFlags=0x%08lx size=%u]\n",
+ TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBufferLength=%u/%u dwFlags=0x%08x size=%lu]\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
- (DWORD)lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded,
+ lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded,
lpMidiHdr->dwFlags, msg->wParam);
#if 0
/* dumps content of lpMidiHdr->lpData
if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
- FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n",
+ FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
((LPMIDIEVENT)lpData)->dwStreamID);
lpMidiHdr->dwFlags |= MHDR_DONE;
DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
(HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
- lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
+ lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0);
break;
}
- for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = (LPMIDIHDR*)&((*lpmh)->lpNext));
+ for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = &(*lpmh)->lpNext);
*lpmh = lpMidiHdr;
lpMidiHdr = (LPMIDIHDR)msg->lParam;
lpMidiHdr->lpNext = 0;
dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS;
- TRACE("%ld/%ld/%ld\n", dwToGo, GetTickCount(), me->dwDeltaTime);
+ TRACE("%d/%d/%d\n", dwToGo, GetTickCount(), me->dwDeltaTime);
while ((dwCurrTC = GetTickCount()) < dwToGo) {
if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) {
/* got a message, handle it */
lpMidiHdr->dwFlags |= MHDR_DONE;
lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
- lpMidiStrm->lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext;
+ lpMidiStrm->lpMidiHdr = lpMidiHdr->lpNext;
DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
(HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
- lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
+ lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0);
lpData = 0;
}
}
static BOOL MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream* lpMidiStrm, WORD msg, DWORD pmt1, DWORD pmt2)
{
if (PostThreadMessageA(lpMidiStrm->dwThreadID, msg, pmt1, pmt2)) {
- DWORD count;
+ //DWORD count;
- if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
+ //ReleaseThunkLock(&count);
WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
- if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
+ //RestoreThunkLock(count);
} else {
WARN("bad PostThreadMessageA\n");
return FALSE;
}
/**************************************************************************
- * MMSYSTEM_MidiStream_Open [internal]
+ * midiStreamOpen [WINMM.@]
*/
-MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi,
- DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen,
- BOOL bFrom32)
+MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
+ DWORD cMidi, DWORD_PTR dwCallback,
+ DWORD_PTR dwInstance, DWORD fdwOpen)
{
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret;
LPWINE_MIDI lpwm;
HMIDIOUT hMidiOut;
- TRACE("(%p, %p, %ld, 0x%08lx, 0x%08lx, 0x%08lx)!\n",
+ TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
return MMSYSERR_NOMEM;
lpMidiStrm->dwTempo = 500000;
- lpMidiStrm->dwTimeDiv = 480; /* 480 is 120 quater notes per minute *//* FIXME ??*/
+ lpMidiStrm->dwTimeDiv = 480; /* 480 is 120 quarter notes per minute *//* FIXME ??*/
lpMidiStrm->dwPositionMS = 0;
mosm.dwStreamID = (DWORD)lpMidiStrm;
/* FIXME: the correct value is not allocated yet for MAPPER */
mosm.wDeviceID = *lpuDeviceID;
- lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm, bFrom32);
+ lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm);
lpMidiStrm->hDevice = hMidiOut;
if (lphMidiStrm)
*lphMidiStrm = (HMIDISTRM)hMidiOut;
lpwm->mld.uDeviceID = *lpuDeviceID;
- ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD)&lpwm->mod, fdwOpen);
+ ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD_PTR)&lpwm->mod, fdwOpen);
lpMidiStrm->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
lpMidiStrm->wFlags = HIWORD(fdwOpen);
/* wait for thread to have started, and for its queue to be created */
{
- DWORD count;
+ //DWORD count;
/* (Release|Restore)ThunkLock() is needed when this method is called from 16 bit code,
* (meaning the Win16Lock is set), so that it's released and the 32 bit thread running
* MMSYSTEM_MidiStreamPlayer can acquire Win16Lock to create its queue.
*/
- if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
+ //ReleaseThunkLock(&count);
WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
- if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
+ //RestoreThunkLock(count);
}
TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
return ret;
}
-/**************************************************************************
- * midiStreamOpen [WINMM.@]
- */
-MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
- DWORD cMidi, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD fdwOpen)
-{
- return MIDI_StreamOpen(lphMidiStrm, lpuDeviceID, cMidi, dwCallback,
- dwInstance, fdwOpen, TRUE);
-}
-
/**************************************************************************
* midiStreamOut [WINMM.@]
*/
} else {
if (!PostThreadMessageA(lpMidiStrm->dwThreadID,
WINE_MSM_HEADER, cbMidiHdr,
- (DWORD)lpMidiHdr)) {
+ (LPARAM)lpMidiHdr)) {
WARN("bad PostThreadMessageA\n");
ret = MMSYSERR_ERROR;
}
ret = MMSYSERR_INVALHANDLE;
} else {
if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) {
- WARN("bad Suspend (%ld)\n", GetLastError());
+ WARN("bad Suspend (%d)\n", GetLastError());
ret = MMSYSERR_ERROR;
}
}
switch (lpMMT->wType) {
case TIME_MS:
lpMMT->u.ms = lpMidiStrm->dwPositionMS;
- TRACE("=> %ld ms\n", lpMMT->u.ms);
+ TRACE("=> %d ms\n", lpMMT->u.ms);
break;
case TIME_TICKS:
lpMMT->u.ticks = lpMidiStrm->dwPulses;
- TRACE("=> %ld ticks\n", lpMMT->u.ticks);
+ TRACE("=> %d ticks\n", lpMMT->u.ticks);
break;
default:
WARN("Unsupported time type %d\n", lpMMT->wType);
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret = MMSYSERR_NOERROR;
- TRACE("(%p, %p, %lx)\n", hMidiStrm, lpPropData, dwProperty);
+ TRACE("(%p, %p, %x)\n", hMidiStrm, lpPropData, dwProperty);
if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
ret = MMSYSERR_INVALHANDLE;
ret = MMSYSERR_INVALPARAM;
} else if (dwProperty & MIDIPROP_SET) {
lpMidiStrm->dwTempo = mpt->dwTempo;
- TRACE("Setting tempo to %ld\n", mpt->dwTempo);
+ TRACE("Setting tempo to %d\n", mpt->dwTempo);
} else if (dwProperty & MIDIPROP_GET) {
mpt->dwTempo = lpMidiStrm->dwTempo;
- TRACE("Getting tempo <= %ld\n", mpt->dwTempo);
+ TRACE("Getting tempo <= %d\n", mpt->dwTempo);
}
} else if (dwProperty & MIDIPROP_TIMEDIV) {
MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData;
ret = MMSYSERR_INVALPARAM;
} else if (dwProperty & MIDIPROP_SET) {
lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv;
- TRACE("Setting time div to %ld\n", mptd->dwTimeDiv);
+ TRACE("Setting time div to %d\n", mptd->dwTimeDiv);
} else if (dwProperty & MIDIPROP_GET) {
mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv;
- TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv);
+ TRACE("Getting time div <= %d\n", mptd->dwTimeDiv);
}
} else {
ret = MMSYSERR_INVALPARAM;
ret = ResumeThread(lpMidiStrm->hThread);
} while (ret != 0xFFFFFFFF && ret != 0);
if (ret == 0xFFFFFFFF) {
- WARN("bad Resume (%ld)\n", GetLastError());
+ WARN("bad Resume (%d)\n", GetLastError());
ret = MMSYSERR_ERROR;
} else {
lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS;
return ret;
}
-UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
- LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
+static UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
+ LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
+ DWORD_PTR dwInstance, DWORD dwFlags)
{
HANDLE handle;
LPWINE_MLD wmld;
DWORD dwRet = MMSYSERR_NOERROR;
WAVEOPENDESC wod;
- TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08lX, %d);\n",
+ TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08X);\n",
lphndl, (int)uDeviceID, (uType==MMDRV_WAVEOUT)?"Out":"In", lpFormat, dwCallback,
- dwInstance, dwFlags, bFrom32?32:16);
+ dwInstance, dwFlags);
if (dwFlags & WAVE_FORMAT_QUERY)
TRACE("WAVE_FORMAT_QUERY requested !\n");
}
/* may have a PCMWAVEFORMAT rather than a WAVEFORMATEX so don't read cbSize */
- TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u\n",
+ TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u\n",
lpFormat->wFormatTag, lpFormat->nChannels, lpFormat->nSamplesPerSec,
lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample);
if ((wmld = MMDRV_Alloc(sizeof(WINE_WAVE), uType, &handle,
- &dwFlags, &dwCallback, &dwInstance, bFrom32)) == NULL) {
+ &dwFlags, &dwCallback, &dwInstance)) == NULL) {
WARN("no memory\n");
return MMSYSERR_NOMEM;
}
wod.uMappedDeviceID = -1;
}
wmld->uDeviceID = uDeviceID;
-
+
dwRet = MMDRV_Open(wmld, (uType == MMDRV_WAVEOUT) ? WODM_OPEN : WIDM_OPEN,
- (DWORD)&wod, dwFlags);
+ (DWORD_PTR)&wod, dwFlags);
TRACE("dwRet = %s\n", WINMM_ErrorToString(dwRet));
if (dwRet != WAVERR_BADFORMAT ||
((dwFlags & (WAVE_MAPPED|WAVE_FORMAT_DIRECT)) != 0) || (uDeviceID == WAVE_MAPPER)) break;
- /* if we ask for a format which isn't supported by the physical driver,
+ /* if we ask for a format which isn't supported by the physical driver,
* let's try to map it through the wave mapper (except, if we already tried
* or user didn't allow us to use acm codecs or the device is already the mapper)
*/
{
LPWINE_MLD wmld;
- TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
+ TRACE("(%lu %p %u)!\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
- return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
-
+ return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
}
/**************************************************************************
if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
else if (uSize == 0) ret = MMSYSERR_NOERROR;
else if (
- /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
+ /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
* a warning for the test was always true */
(/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
(uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) {
- if (LoadStringW(WINMM_IData.hWinMM32Instance,
+ if (LoadStringW(hWinMM32Instance,
uError, lpText, uSize) > 0) {
ret = MMSYSERR_NOERROR;
}
DWORD_PTR dwInstance, DWORD dwFlags)
{
return WAVE_Open((HANDLE*)lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat,
- dwCallback, dwInstance, dwFlags, TRUE);
+ dwCallback, dwInstance, dwFlags);
}
/**************************************************************************
return MMSYSERR_INVALHANDLE;
if ((result = MMDRV_Message(wmld, WODM_PREPARE, (DWORD_PTR)lpWaveOutHdr,
- uSize, TRUE)) != MMSYSERR_NOTSUPPORTED)
+ uSize)) != MMSYSERR_NOTSUPPORTED)
return result;
if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
if (lpWaveOutHdr == NULL || uSize < sizeof (WAVEHDR))
return MMSYSERR_INVALPARAM;
-
+
if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
return MMSYSERR_NOERROR;
}
return MMSYSERR_INVALHANDLE;
if ((result = MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD_PTR)lpWaveOutHdr,
- uSize, TRUE)) != MMSYSERR_NOTSUPPORTED)
+ uSize)) != MMSYSERR_NOTSUPPORTED)
return result;
if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_BREAKLOOP, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_BREAKLOOP, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_PAUSE, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_PAUSE, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_RESET, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_RESET, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_RESTART, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_RESTART, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
+ return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw);
+ TRACE("(%p, %p);\n", hWaveOut, lpdw);
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw);
+ TRACE("(%p, %08x);\n", hWaveOut, dw);
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_SETPITCH, dw, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_SETPITCH, dw, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw);
+ TRACE("(%p, %p);\n", hWaveOut, lpdw);
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw);
+ TRACE("(%p, %08x);\n", hWaveOut, dw);
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_SETPLAYBACKRATE, dw, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_SETPLAYBACKRATE, dw, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw);
+ TRACE("(%p, %p);\n", hWaveOut, lpdw);
- if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
+ if (lpdw == NULL) {
+ WARN("invalid parameter\n");
+ return MMSYSERR_INVALPARAM;
+ }
+
+ if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%p, %08lx);\n", hWaveOut, dw);
+ TRACE("(%p, %08x);\n", hWaveOut, dw);
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WODM_SETVOLUME, dw, 0L, TRUE);
+ return MMDRV_Message(wmld, WODM_SETVOLUME, dw, 0L);
}
/**************************************************************************
return MMSYSERR_INVALPARAM;
}
- return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
+ return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2);
}
/**************************************************************************
{
LPWINE_MLD wmld;
- TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
+ TRACE("(%lu %p %u)!\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEIN, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
- return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
+ return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
}
/**************************************************************************
/**************************************************************************
* waveInOpen [WINMM.@]
*/
-MMRESULT WINAPI waveInOpen(LPHWAVEIN lphWaveIn, UINT uDeviceID,
- LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD dwFlags)
+MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
+ LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
+ DWORD_PTR dwInstance, DWORD dwFlags)
{
return WAVE_Open((HANDLE*)lphWaveIn, uDeviceID, MMDRV_WAVEIN, lpFormat,
- dwCallback, dwInstance, dwFlags, TRUE);
+ dwCallback, dwInstance, dwFlags);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- dwRet = MMDRV_Message(wmld, WIDM_CLOSE, 0L, 0L, TRUE);
+ dwRet = MMDRV_Message(wmld, WIDM_CLOSE, 0L, 0L);
if (dwRet != WAVERR_STILLPLAYING)
MMDRV_Free(hWaveIn, wmld);
return dwRet;
return MMSYSERR_INVALHANDLE;
if ((result = MMDRV_Message(wmld, WIDM_PREPARE, (DWORD_PTR)lpWaveInHdr,
- uSize, TRUE)) != MMSYSERR_NOTSUPPORTED)
+ uSize)) != MMSYSERR_NOTSUPPORTED)
return result;
if (lpWaveInHdr->dwFlags & WHDR_INQUEUE)
return MMSYSERR_INVALHANDLE;
if ((result = MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD_PTR)lpWaveInHdr,
- uSize, TRUE)) != MMSYSERR_NOTSUPPORTED)
+ uSize)) != MMSYSERR_NOTSUPPORTED)
return result;
if (lpWaveInHdr->dwFlags & WHDR_INQUEUE)
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
+ return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WIDM_RESET, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, WIDM_RESET, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WIDM_START, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld, WIDM_START, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld,WIDM_STOP, 0L, 0L, TRUE);
+ return MMDRV_Message(wmld,WIDM_STOP, 0L, 0L);
}
/**************************************************************************
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
- return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
+ return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize);
}
/**************************************************************************
return MMSYSERR_INVALPARAM;
- return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
+ return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2);
}
struct mm_starter
/******************************************************************
* mmTaskCreate (WINMM.@)
*/
-MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD client)
+UINT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD_PTR client)
{
HANDLE hThread;
HANDLE hEvent = 0;
/******************************************************************
* mmTaskBlock (WINMM.@)
*/
-void WINAPI mmTaskBlock(HANDLE tid)
+VOID WINAPI mmTaskBlock(DWORD tid)
{
MSG msg;
/******************************************************************
* mmTaskSignal (WINMM.@)
*/
-BOOL WINAPI mmTaskSignal(HANDLE tid)
+BOOL WINAPI mmTaskSignal(DWORD tid)
{
- return PostThreadMessageW((DWORD)tid, WM_USER, 0, 0);
+ return PostThreadMessageW(tid, WM_USER, 0, 0);
}
/******************************************************************
* mmTaskYield (WINMM.@)
*/
-void WINAPI mmTaskYield(void) {}
+VOID WINAPI mmTaskYield(VOID) {}
/******************************************************************
* mmGetCurrentTask (WINMM.@)
*/
-HANDLE WINAPI mmGetCurrentTask(void)
+DWORD WINAPI mmGetCurrentTask(VOID)
{
- return (HANDLE)GetCurrentThreadId();
+ return GetCurrentThreadId();
}
projects / reactos.git / blobdiff