{
lpNewDrv->dwMagic = WINE_DI_MAGIC;
/* First driver to be loaded for this module, need to load correctly the module */
-- if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
-- /* first of this driver in list ? */
-- if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
-- if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
- TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
- TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
-- return FALSE;
-- }
-- /* returned value is not checked */
-- DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
-- }
++ /* first of this driver in list ? */
++ if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->hModule, NULL) == 0) {
++ if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
++ TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
++ return FALSE;
++ }
++ /* returned value is not checked */
++ DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
}
++ /* Now just open a new instance of a driver on this module */
++ lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
++
++ if (lpNewDrv->dwDriverID == 0)
++ {
++ TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
++ return FALSE;
++ }
++
++ EnterCriticalSection( &mmdriver_lock );
++
lpNewDrv->lpNextItem = NULL;
if (lpDrvItemList == NULL) {
lpDrvItemList = lpNewDrv;
lpNewDrv->lpPrevItem = lpDrv;
}
-- if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
-- /* Now just open a new instance of a driver on this module */
-- lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
--
-- if (lpNewDrv->d.d32.dwDriverID == 0) {
- TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
- TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
-- DRIVER_RemoveFromList(lpNewDrv);
-- return FALSE;
-- }
-- }
++ LeaveCriticalSection( &mmdriver_lock );
return TRUE;
}
* CloseDriver [WINMM.@]
* DrvClose [WINMM.@]
*/
--LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
++LRESULT WINAPI CloseDriver(HDRVR hDrvr, LONG lParam1, LONG lParam2)
{
++ BOOL ret;
LPWINE_DRIVER lpDrv;
TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
tmp = devType; devType = dev; dev = tmp;
dwFlags |= MCI_OPEN_TYPE;
-- data[2] = (DWORD)devType;
++ data[2] = (DWORD_PTR)devType;
devType = str_dup_upper(devType);
dwFlags |= MCI_OPEN_ELEMENT;
-- data[3] = (DWORD)dev;
- } else if (strchrW(dev, '.') == NULL) {
- tmp = strchrW(dev,' ');
++ data[3] = (DWORD_PTR)dev;
- } else if (strchrW(dev, '.') == NULL) {
- tmp = strchrW(dev,' ');
++ } else if (DRIVER_GetLibName(dev, wszMci, buf, sizeof(buf))) {
++ /* this is the name of a mci driver's type */
++ tmp = strchrW(dev, ' ');
if (tmp) *tmp = '\0';
-- data[2] = (DWORD)dev;
++ data[2] = (DWORD_PTR)dev;
devType = str_dup_upper(dev);
if (tmp) *tmp = ' ';
dwFlags |= MCI_OPEN_TYPE;
tmp2 = HeapAlloc(GetProcessHeap(), 0, (tmp - devAlias + 1) * sizeof(WCHAR) );
memcpy( tmp2, devAlias, (tmp - devAlias) * sizeof(WCHAR) );
tmp2[tmp - devAlias] = 0;
-- data[4] = (DWORD)tmp2;
++ data[4] = (DWORD_PTR)tmp2;
/* should be done in regular options parsing */
/* dwFlags |= MCI_OPEN_ALIAS; */
++ } else if (dev == 0) {
++ /* "open new" requires alias */
++ dwRet = MCIERR_NEW_REQUIRES_ALIAS;
++ goto errCleanUp;
}
dwRet = MCI_LoadMciDriver(devType, &wmd);
goto errCleanUp;
}
-- /* set up call back */
-- if (hwndCallback != 0) {
-- dwFlags |= MCI_NOTIFY;
- data[0] = (DWORD_PTR)hwndCallback;
- data[0] = (DWORD)hwndCallback;
-- }
--
/* set return information */
switch (retType = MCI_GetReturnType(lpCmd)) {
case 0: offset = 1; break;
{
TRACE("(%08x)!\n", uTable);
-- return MCI_DeleteCommandTable(uTable, FALSE);
-- }
--
-- /**************************************************************************
-- * MCI_SendCommandFrom32 [internal]
-- */
- DWORD MCI_SendCommandFrom32(MCIDEVICEID 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);
--
-- if (wmd) {
-- if (wmd->bIs32) {
-- dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
-- } else if (pFnMciMapMsg32WTo16) {
-- WINMM_MapType res;
--
-- switch (res = pFnMciMapMsg32WTo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
-- case WINMM_MAP_MSGERROR:
-- TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
-- dwRet = MCIERR_DRIVER_INTERNAL;
-- break;
-- case WINMM_MAP_NOMEM:
-- TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg));
-- dwRet = MCIERR_OUT_OF_MEMORY;
-- break;
-- case WINMM_MAP_OK:
-- case WINMM_MAP_OKMEM:
-- dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
-- if (res == WINMM_MAP_OKMEM)
-- pFnMciUnMapMsg32WTo16(wmd->wType, wMsg, dwParam1, dwParam2);
-- break;
-- }
-- }
-- }
-- return dwRet;
-- }
--
-- /**************************************************************************
-- * MCI_SendCommandFrom16 [internal]
-- */
- DWORD MCI_SendCommandFrom16(MCIDEVICEID 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);
--
-- if (wmd) {
-- dwRet = MCIERR_INVALID_DEVICE_ID;
--
-- if (wmd->bIs32 && pFnMciMapMsg16To32W) {
-- WINMM_MapType res;
++ if (uTable >= MAX_MCICMDTABLE || !S_MciCmdTable[uTable].lpTable)
++ return FALSE;
-- switch (res = pFnMciMapMsg16To32W(wmd->wType, wMsg, dwParam1, &dwParam2)) {
-- case WINMM_MAP_MSGERROR:
-- TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
-- dwRet = MCIERR_DRIVER_INTERNAL;
-- break;
-- case WINMM_MAP_NOMEM:
-- TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg));
-- dwRet = MCIERR_OUT_OF_MEMORY;
-- break;
-- case WINMM_MAP_OK:
-- case WINMM_MAP_OKMEM:
-- dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
-- if (res == WINMM_MAP_OKMEM)
-- pFnMciUnMapMsg16To32W(wmd->wType, wMsg, dwParam1, dwParam2);
-- break;
-- }
-- } else {
-- dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
-- }
-- }
-- return dwRet;
++ FreeResource(S_MciCmdTable[uTable].hMem);
++ S_MciCmdTable[uTable].hMem = NULL;
++ S_MciCmdTable[uTable].lpTable = NULL;
++ HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTable].aVerbs);
++ S_MciCmdTable[uTable].aVerbs = 0;
++ S_MciCmdTable[uTable].nVerbs = 0;
++ return TRUE;
}
/**************************************************************************
if (dwParam & MCI_OPEN_TYPE) {
if (dwParam & MCI_OPEN_TYPE_ID) {
- WORD uDevType = LOWORD((DWORD_PTR)lpParms->lpstrDeviceType);
- WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
++ WORD uDevType = LOWORD(lpParms->lpstrDeviceType);
if (uDevType < MCI_DEVTYPE_FIRST ||
uDevType > MCI_DEVTYPE_LAST ||
LPWINE_MCIDRIVER wmd;
HKEY hKey;
-- if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
++ if (lpParms == NULL || lpParms->lpstrReturn == NULL)
++ return MCIERR_NULL_PARAMETER_BLOCK;
-- TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
- uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
++ TRACE("(%08x, %08X, %p[num=%d, wDevTyp=%u])\n",
+ uDevID, dwFlags, lpParms, lpParms->dwNumber, lpParms->wDeviceType);
switch (dwFlags & ~MCI_SYSINFO_OPEN) {
case MCI_SYSINFO_QUANTITY:
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);
+ }
+
- UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
- DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
++ /**************************************************************************
++ * mixerOpen [WINMM.@]
++ */
++ UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
++ DWORD_PTR dwInstance, DWORD fdwOpen)
{
HANDLE hMix;
LPWINE_MLD wmld;
return dwRet;
}
-- /**************************************************************************
-- * mixerOpen [WINMM.@]
-- */
- MMRESULT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
- UINT 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.@]
*/
return dwRet;
}
-- /**************************************************************************
-- * midiOutOpen [WINMM.@]
-- */
- MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT_PTR uDeviceID,
- UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
-- DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
-- {
-- return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
-- }
--
/**************************************************************************
* midiOutClose [WINMM.@]
*/
return dwRet;
}
-- /**************************************************************************
-- * midiInOpen [WINMM.@]
-- */
- MMRESULT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT_PTR uDeviceID,
- UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
-- DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
-- {
-- return MIDI_InOpen(lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
-- }
--
/**************************************************************************
* midiInClose [WINMM.@]
*/
#define DCB_TYPEMASK 0x0007
#define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */
- BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, UINT uFlags, HDRVR hDev,
- UINT wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
- BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
- UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
++ BOOL APIENTRY DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
++ DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
typedef void (*LPTASKCALLBACK)(DWORD dwInst);
#define TASKERR_NOTASKSUPPORT 1
#define TASKERR_OUTOFMEMORY 2
MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK, HANDLE*, DWORD);
-- void WINAPI mmTaskBlock(HANDLE);
- BOOL WINAPI mmTaskSignal(HANDLE);
++ void WINAPI mmTaskBlock(DWORD);
+ BOOL WINAPI mmTaskSignal(DWORD);
void WINAPI mmTaskYield(void);
- HANDLE WINAPI mmGetCurrentTask(void);
+ DWORD WINAPI mmGetCurrentTask(void);
#define WAVE_DIRECTSOUND 0x0080
VOID
NTAPI
- KdpSetContextState(IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange,
-KdpSetContextState(IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange,
-- IN PCONTEXT Context)
++KdpGetStateChange(IN PDBGKD_MANIPULATE_STATE64 State,
++ IN PCONTEXT Context)
{
-- UNIMPLEMENTED;
-- while (TRUE);
++ PKPRCB Prcb;
++ ULONG i;
++
++ /* Check for success */
++ if (NT_SUCCESS(State->u.Continue2.ContinueStatus))
++ {
++ /* Check if we're tracing */
++ if (State->u.Continue2.ControlSet.TraceFlag)
++ {
++ /* Enable TF */
++ Context->EFlags |= EFLAGS_TF;
++ }
++ else
++ {
++ /* Remove it */
++ Context->EFlags &= ~EFLAGS_TF;
++ }
++
++ /* Loop all processors */
++ for (i = 0; i < KeNumberProcessors; i++)
++ {
++ /* Get the PRCB and update DR7 and DR6 */
++ Prcb = KiProcessorBlock[i];
++ Prcb->ProcessorState.SpecialRegisters.KernelDr7 =
++ State->u.Continue2.ControlSet.Dr7;
++ Prcb->ProcessorState.SpecialRegisters.KernelDr6 = 0;
++ }
++
++ /* Check if we have new symbol information */
++ if (State->u.Continue2.ControlSet.CurrentSymbolStart != 1)
++ {
++ /* Update it */
++ KdpCurrentSymbolStart =
++ State->u.Continue2.ControlSet.CurrentSymbolStart;
++ KdpCurrentSymbolEnd= State->u.Continue2.ControlSet.CurrentSymbolEnd;
++ }
++ }
}
VOID
NTAPI
- KdpSetContextState(IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange,
--KdpSysGetVersion(IN PDBGKD_GET_VERSION64 Version)
+++KdpSetContextState(IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange,
++ IN PCONTEXT Context)
{
-- UNIMPLEMENTED;
-- while (TRUE);
++ PKPRCB Prcb = KeGetCurrentPrcb();
++
++ /* Copy i386 specific debug registers */
++ WaitStateChange->ControlReport.Dr6 = Prcb->ProcessorState.SpecialRegisters.
++ KernelDr6;
++ WaitStateChange->ControlReport.Dr7 = Prcb->ProcessorState.SpecialRegisters.
++ KernelDr7;
++
++ /* Copy i386 specific segments */
++ WaitStateChange->ControlReport.SegCs = (USHORT)Context->SegCs;
++ WaitStateChange->ControlReport.SegDs = (USHORT)Context->SegDs;
++ WaitStateChange->ControlReport.SegEs = (USHORT)Context->SegEs;
++ WaitStateChange->ControlReport.SegFs = (USHORT)Context->SegFs;
++
++ /* Copy EFlags */
++ WaitStateChange->ControlReport.EFlags = Context->EFlags;
++
++ /* Set Report Flags */
++ WaitStateChange->ControlReport.ReportFlags = REPORT_INCLUDES_SEGS;
++ if (WaitStateChange->ControlReport.SegCs == KGDT_64_R0_CODE)
++ {
++ WaitStateChange->ControlReport.ReportFlags |= REPORT_STANDARD_CS;
++ }
}
NTSTATUS
NTAPI
KdpSetCommonState(IN ULONG NewState,
IN PCONTEXT Context,
- OUT PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange)
- IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange)
++ IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange)
{
USHORT InstructionCount;
BOOLEAN HadBreakpoints;
KdpSetContextState(&WaitStateChange, Context);
/* Setup the actual header to send to KD */
- Header.Length = sizeof(DBGKD_WAIT_STATE_CHANGE64) - sizeof(CONTEXT);
- Header.Length = sizeof(DBGKD_WAIT_STATE_CHANGE64);
++ Header.Length = sizeof(DBGKD_ANY_WAIT_STATE_CHANGE);
Header.Buffer = (PCHAR)&WaitStateChange;
/* Setup the trace data */