/* -*- tab-width: 8; c-basic-offset: 4 -*- */ /* * MMSYTEM functions * * Copyright 1993 Martin Ayotte */ /* * Eric POUECH : * 98/9 added support for Win32 MCI */ /* FIXME: I think there are some segmented vs. linear pointer weirdnesses * and long term pointers to 16 bit space in here */ #include #include #include #include #include #include #include "wine/winuser16.h" #include "win.h" #include "heap.h" #include "ldt.h" #include "user.h" #include "driver.h" #include "file.h" #include "mmsystem.h" #include "multimedia.h" #include "xmalloc.h" #include "callback.h" #include "module.h" #include "selectors.h" #include "debug.h" int mciInstalledCount; int mciInstalledListLen; LPSTR lpmciInstallNames = NULL; struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS]; UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize); static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize); LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, DWORD dwParam1, DWORD dwParam2); #define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)]) #define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop)) /* The wDevID's returned by wine were originally in the range * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices. * Unfortunately, ms-windows uses wDevID of zero to indicate * errors. Now, multimedia drivers must pass the wDevID through * MCI_DevIDToIndex to get an index in that range. An * arbitrary value, MCI_MAGIC is added to the wDevID seen * by the windows programs. */ #define MCI_MAGIC 0x0F00 /************************************************************************** * MCI_GetProc32 [internal] */ MCIPROC32 MCI_GetProc32(UINT16 uDevType) { MCIPROC32 proc = 0; switch (uDevType) { case MCI_DEVTYPE_CD_AUDIO: proc = MCICDAUDIO_DriverProc32; break; case MCI_DEVTYPE_WAVEFORM_AUDIO: proc = MCIWAVE_DriverProc32; break; case MCI_DEVTYPE_SEQUENCER: proc = MCIMIDI_DriverProc32; break; case MCI_DEVTYPE_ANIMATION: proc = MCIANIM_DriverProc32; break; case MCI_DEVTYPE_DIGITAL_VIDEO: proc = MCIAVI_DriverProc32; break; default: TRACE(mci, "Unknown device type %u\n", uDevType); } return proc; } /************************************************************************** * MCI_GetDevType [internal] */ WORD MCI_GetDevType(LPCSTR str) { WORD uDevTyp = 0; if (lstrcmpi32A(str, "CDAUDIO") == 0) { uDevTyp = MCI_DEVTYPE_CD_AUDIO; } else if (lstrcmpi32A(str, "WAVEAUDIO") == 0) { uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO; } else if (lstrcmpi32A(str, "SEQUENCER") == 0) { uDevTyp = MCI_DEVTYPE_SEQUENCER; } else if (lstrcmpi32A(str, "ANIMATION1") == 0) { uDevTyp = MCI_DEVTYPE_ANIMATION; } else if (lstrcmpi32A(str, "AVIVIDEO") == 0) { uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO; } TRACE(mci, "str = %s => %u\n", str, uDevTyp); return uDevTyp; } /************************************************************************** * MCI_GetDevTypeString [internal] */ static LPCSTR MCI_GetDevTypeString(WORD uDevTyp) { LPCSTR str = "??? MCI ???"; switch (uDevTyp) { case MCI_DEVTYPE_CD_AUDIO: str = "CDAUDIO"; break; case MCI_DEVTYPE_WAVEFORM_AUDIO: str = "WAVEAUDIO"; break; case MCI_DEVTYPE_SEQUENCER: str = "SEQUENCER"; break; case MCI_DEVTYPE_ANIMATION: str = "ANIMATION1"; break; case MCI_DEVTYPE_DIGITAL_VIDEO: str = "AVIVIDEO"; break; default: FIXME(mci, "Incohenrent MCI definitions\n"); } TRACE(mci, "devType=%u => %s\n", uDevTyp, str); return str; } /************************************************************************** * MCI_DevIDToIndex [internal] */ int MCI_DevIDToIndex(UINT16 wDevID) { return wDevID - MCI_MAGIC; } /************************************************************************** * MCI_FirstDevId [internal] */ UINT16 MCI_FirstDevID(void) { return MCI_MAGIC; } /************************************************************************** * MCI_NextDevId [internal] */ UINT16 MCI_NextDevID(UINT16 wDevID) { return wDevID + 1; } /************************************************************************** * MCI_DevIDValid [internal] */ BOOL32 MCI_DevIDValid(UINT16 wDevID) { return wDevID >= MCI_MAGIC && wDevID < (MCI_MAGIC + MAXMCIDRIVERS); } /************************************************************************** * MMSYSTEM_WEP [MMSYSTEM.1] */ int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg, WORD cbHeapSize, LPSTR lpCmdLine) { FIXME(mmsys, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance); return(TRUE); } static void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, LPMMTIME32 mmt32) { mmt16->wType = mmt32->wType; /* layout of rest is the same for 32/16 */ memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u)); } static void MMSYSTEM_MMTIME16to32(LPMMTIME32 mmt32, LPMMTIME16 mmt16) { mmt32->wType = mmt16->wType; /* layout of rest is the same for 32/16, * Note: mmt16->u is 2 bytes smaller than mmt32->u */ memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u)); } static HANDLE32 PlaySound_hThread = 0; static HANDLE32 PlaySound_hPlayEvent = 0; static HANDLE32 PlaySound_hReadyEvent = 0; static HANDLE32 PlaySound_hMiddleEvent = 0; static BOOL32 PlaySound_Result = FALSE; static int PlaySound_Stop = FALSE; static int PlaySound_Playing = FALSE; static LPCSTR PlaySound_pszSound = NULL; static HMODULE32 PlaySound_hmod = 0; static DWORD PlaySound_fdwSound = 0; static int PlaySound_Loop = FALSE; static int PlaySound_SearchMode = 0; /* 1 - sndPlaySound search order 2 - PlaySound order */ static HMMIO16 get_mmioFromFile(LPCSTR lpszName) { return mmioOpen16((LPSTR)lpszName, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE); } static HMMIO16 get_mmioFromProfile(UINT32 uFlags, LPCSTR lpszName) { char str[128]; LPSTR ptr; HMMIO16 hmmio; TRACE(mmsys, "searching in SystemSound List !\n"); GetProfileString32A("Sounds", (LPSTR)lpszName, "", str, sizeof(str)); if (strlen(str) == 0) { if (uFlags & SND_NODEFAULT) return 0; GetProfileString32A("Sounds", "Default", "", str, sizeof(str)); if (strlen(str) == 0) return 0; } if ((ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0'; hmmio = get_mmioFromFile(str); if (hmmio == 0) { WARN(mmsys, "can't find SystemSound='%s' !\n", str); return 0; } return hmmio; } static BOOL16 WINAPI proc_PlaySound(LPCSTR lpszSoundName, UINT32 uFlags) { BOOL16 bRet = FALSE; HMMIO16 hmmio; MMCKINFO ckMainRIFF; TRACE(mmsys, "SoundName='%s' uFlags=%04X !\n", lpszSoundName, uFlags); if (lpszSoundName == NULL) { TRACE(mmsys, "Stop !\n"); return FALSE; } if (uFlags & SND_MEMORY) { MMIOINFO16 mminfo; memset(&mminfo, 0, sizeof(mminfo)); mminfo.fccIOProc = FOURCC_MEM; mminfo.pchBuffer = (LPSTR)lpszSoundName; mminfo.cchBuffer = -1; TRACE(mmsys, "Memory sound %p\n", lpszSoundName); hmmio = mmioOpen16(NULL, &mminfo, MMIO_READ); } else { hmmio = 0; if (uFlags & SND_ALIAS) if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0) return FALSE; if (uFlags & SND_FILENAME) if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0) return FALSE; if (PlaySound_SearchMode == 1) { PlaySound_SearchMode = 0; if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0) if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0) return FALSE; } if (PlaySound_SearchMode == 2) { PlaySound_SearchMode = 0; if ((hmmio=get_mmioFromProfile(uFlags | SND_NODEFAULT, lpszSoundName)) == 0) if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0) if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0) return FALSE; } } if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0) do { TRACE(mmsys, "ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize); if ((ckMainRIFF.ckid == FOURCC_RIFF) && (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E'))) { MMCKINFO mmckInfo; mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' '); if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) { PCMWAVEFORMAT pcmWaveFormat; TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); if (mmioRead32(hmmio, (HPSTR)&pcmWaveFormat, (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT)) { TRACE(mmsys, "wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag); TRACE(mmsys, "nChannels=%d \n", pcmWaveFormat.wf.nChannels); TRACE(mmsys, "nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec); TRACE(mmsys, "nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec); TRACE(mmsys, "nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign); TRACE(mmsys, "wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample); mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a'); if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) { WAVEOPENDESC waveDesc; DWORD dwRet; TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec * pcmWaveFormat.wf.nBlockAlign; waveDesc.hWave = 0; waveDesc.lpFormat = (LPWAVEFORMAT)&pcmWaveFormat; dwRet = wodMessage(0, WODM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL); if (dwRet == MMSYSERR_NOERROR) { WAVEHDR waveHdr; HGLOBAL16 hData; INT32 count, bufsize, left = mmckInfo.cksize; bufsize = 64000; hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize); waveHdr.lpData = (LPSTR)GlobalLock16(hData); waveHdr.dwBufferLength = bufsize; waveHdr.dwUser = 0L; waveHdr.dwFlags = 0L; waveHdr.dwLoops = 0L; dwRet = wodMessage(0, WODM_PREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR)); if (dwRet == MMSYSERR_NOERROR) { while (left) { if (PlaySound_Stop) { PlaySound_Stop = FALSE; PlaySound_Loop = FALSE; break; } if (bufsize > left) bufsize = left; count = mmioRead32(hmmio, waveHdr.lpData,bufsize); if (count < 1) break; left -= count; waveHdr.dwBufferLength = count; /* waveHdr.dwBytesRecorded = count; */ /* FIXME: doesn't expect async ops */ wodMessage(0, WODM_WRITE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR)); } wodMessage(0, WODM_UNPREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR)); wodMessage(0, WODM_CLOSE, 0, 0L, 0L); bRet = TRUE; } else WARN(mmsys, "can't prepare WaveOut device !\n"); GlobalUnlock16(hData); GlobalFree16(hData); } } } } } } while (PlaySound_Loop); if (hmmio != 0) mmioClose32(hmmio, 0); return bRet; } static DWORD WINAPI PlaySound_Thread(LPVOID arg) { DWORD res; for (;;) { PlaySound_Playing = FALSE; SetEvent(PlaySound_hReadyEvent); res = WaitForSingleObject(PlaySound_hPlayEvent, INFINITE32); ResetEvent(PlaySound_hReadyEvent); SetEvent(PlaySound_hMiddleEvent); if (res == WAIT_FAILED) ExitThread(2); if (res != WAIT_OBJECT_0) continue; PlaySound_Playing = TRUE; if ((PlaySound_fdwSound & SND_RESOURCE) == SND_RESOURCE) { HRSRC32 hRES; HGLOBAL32 hGLOB; void *ptr; if ((hRES = FindResource32A(PlaySound_hmod, PlaySound_pszSound, "WAVE")) == 0) { PlaySound_Result = FALSE; continue; } if ((hGLOB = LoadResource32(PlaySound_hmod, hRES)) == 0) { PlaySound_Result = FALSE; continue; } if ((ptr = LockResource32(hGLOB)) == NULL) { FreeResource32(hGLOB); PlaySound_Result = FALSE; continue; } PlaySound_Result = proc_PlaySound(ptr, ((UINT16)PlaySound_fdwSound ^ SND_RESOURCE) | SND_MEMORY); FreeResource32(hGLOB); continue; } PlaySound_Result=proc_PlaySound(PlaySound_pszSound, (UINT16)PlaySound_fdwSound); } } /************************************************************************** * PlaySoundA [WINMM.1] */ BOOL32 WINAPI PlaySound32A(LPCSTR pszSound, HMODULE32 hmod, DWORD fdwSound) { static LPSTR StrDup = NULL; TRACE(mmsys, "pszSound='%p' hmod=%04X fdwSound=%08lX\n", pszSound, hmod, fdwSound); if (PlaySound_hThread == 0) { /* This is the first time they called us */ DWORD id; if ((PlaySound_hReadyEvent = CreateEvent32A(NULL, TRUE, FALSE, NULL)) == 0) return FALSE; if ((PlaySound_hMiddleEvent = CreateEvent32A(NULL, FALSE, FALSE, NULL)) == 0) return FALSE; if ((PlaySound_hPlayEvent = CreateEvent32A(NULL, FALSE, FALSE, NULL)) == 0) return FALSE; if ((PlaySound_hThread = CreateThread(NULL, 0, PlaySound_Thread, 0, 0, &id)) == 0) return FALSE; } /* FIXME? I see no difference between SND_WAIT and SND_NOSTOP ! */ if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && PlaySound_Playing) return FALSE; /* Trying to stop if playing */ if (PlaySound_Playing) PlaySound_Stop = TRUE; /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave*/ if (WaitForSingleObject(PlaySound_hReadyEvent, 1000*10) != WAIT_OBJECT_0) return FALSE; if (!pszSound || (fdwSound & SND_PURGE)) return FALSE; /* We stoped playing so leaving */ if (PlaySound_SearchMode != 1) PlaySound_SearchMode = 2; if (!(fdwSound & SND_ASYNC)) { if (fdwSound & SND_LOOP) return FALSE; PlaySound_pszSound = pszSound; PlaySound_hmod = hmod; PlaySound_fdwSound = fdwSound; PlaySound_Result = FALSE; SetEvent(PlaySound_hPlayEvent); if (WaitForSingleObject(PlaySound_hMiddleEvent, INFINITE32) != WAIT_OBJECT_0) return FALSE; if (WaitForSingleObject(PlaySound_hReadyEvent, INFINITE32) != WAIT_OBJECT_0) return FALSE; return PlaySound_Result; } else { PlaySound_hmod = hmod; PlaySound_fdwSound = fdwSound; PlaySound_Result = FALSE; if (StrDup) { HeapFree(GetProcessHeap(), 0, StrDup); StrDup = NULL; } if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) && !((DWORD)pszSound >> 16)) || !pszSound)) { StrDup = HEAP_strdupA(GetProcessHeap(), 0,pszSound); PlaySound_pszSound = StrDup; } else PlaySound_pszSound = pszSound; PlaySound_Loop = fdwSound & SND_LOOP; SetEvent(PlaySound_hPlayEvent); ResetEvent(PlaySound_hMiddleEvent); return TRUE; } return FALSE; } /************************************************************************** * PlaySoundW [WINMM.18] */ BOOL32 WINAPI PlaySound32W(LPCWSTR pszSound, HMODULE32 hmod, DWORD fdwSound) { LPSTR pszSoundA; BOOL32 bSound; if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) && !((DWORD)pszSound >> 16)) || !pszSound)) { pszSoundA = HEAP_strdupWtoA(GetProcessHeap(), 0,pszSound); bSound = PlaySound32A(pszSoundA, hmod, fdwSound); HeapFree(GetProcessHeap(), 0,pszSoundA); } else bSound = PlaySound32A((LPCSTR)pszSound, hmod, fdwSound); return bSound; } /************************************************************************** * sndPlaySound [MMSYSTEM.2][WINMM135] */ BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags) { PlaySound_SearchMode = 1; return PlaySound32A(lpszSoundName, 0, uFlags); } /************************************************************************** * sndPlaySound [WINMM.136] */ BOOL16 WINAPI sndPlaySound32W(LPCWSTR lpszSoundName, UINT16 uFlags) { PlaySound_SearchMode = 1; return PlaySound32W(lpszSoundName, 0, uFlags); } /************************************************************************** * mmsystemGetVersion [WINMM.134] */ UINT32 WINAPI mmsystemGetVersion32() { return mmsystemGetVersion16(); } /************************************************************************** * mmsystemGetVersion [MMSYSTEM.5] * return value borrowed from Win95 winmm.dll ;) */ UINT16 WINAPI mmsystemGetVersion16() { TRACE(mmsys, "3.10 (Win95?)\n"); return 0x030a; } /************************************************************************** * DriverProc [MMSYSTEM.6] */ LRESULT WINAPI DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, DWORD dwParam1, DWORD dwParam2) { return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2); } /************************************************************************** * DriverCallback [MMSYSTEM.31] */ BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev, WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2) { TRACE(mmsys, "(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n", dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2); switch (uFlags & DCB_TYPEMASK) { case DCB_NULL: TRACE(mmsys, "CALLBACK_NULL !\n"); break; case DCB_WINDOW: TRACE(mmsys, "CALLBACK_WINDOW = %04lX handle = %04X!\n", dwCallBack, hDev); if (!IsWindow32(dwCallBack) || USER_HEAP_LIN_ADDR(hDev) == NULL) return FALSE; PostMessage32A((HWND16)dwCallBack, wMsg, hDev, dwParam1); break; case DCB_TASK: TRACE(mmsys, "CALLBACK_TASK !\n"); return FALSE; case DCB_FUNCTION: TRACE(mmsys, "CALLBACK_FUNCTION !\n"); Callbacks->CallDriverCallback((FARPROC16)dwCallBack, hDev, wMsg, dwUser, dwParam1, dwParam2 ); break; case DCB_FUNC32: TRACE(mmsys, "CALLBACK_FUNCTION !\n"); ((LPDRVCALLBACK32)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2 ); break; default: WARN(mmsys, "Unknown callback type\n"); break; } return TRUE; } /************************************************************************** * Mixer devices. New to Win95 */ /************************************************************************** * find out the real mixer ID depending on hmix (depends on dwFlags) * FIXME: also fix dwInstance passing to mixMessage */ static UINT32 _get_mixerID_from_handle(HMIXEROBJ32 hmix, DWORD dwFlags) { /* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix * accordingly. For now we always use mixerdevice 0. */ return 0; } /************************************************************************** * mixerGetNumDevs [WINMM.108] */ UINT32 WINAPI mixerGetNumDevs32() { return mixerGetNumDevs16(); } /************************************************************************** * mixerGetNumDevs */ UINT16 WINAPI mixerGetNumDevs16() { UINT16 count = mixMessage(0, MXDM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmaux,"mixerGetNumDevs returns %d\n",count); return count; } /************************************************************************** * mixerGetDevCapsW [WINMM.102] */ UINT32 WINAPI mixerGetDevCaps32W(UINT32 devid, LPMIXERCAPS32W mixcaps,UINT32 size) { MIXERCAPS16 mic16; UINT32 ret = mixerGetDevCaps16(devid, &mic16, sizeof(mic16)); mixcaps->wMid = mic16.wMid; mixcaps->wPid = mic16.wPid; mixcaps->vDriverVersion = mic16.vDriverVersion; lstrcpyAtoW(mixcaps->szPname, mic16.szPname); mixcaps->fdwSupport = mic16.fdwSupport; mixcaps->cDestinations = mic16.cDestinations; return ret; } /************************************************************************** * mixerGetDevCaps [WINMM.101] */ UINT32 WINAPI mixerGetDevCaps32A(UINT32 devid, LPMIXERCAPS32A mixcaps,UINT32 size) { MIXERCAPS16 mic16; UINT32 ret = mixerGetDevCaps16(devid, &mic16, sizeof(mic16)); mixcaps->wMid = mic16.wMid; mixcaps->wPid = mic16.wPid; mixcaps->vDriverVersion = mic16.vDriverVersion; strcpy(mixcaps->szPname, mic16.szPname); mixcaps->fdwSupport = mic16.fdwSupport; mixcaps->cDestinations = mic16.cDestinations; return ret; } /************************************************************************** * mixerGetDevCaps */ UINT16 WINAPI mixerGetDevCaps16(UINT16 devid, LPMIXERCAPS16 mixcaps,UINT16 size) { FIXME(mmsys,"should this be a fixme?\n"); return mixMessage(devid, MXDM_GETDEVCAPS, 0L, (DWORD)mixcaps, (DWORD)size); } /************************************************************************** * mixerOpen [WINMM.110] */ UINT32 WINAPI mixerOpen32(LPHMIXER32 lphmix,UINT32 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen) { HMIXER16 hmix16; UINT32 ret; FIXME(mmsys,"(%p,%d,%08lx,%08lx,%08lx): semi stub?\n", lphmix,uDeviceID, dwCallback, dwInstance, fdwOpen); ret = mixerOpen16(&hmix16,uDeviceID, dwCallback, dwInstance,fdwOpen); if (lphmix) *lphmix = hmix16; return ret; } /************************************************************************** * mixerOpen */ UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix,UINT16 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen) { HMIXER16 hmix; LPMIXEROPENDESC lpmod; BOOL32 mapperflag = (uDeviceID==0); DWORD dwRet=0; TRACE(mmsys,"(%p,%d,%08lx,%08lx,%08lx)\n", lphmix,uDeviceID, dwCallback, dwInstance, fdwOpen); hmix = USER_HEAP_ALLOC(sizeof(MIXEROPENDESC)); if (lphmix) *lphmix = hmix; lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix); lpmod->hmx = hmix; lpmod->dwCallback = dwCallback; lpmod->dwInstance = dwInstance; if (uDeviceID >= MAXMIXERDRIVERS) uDeviceID = 0; while (uDeviceID < MAXMIXERDRIVERS) { dwRet=mixMessage(uDeviceID, MXDM_OPEN, dwInstance, (DWORD)lpmod, fdwOpen); if (dwRet == MMSYSERR_NOERROR) break; if (!mapperflag) break; uDeviceID++; } lpmod->uDeviceID = uDeviceID; return dwRet; } /************************************************************************** * mixerClose [WINMM.98] */ UINT32 WINAPI mixerClose32(HMIXER32 hmix) { return mixerClose16(hmix); } /************************************************************************** * mixerClose */ UINT16 WINAPI mixerClose16(HMIXER16 hmix) { LPMIXEROPENDESC lpmod; FIXME(mmsys,"(%04x): semi-stub?\n", hmix); lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix); return mixMessage(lpmod->uDeviceID, MXDM_CLOSE, lpmod->dwInstance, 0L, 0L); } /************************************************************************** * mixerGetID [WINMM.103] */ UINT32 WINAPI mixerGetID32(HMIXEROBJ32 hmix, LPUINT32 lpid, DWORD fdwID) { UINT16 xid; UINT32 ret = mixerGetID16(hmix, &xid, fdwID); if (lpid) *lpid = xid; return ret; } /************************************************************************** * mixerGetID */ UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix,LPUINT16 lpid,DWORD fdwID) { FIXME(mmsys,"(%04x): semi-stub\n",hmix); if (lpid) *lpid = _get_mixerID_from_handle(hmix,fdwID); return MMSYSERR_NOERROR; /* FIXME: many error possibilities */ } /************************************************************************** * mixerGetControlDetailsA [WINMM.99] */ UINT32 WINAPI mixerGetControlDetails32A(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerGetControlDetailsW [WINMM.100] */ UINT32 WINAPI mixerGetControlDetails32W(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix,lpmcd,fdwDetails); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerGetControlDetails [MMSYSTEM.808] */ UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerGetLineControlsA [WINMM.104] */ UINT32 WINAPI mixerGetLineControls32A(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32A lpmlc,DWORD fdwControls) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerGetLineControlsW [WINMM.105] */ UINT32 WINAPI mixerGetLineControls32W(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32W lpmlc,DWORD fdwControls) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerGetLineControls [MMSYSTEM.807] */ UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,LPMIXERLINECONTROLS16 lpmlc,DWORD fdwControls) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerGetLineInfoA [WINMM.106] */ UINT32 WINAPI mixerGetLineInfo32A(HMIXEROBJ32 hmix,LPMIXERLINE32A lpml,DWORD fdwInfo) { MIXERLINE16 ml16; UINT32 ret; ml16.dwDestination = lpml->dwDestination; FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpml,fdwInfo); ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo); lpml->cbStruct = sizeof(*lpml); lpml->dwSource = ml16.dwSource; lpml->dwLineID = ml16.dwLineID; lpml->fdwLine = ml16.fdwLine; lpml->dwUser = ml16.dwUser; lpml->dwComponentType = ml16.dwComponentType; lpml->cChannels = ml16.cChannels; lpml->cConnections = ml16.cConnections; lpml->cControls = ml16.cControls; strcpy(lpml->szShortName, ml16.szShortName); strcpy(lpml->szName, ml16.szName); lpml->Target.dwType = ml16.Target.dwType; lpml->Target.dwDeviceID = ml16.Target.dwDeviceID; lpml->Target.wMid = ml16.Target.wMid; lpml->Target.wPid = ml16.Target.wPid; lpml->Target.vDriverVersion = ml16.Target.vDriverVersion; strcpy(lpml->Target.szPname, ml16.Target.szPname); return ret; } /************************************************************************** * mixerGetLineInfoW [WINMM.107] */ UINT32 WINAPI mixerGetLineInfo32W(HMIXEROBJ32 hmix, LPMIXERLINE32W lpml, DWORD fdwInfo) { MIXERLINE16 ml16; UINT32 ret; TRACE(mmsys,"(%04x,%p,%08lx)\n", hmix, lpml, fdwInfo); if (lpml == NULL || lpml->cbStruct != sizeof(*lpml)) return MMSYSERR_INVALPARAM; ml16.cbStruct = sizeof(ml16); ml16.dwDestination = lpml->dwDestination; ml16.dwSource = lpml->dwSource; ml16.dwLineID = lpml->dwLineID; ml16.dwUser = lpml->dwUser; ml16.dwComponentType = lpml->dwComponentType; ml16.cChannels = lpml->cChannels; ml16.cConnections = lpml->cConnections; ml16.cControls = lpml->cControls; ret = mixerGetLineInfo16(hmix, &ml16, fdwInfo); lpml->dwSource = ml16.dwSource; lpml->dwLineID = ml16.dwLineID; lpml->fdwLine = ml16.fdwLine; lpml->dwUser = ml16.dwUser; lpml->dwComponentType = ml16.dwComponentType; lpml->cChannels = ml16.cChannels; lpml->cConnections = ml16.cConnections; lpml->cControls = ml16.cControls; lstrcpyAtoW(lpml->szShortName, ml16.szShortName); lstrcpyAtoW(lpml->szName, ml16.szName); lpml->Target.dwType = ml16.Target.dwType; lpml->Target.dwDeviceID = ml16.Target.dwDeviceID; lpml->Target.wMid = ml16.Target.wMid; lpml->Target.wPid = ml16.Target.wPid; lpml->Target.vDriverVersion = ml16.Target.vDriverVersion; /*lstrcpyAtoW(lpml->Target.szPname, ml16.Target.szPname);*/ return ret; } /************************************************************************** * mixerGetLineInfo [MMSYSTEM.805] */ UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpml, DWORD fdwInfo) { UINT16 devid = _get_mixerID_from_handle(hmix, fdwInfo); FIXME(mmsys, "(%04x, %p[line %08lx], %08lx)\n", hmix, lpml, lpml->dwDestination, fdwInfo); return mixMessage(devid, MXDM_GETLINEINFO, 0, (DWORD)lpml, fdwInfo); } /************************************************************************** * mixerSetControlDetails [WINMM.111] */ UINT32 WINAPI mixerSetControlDetails32(HMIXEROBJ32 hmix, LPMIXERCONTROLDETAILS32 lpmcd, DWORD fdwDetails) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerSetControlDetails [MMSYSTEM.809] */ UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails) { FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails); return MMSYSERR_NOTENABLED; } /************************************************************************** * mixerMessage [WINMM.109] */ UINT32 WINAPI mixerMessage32(HMIXER32 hmix,UINT32 uMsg, DWORD dwParam1, DWORD dwParam2) { LPMIXEROPENDESC lpmod; UINT16 uDeviceID; lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix); if (lpmod) uDeviceID = lpmod->uDeviceID; else uDeviceID = 0; FIXME(mmsys,"(%04lx,%d,%08lx,%08lx): semi-stub?\n", (DWORD)hmix,uMsg, dwParam1, dwParam2); return mixMessage(uDeviceID,uMsg, 0L, dwParam1, dwParam2); } /************************************************************************** * mixerMessage [MMSYSTEM.804] */ UINT16 WINAPI mixerMessage16(HMIXER16 hmix,UINT16 uMsg, DWORD dwParam1, DWORD dwParam2) { LPMIXEROPENDESC lpmod; UINT16 uDeviceID; lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix); uDeviceID = (lpmod) ? lpmod->uDeviceID : 0; FIXME(mmsys,"(%04x,%d,%08lx,%08lx) - semi-stub?\n", hmix,uMsg, dwParam1, dwParam2); return mixMessage(uDeviceID,uMsg, 0L, dwParam1, dwParam2); } /************************************************************************** * auxGetNumDevs [WINMM.22] */ UINT32 WINAPI auxGetNumDevs32() { return auxGetNumDevs16(); } /************************************************************************** * auxGetNumDevs [MMSYSTEM.350] */ UINT16 WINAPI auxGetNumDevs16() { UINT16 count; TRACE(mmsys, "\n"); count = auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmsys, "=> %u\n", count); return count; } /************************************************************************** * auxGetDevCaps [WINMM.20] */ UINT32 WINAPI auxGetDevCaps32W(UINT32 uDeviceID, LPAUXCAPS32W lpCaps,UINT32 uSize) { AUXCAPS16 ac16; UINT32 ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16)); lpCaps->wMid = ac16.wMid; lpCaps->wPid = ac16.wPid; lpCaps->vDriverVersion = ac16.vDriverVersion; lstrcpyAtoW(lpCaps->szPname,ac16.szPname); lpCaps->wTechnology = ac16.wTechnology; lpCaps->dwSupport = ac16.dwSupport; return ret; } /************************************************************************** * auxGetDevCaps [WINMM.21] */ UINT32 WINAPI auxGetDevCaps32A(UINT32 uDeviceID, LPAUXCAPS32A lpCaps,UINT32 uSize) { AUXCAPS16 ac16; UINT32 ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16)); 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; return ret; } /************************************************************************** * auxGetDevCaps [MMSYSTEM.351] */ UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize) { TRACE(mmsys, "(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize); return auxMessage(uDeviceID, AUXDM_GETDEVCAPS, 0L, (DWORD)lpCaps, (DWORD)uSize); } /************************************************************************** * auxGetVolume [WINM.23] */ UINT32 WINAPI auxGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume) { return auxGetVolume16(uDeviceID, lpdwVolume); } /************************************************************************** * auxGetVolume [MMSYSTEM.352] */ UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume) { TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume); return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L); } /************************************************************************** * auxSetVolume [WINMM.25] */ UINT32 WINAPI auxSetVolume32(UINT32 uDeviceID, DWORD dwVolume) { return auxSetVolume16(uDeviceID, dwVolume); } /************************************************************************** * auxSetVolume [MMSYSTEM.353] */ UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume) { TRACE(mmsys, "(%04X, %08lX) !\n", uDeviceID, dwVolume); return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L); } /************************************************************************** * auxOutMessage [MMSYSTEM.354] */ DWORD WINAPI auxOutMessage32(UINT32 uDeviceID,UINT32 uMessage, DWORD dw1, DWORD dw2) { switch (uMessage) { case AUXDM_GETNUMDEVS: case AUXDM_GETVOLUME: case AUXDM_SETVOLUME: /* no argument conversion needed */ break; case AUXDM_GETDEVCAPS: return auxGetDevCaps32A(uDeviceID, (LPAUXCAPS32A)dw1, dw2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", uDeviceID,uMessage, dw1, dw2); break; } return auxMessage(uDeviceID,uMessage, 0L, dw1, dw2); } /************************************************************************** * auxOutMessage [MMSYSTEM.354] */ DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2) { TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", uDeviceID, uMessage, dw1, dw2); switch (uMessage) { case AUXDM_GETNUMDEVS: case AUXDM_SETVOLUME: /* no argument conversion needed */ break; case AUXDM_GETVOLUME: return auxGetVolume16(uDeviceID, (LPDWORD)PTR_SEG_TO_LIN(dw1)); case AUXDM_GETDEVCAPS: return auxGetDevCaps16(uDeviceID, (LPAUXCAPS16)PTR_SEG_TO_LIN(dw1), dw2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", uDeviceID,uMessage, dw1, dw2); break; } return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2); } /************************************************************************** * mciGetErrorStringW [WINMM.46] */ BOOL32 WINAPI mciGetErrorString32W(DWORD wError, LPWSTR lpstrBuffer,UINT32 uLength) { LPSTR bufstr = HeapAlloc(GetProcessHeap(), 0,uLength); BOOL32 ret = mciGetErrorString32A(wError,bufstr,uLength); lstrcpyAtoW(lpstrBuffer,bufstr); HeapFree(GetProcessHeap(), 0,bufstr); return ret; } /************************************************************************** * mciGetErrorStringA [WINMM.45] */ BOOL32 WINAPI mciGetErrorString32A(DWORD wError, LPSTR lpstrBuffer,UINT32 uLength) { return mciGetErrorString16(wError, lpstrBuffer,uLength); } /************************************************************************** * mciGetErrorString [MMSYSTEM.706] */ BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer,UINT16 uLength) { LPSTR msgptr; TRACE(mmsys, "(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength); if ((lpstrBuffer == NULL) || (uLength < 1)) return(FALSE); lpstrBuffer[0] = '\0'; switch (wError) { case 0: msgptr = "The specified command has been executed."; break; case MCIERR_INVALID_DEVICE_ID: msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device."; break; case MCIERR_UNRECOGNIZED_KEYWORD: msgptr = "The driver cannot recognize the specified command parameter."; break; case MCIERR_UNRECOGNIZED_COMMAND: msgptr = "The driver cannot recognize the specified command."; break; case MCIERR_HARDWARE: msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer."; break; case MCIERR_INVALID_DEVICE_NAME: msgptr = "The specified device is not open or is not recognized by MCI."; break; case MCIERR_OUT_OF_MEMORY: msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again."; break; case MCIERR_DEVICE_OPEN: msgptr = "The device name is already being used as an alias by this application. Use a unique alias."; break; case MCIERR_CANNOT_LOAD_DRIVER: msgptr = "There is an undetectable problem in loading the specified device driver."; break; case MCIERR_MISSING_COMMAND_STRING: msgptr = "No command was specified."; break; case MCIERR_PARAM_OVERFLOW: msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer."; break; case MCIERR_MISSING_STRING_ARGUMENT: msgptr = "The specified command requires a character-string parameter. Please provide one."; break; case MCIERR_BAD_INTEGER: msgptr = "The specified integer is invalid for this command."; break; case MCIERR_PARSER_INTERNAL: msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver."; break; case MCIERR_DRIVER_INTERNAL: msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver."; break; case MCIERR_MISSING_PARAMETER: msgptr = "The specified command requires a parameter. Please supply one."; break; case MCIERR_UNSUPPORTED_FUNCTION: msgptr = "The MCI device you are using does not support the specified command."; break; case MCIERR_FILE_NOT_FOUND: msgptr = "Cannot find the specified file. Make sure the path and filename are correct."; break; case MCIERR_DEVICE_NOT_READY: msgptr = "The device driver is not ready."; break; case MCIERR_INTERNAL: msgptr = "A problem occurred in initializing MCI. Try restarting Windows."; break; case MCIERR_DRIVER: msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error."; break; case MCIERR_CANNOT_USE_ALL: msgptr = "Cannot use 'all' as the device name with the specified command."; break; case MCIERR_MULTIPLE: msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error"; break; case MCIERR_EXTENSION_NOT_FOUND: msgptr = "Cannot determine the device type from the given filename extension."; break; case MCIERR_OUTOFRANGE: msgptr = "The specified parameter is out of range for the specified command."; break; case MCIERR_FLAGS_NOT_COMPATIBLE: msgptr = "The specified parameters cannot be used together."; break; case MCIERR_FILE_NOT_SAVED: msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network."; break; case MCIERR_DEVICE_TYPE_REQUIRED: msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly."; break; case MCIERR_DEVICE_LOCKED: msgptr = "The specified device is now being closed. Wait a few seconds, and then try again."; break; case MCIERR_DUPLICATE_ALIAS: msgptr = "The specified alias is already being used in this application. Use a unique alias."; break; case MCIERR_BAD_CONSTANT: msgptr = "The specified parameter is invalid for this command."; break; case MCIERR_MUST_USE_SHAREABLE: msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command."; break; case MCIERR_MISSING_DEVICE_NAME: msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one."; break; case MCIERR_BAD_TIME_FORMAT: msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats."; break; case MCIERR_NO_CLOSING_QUOTE: msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one."; break; case MCIERR_DUPLICATE_FLAGS: msgptr = "A parameter or value was specified twice. Only specify it once."; break; case MCIERR_INVALID_FILE: msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format."; break; case MCIERR_NULL_PARAMETER_BLOCK: msgptr = "A null parameter block was passed to MCI."; break; case MCIERR_UNNAMED_RESOURCE: msgptr = "Cannot save an unnamed file. Supply a filename."; break; case MCIERR_NEW_REQUIRES_ALIAS: msgptr = "You must specify an alias when using the 'new' parameter."; break; case MCIERR_NOTIFY_ON_AUTO_OPEN: msgptr = "Cannot use the 'notify' flag with auto-opened devices."; break; case MCIERR_NO_ELEMENT_ALLOWED: msgptr = "Cannot use a filename with the specified device."; break; case MCIERR_NONAPPLICABLE_FUNCTION: msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again."; break; case MCIERR_ILLEGAL_FOR_AUTO_OPEN: msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again."; break; case MCIERR_FILENAME_REQUIRED: msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension."; break; case MCIERR_EXTRA_CHARACTERS: msgptr = "Cannot specify extra characters after a string enclosed in quotation marks."; break; case MCIERR_DEVICE_NOT_INSTALLED: msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device."; break; case MCIERR_GET_CD: msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer."; break; case MCIERR_SET_CD: msgptr = "Cannot access the specified file or MCI device because the application cannot change directories."; break; case MCIERR_SET_DRIVE: msgptr = "Cannot access specified file or MCI device because the application cannot change drives."; break; case MCIERR_DEVICE_LENGTH: msgptr = "Specify a device or driver name that is less than 79 characters."; break; case MCIERR_DEVICE_ORD_LENGTH: msgptr = "Specify a device or driver name that is less than 69 characters."; break; case MCIERR_NO_INTEGER: msgptr = "The specified command requires an integer parameter. Please provide one."; break; case MCIERR_WAVE_OUTPUTSINUSE: msgptr = "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again."; break; case MCIERR_WAVE_SETOUTPUTINUSE: msgptr = "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again."; break; case MCIERR_WAVE_INPUTSINUSE: msgptr = "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again."; break; case MCIERR_WAVE_SETINPUTINUSE: msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again."; break; case MCIERR_WAVE_OUTPUTUNSPECIFIED: msgptr = "Any compatible waveform playback device may be used."; break; case MCIERR_WAVE_INPUTUNSPECIFIED: msgptr = "Any compatible waveform recording device may be used."; break; case MCIERR_WAVE_OUTPUTSUNSUITABLE: msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device."; break; case MCIERR_WAVE_SETOUTPUTUNSUITABLE: msgptr = "The device you are trying to play to cannot recognize the current file format."; break; case MCIERR_WAVE_INPUTSUNSUITABLE: msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device."; break; case MCIERR_WAVE_SETINPUTUNSUITABLE: msgptr = "The device you are trying to record from cannot recognize the current file format."; break; case MCIERR_NO_WINDOW: msgptr = "There is no display window."; break; case MCIERR_CREATEWINDOW: msgptr = "Could not create or use window."; break; case MCIERR_FILE_READ: msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection."; break; case MCIERR_FILE_WRITE: msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network."; break; case MCIERR_SEQ_DIV_INCOMPATIBLE: msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together."; break; case MCIERR_SEQ_NOMIDIPRESENT: msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver."; break; case MCIERR_SEQ_PORT_INUSE: msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again."; break; case MCIERR_SEQ_PORT_MAPNODEVICE: msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup."; break; case MCIERR_SEQ_PORT_MISCERROR: msgptr = "An error occurred with the specified port."; break; case MCIERR_SEQ_PORT_NONEXISTENT: msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device."; break; case MCIERR_SEQ_PORTUNSPECIFIED: msgptr = "The system doesnot have a current MIDI port specified."; break; case MCIERR_SEQ_TIMER: msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again."; break; /* msg# 513 : vcr msg# 514 : videodisc msg# 515 : overlay msg# 516 : cdaudio msg# 517 : dat msg# 518 : scanner msg# 519 : animation msg# 520 : digitalvideo msg# 521 : other msg# 522 : waveaudio msg# 523 : sequencer msg# 524 : not ready msg# 525 : stopped msg# 526 : playing msg# 527 : recording msg# 528 : seeking msg# 529 : paused msg# 530 : open msg# 531 : false msg# 532 : true msg# 533 : milliseconds msg# 534 : hms msg# 535 : msf msg# 536 : frames msg# 537 : smpte 24 msg# 538 : smpte 25 msg# 539 : smpte 30 msg# 540 : smpte 30 drop msg# 541 : bytes msg# 542 : samples msg# 543 : tmsf */ default: msgptr = "Unknown MCI Error !\n"; break; } lstrcpyn32A(lpstrBuffer, msgptr, uLength); TRACE(mmsys, "msg = %s;\n", msgptr); return TRUE; } /************************************************************************** * mciDriverNotify [MMSYSTEM.711] */ BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus) { TRACE(mmsys, "(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus); if (!IsWindow32(hWndCallBack)) { WARN(mmsys, "bad hWnd for call back\n"); return FALSE; } TRACE(mmsys, "before PostMessage\n"); PostMessage32A(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID); return TRUE; } /************************************************************************** * mciDriverNotify32 [WINMM.36] */ BOOL32 WINAPI mciDriverNotify32(HWND32 hWndCallBack, UINT32 wDevID, UINT32 wStatus) { FIXME(mmsys, "(%08X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus); if (!IsWindow32(hWndCallBack)) { WARN(mmsys, "bad hWnd for call back\n"); return FALSE; } TRACE(mmsys, "before PostMessage\n"); PostMessage32A(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID); return TRUE; } /************************************************************************** * mciGetDriverData [MMSYSTEM.708] */ DWORD WINAPI mciGetDriverData16(HDRVR16 hdrv) { return mciGetDriverData32(hdrv); } /************************************************************************** * mciGetDriverData [WINMM.44] */ DWORD WINAPI mciGetDriverData32(HDRVR32 hdrv) { TRACE(mmsys,"(%04x)\n", hdrv); if (!MCI_DevIDValid(hdrv) || MCI_GetDrv(hdrv)->modp.wType == 0) { return 0L; } return MCI_GetDrv(hdrv)->dwPrivate; } /************************************************************************** * mciSetDriverData [MMSYSTEM.707] */ BOOL16 WINAPI mciSetDriverData16(HDRVR16 hdrv, DWORD data) { return mciSetDriverData32(hdrv, data); } /************************************************************************** * mciSetDriverData [WINMM.53] */ BOOL32 WINAPI mciSetDriverData32(HDRVR32 hdrv, DWORD data) { TRACE(mmsys,"(%04x,%08lx)\n", hdrv, data); if (!MCI_DevIDValid(hdrv) || MCI_GetDrv(hdrv)->modp.wType == 0) { return FALSE; } MCI_GetDrv(hdrv)->dwPrivate = data; return TRUE; } /************************************************************************** * mciLoadCommandResource [MMSYSTEM.705] */ UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hinst, LPCSTR resname,UINT16 type) { char buf[200]; OFSTRUCT ofs; HANDLE16 xhinst; HRSRC16 hrsrc; HGLOBAL16 hmem; LPSTR segstr; SEGPTR xmem; LPBYTE lmem; static UINT16 mcidevtype = 0; FIXME(mmsys,"(%04x,%s,%d): stub!\n", hinst, resname, type); if (!lstrcmpi32A(resname,"core")) { FIXME(mmsys, "(...,\"core\",...), have to use internal tables... (not there yet)\n"); return 0; } /* if file exists "resname.mci", then load resource "resname" from it * otherwise directly from driver */ strcpy(buf,resname); strcat(buf,".mci"); if (OpenFile32(buf, &ofs,OF_EXIST) != HFILE_ERROR32) { xhinst = LoadLibrary16(buf); if (xhinst >32) hinst = xhinst; } /* else use passed hinst */ segstr = SEGPTR_STRDUP(resname); hrsrc = FindResource16(hinst, SEGPTR_GET(segstr), type); SEGPTR_FREE(segstr); if (!hrsrc) { WARN(mmsys,"no special commandlist found in resource\n"); return MCI_NO_COMMAND_TABLE; } hmem = LoadResource16(hinst, hrsrc); if (!hmem) { WARN(mmsys,"couldn't load resource??\n"); return MCI_NO_COMMAND_TABLE; } xmem = WIN16_LockResource16(hmem); if (!xmem) { WARN(mmsys,"couldn't lock resource??\n"); FreeResource16(hmem); return MCI_NO_COMMAND_TABLE; } lmem = PTR_SEG_TO_LIN(xmem); TRACE(mmsys, "first resource entry is %s\n", (char*)lmem); /* parse resource, register stuff, return unique id */ return ++mcidevtype; } /************************************************************************** * mciFreeCommandResource [MMSYSTEM.713] */ BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable) { FIXME(mci, "(%04x) stub\n", uTable); return 0; } /************************************************************************** * mciFreeCommandResource [WINMM.39] */ BOOL32 WINAPI mciFreeCommandResource32(UINT32 uTable) { FIXME(mci, "(%08x) stub\n", uTable); return 0; } /************************************************************************** * mciLoadCommandResource [WINMM.48] */ UINT32 WINAPI mciLoadCommandResource32(HANDLE32 hinst, LPCSTR resname,UINT32 type) { return mciLoadCommandResource16(hinst, resname, type); } const char* MCI_CommandToString(UINT16 wMsg) { static char buffer[100]; #define CASE(s) case (s): return #s switch (wMsg) { CASE(MCI_OPEN); CASE(MCI_CLOSE); CASE(MCI_ESCAPE); CASE(MCI_PLAY); CASE(MCI_SEEK); CASE(MCI_STOP); CASE(MCI_PAUSE); CASE(MCI_INFO); CASE(MCI_GETDEVCAPS); CASE(MCI_SPIN); CASE(MCI_SET); CASE(MCI_STEP); CASE(MCI_RECORD); CASE(MCI_SYSINFO); CASE(MCI_BREAK); CASE(MCI_SAVE); CASE(MCI_STATUS); CASE(MCI_CUE); CASE(MCI_REALIZE); CASE(MCI_WINDOW); CASE(MCI_PUT); CASE(MCI_WHERE); CASE(MCI_FREEZE); CASE(MCI_UNFREEZE); CASE(MCI_LOAD); CASE(MCI_CUT); CASE(MCI_COPY); CASE(MCI_PASTE); CASE(MCI_UPDATE); CASE(MCI_RESUME); CASE(MCI_DELETE); default: sprintf(buffer, "MCI_<<%04X>>", wMsg); return buffer; } } /************************************************************************** * MCI_SendCommand32 [internal] */ DWORD MCI_SendCommand32(UINT32 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2) { DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED; if (!MCI_DevIDValid(wDevID)) { dwRet = MCIERR_INVALID_DEVICE_ID; } else { MCIPROC32 proc = MCI_GetProc32(MCI_GetDrv(wDevID)->modp.wType); if (proc) { dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID, MCI_GetDrv(wDevID)->hDrv, wMsg, dwParam1, dwParam2); } else if (MCI_GetDrv(wDevID)->driverProc) { FIXME(mmsys, "is that correct ?\n"); dwRet = Callbacks->CallDriverProc(MCI_GetDrv(wDevID)->driverProc, MCI_GetDrv(wDevID)->modp.wDeviceID, MCI_GetDrv(wDevID)->hDrv, wMsg, dwParam1, dwParam2); } else { WARN(mmsys, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType); } } return dwRet; } /************************************************************************** * MCI_Open [internal] */ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms) { char str[128]; UINT16 uDevTyp = 0; UINT16 wDevID = MCI_FirstDevID(); DWORD dwRet; TRACE(mmsys, "(%08lX, %p)\n", dwParam, lpParms); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if ((dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) { FIXME(mmsys, "unsupported yet dwFlags=%08lX\n", (dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT))); } while (MCI_GetDrv(wDevID)->modp.wType != 0) { wDevID = MCI_NextDevID(wDevID); if (!MCI_DevIDValid(wDevID)) { TRACE(mmsys, "MAXMCIDRIVERS reached !\n"); return MCIERR_OUT_OF_MEMORY; } } TRACE(mmsys, "wDevID=%04X \n", wDevID); memcpy(MCI_GetOpenDrv(wDevID), lpParms, sizeof(*lpParms)); if (dwParam & MCI_OPEN_ELEMENT) { char *s,*t; TRACE(mmsys,"lpstrElementName='%s'\n", lpParms->lpstrElementName); s = lpParms->lpstrElementName; t = strrchr(s, '.'); if (t) { GetProfileString32A("mci extensions", t+1, "*", str, sizeof(str)); CharUpper32A(str); uDevTyp = MCI_GetDevType(str); if (uDevTyp == 0) { if (strcmp(str,"*") == 0) { TRACE(mmsys,"No [mci extensions] entry for %s found.\n", t); return MCIERR_EXTENSION_NOT_FOUND; } #if testing32 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */ else { HDRVR16 hdrv = OpenDriver32(str, "mci", NULL); if (hdrv) { HMODULE16 hmod; hmod = GetDriverModuleHandle(hdrv); MCI_GetDrv(wDevID)->hDrv = hdrv; MCI_GetDrv(wDevID)->driverProc = GetProcAddress32(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC"))); uDevTyp = MCI_DEVTYPE_OTHER; } else { FIXME(mmsys, "[mci extensions] entry %s for %s not supported.\n", str, t); return MCIERR_DEVICE_NOT_INSTALLED; } } #endif } } else if (GetDriveType32A(s) == DRIVE_CDROM) { /* FIXME: this will not work if several CDROM drives are installed on the machine */ uDevTyp = MCI_DEVTYPE_CD_AUDIO; } else { return MCIERR_EXTENSION_NOT_FOUND; } } if (dwParam & MCI_OPEN_ALIAS) { TRACE(mmsys, "Alias='%s' !\n", lpParms->lpstrAlias); /* FIXME is there any memory leak here ? */ MCI_GetOpenDrv(wDevID)->lpstrAlias = strdup(lpParms->lpstrAlias); /* mplayer does allocate alias to CDAUDIO */ } if (dwParam & MCI_OPEN_TYPE) { if (dwParam & MCI_OPEN_TYPE_ID) { TRACE(mmsys, "Dev=%08lx!\n", (DWORD)lpParms->lpstrDeviceType); uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType); MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType; } else { if (lpParms->lpstrDeviceType == NULL) return MCIERR_NULL_PARAMETER_BLOCK; TRACE(mmsys, "Dev='%s' !\n", lpParms->lpstrDeviceType); /* FIXME is there any memory leak here ? */ MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType); strcpy(str, lpParms->lpstrDeviceType); CharUpper32A(str); uDevTyp = MCI_GetDevType(str); if (uDevTyp == 0) { #if testing32 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */ HDRVR16 hdrv; TRACE(mmsys,"trying to load driver...\n"); hdrv = OpenDriver32(str,"mci",NULL); if (hdrv) { HMODULE16 hmod; hmod = GetDriverModuleHandle(hdrv); MCI_GetDrv(wDevID)->hDrv = hdrv; MCI_GetDrv(wDevID)->driverProc = GetProcAddress32(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DriverProc"))); uDevTyp = MCI_DEVTYPE_OTHER; } else #endif return MCIERR_DEVICE_NOT_INSTALLED; } } } MCI_GetDrv(wDevID)->modp.wType = uDevTyp; MCI_GetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */ MCI_GetDrv(wDevID)->dwPrivate = 0; lpParms->wDeviceID = wDevID; TRACE(mmsys, "mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n", wDevID, uDevTyp, lpParms->wDeviceID); dwRet = MCI_SendCommand32(wDevID, MCI_OPEN_DRIVER, dwParam, (DWORD)lpParms); if (dwRet == 0) { /* only handled devices fall through */ TRACE(mmsys, "wDevID = %04X wDeviceID = %d dwRet = %ld\n", wDevID, lpParms->wDeviceID, dwRet); } else { TRACE(mmsys, "failed to open driver (MCI_OPEN_DRIVER msg) [%08lx], closing\n", dwRet); MCI_GetDrv(wDevID)->modp.wType = 0; } if (dwParam & MCI_NOTIFY) mciDriverNotify16(lpParms->dwCallback, wDevID, dwRet == 0 ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE); return dwRet; } /************************************************************************** * MCI_Close [internal] */ static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { DWORD dwRet; TRACE(mmsys, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms); if (wDevID == MCI_ALL_DEVICE_ID) { FIXME(mmsys, "unhandled MCI_ALL_DEVICE_ID\n"); return MCIERR_CANNOT_USE_ALL; } dwRet = MCI_SendCommand32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms); MCI_GetDrv(wDevID)->modp.wType = 0; if (dwParam&MCI_NOTIFY) mciDriverNotify16(lpParms->dwCallback, wDevID, (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE)); TRACE(mmsys, "returns %ld\n", dwRet); return dwRet; } /************************************************************************** * MCI_WriteString [internal] */ DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr) { DWORD ret; if (dstSize <= strlen(lpSrcStr)) { lstrcpyn32A(lpDstStr, lpSrcStr, dstSize - 1); ret = MCIERR_PARAM_OVERFLOW; } else { strcpy(lpDstStr, lpSrcStr); ret = 0; } return ret; } /************************************************************************** * MCI_Sysinfo [internal] */ static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lpParms) { DWORD ret = MCIERR_INVALID_DEVICE_ID; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; TRACE(mci, "(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n", uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType); switch (dwFlags & ~MCI_SYSINFO_OPEN) { case MCI_SYSINFO_QUANTITY: { DWORD cnt = 0; WORD i; if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) { if (dwFlags & MCI_SYSINFO_OPEN) { TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers\n"); for (i = 0; i < MAXMCIDRIVERS; i++) { if (mciDrv[i].modp.wType != 0) cnt++; } } else { TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n"); cnt = mciInstalledCount; } } else { if (dwFlags & MCI_SYSINFO_OPEN) { TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType); for (i = 0; i < MAXMCIDRIVERS; i++) { if (mciDrv[i].modp.wType == lpParms->wDeviceType) cnt++; } } else { TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType); FIXME(mci, "Don't know how to get # of MCI devices of a given type\n"); cnt = 1; } } *(DWORD*)lpParms->lpstrReturn = cnt; } TRACE(mci, "(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn); ret = 0; break; case MCI_SYSINFO_INSTALLNAME: TRACE(mci, "MCI_SYSINFO_INSTALLNAME \n"); if (MCI_DevIDValid(uDevID)) { LPCSTR str = MCI_GetDevTypeString(MCI_GetDrv(uDevID)->modp.wType); ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str); } else { *lpParms->lpstrReturn = 0; ret = MCIERR_INVALID_DEVICE_ID; } TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn); break; case MCI_SYSINFO_NAME: TRACE(mci, "MCI_SYSINFO_NAME\n"); if (dwFlags & MCI_SYSINFO_OPEN) { FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n"); ret = MCIERR_UNRECOGNIZED_COMMAND; } else if (lpParms->dwNumber > mciInstalledCount) { ret = MCIERR_OUTOFRANGE; } else { DWORD count = lpParms->dwNumber; LPSTR ptr = lpmciInstallNames; while (--count > 0) ptr += strlen(ptr) + 1; ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr); } TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn); break; default: TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags); ret = MCIERR_UNRECOGNIZED_COMMAND; } return ret; } struct SCA32 { UINT32 wDevID; UINT32 wMsg; DWORD dwParam1; DWORD dwParam2; BOOL32 allocatedCopy; }; DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2); /************************************************************************** * MCI_SCAStarter32 [internal] */ static DWORD WINAPI MCI_SCAStarter32(LPVOID arg) { struct SCA32* sca = (struct SCA32*)arg; DWORD ret; TRACE(mci, "In thread before async command (%08x,%s,%08lx,%08lx)\n", sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2); ret = mciSendCommand32A(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2); TRACE(mci, "In thread after async command (%08x,%s,%08lx,%08lx)\n", sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2); if (sca->allocatedCopy) HeapFree(GetProcessHeap(), 0, (LPVOID)sca->dwParam2); HeapFree(GetProcessHeap(), 0, sca); ExitThread(ret); WARN(mci, "Should not happen ? what's wrong \n"); /* should not go after this point */ return ret; } /************************************************************************** * MCI_SendCommandAsync32 [internal] */ DWORD MCI_SendCommandAsync32(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2, UINT32 size) { struct SCA32* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA32)); if (sca == 0) return MCIERR_OUT_OF_MEMORY; sca->wDevID = wDevID; sca->wMsg = wMsg; sca->dwParam1 = dwParam1; if (size) { sca->dwParam2 = (DWORD)HeapAlloc(GetProcessHeap(), 0, size); if (sca->dwParam2 == 0) { HeapFree(GetProcessHeap(), 0, sca); return MCIERR_OUT_OF_MEMORY; } sca->allocatedCopy = TRUE; /* copy structure passed by program in dwParam2 to be sure * we can still use it whatever the program does */ memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size); } else { sca->dwParam2 = dwParam2; sca->allocatedCopy = FALSE; } if (CreateThread(NULL, 0, MCI_SCAStarter32, sca, 0, NULL) == 0) { WARN(mci, "Couldn't allocate thread for async command handling, sending synchonously\n"); return MCI_SCAStarter32(&sca); } return 0; } /************************************************************************** * MCI_MapMsg16To32A [internal] */ int MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam) { if (*lParam == 0) return 0; /* FIXME: to add also (with seg/linear modifications to do): * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO, MCI_WINDOW */ switch (wMsg) { /* case MCI_CAPTURE */ case MCI_CLOSE: case MCI_CLOSE_DRIVER: /* case MCI_CONFIGURE:*/ case MCI_COPY: case MCI_CUE: case MCI_CUT: case MCI_DELETE: case MCI_FREEZE: case MCI_GETDEVCAPS: /* case MCI_INDEX: */ /* case MCI_MARK: */ /* case MCI_MONITOR: */ case MCI_PASTE: case MCI_PAUSE: case MCI_PLAY: case MCI_PUT: case MCI_REALIZE: case MCI_RECORD: case MCI_RESUME: case MCI_SEEK: case MCI_SET: /* case MCI_SETTIMECODE:*/ /* case MCI_SIGNAL:*/ case MCI_SPIN: case MCI_STATUS: /* FIXME: is wrong for digital video */ case MCI_STEP: case MCI_STOP: /* case MCI_UNDO: */ case MCI_UNFREEZE: case MCI_UPDATE: case MCI_WHERE: *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam); return 0; case MCI_BREAK: { LPMCI_BREAK_PARMS32 mbp32 = HeapAlloc(SystemHeap, 0, sizeof(MCI_BREAK_PARMS32)); LPMCI_BREAK_PARMS16 mbp16 = PTR_SEG_TO_LIN(*lParam); if (mbp32) { mbp32->dwCallback = mbp16->dwCallback; mbp32->nVirtKey = mbp16->nVirtKey; mbp32->hwndBreak = mbp16->hwndBreak; } else { return -2; } *lParam = (DWORD)mbp32; } return 1; case MCI_ESCAPE: { LPMCI_VD_ESCAPE_PARMS32A mvep32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_VD_ESCAPE_PARMS32A)); LPMCI_VD_ESCAPE_PARMS16 mvep16 = PTR_SEG_TO_LIN(*lParam); if (mvep32a) { mvep32a->dwCallback = mvep16->dwCallback; mvep32a->lpstrCommand = PTR_SEG_TO_LIN(mvep16->lpstrCommand); } else { return -2; } *lParam = (DWORD)mvep32a; } return 1; case MCI_INFO: { LPMCI_INFO_PARMS32A mip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_INFO_PARMS32A)); LPMCI_INFO_PARMS16 mip16 = PTR_SEG_TO_LIN(*lParam); /* FIXME this is wrong if device is of type * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped */ if (mip32a) { mip32a->dwCallback = mip16->dwCallback; mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn); mip32a->dwRetSize = mip16->dwRetSize; } else { return -2; } *lParam = (DWORD)mip32a; } return 1; case MCI_OPEN: case MCI_OPEN_DRIVER: { LPMCI_OPEN_PARMS32A mop32a = HeapAlloc(SystemHeap, 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMS32A) + 2 * sizeof(DWORD)); LPMCI_OPEN_PARMS16 mop16 = PTR_SEG_TO_LIN(*lParam); if (mop32a) { *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16; mop32a = (LPMCI_OPEN_PARMS32A)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16)); mop32a->dwCallback = mop16->dwCallback; mop32a->wDeviceID = mop16->wDeviceID; mop32a->lpstrDeviceType = PTR_SEG_TO_LIN(mop16->lpstrDeviceType); mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName); mop32a->lpstrAlias = PTR_SEG_TO_LIN(mop16->lpstrAlias); /* copy extended information if any... * FIXME: this may seg fault if initial structure does not contain them and * the reads after msip16 fail under LDT limits... * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and * should not take care of extended parameters, and should be used by MCI_Open * to fetch uDevTyp. When, this is known, the mapping for sending the * MCI_OPEN_DRIVER shall be done depending on uDevTyp. */ ((DWORD*)(mop32a + 1))[0] = ((DWORD*)(mop16 + 1))[0]; ((DWORD*)(mop32a + 1))[1] = ((DWORD*)(mop16 + 1))[1]; } else { return -2; } *lParam = (DWORD)mop32a; } return 1; case MCI_SYSINFO: { LPMCI_SYSINFO_PARMS32A msip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_SYSINFO_PARMS32A)); LPMCI_SYSINFO_PARMS16 msip16 = PTR_SEG_TO_LIN(*lParam); if (msip32a) { msip32a->dwCallback = msip16->dwCallback; msip32a->lpstrReturn = PTR_SEG_TO_LIN(msip16->lpstrReturn); msip32a->dwRetSize = msip16->dwRetSize; msip32a->dwNumber = msip16->dwNumber; msip32a->wDeviceType = msip16->wDeviceType; } else { return -2; } *lParam = (DWORD)msip32a; } return 1; case DRV_LOAD: case DRV_ENABLE: case DRV_OPEN: case DRV_CLOSE: case DRV_DISABLE: case DRV_FREE: case DRV_CONFIGURE: case DRV_QUERYCONFIGURE: case DRV_INSTALL: case DRV_REMOVE: case DRV_EXITSESSION: case DRV_EXITAPPLICATION: case DRV_POWER: FIXME(mci, "This is a hack\n"); return 0; default: WARN(mci, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg)); } return -1; } /************************************************************************** * MCI_UnMapMsg16To32A [internal] */ int MCI_UnMapMsg16To32A(WORD uDevTyp, WORD wMsg, DWORD lParam) { switch (wMsg) { /* case MCI_CAPTURE */ case MCI_CLOSE: case MCI_CLOSE_DRIVER: /* case MCI_CONFIGURE:*/ case MCI_COPY: case MCI_CUE: case MCI_CUT: case MCI_DELETE: case MCI_FREEZE: case MCI_GETDEVCAPS: /* case MCI_INDEX: */ /* case MCI_MARK: */ /* case MCI_MONITOR: */ case MCI_PASTE: case MCI_PAUSE: case MCI_PLAY: case MCI_PUT: case MCI_REALIZE: case MCI_RECORD: case MCI_RESUME: case MCI_SEEK: case MCI_SET: /* case MCI_SETTIMECODE:*/ /* case MCI_SIGNAL:*/ case MCI_SPIN: case MCI_STATUS: case MCI_STEP: case MCI_STOP: /* case MCI_UNDO: */ case MCI_UNFREEZE: case MCI_UPDATE: case MCI_WHERE: return 0; case MCI_BREAK: case MCI_ESCAPE: case MCI_INFO: case MCI_SYSINFO: HeapFree(SystemHeap, 0, (LPVOID)lParam); return 0; case MCI_OPEN: case MCI_OPEN_DRIVER: if (lParam) { LPMCI_OPEN_PARMS32A mop32a = (MCI_OPEN_PARMS32A*)lParam; LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16*)); mop16->wDeviceID = mop32a->wDeviceID; HeapFree(SystemHeap, 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))); } return 0; case DRV_LOAD: case DRV_ENABLE: case DRV_OPEN: case DRV_CLOSE: case DRV_DISABLE: case DRV_FREE: case DRV_CONFIGURE: case DRV_QUERYCONFIGURE: case DRV_INSTALL: case DRV_REMOVE: case DRV_EXITSESSION: case DRV_EXITAPPLICATION: case DRV_POWER: FIXME(mci, "This is a hack\n"); return 0; default: FIXME(mci, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg)); } return -1; } /************************************************************************** * mciSendCommandA [WINMM.49] */ DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2) { TRACE(mci, "(%08x,%s,%08lx,%08lx)\n", wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2); switch (wMsg) { case MCI_OPEN: return MCI_Open(dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2); case MCI_CLOSE: return MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); case MCI_SYSINFO: return MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMS32A)dwParam2); default: if (wDevID == MCI_ALL_DEVICE_ID) { FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n"); return MCIERR_CANNOT_USE_ALL; } return MCI_SendCommand32(wDevID, wMsg, dwParam1, dwParam2); } } /************************************************************************** * mciSendCommandW [WINMM.50] */ DWORD WINAPI mciSendCommand32W(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2) { return 0x1; /* !ok */ } /************************************************************************** * mciSendCommand [MMSYSTEM.701] */ DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2) { DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND; TRACE(mmsys, "(%04X, %s, %08lX, %08lX)\n", wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2); switch (wMsg) { case MCI_OPEN: if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) { dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2); MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2); } break; case MCI_CLOSE: if (wDevID == MCI_ALL_DEVICE_ID) { FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n"); dwRet = MCIERR_CANNOT_USE_ALL; } else if (!MCI_DevIDValid(wDevID)) { dwRet = MCIERR_INVALID_DEVICE_ID; } else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) { dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2); } break; case MCI_SYSINFO: if (MCI_MapMsg16To32A(0, wDevID, &dwParam2) >= 0) { dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMS32A)dwParam2); MCI_UnMapMsg16To32A(0, wDevID, dwParam2); } break; /* FIXME: it seems that MCI_BREAK and MCI_SOUND need the same handling */ default: if (wDevID == MCI_ALL_DEVICE_ID) { FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n"); dwRet = MCIERR_CANNOT_USE_ALL; } else if (!MCI_DevIDValid(wDevID)) { dwRet = MCIERR_INVALID_DEVICE_ID; } else { int res; switch (res = MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) { case -1: TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg)); break; case -2: TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg)); case 0: case 1: dwRet = MCI_SendCommand32(wDevID, wMsg, dwParam1, dwParam2); if (res) MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2); break; } } } return dwRet; } /************************************************************************** * mciGetDeviceID [MMSYSTEM.703] */ UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName) { UINT16 wDevID; TRACE(mmsys, "(\"%s\")\n", lpstrName); if (!lpstrName) return 0; if (!lstrcmpi32A(lpstrName, "ALL")) return MCI_ALL_DEVICE_ID; for (wDevID = MCI_FirstDevID(); MCI_DevIDValid(wDevID); wDevID = MCI_NextDevID(wDevID)) { if (MCI_GetDrv(wDevID)->modp.wType) { FIXME(mmsys, "This is wrong for compound devices\n"); /* FIXME: for compound devices, lpstrName is matched against * the name of the file, not the name of the device... */ if (MCI_GetOpenDrv(wDevID)->lpstrDeviceType && strcmp(MCI_GetOpenDrv(wDevID)->lpstrDeviceType, lpstrName) == 0) return wDevID; if (MCI_GetOpenDrv(wDevID)->lpstrAlias && strcmp(MCI_GetOpenDrv(wDevID)->lpstrAlias, lpstrName) == 0) return wDevID; } } return 0; } /************************************************************************** * mciGetDeviceIDA [WINMM.41] */ UINT32 WINAPI mciGetDeviceID32A(LPCSTR lpstrName) { return mciGetDeviceID16(lpstrName); } /************************************************************************** * mciGetDeviceIDW [WINMM.43] */ UINT32 WINAPI mciGetDeviceID32W(LPCWSTR lpwstrName) { LPSTR lpstrName; UINT32 ret; lpstrName = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName); ret = mciGetDeviceID16(lpstrName); HeapFree(GetProcessHeap(), 0, lpstrName); return ret; } /************************************************************************** * mciSetYieldProc [MMSYSTEM.714] */ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData) { FIXME(mci, "(%u, %p, %08lx) stub\n", uDeviceID, fpYieldProc, dwYieldData); return FALSE; } /************************************************************************** * mciSetYieldProc [WINMM.54] */ BOOL32 WINAPI mciSetYieldProc32(UINT32 uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData) { FIXME(mci, "(%u, %p, %08lx) stub\n", uDeviceID, fpYieldProc, dwYieldData); return FALSE; } /************************************************************************** * mciGetDeviceIDFromElementID [MMSYSTEM.715] */ UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType) { FIXME(mci, "(%lu, %s) stub\n", dwElementID, lpstrType); return 0; } /************************************************************************** * mciGetDeviceIDFromElementIDW [WINMM.42] */ UINT32 WINAPI mciGetDeviceIDFromElementID32W(DWORD dwElementID, LPCWSTR lpstrType) { /* FIXME: that's rather strange, there is no * mciGetDeviceIDFromElementID32A in winmm.spec */ FIXME(mci, "(%lu, %p) stub\n", dwElementID, lpstrType); return 0; } /************************************************************************** * mciGetYieldProc [MMSYSTEM.716] */ YIELDPROC WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData) { FIXME(mci, "(%u, %p) stub\n", uDeviceID, lpdwYieldData); return NULL; } /************************************************************************** * mciGetYieldProc [WINMM.47] */ YIELDPROC WINAPI mciGetYieldProc32(UINT32 uDeviceID, DWORD* lpdwYieldData) { FIXME(mci, "(%u, %p) stub\n", uDeviceID, lpdwYieldData); return NULL; } /************************************************************************** * mciGetCreatorTask [MMSYSTEM.717] */ HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID) { FIXME(mci, "(%u) stub\n", uDeviceID); return 0; } /************************************************************************** * mciGetCreatorTask [WINMM.40] */ HTASK32 WINAPI mciGetCreatorTask32(UINT32 uDeviceID) { FIXME(mci, "(%u) stub\n", uDeviceID); return 0; } /************************************************************************** * mciDriverYield [MMSYSTEM.710] */ UINT16 WINAPI mciDriverYield16(HANDLE16 hnd) { FIXME(mmsys,"(%04x): stub!\n", hnd); return 0; } /************************************************************************** * mciDriverYield [WINMM.37] */ UINT32 WINAPI mciDriverYield32(HANDLE32 hnd) { FIXME(mmsys,"(%04x): stub!\n", hnd); return 0; } /************************************************************************** * midiOutGetNumDevs [WINMM.80] */ UINT32 WINAPI midiOutGetNumDevs32(void) { return midiOutGetNumDevs16(); } /************************************************************************** * midiOutGetNumDevs [MMSYSTEM.201] */ UINT16 WINAPI midiOutGetNumDevs16(void) { UINT16 count = modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmsys, "returns %u\n", count); return count; } /************************************************************************** * midiOutGetDevCapsW [WINMM.76] */ UINT32 WINAPI midiOutGetDevCaps32W(UINT32 uDeviceID, LPMIDIOUTCAPS32W lpCaps, UINT32 uSize) { MIDIOUTCAPS16 moc16; UINT32 ret; ret = midiOutGetDevCaps16(uDeviceID, &moc16, sizeof(moc16)); lpCaps->wMid = moc16.wMid; lpCaps->wPid = moc16.wPid; lpCaps->vDriverVersion = moc16.vDriverVersion; lstrcpyAtoW(lpCaps->szPname, moc16.szPname); lpCaps->wTechnology = moc16.wTechnology; lpCaps->wVoices = moc16.wVoices; lpCaps->wNotes = moc16.wNotes; lpCaps->wChannelMask = moc16.wChannelMask; lpCaps->dwSupport = moc16.dwSupport; return ret; } /************************************************************************** * midiOutGetDevCapsA [WINMM.75] */ UINT32 WINAPI midiOutGetDevCaps32A(UINT32 uDeviceID, LPMIDIOUTCAPS32A lpCaps, UINT32 uSize) { MIDIOUTCAPS16 moc16; UINT32 ret; ret = midiOutGetDevCaps16(uDeviceID, &moc16, sizeof(moc16)); lpCaps->wMid = moc16.wMid; lpCaps->wPid = moc16.wPid; lpCaps->vDriverVersion = moc16.vDriverVersion; strcpy(lpCaps->szPname, moc16.szPname); lpCaps->wTechnology = moc16.wTechnology; lpCaps->wVoices = moc16.wVoices; lpCaps->wNotes = moc16.wNotes; lpCaps->wChannelMask = moc16.wChannelMask; lpCaps->dwSupport = moc16.dwSupport; return ret; } /************************************************************************** * midiOutGetDevCaps [MMSYSTEM.202] */ UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps, UINT16 uSize) { TRACE(mmsys, "midiOutGetDevCaps\n"); return modMessage(uDeviceID, MODM_GETDEVCAPS, 0, (DWORD)lpCaps,uSize); } /************************************************************************** * midiOutGetErrorTextA [WINMM.77] */ UINT32 WINAPI midiOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize) { TRACE(mmsys, "midiOutGetErrorText\n"); return midiGetErrorText(uError, lpText, uSize); } /************************************************************************** * midiOutGetErrorTextW [WINMM.78] */ UINT32 WINAPI midiOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize) { LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize); UINT32 ret; TRACE(mmsys, "midiOutGetErrorText\n"); ret = midiGetErrorText(uError, xstr, uSize); lstrcpyAtoW(lpText,xstr); HeapFree(GetProcessHeap(), 0,xstr); return ret; } /************************************************************************** * midiOutGetErrorText [MMSYSTEM.203] */ UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { TRACE(mmsys, "midiOutGetErrorText\n"); return midiGetErrorText(uError, lpText, uSize); } /************************************************************************** * midiGetErrorText [internal] */ UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) { LPSTR msgptr; if ((lpText == NULL) || (uSize < 1)) return(FALSE); lpText[0] = '\0'; switch (uError) { case MIDIERR_UNPREPARED: msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again."; break; case MIDIERR_STILLPLAYING: msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."; break; case MIDIERR_NOMAP: msgptr = "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing."; break; case MIDIERR_NOTREADY: msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again."; break; case MIDIERR_NODEVICE: msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup."; break; case MIDIERR_INVALIDSETUP: msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again."; break; /* msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together. msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again. msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver. msg# 339 : The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup. msg# 340 : An error occurred using the specified port. msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again. msg# 342 : There is no current MIDI port. msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver. */ default: msgptr = "Unknown MIDI Error !\n"; break; } lstrcpyn32A(lpText, msgptr, uSize); return TRUE; } /************************************************************************** * midiOutOpen [WINM.84] */ UINT32 WINAPI midiOutOpen32(HMIDIOUT32 * lphMidiOut, UINT32 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HMIDIOUT16 hmo16; UINT32 ret; ret = midiOutOpen16(&hmo16,uDeviceID, dwCallback, dwInstance, CALLBACK32CONV(dwFlags)); if (lphMidiOut) *lphMidiOut = hmo16; return ret; } /************************************************************************** * midiOutOpen [MMSYSTEM.204] */ UINT16 WINAPI midiOutOpen16(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HMIDI16 hMidiOut; LPMIDIOPENDESC lpDesc; DWORD dwRet = 0; BOOL32 bMapperFlg = FALSE; if (lphMidiOut != NULL) *lphMidiOut = 0; TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n", lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags); if (uDeviceID == (UINT16)MIDI_MAPPER) { TRACE(mmsys, "MIDI_MAPPER mode requested !\n"); bMapperFlg = TRUE; uDeviceID = 0; } hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC)); if (lphMidiOut != NULL) *lphMidiOut = hMidiOut; lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_NOMEM; lpDesc->hMidi = hMidiOut; lpDesc->dwCallback = dwCallback; lpDesc->dwInstance = dwInstance; while (uDeviceID < MAXMIDIDRIVERS) { dwRet = modMessage(uDeviceID, MODM_OPEN, lpDesc->dwInstance, (DWORD)lpDesc, dwFlags); if (dwRet == MMSYSERR_NOERROR) break; if (!bMapperFlg) break; uDeviceID++; TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n"); } lpDesc->wDevID = uDeviceID; return dwRet; } /************************************************************************** * midiOutClose [WINMM.74] */ UINT32 WINAPI midiOutClose32(HMIDIOUT32 hMidiOut) { return midiOutClose16(hMidiOut); } /************************************************************************** * midiOutClose [MMSYSTEM.205] */ UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hMidiOut); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return modMessage(lpDesc->wDevID, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * midiOutPrepareHeader [WINMM.85] */ UINT32 WINAPI midiOutPrepareHeader32(HMIDIOUT32 hMidiOut, MIDIHDR * lpMidiOutHdr, UINT32 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpMidiOutHdr->reserved = (DWORD)lpMidiOutHdr->lpData; return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance, (DWORD)lpMidiOutHdr, (DWORD)uSize); } /************************************************************************** * midiOutPrepareHeader [MMSYSTEM.206] */ UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, MIDIHDR * lpMidiOutHdr, UINT16 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpMidiOutHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiOutHdr->lpData); return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance, (DWORD)lpMidiOutHdr, (DWORD)uSize); } /************************************************************************** * midiOutUnprepareHeader [WINMM.89] */ UINT32 WINAPI midiOutUnprepareHeader32(HMIDIOUT32 hMidiOut, MIDIHDR * lpMidiOutHdr, UINT32 uSize) { return midiOutUnprepareHeader16(hMidiOut, lpMidiOutHdr,uSize); } /************************************************************************** * midiOutUnprepareHeader [MMSYSTEM.207] */ UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, MIDIHDR * lpMidiOutHdr, UINT16 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return modMessage(lpDesc->wDevID, MODM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpMidiOutHdr, (DWORD)uSize); } /************************************************************************** * midiOutShortMsg [WINMM.88] */ UINT32 WINAPI midiOutShortMsg32(HMIDIOUT32 hMidiOut, DWORD dwMsg) { return midiOutShortMsg16(hMidiOut, dwMsg); } /************************************************************************** * midiOutShortMsg [MMSYSTEM.208] */ UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %08lX)\n", hMidiOut, dwMsg); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return modMessage(lpDesc->wDevID, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L); } /************************************************************************** * midiOutLongMsg [WINMM.82] */ UINT32 WINAPI midiOutLongMsg32(HMIDIOUT32 hMidiOut, MIDIHDR * lpMidiOutHdr, UINT32 uSize) { return midiOutLongMsg16(hMidiOut, lpMidiOutHdr,uSize); } /************************************************************************** * midiOutLongMsg [MMSYSTEM.209] */ UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut, MIDIHDR * lpMidiOutHdr, UINT16 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return modMessage(lpDesc->wDevID, MODM_LONGDATA, lpDesc->dwInstance, (DWORD)lpMidiOutHdr, (DWORD)uSize); } /************************************************************************** * midiOutReset [WINMM.86] */ UINT32 WINAPI midiOutReset32(HMIDIOUT32 hMidiOut) { return midiOutReset16(hMidiOut); } /************************************************************************** * midiOutReset [MMSYSTEM.210] */ UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hMidiOut); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return modMessage(lpDesc->wDevID, MODM_RESET, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * midiOutGetVolume [WINM.81] */ UINT32 WINAPI midiOutGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume) { return midiOutGetVolume16(uDeviceID, lpdwVolume); } /************************************************************************** * midiOutGetVolume [MMSYSTEM.211] */ UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume) { TRACE(mmsys, "(%04X, %p);\n", uDeviceID, lpdwVolume); return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L); } /************************************************************************** * midiOutSetVolume [WINMM.87] */ UINT32 WINAPI midiOutSetVolume32(UINT32 uDeviceID, DWORD dwVolume) { return midiOutSetVolume16(uDeviceID, dwVolume); } /************************************************************************** * midiOutSetVolume [MMSYSTEM.212] */ UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume) { TRACE(mmsys, "(%04X, %08lX);\n", uDeviceID, dwVolume); return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L); } /************************************************************************** * midiOutCachePatches [WINMM.73] */ UINT32 WINAPI midiOutCachePatches32(HMIDIOUT32 hMidiOut, UINT32 uBank, WORD * lpwPatchArray, UINT32 uFlags) { return midiOutCachePatches16(hMidiOut,uBank, lpwPatchArray,uFlags); } /************************************************************************** * midiOutCachePatches [MMSYSTEM.213] */ UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank, WORD * lpwPatchArray, UINT16 uFlags) { /* not really necessary to support this */ FIXME(mmsys, "not supported yet\n"); return MMSYSERR_NOTSUPPORTED; } /************************************************************************** * midiOutCacheDrumPatches [WINMM.72] */ UINT32 WINAPI midiOutCacheDrumPatches32(HMIDIOUT32 hMidiOut, UINT32 uPatch, WORD * lpwKeyArray, UINT32 uFlags) { return midiOutCacheDrumPatches16(hMidiOut,uPatch, lpwKeyArray,uFlags); } /************************************************************************** * midiOutCacheDrumPatches [MMSYSTEM.214] */ UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch, WORD * lpwKeyArray, UINT16 uFlags) { FIXME(mmsys, "not supported yet\n"); return MMSYSERR_NOTSUPPORTED; } /************************************************************************** * midiOutGetID [WINMM.79] */ UINT32 WINAPI midiOutGetID32(HMIDIOUT32 hMidiOut, UINT32 * lpuDeviceID) { UINT16 xid; UINT32 ret; ret = midiOutGetID16(hMidiOut, &xid); *lpuDeviceID = xid; return ret; } /************************************************************************** * midiOutGetID [MMSYSTEM.215] */ UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID) { TRACE(mmsys, "midiOutGetID\n"); return 0; } /************************************************************************** * midiOutMessage [WINMM.83] */ DWORD WINAPI midiOutMessage32(HMIDIOUT32 hMidiOut, UINT32 uMessage, DWORD dwParam1, DWORD dwParam2) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case MODM_OPEN: FIXME(mmsys,"can't handle MODM_OPEN!\n"); return 0; case MODM_GETDEVCAPS: return midiOutGetDevCaps32A(hMidiOut, (LPMIDIOUTCAPS32A)dwParam1, dwParam2); case MODM_GETNUMDEVS: case MODM_RESET: case MODM_CLOSE: case MODM_GETVOLUME: case MODM_SETVOLUME: case MODM_LONGDATA: case MODM_PREPARE: case MODM_UNPREPARE: /* no argument conversion needed */ break; default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", hMidiOut,uMessage, dwParam1, dwParam2); break; } return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * midiOutMessage [MMSYSTEM.216] */ DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case MODM_OPEN: FIXME(mmsys,"can't handle MODM_OPEN!\n"); return 0; case MODM_GETNUMDEVS: case MODM_RESET: case MODM_CLOSE: case MODM_SETVOLUME: /* no argument conversion needed */ break; case MODM_GETVOLUME: return midiOutGetVolume16(hMidiOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1)); case MODM_LONGDATA: return midiOutLongMsg16(hMidiOut, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case MODM_PREPARE: return midiOutPrepareHeader16(hMidiOut, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case MODM_UNPREPARE: return midiOutUnprepareHeader16(hMidiOut, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", hMidiOut,uMessage, dwParam1, dwParam2); break; } return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * midiInGetNumDevs [WINMM.64] */ UINT32 WINAPI midiInGetNumDevs32(void) { return midiInGetNumDevs16(); } /************************************************************************** * midiInGetNumDevs [MMSYSTEM.301] */ UINT16 WINAPI midiInGetNumDevs16(void) { UINT16 count = 0; TRACE(mmsys, "midiInGetNumDevs\n"); count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmsys, "midiInGetNumDevs return %u \n", count); return count; } /************************************************************************** * midiInGetDevCaps [WINMM.60] */ UINT32 WINAPI midiInGetDevCaps32W(UINT32 uDeviceID, LPMIDIINCAPS32W lpCaps, UINT32 uSize) { MIDIINCAPS16 mic16; UINT32 ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize); lpCaps->wMid = mic16.wMid; lpCaps->wPid = mic16.wPid; lpCaps->vDriverVersion = mic16.vDriverVersion; lstrcpyAtoW(lpCaps->szPname, mic16.szPname); lpCaps->dwSupport = mic16.dwSupport; return ret; } /************************************************************************** * midiInGetDevCaps [WINMM.59] */ UINT32 WINAPI midiInGetDevCaps32A(UINT32 uDeviceID, LPMIDIINCAPS32A lpCaps, UINT32 uSize) { MIDIINCAPS16 mic16; UINT32 ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize); lpCaps->wMid = mic16.wMid; lpCaps->wPid = mic16.wPid; lpCaps->vDriverVersion = mic16.vDriverVersion; strcpy(lpCaps->szPname, mic16.szPname); lpCaps->dwSupport = mic16.dwSupport; return ret; } /************************************************************************** * midiInGetDevCaps [MMSYSTEM.302] */ UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps, UINT16 uSize) { TRACE(mmsys, "midiInGetDevCaps\n"); return midMessage(uDeviceID, MIDM_GETDEVCAPS, 0, (DWORD)lpCaps, uSize); } /************************************************************************** * midiInGetErrorText [WINMM.62] */ UINT32 WINAPI midiInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize) { LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize); UINT32 ret = midiInGetErrorText16(uError,xstr,uSize); lstrcpyAtoW(lpText,xstr); HeapFree(GetProcessHeap(), 0,xstr); return ret; } /************************************************************************** * midiInGetErrorText [WINMM.61] */ UINT32 WINAPI midiInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize) { return midiInGetErrorText16(uError, lpText,uSize); } /************************************************************************** * midiInGetErrorText [MMSYSTEM.303] */ UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { TRACE(mmsys, "midiInGetErrorText\n"); return (midiGetErrorText(uError, lpText, uSize)); } /************************************************************************** * midiInOpen [WINMM.66] */ UINT32 WINAPI midiInOpen32(HMIDIIN32 * lphMidiIn, UINT32 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HMIDIIN16 xhmid16; UINT32 ret = midiInOpen16(&xhmid16,uDeviceID, dwCallback, dwInstance, CALLBACK32CONV(dwFlags)); if (lphMidiIn) *lphMidiIn = xhmid16; return ret; } /************************************************************************** * midiInOpen [MMSYSTEM.304] */ UINT16 WINAPI midiInOpen16(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HMIDI16 hMidiIn; LPMIDIOPENDESC lpDesc; DWORD dwRet = 0; BOOL32 bMapperFlg = FALSE; if (lphMidiIn != NULL) *lphMidiIn = 0; TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n", lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags); if (uDeviceID == (UINT16)MIDI_MAPPER) { TRACE(mmsys, "MIDI_MAPPER mode requested !\n"); bMapperFlg = TRUE; uDeviceID = 0; } hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC)); if (lphMidiIn != NULL) *lphMidiIn = hMidiIn; lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_NOMEM; lpDesc->hMidi = hMidiIn; lpDesc->dwCallback = dwCallback; lpDesc->dwInstance = dwInstance; while (uDeviceID < MAXMIDIDRIVERS) { dwRet = midMessage(uDeviceID, MIDM_OPEN, lpDesc->dwInstance, (DWORD)lpDesc, dwFlags); if (dwRet == MMSYSERR_NOERROR) break; if (!bMapperFlg) break; uDeviceID++; TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n"); } lpDesc->wDevID = uDeviceID; return dwRet; } /************************************************************************** * midiInClose [WINMM.58] */ UINT32 WINAPI midiInClose32(HMIDIIN32 hMidiIn) { return midiInClose16(hMidiIn); } /************************************************************************** * midiInClose [MMSYSTEM.305] */ UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hMidiIn); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return midMessage(lpDesc->wDevID, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * midiInPrepareHeader [WINMM.67] */ UINT32 WINAPI midiInPrepareHeader32(HMIDIIN32 hMidiIn, MIDIHDR * lpMidiInHdr, UINT32 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpMidiInHdr->reserved = (DWORD)lpMidiInHdr->lpData; return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance, (DWORD)lpMidiInHdr, (DWORD)uSize); } /************************************************************************** * midiInPrepareHeader [MMSYSTEM.306] */ UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, MIDIHDR * lpMidiInHdr, UINT16 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpMidiInHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiInHdr->lpData); return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance, (DWORD)lpMidiInHdr, (DWORD)uSize); } /************************************************************************** * midiInUnprepareHeader [WINMM.71] */ UINT32 WINAPI midiInUnprepareHeader32(HMIDIIN32 hMidiIn, MIDIHDR * lpMidiInHdr, UINT32 uSize) { return midiInUnprepareHeader16(hMidiIn, lpMidiInHdr,uSize); } /************************************************************************** * midiInUnprepareHeader [MMSYSTEM.307] */ UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, MIDIHDR * lpMidiInHdr, UINT16 uSize) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return midMessage(lpDesc->wDevID, MIDM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpMidiInHdr, (DWORD)uSize); } /************************************************************************** * midiInAddBuffer [WINMM.57] */ UINT32 WINAPI midiInAddBuffer32(HMIDIIN32 hMidiIn, MIDIHDR * lpMidiInHdr, UINT32 uSize) { return midiInAddBuffer16(hMidiIn, lpMidiInHdr,uSize); } /************************************************************************** * midiInAddBuffer [MMSYSTEM.308] */ UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, MIDIHDR * lpMidiInHdr, UINT16 uSize) { TRACE(mmsys, "midiInAddBuffer\n"); return 0; } /************************************************************************** * midiInStart [WINMM.69] */ UINT32 WINAPI midiInStart32(HMIDIIN32 hMidiIn) { return midiInStart16(hMidiIn); } /************************************************************************** * midiInStart [MMSYSTEM.309] */ UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hMidiIn); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return midMessage(lpDesc->wDevID, MIDM_START, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * midiInStop [WINMM.70] */ UINT32 WINAPI midiInStop32(HMIDIIN32 hMidiIn) { return midiInStop16(hMidiIn); } /************************************************************************** * midiInStop [MMSYSTEM.310] */ UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hMidiIn); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return midMessage(lpDesc->wDevID, MIDM_STOP, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * midiInReset [WINMM.68] */ UINT32 WINAPI midiInReset32(HMIDIIN32 hMidiIn) { return midiInReset16(hMidiIn); } /************************************************************************** * midiInReset [MMSYSTEM.311] */ UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hMidiIn); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return midMessage(lpDesc->wDevID, MIDM_RESET, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * midiInGetID [WINMM.63] */ UINT32 WINAPI midiInGetID32(HMIDIIN32 hMidiIn, UINT32* lpuDeviceID) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM; *lpuDeviceID = lpDesc->wDevID; return MMSYSERR_NOERROR; } /************************************************************************** * midiInGetID [MMSYSTEM.312] */ UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM; *lpuDeviceID = lpDesc->wDevID; return MMSYSERR_NOERROR; } /************************************************************************** * midiInMessage [WINMM.65] */ DWORD WINAPI midiInMessage32(HMIDIIN32 hMidiIn, UINT32 uMessage, DWORD dwParam1, DWORD dwParam2) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case MIDM_OPEN: FIXME(mmsys,"can't handle MIDM_OPEN!\n"); return 0; case MIDM_GETDEVCAPS: return midiInGetDevCaps32A(hMidiIn, (LPMIDIINCAPS32A)dwParam1, dwParam2); case MIDM_GETNUMDEVS: case MIDM_RESET: case MIDM_STOP: case MIDM_START: case MIDM_CLOSE: /* no argument conversion needed */ break; case MIDM_PREPARE: return midiInPrepareHeader32(hMidiIn, (LPMIDIHDR)dwParam1, dwParam2); case MIDM_UNPREPARE: return midiInUnprepareHeader32(hMidiIn, (LPMIDIHDR)dwParam1, dwParam2); case MIDM_ADDBUFFER: return midiInAddBuffer32(hMidiIn, (LPMIDIHDR)dwParam1, dwParam2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", hMidiIn,uMessage, dwParam1, dwParam2); break; } return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * midiInMessage [MMSYSTEM.313] */ DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPMIDIOPENDESC lpDesc; TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2); lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case MIDM_OPEN: WARN(mmsys,"can't handle MIDM_OPEN!\n"); return 0; case MIDM_GETDEVCAPS: return midiInGetDevCaps16(hMidiIn, (LPMIDIINCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2); case MIDM_GETNUMDEVS: case MIDM_RESET: case MIDM_STOP: case MIDM_START: case MIDM_CLOSE: /* no argument conversion needed */ break; case MIDM_PREPARE: return midiInPrepareHeader16(hMidiIn, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case MIDM_UNPREPARE: return midiInUnprepareHeader16(hMidiIn, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case MIDM_ADDBUFFER: return midiInAddBuffer16(hMidiIn, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", hMidiIn,uMessage, dwParam1, dwParam2); break; } return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } #define MIDI_STREAM_MAGIC 0xC9080F17 typedef struct { DWORD dwMagic; HMIDIOUT32 hDevice; /* thread ID */ DWORD dwTempo; DWORD dwTimeDiv; DWORD dwMS; DWORD dwStatus; LPMIDIHDR_WIN32 lpMidiHdr; } WINE_MIDIStream; /************************************************************************** * MMSYSTEM_MidiStreamPlayer [internal] */ static void MMSYSTEM_MidiStreamPlayer(WINE_MIDIStream* ms) { /* FIXME: should I sleep a bit when there is no pending lpMidiHdr ? * => provide a better synchronization system * midiStreamPause/midiStreamRestart should freeze/thaw this thread * global resource should guard access to ms->lpMidiHdr list, or * use a MB to send new LPMIDIHDR * an empty ms->lpMidiHdr list should freeze this thread */ for (;;) { if (ms->dwStatus && ms->lpMidiHdr) { LPMIDIEVENT me = (LPMIDIEVENT)(ms->lpMidiHdr->lpData + ms->lpMidiHdr->dwOffset); FIXME(mmsys, "Should wait for current time to be in sync with me->dwDeltaTime\n"); if (me->dwEvent & MEVT_F_CALLBACK) { WARN(mmsys, "Should generate callback when encountering F_CALLBACK flagged midi events...\n"); } switch (MEVT_EVENTTYPE(me->dwEvent)) { case MEVT_COMMENT: /* do nothing, skip bytes */ break; case MEVT_LONGMSG: WARN(mmsys, "NIY: sending Sysex Event"); break; case MEVT_NOP: break; case MEVT_SHORTMSG: midiOutShortMsg32(ms->hDevice, MEVT_EVENTPARM(me->dwEvent)); break; case MEVT_TEMPO: ms->dwTempo = MEVT_EVENTPARM(me->dwEvent); break; case MEVT_VERSION: break; } ms->lpMidiHdr->dwOffset += sizeof(MIDIEVENT); if (me->dwEvent & MEVT_F_LONG) { ms->lpMidiHdr->dwOffset += MEVT_EVENTPARM(me->dwEvent); } if (ms->lpMidiHdr->dwOffset >= ms->lpMidiHdr->dwBufferLength) { ms->lpMidiHdr->dwFlags |= MHDR_DONE; ms->lpMidiHdr->dwFlags &= ~MHDR_INQUEUE; ms->lpMidiHdr = (LPMIDIHDR_WIN32)ms->lpMidiHdr->lpNext; WARN(mmsys, "Should generate callback when done with MIDIHDR...\n"); } FIXME(mmsys, "Should accordingly update ms->dwMS with me->dwDeltaTime\n"); } } } /************************************************************************** * midiStreamClose [WINMM.90] */ MMRESULT32 WINAPI midiStreamClose32(HMIDISTRM32 hms) { WINE_MIDIStream* ms; TRACE(midi, "(%08x)!\n", hms); ms = (WINE_MIDIStream*)hms; if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) return MMSYSERR_INVALHANDLE; free(ms); return MMSYSERR_NOTSUPPORTED; } /************************************************************************** * midiStreamOpen [WINMM.91] */ MMRESULT32 WINAPI midiStreamOpen32(HMIDISTRM32* phms, LPUINT32 lpuDeviceID, DWORD cMidi, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen) { WINE_MIDIStream* ms; TRACE(midi, "(%p,%p,%ld, 0x%08lx, 0x%08lx, 0x%08lx), stub!\n", phms, lpuDeviceID,cMidi, dwCallback, dwInstance, fdwOpen); if (cMidi != 1 || phms == NULL || lpuDeviceID == NULL) return MMSYSERR_INVALPARAM; ms = malloc(sizeof(WINE_MIDIStream)); *phms = (HMIDISTRM32)ms; ms->dwMagic = MIDI_STREAM_MAGIC; ms->dwTempo = 50000; /* FIXME */ ms->dwTimeDiv = 1; /* FIXME */ ms->dwMS = 0; ms->dwStatus = 0; /* FIXME is this correct ? */ *lpuDeviceID = 0; /* FIXME is this correct ? */ return midiOutOpen32(&(ms->hDevice), *lpuDeviceID, dwCallback, dwInstance, fdwOpen); } /************************************************************************** * midiStreamOut [WINMM.92] */ MMRESULT32 WINAPI midiStreamOut32(HMIDISTRM32 hms, LPMIDIHDR lpMidiHdr, UINT32 cbMidiHdr) { FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMidiHdr, cbMidiHdr); return MMSYSERR_NOTSUPPORTED; } /************************************************************************** * midiStreamPause [WINMM.93] */ MMRESULT32 WINAPI midiStreamPause32(HMIDISTRM32 hms) { WINE_MIDIStream* ms; TRACE(midi, "(%08x)!\n", hms); ms = (WINE_MIDIStream*)hms; if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) return MMSYSERR_INVALHANDLE; ms->dwStatus = 0; return MMSYSERR_NOERROR; } /************************************************************************** * midiStreamPosition [WINMM.94] */ MMRESULT32 WINAPI midiStreamPosition32(HMIDISTRM32 hms, LPMMTIME32 lpMMT, UINT32 cbmmt) { WINE_MIDIStream* ms; DWORD ret = MMSYSERR_NOERROR; FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMMT, cbmmt); ms = (WINE_MIDIStream*)hms; if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) { ret = MMSYSERR_INVALHANDLE; } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME32)) { ret = MMSYSERR_INVALPARAM; } else { switch (lpMMT->wType) { case TIME_MS: lpMMT->u.ms = ms->dwMS; break; default: lpMMT->wType = TIME_MS; ret = MMSYSERR_INVALPARAM; } } return ret; } /************************************************************************** * midiStreamProperty [WINMM.95] */ MMRESULT32 WINAPI midiStreamProperty32(HMIDISTRM32 hms, LPBYTE lpPropData, DWORD dwProperty) { WINE_MIDIStream* ms = (WINE_MIDIStream*)hms; MMRESULT32 ret = MMSYSERR_NOERROR; TRACE(midi, "(%08x, %p, %lx)\n", hms, lpPropData, dwProperty); if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) { ret = MMSYSERR_INVALHANDLE; } else if ((dwProperty & (MIDIPROP_GET|MIDIPROP_SET)) == 0) { return MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_TEMPO) { MIDIPROPTEMPO* mpt = (MIDIPROPTEMPO*)lpPropData; if (sizeof(MIDIPROPTEMPO) != mpt->cbStruct) { ret = MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_GET) { ms->dwTempo = mpt->dwTempo; } else if (dwProperty & MIDIPROP_SET) { mpt->dwTempo = ms->dwTempo; } } else if (dwProperty & MIDIPROP_TIMEDIV) { MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData; if (sizeof(MIDIPROPTIMEDIV) != mptd->cbStruct) { ret = MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_GET) { ms->dwTimeDiv = mptd->dwTimeDiv; } else if (dwProperty & MIDIPROP_SET) { mptd->dwTimeDiv = ms->dwTimeDiv; } } else { ret = MMSYSERR_INVALPARAM; } return ret; } /************************************************************************** * midiStreamRestart [WINMM.96] */ MMRESULT32 WINAPI midiStreamRestart32(HMIDISTRM32 hms) { WINE_MIDIStream* ms; TRACE(midi, "(%08x)!\n", hms); ms = (WINE_MIDIStream*)hms; if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) return MMSYSERR_INVALHANDLE; ms->dwStatus = 1; return MMSYSERR_NOERROR; } /************************************************************************** * midiStreamStop [WINMM.97] */ MMRESULT32 WINAPI midiStreamStop32(HMIDISTRM32 hms) { FIXME(midi, "(%08x stub!)\n", hms); return MMSYSERR_NOTSUPPORTED; } /************************************************************************** * midiStreamClose [MMSYSTEM.252] */ MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms) { return midiStreamClose32(hms); } /************************************************************************** * midiStreamOpen [MMSYSTEM.251] */ MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phms, LPUINT16 devid, DWORD cMidi, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen) { HMIDISTRM32 hms32; MMRESULT32 ret; UINT32 devid32; if (!phms || !devid) return MMSYSERR_INVALPARAM; devid32 = *devid; ret = midiStreamOpen32(&hms32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen); *phms = hms32; *devid = devid32; return ret; } /************************************************************************** * midiStreamOut [MMSYSTEM.254] */ MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hms, LPMIDIHDR lpMidiHdr, UINT16 cbMidiHdr) { return midiStreamOut32(hms, lpMidiHdr, cbMidiHdr); } /************************************************************************** * midiStreamPause [MMSYSTEM.255] */ MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hms) { return midiStreamPause32(hms); } /************************************************************************** * midiStreamPosition [MMSYSTEM.253] */ MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hms, LPMMTIME16 lpmmt, UINT16 cbmmt) { MMTIME32 mmt32; MMRESULT32 ret; if (!lpmmt) return MMSYSERR_INVALPARAM; MMSYSTEM_MMTIME16to32(&mmt32, lpmmt); ret = midiStreamPosition32(hms, &mmt32, cbmmt); MMSYSTEM_MMTIME32to16(lpmmt, &mmt32); return ret; } /************************************************************************** * midiStreamProperty [MMSYSTEM.250] */ MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hms, LPBYTE lpPropData, DWORD dwProperty) { return midiStreamProperty32(hms, lpPropData, dwProperty); } /************************************************************************** * midiStreamRestart [MMSYSTEM.256] */ MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hms) { return midiStreamRestart32(hms); } /************************************************************************** * midiStreamStop [MMSYSTEM.257] */ MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hms) { return midiStreamStop32(hms); } /************************************************************************** * waveOutGetNumDevs [MMSYSTEM.401] */ UINT32 WINAPI waveOutGetNumDevs32() { return waveOutGetNumDevs16(); } /************************************************************************** * waveOutGetNumDevs [WINMM.167] */ UINT16 WINAPI waveOutGetNumDevs16() { UINT16 count = 0; TRACE(mmsys, "waveOutGetNumDevs\n"); /* FIXME: I'm not sure MCI_FirstDevID() is correct */ count += wodMessage(MCI_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmsys, "waveOutGetNumDevs return %u \n", count); return count; } /************************************************************************** * waveOutGetDevCaps [MMSYSTEM.402] */ UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, WAVEOUTCAPS16 * lpCaps, UINT16 uSize) { if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID; if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */ TRACE(mmsys, "waveOutGetDevCaps\n"); return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize); } /************************************************************************** * waveOutGetDevCapsA [WINMM.162] */ UINT32 WINAPI waveOutGetDevCaps32A(UINT32 uDeviceID, LPWAVEOUTCAPS32A lpCaps, UINT32 uSize) { WAVEOUTCAPS16 woc16; UINT16 ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16)); lpCaps->wMid = woc16.wMid; lpCaps->wPid = woc16.wPid; lpCaps->vDriverVersion = woc16.vDriverVersion; strcpy(lpCaps->szPname, woc16.szPname); lpCaps->dwFormats = woc16.dwFormats; lpCaps->wChannels = woc16.wChannels; lpCaps->dwSupport = woc16.dwSupport; return ret; } /************************************************************************** * waveOutGetDevCapsW [WINMM.163] */ UINT32 WINAPI waveOutGetDevCaps32W(UINT32 uDeviceID, LPWAVEOUTCAPS32W lpCaps, UINT32 uSize) { WAVEOUTCAPS16 woc16; UINT32 ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16)); lpCaps->wMid = woc16.wMid; lpCaps->wPid = woc16.wPid; lpCaps->vDriverVersion = woc16.vDriverVersion; lstrcpyAtoW(lpCaps->szPname, woc16.szPname); lpCaps->dwFormats = woc16.dwFormats; lpCaps->wChannels = woc16.wChannels; lpCaps->dwSupport = woc16.dwSupport; return ret; } /************************************************************************** * waveOutGetErrorText [MMSYSTEM.403] */ UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { TRACE(mmsys, "waveOutGetErrorText\n"); return(waveGetErrorText(uError, lpText, uSize)); } /************************************************************************** * waveOutGetErrorTextA [WINMM.164] */ UINT32 WINAPI waveOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize) { return(waveOutGetErrorText16(uError, lpText, uSize)); } /************************************************************************** * waveOutGetErrorTextW [WINMM.165] */ UINT32 WINAPI waveOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize) { LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize); UINT32 ret = waveOutGetErrorText32A(uError, xstr, uSize); lstrcpyAtoW(lpText,xstr); HeapFree(GetProcessHeap(), 0,xstr); return ret; } /************************************************************************** * waveGetErrorText [internal] */ static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize) { LPSTR msgptr; TRACE(mmsys, "(%04X, %p, %d);\n", uError, lpText, uSize); if ((lpText == NULL) || (uSize < 1)) return(FALSE); lpText[0] = '\0'; switch (uError) { case MMSYSERR_NOERROR: msgptr = "The specified command was carried out."; break; case MMSYSERR_ERROR: msgptr = "Undefined external error."; break; case MMSYSERR_BADDEVICEID: msgptr = "A device ID has been used that is out of range for your system."; break; case MMSYSERR_NOTENABLED: msgptr = "The driver was not enabled."; break; case MMSYSERR_ALLOCATED: msgptr = "The specified device is already in use. Wait until it is free, and then try again."; break; case MMSYSERR_INVALHANDLE: msgptr = "The specified device handle is invalid."; break; case MMSYSERR_NODRIVER: msgptr = "There is no driver installed on your system !\n"; break; case MMSYSERR_NOMEM: msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again."; break; case MMSYSERR_NOTSUPPORTED: msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports."; break; case MMSYSERR_BADERRNUM: msgptr = "An error number was specified that is not defined in the system."; break; case MMSYSERR_INVALFLAG: msgptr = "An invalid flag was passed to a system function."; break; case MMSYSERR_INVALPARAM: msgptr = "An invalid parameter was passed to a system function."; break; case WAVERR_BADFORMAT: msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats"; break; case WAVERR_STILLPLAYING: msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."; break; case WAVERR_UNPREPARED: msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again."; break; case WAVERR_SYNC: msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again."; break; default: msgptr = "Unknown MMSYSTEM Error !\n"; break; } lstrcpyn32A(lpText, msgptr, uSize); return TRUE; } /************************************************************************** * waveOutOpen [WINMM.173] * All the args/structs have the same layout as the win16 equivalents */ UINT32 WINAPI waveOutOpen32(HWAVEOUT32 * lphWaveOut, UINT32 uDeviceID, const LPWAVEFORMATEX lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HWAVEOUT16 hwo16; UINT32 ret = waveOutOpen16(&hwo16,uDeviceID, lpFormat, dwCallback, dwInstance, CALLBACK32CONV(dwFlags)); if (lphWaveOut) *lphWaveOut=hwo16; return ret; } /************************************************************************** * waveOutOpen [MMSYSTEM.404] */ UINT16 WINAPI waveOutOpen16(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID, const LPWAVEFORMATEX lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HWAVEOUT16 hWaveOut; LPWAVEOPENDESC lpDesc; DWORD dwRet = 0; BOOL32 bMapperFlg = FALSE; TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n", lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags); if (dwFlags & WAVE_FORMAT_QUERY) TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n"); if (uDeviceID == (UINT16)WAVE_MAPPER) { TRACE(mmsys, "WAVE_MAPPER mode requested !\n"); bMapperFlg = TRUE; uDeviceID = 0; } if (lpFormat == NULL) return WAVERR_BADFORMAT; hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); if (lphWaveOut != NULL) *lphWaveOut = hWaveOut; lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_NOMEM; lpDesc->hWave = hWaveOut; lpDesc->lpFormat = (LPWAVEFORMAT)lpFormat; /* should the struct be copied iso pointer? */ lpDesc->dwCallBack = dwCallback; lpDesc->dwInstance = dwInstance; if (uDeviceID >= MAXWAVEDRIVERS) uDeviceID = 0; while (uDeviceID < MAXWAVEDRIVERS) { dwRet = wodMessage(uDeviceID, WODM_OPEN, lpDesc->dwInstance, (DWORD)lpDesc, dwFlags); if (dwRet == MMSYSERR_NOERROR) break; if (!bMapperFlg) break; uDeviceID++; TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n"); } lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */ if (dwFlags & WAVE_FORMAT_QUERY) { TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n"); dwRet = waveOutClose32(hWaveOut); } return dwRet; } /************************************************************************** * waveOutClose [WINMM.161] */ UINT32 WINAPI waveOutClose32(HWAVEOUT32 hWaveOut) { return waveOutClose16(hWaveOut); } /************************************************************************** * waveOutClose [MMSYSTEM.405] */ UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return wodMessage(lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * waveOutPrepareHeader [WINMM.175] */ UINT32 WINAPI waveOutPrepareHeader32(HWAVEOUT32 hWaveOut, WAVEHDR* lpWaveOutHdr, UINT32 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData; return wodMessage(lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr,uSize); } /************************************************************************** * waveOutPrepareHeader [MMSYSTEM.406] */ UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, WAVEHDR* lpWaveOutHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; UINT16 ret; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData; lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData); ret = wodMessage(lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr,uSize); lpWaveOutHdr->lpData = lpWaveOutHdr->lpData; return ret; } /************************************************************************** * waveOutUnprepareHeader [WINMM.181] */ UINT32 WINAPI waveOutUnprepareHeader32(HWAVEOUT32 hWaveOut, WAVEHDR* lpWaveOutHdr, UINT32 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData; return wodMessage(lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); } /************************************************************************** * waveOutUnprepareHeader [MMSYSTEM.407] */ UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, WAVEHDR* lpWaveOutHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; UINT16 ret; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData; lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData); ret = wodMessage(lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved; return ret; } /************************************************************************** * waveOutWrite [MMSYSTEM.408] */ UINT32 WINAPI waveOutWrite32(HWAVEOUT32 hWaveOut, WAVEHDR* lpWaveOutHdr, UINT32 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData; return wodMessage(lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); } /************************************************************************** * waveOutWrite [MMSYSTEM.408] */ UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; UINT16 ret; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; lpWaveOutHdr->reserved =(DWORD)lpWaveOutHdr->lpData;/*save original ptr*/ lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData); ret = wodMessage(lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved; return ret; } /************************************************************************** * waveOutPause [WINMM.174] */ UINT32 WINAPI waveOutPause32(HWAVEOUT32 hWaveOut) { return waveOutPause16(hWaveOut); } /************************************************************************** * waveOutPause [MMSYSTEM.409] */ UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return wodMessage(lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * waveOutRestart [WINMM.177] */ UINT32 WINAPI waveOutRestart32(HWAVEOUT32 hWaveOut) { return waveOutRestart16(hWaveOut); } /************************************************************************** * waveOutRestart [MMSYSTEM.410] */ UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return wodMessage(lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * waveOutReset [WINMM.176] */ UINT32 WINAPI waveOutReset32(HWAVEOUT32 hWaveOut) { return waveOutReset16(hWaveOut); } /************************************************************************** * waveOutReset [MMSYSTEM.411] */ UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return wodMessage(lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * waveOutGetPosition [WINMM.170] */ UINT32 WINAPI waveOutGetPosition32(HWAVEOUT32 hWaveOut, LPMMTIME32 lpTime, UINT32 uSize) { MMTIME16 mmt16; UINT32 ret; mmt16.wType = lpTime->wType; ret = waveOutGetPosition16(hWaveOut, &mmt16, sizeof(mmt16)); MMSYSTEM_MMTIME16to32(lpTime, &mmt16); return ret; } /************************************************************************** * waveOutGetPosition [MMSYSTEM.412] */ UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime, UINT16 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpTime, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return wodMessage(lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance, (DWORD)lpTime, (DWORD)uSize); } #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \ UINT32 WINAPI waveOut##xx##32(HWAVEOUT32 hWaveOut, atype x) \ { \ return waveOut##xx##16(hWaveOut,x); \ } \ UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \ { \ LPWAVEOPENDESC lpDesc; \ TRACE(mmsys, "(%04X, %08lx);\n", hWaveOut, (DWORD)x); \ lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \ return wodMessage(lpDesc->uDeviceID, WODM_##XX, \ lpDesc->dwInstance, (DWORD)x, 0L); \ } WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH, DWORD*) WAVEOUT_SHORTCUT_1(SetPitch,SETPITCH, DWORD) WAVEOUT_SHORTCUT_1(GetPlaybackRate,GETPLAYBACKRATE, DWORD*) WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE, DWORD) #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \ UINT32 WINAPI waveOut##xx##32(UINT32 devid, atype x) \ { \ return waveOut##xx##16(devid,x); \ } \ UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \ { \ TRACE(mmsys, "(%04X, %08lx);\n", devid, (DWORD)x); \ return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \ } WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME, DWORD*) WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME, DWORD) /************************************************************************** * waveOutBreakLoop [MMSYSTEM.419] */ UINT32 WINAPI waveOutBreakLoop32(HWAVEOUT32 hWaveOut) { return waveOutBreakLoop16(hWaveOut); } /************************************************************************** * waveOutBreakLoop [MMSYSTEM.419] */ UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut) { TRACE(mmsys, "(%04X)\n", hWaveOut); return MMSYSERR_INVALHANDLE; } /************************************************************************** * waveOutGetID [MMSYSTEM.420] */ UINT32 WINAPI waveOutGetID32(HWAVEOUT32 hWaveOut, UINT32 * lpuDeviceID) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = lpDesc->uDeviceID; return 0; } /************************************************************************** * waveOutGetID [MMSYSTEM.420] */ UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = lpDesc->uDeviceID; return 0; } /************************************************************************** * waveOutMessage [MMSYSTEM.421] */ DWORD WINAPI waveOutMessage32(HWAVEOUT32 hWaveOut, UINT32 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWAVEOPENDESC lpDesc; lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case WODM_GETNUMDEVS: case WODM_GETPOS: case WODM_GETVOLUME: case WODM_GETPITCH: case WODM_GETPLAYBACKRATE: case WODM_SETVOLUME: case WODM_SETPITCH: case WODM_SETPLAYBACKRATE: case WODM_RESET: case WODM_PAUSE: case WODM_PREPARE: case WODM_UNPREPARE: case WODM_STOP: case WODM_CLOSE: /* no argument conversion needed */ break; case WODM_WRITE: return waveOutWrite32(hWaveOut, (LPWAVEHDR)dwParam1, dwParam2); case WODM_GETDEVCAPS: /* FIXME: UNICODE/ANSI? */ return waveOutGetDevCaps32A(hWaveOut, (LPWAVEOUTCAPS32A)dwParam1, dwParam2); case WODM_OPEN: FIXME(mmsys,"can't handle WODM_OPEN, please report.\n"); break; default: ERR(mmsys,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n", hWaveOut,uMessage, dwParam1, dwParam2); break; } return wodMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * waveOutMessage [MMSYSTEM.421] */ DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWAVEOPENDESC lpDesc; lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case WODM_GETNUMDEVS: case WODM_SETVOLUME: case WODM_SETPITCH: case WODM_SETPLAYBACKRATE: case WODM_RESET: case WODM_PAUSE: case WODM_STOP: case WODM_CLOSE: /* no argument conversion needed */ break; case WODM_GETPOS: return waveOutGetPosition16(hWaveOut, (LPMMTIME16)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WODM_GETVOLUME: return waveOutGetVolume16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1)); case WODM_GETPITCH: return waveOutGetPitch16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1)); case WODM_GETPLAYBACKRATE: return waveOutGetPlaybackRate16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1)); case WODM_GETDEVCAPS: return waveOutGetDevCaps16(hWaveOut, (LPWAVEOUTCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WODM_PREPARE: return waveOutPrepareHeader16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WODM_UNPREPARE: return waveOutUnprepareHeader16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WODM_WRITE: return waveOutWrite16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WODM_OPEN: FIXME(mmsys,"can't handle WODM_OPEN, please report.\n"); break; default: ERR(mmsys,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n", hWaveOut,uMessage, dwParam1, dwParam2); } return wodMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * waveInGetNumDevs [WINMM.151] */ UINT32 WINAPI waveInGetNumDevs32() { return waveInGetNumDevs16(); } /************************************************************************** * waveInGetNumDevs [MMSYSTEM.501] */ UINT16 WINAPI waveInGetNumDevs16() { UINT16 count = 0; TRACE(mmsys, "waveInGetNumDevs\n"); count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmsys, "waveInGetNumDevs return %u \n", count); return count; } /************************************************************************** * waveInGetDevCapsA [WINMM.147] */ UINT32 WINAPI waveInGetDevCaps32W(UINT32 uDeviceID, LPWAVEINCAPS32W lpCaps, UINT32 uSize) { WAVEINCAPS16 wic16; UINT32 ret = waveInGetDevCaps16(uDeviceID, &wic16,uSize); lpCaps->wMid = wic16.wMid; lpCaps->wPid = wic16.wPid; lpCaps->vDriverVersion = wic16.vDriverVersion; lstrcpyAtoW(lpCaps->szPname, wic16.szPname); lpCaps->dwFormats = wic16.dwFormats; lpCaps->wChannels = wic16.wChannels; return ret; } /************************************************************************** * waveInGetDevCapsA [WINMM.146] */ UINT32 WINAPI waveInGetDevCaps32A(UINT32 uDeviceID, LPWAVEINCAPS32A lpCaps, UINT32 uSize) { WAVEINCAPS16 wic16; UINT32 ret = waveInGetDevCaps16(uDeviceID, &wic16,uSize); lpCaps->wMid = wic16.wMid; lpCaps->wPid = wic16.wPid; lpCaps->vDriverVersion = wic16.vDriverVersion; strcpy(lpCaps->szPname, wic16.szPname); lpCaps->dwFormats = wic16.dwFormats; lpCaps->wChannels = wic16.wChannels; return ret; } /************************************************************************** * waveInGetDevCaps [MMSYSTEM.502] */ UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize) { TRACE(mmsys, "waveInGetDevCaps\n"); return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize); } /************************************************************************** * waveInGetErrorTextA [WINMM.148] */ UINT32 WINAPI waveInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize) { TRACE(mmsys, "waveInGetErrorText\n"); return(waveGetErrorText(uError, lpText, uSize)); } /************************************************************************** * waveInGetErrorTextW [WINMM.149] */ UINT32 WINAPI waveInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize) { LPSTR txt = HeapAlloc(GetProcessHeap(), 0,uSize); UINT32 ret = waveGetErrorText(uError, txt, uSize); lstrcpyAtoW(lpText, txt); HeapFree(GetProcessHeap(), 0, txt); return ret; } /************************************************************************** * waveInGetErrorText [MMSYSTEM.503] */ UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize) { TRACE(mmsys, "waveInGetErrorText\n"); return(waveGetErrorText(uError, lpText, uSize)); } /************************************************************************** * waveInOpen [WINMM.154] */ UINT32 WINAPI waveInOpen32(HWAVEIN32 * lphWaveIn, UINT32 uDeviceID, const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HWAVEIN16 hwin16; UINT32 ret = waveInOpen16(&hwin16,uDeviceID, lpFormat, dwCallback, dwInstance, CALLBACK32CONV(dwFlags)); if (lphWaveIn) *lphWaveIn = hwin16; return ret; } /************************************************************************** * waveInOpen [MMSYSTEM.504] */ UINT16 WINAPI waveInOpen16(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID, const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags) { HWAVEIN16 hWaveIn; LPWAVEOPENDESC lpDesc; DWORD dwRet = 0; BOOL32 bMapperFlg = FALSE; TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n", lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags); if (dwFlags & WAVE_FORMAT_QUERY) TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n"); if (uDeviceID == (UINT16)WAVE_MAPPER) { TRACE(mmsys, "WAVE_MAPPER mode requested !\n"); bMapperFlg = TRUE; uDeviceID = 0; } if (lpFormat == NULL) return WAVERR_BADFORMAT; hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); if (lphWaveIn != NULL) *lphWaveIn = hWaveIn; lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_NOMEM; lpDesc->hWave = hWaveIn; lpDesc->lpFormat = lpFormat; lpDesc->dwCallBack = dwCallback; lpDesc->dwInstance = dwInstance; while (uDeviceID < MAXWAVEDRIVERS) { dwRet = widMessage(uDeviceID, WIDM_OPEN, lpDesc->dwInstance, (DWORD)lpDesc, 0L); if (dwRet == MMSYSERR_NOERROR) break; if (!bMapperFlg) break; uDeviceID++; TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n"); } lpDesc->uDeviceID = uDeviceID; if (dwFlags & WAVE_FORMAT_QUERY) { TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n"); dwRet = waveInClose16(hWaveIn); } return dwRet; } /************************************************************************** * waveInClose [WINMM.145] */ UINT32 WINAPI waveInClose32(HWAVEIN32 hWaveIn) { return waveInClose16(hWaveIn); } /************************************************************************** * waveInClose [MMSYSTEM.505] */ UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * waveInPrepareHeader [WINMM.155] */ UINT32 WINAPI waveInPrepareHeader32(HWAVEIN32 hWaveIn, WAVEHDR * lpWaveInHdr, UINT32 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; lpWaveInHdr = lpWaveInHdr; lpWaveInHdr->lpNext = NULL; lpWaveInHdr->dwBytesRecorded = 0; TRACE(mmsys, "lpData=%p size=%lu \n", lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength); return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } /************************************************************************** * waveInPrepareHeader [MMSYSTEM.506] */ UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, WAVEHDR * lpWaveInHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; LPBYTE saveddata = lpWaveInHdr->lpData; UINT16 ret; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; lpWaveInHdr = lpWaveInHdr; lpWaveInHdr->lpNext = NULL; lpWaveInHdr->dwBytesRecorded = 0; TRACE(mmsys, "lpData=%p size=%lu \n", lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength); lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData); ret = widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance, (DWORD)lpWaveInHdr,uSize); lpWaveInHdr->lpData = saveddata; return ret; } /************************************************************************** * waveInUnprepareHeader [WINMM.159] */ UINT32 WINAPI waveInUnprepareHeader32(HWAVEIN32 hWaveIn, WAVEHDR * lpWaveInHdr, UINT32 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */ lpWaveInHdr->lpData = NULL; lpWaveInHdr->lpNext = NULL; return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } /************************************************************************** * waveInUnprepareHeader [MMSYSTEM.507] */ UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, WAVEHDR * lpWaveInHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */ lpWaveInHdr->lpData = NULL; lpWaveInHdr->lpNext = NULL; return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } /************************************************************************** * waveInAddBuffer [WINMM.144] */ UINT32 WINAPI waveInAddBuffer32(HWAVEIN32 hWaveIn, WAVEHDR * lpWaveInHdr, UINT32 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; lpWaveInHdr->lpNext = NULL; lpWaveInHdr->dwBytesRecorded = 0; TRACE(mmsys, "lpData=%p size=%lu \n", lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength); return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } /************************************************************************** * waveInAddBuffer [MMSYSTEM.508] */ UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, WAVEHDR * lpWaveInHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; UINT16 ret; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE; lpWaveInHdr->lpNext = NULL; lpWaveInHdr->dwBytesRecorded = 0; lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData); TRACE(mmsys, "lpData=%p size=%lu \n", lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength); ret = widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); /*lpWaveInHdr->lpData = saveddata;*/ return ret; } /************************************************************************** * waveInStart [WINMM.157] */ UINT32 WINAPI waveInStart32(HWAVEIN32 hWaveIn) { return waveInStart16(hWaveIn); } /************************************************************************** * waveInStart [MMSYSTEM.509] */ UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0, 0); } /************************************************************************** * waveInStop [WINMM.158] */ UINT32 WINAPI waveInStop32(HWAVEIN32 hWaveIn) { return waveInStop16(hWaveIn); } /************************************************************************** * waveInStop [MMSYSTEM.510] */ UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** * waveInReset [WINMM.156] */ UINT32 WINAPI waveInReset32(HWAVEIN32 hWaveIn) { return waveInReset16(hWaveIn); } /************************************************************************** * waveInReset [MMSYSTEM.511] */ UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0, 0); } /************************************************************************** * waveInGetPosition [WINMM.152] */ UINT32 WINAPI waveInGetPosition32(HWAVEIN32 hWaveIn, LPMMTIME32 lpTime, UINT32 uSize) { MMTIME16 mmt16; UINT32 ret; mmt16.wType = lpTime->wType; ret = waveInGetPosition16(hWaveIn, &mmt16,uSize); MMSYSTEM_MMTIME16to32(lpTime, &mmt16); return ret; } /************************************************************************** * waveInGetPosition [MMSYSTEM.512] */ UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime, UINT16 uSize) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpTime, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance, (DWORD)lpTime, (DWORD)uSize); } /************************************************************************** * waveInGetID [WINMM.150] */ UINT32 WINAPI waveInGetID32(HWAVEIN32 hWaveIn, UINT32 * lpuDeviceID) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "waveInGetID\n"); if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = lpDesc->uDeviceID; return 0; } /************************************************************************** * waveInGetID [MMSYSTEM.513] */ UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID) { LPWAVEOPENDESC lpDesc; TRACE(mmsys, "waveInGetID\n"); if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; *lpuDeviceID = lpDesc->uDeviceID; return 0; } /************************************************************************** * waveInMessage [WINMM.153] */ DWORD WINAPI waveInMessage32(HWAVEIN32 hWaveIn, UINT32 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWAVEOPENDESC lpDesc; FIXME(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hWaveIn, uMessage, dwParam1, dwParam2); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case WIDM_OPEN: FIXME(mmsys, "cannot handle WIDM_OPEN, please report.\n"); break; case WIDM_GETNUMDEVS: case WIDM_GETPOS: case WIDM_CLOSE: case WIDM_STOP: case WIDM_RESET: case WIDM_START: case WIDM_PREPARE: case WIDM_UNPREPARE: case WIDM_ADDBUFFER: case WIDM_PAUSE: /* no argument conversion needed */ break; case WIDM_GETDEVCAPS: /*FIXME: ANSI/UNICODE */ return waveInGetDevCaps32A(hWaveIn, (LPWAVEINCAPS32A)dwParam1, dwParam2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", hWaveIn,uMessage, dwParam1, dwParam2); break; } return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * waveInMessage [MMSYSTEM.514] */ DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWAVEOPENDESC lpDesc; FIXME(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hWaveIn, uMessage, dwParam1, dwParam2); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; switch (uMessage) { case WIDM_OPEN: FIXME(mmsys,"cannot handle WIDM_OPEN, please report.\n"); break; case WIDM_GETNUMDEVS: case WIDM_CLOSE: case WIDM_STOP : case WIDM_RESET: case WIDM_START: case WIDM_PAUSE: /* no argument conversion needed */ break; case WIDM_GETDEVCAPS: return waveInGetDevCaps16(hWaveIn, (LPWAVEINCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WIDM_GETPOS: return waveInGetPosition16(hWaveIn, (LPMMTIME16)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WIDM_PREPARE: return waveInPrepareHeader16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WIDM_UNPREPARE: return waveInUnprepareHeader16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); case WIDM_ADDBUFFER: return waveInAddBuffer16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2); default: ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n", hWaveIn,uMessage, dwParam1, dwParam2); break; } return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** * DrvOpen [MMSYSTEM.1100] */ HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam) { TRACE(mmsys,"('%s','%s',%08lX);\n", lpDriverName, lpSectionName, lParam); return OpenDriver16(lpDriverName, lpSectionName, lParam); } /************************************************************************** * DrvClose [MMSYSTEM.1101] */ LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2) { TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2); return CloseDriver16(hDrvr, lParam1, lParam2); } /************************************************************************** * DrvSendMessage [MMSYSTEM.1102] */ LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1, LPARAM lParam2) { /* DWORD dwDriverID = 0; */ FIXME(mmsys, "(%04X, %04X, %08lX, %08lX);\n", hDriver, msg, lParam1, lParam2); return MMSYSERR_NOTENABLED; /* FIXME: wrong ... */ /* should known the mapping between hDrv and wDevIDs */ /* MCICDAUDIO_DriverProc16(dwDriverID, hDriver, msg, lParam1, lParam2); */ } /************************************************************************** * DrvGetModuleHandle [MMSYSTEM.1103] */ HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrvr) { return GetDriverModuleHandle16(hDrvr); } /************************************************************************** * DrvDefDriverProc [MMSYSTEM.1104] */ LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg, DWORD dwParam1, DWORD dwParam2) { return DefDriverProc16(dwDriverID, hDriv, wMsg, dwParam1, dwParam2); } /************************************************************************** * DefDriverProc32 [WINMM.5] */ LRESULT WINAPI DefDriverProc32(DWORD dwDriverIdentifier, HDRVR32 hdrvr, UINT32 Msg, LPARAM lParam1, LPARAM lParam2) { switch (Msg) { case DRV_LOAD: case DRV_DISABLE: case DRV_INSTALL: return 0; case DRV_ENABLE: case DRV_FREE: case DRV_REMOVE: return 1; default: return 0; } } /************************************************************************** * mmThreadCreate [MMSYSTEM.1120] */ LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4) { FIXME(mmsys,"(%p,%p,%08lx,%08lx): stub!\n",x1,x2,x3,x4); *x2 = 0xbabe; return 0; } /************************************************************************** * mmThreadGetTask [MMSYSTEM.1125] */ LRESULT WINAPI mmThreadGetTask16(WORD hnd) { FIXME(mmsys,"(%04x): stub!\n", hnd); return GetCurrentTask(); } /************************************************************************** * mmThreadSignal [MMSYSTEM.1121] */ LRESULT WINAPI mmThreadSignal16(WORD hnd) { FIXME(mmsys,"(%04x): stub!\n", hnd); return 0; } /************************************************************************** * mmTaskCreate [MMSYSTEM.900] */ HINSTANCE16 WINAPI mmTaskCreate16(LPWORD lphnd,HINSTANCE16 *hMmTask, DWORD x2) { DWORD showCmd = 0x40002; LPSTR cmdline; WORD sel1, sel2; LOADPARAMS *lp; HINSTANCE16 ret, handle; TRACE(mmsys,"(%p,%p,%08lx);\n", lphnd, hMmTask,x2); cmdline = (LPSTR)HeapAlloc(GetProcessHeap(), 0, 0x0d); cmdline[0] = 0x0d; (DWORD)cmdline[1] = (DWORD)lphnd; (DWORD)cmdline[5] = x2; (DWORD)cmdline[9] = 0; sel1 = SELECTOR_AllocBlock(cmdline, 0x0d, SEGMENT_DATA, FALSE, FALSE); sel2 = SELECTOR_AllocBlock(&showCmd, sizeof(showCmd), SEGMENT_DATA, FALSE, FALSE); lp = (LOADPARAMS *)HeapAlloc(GetProcessHeap(), 0, sizeof(LOADPARAMS)); lp->hEnvironment = 0; lp->cmdLine = PTR_SEG_OFF_TO_SEGPTR(sel1, 0); lp->showCmd = PTR_SEG_OFF_TO_SEGPTR(sel2, 0); lp->reserved = 0; ret = LoadModule16("c:\\windows\\mmtask.tsk", lp); if (ret < 32) { if (ret) ret = 1; else ret = 2; handle = 0; } else { handle = ret; ret = 0; } if (hMmTask) *(HINSTANCE16 *)PTR_SEG_TO_LIN(hMmTask) = handle; UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel2, 0)); UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel1, 0)); HeapFree(GetProcessHeap(), 0, lp); HeapFree(GetProcessHeap(), 0, cmdline); return ret; } /************************************************************************** * mmTaskSignal [MMSYSTEM.903] */ LRESULT WINAPI mmTaskSignal16(HTASK16 ht) { TRACE(mmsys,"(%04x);\n", ht); return PostAppMessage32A(ht, WM_USER, 0, 0); }