diff --git a/dlls/winmm/lolvldrv.c b/dlls/winmm/lolvldrv.c index ebc276db4dd..d17ed45bb3e 100644 --- a/dlls/winmm/lolvldrv.c +++ b/dlls/winmm/lolvldrv.c @@ -31,31 +31,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(mmsys); -typedef DWORD (CALLBACK *WINEMM_msgFunc16)(UINT16, WORD, DWORD, DWORD, DWORD); -typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT , UINT, DWORD, DWORD, DWORD); - -/* for each loaded driver and each known type of driver, this structure contains - * the information needed to access it - */ -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_msgFunc16 fnMessage16; - } u; -} WINE_MM_DRIVER_PART; - -/* each low-level .drv will be associated with an instance of this structure */ -typedef struct tagWINE_MM_DRIVER { - HDRVR hDriver; - LPSTR drvname; /* name of the driver */ - BOOL bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */ - bIsMapper : 1; /* TRUE if mapper */ - WINE_MM_DRIVER_PART parts[MMDRV_MAX];/* Information for all known types */ -} WINE_MM_DRIVER, *LPWINE_MM_DRIVER; - -typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +extern WORD CALLBACK MMDRV_CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG); /* each known type of driver has an instance of this structure */ typedef struct tagWINE_LLTYPE { @@ -78,44 +54,13 @@ static WINE_MM_DRIVER MMDrvs[3]; static LPWINE_MLD MM_MLDrvs[40]; #define MAX_MM_MLDRVS (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) -/* ### start build ### */ -extern WORD CALLBACK MMDRV_CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG); -/* ### stop build ### */ - -/************************************************************************** - * MMDRV_GetDescription16 [internal] +/****************************************************************** + * MMDRV_Is32 + * */ -static BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen) +BOOL MMDRV_Is32(unsigned int idx) { - OFSTRUCT ofs; - HFILE hFile; - WORD w; - DWORD dw; - BOOL ret = FALSE; - - if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) { - ERR("Can't open file %s (builtin driver ?)\n", fname); - return FALSE; - } - -#define E(_x) do {TRACE _x;goto theEnd;} while(0) - - if (_lread(hFile, &w, 2) != 2) E(("Can't read sig\n")); - if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w)); - if (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n")); - if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n")); - if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %lu\n", dw+0x2C)); - if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n")); - if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %lu\n", dw)); - if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n")); - buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1); - if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen)); - buf[buflen] = '\0'; - ret = TRUE; - TRACE("Got '%s' [%d]\n", buf, buflen); -theEnd: - CloseHandle(hFile); - return ret; + return MMDrvs[idx].bIs32; } /************************************************************************** @@ -179,1692 +124,6 @@ theEnd: return ret; } -/************************************************************************** - * MMDRV_Callback [internal] - */ -static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2) -{ - TRACE("CB (*%08lx)(%08x %08x %08lx %08lx %08lx\n", - mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2); - - if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION) { - /* 16 bit func, call it */ - TRACE("Function (16 bit) !\n"); - MMDRV_CallTo16_word_wwlll((FARPROC16)mld->dwCallback, HDRVR_16(hDev), uMsg, - mld->dwClientInstance, dwParam1, dwParam2); - } else { - DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg, - mld->dwClientInstance, dwParam1, dwParam2); - } -} - -/* ================================= - * A U X M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_Aux_Map16To32A [internal] - */ -static WINMM_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_UnMap16To32A [internal] - */ -static WINMM_MapType MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_Map32ATo16 [internal] - */ -static WINMM_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_UnMap32ATo16 [internal] - */ -static WINMM_MapType MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ -#if 0 - case AUXDM_GETDEVCAPS: - lpCaps->wMid = ac16.wMid; - lpCaps->wPid = ac16.wPid; - lpCaps->vDriverVersion = ac16.vDriverVersion; - strcpy(lpCaps->szPname, ac16.szPname); - lpCaps->wTechnology = ac16.wTechnology; - lpCaps->dwSupport = ac16.dwSupport; -#endif - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_Callback [internal] - */ -static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - FIXME("NIY\n"); - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * M I X E R M A P P E R S - * ================================= */ - -/************************************************************************** - * xMMDRV_Mixer_Map16To32A [internal] - */ -static WINMM_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_UnMap16To32A [internal] - */ -static WINMM_MapType MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ -#if 0 - MIXERCAPSA micA; - UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); - - if (ret == MMSYSERR_NOERROR) { - mixcaps->wMid = micA.wMid; - mixcaps->wPid = micA.wPid; - mixcaps->vDriverVersion = micA.vDriverVersion; - strcpy(mixcaps->szPname, micA.szPname); - mixcaps->fdwSupport = micA.fdwSupport; - mixcaps->cDestinations = micA.cDestinations; - } - return ret; -#endif - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_Map32ATo16 [internal] - */ -static WINMM_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_UnMap32ATo16 [internal] - */ -static WINMM_MapType MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_Callback [internal] - */ -static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - FIXME("NIY\n"); - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * M I D I I N M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_MidiIn_Map16To32A [internal] - */ -static WINMM_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_UnMap16To32A [internal] - */ -static WINMM_MapType MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_Map32ATo16 [internal] - */ -static WINMM_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_UnMap32ATo16 [internal] - */ -static WINMM_MapType MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_Callback [internal] - */ -static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - switch (uMsg) { - case MIM_OPEN: - case MIM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - - case MIM_DATA: - case MIM_MOREDATA: - case MIM_ERROR: - /* dwParam1 & dwParam2 are are data, nothing to do */ - break; - case MIM_LONGDATA: - case MIM_LONGERROR: - /* dwParam1 points to a MidiHdr, work to be done !!! */ - if (mld->bFrom32 && !MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 32 => 16 */ - LPMIDIHDR mh16 = MapSL(dwParam1); - LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR)); - - dwParam1 = (DWORD)mh32; - mh32->dwFlags = mh16->dwFlags; - mh32->dwBytesRecorded = mh16->dwBytesRecorded; - if (mh32->reserved >= sizeof(MIDIHDR)) - mh32->dwOffset = mh16->dwOffset; - } else if (!mld->bFrom32 && MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 16 => 32 */ - LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR mh16 = MapSL(segmh16); - - dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - if (mh16->reserved >= sizeof(MIDIHDR)) - mh16->dwOffset = mh32->dwOffset; - } - /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ - break; - /* case MOM_POSITIONCB: */ - default: - ERR("Unknown msg %u\n", uMsg); - } - - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * M I D I O U T M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_MidiOut_Map16To32A [internal] - */ -static WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case MODM_GETNUMDEVS: - case MODM_DATA: - case MODM_RESET: - case MODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case MODM_OPEN: - case MODM_CLOSE: - case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - - case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSA moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSA)); - LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); - - if (moc32) { - *(LPMIDIOUTCAPS16*)moc32 = moc16; - moc32 = (LPMIDIOUTCAPSA)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); - *lpParam1 = (DWORD)moc32; - *lpParam2 = sizeof(MIDIOUTCAPSA); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case MODM_PREPARE: - { - LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); - LPMIDIHDR mh16 = MapSL(*lpParam1); - - if (mh32) { - *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; - mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); - mh32->lpData = MapSL((SEGPTR)mh16->lpData); - mh32->dwBufferLength = mh16->dwBufferLength; - mh32->dwBytesRecorded = mh16->dwBytesRecorded; - mh32->dwUser = mh16->dwUser; - mh32->dwFlags = mh16->dwFlags; - /* FIXME: nothing on mh32->lpNext */ - /* could link the mh32->lpNext at this level for memory house keeping */ - mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0; - mh16->lpNext = mh32; /* for reuse in unprepare and write */ - /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */ - mh16->reserved = *lpParam2; - *lpParam1 = (DWORD)mh32; - *lpParam2 = sizeof(MIDIHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case MODM_UNPREPARE: - case MODM_LONGDATA: - { - LPMIDIHDR mh16 = MapSL(*lpParam1); - LPMIDIHDR mh32 = (LPMIDIHDR)mh16->lpNext; - - *lpParam1 = (DWORD)mh32; - *lpParam2 = sizeof(MIDIHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - mh32->dwBufferLength, mh16->dwBufferLength); - } else - mh32->dwBufferLength = mh16->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - - case MODM_CACHEPATCHES: - case MODM_CACHEDRUMPATCHES: - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_MidiOut_UnMap16To32A [internal] - */ -static WINMM_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case MODM_GETNUMDEVS: - case MODM_DATA: - case MODM_RESET: - case MODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case MODM_OPEN: - case MODM_CLOSE: - case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - - case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)(*lpParam1); - LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - - moc16->wMid = moc32->wMid; - moc16->wPid = moc32->wPid; - moc16->vDriverVersion = moc32->vDriverVersion; - strcpy(moc16->szPname, moc32->szPname); - moc16->wTechnology = moc32->wTechnology; - moc16->wVoices = moc32->wVoices; - moc16->wNotes = moc32->wNotes; - moc16->wChannelMask = moc32->wChannelMask; - moc16->dwSupport = moc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - ret = WINMM_MAP_OK; - } - break; - case MODM_PREPARE: - case MODM_UNPREPARE: - case MODM_LONGDATA: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); - LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); - - assert(mh16->lpNext == mh32); - mh16->dwBufferLength = mh32->dwBufferLength; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - mh16->dwUser = mh32->dwUser; - mh16->dwFlags = mh32->dwFlags; - if (mh16->reserved >= sizeof(MIDIHDR)) - mh16->dwOffset = mh32->dwOffset; - - if (wMsg == MODM_UNPREPARE) { - HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); - mh16->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - - case MODM_CACHEPATCHES: - case MODM_CACHEDRUMPATCHES: - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_MidiOut_Map32ATo16 [internal] - */ -static WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case MODM_CLOSE: - case MODM_GETNUMDEVS: - case MODM_DATA: - case MODM_RESET: - case MODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)*lpParam1; - LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSA)+sizeof(MIDIOUTCAPS16)); - - if (ptr) { - *(LPMIDIOUTCAPSA*)ptr = moc32; - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSA); - *lpParam2 = sizeof(MIDIOUTCAPS16); - } - break; - case MODM_PREPARE: - { - LPMIDIHDR mh32 = (LPMIDIHDR)*lpParam1; - LPMIDIHDR mh16; - LPVOID ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength); - - if (ptr) { - *(LPMIDIHDR*)ptr = mh32; - mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR)); - *lpParam1 = MapLS(mh16); - mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR); - /* data will be copied on WODM_WRITE */ - mh16->dwBufferLength = mh32->dwBufferLength; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - mh16->dwUser = mh32->dwUser; - mh16->dwFlags = mh32->dwFlags; - /* FIXME: nothing on mh32->lpNext */ - /* could link the mh32->lpNext at this level for memory house keeping */ - mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0; - - mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */ - mh32->reserved = *lpParam2; - - TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", - *lpParam1, (DWORD)mh16->lpData, - mh32->dwBufferLength, (DWORD)mh32->lpData); - *lpParam2 = sizeof(MIDIHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case MODM_UNPREPARE: - case MODM_LONGDATA: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); - LPMIDIHDR mh16 = (LPMIDIHDR)mh32->lpNext; - LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR); - - assert(*(LPMIDIHDR*)ptr == mh32); - - if (wMsg == MODM_LONGDATA) - memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength); - - *lpParam1 = MapLS(mh16); - *lpParam2 = sizeof(MIDIHDR); - TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", - *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData); - - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - mh16->dwBufferLength, mh32->dwBufferLength); - } else - mh16->dwBufferLength = mh32->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case MODM_OPEN: - { - LPMIDIOPENDESC mod32 = (LPMIDIOPENDESC)*lpParam1; - LPVOID ptr; - LPMIDIOPENDESC16 mod16; - - /* allocated data are mapped as follows: - LPMIDIOPENDESC ptr to orig lParam1 - DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance - DWORD dwUser passed to driver - MIDIOPENDESC16 mod16: openDesc passed to driver - MIDIOPENSTRMID cIds - */ - ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) + - mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0); - - if (ptr) { - SEGPTR segptr = MapLS(ptr); - *(LPMIDIOPENDESC*)ptr = mod32; - *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser; - mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD)); - - mod16->hMidi = HMIDI_16(mod32->hMidi); - mod16->dwCallback = mod32->dwCallback; - mod16->dwInstance = mod32->dwInstance; - mod16->dnDevNode = mod32->dnDevNode; - mod16->cIds = mod32->cIds; - memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID)); - - *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD); - *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case MODM_GETVOLUME: - case MODM_CACHEPATCHES: - case MODM_CACHEDRUMPATCHES: - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_MidiOut_UnMap32ATo16 [internal] - */ -static WINMM_MapType MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case MODM_CLOSE: - case MODM_GETNUMDEVS: - case MODM_DATA: - case MODM_RESET: - case MODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSA); - LPMIDIOUTCAPSA moc32 = *(LPMIDIOUTCAPSA*)ptr; - - moc32->wMid = moc16->wMid; - moc32->wPid = moc16->wPid; - moc32->vDriverVersion = moc16->vDriverVersion; - strcpy(moc32->szPname, moc16->szPname); - moc32->wTechnology = moc16->wTechnology; - moc32->wVoices = moc16->wVoices; - moc32->wNotes = moc16->wNotes; - moc32->wChannelMask = moc16->wChannelMask; - moc32->dwSupport = moc16->dwSupport; - UnMapLS( *lpParam1 ); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case MODM_PREPARE: - case MODM_UNPREPARE: - case MODM_LONGDATA: - { - LPMIDIHDR mh16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR); - LPMIDIHDR mh32 = *(LPMIDIHDR*)ptr; - - assert(mh32->lpNext == (LPMIDIHDR)mh16); - UnMapLS( *lpParam1 ); - mh32->dwBytesRecorded = mh16->dwBytesRecorded; - mh32->dwUser = mh16->dwUser; - mh32->dwFlags = mh16->dwFlags; - - if (wMsg == MODM_UNPREPARE) { - HeapFree( GetProcessHeap(), 0, ptr ); - mh32->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - case MODM_OPEN: - { - LPMIDIOPENDESC16 mod16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD); - UnMapLS( *lpParam1 ); - **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD)); - - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case MODM_GETVOLUME: - case MODM_CACHEPATCHES: - case MODM_CACHEDRUMPATCHES: - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_MidiOut_Callback [internal] - */ -static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - switch (uMsg) { - case MOM_OPEN: - case MOM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; - case MOM_DONE: - if (mld->bFrom32 && !MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 32 => 16 */ - LPMIDIHDR mh16 = MapSL(dwParam1); - LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR)); - - dwParam1 = (DWORD)mh32; - mh32->dwFlags = mh16->dwFlags; - mh32->dwOffset = mh16->dwOffset; - if (mh32->reserved >= sizeof(MIDIHDR)) - mh32->dwOffset = mh16->dwOffset; - } else if (!mld->bFrom32 && MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 16 => 32 */ - LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR mh16 = MapSL(segmh16); - - dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - if (mh16->reserved >= sizeof(MIDIHDR)) - mh16->dwOffset = mh32->dwOffset; - } - /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ - break; - /* case MOM_POSITIONCB: */ - default: - ERR("Unknown msg %u\n", uMsg); - } - - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * W A V E I N M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_WaveIn_Map16To32A [internal] - */ -static WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case WIDM_GETNUMDEVS: - case WIDM_RESET: - case WIDM_START: - case WIDM_STOP: - ret = WINMM_MAP_OK; - break; - case WIDM_OPEN: - case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSA wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSA)); - LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); - - if (wic32) { - *(LPWAVEINCAPS16*)wic32 = wic16; - wic32 = (LPWAVEINCAPSA)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); - *lpParam1 = (DWORD)wic32; - *lpParam2 = sizeof(WAVEINCAPSA); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_ADDBUFFER: - case WIDM_UNPREPARE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case WIDM_MAPPER_STATUS: - /* just a single DWORD */ - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = WINMM_MAP_OK; - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveIn_UnMap16To32A [internal] - */ -static WINMM_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case WIDM_GETNUMDEVS: - case WIDM_RESET: - case WIDM_START: - case WIDM_STOP: - case WIDM_MAPPER_STATUS: - ret = WINMM_MAP_OK; - break; - case WIDM_OPEN: - case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)(*lpParam1); - LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - - wic16->wMid = wic32->wMid; - wic16->wPid = wic32->wPid; - wic16->vDriverVersion = wic32->vDriverVersion; - strcpy(wic16->szPname, wic32->szPname); - wic16->dwFormats = wic32->dwFormats; - wic16->wChannels = wic32->wChannels; - HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - ret = WINMM_MAP_OK; - } - break; - case WIDM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = WINMM_MAP_OK; - } - break; - case WIDM_ADDBUFFER: - case WIDM_PREPARE: - case WIDM_UNPREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwBufferLength = wh32->dwBufferLength; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwUser = wh32->dwUser; - wh16->dwFlags = wh32->dwFlags; - wh16->dwLoops = wh32->dwLoops; - - if (wMsg == WIDM_UNPREPARE) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveIn_Map32ATo16 [internal] - */ -static WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case WIDM_CLOSE: - case WIDM_GETNUMDEVS: - case WIDM_RESET: - case WIDM_START: - case WIDM_STOP: - ret = WINMM_MAP_OK; - break; - - case WIDM_OPEN: - { - LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1; - int sz = sizeof(WAVEFORMATEX); - LPVOID ptr; - LPWAVEOPENDESC16 wod16; - - /* allocated data are mapped as follows: - LPWAVEOPENDESC ptr to orig lParam1 - DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance - DWORD dwUser passed to driver - WAVEOPENDESC16 wod16: openDesc passed to driver - WAVEFORMATEX openDesc->lpFormat passed to driver - xxx extra bytes to WAVEFORMATEX - */ - if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) { - TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag); - sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize; - } - - ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz); - - if (ptr) { - SEGPTR seg_ptr = MapLS( ptr ); - *(LPWAVEOPENDESC*)ptr = wod32; - *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser; - wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD)); - - wod16->hWave = HWAVE_16(wod32->hWave); - wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16)); - memcpy(wod16 + 1, wod32->lpFormat, sz); - - wod16->dwCallback = wod32->dwCallback; - wod16->dwInstance = wod32->dwInstance; - wod16->uMappedDeviceID = wod32->uMappedDeviceID; - wod16->dnDevNode = wod32->dnDevNode; - - *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD); - *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_PREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1; - LPWAVEHDR wh16; - LPVOID ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength); - - if (ptr) { - SEGPTR seg_ptr = MapLS( ptr ); - *(LPWAVEHDR*)ptr = wh32; - wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR)); - wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR); - /* data will be copied on WODM_WRITE */ - wh16->dwBufferLength = wh32->dwBufferLength; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwUser = wh32->dwUser; - wh16->dwFlags = wh32->dwFlags; - wh16->dwLoops = wh32->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh32->lpNext = wh16; /* for reuse in unprepare and write */ - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_ADDBUFFER: - case WIDM_UNPREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = wh32->lpNext; - LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); - SEGPTR seg_ptr = MapLS( ptr ); - - assert(*(LPWAVEHDR*)ptr == wh32); - - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - - if (wMsg == WIDM_ADDBUFFER) - memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); - - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - wh16->dwBufferLength, wh32->dwBufferLength); - } else - wh16->dwBufferLength = wh32->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)*lpParam1; - LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSA) + sizeof(WAVEINCAPS16)); - - if (ptr) { - *(LPWAVEINCAPSA*)ptr = wic32; - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSA); - *lpParam2 = sizeof(WAVEINCAPS16); - } - break; - case WIDM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)*lpParam1; - LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16)); - LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME)); - - if (ptr) { - *(LPMMTIME*)ptr = mmt32; - mmt16->wType = mmt32->wType; - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME); - *lpParam2 = sizeof(MMTIME16); - } - break; - case DRVM_MAPPER_STATUS: - { - LPDWORD p32 = (LPDWORD)*lpParam2; - *lpParam2 = MapLS(p32); - ret = WINMM_MAP_OKMEM; - } - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveIn_UnMap32ATo16 [internal] - */ -static WINMM_MapType MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case WIDM_CLOSE: - case WIDM_GETNUMDEVS: - case WIDM_RESET: - case WIDM_START: - case WIDM_STOP: - ret = WINMM_MAP_OK; - break; - - case WIDM_OPEN: - { - LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD); - LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr; - - UnMapLS( *lpParam1 ); - wod32->uMappedDeviceID = wod16->uMappedDeviceID; - **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD)); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - - case WIDM_ADDBUFFER: - case WIDM_PREPARE: - case WIDM_UNPREPARE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); - LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr; - - assert(wh32->lpNext == wh16); - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - UnMapLS( *lpParam1 ); - - if (wMsg == WIDM_UNPREPARE) { - HeapFree( GetProcessHeap(), 0, ptr ); - wh32->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - case WIDM_GETDEVCAPS: - { - LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)wic16 - sizeof(LPWAVEINCAPSA); - LPWAVEINCAPSA wic32 = *(LPWAVEINCAPSA*)ptr; - - wic32->wMid = wic16->wMid; - wic32->wPid = wic16->wPid; - wic32->vDriverVersion = wic16->vDriverVersion; - strcpy(wic32->szPname, wic16->szPname); - wic32->dwFormats = wic16->dwFormats; - wic32->wChannels = wic16->wChannels; - UnMapLS( *lpParam1 ); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case WIDM_GETPOS: - { - LPMMTIME16 mmt16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME); - LPMMTIME mmt32 = *(LPMMTIME*)ptr; - - MMSYSTEM_MMTIME16to32(mmt32, mmt16); - UnMapLS( *lpParam1 ); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case DRVM_MAPPER_STATUS: - { - UnMapLS( *lpParam2 ); - ret = WINMM_MAP_OK; - } - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveIn_Callback [internal] - */ -static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - switch (uMsg) { - case WIM_OPEN: - case WIM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; - case WIM_DATA: - if (mld->bFrom32 && !MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 32 => 16 */ - LPWAVEHDR wh16 = MapSL(dwParam1); - LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR)); - - dwParam1 = (DWORD)wh32; - wh32->dwFlags = wh16->dwFlags; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - } else if (!mld->bFrom32 && MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - } - /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ - break; - default: - ERR("Unknown msg %u\n", uMsg); - } - - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * W A V E O U T M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_WaveOut_Map16To32A [internal] - */ -static WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - /* nothing to do */ - case WODM_BREAKLOOP: - case WODM_CLOSE: - case WODM_GETNUMDEVS: - case WODM_PAUSE: - case WODM_RESET: - case WODM_RESTART: - case WODM_SETPITCH: - case WODM_SETPLAYBACKRATE: - case WODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case WODM_GETPITCH: - case WODM_GETPLAYBACKRATE: - case WODM_GETVOLUME: - case WODM_OPEN: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - - case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSA woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSA)); - LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); - - if (woc32) { - *(LPWAVEOUTCAPS16*)woc32 = woc16; - woc32 = (LPWAVEOUTCAPSA)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); - *lpParam1 = (DWORD)woc32; - *lpParam2 = sizeof(WAVEOUTCAPSA); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_UNPREPARE: - case WODM_WRITE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case WODM_MAPPER_STATUS: - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = WINMM_MAP_OK; - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveOut_UnMap16To32A [internal] - */ -static WINMM_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - /* nothing to do */ - case WODM_BREAKLOOP: - case WODM_CLOSE: - case WODM_GETNUMDEVS: - case WODM_PAUSE: - case WODM_RESET: - case WODM_RESTART: - case WODM_SETPITCH: - case WODM_SETPLAYBACKRATE: - case WODM_SETVOLUME: - case WODM_MAPPER_STATUS: - ret = WINMM_MAP_OK; - break; - - case WODM_GETPITCH: - case WODM_GETPLAYBACKRATE: - case WODM_GETVOLUME: - case WODM_OPEN: - FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); - break; - - case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)(*lpParam1); - LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - - woc16->wMid = woc32->wMid; - woc16->wPid = woc32->wPid; - woc16->vDriverVersion = woc32->vDriverVersion; - strcpy(woc16->szPname, woc32->szPname); - woc16->dwFormats = woc32->dwFormats; - woc16->wChannels = woc32->wChannels; - woc16->dwSupport = woc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - ret = WINMM_MAP_OK; - } - break; - case WODM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = WINMM_MAP_OK; - } - break; - case WODM_PREPARE: - case WODM_UNPREPARE: - case WODM_WRITE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwBufferLength = wh32->dwBufferLength; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwUser = wh32->dwUser; - wh16->dwFlags = wh32->dwFlags; - wh16->dwLoops = wh32->dwLoops; - - if (wMsg == WODM_UNPREPARE) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveOut_Map32ATo16 [internal] - */ -static WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret; - - switch (wMsg) { - /* nothing to do */ - case WODM_BREAKLOOP: - case WODM_CLOSE: - case WODM_GETNUMDEVS: - case WODM_PAUSE: - case WODM_RESET: - case WODM_RESTART: - case WODM_SETPITCH: - case WODM_SETPLAYBACKRATE: - case WODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)*lpParam1; - LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPWAVEOUTCAPSA) + sizeof(WAVEOUTCAPS16)); - - if (ptr) { - *(LPWAVEOUTCAPSA*)ptr = woc32; - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSA); - *lpParam2 = sizeof(WAVEOUTCAPS16); - } - break; - case WODM_GETPITCH: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - case WODM_GETPLAYBACKRATE: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - case WODM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)*lpParam1; - LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16)); - LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME)); - - if (ptr) { - *(LPMMTIME*)ptr = mmt32; - mmt16->wType = mmt32->wType; - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME); - *lpParam2 = sizeof(MMTIME16); - } - break; - case WODM_GETVOLUME: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - case WODM_OPEN: - { - LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1; - int sz = sizeof(WAVEFORMATEX); - LPVOID ptr; - LPWAVEOPENDESC16 wod16; - - /* allocated data are mapped as follows: - LPWAVEOPENDESC ptr to orig lParam1 - DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance - DWORD dwUser passed to driver - WAVEOPENDESC16 wod16: openDesc passed to driver - WAVEFORMATEX openDesc->lpFormat passed to driver - xxx extra bytes to WAVEFORMATEX - */ - if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) { - TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag); - sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize; - } - - ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz); - - if (ptr) { - SEGPTR seg_ptr = MapLS( ptr ); - *(LPWAVEOPENDESC*)ptr = wod32; - *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser; - wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD)); - - wod16->hWave = HWAVE_16(wod32->hWave); - wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16)); - memcpy(wod16 + 1, wod32->lpFormat, sz); - - wod16->dwCallback = wod32->dwCallback; - wod16->dwInstance = wod32->dwInstance; - wod16->uMappedDeviceID = wod32->uMappedDeviceID; - wod16->dnDevNode = wod32->dnDevNode; - - *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD); - *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_PREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1; - LPWAVEHDR wh16; - LPVOID ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength); - - if (ptr) { - SEGPTR seg_ptr = MapLS( ptr ); - *(LPWAVEHDR*)ptr = wh32; - wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR)); - wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR); - /* data will be copied on WODM_WRITE */ - wh16->dwBufferLength = wh32->dwBufferLength; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwUser = wh32->dwUser; - wh16->dwFlags = wh32->dwFlags; - wh16->dwLoops = wh32->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh32->lpNext = wh16; /* for reuse in unprepare and write */ - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_UNPREPARE: - case WODM_WRITE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = wh32->lpNext; - LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); - SEGPTR seg_ptr = MapLS( ptr ); - - assert(*(LPWAVEHDR*)ptr == wh32); - - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - - if (wMsg == WODM_WRITE) - memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); - - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - wh16->dwBufferLength, wh32->dwBufferLength); - } else - wh16->dwBufferLength = wh32->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case DRVM_MAPPER_STATUS: - { - LPDWORD p32 = (LPDWORD)*lpParam2; - *lpParam2 = MapLS(p32); - ret = WINMM_MAP_OKMEM; - } - break; - default: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveOut_UnMap32ATo16 [internal] - */ -static WINMM_MapType MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret; - - switch (wMsg) { - /* nothing to do */ - case WODM_BREAKLOOP: - case WODM_CLOSE: - case WODM_GETNUMDEVS: - case WODM_PAUSE: - case WODM_RESET: - case WODM_RESTART: - case WODM_SETPITCH: - case WODM_SETPLAYBACKRATE: - case WODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSA); - LPWAVEOUTCAPSA woc32 = *(LPWAVEOUTCAPSA*)ptr; - - woc32->wMid = woc16->wMid; - woc32->wPid = woc16->wPid; - woc32->vDriverVersion = woc16->vDriverVersion; - strcpy(woc32->szPname, woc16->szPname); - woc32->dwFormats = woc16->dwFormats; - woc32->wChannels = woc16->wChannels; - woc32->dwSupport = woc16->dwSupport; - UnMapLS( *lpParam1 ); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case WODM_GETPITCH: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - case WODM_GETPLAYBACKRATE: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - case WODM_GETPOS: - { - LPMMTIME16 mmt16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME); - LPMMTIME mmt32 = *(LPMMTIME*)ptr; - - MMSYSTEM_MMTIME16to32(mmt32, mmt16); - UnMapLS( *lpParam1 ); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case WODM_OPEN: - { - LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD); - LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr; - - wod32->uMappedDeviceID = wod16->uMappedDeviceID; - **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD)); - UnMapLS( *lpParam1 ); - HeapFree( GetProcessHeap(), 0, ptr ); - ret = WINMM_MAP_OK; - } - break; - case WODM_PREPARE: - case WODM_UNPREPARE: - case WODM_WRITE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); - LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr; - - assert(wh32->lpNext == wh16); - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - - UnMapLS( *lpParam1 ); - if (wMsg == WODM_UNPREPARE) { - HeapFree( GetProcessHeap(), 0, ptr ); - wh32->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - case WODM_GETVOLUME: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - case DRVM_MAPPER_STATUS: - { - UnMapLS( *lpParam2 ); - ret = WINMM_MAP_OK; - } - break; - default: - FIXME("NIY: no conversion yet\n"); - ret = WINMM_MAP_MSGERROR; - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveOut_Callback [internal] - */ -static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - switch (uMsg) { - case WOM_OPEN: - case WOM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; - case WOM_DONE: - if (mld->bFrom32 && !MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 32 => 16 */ - LPWAVEHDR wh16 = MapSL(dwParam1); - LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR)); - - dwParam1 = (DWORD)wh32; - wh32->dwFlags = wh16->dwFlags; - } else if (!mld->bFrom32 && MMDrvs[mld->mmdIndex].bIs32) { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - } - /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ - break; - default: - ERR("Unknown msg %u\n", uMsg); - } - - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - #define A(_x,_y) {#_y, _x, \ MMDRV_##_y##_Map16To32A, MMDRV_##_y##_UnMap16To32A, \ MMDRV_##_y##_Map32ATo16, MMDRV_##_y##_UnMap32ATo16, \ diff --git a/dlls/winmm/message16.c b/dlls/winmm/message16.c index e9c7c7b0a81..d077f0b410c 100644 --- a/dlls/winmm/message16.c +++ b/dlls/winmm/message16.c @@ -32,6 +32,1736 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); +/* ### start build ### */ +extern WORD CALLBACK MMDRV_CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG); +/* ### stop build ### */ + +/************************************************************************** + * MMDRV_Callback [internal] + */ +void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2) +{ + TRACE("CB (*%08lx)(%08x %08x %08lx %08lx %08lx\n", + mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2); + + if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION) { + /* 16 bit func, call it */ + TRACE("Function (16 bit) !\n"); + MMDRV_CallTo16_word_wwlll((FARPROC16)mld->dwCallback, HDRVR_16(hDev), uMsg, + mld->dwClientInstance, dwParam1, dwParam2); + } else { + DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg, + mld->dwClientInstance, dwParam1, dwParam2); + } +} + +/* ================================= + * A U X M A P P E R S + * ================================= */ + +/************************************************************************** + * MMDRV_Aux_Map16To32A [internal] + */ +WINMM_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Aux_UnMap16To32A [internal] + */ +WINMM_MapType MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Aux_Map32ATo16 [internal] + */ +WINMM_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Aux_UnMap32ATo16 [internal] + */ +WINMM_MapType MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ +#if 0 + case AUXDM_GETDEVCAPS: + lpCaps->wMid = ac16.wMid; + lpCaps->wPid = ac16.wPid; + lpCaps->vDriverVersion = ac16.vDriverVersion; + strcpy(lpCaps->szPname, ac16.szPname); + lpCaps->wTechnology = ac16.wTechnology; + lpCaps->dwSupport = ac16.dwSupport; +#endif + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Aux_Callback [internal] + */ +void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) +{ + LPWINE_MLD mld = (LPWINE_MLD)dwInstance; + + FIXME("NIY\n"); + MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); +} + +/* ================================= + * M I X E R M A P P E R S + * ================================= */ + +/************************************************************************** + * xMMDRV_Mixer_Map16To32A [internal] + */ +WINMM_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Mixer_UnMap16To32A [internal] + */ +WINMM_MapType MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ +#if 0 + MIXERCAPSA micA; + UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); + + if (ret == MMSYSERR_NOERROR) { + mixcaps->wMid = micA.wMid; + mixcaps->wPid = micA.wPid; + mixcaps->vDriverVersion = micA.vDriverVersion; + strcpy(mixcaps->szPname, micA.szPname); + mixcaps->fdwSupport = micA.fdwSupport; + mixcaps->cDestinations = micA.cDestinations; + } + return ret; +#endif + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Mixer_Map32ATo16 [internal] + */ +WINMM_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Mixer_UnMap32ATo16 [internal] + */ +WINMM_MapType MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_Mixer_Callback [internal] + */ +void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) +{ + LPWINE_MLD mld = (LPWINE_MLD)dwInstance; + + FIXME("NIY\n"); + MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); +} + +/* ================================= + * M I D I I N M A P P E R S + * ================================= */ + +/************************************************************************** + * MMDRV_MidiIn_Map16To32A [internal] + */ +WINMM_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_MidiIn_UnMap16To32A [internal] + */ +WINMM_MapType MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_MidiIn_Map32ATo16 [internal] + */ +WINMM_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_MidiIn_UnMap32ATo16 [internal] + */ +WINMM_MapType MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + return WINMM_MAP_MSGERROR; +} + +/************************************************************************** + * MMDRV_MidiIn_Callback [internal] + */ +void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) +{ + LPWINE_MLD mld = (LPWINE_MLD)dwInstance; + + switch (uMsg) { + case MIM_OPEN: + case MIM_CLOSE: + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + + case MIM_DATA: + case MIM_MOREDATA: + case MIM_ERROR: + /* dwParam1 & dwParam2 are are data, nothing to do */ + break; + case MIM_LONGDATA: + case MIM_LONGERROR: + /* dwParam1 points to a MidiHdr, work to be done !!! */ + if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 32 => 16 */ + LPMIDIHDR mh16 = MapSL(dwParam1); + LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR)); + + dwParam1 = (DWORD)mh32; + mh32->dwFlags = mh16->dwFlags; + mh32->dwBytesRecorded = mh16->dwBytesRecorded; + if (mh32->reserved >= sizeof(MIDIHDR)) + mh32->dwOffset = mh16->dwOffset; + } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 16 => 32 */ + LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1); + SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); + LPMIDIHDR mh16 = MapSL(segmh16); + + dwParam1 = (DWORD)segmh16; + mh16->dwFlags = mh32->dwFlags; + mh16->dwBytesRecorded = mh32->dwBytesRecorded; + if (mh16->reserved >= sizeof(MIDIHDR)) + mh16->dwOffset = mh32->dwOffset; + } + /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ + break; + /* case MOM_POSITIONCB: */ + default: + ERR("Unknown msg %u\n", uMsg); + } + + MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); +} + +/* ================================= + * M I D I O U T M A P P E R S + * ================================= */ + +/************************************************************************** + * MMDRV_MidiOut_Map16To32A [internal] + */ +WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case MODM_GETNUMDEVS: + case MODM_DATA: + case MODM_RESET: + case MODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + + case MODM_OPEN: + case MODM_CLOSE: + case MODM_GETVOLUME: + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; + + case MODM_GETDEVCAPS: + { + LPMIDIOUTCAPSA moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSA)); + LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); + + if (moc32) { + *(LPMIDIOUTCAPS16*)moc32 = moc16; + moc32 = (LPMIDIOUTCAPSA)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); + *lpParam1 = (DWORD)moc32; + *lpParam2 = sizeof(MIDIOUTCAPSA); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case MODM_PREPARE: + { + LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); + LPMIDIHDR mh16 = MapSL(*lpParam1); + + if (mh32) { + *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; + mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); + mh32->lpData = MapSL((SEGPTR)mh16->lpData); + mh32->dwBufferLength = mh16->dwBufferLength; + mh32->dwBytesRecorded = mh16->dwBytesRecorded; + mh32->dwUser = mh16->dwUser; + mh32->dwFlags = mh16->dwFlags; + /* FIXME: nothing on mh32->lpNext */ + /* could link the mh32->lpNext at this level for memory house keeping */ + mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0; + mh16->lpNext = mh32; /* for reuse in unprepare and write */ + /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */ + mh16->reserved = *lpParam2; + *lpParam1 = (DWORD)mh32; + *lpParam2 = sizeof(MIDIHDR); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case MODM_UNPREPARE: + case MODM_LONGDATA: + { + LPMIDIHDR mh16 = MapSL(*lpParam1); + LPMIDIHDR mh32 = (LPMIDIHDR)mh16->lpNext; + + *lpParam1 = (DWORD)mh32; + *lpParam2 = sizeof(MIDIHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { + ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + mh32->dwBufferLength, mh16->dwBufferLength); + } else + mh32->dwBufferLength = mh16->dwBufferLength; + ret = WINMM_MAP_OKMEM; + } + break; + + case MODM_CACHEPATCHES: + case MODM_CACHEDRUMPATCHES: + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_MidiOut_UnMap16To32A [internal] + */ +WINMM_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case MODM_GETNUMDEVS: + case MODM_DATA: + case MODM_RESET: + case MODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + + case MODM_OPEN: + case MODM_CLOSE: + case MODM_GETVOLUME: + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; + + case MODM_GETDEVCAPS: + { + LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)(*lpParam1); + LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); + + moc16->wMid = moc32->wMid; + moc16->wPid = moc32->wPid; + moc16->vDriverVersion = moc32->vDriverVersion; + strcpy(moc16->szPname, moc32->szPname); + moc16->wTechnology = moc32->wTechnology; + moc16->wVoices = moc32->wVoices; + moc16->wNotes = moc32->wNotes; + moc16->wChannelMask = moc32->wChannelMask; + moc16->dwSupport = moc32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); + ret = WINMM_MAP_OK; + } + break; + case MODM_PREPARE: + case MODM_UNPREPARE: + case MODM_LONGDATA: + { + LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); + LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); + + assert(mh16->lpNext == mh32); + mh16->dwBufferLength = mh32->dwBufferLength; + mh16->dwBytesRecorded = mh32->dwBytesRecorded; + mh16->dwUser = mh32->dwUser; + mh16->dwFlags = mh32->dwFlags; + if (mh16->reserved >= sizeof(MIDIHDR)) + mh16->dwOffset = mh32->dwOffset; + + if (wMsg == MODM_UNPREPARE) { + HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); + mh16->lpNext = 0; + } + ret = WINMM_MAP_OK; + } + break; + + case MODM_CACHEPATCHES: + case MODM_CACHEDRUMPATCHES: + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_MidiOut_Map32ATo16 [internal] + */ +WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case MODM_CLOSE: + case MODM_GETNUMDEVS: + case MODM_DATA: + case MODM_RESET: + case MODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + case MODM_GETDEVCAPS: + { + LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)*lpParam1; + LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSA)+sizeof(MIDIOUTCAPS16)); + + if (ptr) { + *(LPMIDIOUTCAPSA*)ptr = moc32; + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSA); + *lpParam2 = sizeof(MIDIOUTCAPS16); + } + break; + case MODM_PREPARE: + { + LPMIDIHDR mh32 = (LPMIDIHDR)*lpParam1; + LPMIDIHDR mh16; + LPVOID ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength); + + if (ptr) { + *(LPMIDIHDR*)ptr = mh32; + mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR)); + *lpParam1 = MapLS(mh16); + mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR); + /* data will be copied on WODM_WRITE */ + mh16->dwBufferLength = mh32->dwBufferLength; + mh16->dwBytesRecorded = mh32->dwBytesRecorded; + mh16->dwUser = mh32->dwUser; + mh16->dwFlags = mh32->dwFlags; + /* FIXME: nothing on mh32->lpNext */ + /* could link the mh32->lpNext at this level for memory house keeping */ + mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0; + + mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */ + mh32->reserved = *lpParam2; + + TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", + *lpParam1, (DWORD)mh16->lpData, + mh32->dwBufferLength, (DWORD)mh32->lpData); + *lpParam2 = sizeof(MIDIHDR); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case MODM_UNPREPARE: + case MODM_LONGDATA: + { + LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); + LPMIDIHDR mh16 = (LPMIDIHDR)mh32->lpNext; + LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR); + + assert(*(LPMIDIHDR*)ptr == mh32); + + if (wMsg == MODM_LONGDATA) + memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength); + + *lpParam1 = MapLS(mh16); + *lpParam2 = sizeof(MIDIHDR); + TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", + *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData); + + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) { + ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + mh16->dwBufferLength, mh32->dwBufferLength); + } else + mh16->dwBufferLength = mh32->dwBufferLength; + ret = WINMM_MAP_OKMEM; + } + break; + case MODM_OPEN: + { + LPMIDIOPENDESC mod32 = (LPMIDIOPENDESC)*lpParam1; + LPVOID ptr; + LPMIDIOPENDESC16 mod16; + + /* allocated data are mapped as follows: + LPMIDIOPENDESC ptr to orig lParam1 + DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance + DWORD dwUser passed to driver + MIDIOPENDESC16 mod16: openDesc passed to driver + MIDIOPENSTRMID cIds + */ + ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) + + mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0); + + if (ptr) { + SEGPTR segptr = MapLS(ptr); + *(LPMIDIOPENDESC*)ptr = mod32; + *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser; + mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD)); + + mod16->hMidi = HMIDI_16(mod32->hMidi); + mod16->dwCallback = mod32->dwCallback; + mod16->dwInstance = mod32->dwInstance; + mod16->dnDevNode = mod32->dnDevNode; + mod16->cIds = mod32->cIds; + memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID)); + + *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD); + *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case MODM_GETVOLUME: + case MODM_CACHEPATCHES: + case MODM_CACHEDRUMPATCHES: + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_MidiOut_UnMap32ATo16 [internal] + */ +WINMM_MapType MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case MODM_CLOSE: + case MODM_GETNUMDEVS: + case MODM_DATA: + case MODM_RESET: + case MODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + case MODM_GETDEVCAPS: + { + LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSA); + LPMIDIOUTCAPSA moc32 = *(LPMIDIOUTCAPSA*)ptr; + + moc32->wMid = moc16->wMid; + moc32->wPid = moc16->wPid; + moc32->vDriverVersion = moc16->vDriverVersion; + strcpy(moc32->szPname, moc16->szPname); + moc32->wTechnology = moc16->wTechnology; + moc32->wVoices = moc16->wVoices; + moc32->wNotes = moc16->wNotes; + moc32->wChannelMask = moc16->wChannelMask; + moc32->dwSupport = moc16->dwSupport; + UnMapLS( *lpParam1 ); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case MODM_PREPARE: + case MODM_UNPREPARE: + case MODM_LONGDATA: + { + LPMIDIHDR mh16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR); + LPMIDIHDR mh32 = *(LPMIDIHDR*)ptr; + + assert(mh32->lpNext == (LPMIDIHDR)mh16); + UnMapLS( *lpParam1 ); + mh32->dwBytesRecorded = mh16->dwBytesRecorded; + mh32->dwUser = mh16->dwUser; + mh32->dwFlags = mh16->dwFlags; + + if (wMsg == MODM_UNPREPARE) { + HeapFree( GetProcessHeap(), 0, ptr ); + mh32->lpNext = 0; + } + ret = WINMM_MAP_OK; + } + break; + case MODM_OPEN: + { + LPMIDIOPENDESC16 mod16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD); + UnMapLS( *lpParam1 ); + **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD)); + + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case MODM_GETVOLUME: + case MODM_CACHEPATCHES: + case MODM_CACHEDRUMPATCHES: + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_MidiOut_Callback [internal] + */ +void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) +{ + LPWINE_MLD mld = (LPWINE_MLD)dwInstance; + + switch (uMsg) { + case MOM_OPEN: + case MOM_CLOSE: + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; + case MOM_DONE: + if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 32 => 16 */ + LPMIDIHDR mh16 = MapSL(dwParam1); + LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR)); + + dwParam1 = (DWORD)mh32; + mh32->dwFlags = mh16->dwFlags; + mh32->dwOffset = mh16->dwOffset; + if (mh32->reserved >= sizeof(MIDIHDR)) + mh32->dwOffset = mh16->dwOffset; + } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 16 => 32 */ + LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1); + SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); + LPMIDIHDR mh16 = MapSL(segmh16); + + dwParam1 = (DWORD)segmh16; + mh16->dwFlags = mh32->dwFlags; + if (mh16->reserved >= sizeof(MIDIHDR)) + mh16->dwOffset = mh32->dwOffset; + } + /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ + break; + /* case MOM_POSITIONCB: */ + default: + ERR("Unknown msg %u\n", uMsg); + } + + MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); +} + +/* ================================= + * W A V E I N M A P P E R S + * ================================= */ + +/************************************************************************** + * MMDRV_WaveIn_Map16To32A [internal] + */ +WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case WIDM_GETNUMDEVS: + case WIDM_RESET: + case WIDM_START: + case WIDM_STOP: + ret = WINMM_MAP_OK; + break; + case WIDM_OPEN: + case WIDM_CLOSE: + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; + case WIDM_GETDEVCAPS: + { + LPWAVEINCAPSA wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSA)); + LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); + + if (wic32) { + *(LPWAVEINCAPS16*)wic32 = wic16; + wic32 = (LPWAVEINCAPSA)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); + *lpParam1 = (DWORD)wic32; + *lpParam2 = sizeof(WAVEINCAPSA); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WIDM_GETPOS: + { + LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); + LPMMTIME16 mmt16 = MapSL(*lpParam1); + + if (mmt32) { + *(LPMMTIME16*)mmt32 = mmt16; + mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); + + mmt32->wType = mmt16->wType; + *lpParam1 = (DWORD)mmt32; + *lpParam2 = sizeof(MMTIME); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WIDM_PREPARE: + { + LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); + LPWAVEHDR wh16 = MapSL(*lpParam1); + + if (wh32) { + *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; + wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); + wh32->lpData = MapSL((SEGPTR)wh16->lpData); + wh32->dwBufferLength = wh16->dwBufferLength; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh16->lpNext = wh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WIDM_ADDBUFFER: + case WIDM_UNPREPARE: + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext; + + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { + ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + wh32->dwBufferLength, wh16->dwBufferLength); + } else + wh32->dwBufferLength = wh16->dwBufferLength; + ret = WINMM_MAP_OKMEM; + } + break; + case WIDM_MAPPER_STATUS: + /* just a single DWORD */ + *lpParam2 = (DWORD)MapSL(*lpParam2); + ret = WINMM_MAP_OK; + break; + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveIn_UnMap16To32A [internal] + */ +WINMM_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case WIDM_GETNUMDEVS: + case WIDM_RESET: + case WIDM_START: + case WIDM_STOP: + case WIDM_MAPPER_STATUS: + ret = WINMM_MAP_OK; + break; + case WIDM_OPEN: + case WIDM_CLOSE: + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; + case WIDM_GETDEVCAPS: + { + LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)(*lpParam1); + LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); + + wic16->wMid = wic32->wMid; + wic16->wPid = wic32->wPid; + wic16->vDriverVersion = wic32->vDriverVersion; + strcpy(wic16->szPname, wic32->szPname); + wic16->dwFormats = wic32->dwFormats; + wic16->wChannels = wic32->wChannels; + HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); + ret = WINMM_MAP_OK; + } + break; + case WIDM_GETPOS: + { + LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); + LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); + + MMSYSTEM_MMTIME32to16(mmt16, mmt32); + HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); + ret = WINMM_MAP_OK; + } + break; + case WIDM_ADDBUFFER: + case WIDM_PREPARE: + case WIDM_UNPREPARE: + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); + + assert(wh16->lpNext == wh32); + wh16->dwBufferLength = wh32->dwBufferLength; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + wh16->dwUser = wh32->dwUser; + wh16->dwFlags = wh32->dwFlags; + wh16->dwLoops = wh32->dwLoops; + + if (wMsg == WIDM_UNPREPARE) { + HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); + wh16->lpNext = 0; + } + ret = WINMM_MAP_OK; + } + break; + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveIn_Map32ATo16 [internal] + */ +WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case WIDM_CLOSE: + case WIDM_GETNUMDEVS: + case WIDM_RESET: + case WIDM_START: + case WIDM_STOP: + ret = WINMM_MAP_OK; + break; + + case WIDM_OPEN: + { + LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1; + int sz = sizeof(WAVEFORMATEX); + LPVOID ptr; + LPWAVEOPENDESC16 wod16; + + /* allocated data are mapped as follows: + LPWAVEOPENDESC ptr to orig lParam1 + DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance + DWORD dwUser passed to driver + WAVEOPENDESC16 wod16: openDesc passed to driver + WAVEFORMATEX openDesc->lpFormat passed to driver + xxx extra bytes to WAVEFORMATEX + */ + if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) { + TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag); + sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize; + } + + ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz); + + if (ptr) { + SEGPTR seg_ptr = MapLS( ptr ); + *(LPWAVEOPENDESC*)ptr = wod32; + *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser; + wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD)); + + wod16->hWave = HWAVE_16(wod32->hWave); + wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16)); + memcpy(wod16 + 1, wod32->lpFormat, sz); + + wod16->dwCallback = wod32->dwCallback; + wod16->dwInstance = wod32->dwInstance; + wod16->uMappedDeviceID = wod32->uMappedDeviceID; + wod16->dnDevNode = wod32->dnDevNode; + + *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD); + *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WIDM_PREPARE: + { + LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1; + LPWAVEHDR wh16; + LPVOID ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength); + + if (ptr) { + SEGPTR seg_ptr = MapLS( ptr ); + *(LPWAVEHDR*)ptr = wh32; + wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR)); + wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR); + /* data will be copied on WODM_WRITE */ + wh16->dwBufferLength = wh32->dwBufferLength; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + wh16->dwUser = wh32->dwUser; + wh16->dwFlags = wh32->dwFlags; + wh16->dwLoops = wh32->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh32->lpNext = wh16; /* for reuse in unprepare and write */ + TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", + seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, + wh32->dwBufferLength, (DWORD)wh32->lpData); + *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); + *lpParam2 = sizeof(WAVEHDR); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WIDM_ADDBUFFER: + case WIDM_UNPREPARE: + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = wh32->lpNext; + LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); + SEGPTR seg_ptr = MapLS( ptr ); + + assert(*(LPWAVEHDR*)ptr == wh32); + + TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", + seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, + wh32->dwBufferLength, (DWORD)wh32->lpData); + + if (wMsg == WIDM_ADDBUFFER) + memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); + + *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) { + ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + wh16->dwBufferLength, wh32->dwBufferLength); + } else + wh16->dwBufferLength = wh32->dwBufferLength; + ret = WINMM_MAP_OKMEM; + } + break; + case WIDM_GETDEVCAPS: + { + LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)*lpParam1; + LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSA) + sizeof(WAVEINCAPS16)); + + if (ptr) { + *(LPWAVEINCAPSA*)ptr = wic32; + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSA); + *lpParam2 = sizeof(WAVEINCAPS16); + } + break; + case WIDM_GETPOS: + { + LPMMTIME mmt32 = (LPMMTIME)*lpParam1; + LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16)); + LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME)); + + if (ptr) { + *(LPMMTIME*)ptr = mmt32; + mmt16->wType = mmt32->wType; + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME); + *lpParam2 = sizeof(MMTIME16); + } + break; + case DRVM_MAPPER_STATUS: + { + LPDWORD p32 = (LPDWORD)*lpParam2; + *lpParam2 = MapLS(p32); + ret = WINMM_MAP_OKMEM; + } + break; + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveIn_UnMap32ATo16 [internal] + */ +WINMM_MapType MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + case WIDM_CLOSE: + case WIDM_GETNUMDEVS: + case WIDM_RESET: + case WIDM_START: + case WIDM_STOP: + ret = WINMM_MAP_OK; + break; + + case WIDM_OPEN: + { + LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD); + LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr; + + UnMapLS( *lpParam1 ); + wod32->uMappedDeviceID = wod16->uMappedDeviceID; + **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD)); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + + case WIDM_ADDBUFFER: + case WIDM_PREPARE: + case WIDM_UNPREPARE: + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); + LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr; + + assert(wh32->lpNext == wh16); + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + UnMapLS( *lpParam1 ); + + if (wMsg == WIDM_UNPREPARE) { + HeapFree( GetProcessHeap(), 0, ptr ); + wh32->lpNext = 0; + } + ret = WINMM_MAP_OK; + } + break; + case WIDM_GETDEVCAPS: + { + LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)wic16 - sizeof(LPWAVEINCAPSA); + LPWAVEINCAPSA wic32 = *(LPWAVEINCAPSA*)ptr; + + wic32->wMid = wic16->wMid; + wic32->wPid = wic16->wPid; + wic32->vDriverVersion = wic16->vDriverVersion; + strcpy(wic32->szPname, wic16->szPname); + wic32->dwFormats = wic16->dwFormats; + wic32->wChannels = wic16->wChannels; + UnMapLS( *lpParam1 ); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case WIDM_GETPOS: + { + LPMMTIME16 mmt16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME); + LPMMTIME mmt32 = *(LPMMTIME*)ptr; + + MMSYSTEM_MMTIME16to32(mmt32, mmt16); + UnMapLS( *lpParam1 ); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case DRVM_MAPPER_STATUS: + { + UnMapLS( *lpParam2 ); + ret = WINMM_MAP_OK; + } + break; + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveIn_Callback [internal] + */ +void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) +{ + LPWINE_MLD mld = (LPWINE_MLD)dwInstance; + + switch (uMsg) { + case WIM_OPEN: + case WIM_CLOSE: + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; + case WIM_DATA: + if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 32 => 16 */ + LPWAVEHDR wh16 = MapSL(dwParam1); + LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR)); + + dwParam1 = (DWORD)wh32; + wh32->dwFlags = wh16->dwFlags; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 16 => 32 */ + LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1); + SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); + LPWAVEHDR wh16 = MapSL(segwh16); + + dwParam1 = (DWORD)segwh16; + wh16->dwFlags = wh32->dwFlags; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + } + /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ + break; + default: + ERR("Unknown msg %u\n", uMsg); + } + + MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); +} + +/* ================================= + * W A V E O U T M A P P E R S + * ================================= */ + +/************************************************************************** + * MMDRV_WaveOut_Map16To32A [internal] + */ +WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + /* nothing to do */ + case WODM_BREAKLOOP: + case WODM_CLOSE: + case WODM_GETNUMDEVS: + case WODM_PAUSE: + case WODM_RESET: + case WODM_RESTART: + case WODM_SETPITCH: + case WODM_SETPLAYBACKRATE: + case WODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + + case WODM_GETPITCH: + case WODM_GETPLAYBACKRATE: + case WODM_GETVOLUME: + case WODM_OPEN: + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; + + case WODM_GETDEVCAPS: + { + LPWAVEOUTCAPSA woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSA)); + LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); + + if (woc32) { + *(LPWAVEOUTCAPS16*)woc32 = woc16; + woc32 = (LPWAVEOUTCAPSA)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); + *lpParam1 = (DWORD)woc32; + *lpParam2 = sizeof(WAVEOUTCAPSA); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WODM_GETPOS: + { + LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); + LPMMTIME16 mmt16 = MapSL(*lpParam1); + + if (mmt32) { + *(LPMMTIME16*)mmt32 = mmt16; + mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); + + mmt32->wType = mmt16->wType; + *lpParam1 = (DWORD)mmt32; + *lpParam2 = sizeof(MMTIME); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WODM_PREPARE: + { + LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); + LPWAVEHDR wh16 = MapSL(*lpParam1); + + if (wh32) { + *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; + wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); + wh32->lpData = MapSL((SEGPTR)wh16->lpData); + wh32->dwBufferLength = wh16->dwBufferLength; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh16->lpNext = wh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WODM_UNPREPARE: + case WODM_WRITE: + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext; + + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { + ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + wh32->dwBufferLength, wh16->dwBufferLength); + } else + wh32->dwBufferLength = wh16->dwBufferLength; + ret = WINMM_MAP_OKMEM; + } + break; + case WODM_MAPPER_STATUS: + *lpParam2 = (DWORD)MapSL(*lpParam2); + ret = WINMM_MAP_OK; + break; + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveOut_UnMap16To32A [internal] + */ +WINMM_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret = WINMM_MAP_MSGERROR; + + switch (wMsg) { + /* nothing to do */ + case WODM_BREAKLOOP: + case WODM_CLOSE: + case WODM_GETNUMDEVS: + case WODM_PAUSE: + case WODM_RESET: + case WODM_RESTART: + case WODM_SETPITCH: + case WODM_SETPLAYBACKRATE: + case WODM_SETVOLUME: + case WODM_MAPPER_STATUS: + ret = WINMM_MAP_OK; + break; + + case WODM_GETPITCH: + case WODM_GETPLAYBACKRATE: + case WODM_GETVOLUME: + case WODM_OPEN: + FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); + break; + + case WODM_GETDEVCAPS: + { + LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)(*lpParam1); + LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); + + woc16->wMid = woc32->wMid; + woc16->wPid = woc32->wPid; + woc16->vDriverVersion = woc32->vDriverVersion; + strcpy(woc16->szPname, woc32->szPname); + woc16->dwFormats = woc32->dwFormats; + woc16->wChannels = woc32->wChannels; + woc16->dwSupport = woc32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); + ret = WINMM_MAP_OK; + } + break; + case WODM_GETPOS: + { + LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); + LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); + + MMSYSTEM_MMTIME32to16(mmt16, mmt32); + HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); + ret = WINMM_MAP_OK; + } + break; + case WODM_PREPARE: + case WODM_UNPREPARE: + case WODM_WRITE: + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); + + assert(wh16->lpNext == wh32); + wh16->dwBufferLength = wh32->dwBufferLength; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + wh16->dwUser = wh32->dwUser; + wh16->dwFlags = wh32->dwFlags; + wh16->dwLoops = wh32->dwLoops; + + if (wMsg == WODM_UNPREPARE) { + HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); + wh16->lpNext = 0; + } + ret = WINMM_MAP_OK; + } + break; + default: + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveOut_Map32ATo16 [internal] + */ +WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret; + + switch (wMsg) { + /* nothing to do */ + case WODM_BREAKLOOP: + case WODM_CLOSE: + case WODM_GETNUMDEVS: + case WODM_PAUSE: + case WODM_RESET: + case WODM_RESTART: + case WODM_SETPITCH: + case WODM_SETPLAYBACKRATE: + case WODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + + case WODM_GETDEVCAPS: + { + LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)*lpParam1; + LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPWAVEOUTCAPSA) + sizeof(WAVEOUTCAPS16)); + + if (ptr) { + *(LPWAVEOUTCAPSA*)ptr = woc32; + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSA); + *lpParam2 = sizeof(WAVEOUTCAPS16); + } + break; + case WODM_GETPITCH: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + case WODM_GETPLAYBACKRATE: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + case WODM_GETPOS: + { + LPMMTIME mmt32 = (LPMMTIME)*lpParam1; + LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16)); + LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME)); + + if (ptr) { + *(LPMMTIME*)ptr = mmt32; + mmt16->wType = mmt32->wType; + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME); + *lpParam2 = sizeof(MMTIME16); + } + break; + case WODM_GETVOLUME: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + case WODM_OPEN: + { + LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1; + int sz = sizeof(WAVEFORMATEX); + LPVOID ptr; + LPWAVEOPENDESC16 wod16; + + /* allocated data are mapped as follows: + LPWAVEOPENDESC ptr to orig lParam1 + DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance + DWORD dwUser passed to driver + WAVEOPENDESC16 wod16: openDesc passed to driver + WAVEFORMATEX openDesc->lpFormat passed to driver + xxx extra bytes to WAVEFORMATEX + */ + if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) { + TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag); + sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize; + } + + ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz); + + if (ptr) { + SEGPTR seg_ptr = MapLS( ptr ); + *(LPWAVEOPENDESC*)ptr = wod32; + *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser; + wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD)); + + wod16->hWave = HWAVE_16(wod32->hWave); + wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16)); + memcpy(wod16 + 1, wod32->lpFormat, sz); + + wod16->dwCallback = wod32->dwCallback; + wod16->dwInstance = wod32->dwInstance; + wod16->uMappedDeviceID = wod32->uMappedDeviceID; + wod16->dnDevNode = wod32->dnDevNode; + + *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD); + *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WODM_PREPARE: + { + LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1; + LPWAVEHDR wh16; + LPVOID ptr = HeapAlloc( GetProcessHeap(), 0, + sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength); + + if (ptr) { + SEGPTR seg_ptr = MapLS( ptr ); + *(LPWAVEHDR*)ptr = wh32; + wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR)); + wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR); + /* data will be copied on WODM_WRITE */ + wh16->dwBufferLength = wh32->dwBufferLength; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + wh16->dwUser = wh32->dwUser; + wh16->dwFlags = wh32->dwFlags; + wh16->dwLoops = wh32->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh32->lpNext = wh16; /* for reuse in unprepare and write */ + TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", + seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, + wh32->dwBufferLength, (DWORD)wh32->lpData); + *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); + *lpParam2 = sizeof(WAVEHDR); + + ret = WINMM_MAP_OKMEM; + } else { + ret = WINMM_MAP_NOMEM; + } + } + break; + case WODM_UNPREPARE: + case WODM_WRITE: + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = wh32->lpNext; + LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); + SEGPTR seg_ptr = MapLS( ptr ); + + assert(*(LPWAVEHDR*)ptr == wh32); + + TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", + seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, + wh32->dwBufferLength, (DWORD)wh32->lpData); + + if (wMsg == WODM_WRITE) + memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); + + *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) { + ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + wh16->dwBufferLength, wh32->dwBufferLength); + } else + wh16->dwBufferLength = wh32->dwBufferLength; + ret = WINMM_MAP_OKMEM; + } + break; + case DRVM_MAPPER_STATUS: + { + LPDWORD p32 = (LPDWORD)*lpParam2; + *lpParam2 = MapLS(p32); + ret = WINMM_MAP_OKMEM; + } + break; + default: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveOut_UnMap32ATo16 [internal] + */ +WINMM_MapType MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) +{ + WINMM_MapType ret; + + switch (wMsg) { + /* nothing to do */ + case WODM_BREAKLOOP: + case WODM_CLOSE: + case WODM_GETNUMDEVS: + case WODM_PAUSE: + case WODM_RESET: + case WODM_RESTART: + case WODM_SETPITCH: + case WODM_SETPLAYBACKRATE: + case WODM_SETVOLUME: + ret = WINMM_MAP_OK; + break; + + case WODM_GETDEVCAPS: + { + LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSA); + LPWAVEOUTCAPSA woc32 = *(LPWAVEOUTCAPSA*)ptr; + + woc32->wMid = woc16->wMid; + woc32->wPid = woc16->wPid; + woc32->vDriverVersion = woc16->vDriverVersion; + strcpy(woc32->szPname, woc16->szPname); + woc32->dwFormats = woc16->dwFormats; + woc32->wChannels = woc16->wChannels; + woc32->dwSupport = woc16->dwSupport; + UnMapLS( *lpParam1 ); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case WODM_GETPITCH: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + case WODM_GETPLAYBACKRATE: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + case WODM_GETPOS: + { + LPMMTIME16 mmt16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME); + LPMMTIME mmt32 = *(LPMMTIME*)ptr; + + MMSYSTEM_MMTIME16to32(mmt32, mmt16); + UnMapLS( *lpParam1 ); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case WODM_OPEN: + { + LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD); + LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr; + + wod32->uMappedDeviceID = wod16->uMappedDeviceID; + **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD)); + UnMapLS( *lpParam1 ); + HeapFree( GetProcessHeap(), 0, ptr ); + ret = WINMM_MAP_OK; + } + break; + case WODM_PREPARE: + case WODM_UNPREPARE: + case WODM_WRITE: + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR); + LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr; + + assert(wh32->lpNext == wh16); + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + + UnMapLS( *lpParam1 ); + if (wMsg == WODM_UNPREPARE) { + HeapFree( GetProcessHeap(), 0, ptr ); + wh32->lpNext = 0; + } + ret = WINMM_MAP_OK; + } + break; + case WODM_GETVOLUME: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + case DRVM_MAPPER_STATUS: + { + UnMapLS( *lpParam2 ); + ret = WINMM_MAP_OK; + } + break; + default: + FIXME("NIY: no conversion yet\n"); + ret = WINMM_MAP_MSGERROR; + break; + } + return ret; +} + +/************************************************************************** + * MMDRV_WaveOut_Callback [internal] + */ +void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) +{ + LPWINE_MLD mld = (LPWINE_MLD)dwInstance; + + switch (uMsg) { + case WOM_OPEN: + case WOM_CLOSE: + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; + case WOM_DONE: + if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 32 => 16 */ + LPWAVEHDR wh16 = MapSL(dwParam1); + LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR)); + + dwParam1 = (DWORD)wh32; + wh32->dwFlags = wh16->dwFlags; + } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { + /* initial map is: 16 => 32 */ + LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1); + SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); + LPWAVEHDR wh16 = MapSL(segwh16); + + dwParam1 = (DWORD)segwh16; + wh16->dwFlags = wh32->dwFlags; + } + /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ + break; + default: + ERR("Unknown msg %u\n", uMsg); + } + + MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); +} + +/************************************************************************** + * MMDRV_GetDescription16 [internal] + */ +BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen) +{ + OFSTRUCT ofs; + HFILE hFile; + WORD w; + DWORD dw; + BOOL ret = FALSE; + + if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) { + ERR("Can't open file %s (builtin driver ?)\n", fname); + return FALSE; + } + +#define E(_x) do {TRACE _x;goto theEnd;} while(0) + + if (_lread(hFile, &w, 2) != 2) E(("Can't read sig\n")); + if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w)); + if (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n")); + if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n")); + if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %lu\n", dw+0x2C)); + if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n")); + if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %lu\n", dw)); + if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n")); + buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1); + if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen)); + buf[buflen] = '\0'; + ret = TRUE; + TRACE("Got '%s' [%d]\n", buf, buflen); +theEnd: + CloseHandle(hFile); + return ret; +} + +/* ================================= + * M C I + * ================================= */ + /************************************************************************** * MCI_MapMsg16To32A [internal] */ diff --git a/dlls/winmm/winemm.h b/dlls/winmm/winemm.h index aba847e24b1..e6d5d9295b3 100644 --- a/dlls/winmm/winemm.h +++ b/dlls/winmm/winemm.h @@ -57,6 +57,40 @@ typedef struct tagWINE_DRIVER struct tagWINE_DRIVER* lpNextItem; } WINE_DRIVER, *LPWINE_DRIVER; +typedef DWORD (CALLBACK *WINEMM_msgFunc16)(UINT16, WORD, DWORD, DWORD, DWORD); +typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT , UINT, DWORD, DWORD, DWORD); + +/* for each loaded driver and each known type of driver, this structure contains + * the information needed to access it + */ +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_msgFunc16 fnMessage16; + } u; +} WINE_MM_DRIVER_PART; + +#define MMDRV_AUX 0 +#define MMDRV_MIXER 1 +#define MMDRV_MIDIIN 2 +#define MMDRV_MIDIOUT 3 +#define MMDRV_WAVEIN 4 +#define MMDRV_WAVEOUT 5 +#define MMDRV_MAX 6 + +/* each low-level .drv will be associated with an instance of this structure */ +typedef struct tagWINE_MM_DRIVER { + HDRVR hDriver; + LPSTR drvname; /* name of the driver */ + BOOL bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */ + bIsMapper : 1; /* TRUE if mapper */ + WINE_MM_DRIVER_PART parts[MMDRV_MAX];/* Information for all known types */ +} WINE_MM_DRIVER, *LPWINE_MM_DRIVER; + +typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); + typedef struct tagWINE_MLD { /* EPP struct tagWINE_MLD* lpNext; */ /* not used so far */ UINT uDeviceID; @@ -83,26 +117,6 @@ typedef struct { WINE_MLD mld; } WINE_MIXER, *LPWINE_MIXER; -extern BOOL MMDRV_Init(void); -extern UINT MMDRV_GetNum(UINT); -extern LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, - DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32); -extern void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld); -extern DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2); -extern DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg); -extern LPWINE_MLD MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID); -extern LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstTyped); -extern DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32); -extern UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2); - -#define MMDRV_AUX 0 -#define MMDRV_MIXER 1 -#define MMDRV_MIDIIN 2 -#define MMDRV_MIDIOUT 3 -#define MMDRV_WAVEIN 4 -#define MMDRV_WAVEOUT 5 -#define MMDRV_MAX 6 - #define WINE_MMTHREAD_CREATED 0x4153494C /* "BSIL" */ #define WINE_MMTHREAD_DELETED 0xDEADDEAD @@ -215,63 +229,114 @@ typedef struct tagWINE_MM_IDATA { typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD); typedef LONG (*MCIPROC)(DWORD, HDRVR, DWORD, DWORD, DWORD); -extern LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr); -extern BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz); -extern LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2); +LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr); +BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz); +LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2); -extern LPWINE_MCIDRIVER MCI_GetDriver(UINT16 uDevID); -extern UINT MCI_GetDriverFromString(LPCSTR str); -extern DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr); -extern const char* MCI_MessageToString(UINT16 wMsg); +BOOL MMDRV_Init(void); +UINT MMDRV_GetNum(UINT); +LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, + DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32); +void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld); +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); +UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2); +BOOL MMDRV_Is32(unsigned int); -extern UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data); +WINE_MCIDRIVER* MCI_GetDriver(UINT16 uDevID); +UINT MCI_GetDriverFromString(LPCSTR str); +DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr); +const char* MCI_MessageToString(UINT16 wMsg); +UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data); +LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32); +DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32); +DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2); +DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2); -extern LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32); +void CALLBACK WINE_mmThreadEntryPoint(DWORD _pmt); -extern DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32); -extern DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2); -extern DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2); +void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16); +void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32); -void CALLBACK WINE_mmThreadEntryPoint(DWORD _pmt); +UINT MMSYSTEM_mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback, + DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32); +UINT MMSYSTEM_midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback, + DWORD dwInstance, DWORD dwFlags, BOOL bFrom32); +UINT MMSYSTEM_midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD dwCallback, + DWORD dwInstance, DWORD dwFlags, BOOL bFrom32); +MMRESULT MMSYSTEM_MidiStream_Open(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, + DWORD cMidi, DWORD dwCallback, + DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32); +UINT MMSYSTEM_waveOpen(HANDLE* lphndl, UINT uDeviceID, UINT uType, + const LPWAVEFORMATEX lpFormat, DWORD dwCallback, + DWORD dwInstance, DWORD dwFlags, BOOL bFrom32); -void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16); -void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32); +WORD timeSetEventInternal(UINT wDelay, UINT wResol, + FARPROC16 lpFunc, DWORD dwUser, UINT wFlags); -UINT MMSYSTEM_mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback, - DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32); -UINT MMSYSTEM_midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback, - DWORD dwInstance, DWORD dwFlags, BOOL bFrom32); -UINT MMSYSTEM_midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD dwCallback, - DWORD dwInstance, DWORD dwFlags, BOOL bFrom32); -MMRESULT MMSYSTEM_MidiStream_Open(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, - DWORD cMidi, DWORD dwCallback, - DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32); -UINT MMSYSTEM_waveOpen(HANDLE* lphndl, UINT uDeviceID, UINT uType, - const LPWAVEFORMATEX lpFormat, DWORD dwCallback, - DWORD dwInstance, DWORD dwFlags, BOOL bFrom32); -WORD timeSetEventInternal(UINT wDelay, UINT wResol, - FARPROC16 lpFunc, DWORD dwUser, UINT wFlags); -HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, - DWORD dwOpenFlags, enum mmioProcType type); -LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, - DWORD dwFlags, enum mmioProcType type); -LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, - LPARAM lParam2, enum mmioProcType type); -LPWINE_MMIO MMIO_Get(HMMIO h); +HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, + DWORD dwOpenFlags, enum mmioProcType type); +LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, + DWORD dwFlags, enum mmioProcType type); +LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, + LPARAM lParam2, enum mmioProcType type); +LPWINE_MMIO MMIO_Get(HMMIO h); -BOOL MULTIMEDIA_MciInit(void); -BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSound, BOOL bUnicode); +BOOL MULTIMEDIA_MciInit(void); +BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSound, BOOL bUnicode); -void TIME_MMTimeStart(void); -void TIME_MMTimeStop(void); +void TIME_MMTimeStart(void); +void TIME_MMTimeStop(void); -/* temporary defines */ +/* temporary definitions */ WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2); WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2); WINMM_MapType MCI_MapMsg16To32A (WORD uDevType, WORD wMsg, DWORD* lParam); WINMM_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam); WINMM_MapType MCI_MapMsg32ATo16 (WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam); WINMM_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam); +void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2); + +WINMM_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_Aux_UnMap16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_Aux_UnMap32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2); + +WINMM_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_Mixer_UnMap16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_Mixer_UnMap32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2); + +WINMM_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_MidiIn_UnMap16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_MidiIn_UnMap32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2); + +WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_MidiOut_UnMap16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_MidiOut_UnMap32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2); + +WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_WaveIn_UnMap16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_WaveIn_UnMap32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2); + +WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_WaveOut_UnMap16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +WINMM_MapType MMDRV_WaveOut_UnMap32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); +void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2); + +BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen); /* Global variables */ extern LPWINE_MM_IDATA WINMM_IData;