/* -*- tab-width: 8; c-basic-offset: 4 -*- */ /* * MMSYTEM low level drivers handling functions * * Copyright 1999 Eric Pouech */ #include #include #include #include "wine/winbase16.h" #include "winreg.h" #include "winver.h" #include "winemm.h" #include "debugtools.h" 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 enum { MMDRV_MAP_NOMEM, /* ko, memory problem */ MMDRV_MAP_MSGERROR, /* ko, unknown message */ MMDRV_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */ MMDRV_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */ MMDRV_MAP_PASS /* not handled (no memory allocated) to be sent to the driver */ } MMDRV_MapType; typedef MMDRV_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); /* each known type of driver has an instance of this structure */ typedef struct tagWINE_LLTYPE { /* those attributes depend on the specification of the type */ LPSTR typestr; /* name (for debugging) */ BOOL bSupportMapper; /* if type is allowed to support mapper */ MMDRV_MAPFUNC Map16To32A; /* those are function pointers to handle */ MMDRV_MAPFUNC UnMap16To32A; /* the parameter conversion (16 vs 32 bit) */ MMDRV_MAPFUNC Map32ATo16; /* when hi-func (in mmsystem or winmm) and */ MMDRV_MAPFUNC UnMap32ATo16; /* low-func (in .drv) do not match */ LPDRVCALLBACK Callback; /* handles callback for a specified type */ /* those attributes reflect the loaded/current situation for the type */ UINT wMaxId; /* number of loaded devices (sum across all loaded drivers */ LPWINE_MLD lpMlds; /* "static" mlds to access the part though device IDs */ int nMapper; /* index to mapper */ } WINE_LLTYPE; static int MMDrvsHi /* = 0 */; 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] */ static 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((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; } /************************************************************************** * MMDRV_GetDescription32 [internal] */ static BOOL MMDRV_GetDescription32(const char* fname, char* buf, int buflen) { OFSTRUCT ofs; DWORD h; LPVOID ptr = 0; LPVOID val; DWORD dw; BOOL ret = FALSE; UINT u; FARPROC pGetFileVersionInfoSizeA; FARPROC pGetFileVersionInfoA; FARPROC pVerQueryValueA; HMODULE hmodule = 0; #define E(_x) do {TRACE _x;goto theEnd;} while(0) if (OpenFile(fname, &ofs, OF_EXIST)==HFILE_ERROR) E(("Can't find file %s\n", fname)); if (!(hmodule = LoadLibraryA( "version.dll" ))) goto theEnd; if (!(pGetFileVersionInfoSizeA = GetProcAddress( hmodule, "GetFileVersionInfoSizeA" ))) goto theEnd; if (!(pGetFileVersionInfoA = GetProcAddress( hmodule, "GetFileVersionInfoA" ))) goto theEnd; if (!(pVerQueryValueA = GetProcAddress( hmodule, "pVerQueryValueA" ))) goto theEnd; if (!(dw = pGetFileVersionInfoSizeA(ofs.szPathName, &h))) E(("Can't get FVIS\n")); if (!(ptr = HeapAlloc(GetProcessHeap(), 0, dw))) E(("OOM\n")); if (!pGetFileVersionInfoA(ofs.szPathName, h, dw, ptr)) E(("Can't get FVI\n")); #define A(_x) if (pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\" #_x, &val, &u)) \ TRACE(#_x " => %s\n", (LPSTR)val); else TRACE(#_x " @\n") A(CompanyName); A(FileDescription); A(FileVersion); A(InternalName); A(LegalCopyright); A(OriginalFilename); A(ProductName); A(ProductVersion); A(Comments); A(LegalTrademarks); A(PrivateBuild); A(SpecialBuild); #undef A if (!pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\ProductName", &val, &u)) E(("Can't get product name\n")); lstrcpynA(buf, val, buflen); #undef E ret = TRUE; theEnd: HeapFree(GetProcessHeap(), 0, ptr); if (hmodule) FreeLibrary( hmodule ); 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, 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 MMDRV_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_Aux_UnMap16To32A [internal] */ static MMDRV_MapType MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_Aux_Map32ATo16 [internal] */ static MMDRV_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_Aux_UnMap32ATo16 [internal] */ static MMDRV_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 MMDRV_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 MMDRV_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_Mixer_UnMap16To32A [internal] */ static MMDRV_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 MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_Mixer_Map32ATo16 [internal] */ static MMDRV_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_Mixer_UnMap32ATo16 [internal] */ static MMDRV_MapType MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_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 MMDRV_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_MidiIn_UnMap16To32A [internal] */ static MMDRV_MapType MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_MidiIn_Map32ATo16 [internal] */ static MMDRV_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_MAP_MSGERROR; } /************************************************************************** * MMDRV_MidiIn_UnMap32ATo16 [internal] */ static MMDRV_MapType MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { return MMDRV_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 MMDRV_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 (mh32->dwBufferLength < mh16->dwBufferLength) { ERR("Size of buffer has been increased (%ld, %ld)\n", mh32->dwBufferLength, mh16->dwBufferLength); return MMDRV_MAP_MSGERROR; } mh32->dwBufferLength = mh16->dwBufferLength; ret = MMDRV_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 MMDRV_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: ret = MMDRV_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 = MMDRV_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 = MMDRV_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 MMDRV_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case MODM_CLOSE: case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 (mh16->dwBufferLength < mh32->dwBufferLength) { ERR("Size of buffer has been increased (%ld, %ld)\n", mh16->dwBufferLength, mh32->dwBufferLength); return MMDRV_MAP_MSGERROR; } mh16->dwBufferLength = mh32->dwBufferLength; ret = MMDRV_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)(ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser; mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD)); mod16->hMidi = 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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 MMDRV_MapType MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case MODM_CLOSE: case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: ret = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_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 MMDRV_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case WIDM_GETNUMDEVS: case WIDM_RESET: case WIDM_START: case WIDM_STOP: ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 (wh32->dwBufferLength < wh16->dwBufferLength) { ERR("Size of buffer has been increased (%ld, %ld)\n", wh32->dwBufferLength, wh16->dwBufferLength); return MMDRV_MAP_MSGERROR; } wh32->dwBufferLength = wh16->dwBufferLength; ret = MMDRV_MAP_OKMEM; } break; case WIDM_MAPPER_STATUS: /* just a single DWORD */ *lpParam2 = (DWORD)MapSL(*lpParam2); ret = MMDRV_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 MMDRV_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case WIDM_GETNUMDEVS: case WIDM_RESET: case WIDM_START: case WIDM_STOP: case WIDM_MAPPER_STATUS: ret = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_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 MMDRV_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case WIDM_CLOSE: case WIDM_GETNUMDEVS: case WIDM_RESET: case WIDM_START: case WIDM_STOP: ret = MMDRV_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)(ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser; wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD)); wod16->hWave = 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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 (wh32->dwBufferLength < wh16->dwBufferLength) { ERR("Size of buffer has been increased (%ld, %ld)\n", wh32->dwBufferLength, wh16->dwBufferLength); return MMDRV_MAP_MSGERROR; } wh32->dwBufferLength = wh16->dwBufferLength; ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_MAP_NOMEM; } *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME); *lpParam2 = sizeof(MMTIME16); } break; case DRVM_MAPPER_STATUS: { LPDWORD p32 = (LPDWORD)*lpParam2; *lpParam2 = MapLS(p32); ret = MMDRV_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 MMDRV_MapType MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_MAP_MSGERROR; switch (wMsg) { case WIDM_CLOSE: case WIDM_GETNUMDEVS: case WIDM_RESET: case WIDM_START: case WIDM_STOP: ret = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_MAP_OK; } break; case DRVM_MAPPER_STATUS: { UnMapLS( *lpParam2 ); ret = MMDRV_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 MMDRV_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_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 = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 (wh32->dwBufferLength < wh16->dwBufferLength) { ERR("Size of buffer has been increased (%ld, %ld)\n", wh32->dwBufferLength, wh16->dwBufferLength); return MMDRV_MAP_MSGERROR; } wh32->dwBufferLength = wh16->dwBufferLength; ret = MMDRV_MAP_OKMEM; } break; case WODM_MAPPER_STATUS: *lpParam2 = (DWORD)MapSL(*lpParam2); ret = MMDRV_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 MMDRV_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_MapType ret = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_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 MMDRV_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_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 = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_MAP_NOMEM; } *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSA); *lpParam2 = sizeof(WAVEOUTCAPS16); } break; case WODM_GETPITCH: FIXME("NIY: no conversion yet\n"); ret = MMDRV_MAP_MSGERROR; break; case WODM_GETPLAYBACKRATE: FIXME("NIY: no conversion yet\n"); ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_MAP_NOMEM; } *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME); *lpParam2 = sizeof(MMTIME16); } break; case WODM_GETVOLUME: FIXME("NIY: no conversion yet\n"); ret = MMDRV_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)(ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser; wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD)); wod16->hWave = 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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 = MMDRV_MAP_OKMEM; } else { ret = MMDRV_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 (wh16->dwBufferLength < wh32->dwBufferLength) { ERR("Size of buffer has been increased (%ld, %ld)\n", wh16->dwBufferLength, wh32->dwBufferLength); return MMDRV_MAP_MSGERROR; } wh16->dwBufferLength = wh32->dwBufferLength; ret = MMDRV_MAP_OKMEM; } break; case DRVM_MAPPER_STATUS: { LPDWORD p32 = (LPDWORD)*lpParam2; *lpParam2 = MapLS(p32); ret = MMDRV_MAP_OKMEM; } break; default: FIXME("NIY: no conversion yet\n"); ret = MMDRV_MAP_MSGERROR; break; } return ret; } /************************************************************************** * MMDRV_WaveOut_UnMap32ATo16 [internal] */ static MMDRV_MapType MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) { MMDRV_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 = MMDRV_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 = MMDRV_MAP_OK; } break; case WODM_GETPITCH: FIXME("NIY: no conversion yet\n"); ret = MMDRV_MAP_MSGERROR; break; case WODM_GETPLAYBACKRATE: FIXME("NIY: no conversion yet\n"); ret = MMDRV_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 = MMDRV_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 = MMDRV_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 = MMDRV_MAP_OK; } break; case WODM_GETVOLUME: FIXME("NIY: no conversion yet\n"); ret = MMDRV_MAP_MSGERROR; break; case DRVM_MAPPER_STATUS: { UnMapLS( *lpParam2 ); ret = MMDRV_MAP_OK; } break; default: FIXME("NIY: no conversion yet\n"); ret = MMDRV_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, \ MMDRV_##_y##_Callback, 0, NULL, -1} /* Note: the indices of this array must match the definitions * of the MMDRV_???? manifest constants */ static WINE_LLTYPE llTypes[MMDRV_MAX] = { A(TRUE, Aux), A(FALSE, Mixer), A(TRUE, MidiIn), A(TRUE, MidiOut), A(TRUE, WaveIn), A(TRUE, WaveOut), }; #undef A /************************************************************************** * MMDRV_GetNum [internal] */ UINT MMDRV_GetNum(UINT type) { assert(type < MMDRV_MAX); return llTypes[type].wMaxId; } /************************************************************************** * WINE_Message [internal] */ DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32) { LPWINE_MM_DRIVER lpDrv; DWORD ret; WINE_MM_DRIVER_PART* part; WINE_LLTYPE* llType = &llTypes[mld->type]; MMDRV_MapType map; int devID; TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx %c)!\n", llTypes[mld->type].typestr, mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N'); if (mld->uDeviceID == (UINT16)-1) { if (!llType->bSupportMapper) { WARN("uDev=-1 requested on non-mappable ll type %s\n", llTypes[mld->type].typestr); return MMSYSERR_BADDEVICEID; } devID = -1; } else { if (mld->uDeviceID >= llType->wMaxId) { WARN("uDev(%u) requested >= max (%d)\n", mld->uDeviceID, llType->wMaxId); return MMSYSERR_BADDEVICEID; } devID = mld->uDeviceID; } lpDrv = &MMDrvs[mld->mmdIndex]; part = &lpDrv->parts[mld->type]; #if 0 /* some sanity checks */ if (!(part->nIDMin <= devID)) ERR("!(part->nIDMin(%d) <= devID(%d))\n", part->nIDMin, devID); if (!(devID < part->nIDMax)) ERR("!(devID(%d) < part->nIDMax(%d))\n", devID, part->nIDMax); #endif if (lpDrv->bIs32) { assert(part->u.fnMessage32); if (bFrom32) { TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx\n", mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); TRACE("=> %lu\n", ret); } else { map = llType->Map16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2); switch (map) { case MMDRV_MAP_NOMEM: ret = MMSYSERR_NOMEM; break; case MMDRV_MAP_MSGERROR: FIXME("NIY: no conversion yet 16->32 (%u)\n", wMsg); ret = MMSYSERR_ERROR; break; case MMDRV_MAP_OK: case MMDRV_MAP_OKMEM: TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx\n", mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); TRACE("=> %lu\n", ret); if (map == MMDRV_MAP_OKMEM) llType->UnMap16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2); break; default: case MMDRV_MAP_PASS: FIXME("NIY: pass used ?\n"); ret = MMSYSERR_NOTSUPPORTED; break; } } } else { assert(part->u.fnMessage16); if (bFrom32) { map = llType->Map32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2); switch (map) { case MMDRV_MAP_NOMEM: ret = MMSYSERR_NOMEM; break; case MMDRV_MAP_MSGERROR: FIXME("NIY: no conversion yet 32->16 (%u)\n", wMsg); ret = MMSYSERR_ERROR; break; case MMDRV_MAP_OK: case MMDRV_MAP_OKMEM: TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx\n", mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = MMDRV_CallTo16_word_wwlll((FARPROC16)part->u.fnMessage16, mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); TRACE("=> %lu\n", ret); if (map == MMDRV_MAP_OKMEM) llType->UnMap32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2); break; default: case MMDRV_MAP_PASS: FIXME("NIY: pass used ?\n"); ret = MMSYSERR_NOTSUPPORTED; break; } } else { TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx\n", mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = MMDRV_CallTo16_word_wwlll((FARPROC16)part->u.fnMessage16, mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); TRACE("=> %lu\n", ret); } } return ret; } /************************************************************************** * MMDRV_Alloc [internal] */ LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32) { LPWINE_MLD mld; mld = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); if (!mld) return NULL; /* find an empty slot in MM_MLDrvs table */ for (*hndl = 0; *hndl < MAX_MM_MLDRVS; (*hndl)++) { if (!MM_MLDrvs[*hndl]) break; } if (*hndl == MAX_MM_MLDRVS) { /* the MM_MLDrvs table could be made growable in the future if needed */ ERR("Too many open drivers\n"); return NULL; } MM_MLDrvs[*hndl] = mld; *hndl |= 0x8000; mld->type = type; if ((UINT)*hndl < MMDRV_GetNum(type) || HIWORD(*hndl) != 0) { /* FIXME: those conditions must be fulfilled so that: * - we can distinguish between device IDs and handles * - we can use handles as 16 or 32 bit entities */ ERR("Shouldn't happen. Bad allocation scheme\n"); } mld->bFrom32 = bFrom32; mld->dwFlags = HIWORD(*dwFlags); mld->dwCallback = *dwCallback; mld->dwClientInstance = *dwInstance; *dwFlags = LOWORD(*dwFlags) | CALLBACK_FUNCTION; *dwCallback = (DWORD)llTypes[type].Callback; *dwInstance = (DWORD)mld; /* FIXME: wouldn't some 16 bit drivers only use the loword ? */ return mld; } /************************************************************************** * MMDRV_Free [internal] */ void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld) { if (hndl & 0x8000) { unsigned idx = hndl & ~0x8000; if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { MM_MLDrvs[idx] = NULL; HeapFree(GetProcessHeap(), 0, mld); return; } } ERR("Bad Handle %08x at %p (not freed)\n", hndl, mld); } /************************************************************************** * MMDRV_Open [internal] */ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags) { DWORD dwRet = MMSYSERR_BADDEVICEID; DWORD dwInstance; WINE_LLTYPE* llType = &llTypes[mld->type]; mld->dwDriverInstance = (DWORD)&dwInstance; if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) { TRACE("MAPPER mode requested !\n"); /* check if mapper is supported by type */ if (llType->bSupportMapper) { if (llType->nMapper == -1) { /* no driver for mapper has been loaded, try a dumb implementation */ TRACE("No mapper loaded, doing it by hand\n"); for (mld->uDeviceID = 0; mld->uDeviceID < llType->wMaxId; mld->uDeviceID++) { if ((dwRet = MMDRV_Open(mld, wMsg, dwParam1, dwFlags)) == MMSYSERR_NOERROR) { /* to share this function epilog */ dwInstance = mld->dwDriverInstance; break; } } } else { mld->uDeviceID = (UINT16)-1; mld->mmdIndex = llType->lpMlds[-1].mmdIndex; TRACE("Setting mmdIndex to %u\n", mld->mmdIndex); dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE); } } } else { if (mld->uDeviceID < llType->wMaxId) { mld->mmdIndex = llType->lpMlds[mld->uDeviceID].mmdIndex; TRACE("Setting mmdIndex to %u\n", mld->mmdIndex); dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE); } } if (dwRet == MMSYSERR_NOERROR) mld->dwDriverInstance = dwInstance; return dwRet; } /************************************************************************** * MMDRV_Close [internal] */ DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg) { return MMDRV_Message(mld, wMsg, 0L, 0L, TRUE); } /************************************************************************** * MMDRV_GetByID [internal] */ LPWINE_MLD MMDRV_GetByID(UINT uDevID, UINT type) { if (uDevID < llTypes[type].wMaxId) return &llTypes[type].lpMlds[uDevID]; if ((uDevID == (UINT16)-1 || uDevID == (UINT)-1) && llTypes[type].nMapper != -1) return &llTypes[type].lpMlds[-1]; return NULL; } /************************************************************************** * MMDRV_Get [internal] */ LPWINE_MLD MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID) { LPWINE_MLD mld = NULL; assert(type < MMDRV_MAX); if ((UINT)hndl >= llTypes[type].wMaxId && hndl != (UINT16)-1 && hndl != (UINT)-1) { if (hndl & 0x8000) { hndl &= ~0x8000; if (hndl < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { mld = MM_MLDrvs[hndl]; if (!mld || !HeapValidate(GetProcessHeap(), 0, mld) || mld->type != type) mld = NULL; } hndl |= 0x8000; } } if (mld == NULL && bCanBeID) { mld = MMDRV_GetByID((UINT)hndl, type); } return mld; } /************************************************************************** * MMDRV_GetRelated [internal] */ LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstType) { LPWINE_MLD mld; if ((mld = MMDRV_Get(hndl, srcType, bSrcCanBeID)) != NULL) { WINE_MM_DRIVER_PART* part = &MMDrvs[mld->mmdIndex].parts[dstType]; if (part->nIDMin < part->nIDMax) return MMDRV_GetByID(part->nIDMin, dstType); } return NULL; } /************************************************************************** * MMDRV_PhysicalFeatures [internal] */ UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2) { WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex]; TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2); /* all those function calls are undocumented */ switch (uMsg) { case DRV_QUERYDRVENTRY: lstrcpynA((LPSTR)dwParam1, lpDrv->drvname, LOWORD(dwParam2)); break; case DRV_QUERYDEVNODE: *(LPDWORD)dwParam1 = 0L; /* should be DevNode */ break; case DRV_QUERYNAME: WARN("NIY QueryName\n"); break; case DRV_QUERYDRIVERIDS: WARN("NIY call VxD\n"); /* should call VxD MMDEVLDR with (DevNode, dwParam1 and dwParam2) as pmts * dwParam1 is buffer and dwParam2 is sizeof buffer * I don't know where the result is stored though */ break; case DRV_QUERYMAPPABLE: return (lpDrv->bIsMapper) ? 2 : 0; case DRV_QUERYDSOUNDIFACE: /* Wine-specific: Retrieve DirectSound interface */ return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE); default: WARN("Unknown call %04x\n", uMsg); return MMSYSERR_INVALPARAM; } return 0L; } /************************************************************************** * MMDRV_InitPerType [internal] */ static BOOL MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg) { WINE_MM_DRIVER_PART* part = &lpDrv->parts[type]; DWORD ret; UINT count = 0; int i, k; part->nIDMin = part->nIDMax = 0; /* for DRVM_INIT and DRVM_ENABLE, dwParam2 should be PnP node */ /* the DRVM_ENABLE is only required when the PnP node is non zero */ if (lpDrv->bIs32 && part->u.fnMessage32) { ret = part->u.fnMessage32(0, DRVM_INIT, 0L, 0L, 0L); TRACE("DRVM_INIT => %08lx\n", ret); #if 0 ret = part->u.fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L); TRACE("DRVM_ENABLE => %08lx\n", ret); #endif count = part->u.fnMessage32(0, wMsg, 0L, 0L, 0L); } else if (!lpDrv->bIs32 && part->u.fnMessage16) { ret = MMDRV_CallTo16_word_wwlll((FARPROC16)part->u.fnMessage16, 0, DRVM_INIT, 0L, 0L, 0L); TRACE("DRVM_INIT => %08lx\n", ret); #if 0 ret = MMDRV_CallTo16_word_wwlll((FARPROC16)part->u.fnMessage16, 0, DRVM_ENABLE, 0L, 0L, 0L); TRACE("DRVM_ENABLE => %08lx\n", ret); #endif count = MMDRV_CallTo16_word_wwlll((FARPROC16)part->u.fnMessage16, 0, wMsg, 0L, 0L, 0L); } else { return FALSE; } TRACE("Got %u dev for (%s:%s)\n", count, lpDrv->drvname, llTypes[type].typestr); /* got some drivers */ if (lpDrv->bIsMapper) { /* it seems native mappers return 0 devices :-( */ if (llTypes[type].nMapper != -1) ERR("Two mappers for type %s (%d, %s)\n", llTypes[type].typestr, llTypes[type].nMapper, lpDrv->drvname); if (count > 1) ERR("Strange: mapper with %d > 1 devices\n", count); llTypes[type].nMapper = MMDrvsHi; } else { if (count == 0) return FALSE; part->nIDMin = llTypes[type].wMaxId; llTypes[type].wMaxId += count; part->nIDMax = llTypes[type].wMaxId; } TRACE("Setting min=%d max=%d (ttop=%d) for (%s:%s)\n", part->nIDMin, part->nIDMax, llTypes[type].wMaxId, lpDrv->drvname, llTypes[type].typestr); /* realloc translation table */ llTypes[type].lpMlds = (LPWINE_MLD) HeapReAlloc(GetProcessHeap(), 0, (llTypes[type].lpMlds) ? llTypes[type].lpMlds - 1 : NULL, sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1; /* re-build the translation table */ if (llTypes[type].nMapper != -1) { TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, -1, MMDrvs[llTypes[type].nMapper].drvname); llTypes[type].lpMlds[-1].uDeviceID = (UINT16)-1; llTypes[type].lpMlds[-1].type = type; llTypes[type].lpMlds[-1].mmdIndex = llTypes[type].nMapper; llTypes[type].lpMlds[-1].dwDriverInstance = 0; } for (i = k = 0; i <= MMDrvsHi; i++) { while (MMDrvs[i].parts[type].nIDMin <= k && k < MMDrvs[i].parts[type].nIDMax) { TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, k, MMDrvs[i].drvname); llTypes[type].lpMlds[k].uDeviceID = k; llTypes[type].lpMlds[k].type = type; llTypes[type].lpMlds[k].mmdIndex = i; llTypes[type].lpMlds[k].dwDriverInstance = 0; k++; } } return TRUE; } /************************************************************************** * MMDRV_Install [internal] */ static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper) { int i, count = 0; char buffer[128]; LPWINE_MM_DRIVER lpDrv = &MMDrvs[MMDrvsHi]; LPWINE_DRIVER d; TRACE("('%s', '%s', mapper=%c);\n", drvRegName, drvFileName, bIsMapper ? 'Y' : 'N'); /* be sure that size of MMDrvs matches the max number of loadable drivers !! * if not just increase size of MMDrvs */ assert(MMDrvsHi <= sizeof(MMDrvs)/sizeof(MMDrvs[0])); for (i = 0; i < MMDrvsHi; i++) { if (!strcmp(drvRegName, MMDrvs[i].drvname)) return FALSE; } memset(lpDrv, 0, sizeof(*lpDrv)); if (!(lpDrv->hDriver = OpenDriverA(drvFileName, 0, 0))) { WARN("Couldn't open driver '%s'\n", drvFileName); return FALSE; } d = DRIVER_FindFromHDrvr(lpDrv->hDriver); lpDrv->bIs32 = (d->dwFlags & WINE_GDF_16BIT) ? FALSE : TRUE; /* Then look for xxxMessage functions */ #define AA(_h,_w,_x,_y,_z) \ func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \ if (func != NULL) \ { lpDrv->parts[_w].u.fnMessage##_y = func; count++; \ TRACE("Got %d bit func '%s'\n", _y, #_x); } if (lpDrv->bIs32) { WINEMM_msgFunc32 func; if (d->d.d32.hModule) { #define A(_x,_y) AA(d->d.d32.hModule,_x,_y,32,GetProcAddress) A(MMDRV_AUX, auxMessage); A(MMDRV_MIXER, mixMessage); A(MMDRV_MIDIIN, midMessage); A(MMDRV_MIDIOUT, modMessage); A(MMDRV_WAVEIN, widMessage); A(MMDRV_WAVEOUT, wodMessage); #undef A } } else { WINEMM_msgFunc16 func; /* * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver' * The beginning of the module description indicates the driver supports * waveform, auxiliary, and mixer devices. Use one of the following * device-type names, followed by a colon (:) to indicate the type of * device your driver supports. If the driver supports more than one * type of device, separate each device-type name with a comma (,). * * wave for waveform audio devices * wavemapper for wave mappers * midi for MIDI audio devices * midimapper for midi mappers * aux for auxiliary audio devices * mixer for mixer devices */ if (d->d.d16.hDriver16) { HMODULE16 hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16); #define A(_x,_y) AA(hMod16,_x,_y,16,GetProcAddress16) A(MMDRV_AUX, auxMessage); A(MMDRV_MIXER, mixMessage); A(MMDRV_MIDIIN, midMessage); A(MMDRV_MIDIOUT, modMessage); A(MMDRV_WAVEIN, widMessage); A(MMDRV_WAVEOUT, wodMessage); #undef A } } #undef AA if (TRACE_ON(mmsys)) { if ((lpDrv->bIs32) ? MMDRV_GetDescription32(drvFileName, buffer, sizeof(buffer)) : MMDRV_GetDescription16(drvFileName, buffer, sizeof(buffer))) TRACE("%s => %s\n", drvFileName, buffer); else TRACE("%s => No description\n", drvFileName); } if (!count) { CloseDriver(lpDrv->hDriver, 0, 0); WARN("No message functions found\n"); return FALSE; } /* FIXME: being a mapper or not should be known by another way */ /* it's known for NE drvs (the description is of the form '*mapper: *' * I don't have any clue for PE drvs */ lpDrv->bIsMapper = bIsMapper; lpDrv->drvname = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(drvRegName) + 1), drvRegName); /* Finish init and get the count of the devices */ MMDRV_InitPerType(lpDrv, MMDRV_AUX, AUXDM_GETNUMDEVS); MMDRV_InitPerType(lpDrv, MMDRV_MIXER, MXDM_GETNUMDEVS); MMDRV_InitPerType(lpDrv, MMDRV_MIDIIN, MIDM_GETNUMDEVS); MMDRV_InitPerType(lpDrv, MMDRV_MIDIOUT, MODM_GETNUMDEVS); MMDRV_InitPerType(lpDrv, MMDRV_WAVEIN, WIDM_GETNUMDEVS); MMDRV_InitPerType(lpDrv, MMDRV_WAVEOUT, WODM_GETNUMDEVS); /* FIXME: if all those func calls return FALSE, * then the driver must be unloaded */ MMDrvsHi++; return TRUE; } /************************************************************************** * MMDRV_InitFromRegistry [internal] */ static BOOL MMDRV_InitFromRegistry(void) { HKEY hKey; char buffer[256]; char* p1; char* p2; DWORD type, size; BOOL ret = FALSE; if (RegCreateKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\WinMM", &hKey)) { TRACE("Cannot open WinMM config key\n"); return FALSE; } size = sizeof(buffer); if (!RegQueryValueExA(hKey, "Drivers", 0, &type, (LPVOID)buffer, &size)) { p1 = buffer; while (p1) { p2 = strchr(p1, ';'); if (p2) *p2++ = '\0'; ret |= MMDRV_Install(p1, p1, FALSE); p1 = p2; } } /* finish with mappers */ size = sizeof(buffer); if (!RegQueryValueExA(hKey, "WaveMapper", 0, &type, (LPVOID)buffer, &size)) ret |= MMDRV_Install("wavemapper", buffer, TRUE); size = sizeof(buffer); if (!RegQueryValueExA(hKey, "MidiMapper", 0, &type, (LPVOID)buffer, &size)) ret |= MMDRV_Install("midimapper", buffer, TRUE); RegCloseKey(hKey); return ret; } /************************************************************************** * MMDRV_InitHardcoded [internal] */ static BOOL MMDRV_InitHardcoded(void) { ERR("You didn't setup properly the config file for the Wine multimedia modules.\n" "Will use the hard-coded setup, but this will disappear soon.\n" "Please add a WinMM section to your Wine config file.\n"); /* first load hardware drivers */ MMDRV_Install("wineoss.drv", "wineoss.drv", FALSE); /* finish with mappers */ MMDRV_Install("wavemapper", "msacm.drv", TRUE); MMDRV_Install("midimapper", "midimap.drv", TRUE); return TRUE; } /************************************************************************** * MMDRV_Init [internal] */ BOOL MMDRV_Init(void) { /* FIXME: MMDRV_InitFromRegistry shall be MMDRV_Init in a near future */ return MMDRV_InitFromRegistry() || MMDRV_InitHardcoded(); }