reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-02 00:36:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
16bdc256b9
wine/multimedia/mmsystem.c
Marcus Meissner 03479f8adb Fixed a lot of warnings for possible problems.
1999-01-28 10:06:38 +00:00

4901 lines
156 KiB
C
Raw Blame History

/* -*- 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 <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#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;
default: TRACE(mci, "Unknown device type %u\n", uDevType);
}
return proc;
}
/**************************************************************************
* MCI_GetDevType [internal]
*/
WORD MCI_GetDevType(LPCSTR str)
{
WORD uDevTyp = 0;
if (strcmp(str, "CDAUDIO") == 0) {
uDevTyp = MCI_DEVTYPE_CD_AUDIO;
} else if (strcmp(str, "WAVEAUDIO") == 0) {
uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
} else if (strcmp(str, "SEQUENCER") == 0) {
uDevTyp = MCI_DEVTYPE_SEQUENCER;
} else if (strcmp(str, "ANIMATION1") == 0) {
uDevTyp = MCI_DEVTYPE_ANIMATION;
} else if (strcmp(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]
*/
BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
{
PlaySound_SearchMode = 1;
return PlaySound32A(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;
PostMessage16((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);
return _get_mixerID_from_handle(hmix,fdwID);
}
/**************************************************************************
* 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;
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;
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) - semi-stub?\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 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, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
if (!IsWindow32(hWndCallBack)) return FALSE;
TRACE(mmsys, "before PostMessage\n");
PostMessage16(hWndCallBack, MM_MCINOTIFY, wStatus, MAKELONG(wDevID, 0));
return TRUE;
}
/**************************************************************************
* mciDriverNotify32 [WINMM.36]
*/
BOOL32 WINAPI mciDriverNotify32(HWND32 hWndCallBack, UINT32 wDevID, UINT32 wStatus)
{
FIXME(mmsys, "stub(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
return FALSE;
}
/**************************************************************************
* mciGetDriverData [MMSYSTEM.708]
*/
DWORD WINAPI mciGetDriverData16(HDRVR16 hdrv)
{
FIXME(mmsys,"(%04x): stub!\n",hdrv);
return 0x42;
}
/**************************************************************************
* mciGetDriverData [WINMM.44]
*/
DWORD WINAPI mciGetDriverData32(HDRVR32 hdrv)
{
FIXME(mmsys,"(%04x): stub!\n",hdrv);
return 0x42;
}
/**************************************************************************
* mciSetDriverData [MMSYSTEM.707]
*/
BOOL16 WINAPI mciSetDriverData16(HDRVR16 hdrv, DWORD data)
{
FIXME(mmsys,"(%04x,%08lx): stub!\n",hdrv,data);
return 0;
}
/**************************************************************************
* mciSetDriverData [WINMM.53]
*/
BOOL32 WINAPI mciSetDriverData32(HDRVR32 hdrv, DWORD data)
{
FIXME(mmsys,"(%04x,%08lx): stub!\n",hdrv,data);
return 0;
}
/**************************************************************************
* 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_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_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 = OpenDriver(str, "mci", NULL);
if (hdrv) {
HMODULE16 hmod;
hmod = GetDriverModuleHandle(hdrv);
MCI_GetDrv(wDevID)->hDrv = hdrv;
MCI_GetDrv(wDevID)->driverProc = GetProcAddress16(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 = OpenDriver(str,"mci",NULL);
if (hdrv) {
HMODULE16 hmod;
hmod = GetDriverModuleHandle(hdrv);
MCI_GetDrv(wDevID)->hDrv = hdrv;
MCI_GetDrv(wDevID)->driverProc = GetProcAddress16(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 */
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;
};
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);
free(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)
{
struct SCA32* sca = malloc(sizeof(struct SCA32));
if (sca == 0) return MCIERR_OUT_OF_MEMORY;
sca->wDevID = wDevID;
sca->wMsg = wMsg;
sca->dwParam1 = dwParam1;
sca->dwParam2 = dwParam2;
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;
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:
{
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;
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;
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_DEVTYPE_SEQUENCER, 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;
wDevID = MCI_FirstDevID();
while (MCI_DevIDValid(wDevID) && MCI_GetDrv(wDevID)->modp.wType) {
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;
wDevID = MCI_NextDevID(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;
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;
LPBYTE saveddata = lpWaveOutHdr->lpData;
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->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
ret = wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
(DWORD)lpWaveOutHdr,uSize);
lpWaveOutHdr->lpData = saveddata;
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;
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;
LPBYTE saveddata = lpWaveOutHdr->lpData;
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->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
ret = wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
(DWORD)lpWaveOutHdr, uSize);
lpWaveOutHdr->lpData = saveddata;
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),FIXME!\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),FIXME!\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 PostAppMessage16(ht,WM_USER,0,0);
}
Reference in New Issue View Git Blame Copy Permalink