1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
6 * Copyright 1993 Martin Ayotte
11 * 98/9 added Win32 MCI support
12 * 99/4 added mmTask and mmThread functions support
13 * added midiStream support
16 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
17 * and long term pointers to 16 bit space in here
23 #include "wine/winbase16.h"
31 #include "selectors.h"
33 #include "debugtools.h"
35 DEFAULT_DEBUG_CHANNEL(mmsys
)
37 LONG WINAPI
DrvDefDriverProc(DWORD dwDevID
, HDRVR16 hDrv
, WORD wMsg
,
38 DWORD dwParam1
, DWORD dwParam2
);
40 static LPWINE_MM_IDATA lpFirstIData
= NULL
;
42 /**************************************************************************
43 * MULTIMEDIA_GetIData [internal]
45 LPWINE_MM_IDATA
MULTIMEDIA_GetIData(void)
47 DWORD pid
= GetCurrentProcessId();
48 LPWINE_MM_IDATA iData
;
50 for (iData
= lpFirstIData
; iData
; iData
= iData
->lpNextIData
) {
51 if (iData
->dwThisProcess
== pid
)
57 /**************************************************************************
58 * WINMM_LibMain [EntryPoint]
60 * WINMM DLL entry point
63 BOOL WINAPI
WINMM_LibMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID fImpLoad
)
65 static BOOL bInitDone
= FALSE
;
66 LPWINE_MM_IDATA iData
;
68 TRACE("0x%x 0x%lx %p\n", hinstDLL
, fdwReason
, fImpLoad
);
71 case DLL_PROCESS_ATTACH
:
72 if (!bInitDone
) { /* to be done only once */
73 /* FIXME: OSS_MidiInit() shall be moved to OSS low level driver */
74 if (!OSS_MidiInit() || !MULTIMEDIA_MciInit()) {
79 iData
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WINE_MM_IDATA
));
82 iData
->hWinMM32Instance
= hinstDLL
;
83 iData
->dwThisProcess
= GetCurrentProcessId();
84 iData
->lpNextIData
= lpFirstIData
;
86 InitializeCriticalSection(&iData
->cs
);
88 case DLL_PROCESS_DETACH
:
89 iData
= MULTIMEDIA_GetIData();
91 LPWINE_MM_IDATA
* ppid
;
93 for (ppid
= &lpFirstIData
; *ppid
; ppid
= &(*ppid
)->lpNextIData
) {
95 *ppid
= iData
->lpNextIData
;
100 ERR("Idata is NULL, please report\n");
103 /* FIXME: should also free content and resources allocated inside iData */
104 HeapFree(GetProcessHeap(), 0, iData
);
106 case DLL_THREAD_ATTACH
:
107 case DLL_THREAD_DETACH
:
113 /**************************************************************************
114 * MMSYSTEM_LibMain [EntryPoint]
116 * MMSYSTEM DLL entry point
119 BOOL WINAPI
MMSYSTEM_LibMain(DWORD fdwReason
, HINSTANCE hinstDLL
, WORD ds
,
120 WORD wHeapSize
, DWORD dwReserved1
, WORD wReserved2
)
123 LPWINE_MM_IDATA iData
;
125 TRACE("0x%x 0x%lx\n", hinstDLL
, fdwReason
);
128 case DLL_PROCESS_ATTACH
:
129 /* need to load WinMM in order to:
130 * - correctly initiates shared variables (MULTIMEDIA_Init())
131 * - correctly creates the per process WINE_MM_IDATA chunk
133 hndl
= LoadLibraryA("WINMM.DLL");
136 ERR("Could not load sibling WinMM.dll\n");
139 iData
= MULTIMEDIA_GetIData();
140 if (!iData
) {ERR("Idata is NULL, please report\n"); return FALSE
;}
141 iData
->hWinMM16Instance
= hinstDLL
;
142 iData
->h16Module32
= hndl
;
144 case DLL_PROCESS_DETACH
:
145 iData
= MULTIMEDIA_GetIData();
147 ERR("Idata is NULL, please report\n");
150 FreeLibrary(iData
->h16Module32
);
152 case DLL_THREAD_ATTACH
:
153 case DLL_THREAD_DETACH
:
159 /**************************************************************************
160 * MMSYSTEM_WEP [MMSYSTEM.1]
162 int WINAPI
MMSYSTEM_WEP(HINSTANCE16 hInstance
, WORD wDataSeg
,
163 WORD cbHeapSize
, LPSTR lpCmdLine
)
165 FIXME("STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance
);
169 static void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16
, const MMTIME
* mmt32
)
171 mmt16
->wType
= mmt32
->wType
;
172 /* layout of rest is the same for 32/16,
173 * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
175 memcpy(&(mmt16
->u
), &(mmt32
->u
), sizeof(mmt16
->u
));
178 static void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32
, const MMTIME16
* mmt16
)
180 mmt32
->wType
= mmt16
->wType
;
181 /* layout of rest is the same for 32/16,
182 * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
184 memcpy(&(mmt32
->u
), &(mmt16
->u
), sizeof(mmt16
->u
));
187 static HANDLE PlaySound_hThread
= 0;
188 static HANDLE PlaySound_hPlayEvent
= 0;
189 static HANDLE PlaySound_hReadyEvent
= 0;
190 static HANDLE PlaySound_hMiddleEvent
= 0;
191 static BOOL PlaySound_Result
= FALSE
;
192 static int PlaySound_Stop
= FALSE
;
193 static int PlaySound_Playing
= FALSE
;
195 static LPCSTR PlaySound_pszSound
= NULL
;
196 static HMODULE PlaySound_hmod
= 0;
197 static DWORD PlaySound_fdwSound
= 0;
198 static int PlaySound_Loop
= FALSE
;
199 static int PlaySound_SearchMode
= 0; /* 1 - sndPlaySound search order
200 2 - PlaySound order */
202 static HMMIO
get_mmioFromFile(LPCSTR lpszName
)
204 return mmioOpenA((LPSTR
)lpszName
, NULL
,
205 MMIO_ALLOCBUF
| MMIO_READ
| MMIO_DENYWRITE
);
208 static HMMIO
get_mmioFromProfile(UINT uFlags
, LPCSTR lpszName
)
214 TRACE("searching in SystemSound List !\n");
215 GetProfileStringA("Sounds", (LPSTR
)lpszName
, "", str
, sizeof(str
));
216 if (strlen(str
) == 0) {
217 if (uFlags
& SND_NODEFAULT
) return 0;
218 GetProfileStringA("Sounds", "Default", "", str
, sizeof(str
));
219 if (strlen(str
) == 0) return 0;
221 if ((ptr
= (LPSTR
)strchr(str
, ',')) != NULL
) *ptr
= '\0';
222 hmmio
= get_mmioFromFile(str
);
224 WARN("can't find SystemSound='%s' !\n", str
);
230 static BOOL WINAPI
proc_PlaySound(LPCSTR lpszSoundName
, UINT uFlags
)
236 TRACE("SoundName='%s' uFlags=%04X !\n", lpszSoundName
, uFlags
);
237 if (lpszSoundName
== NULL
) {
241 if (uFlags
& SND_MEMORY
) {
243 memset(&mminfo
, 0, sizeof(mminfo
));
244 mminfo
.fccIOProc
= FOURCC_MEM
;
245 mminfo
.pchBuffer
= (LPSTR
)lpszSoundName
;
246 mminfo
.cchBuffer
= -1;
247 TRACE("Memory sound %p\n", lpszSoundName
);
248 hmmio
= mmioOpenA(NULL
, &mminfo
, MMIO_READ
);
251 if (uFlags
& SND_ALIAS
)
252 if ((hmmio
=get_mmioFromProfile(uFlags
, lpszSoundName
)) == 0)
255 if (uFlags
& SND_FILENAME
)
256 if ((hmmio
=get_mmioFromFile(lpszSoundName
)) == 0) return FALSE
;
258 if (PlaySound_SearchMode
== 1) {
259 PlaySound_SearchMode
= 0;
260 if ((hmmio
=get_mmioFromFile(lpszSoundName
)) == 0)
261 if ((hmmio
=get_mmioFromProfile(uFlags
, lpszSoundName
)) == 0)
265 if (PlaySound_SearchMode
== 2) {
266 PlaySound_SearchMode
= 0;
267 if ((hmmio
=get_mmioFromProfile(uFlags
| SND_NODEFAULT
, lpszSoundName
)) == 0)
268 if ((hmmio
=get_mmioFromFile(lpszSoundName
)) == 0)
269 if ((hmmio
=get_mmioFromProfile(uFlags
, lpszSoundName
)) == 0) return FALSE
;
273 if (mmioDescend(hmmio
, &ckMainRIFF
, NULL
, 0) == 0) {
274 DWORD dwPos
= mmioSeek(hmmio
, 0, SEEK_CUR
);
276 TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
277 (LPSTR
)&ckMainRIFF
.ckid
, (LPSTR
)&ckMainRIFF
.fccType
,
280 mmioSeek(hmmio
, dwPos
, SEEK_SET
);
282 if ((ckMainRIFF
.ckid
== FOURCC_RIFF
) &&
283 (ckMainRIFF
.fccType
== mmioFOURCC('W', 'A', 'V', 'E'))) {
286 mmckInfo
.ckid
= mmioFOURCC('f', 'm', 't', ' ');
288 if (mmioDescend(hmmio
, &mmckInfo
, &ckMainRIFF
, MMIO_FINDCHUNK
) == 0) {
289 PCMWAVEFORMAT pcmWaveFormat
;
291 TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
292 (LPSTR
)&mmckInfo
.ckid
, (LPSTR
)&mmckInfo
.fccType
, mmckInfo
.cksize
);
294 if (mmioRead(hmmio
, (HPSTR
)&pcmWaveFormat
,
295 (long) sizeof(PCMWAVEFORMAT
)) == (long) sizeof(PCMWAVEFORMAT
)) {
296 TRACE("wFormatTag=%04X !\n", pcmWaveFormat
.wf
.wFormatTag
);
297 TRACE("nChannels=%d \n", pcmWaveFormat
.wf
.nChannels
);
298 TRACE("nSamplesPerSec=%ld\n", pcmWaveFormat
.wf
.nSamplesPerSec
);
299 TRACE("nAvgBytesPerSec=%ld\n", pcmWaveFormat
.wf
.nAvgBytesPerSec
);
300 TRACE("nBlockAlign=%d \n", pcmWaveFormat
.wf
.nBlockAlign
);
301 TRACE("wBitsPerSample=%u !\n", pcmWaveFormat
.wBitsPerSample
);
303 mmckInfo
.ckid
= mmioFOURCC('d', 'a', 't', 'a');
304 /* move to end of 'fmt ' chunk */
305 mmioSeek(hmmio
, mmckInfo
.dwDataOffset
+ ((mmckInfo
.cksize
+ 1) & ~1), SEEK_SET
);
307 if (mmioDescend(hmmio
, &mmckInfo
, &ckMainRIFF
, MMIO_FINDCHUNK
) == 0) {
308 WAVEOPENDESC waveDesc
;
311 TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
312 (LPSTR
)&mmckInfo
.ckid
, (LPSTR
)&mmckInfo
.fccType
, mmckInfo
.cksize
);
314 pcmWaveFormat
.wf
.nAvgBytesPerSec
= pcmWaveFormat
.wf
.nSamplesPerSec
*
315 pcmWaveFormat
.wf
.nBlockAlign
;
317 waveDesc
.lpFormat
= (LPWAVEFORMAT
)&pcmWaveFormat
;
319 dwRet
= wodMessage(0, WODM_OPEN
, 0, (DWORD
)&waveDesc
, CALLBACK_NULL
);
320 if (dwRet
== MMSYSERR_NOERROR
) {
323 INT count
, bufsize
, left
= mmckInfo
.cksize
;
326 hData
= GlobalAlloc16(GMEM_MOVEABLE
, bufsize
);
327 waveHdr
.lpData
= (LPSTR
)GlobalLock16(hData
);
328 waveHdr
.dwBufferLength
= bufsize
;
330 waveHdr
.dwFlags
= 0L;
331 waveHdr
.dwLoops
= 0L;
333 dwRet
= wodMessage(0, WODM_PREPARE
, 0, (DWORD
)&waveHdr
, sizeof(WAVEHDR
));
334 if (dwRet
== MMSYSERR_NOERROR
) {
336 if (PlaySound_Stop
) {
337 PlaySound_Stop
= FALSE
;
338 PlaySound_Loop
= FALSE
;
341 if (bufsize
> left
) bufsize
= left
;
342 count
= mmioRead(hmmio
, waveHdr
.lpData
,bufsize
);
343 if (count
< 1) break;
345 waveHdr
.dwBufferLength
= count
;
347 waveHdr
.reserved
= (DWORD
)&waveHdr
;
348 /* waveHdr.dwBytesRecorded = count; */
349 /* FIXME: doesn't expect async ops */
350 wodMessage(0, WODM_WRITE
, 0, (DWORD
)&waveHdr
, sizeof(WAVEHDR
));
351 while (!(waveHdr
.dwFlags
& WHDR_DONE
))
354 wodMessage(0, WODM_UNPREPARE
, 0, (DWORD
)&waveHdr
, sizeof(WAVEHDR
));
355 while (wodMessage(0, WODM_CLOSE
, 0, 0L, 0L) == WAVERR_STILLPLAYING
)
360 WARN("can't prepare WaveOut device !\n");
362 GlobalUnlock16(hData
);
369 } while (PlaySound_Loop
);
372 if (hmmio
!= 0) mmioClose(hmmio
, 0);
376 static DWORD WINAPI
PlaySound_Thread(LPVOID arg
)
381 PlaySound_Playing
= FALSE
;
382 SetEvent(PlaySound_hReadyEvent
);
383 res
= WaitForSingleObject(PlaySound_hPlayEvent
, INFINITE
);
384 ResetEvent(PlaySound_hReadyEvent
);
385 SetEvent(PlaySound_hMiddleEvent
);
386 if (res
== WAIT_FAILED
) ExitThread(2);
387 if (res
!= WAIT_OBJECT_0
) continue;
388 PlaySound_Playing
= TRUE
;
390 if ((PlaySound_fdwSound
& SND_RESOURCE
) == SND_RESOURCE
) {
395 if ((hRES
= FindResourceA(PlaySound_hmod
, PlaySound_pszSound
, "WAVE")) == 0) {
396 PlaySound_Result
= FALSE
;
399 if ((hGLOB
= LoadResource(PlaySound_hmod
, hRES
)) == 0) {
400 PlaySound_Result
= FALSE
;
403 if ((ptr
= LockResource(hGLOB
)) == NULL
) {
405 PlaySound_Result
= FALSE
;
408 PlaySound_Result
= proc_PlaySound(ptr
,
409 ((UINT16
)PlaySound_fdwSound
^ SND_RESOURCE
) | SND_MEMORY
);
413 PlaySound_Result
= proc_PlaySound(PlaySound_pszSound
, (UINT16
)PlaySound_fdwSound
);
417 /**************************************************************************
418 * PlaySoundA [WINMM.1]
420 BOOL WINAPI
PlaySoundA(LPCSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
422 static LPSTR StrDup
= NULL
;
424 TRACE("pszSound='%p' hmod=%04X fdwSound=%08lX\n",
425 pszSound
, hmod
, fdwSound
);
427 if (PlaySound_hThread
== 0) { /* This is the first time they called us */
429 if ((PlaySound_hReadyEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
)) == 0)
431 if ((PlaySound_hMiddleEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
)) == 0)
433 if ((PlaySound_hPlayEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
)) == 0)
435 if ((PlaySound_hThread
= CreateThread(NULL
, 0, PlaySound_Thread
, 0, 0, &id
)) == 0)
439 /* FIXME? I see no difference between SND_WAIT and SND_NOSTOP ! */
440 if ((fdwSound
& (SND_NOWAIT
| SND_NOSTOP
)) && PlaySound_Playing
)
443 /* Trying to stop if playing */
444 if (PlaySound_Playing
) PlaySound_Stop
= TRUE
;
446 /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave*/
447 if (WaitForSingleObject(PlaySound_hReadyEvent
, 1000*10) != WAIT_OBJECT_0
)
450 if (!pszSound
|| (fdwSound
& SND_PURGE
))
451 return FALSE
; /* We stoped playing so leaving */
453 if (PlaySound_SearchMode
!= 1) PlaySound_SearchMode
= 2;
454 if (!(fdwSound
& SND_ASYNC
)) {
455 if (fdwSound
& SND_LOOP
)
457 PlaySound_pszSound
= pszSound
;
458 PlaySound_hmod
= hmod
;
459 PlaySound_fdwSound
= fdwSound
;
460 PlaySound_Result
= FALSE
;
461 SetEvent(PlaySound_hPlayEvent
);
462 if (WaitForSingleObject(PlaySound_hMiddleEvent
, INFINITE
) != WAIT_OBJECT_0
)
464 if (WaitForSingleObject(PlaySound_hReadyEvent
, INFINITE
) != WAIT_OBJECT_0
)
466 return PlaySound_Result
;
468 PlaySound_hmod
= hmod
;
469 PlaySound_fdwSound
= fdwSound
;
470 PlaySound_Result
= FALSE
;
472 HeapFree(GetProcessHeap(), 0, StrDup
);
475 if (!((fdwSound
& SND_MEMORY
) || ((fdwSound
& SND_RESOURCE
) &&
476 !((DWORD
)pszSound
>> 16)) || !pszSound
)) {
477 StrDup
= HEAP_strdupA(GetProcessHeap(), 0,pszSound
);
478 PlaySound_pszSound
= StrDup
;
479 } else PlaySound_pszSound
= pszSound
;
480 PlaySound_Loop
= fdwSound
& SND_LOOP
;
481 SetEvent(PlaySound_hPlayEvent
);
482 ResetEvent(PlaySound_hMiddleEvent
);
488 /**************************************************************************
489 * PlaySoundW [WINMM.18]
491 BOOL WINAPI
PlaySoundW(LPCWSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
496 if (!((fdwSound
& SND_MEMORY
) || ((fdwSound
& SND_RESOURCE
) &&
497 !((DWORD
)pszSound
>> 16)) || !pszSound
)) {
498 pszSoundA
= HEAP_strdupWtoA(GetProcessHeap(), 0,pszSound
);
499 bSound
= PlaySoundA(pszSoundA
, hmod
, fdwSound
);
500 HeapFree(GetProcessHeap(), 0,pszSoundA
);
502 bSound
= PlaySoundA((LPCSTR
)pszSound
, hmod
, fdwSound
);
507 /**************************************************************************
508 * PlaySound16 [MMSYSTEM.3]
510 BOOL16 WINAPI
PlaySound16(LPCSTR pszSound
, HMODULE16 hmod
, DWORD fdwSound
)
514 SYSLEVEL_ReleaseWin16Lock();
515 retv
= PlaySoundA( pszSound
, hmod
, fdwSound
);
516 SYSLEVEL_RestoreWin16Lock();
521 /**************************************************************************
522 * sndPlaySoundA [WINMM135]
524 BOOL WINAPI
sndPlaySoundA(LPCSTR lpszSoundName
, UINT uFlags
)
526 PlaySound_SearchMode
= 1;
527 return PlaySoundA(lpszSoundName
, 0, uFlags
);
530 /**************************************************************************
531 * sndPlaySoundW [WINMM.136]
533 BOOL WINAPI
sndPlaySoundW(LPCWSTR lpszSoundName
, UINT uFlags
)
535 PlaySound_SearchMode
= 1;
536 return PlaySoundW(lpszSoundName
, 0, uFlags
);
539 /**************************************************************************
540 * sndPlaySound16 [MMSYSTEM.2]
542 BOOL16 WINAPI
sndPlaySound16(LPCSTR lpszSoundName
, UINT16 uFlags
)
546 SYSLEVEL_ReleaseWin16Lock();
547 retv
= sndPlaySoundA( lpszSoundName
, uFlags
);
548 SYSLEVEL_RestoreWin16Lock();
554 /**************************************************************************
555 * mmsystemGetVersion [WINMM.134]
557 UINT WINAPI
mmsystemGetVersion(void)
559 return mmsystemGetVersion16();
562 /**************************************************************************
563 * mmsystemGetVersion [MMSYSTEM.5]
564 * return value borrowed from Win95 winmm.dll ;)
566 UINT16 WINAPI
mmsystemGetVersion16(void)
568 TRACE("3.10 (Win95?)\n");
572 /**************************************************************************
573 * DriverProc [MMSYSTEM.6]
575 LRESULT WINAPI
DriverProc16(DWORD dwDevID
, HDRVR16 hDrv
, WORD wMsg
,
576 DWORD dwParam1
, DWORD dwParam2
)
578 return DrvDefDriverProc(dwDevID
, hDrv
, wMsg
, dwParam1
, dwParam2
);
581 /**************************************************************************
582 * DriverCallback [MMSYSTEM.31]
584 BOOL16 WINAPI
DriverCallback16(DWORD dwCallBack
, UINT16 uFlags
, HANDLE16 hDev
,
585 WORD wMsg
, DWORD dwUser
, DWORD dwParam1
, DWORD dwParam2
)
587 TRACE("(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
588 dwCallBack
, uFlags
, hDev
, wMsg
, dwUser
, dwParam1
, dwParam2
);
590 switch (uFlags
& DCB_TYPEMASK
) {
595 TRACE("Window(%04lX) handle=%04X!\n", dwCallBack
, hDev
);
596 if (!IsWindow(dwCallBack
) || USER_HEAP_LIN_ADDR(hDev
) == NULL
)
598 Callout
.PostMessageA((HWND16
)dwCallBack
, wMsg
, hDev
, dwParam1
);
600 case DCB_TASK
: /* aka DCB_THREAD */
601 TRACE("Task(%04lx) !\n", dwCallBack
);
602 Callout
.PostThreadMessageA(dwCallBack
, wMsg
, hDev
, dwParam1
);
605 TRACE("Function (16bit) !\n");
606 Callbacks
->CallDriverCallback((FARPROC16
)dwCallBack
, hDev
, wMsg
, dwUser
,
609 case DCB_FUNC32
: /* This is a Wine only value - AKAIF not used yet by MS */
610 TRACE("Function (32bit) !\n");
611 ((LPDRVCALLBACK
)dwCallBack
)(hDev
, wMsg
, dwUser
, dwParam1
, dwParam2
);
614 TRACE("Event(%08lx) !\n", dwCallBack
);
615 SetEvent((HANDLE
)dwCallBack
);
617 case 6: /* I would dub it DCB_MMTHREADSIGNAL */
618 /* this is an undocumented DCB_ value used for mmThreads
619 * loword of dwCallBack contains the handle of the lpMMThd block
620 * which dwSignalCount has to be incremented
623 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(LOWORD(dwCallBack
), 0);
625 TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack
), lpMMThd
);
626 /* same as mmThreadSignal16 */
627 InterlockedIncrement(&lpMMThd
->dwSignalCount
);
628 SetEvent(lpMMThd
->hEvent
);
629 /* some other stuff on lpMMThd->hVxD */
634 /* this is an undocumented DCB_ value for... I don't know */
638 WARN("Unknown callback type %d\n", uFlags
& DCB_TYPEMASK
);
645 /**************************************************************************
646 * Mixer devices. New to Win95
649 /**************************************************************************
650 * find out the real mixer ID depending on hmix (depends on dwFlags)
651 * FIXME: also fix dwInstance passing to mixMessage
653 static UINT
MIXER_GetDevID(HMIXEROBJ hmix
, DWORD dwFlags
)
655 /* FIXME: Check dwFlags for MIXER_OBJSECTF_xxxx entries and modify hmix
656 * accordingly. For now we always use mixerdevice 0.
661 /**************************************************************************
662 * mixerGetNumDevs [WINMM.108]
664 UINT WINAPI
mixerGetNumDevs(void)
666 UINT16 count
= mixMessage(0, MXDM_GETNUMDEVS
, 0L, 0L, 0L);
668 TRACE("mixerGetNumDevs returns %d\n", count
);
672 /**************************************************************************
673 * mixerGetNumDevs [MMSYSTEM.800]
675 UINT16 WINAPI
mixerGetNumDevs16(void)
677 return mixerGetNumDevs();
680 /**************************************************************************
681 * mixerGetDevCapsA [WINMM.101]
683 UINT WINAPI
mixerGetDevCapsA(UINT devid
, LPMIXERCAPSA mixcaps
, UINT size
)
685 return mixMessage(devid
, MXDM_GETDEVCAPS
, 0L, (DWORD
)mixcaps
, (DWORD
)size
);
688 /**************************************************************************
689 * mixerGetDevCapsW [WINMM.102]
691 UINT WINAPI
mixerGetDevCapsW(UINT devid
, LPMIXERCAPSW mixcaps
, UINT size
)
694 UINT ret
= mixerGetDevCapsA(devid
, &micA
, sizeof(micA
));
696 if (ret
== MMSYSERR_NOERROR
) {
697 mixcaps
->wMid
= micA
.wMid
;
698 mixcaps
->wPid
= micA
.wPid
;
699 mixcaps
->vDriverVersion
= micA
.vDriverVersion
;
700 lstrcpyAtoW(mixcaps
->szPname
, micA
.szPname
);
701 mixcaps
->fdwSupport
= micA
.fdwSupport
;
702 mixcaps
->cDestinations
= micA
.cDestinations
;
707 /**************************************************************************
708 * mixerGetDevCaps [MMSYSTEM.801]
710 UINT16 WINAPI
mixerGetDevCaps16(UINT16 devid
, LPMIXERCAPS16 mixcaps
, UINT16 size
)
713 UINT ret
= mixerGetDevCapsA(devid
, &micA
, sizeof(micA
));
715 if (ret
== MMSYSERR_NOERROR
) {
716 mixcaps
->wMid
= micA
.wMid
;
717 mixcaps
->wPid
= micA
.wPid
;
718 mixcaps
->vDriverVersion
= micA
.vDriverVersion
;
719 strcpy(mixcaps
->szPname
, micA
.szPname
);
720 mixcaps
->fdwSupport
= micA
.fdwSupport
;
721 mixcaps
->cDestinations
= micA
.cDestinations
;
726 /**************************************************************************
727 * mixerOpen [WINMM.110]
729 UINT WINAPI
mixerOpen(LPHMIXER lphmix
, UINT uDeviceID
, DWORD dwCallback
,
730 DWORD dwInstance
, DWORD fdwOpen
)
735 TRACE("(%p, %d, %08lx, %08lx, %08lx)\n",
736 lphmix
, uDeviceID
, dwCallback
, dwInstance
, fdwOpen
);
737 ret
= mixerOpen16(&hmix16
, uDeviceID
, dwCallback
, dwInstance
,fdwOpen
);
738 if (lphmix
) *lphmix
= hmix16
;
742 /**************************************************************************
743 * mixerOpen [MMSYSTEM.803]
745 UINT16 WINAPI
mixerOpen16(LPHMIXER16 lphmix
, UINT16 uDeviceID
, DWORD dwCallback
,
746 DWORD dwInstance
, DWORD fdwOpen
)
749 LPMIXEROPENDESC lpmod
;
750 BOOL mapperflag
= (uDeviceID
== 0);
753 TRACE("(%p, %d, %08lx, %08lx, %08lx)\n",
754 lphmix
, uDeviceID
, dwCallback
, dwInstance
, fdwOpen
);
755 hmix
= USER_HEAP_ALLOC(sizeof(MIXEROPENDESC
));
756 if (lphmix
) *lphmix
= hmix
;
757 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
759 lpmod
->dwCallback
= dwCallback
;
760 lpmod
->dwInstance
= dwInstance
;
761 if (uDeviceID
>= MAXMIXERDRIVERS
)
763 while (uDeviceID
< MAXMIXERDRIVERS
) {
764 dwRet
= mixMessage(uDeviceID
, MXDM_OPEN
, dwInstance
, (DWORD
)lpmod
, fdwOpen
);
765 if (dwRet
== MMSYSERR_NOERROR
) break;
766 if (!mapperflag
) break;
769 lpmod
->uDeviceID
= uDeviceID
;
771 if (dwRet
!= MMSYSERR_NOERROR
) {
772 USER_HEAP_FREE(hmix
);
773 if (lphmix
) *lphmix
= 0;
779 /**************************************************************************
780 * mixerClose [WINMM.98]
782 UINT WINAPI
mixerClose(HMIXER hmix
)
784 LPMIXEROPENDESC lpmod
;
787 TRACE("(%04x)\n", hmix
);
789 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
790 if (lpmod
== NULL
) return MMSYSERR_INVALHANDLE
;
791 dwRet
= mixMessage(lpmod
->uDeviceID
, MXDM_CLOSE
, lpmod
->dwInstance
, 0L, 0L);
792 USER_HEAP_FREE(hmix
);
796 /**************************************************************************
797 * mixerClose [MMSYSTEM.803]
799 UINT16 WINAPI
mixerClose16(HMIXER16 hmix
)
801 return mixerClose(hmix
);
804 /**************************************************************************
805 * mixerGetID [WINMM.103]
807 UINT WINAPI
mixerGetID(HMIXEROBJ hmix
, LPUINT lpid
, DWORD fdwID
)
809 FIXME("(%04x %p %08lx): semi-stub\n", hmix
, lpid
, fdwID
);
812 *lpid
= MIXER_GetDevID(hmix
, fdwID
);
814 return MMSYSERR_NOERROR
; /* FIXME: many error possibilities */
817 /**************************************************************************
820 UINT16 WINAPI
mixerGetID16(HMIXEROBJ16 hmix
, LPUINT16 lpid
, DWORD fdwID
)
823 UINT ret
= mixerGetID(hmix
, &xid
, fdwID
);
830 /**************************************************************************
831 * mixerGetControlDetailsA [WINMM.99]
833 UINT WINAPI
mixerGetControlDetailsA(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdA
, DWORD fdwDetails
)
837 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmcdA
, fdwDetails
);
839 if (lpmcdA
== NULL
|| lpmcdA
->cbStruct
!= sizeof(*lpmcdA
))
840 return MMSYSERR_INVALPARAM
;
842 uDevID
= MIXER_GetDevID(hmix
, fdwDetails
);
844 return mixMessage(uDevID
, MXDM_GETCONTROLDETAILS
, 0, (DWORD
)lpmcdA
, fdwDetails
);
847 /**************************************************************************
848 * mixerGetControlDetailsW [WINMM.100]
850 UINT WINAPI
mixerGetControlDetailsW(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcd
, DWORD fdwDetails
)
852 DWORD ret
= MMSYSERR_NOTENABLED
;
854 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmcd
, fdwDetails
);
856 if (lpmcd
== NULL
|| lpmcd
->cbStruct
!= sizeof(*lpmcd
))
857 return MMSYSERR_INVALPARAM
;
859 switch (fdwDetails
& MIXER_GETCONTROLDETAILSF_QUERYMASK
) {
860 case MIXER_GETCONTROLDETAILSF_VALUE
:
861 /* can savely use W structure as it is, no string inside */
862 ret
= mixerGetControlDetailsA(hmix
, lpmcd
, fdwDetails
);
864 case MIXER_GETCONTROLDETAILSF_LISTTEXT
:
866 LPVOID paDetailsW
= lpmcd
->paDetails
;
867 int size
= MAX(1, lpmcd
->cChannels
) * sizeof(MIXERCONTROLDETAILS_LISTTEXTA
);
869 if (lpmcd
->u
.cMultipleItems
!= 0 && lpmcd
->u
.cMultipleItems
!= lpmcd
->u
.hwndOwner
) {
870 size
*= lpmcd
->u
.cMultipleItems
;
872 lpmcd
->paDetails
= HeapAlloc(GetProcessHeap(), 0, size
);
873 /* set up lpmcd->paDetails */
874 ret
= mixerGetControlDetailsA(hmix
, lpmcd
, fdwDetails
);
875 /* copy from lpmcd->paDetails back to paDetailsW; */
876 HeapFree(GetProcessHeap(), 0, lpmcd
->paDetails
);
877 lpmcd
->paDetails
= paDetailsW
;
881 ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails
);
887 /**************************************************************************
888 * mixerGetControlDetails [MMSYSTEM.808]
890 UINT16 WINAPI
mixerGetControlDetails16(HMIXEROBJ16 hmix
, LPMIXERCONTROLDETAILS16 lpmcd
, DWORD fdwDetails
)
892 DWORD ret
= MMSYSERR_NOTENABLED
;
895 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmcd
, fdwDetails
);
897 if (lpmcd
== NULL
|| lpmcd
->cbStruct
!= sizeof(*lpmcd
))
898 return MMSYSERR_INVALPARAM
;
900 sppaDetails
= (SEGPTR
)lpmcd
->paDetails
;
901 lpmcd
->paDetails
= PTR_SEG_TO_LIN(sppaDetails
);
902 ret
= mixerGetControlDetailsA(hmix
, (LPMIXERCONTROLDETAILS
)lpmcd
, fdwDetails
);
903 lpmcd
->paDetails
= (LPVOID
)sppaDetails
;
908 /**************************************************************************
909 * mixerGetLineControlsA [WINMM.104]
911 UINT WINAPI
mixerGetLineControlsA(HMIXEROBJ hmix
, LPMIXERLINECONTROLSA lpmlcA
, DWORD fdwControls
)
915 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmlcA
, fdwControls
);
917 if (lpmlcA
== NULL
|| lpmlcA
->cbStruct
!= sizeof(*lpmlcA
))
918 return MMSYSERR_INVALPARAM
;
920 uDevID
= MIXER_GetDevID(hmix
, 0);
922 return mixMessage(uDevID
, MXDM_GETLINECONTROLS
, 0, (DWORD
)lpmlcA
, fdwControls
);
925 /**************************************************************************
926 * mixerGetLineControlsW [WINMM.105]
928 UINT WINAPI
mixerGetLineControlsW(HMIXEROBJ hmix
, LPMIXERLINECONTROLSW lpmlcW
, DWORD fdwControls
)
930 MIXERLINECONTROLSA mlcA
;
934 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmlcW
, fdwControls
);
936 if (lpmlcW
== NULL
|| lpmlcW
->cbStruct
!= sizeof(*lpmlcW
) || lpmlcW
->cbmxctrl
!= sizeof(MIXERCONTROLW
))
937 return MMSYSERR_INVALPARAM
;
939 mlcA
.cbStruct
= sizeof(mlcA
);
940 mlcA
.dwLineID
= lpmlcW
->dwLineID
;
941 mlcA
.u
.dwControlID
= lpmlcW
->u
.dwControlID
;
942 mlcA
.u
.dwControlType
= lpmlcW
->u
.dwControlType
;
943 mlcA
.cControls
= lpmlcW
->cControls
;
944 mlcA
.cbmxctrl
= sizeof(MIXERCONTROLA
);
945 mlcA
.pamxctrl
= HeapAlloc(GetProcessHeap(), 0, mlcA
.cControls
* mlcA
.cbmxctrl
);
947 ret
= mixerGetLineControlsA(hmix
, &mlcA
, fdwControls
);
949 if (ret
== MMSYSERR_NOERROR
) {
950 lpmlcW
->dwLineID
= mlcA
.dwLineID
;
951 lpmlcW
->u
.dwControlID
= mlcA
.u
.dwControlID
;
952 lpmlcW
->u
.dwControlType
= mlcA
.u
.dwControlType
;
953 lpmlcW
->cControls
= mlcA
.cControls
;
955 for (i
= 0; i
< mlcA
.cControls
; i
++) {
956 lpmlcW
->pamxctrl
[i
].cbStruct
= sizeof(MIXERCONTROLW
);
957 lpmlcW
->pamxctrl
[i
].dwControlID
= mlcA
.pamxctrl
[i
].dwControlID
;
958 lpmlcW
->pamxctrl
[i
].dwControlType
= mlcA
.pamxctrl
[i
].dwControlType
;
959 lpmlcW
->pamxctrl
[i
].fdwControl
= mlcA
.pamxctrl
[i
].fdwControl
;
960 lpmlcW
->pamxctrl
[i
].cMultipleItems
= mlcA
.pamxctrl
[i
].cMultipleItems
;
961 lstrcpyAtoW(lpmlcW
->pamxctrl
[i
].szShortName
, mlcA
.pamxctrl
[i
].szShortName
);
962 lstrcpyAtoW(lpmlcW
->pamxctrl
[i
].szName
, mlcA
.pamxctrl
[i
].szName
);
963 /* sizeof(lpmlcW->pamxctrl[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
964 memcpy(&lpmlcW
->pamxctrl
[i
].Bounds
, &mlcA
.pamxctrl
[i
].Bounds
, sizeof(mlcA
.pamxctrl
[i
].Bounds
));
965 /* sizeof(lpmlcW->pamxctrl[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
966 memcpy(&lpmlcW
->pamxctrl
[i
].Metrics
, &mlcA
.pamxctrl
[i
].Metrics
, sizeof(mlcA
.pamxctrl
[i
].Metrics
));
970 HeapFree(GetProcessHeap(), 0, mlcA
.pamxctrl
);
975 /**************************************************************************
976 * mixerGetLineControls [MMSYSTEM.807]
978 UINT16 WINAPI
mixerGetLineControls16(HMIXEROBJ16 hmix
, LPMIXERLINECONTROLS16 lpmlc16
, DWORD fdwControls
)
980 MIXERLINECONTROLSA mlcA
;
983 LPMIXERCONTROL16 lpmc16
;
985 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmlc16
, fdwControls
);
987 if (lpmlc16
== NULL
|| lpmlc16
->cbStruct
!= sizeof(*lpmlc16
) || lpmlc16
->cbmxctrl
!= sizeof(MIXERCONTROL16
))
988 return MMSYSERR_INVALPARAM
;
990 mlcA
.cbStruct
= sizeof(mlcA
);
991 mlcA
.dwLineID
= lpmlc16
->dwLineID
;
992 mlcA
.u
.dwControlID
= lpmlc16
->u
.dwControlID
;
993 mlcA
.u
.dwControlType
= lpmlc16
->u
.dwControlType
;
994 mlcA
.cControls
= lpmlc16
->cControls
;
995 mlcA
.cbmxctrl
= sizeof(MIXERCONTROLA
);
996 mlcA
.pamxctrl
= HeapAlloc(GetProcessHeap(), 0, mlcA
.cControls
* mlcA
.cbmxctrl
);
998 ret
= mixerGetLineControlsA(hmix
, &mlcA
, fdwControls
);
1000 if (ret
== MMSYSERR_NOERROR
) {
1001 lpmlc16
->dwLineID
= mlcA
.dwLineID
;
1002 lpmlc16
->u
.dwControlID
= mlcA
.u
.dwControlID
;
1003 lpmlc16
->u
.dwControlType
= mlcA
.u
.dwControlType
;
1004 lpmlc16
->cControls
= mlcA
.cControls
;
1006 lpmc16
= PTR_SEG_TO_LIN(lpmlc16
->pamxctrl
);
1008 for (i
= 0; i
< mlcA
.cControls
; i
++) {
1009 lpmc16
[i
].cbStruct
= sizeof(MIXERCONTROL16
);
1010 lpmc16
[i
].dwControlID
= mlcA
.pamxctrl
[i
].dwControlID
;
1011 lpmc16
[i
].dwControlType
= mlcA
.pamxctrl
[i
].dwControlType
;
1012 lpmc16
[i
].fdwControl
= mlcA
.pamxctrl
[i
].fdwControl
;
1013 lpmc16
[i
].cMultipleItems
= mlcA
.pamxctrl
[i
].cMultipleItems
;
1014 strcpy(lpmc16
[i
].szShortName
, mlcA
.pamxctrl
[i
].szShortName
);
1015 strcpy(lpmc16
[i
].szName
, mlcA
.pamxctrl
[i
].szName
);
1016 /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
1017 memcpy(&lpmc16
[i
].Bounds
, &mlcA
.pamxctrl
[i
].Bounds
, sizeof(mlcA
.pamxctrl
[i
].Bounds
));
1018 /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
1019 memcpy(&lpmc16
[i
].Metrics
, &mlcA
.pamxctrl
[i
].Metrics
, sizeof(mlcA
.pamxctrl
[i
].Metrics
));
1023 HeapFree(GetProcessHeap(), 0, mlcA
.pamxctrl
);
1028 /**************************************************************************
1029 * mixerGetLineInfoA [WINMM.106]
1031 UINT WINAPI
mixerGetLineInfoA(HMIXEROBJ hmix
, LPMIXERLINEA lpmliW
, DWORD fdwInfo
)
1035 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmliW
, fdwInfo
);
1037 /* FIXME: I'm not sure of the flags */
1038 devid
= MIXER_GetDevID(hmix
, fdwInfo
);
1039 return mixMessage(devid
, MXDM_GETLINEINFO
, 0, (DWORD
)lpmliW
, fdwInfo
);
1042 /**************************************************************************
1043 * mixerGetLineInfoW [WINMM.107]
1045 UINT WINAPI
mixerGetLineInfoW(HMIXEROBJ hmix
, LPMIXERLINEW lpmliW
, DWORD fdwInfo
)
1050 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmliW
, fdwInfo
);
1052 if (lpmliW
== NULL
|| lpmliW
->cbStruct
!= sizeof(*lpmliW
))
1053 return MMSYSERR_INVALPARAM
;
1055 mliA
.cbStruct
= sizeof(mliA
);
1056 switch (fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
) {
1057 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
1058 mliA
.dwComponentType
= lpmliW
->dwComponentType
;
1060 case MIXER_GETLINEINFOF_DESTINATION
:
1061 mliA
.dwDestination
= lpmliW
->dwDestination
;
1063 case MIXER_GETLINEINFOF_LINEID
:
1064 mliA
.dwLineID
= lpmliW
->dwLineID
;
1066 case MIXER_GETLINEINFOF_SOURCE
:
1067 mliA
.dwDestination
= lpmliW
->dwDestination
;
1068 mliA
.dwSource
= lpmliW
->dwSource
;
1070 case MIXER_GETLINEINFOF_TARGETTYPE
:
1071 mliA
.Target
.dwType
= lpmliW
->Target
.dwType
;
1072 mliA
.Target
.wMid
= lpmliW
->Target
.wMid
;
1073 mliA
.Target
.wPid
= lpmliW
->Target
.wPid
;
1074 mliA
.Target
.vDriverVersion
= lpmliW
->Target
.vDriverVersion
;
1075 lstrcpyWtoA(mliA
.Target
.szPname
, lpmliW
->Target
.szPname
);
1078 FIXME("Unsupported fdwControls=0x%08lx\n", fdwInfo
);
1081 ret
= mixerGetLineInfoA(hmix
, &mliA
, fdwInfo
);
1083 lpmliW
->dwDestination
= mliA
.dwDestination
;
1084 lpmliW
->dwSource
= mliA
.dwSource
;
1085 lpmliW
->dwLineID
= mliA
.dwLineID
;
1086 lpmliW
->fdwLine
= mliA
.fdwLine
;
1087 lpmliW
->dwUser
= mliA
.dwUser
;
1088 lpmliW
->dwComponentType
= mliA
.dwComponentType
;
1089 lpmliW
->cChannels
= mliA
.cChannels
;
1090 lpmliW
->cConnections
= mliA
.cConnections
;
1091 lpmliW
->cControls
= mliA
.cControls
;
1092 lstrcpyAtoW(lpmliW
->szShortName
, mliA
.szShortName
);
1093 lstrcpyAtoW(lpmliW
->szName
, mliA
.szName
);
1094 lpmliW
->Target
.dwType
= mliA
.Target
.dwType
;
1095 lpmliW
->Target
.dwDeviceID
= mliA
.Target
.dwDeviceID
;
1096 lpmliW
->Target
.wMid
= mliA
.Target
.wMid
;
1097 lpmliW
->Target
.wPid
= mliA
.Target
.wPid
;
1098 lpmliW
->Target
.vDriverVersion
= mliA
.Target
.vDriverVersion
;
1099 lstrcpyAtoW(lpmliW
->Target
.szPname
, mliA
.Target
.szPname
);
1104 /**************************************************************************
1105 * mixerGetLineInfo [MMSYSTEM.805]
1107 UINT16 WINAPI
mixerGetLineInfo16(HMIXEROBJ16 hmix
, LPMIXERLINE16 lpmli16
, DWORD fdwInfo
)
1112 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmli16
, fdwInfo
);
1114 if (lpmli16
== NULL
|| lpmli16
->cbStruct
!= sizeof(*lpmli16
))
1115 return MMSYSERR_INVALPARAM
;
1117 mliA
.cbStruct
= sizeof(mliA
);
1118 switch (fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
) {
1119 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
1120 mliA
.dwComponentType
= lpmli16
->dwComponentType
;
1122 case MIXER_GETLINEINFOF_DESTINATION
:
1123 mliA
.dwDestination
= lpmli16
->dwDestination
;
1125 case MIXER_GETLINEINFOF_LINEID
:
1126 mliA
.dwLineID
= lpmli16
->dwLineID
;
1128 case MIXER_GETLINEINFOF_SOURCE
:
1129 mliA
.dwDestination
= lpmli16
->dwDestination
;
1130 mliA
.dwSource
= lpmli16
->dwSource
;
1132 case MIXER_GETLINEINFOF_TARGETTYPE
:
1133 mliA
.Target
.dwType
= lpmli16
->Target
.dwType
;
1134 mliA
.Target
.wMid
= lpmli16
->Target
.wMid
;
1135 mliA
.Target
.wPid
= lpmli16
->Target
.wPid
;
1136 mliA
.Target
.vDriverVersion
= lpmli16
->Target
.vDriverVersion
;
1137 strcpy(mliA
.Target
.szPname
, lpmli16
->Target
.szPname
);
1140 FIXME("Unsupported fdwControls=0x%08lx\n", fdwInfo
);
1143 ret
= mixerGetLineInfoA(hmix
, &mliA
, fdwInfo
);
1145 lpmli16
->dwDestination
= mliA
.dwDestination
;
1146 lpmli16
->dwSource
= mliA
.dwSource
;
1147 lpmli16
->dwLineID
= mliA
.dwLineID
;
1148 lpmli16
->fdwLine
= mliA
.fdwLine
;
1149 lpmli16
->dwUser
= mliA
.dwUser
;
1150 lpmli16
->dwComponentType
= mliA
.dwComponentType
;
1151 lpmli16
->cChannels
= mliA
.cChannels
;
1152 lpmli16
->cConnections
= mliA
.cConnections
;
1153 lpmli16
->cControls
= mliA
.cControls
;
1154 strcpy(lpmli16
->szShortName
, mliA
.szShortName
);
1155 strcpy(lpmli16
->szName
, mliA
.szName
);
1156 lpmli16
->Target
.dwType
= mliA
.Target
.dwType
;
1157 lpmli16
->Target
.dwDeviceID
= mliA
.Target
.dwDeviceID
;
1158 lpmli16
->Target
.wMid
= mliA
.Target
.wMid
;
1159 lpmli16
->Target
.wPid
= mliA
.Target
.wPid
;
1160 lpmli16
->Target
.vDriverVersion
= mliA
.Target
.vDriverVersion
;
1161 strcpy(lpmli16
->Target
.szPname
, mliA
.Target
.szPname
);
1166 /**************************************************************************
1167 * mixerSetControlDetails [WINMM.111]
1169 UINT WINAPI
mixerSetControlDetails(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdA
, DWORD fdwDetails
)
1173 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmcdA
, fdwDetails
);
1175 uDevID
= MIXER_GetDevID(hmix
, fdwDetails
);
1177 return mixMessage(uDevID
, MXDM_SETCONTROLDETAILS
, 0, (DWORD
)lpmcdA
, fdwDetails
);
1180 /**************************************************************************
1181 * mixerSetControlDetails [MMSYSTEM.809]
1183 UINT16 WINAPI
mixerSetControlDetails16(HMIXEROBJ16 hmix
, LPMIXERCONTROLDETAILS16 lpmcd
, DWORD fdwDetails
)
1185 TRACE("(%04x, %p, %08lx)\n", hmix
, lpmcd
, fdwDetails
);
1186 return MMSYSERR_NOTENABLED
;
1189 /**************************************************************************
1190 * mixerMessage [WINMM.109]
1192 UINT WINAPI
mixerMessage(HMIXER hmix
, UINT uMsg
, DWORD dwParam1
, DWORD dwParam2
)
1194 LPMIXEROPENDESC lpmod
;
1197 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
1199 uDeviceID
= lpmod
->uDeviceID
;
1202 FIXME("(%04lx, %d, %08lx, %08lx): semi-stub?\n",
1203 (DWORD
)hmix
, uMsg
, dwParam1
, dwParam2
);
1204 return mixMessage(uDeviceID
, uMsg
, 0L, dwParam1
, dwParam2
);
1207 /**************************************************************************
1208 * mixerMessage [MMSYSTEM.804]
1210 UINT16 WINAPI
mixerMessage16(HMIXER16 hmix
, UINT16 uMsg
, DWORD dwParam1
, DWORD dwParam2
)
1212 LPMIXEROPENDESC lpmod
;
1215 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
1216 uDeviceID
= (lpmod
) ? lpmod
->uDeviceID
: 0;
1217 FIXME("(%04x, %d, %08lx, %08lx) - semi-stub?\n",
1218 hmix
, uMsg
, dwParam1
, dwParam2
);
1219 return mixMessage(uDeviceID
, uMsg
, 0L, dwParam1
, dwParam2
);
1222 /**************************************************************************
1223 * auxGetNumDevs [WINMM.22]
1225 UINT WINAPI
auxGetNumDevs(void)
1227 return auxGetNumDevs16();
1230 /**************************************************************************
1231 * auxGetNumDevs [MMSYSTEM.350]
1233 UINT16 WINAPI
auxGetNumDevs16(void)
1238 count
= auxMessage(0, AUXDM_GETNUMDEVS
, 0L, 0L, 0L);
1239 TRACE("=> %u\n", count
);
1243 /**************************************************************************
1244 * auxGetDevCaps [WINMM.20]
1246 UINT WINAPI
auxGetDevCapsW(UINT uDeviceID
, LPAUXCAPSW lpCaps
, UINT uSize
)
1249 UINT ret
= auxGetDevCaps16(uDeviceID
, &ac16
, sizeof(ac16
));
1251 lpCaps
->wMid
= ac16
.wMid
;
1252 lpCaps
->wPid
= ac16
.wPid
;
1253 lpCaps
->vDriverVersion
= ac16
.vDriverVersion
;
1254 lstrcpyAtoW(lpCaps
->szPname
, ac16
.szPname
);
1255 lpCaps
->wTechnology
= ac16
.wTechnology
;
1256 lpCaps
->dwSupport
= ac16
.dwSupport
;
1260 /**************************************************************************
1261 * auxGetDevCaps [WINMM.21]
1263 UINT WINAPI
auxGetDevCapsA(UINT uDeviceID
, LPAUXCAPSA lpCaps
, UINT uSize
)
1266 UINT ret
= auxGetDevCaps16(uDeviceID
, &ac16
, sizeof(ac16
));
1268 lpCaps
->wMid
= ac16
.wMid
;
1269 lpCaps
->wPid
= ac16
.wPid
;
1270 lpCaps
->vDriverVersion
= ac16
.vDriverVersion
;
1271 strcpy(lpCaps
->szPname
, ac16
.szPname
);
1272 lpCaps
->wTechnology
= ac16
.wTechnology
;
1273 lpCaps
->dwSupport
= ac16
.dwSupport
;
1277 /**************************************************************************
1278 * auxGetDevCaps [MMSYSTEM.351]
1280 UINT16 WINAPI
auxGetDevCaps16(UINT16 uDeviceID
, LPAUXCAPS16 lpCaps
, UINT16 uSize
)
1282 TRACE("(%04X, %p, %d) !\n", uDeviceID
, lpCaps
, uSize
);
1284 return auxMessage(uDeviceID
, AUXDM_GETDEVCAPS
,
1285 0L, (DWORD
)lpCaps
, (DWORD
)uSize
);
1288 /**************************************************************************
1289 * auxGetVolume [WINM.23]
1291 UINT WINAPI
auxGetVolume(UINT uDeviceID
, DWORD
* lpdwVolume
)
1293 return auxGetVolume16(uDeviceID
, lpdwVolume
);
1296 /**************************************************************************
1297 * auxGetVolume [MMSYSTEM.352]
1299 UINT16 WINAPI
auxGetVolume16(UINT16 uDeviceID
, DWORD
* lpdwVolume
)
1301 TRACE("(%04X, %p) !\n", uDeviceID
, lpdwVolume
);
1303 return auxMessage(uDeviceID
, AUXDM_GETVOLUME
, 0L, (DWORD
)lpdwVolume
, 0L);
1306 /**************************************************************************
1307 * auxSetVolume [WINMM.25]
1309 UINT WINAPI
auxSetVolume(UINT uDeviceID
, DWORD dwVolume
)
1311 return auxSetVolume16(uDeviceID
, dwVolume
);
1314 /**************************************************************************
1315 * auxSetVolume [MMSYSTEM.353]
1317 UINT16 WINAPI
auxSetVolume16(UINT16 uDeviceID
, DWORD dwVolume
)
1319 TRACE("(%04X, %08lX) !\n", uDeviceID
, dwVolume
);
1321 return auxMessage(uDeviceID
, AUXDM_SETVOLUME
, 0L, dwVolume
, 0L);
1324 /**************************************************************************
1325 * auxOutMessage [MMSYSTEM.354]
1327 DWORD WINAPI
auxOutMessage(UINT uDeviceID
, UINT uMessage
, DWORD dw1
, DWORD dw2
)
1330 case AUXDM_GETNUMDEVS
:
1331 case AUXDM_GETVOLUME
:
1332 case AUXDM_SETVOLUME
:
1333 /* no argument conversion needed */
1335 case AUXDM_GETDEVCAPS
:
1336 return auxGetDevCapsA(uDeviceID
, (LPAUXCAPSA
)dw1
, dw2
);
1338 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
1339 uDeviceID
, uMessage
, dw1
, dw2
);
1342 return auxMessage(uDeviceID
, uMessage
, 0L, dw1
, dw2
);
1345 /**************************************************************************
1346 * auxOutMessage [MMSYSTEM.354]
1348 DWORD WINAPI
auxOutMessage16(UINT16 uDeviceID
, UINT16 uMessage
, DWORD dw1
, DWORD dw2
)
1350 TRACE("(%04X, %04X, %08lX, %08lX)\n", uDeviceID
, uMessage
, dw1
, dw2
);
1353 case AUXDM_GETNUMDEVS
:
1354 case AUXDM_SETVOLUME
:
1355 /* no argument conversion needed */
1357 case AUXDM_GETVOLUME
:
1358 return auxGetVolume16(uDeviceID
, (LPDWORD
)PTR_SEG_TO_LIN(dw1
));
1359 case AUXDM_GETDEVCAPS
:
1360 return auxGetDevCaps16(uDeviceID
, (LPAUXCAPS16
)PTR_SEG_TO_LIN(dw1
), dw2
);
1362 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
1363 uDeviceID
, uMessage
, dw1
, dw2
);
1366 return auxMessage(uDeviceID
, uMessage
, 0L, dw1
, dw2
);
1369 /**************************************************************************
1370 * mciGetErrorStringW [WINMM.46]
1372 BOOL WINAPI
mciGetErrorStringW(DWORD wError
, LPWSTR lpstrBuffer
, UINT uLength
)
1374 LPSTR bufstr
= HeapAlloc(GetProcessHeap(), 0, uLength
);
1375 BOOL ret
= mciGetErrorStringA(wError
, bufstr
, uLength
);
1377 lstrcpyAtoW(lpstrBuffer
, bufstr
);
1378 HeapFree(GetProcessHeap(), 0, bufstr
);
1382 /**************************************************************************
1383 * mciGetErrorStringA [WINMM.45]
1385 BOOL WINAPI
mciGetErrorStringA(DWORD wError
, LPSTR lpstrBuffer
, UINT uLength
)
1387 return mciGetErrorString16(wError
, lpstrBuffer
, uLength
);
1390 /**************************************************************************
1391 * mciGetErrorString [MMSYSTEM.706]
1393 BOOL16 WINAPI
mciGetErrorString16(DWORD dwError
, LPSTR lpstrBuffer
, UINT16 uLength
)
1397 if (lpstrBuffer
!= NULL
&& uLength
> 0 &&
1398 dwError
>= MCIERR_BASE
&& dwError
<= MCIERR_CUSTOM_DRIVER_BASE
) {
1399 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
1401 if (iData
&& LoadStringA(iData
->hWinMM32Instance
, dwError
, lpstrBuffer
, uLength
) > 0) {
1408 /**************************************************************************
1409 * mciDriverNotify [MMSYSTEM.711]
1411 BOOL16 WINAPI
mciDriverNotify16(HWND16 hWndCallBack
, UINT16 wDevID
, UINT16 wStatus
)
1413 TRACE("(%04X, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
1415 if (!IsWindow(hWndCallBack
)) {
1416 WARN("bad hWnd for call back (0x%04x)\n", hWndCallBack
);
1419 TRACE("before PostMessage\n");
1420 Callout
.PostMessageA(hWndCallBack
, MM_MCINOTIFY
, wStatus
, wDevID
);
1424 /**************************************************************************
1425 * mciDriverNotify [WINMM.36]
1427 BOOL WINAPI
mciDriverNotify(HWND hWndCallBack
, UINT wDevID
, UINT wStatus
)
1430 TRACE("(%08X, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
1432 if (!IsWindow(hWndCallBack
)) {
1433 WARN("bad hWnd for call back (0x%04x)\n", hWndCallBack
);
1436 TRACE("before PostMessage\n");
1437 Callout
.PostMessageA(hWndCallBack
, MM_MCINOTIFY
, wStatus
, wDevID
);
1441 /**************************************************************************
1442 * mciGetDriverData [MMSYSTEM.708]
1444 DWORD WINAPI
mciGetDriverData16(UINT16 uDeviceID
)
1446 return mciGetDriverData(uDeviceID
);
1449 /**************************************************************************
1450 * mciGetDriverData [WINMM.44]
1452 DWORD WINAPI
mciGetDriverData(UINT uDeviceID
)
1454 LPWINE_MCIDRIVER wmd
;
1456 TRACE("(%04x)\n", uDeviceID
);
1458 wmd
= MCI_GetDriver(uDeviceID
);
1461 WARN("Bad uDeviceID\n");
1465 return wmd
->dwPrivate
;
1468 /**************************************************************************
1469 * mciSetDriverData [MMSYSTEM.707]
1471 BOOL16 WINAPI
mciSetDriverData16(UINT16 uDeviceID
, DWORD data
)
1473 return mciSetDriverData(uDeviceID
, data
);
1476 /**************************************************************************
1477 * mciSetDriverData [WINMM.53]
1479 BOOL WINAPI
mciSetDriverData(UINT uDeviceID
, DWORD data
)
1481 LPWINE_MCIDRIVER wmd
;
1483 TRACE("(%04x, %08lx)\n", uDeviceID
, data
);
1485 wmd
= MCI_GetDriver(uDeviceID
);
1488 WARN("Bad uDeviceID\n");
1492 wmd
->dwPrivate
= data
;
1496 /**************************************************************************
1497 * mciSendCommandA [WINMM.49]
1499 DWORD WINAPI
mciSendCommandA(UINT wDevID
, UINT wMsg
, DWORD dwParam1
, DWORD dwParam2
)
1503 TRACE("(%08x, %s, %08lx, %08lx)\n",
1504 wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
1506 dwRet
= MCI_SendCommand(wDevID
, wMsg
, dwParam1
, dwParam2
, TRUE
);
1507 dwRet
= MCI_CleanUp(dwRet
, wMsg
, dwParam2
, TRUE
);
1508 TRACE("=> %08lx\n", dwRet
);
1512 /**************************************************************************
1513 * mciSendCommandW [WINMM.50]
1515 DWORD WINAPI
mciSendCommandW(UINT wDevID
, UINT wMsg
, DWORD dwParam1
, DWORD dwParam2
)
1517 FIXME("(%08x, %s, %08lx, %08lx): stub\n", wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
1518 return MCIERR_UNSUPPORTED_FUNCTION
;
1521 /**************************************************************************
1522 * mciSendCommand [MMSYSTEM.701]
1524 DWORD WINAPI
mciSendCommand16(UINT16 wDevID
, UINT16 wMsg
, DWORD dwParam1
, DWORD dwParam2
)
1528 TRACE("(%04X, %s, %08lX, %08lX)\n",
1529 wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
1531 dwRet
= MCI_SendCommand(wDevID
, wMsg
, dwParam1
, dwParam2
, FALSE
);
1532 dwRet
= MCI_CleanUp(dwRet
, wMsg
, dwParam2
, FALSE
);
1533 TRACE("=> %ld\n", dwRet
);
1537 /**************************************************************************
1538 * mciGetDeviceID [MMSYSTEM.703]
1540 UINT16 WINAPI
mciGetDeviceID16(LPCSTR lpstrName
)
1542 TRACE("(\"%s\")\n", lpstrName
);
1544 return MCI_GetDriverFromString(lpstrName
);
1547 /**************************************************************************
1548 * mciGetDeviceIDA [WINMM.41]
1550 UINT WINAPI
mciGetDeviceIDA(LPCSTR lpstrName
)
1552 return MCI_GetDriverFromString(lpstrName
);
1555 /**************************************************************************
1556 * mciGetDeviceIDW [WINMM.43]
1558 UINT WINAPI
mciGetDeviceIDW(LPCWSTR lpwstrName
)
1563 lpstrName
= HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName
);
1564 ret
= MCI_GetDriverFromString(lpstrName
);
1565 HeapFree(GetProcessHeap(), 0, lpstrName
);
1569 /**************************************************************************
1570 * MCI_DefYieldProc [internal]
1572 UINT16 WINAPI
MCI_DefYieldProc(UINT16 wDevID
, DWORD data
)
1576 TRACE("(0x%04x, 0x%08lx)\n", wDevID
, data
);
1578 if ((HIWORD(data
) != 0 && GetActiveWindow16() != HIWORD(data
)) ||
1579 (GetAsyncKeyState(LOWORD(data
)) & 1) == 0) {
1585 msg
.hwnd
= HIWORD(data
);
1586 while (!PeekMessageA(&msg
, HIWORD(data
), WM_KEYFIRST
, WM_KEYLAST
, PM_REMOVE
));
1592 /**************************************************************************
1593 * mciSetYieldProc [MMSYSTEM.714]
1595 BOOL16 WINAPI
mciSetYieldProc16(UINT16 uDeviceID
, YIELDPROC fpYieldProc
, DWORD dwYieldData
)
1597 LPWINE_MCIDRIVER wmd
;
1599 TRACE("(%u, %p, %08lx)\n", uDeviceID
, fpYieldProc
, dwYieldData
);
1601 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
1602 WARN("Bad uDeviceID\n");
1606 wmd
->lpfnYieldProc
= fpYieldProc
;
1607 wmd
->dwYieldData
= dwYieldData
;
1613 /**************************************************************************
1614 * mciSetYieldProc [WINMM.54]
1616 BOOL WINAPI
mciSetYieldProc(UINT uDeviceID
, YIELDPROC fpYieldProc
, DWORD dwYieldData
)
1618 LPWINE_MCIDRIVER wmd
;
1620 TRACE("(%u, %p, %08lx)\n", uDeviceID
, fpYieldProc
, dwYieldData
);
1622 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
1623 WARN("Bad uDeviceID\n");
1627 wmd
->lpfnYieldProc
= fpYieldProc
;
1628 wmd
->dwYieldData
= dwYieldData
;
1634 /**************************************************************************
1635 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
1637 UINT16 WINAPI
mciGetDeviceIDFromElementID16(DWORD dwElementID
, LPCSTR lpstrType
)
1639 FIXME("(%lu, %s) stub\n", dwElementID
, lpstrType
);
1643 /**************************************************************************
1644 * mciGetDeviceIDFromElementIDW [WINMM.42]
1646 UINT WINAPI
mciGetDeviceIDFromElementIDW(DWORD dwElementID
, LPCWSTR lpstrType
)
1648 /* FIXME: that's rather strange, there is no
1649 * mciGetDeviceIDFromElementID32A in winmm.spec
1651 FIXME("(%lu, %p) stub\n", dwElementID
, lpstrType
);
1655 /**************************************************************************
1656 * mciGetYieldProc [MMSYSTEM.716]
1658 YIELDPROC WINAPI
mciGetYieldProc16(UINT16 uDeviceID
, DWORD
* lpdwYieldData
)
1660 LPWINE_MCIDRIVER wmd
;
1662 TRACE("(%u, %p)\n", uDeviceID
, lpdwYieldData
);
1664 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
1665 WARN("Bad uDeviceID\n");
1668 if (!wmd
->lpfnYieldProc
) {
1669 WARN("No proc set\n");
1673 WARN("Proc is 32 bit\n");
1676 return wmd
->lpfnYieldProc
;
1679 /**************************************************************************
1680 * mciGetYieldProc [WINMM.47]
1682 YIELDPROC WINAPI
mciGetYieldProc(UINT uDeviceID
, DWORD
* lpdwYieldData
)
1684 LPWINE_MCIDRIVER wmd
;
1686 TRACE("(%u, %p)\n", uDeviceID
, lpdwYieldData
);
1688 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
1689 WARN("Bad uDeviceID\n");
1692 if (!wmd
->lpfnYieldProc
) {
1693 WARN("No proc set\n");
1697 WARN("Proc is 32 bit\n");
1700 return wmd
->lpfnYieldProc
;
1703 /**************************************************************************
1704 * mciGetCreatorTask [MMSYSTEM.717]
1706 HTASK16 WINAPI
mciGetCreatorTask16(UINT16 uDeviceID
)
1708 return mciGetCreatorTask(uDeviceID
);
1711 /**************************************************************************
1712 * mciGetCreatorTask [WINMM.40]
1714 HTASK WINAPI
mciGetCreatorTask(UINT uDeviceID
)
1716 LPWINE_MCIDRIVER wmd
;
1719 TRACE("(%u)\n", uDeviceID
);
1721 ret
= (!(wmd
= MCI_GetDriver(uDeviceID
))) ? 0 : wmd
->hCreatorTask
;
1723 TRACE("=> %04x\n", ret
);
1727 /**************************************************************************
1728 * mciDriverYield [MMSYSTEM.710]
1730 UINT16 WINAPI
mciDriverYield16(UINT16 uDeviceID
)
1732 LPWINE_MCIDRIVER wmd
;
1735 /* TRACE("(%04x)\n", uDeviceID); */
1737 if (!(wmd
= MCI_GetDriver(uDeviceID
)) || !wmd
->lpfnYieldProc
|| wmd
->bIs32
) {
1740 ret
= wmd
->lpfnYieldProc(uDeviceID
, wmd
->dwYieldData
);
1746 /**************************************************************************
1747 * mciDriverYield [WINMM.37]
1749 UINT WINAPI
mciDriverYield(UINT uDeviceID
)
1751 LPWINE_MCIDRIVER wmd
;
1754 TRACE("(%04x)\n", uDeviceID
);
1756 if (!(wmd
= MCI_GetDriver(uDeviceID
)) || !wmd
->lpfnYieldProc
|| !wmd
->bIs32
) {
1759 ret
= wmd
->lpfnYieldProc(uDeviceID
, wmd
->dwYieldData
);
1765 /**************************************************************************
1766 * midiOutGetNumDevs [WINMM.80]
1768 UINT WINAPI
midiOutGetNumDevs(void)
1770 return midiOutGetNumDevs16();
1773 /**************************************************************************
1774 * midiOutGetNumDevs [MMSYSTEM.201]
1776 UINT16 WINAPI
midiOutGetNumDevs16(void)
1778 UINT16 count
= modMessage(0, MODM_GETNUMDEVS
, 0L, 0L, 0L);
1780 TRACE("returns %u\n", count
);
1784 /**************************************************************************
1785 * midiOutGetDevCapsW [WINMM.76]
1787 UINT WINAPI
midiOutGetDevCapsW(UINT uDeviceID
, LPMIDIOUTCAPSW lpCaps
, UINT uSize
)
1789 MIDIOUTCAPS16 moc16
;
1792 ret
= midiOutGetDevCaps16(uDeviceID
, &moc16
, sizeof(moc16
));
1793 lpCaps
->wMid
= moc16
.wMid
;
1794 lpCaps
->wPid
= moc16
.wPid
;
1795 lpCaps
->vDriverVersion
= moc16
.vDriverVersion
;
1796 lstrcpyAtoW(lpCaps
->szPname
, moc16
.szPname
);
1797 lpCaps
->wTechnology
= moc16
.wTechnology
;
1798 lpCaps
->wVoices
= moc16
.wVoices
;
1799 lpCaps
->wNotes
= moc16
.wNotes
;
1800 lpCaps
->wChannelMask
= moc16
.wChannelMask
;
1801 lpCaps
->dwSupport
= moc16
.dwSupport
;
1805 /**************************************************************************
1806 * midiOutGetDevCapsA [WINMM.75]
1808 UINT WINAPI
midiOutGetDevCapsA(UINT uDeviceID
, LPMIDIOUTCAPSA lpCaps
, UINT uSize
)
1810 MIDIOUTCAPS16 moc16
;
1813 ret
= midiOutGetDevCaps16(uDeviceID
, &moc16
, sizeof(moc16
));
1814 lpCaps
->wMid
= moc16
.wMid
;
1815 lpCaps
->wPid
= moc16
.wPid
;
1816 lpCaps
->vDriverVersion
= moc16
.vDriverVersion
;
1817 strcpy(lpCaps
->szPname
, moc16
.szPname
);
1818 lpCaps
->wTechnology
= moc16
.wTechnology
;
1819 lpCaps
->wVoices
= moc16
.wVoices
;
1820 lpCaps
->wNotes
= moc16
.wNotes
;
1821 lpCaps
->wChannelMask
= moc16
.wChannelMask
;
1822 lpCaps
->dwSupport
= moc16
.dwSupport
;
1826 /**************************************************************************
1827 * midiOutGetDevCaps [MMSYSTEM.202]
1829 UINT16 WINAPI
midiOutGetDevCaps16(UINT16 uDeviceID
, LPMIDIOUTCAPS16 lpCaps
, UINT16 uSize
)
1831 TRACE("(%u, %p, %u);\n", uDeviceID
, lpCaps
, uSize
);
1832 return modMessage(uDeviceID
, MODM_GETDEVCAPS
, 0, (DWORD
)lpCaps
, uSize
);
1835 /**************************************************************************
1836 * MIDI_GetErrorText [internal]
1838 static UINT16
MIDI_GetErrorText(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
1840 UINT16 ret
= MMSYSERR_BADERRNUM
;
1842 if (lpText
== NULL
) {
1843 ret
= MMSYSERR_INVALPARAM
;
1844 } else if (uSize
== 0) {
1845 ret
= MMSYSERR_NOERROR
;
1847 /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
1848 * a warning for the test was always true */
1849 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
1850 (uError
>= MIDIERR_BASE
&& uError
<= MIDIERR_LASTERROR
)) {
1852 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
1855 ret
= MMSYSERR_ERROR
;
1856 } else if (LoadStringA(iData
->hWinMM32Instance
, uError
, lpText
, uSize
) > 0) {
1857 ret
= MMSYSERR_NOERROR
;
1863 /**************************************************************************
1864 * midiOutGetErrorTextA [WINMM.77]
1866 UINT WINAPI
midiOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
1868 return MIDI_GetErrorText(uError
, lpText
, uSize
);
1871 /**************************************************************************
1872 * midiOutGetErrorTextW [WINMM.78]
1874 UINT WINAPI
midiOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
1876 LPSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
);
1879 ret
= MIDI_GetErrorText(uError
, xstr
, uSize
);
1880 lstrcpyAtoW(lpText
, xstr
);
1881 HeapFree(GetProcessHeap(), 0, xstr
);
1885 /**************************************************************************
1886 * midiOutGetErrorText [MMSYSTEM.203]
1888 UINT16 WINAPI
midiOutGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
1890 return MIDI_GetErrorText(uError
, lpText
, uSize
);
1893 /**************************************************************************
1894 * MIDI_OutAlloc [internal]
1896 static LPMIDIOPENDESC
MIDI_OutAlloc(HMIDIOUT16
* lphMidiOut
, DWORD dwCallback
,
1897 DWORD dwInstance
, DWORD cIDs
, MIDIOPENSTRMID
* lpIDs
)
1900 LPMIDIOPENDESC lpDesc
;
1902 hMidiOut
= USER_HEAP_ALLOC(sizeof(MIDIOPENDESC
) + (cIDs
? (cIDs
- 1) : 0) * sizeof(MIDIOPENSTRMID
));
1904 if (lphMidiOut
!= NULL
)
1905 *lphMidiOut
= hMidiOut
;
1906 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
1909 lpDesc
->hMidi
= hMidiOut
;
1910 lpDesc
->dwCallback
= dwCallback
;
1911 lpDesc
->dwInstance
= dwInstance
;
1912 lpDesc
->dnDevNode
= 0;
1913 lpDesc
->cIds
= cIDs
;
1915 memcpy(&(lpDesc
->rgIds
), lpIDs
, cIDs
* sizeof(MIDIOPENSTRMID
));
1920 /**************************************************************************
1921 * midiOutOpen [WINM.84]
1923 UINT WINAPI
midiOutOpen(HMIDIOUT
* lphMidiOut
, UINT uDeviceID
,
1924 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
1929 ret
= midiOutOpen16(&hmo16
, uDeviceID
, dwCallback
, dwInstance
,
1930 CALLBACK32CONV(dwFlags
));
1931 if (lphMidiOut
) *lphMidiOut
= hmo16
;
1935 /**************************************************************************
1936 * midiOutOpen [MMSYSTEM.204]
1938 UINT16 WINAPI
midiOutOpen16(HMIDIOUT16
* lphMidiOut
, UINT16 uDeviceID
,
1939 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
1941 HMIDIOUT16 hMidiOut
;
1942 LPMIDIOPENDESC lpDesc
;
1944 BOOL bMapperFlg
= FALSE
;
1946 TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
1947 lphMidiOut
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
1949 if (lphMidiOut
!= NULL
) *lphMidiOut
= 0;
1951 if (uDeviceID
== (UINT16
)MIDI_MAPPER
) {
1952 TRACE("MIDI_MAPPER mode requested !\n");
1957 lpDesc
= MIDI_OutAlloc(&hMidiOut
, dwCallback
, dwInstance
, 0, NULL
);
1960 return MMSYSERR_NOMEM
;
1962 while (uDeviceID
< MAXMIDIDRIVERS
) {
1963 ret
= modMessage(uDeviceID
, MODM_OPEN
,
1964 lpDesc
->dwInstance
, (DWORD
)lpDesc
, dwFlags
);
1965 if (ret
== MMSYSERR_NOERROR
) break;
1966 if (!bMapperFlg
) break;
1968 TRACE("MIDI_MAPPER mode ! try next driver...\n");
1970 TRACE("=> wDevID=%u (%d)\n", uDeviceID
, ret
);
1971 if (ret
!= MMSYSERR_NOERROR
) {
1972 USER_HEAP_FREE(hMidiOut
);
1973 if (lphMidiOut
) *lphMidiOut
= 0;
1975 lpDesc
->wDevID
= uDeviceID
;
1976 if (lphMidiOut
) *lphMidiOut
= hMidiOut
;
1982 /**************************************************************************
1983 * midiOutClose [WINMM.74]
1985 UINT WINAPI
midiOutClose(HMIDIOUT hMidiOut
)
1987 return midiOutClose16(hMidiOut
);
1990 /**************************************************************************
1991 * midiOutClose [MMSYSTEM.205]
1993 UINT16 WINAPI
midiOutClose16(HMIDIOUT16 hMidiOut
)
1995 LPMIDIOPENDESC lpDesc
;
1998 TRACE("(%04X)\n", hMidiOut
);
2000 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2002 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2003 dwRet
= modMessage(lpDesc
->wDevID
, MODM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
2004 USER_HEAP_FREE(hMidiOut
);
2008 /**************************************************************************
2009 * midiOutPrepareHeader [WINMM.85]
2011 UINT WINAPI
midiOutPrepareHeader(HMIDIOUT hMidiOut
,
2012 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
2014 LPMIDIOPENDESC lpDesc
;
2016 TRACE("(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2018 lpDesc
= (LPMIDIOPENDESC
)USER_HEAP_LIN_ADDR(hMidiOut
);
2020 return MMSYSERR_INVALHANDLE
;
2021 lpMidiOutHdr
->reserved
= (DWORD
)lpMidiOutHdr
;
2022 return modMessage(lpDesc
->wDevID
, MODM_PREPARE
, lpDesc
->dwInstance
,
2023 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2026 /**************************************************************************
2027 * midiOutPrepareHeader [MMSYSTEM.206]
2029 UINT16 WINAPI
midiOutPrepareHeader16(HMIDIOUT16 hMidiOut
,
2030 LPMIDIHDR16
/*SEGPTR*/ _lpMidiOutHdr
, UINT16 uSize
)
2032 LPMIDIOPENDESC lpDesc
;
2033 LPMIDIHDR16 lpMidiOutHdr
= (LPMIDIHDR16
)PTR_SEG_TO_LIN(_lpMidiOutHdr
);
2035 TRACE("(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2037 lpDesc
= (LPMIDIOPENDESC
)USER_HEAP_LIN_ADDR(hMidiOut
);
2039 return MMSYSERR_INVALHANDLE
;
2040 lpMidiOutHdr
->reserved
= (DWORD
)_lpMidiOutHdr
;
2041 return modMessage(lpDesc
->wDevID
, MODM_PREPARE
, lpDesc
->dwInstance
,
2042 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2045 /**************************************************************************
2046 * midiOutUnprepareHeader [WINMM.89]
2048 UINT WINAPI
midiOutUnprepareHeader(HMIDIOUT hMidiOut
,
2049 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
2051 return midiOutUnprepareHeader16(hMidiOut
, (MIDIHDR16
*)lpMidiOutHdr
, uSize
);
2054 /**************************************************************************
2055 * midiOutUnprepareHeader [MMSYSTEM.207]
2057 UINT16 WINAPI
midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut
,
2058 MIDIHDR16
* lpMidiOutHdr
, UINT16 uSize
)
2060 LPMIDIOPENDESC lpDesc
;
2062 TRACE("(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2064 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2065 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2066 return modMessage(lpDesc
->wDevID
, MODM_UNPREPARE
, lpDesc
->dwInstance
,
2067 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2070 /**************************************************************************
2071 * midiOutShortMsg [WINMM.88]
2073 UINT WINAPI
midiOutShortMsg(HMIDIOUT hMidiOut
, DWORD dwMsg
)
2075 return midiOutShortMsg16(hMidiOut
, dwMsg
);
2078 /**************************************************************************
2079 * midiOutShortMsg [MMSYSTEM.208]
2081 UINT16 WINAPI
midiOutShortMsg16(HMIDIOUT16 hMidiOut
, DWORD dwMsg
)
2083 LPMIDIOPENDESC lpDesc
;
2085 TRACE("(%04X, %08lX)\n", hMidiOut
, dwMsg
);
2087 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2088 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2089 return modMessage(lpDesc
->wDevID
, MODM_DATA
, lpDesc
->dwInstance
, dwMsg
, 0L);
2092 /**************************************************************************
2093 * midiOutLongMsg [WINMM.82]
2095 UINT WINAPI
midiOutLongMsg(HMIDIOUT hMidiOut
,
2096 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
2098 return midiOutLongMsg16(hMidiOut
, (MIDIHDR16
*)lpMidiOutHdr
, uSize
);
2101 /**************************************************************************
2102 * midiOutLongMsg [MMSYSTEM.209]
2104 UINT16 WINAPI
midiOutLongMsg16(HMIDIOUT16 hMidiOut
,
2105 MIDIHDR16
* lpMidiOutHdr
, UINT16 uSize
)
2107 LPMIDIOPENDESC lpDesc
;
2109 TRACE("(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2111 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2112 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2113 return modMessage(lpDesc
->wDevID
, MODM_LONGDATA
, lpDesc
->dwInstance
,
2114 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2117 /**************************************************************************
2118 * midiOutReset [WINMM.86]
2120 UINT WINAPI
midiOutReset(HMIDIOUT hMidiOut
)
2122 return midiOutReset16(hMidiOut
);
2125 /**************************************************************************
2126 * midiOutReset [MMSYSTEM.210]
2128 UINT16 WINAPI
midiOutReset16(HMIDIOUT16 hMidiOut
)
2130 LPMIDIOPENDESC lpDesc
;
2132 TRACE("(%04X)\n", hMidiOut
);
2134 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2135 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2136 return modMessage(lpDesc
->wDevID
, MODM_RESET
, lpDesc
->dwInstance
, 0L, 0L);
2139 /**************************************************************************
2140 * midiOutGetVolume [WINM.81]
2142 UINT WINAPI
midiOutGetVolume(UINT uDeviceID
, DWORD
* lpdwVolume
)
2144 return midiOutGetVolume16(uDeviceID
, lpdwVolume
);
2147 /**************************************************************************
2148 * midiOutGetVolume [MMSYSTEM.211]
2150 UINT16 WINAPI
midiOutGetVolume16(UINT16 uDeviceID
, DWORD
* lpdwVolume
)
2152 TRACE("(%04X, %p);\n", uDeviceID
, lpdwVolume
);
2153 return modMessage(uDeviceID
, MODM_GETVOLUME
, 0L, (DWORD
)lpdwVolume
, 0L);
2156 /**************************************************************************
2157 * midiOutSetVolume [WINMM.87]
2159 UINT WINAPI
midiOutSetVolume(UINT uDeviceID
, DWORD dwVolume
)
2161 return midiOutSetVolume16(uDeviceID
, dwVolume
);
2164 /**************************************************************************
2165 * midiOutSetVolume [MMSYSTEM.212]
2167 UINT16 WINAPI
midiOutSetVolume16(UINT16 uDeviceID
, DWORD dwVolume
)
2169 TRACE("(%04X, %08lX);\n", uDeviceID
, dwVolume
);
2170 return modMessage(uDeviceID
, MODM_SETVOLUME
, 0L, dwVolume
, 0L);
2173 /**************************************************************************
2174 * midiOutCachePatches [WINMM.73]
2176 UINT WINAPI
midiOutCachePatches(HMIDIOUT hMidiOut
, UINT uBank
,
2177 WORD
* lpwPatchArray
, UINT uFlags
)
2179 return midiOutCachePatches16(hMidiOut
, uBank
, lpwPatchArray
, uFlags
);
2182 /**************************************************************************
2183 * midiOutCachePatches [MMSYSTEM.213]
2185 UINT16 WINAPI
midiOutCachePatches16(HMIDIOUT16 hMidiOut
, UINT16 uBank
,
2186 WORD
* lpwPatchArray
, UINT16 uFlags
)
2188 /* not really necessary to support this */
2189 FIXME("not supported yet\n");
2190 return MMSYSERR_NOTSUPPORTED
;
2193 /**************************************************************************
2194 * midiOutCacheDrumPatches [WINMM.72]
2196 UINT WINAPI
midiOutCacheDrumPatches(HMIDIOUT hMidiOut
, UINT uPatch
,
2197 WORD
* lpwKeyArray
, UINT uFlags
)
2199 return midiOutCacheDrumPatches16(hMidiOut
, uPatch
, lpwKeyArray
, uFlags
);
2202 /**************************************************************************
2203 * midiOutCacheDrumPatches [MMSYSTEM.214]
2205 UINT16 WINAPI
midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut
, UINT16 uPatch
,
2206 WORD
* lpwKeyArray
, UINT16 uFlags
)
2208 FIXME("not supported yet\n");
2209 return MMSYSERR_NOTSUPPORTED
;
2212 /**************************************************************************
2213 * midiOutGetID [WINMM.79]
2215 UINT WINAPI
midiOutGetID(HMIDIOUT hMidiOut
, UINT
* lpuDeviceID
)
2220 ret
= midiOutGetID16(hMidiOut
, &xid
);
2225 /**************************************************************************
2226 * midiOutGetID [MMSYSTEM.215]
2228 UINT16 WINAPI
midiOutGetID16(HMIDIOUT16 hMidiOut
, UINT16
* lpuDeviceID
)
2230 TRACE("midiOutGetID\n");
2234 /**************************************************************************
2235 * midiOutMessage [WINMM.83]
2237 DWORD WINAPI
midiOutMessage(HMIDIOUT hMidiOut
, UINT uMessage
,
2238 DWORD dwParam1
, DWORD dwParam2
)
2240 LPMIDIOPENDESC lpDesc
;
2242 /* Shouldn't we anyway use the functions midiOutXXX ?
2243 * M$ doc says: This function is used only for driver-specific
2244 * messages that are not supported by the MIDI API.
2245 * Clearly not what we are currently doing
2248 TRACE("(%04X, %04X, %08lX, %08lX)\n",
2249 hMidiOut
, uMessage
, dwParam1
, dwParam2
);
2251 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2252 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2255 FIXME("can't handle MODM_OPEN!\n");
2257 case MODM_GETDEVCAPS
:
2258 return midiOutGetDevCapsA(hMidiOut
, (LPMIDIOUTCAPSA
)dwParam1
, dwParam2
);
2259 case MODM_GETNUMDEVS
:
2262 case MODM_GETVOLUME
:
2263 case MODM_SETVOLUME
:
2266 case MODM_UNPREPARE
:
2267 /* no argument conversion needed */
2270 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
2271 hMidiOut
, uMessage
, dwParam1
, dwParam2
);
2274 return modMessage(lpDesc
->wDevID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
2277 /**************************************************************************
2278 * midiOutMessage [MMSYSTEM.216]
2280 DWORD WINAPI
midiOutMessage16(HMIDIOUT16 hMidiOut
, UINT16 uMessage
,
2281 DWORD dwParam1
, DWORD dwParam2
)
2283 LPMIDIOPENDESC lpDesc
;
2285 TRACE("(%04X, %04X, %08lX, %08lX)\n",
2286 hMidiOut
, uMessage
, dwParam1
, dwParam2
);
2287 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2288 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2291 FIXME("can't handle MODM_OPEN!\n");
2293 case MODM_GETNUMDEVS
:
2296 case MODM_SETVOLUME
:
2297 /* no argument conversion needed */
2299 case MODM_GETVOLUME
:
2300 return midiOutGetVolume16(hMidiOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
2302 return midiOutLongMsg16(hMidiOut
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2304 /* lpMidiOutHdr is still a segmented pointer for this function */
2305 return midiOutPrepareHeader16(hMidiOut
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
2306 case MODM_UNPREPARE
:
2307 return midiOutUnprepareHeader16(hMidiOut
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2309 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
2310 hMidiOut
, uMessage
, dwParam1
, dwParam2
);
2313 return modMessage(lpDesc
->wDevID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
2316 /**************************************************************************
2317 * midiInGetNumDevs [WINMM.64]
2319 UINT WINAPI
midiInGetNumDevs(void)
2321 return midiInGetNumDevs16();
2324 /**************************************************************************
2325 * midiInGetNumDevs [MMSYSTEM.301]
2327 UINT16 WINAPI
midiInGetNumDevs16(void)
2330 TRACE("midiInGetNumDevs\n");
2331 count
+= midMessage(0, MIDM_GETNUMDEVS
, 0L, 0L, 0L);
2332 TRACE("midiInGetNumDevs return %u \n", count
);
2336 /**************************************************************************
2337 * midiInGetDevCaps [WINMM.60]
2339 UINT WINAPI
midiInGetDevCapsW(UINT uDeviceID
, LPMIDIINCAPSW lpCaps
, UINT uSize
)
2342 UINT ret
= midiInGetDevCaps16(uDeviceID
, &mic16
, uSize
);
2344 lpCaps
->wMid
= mic16
.wMid
;
2345 lpCaps
->wPid
= mic16
.wPid
;
2346 lpCaps
->vDriverVersion
= mic16
.vDriverVersion
;
2347 lstrcpyAtoW(lpCaps
->szPname
, mic16
.szPname
);
2348 lpCaps
->dwSupport
= mic16
.dwSupport
;
2352 /**************************************************************************
2353 * midiInGetDevCaps [WINMM.59]
2355 UINT WINAPI
midiInGetDevCapsA(UINT uDeviceID
, LPMIDIINCAPSA lpCaps
, UINT uSize
)
2358 UINT ret
= midiInGetDevCaps16(uDeviceID
, &mic16
, uSize
);
2360 lpCaps
->wMid
= mic16
.wMid
;
2361 lpCaps
->wPid
= mic16
.wPid
;
2362 lpCaps
->vDriverVersion
= mic16
.vDriverVersion
;
2363 strcpy(lpCaps
->szPname
, mic16
.szPname
);
2364 lpCaps
->dwSupport
= mic16
.dwSupport
;
2368 /**************************************************************************
2369 * midiInGetDevCaps [MMSYSTEM.302]
2371 UINT16 WINAPI
midiInGetDevCaps16(UINT16 uDeviceID
,
2372 LPMIDIINCAPS16 lpCaps
, UINT16 uSize
)
2374 TRACE("(%d, %p, %d);\n",uDeviceID
, lpCaps
, uSize
);
2376 return midMessage(uDeviceID
, MIDM_GETDEVCAPS
, 0, (DWORD
)lpCaps
, uSize
);
2379 /**************************************************************************
2380 * midiInGetErrorText [WINMM.62]
2382 UINT WINAPI
midiInGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
2384 LPSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
);
2385 UINT ret
= MIDI_GetErrorText(uError
, xstr
, uSize
);
2387 lstrcpyAtoW(lpText
, xstr
);
2388 HeapFree(GetProcessHeap(), 0, xstr
);
2392 /**************************************************************************
2393 * midiInGetErrorText [WINMM.61]
2395 UINT WINAPI
midiInGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
2397 return MIDI_GetErrorText(uError
, lpText
, uSize
);
2400 /**************************************************************************
2401 * midiInGetErrorText [MMSYSTEM.303]
2403 UINT16 WINAPI
midiInGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
2405 return MIDI_GetErrorText(uError
, lpText
, uSize
);
2408 /**************************************************************************
2409 * midiInOpen [WINMM.66]
2411 UINT WINAPI
midiInOpen(HMIDIIN
* lphMidiIn
, UINT uDeviceID
,
2412 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
2415 UINT ret
= midiInOpen16(&xhmid16
, uDeviceID
, dwCallback
, dwInstance
,
2416 CALLBACK32CONV(dwFlags
));
2418 *lphMidiIn
= xhmid16
;
2422 /**************************************************************************
2423 * midiInOpen [MMSYSTEM.304]
2425 UINT16 WINAPI
midiInOpen16(HMIDIIN16
* lphMidiIn
, UINT16 uDeviceID
,
2426 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
2429 LPMIDIOPENDESC lpDesc
;
2431 BOOL bMapperFlg
= FALSE
;
2433 if (lphMidiIn
!= NULL
)
2435 TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
2436 lphMidiIn
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
2437 if (uDeviceID
== (UINT16
)MIDI_MAPPER
) {
2438 TRACE("MIDI_MAPPER mode requested !\n");
2442 hMidiIn
= USER_HEAP_ALLOC(sizeof(MIDIOPENDESC
));
2443 if (lphMidiIn
!= NULL
)
2444 *lphMidiIn
= hMidiIn
;
2445 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2447 return MMSYSERR_NOMEM
;
2448 lpDesc
->hMidi
= hMidiIn
;
2449 lpDesc
->dwCallback
= dwCallback
;
2450 lpDesc
->dwInstance
= dwInstance
;
2452 while (uDeviceID
< MAXMIDIDRIVERS
) {
2453 dwRet
= midMessage(uDeviceID
, MIDM_OPEN
,
2454 lpDesc
->dwInstance
, (DWORD
)lpDesc
, dwFlags
);
2455 if (dwRet
== MMSYSERR_NOERROR
)
2460 TRACE("MIDI_MAPPER mode ! try next driver...\n");
2462 lpDesc
->wDevID
= uDeviceID
;
2464 if (dwRet
!= MMSYSERR_NOERROR
) {
2465 USER_HEAP_FREE(hMidiIn
);
2466 if (lphMidiIn
) *lphMidiIn
= 0;
2472 /**************************************************************************
2473 * midiInClose [WINMM.58]
2475 UINT WINAPI
midiInClose(HMIDIIN hMidiIn
)
2477 return midiInClose16(hMidiIn
);
2480 /**************************************************************************
2481 * midiInClose [MMSYSTEM.305]
2483 UINT16 WINAPI
midiInClose16(HMIDIIN16 hMidiIn
)
2485 LPMIDIOPENDESC lpDesc
;
2488 TRACE("(%04X)\n", hMidiIn
);
2489 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2491 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2492 dwRet
= midMessage(lpDesc
->wDevID
, MIDM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
2493 USER_HEAP_FREE(hMidiIn
);
2497 /**************************************************************************
2498 * midiInPrepareHeader [WINMM.67]
2500 UINT WINAPI
midiInPrepareHeader(HMIDIIN hMidiIn
,
2501 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
2503 LPMIDIOPENDESC lpDesc
;
2505 TRACE("(%04X, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
2507 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2509 return MMSYSERR_INVALHANDLE
;
2510 lpMidiInHdr
->reserved
= (DWORD
)lpMidiInHdr
;
2511 return midMessage(lpDesc
->wDevID
, MIDM_PREPARE
, lpDesc
->dwInstance
,
2512 (DWORD
)lpMidiInHdr
, (DWORD
)uSize
);
2515 /**************************************************************************
2516 * midiInPrepareHeader [MMSYSTEM.306]
2518 UINT16 WINAPI
midiInPrepareHeader16(HMIDIIN16 hMidiIn
,
2519 MIDIHDR16
* /*SEGPTR*/ _lpMidiInHdr
, UINT16 uSize
)
2521 LPMIDIOPENDESC lpDesc
;
2522 LPMIDIHDR16 lpMidiInHdr
= (LPMIDIHDR16
)PTR_SEG_TO_LIN(_lpMidiInHdr
);
2524 TRACE("(%04X, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
2526 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2528 return MMSYSERR_INVALHANDLE
;
2529 lpMidiInHdr
->reserved
= (DWORD
)_lpMidiInHdr
;
2530 return midMessage(lpDesc
->wDevID
, MIDM_PREPARE
, lpDesc
->dwInstance
,
2531 (DWORD
)lpMidiInHdr
, (DWORD
)uSize
);
2534 /**************************************************************************
2535 * midiInUnprepareHeader [WINMM.71]
2537 UINT WINAPI
midiInUnprepareHeader(HMIDIIN hMidiIn
,
2538 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
2540 return midiInUnprepareHeader16(hMidiIn
, (MIDIHDR16
*)lpMidiInHdr
, uSize
);
2543 /**************************************************************************
2544 * midiInUnprepareHeader [MMSYSTEM.307]
2546 UINT16 WINAPI
midiInUnprepareHeader16(HMIDIIN16 hMidiIn
,
2547 MIDIHDR16
* lpMidiInHdr
, UINT16 uSize
)
2549 LPMIDIOPENDESC lpDesc
;
2551 TRACE("(%04X, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
2553 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2555 return MMSYSERR_INVALHANDLE
;
2556 return midMessage(lpDesc
->wDevID
, MIDM_UNPREPARE
, lpDesc
->dwInstance
,
2557 (DWORD
)lpMidiInHdr
, (DWORD
)uSize
);
2560 /**************************************************************************
2561 * midiInAddBuffer [WINMM.57]
2563 UINT WINAPI
midiInAddBuffer(HMIDIIN hMidiIn
,
2564 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
2566 return midiInAddBuffer16(hMidiIn
, (MIDIHDR16
*)lpMidiInHdr
, uSize
);
2569 /**************************************************************************
2570 * midiInAddBuffer [MMSYSTEM.308]
2572 UINT16 WINAPI
midiInAddBuffer16(HMIDIIN16 hMidiIn
,
2573 MIDIHDR16
* lpMidiInHdr
, UINT16 uSize
)
2575 TRACE("midiInAddBuffer\n");
2579 /**************************************************************************
2580 * midiInStart [WINMM.69]
2582 UINT WINAPI
midiInStart(HMIDIIN hMidiIn
)
2584 return midiInStart16(hMidiIn
);
2587 /**************************************************************************
2588 * midiInStart [MMSYSTEM.309]
2590 UINT16 WINAPI
midiInStart16(HMIDIIN16 hMidiIn
)
2592 LPMIDIOPENDESC lpDesc
;
2594 TRACE("(%04X)\n", hMidiIn
);
2595 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2597 return MMSYSERR_INVALHANDLE
;
2598 return midMessage(lpDesc
->wDevID
, MIDM_START
, lpDesc
->dwInstance
, 0L, 0L);
2601 /**************************************************************************
2602 * midiInStop [WINMM.70]
2604 UINT WINAPI
midiInStop(HMIDIIN hMidiIn
)
2606 return midiInStop16(hMidiIn
);
2609 /**************************************************************************
2610 * midiInStop [MMSYSTEM.310]
2612 UINT16 WINAPI
midiInStop16(HMIDIIN16 hMidiIn
)
2614 LPMIDIOPENDESC lpDesc
;
2616 TRACE("(%04X)\n", hMidiIn
);
2617 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2619 return MMSYSERR_INVALHANDLE
;
2620 return midMessage(lpDesc
->wDevID
, MIDM_STOP
, lpDesc
->dwInstance
, 0L, 0L);
2623 /**************************************************************************
2624 * midiInReset [WINMM.68]
2626 UINT WINAPI
midiInReset(HMIDIIN hMidiIn
)
2628 return midiInReset16(hMidiIn
);
2631 /**************************************************************************
2632 * midiInReset [MMSYSTEM.311]
2634 UINT16 WINAPI
midiInReset16(HMIDIIN16 hMidiIn
)
2636 LPMIDIOPENDESC lpDesc
;
2638 TRACE("(%04X)\n", hMidiIn
);
2639 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2641 return MMSYSERR_INVALHANDLE
;
2642 return midMessage(lpDesc
->wDevID
, MIDM_RESET
, lpDesc
->dwInstance
, 0L, 0L);
2645 /**************************************************************************
2646 * midiInGetID [WINMM.63]
2648 UINT WINAPI
midiInGetID(HMIDIIN hMidiIn
, UINT
* lpuDeviceID
)
2650 LPMIDIOPENDESC lpDesc
;
2652 TRACE("(%04X, %p)\n", hMidiIn
, lpuDeviceID
);
2653 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2655 return MMSYSERR_INVALHANDLE
;
2656 if (lpuDeviceID
== NULL
)
2657 return MMSYSERR_INVALPARAM
;
2658 *lpuDeviceID
= lpDesc
->wDevID
;
2660 return MMSYSERR_NOERROR
;
2663 /**************************************************************************
2664 * midiInGetID [MMSYSTEM.312]
2666 UINT16 WINAPI
midiInGetID16(HMIDIIN16 hMidiIn
, UINT16
* lpuDeviceID
)
2668 LPMIDIOPENDESC lpDesc
;
2670 TRACE("(%04X, %p)\n", hMidiIn
, lpuDeviceID
);
2671 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2673 return MMSYSERR_INVALHANDLE
;
2674 if (lpuDeviceID
== NULL
)
2675 return MMSYSERR_INVALPARAM
;
2676 *lpuDeviceID
= lpDesc
->wDevID
;
2678 return MMSYSERR_NOERROR
;
2681 /**************************************************************************
2682 * midiInMessage [WINMM.65]
2684 DWORD WINAPI
midiInMessage(HMIDIIN hMidiIn
, UINT uMessage
,
2685 DWORD dwParam1
, DWORD dwParam2
)
2687 LPMIDIOPENDESC lpDesc
;
2689 TRACE("(%04X, %04X, %08lX, %08lX)\n",
2690 hMidiIn
, uMessage
, dwParam1
, dwParam2
);
2691 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2693 return MMSYSERR_INVALHANDLE
;
2697 FIXME("can't handle MIDM_OPEN!\n");
2699 case MIDM_GETDEVCAPS
:
2700 return midiInGetDevCapsA(hMidiIn
, (LPMIDIINCAPSA
)dwParam1
, dwParam2
);
2701 case MIDM_GETNUMDEVS
:
2706 /* no argument conversion needed */
2709 return midiInPrepareHeader(hMidiIn
, (LPMIDIHDR
)dwParam1
, dwParam2
);
2710 case MIDM_UNPREPARE
:
2711 return midiInUnprepareHeader(hMidiIn
, (LPMIDIHDR
)dwParam1
, dwParam2
);
2712 case MIDM_ADDBUFFER
:
2713 return midiInAddBuffer(hMidiIn
, (LPMIDIHDR
)dwParam1
, dwParam2
);
2715 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
2716 hMidiIn
, uMessage
, dwParam1
, dwParam2
);
2719 return midMessage(0, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
2722 /**************************************************************************
2723 * midiInMessage [MMSYSTEM.313]
2725 DWORD WINAPI
midiInMessage16(HMIDIIN16 hMidiIn
, UINT16 uMessage
,
2726 DWORD dwParam1
, DWORD dwParam2
)
2728 LPMIDIOPENDESC lpDesc
;
2730 TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiIn
, uMessage
, dwParam1
, dwParam2
);
2732 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
2733 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2736 WARN("can't handle MIDM_OPEN!\n");
2738 case MIDM_GETDEVCAPS
:
2739 return midiInGetDevCaps16(hMidiIn
, (LPMIDIINCAPS16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2740 case MIDM_GETNUMDEVS
:
2745 /* no argument conversion needed */
2748 return midiInPrepareHeader16(hMidiIn
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2749 case MIDM_UNPREPARE
:
2750 return midiInUnprepareHeader16(hMidiIn
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2751 case MIDM_ADDBUFFER
:
2752 return midiInAddBuffer16(hMidiIn
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2754 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
2755 hMidiIn
, uMessage
, dwParam1
, dwParam2
);
2758 return midMessage(0, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
2761 typedef struct WINE_MIDIStream
{
2772 LPMIDIHDR lpMidiHdr
;
2775 #define WINE_MSM_HEADER (WM_USER+0)
2776 #define WINE_MSM_STOP (WM_USER+1)
2778 /**************************************************************************
2779 * MMSYSTEM_GetMidiStream [internal]
2781 static BOOL
MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm
, WINE_MIDIStream
** lpMidiStrm
, MIDIOPENDESC
** lplpDesc
)
2783 MIDIOPENDESC
* lpDesc
= (LPMIDIOPENDESC
)USER_HEAP_LIN_ADDR(hMidiStrm
);
2788 if (lpDesc
== NULL
) {
2792 *lpMidiStrm
= (WINE_MIDIStream
*)lpDesc
->rgIds
.dwStreamID
;
2794 return *lpMidiStrm
!= NULL
;
2797 /**************************************************************************
2798 * MMSYSTEM_MidiStream_Convert [internal]
2800 static DWORD
MMSYSTEM_MidiStream_Convert(WINE_MIDIStream
* lpMidiStrm
, DWORD pulse
)
2804 if (lpMidiStrm
->dwTimeDiv
== 0) {
2805 FIXME("Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
2806 } else if (lpMidiStrm
->dwTimeDiv
> 0x8000) { /* SMPTE, unchecked FIXME? */
2807 int nf
= -(char)HIBYTE(lpMidiStrm
->dwTimeDiv
); /* number of frames */
2808 int nsf
= LOBYTE(lpMidiStrm
->dwTimeDiv
); /* number of sub-frames */
2809 ret
= (pulse
* 1000) / (nf
* nsf
);
2811 ret
= (DWORD
)((double)pulse
* ((double)lpMidiStrm
->dwTempo
/ 1000) /
2812 (double)lpMidiStrm
->dwTimeDiv
);
2818 /**************************************************************************
2819 * MMSYSTEM_MidiStream_MessageHandler [internal]
2821 static BOOL
MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream
* lpMidiStrm
, LPMIDIOPENDESC lpDesc
, LPMSG msg
)
2823 LPMIDIHDR lpMidiHdr
;
2827 switch (msg
->message
) {
2829 SetEvent(lpMidiStrm
->hEvent
);
2833 /* this is not quite what MS doc says... */
2834 midiOutReset(lpMidiStrm
->hDevice
);
2835 /* empty list of already submitted buffers */
2836 for (lpMidiHdr
= lpMidiStrm
->lpMidiHdr
; lpMidiHdr
; lpMidiHdr
= (LPMIDIHDR
)lpMidiHdr
->lpNext
) {
2837 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
2838 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
2840 DriverCallback16(lpDesc
->dwCallback
, lpMidiStrm
->wFlags
, lpMidiStrm
->hDevice
,
2841 MM_MOM_DONE
, lpDesc
->dwInstance
, lpMidiHdr
->reserved
, 0L);
2843 lpMidiStrm
->lpMidiHdr
= 0;
2844 SetEvent(lpMidiStrm
->hEvent
);
2846 case WINE_MSM_HEADER
:
2847 /* sets initial tick count for first MIDIHDR */
2848 if (!lpMidiStrm
->dwStartTicks
)
2849 lpMidiStrm
->dwStartTicks
= GetTickCount();
2851 /* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
2852 * by native mcimidi, it doesn't look like a correct one".
2853 * this trick allows to throw it away... but I don't like it.
2854 * It looks like part of the file I'm trying to play and definitively looks
2855 * like raw midi content
2856 * I'd really like to understand why native mcimidi sends it. Perhaps a bad
2857 * synchronization issue where native mcimidi is still processing raw MIDI
2858 * content before generating MIDIEVENTs ?
2860 * 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
2861 * 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
2862 * 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
2863 * 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
2864 * 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
2865 * 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
2866 * 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
2867 * 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
2868 * 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
2869 * 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
2870 * 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
2871 * 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
2872 * 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
2873 * 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
2874 * 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
2875 * 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
2876 * 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
2878 lpMidiHdr
= (LPMIDIHDR
)msg
->lParam
;
2879 lpData
= ((DWORD
)lpMidiHdr
== lpMidiHdr
->reserved
) ?
2880 (LPBYTE
)lpMidiHdr
->lpData
: (LPBYTE
)PTR_SEG_TO_LIN(lpMidiHdr
->lpData
);
2881 TRACE("Adding %s lpMidiHdr=%p [lpData=0x%08lx dwBufferLength=%lu/%lu dwFlags=0x%08lx size=%u]\n",
2882 (lpMidiHdr
->dwFlags
& MHDR_ISSTRM
) ? "stream" : "regular", lpMidiHdr
,
2883 lpMidiHdr
->reserved
, lpMidiHdr
->dwBufferLength
, lpMidiHdr
->dwBytesRecorded
,
2884 lpMidiHdr
->dwFlags
, msg
->wParam
);
2886 /* dumps content of lpMidiHdr->lpData
2887 * FIXME: there should be a debug routine somewhere that already does this
2888 * I hate spreading this type of shit all around the code
2890 for (dwToGo
= 0; dwToGo
< lpMidiHdr
->dwBufferLength
; dwToGo
+= 16) {
2894 for (i
= 0; i
< MIN(16, lpMidiHdr
->dwBufferLength
- dwToGo
); i
++)
2895 printf("%02x ", lpData
[dwToGo
+ i
]);
2898 for (i
= 0; i
< MIN(16, lpMidiHdr
->dwBufferLength
- dwToGo
); i
++) {
2899 ch
= lpData
[dwToGo
+ i
];
2900 printf("%c", (ch
>= 0x20 && ch
<= 0x7F) ? ch
: '.');
2905 if (((LPMIDIEVENT
)lpData
)->dwStreamID
!= 0 &&
2906 ((LPMIDIEVENT
)lpData
)->dwStreamID
!= 0xFFFFFFFF &&
2907 ((LPMIDIEVENT
)lpData
)->dwStreamID
!= (DWORD
)lpMidiStrm
) {
2908 FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n",
2909 (lpMidiHdr
->dwFlags
& MHDR_ISSTRM
) ? "stream" : "regular",
2910 ((LPMIDIEVENT
)lpData
)->dwStreamID
);
2911 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
2912 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
2914 DriverCallback16(lpDesc
->dwCallback
, lpMidiStrm
->wFlags
, lpMidiStrm
->hDevice
,
2915 MM_MOM_DONE
, lpDesc
->dwInstance
, lpMidiHdr
->reserved
, 0L);
2919 for (lpmh
= &lpMidiStrm
->lpMidiHdr
; *lpmh
; lpmh
= (LPMIDIHDR
*)&((*lpmh
)->lpNext
));
2921 lpMidiHdr
= (LPMIDIHDR
)msg
->lParam
;
2922 lpMidiHdr
->lpNext
= 0;
2923 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
2924 lpMidiHdr
->dwFlags
&= MHDR_DONE
;
2925 lpMidiHdr
->dwOffset
= 0;
2929 FIXME("Unknown message %d\n", msg
->message
);
2935 /**************************************************************************
2936 * MMSYSTEM_MidiStream_Player [internal]
2938 static DWORD CALLBACK
MMSYSTEM_MidiStream_Player(LPVOID pmt
)
2940 WINE_MIDIStream
* lpMidiStrm
= pmt
;
2941 MIDIOPENDESC
* lpDesc
= USER_HEAP_LIN_ADDR(lpMidiStrm
->hDevice
);
2945 LPMIDIHDR lpMidiHdr
;
2949 TRACE("(%p)!\n", lpMidiStrm
);
2951 /* force thread's queue creation */
2952 /* Used to be InitThreadInput16(0, 5); */
2953 /* but following works also with hack in midiStreamOpen */
2954 Callout
.PeekMessageA(&msg
, 0, 0, 0, 0);
2956 /* FIXME: this next line must be called before midiStreamOut or midiStreamRestart are called */
2957 SetEvent(lpMidiStrm
->hEvent
);
2958 TRACE("Ready to go 1\n");
2959 /* thread is started in paused mode */
2960 SuspendThread(lpMidiStrm
->hThread
);
2961 TRACE("Ready to go 2\n");
2963 lpMidiStrm
->dwStartTicks
= 0;
2964 lpMidiStrm
->dwPulses
= 0;
2966 lpMidiStrm
->lpMidiHdr
= 0;
2969 lpMidiHdr
= lpMidiStrm
->lpMidiHdr
;
2971 /* for first message, block until one arrives, then process all that are available */
2972 Callout
.GetMessageA(&msg
, 0, 0, 0);
2974 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm
, lpDesc
, &msg
))
2976 } while (Callout
.PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
));
2982 * midiOutPrepareHeader(), in Wine, sets the 'reserved' field of MIDIHDR to the
2983 * 16 or 32 bit address of lpMidiHdr (depending if called from 16 to 32 bit code)
2986 lpData
= ((DWORD
)lpMidiHdr
== lpMidiHdr
->reserved
) ?
2987 (LPBYTE
)lpMidiHdr
->lpData
: (LPBYTE
)PTR_SEG_TO_LIN(lpMidiHdr
->lpData
);
2989 me
= (LPMIDIEVENT
)(lpData
+ lpMidiHdr
->dwOffset
);
2991 /* do we have to wait ? */
2992 if (me
->dwDeltaTime
) {
2993 lpMidiStrm
->dwPositionMS
+= MMSYSTEM_MidiStream_Convert(lpMidiStrm
, me
->dwDeltaTime
);
2994 lpMidiStrm
->dwPulses
+= me
->dwDeltaTime
;
2996 dwToGo
= lpMidiStrm
->dwStartTicks
+ lpMidiStrm
->dwPositionMS
;
2998 TRACE("%ld/%ld/%ld\n", dwToGo
, GetTickCount(), me
->dwDeltaTime
);
2999 while ((dwCurrTC
= GetTickCount()) < dwToGo
) {
3000 if (MsgWaitForMultipleObjects(0, NULL
, FALSE
, dwToGo
- dwCurrTC
, QS_ALLINPUT
) == WAIT_OBJECT_0
) {
3001 /* got a message, handle it */
3002 while (Callout
.PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
)) {
3003 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm
, lpDesc
, &msg
))
3008 /* timeout, so me->dwDeltaTime is elapsed, can break the while loop */
3013 switch (MEVT_EVENTTYPE(me
->dwEvent
& ~MEVT_F_CALLBACK
)) {
3015 FIXME("NIY: MEVT_COMMENT\n");
3016 /* do nothing, skip bytes */
3019 FIXME("NIY: MEVT_LONGMSG, aka sending Sysex event\n");
3024 midiOutShortMsg(lpMidiStrm
->hDevice
, MEVT_EVENTPARM(me
->dwEvent
));
3027 lpMidiStrm
->dwTempo
= MEVT_EVENTPARM(me
->dwEvent
);
3032 FIXME("Unknown MEVT (0x%02x)\n", MEVT_EVENTTYPE(me
->dwEvent
& ~MEVT_F_CALLBACK
));
3035 if (me
->dwEvent
& MEVT_F_CALLBACK
) {
3036 DriverCallback16(lpDesc
->dwCallback
, lpMidiStrm
->wFlags
, lpMidiStrm
->hDevice
,
3037 MM_MOM_POSITIONCB
, lpDesc
->dwInstance
, (LPARAM
)lpMidiHdr
, 0L);
3039 lpMidiHdr
->dwOffset
+= sizeof(MIDIEVENT
);
3040 if (me
->dwEvent
& MEVT_F_LONG
)
3041 lpMidiHdr
->dwOffset
+= (MEVT_EVENTPARM(me
->dwEvent
) + 3) & ~3;
3042 if (lpMidiHdr
->dwOffset
>= lpMidiHdr
->dwBufferLength
) {
3043 /* done with this header */
3044 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
3045 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
3047 lpMidiStrm
->lpMidiHdr
= (LPMIDIHDR
)lpMidiHdr
->lpNext
;
3048 DriverCallback16(lpDesc
->dwCallback
, lpMidiStrm
->wFlags
, lpMidiStrm
->hDevice
,
3049 MM_MOM_DONE
, lpDesc
->dwInstance
, lpMidiHdr
->reserved
, 0L);
3054 TRACE("End of thread\n");
3056 return 0; /* for removing the warning, never executed */
3059 /**************************************************************************
3060 * MMSYSTEM_MidiStream_PostMessage [internal]
3062 static BOOL
MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream
* lpMidiStrm
, WORD msg
, DWORD pmt1
, DWORD pmt2
)
3064 if (Callout
.PostThreadMessageA(lpMidiStrm
->dwThreadID
, msg
, pmt1
, pmt2
)) {
3068 /* FIXME: should use the new syslevel APIs */
3069 if ((bHasWin16Lock
= _ConfirmWin16Lock()) != 0) {
3070 ReleaseThunkLock(&count
);
3072 WaitForSingleObject(lpMidiStrm
->hEvent
, INFINITE
);
3073 if (bHasWin16Lock
) {
3074 RestoreThunkLock(count
);
3077 WARN("bad PostThreadMessageA\n");
3083 /**************************************************************************
3084 * midiStreamClose [WINMM.90]
3086 MMRESULT WINAPI
midiStreamClose(HMIDISTRM hMidiStrm
)
3088 WINE_MIDIStream
* lpMidiStrm
;
3090 TRACE("(%08x)!\n", hMidiStrm
);
3092 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
))
3093 return MMSYSERR_INVALHANDLE
;
3095 midiStreamStop(hMidiStrm
);
3096 MMSYSTEM_MidiStream_PostMessage(lpMidiStrm
, WM_QUIT
, 0, 0);
3097 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
3098 CloseHandle(lpMidiStrm
->hEvent
);
3100 return midiOutClose(hMidiStrm
);
3103 /**************************************************************************
3104 * MMSYSTEM_MidiStream_Open [internal]
3106 static MMRESULT WINAPI
MMSYSTEM_MidiStream_Open(HMIDISTRM
* lphMidiStrm
, LPUINT lpuDeviceID
,
3107 DWORD cMidi
, DWORD dwCallback
,
3108 DWORD dwInstance
, DWORD fdwOpen
)
3110 WINE_MIDIStream
* lpMidiStrm
;
3112 MIDIOPENSTRMID mosm
;
3113 MIDIOPENDESC
* lpDesc
;
3114 HMIDIOUT16 hMidiOut16
;
3116 TRACE("(%p, %p, %ld, 0x%08lx, 0x%08lx, 0x%08lx)!\n",
3117 lphMidiStrm
, lpuDeviceID
, cMidi
, dwCallback
, dwInstance
, fdwOpen
);
3119 if (cMidi
!= 1 || lphMidiStrm
== NULL
|| lpuDeviceID
== NULL
)
3120 return MMSYSERR_INVALPARAM
;
3122 if (*lpuDeviceID
== (UINT16
)MIDI_MAPPER
) {
3123 FIXME("MIDI_MAPPER mode requested ! => forcing devID to 0\n");
3127 lpMidiStrm
= HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream
));
3129 return MMSYSERR_NOMEM
;
3131 lpMidiStrm
->dwTempo
= 500000;
3132 lpMidiStrm
->dwTimeDiv
= 480; /* 480 is 120 quater notes per minute *//* FIXME ??*/
3133 lpMidiStrm
->dwPositionMS
= 0;
3135 mosm
.dwStreamID
= (DWORD
)lpMidiStrm
;
3136 /* FIXME: the correct value is not allocated yet for MAPPER */
3137 mosm
.wDeviceID
= *lpuDeviceID
;
3138 lpDesc
= MIDI_OutAlloc(&hMidiOut16
, dwCallback
, dwInstance
, 1, &mosm
);
3139 lpMidiStrm
->hDevice
= hMidiOut16
;
3141 *lphMidiStrm
= hMidiOut16
;
3143 lpDesc
->wDevID
= *lpuDeviceID
;
3144 ret
= modMessage(lpDesc
->wDevID
, MODM_OPEN
,
3145 lpDesc
->dwInstance
, (DWORD
)lpDesc
, fdwOpen
);
3146 lpMidiStrm
->hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
3147 lpMidiStrm
->wFlags
= HIWORD(fdwOpen
);
3149 lpMidiStrm
->hThread
= CreateThread(NULL
, 0, MMSYSTEM_MidiStream_Player
,
3150 lpMidiStrm
, 0, &(lpMidiStrm
->dwThreadID
));
3152 if (!lpMidiStrm
->hThread
) {
3153 midiStreamClose((HMIDISTRM
)hMidiOut16
);
3154 return MMSYSERR_NOMEM
;
3157 /* wait for thread to have started, and for it's queue to be created */
3162 /* (Release|Restore)ThunkLock() is needed when this method is called from 16 bit code,
3163 * (meaning the Win16Lock is set), so that it's released and the 32 bit thread running
3164 * MMSYSTEM_MidiStreamPlayer can acquire Win16Lock to create its queue.
3166 if ((bHasWin16Lock
= _ConfirmWin16Lock()) != 0) {
3167 ReleaseThunkLock(&count
);
3169 WaitForSingleObject(lpMidiStrm
->hEvent
, INFINITE
);
3170 if (bHasWin16Lock
) {
3171 RestoreThunkLock(count
);
3175 TRACE("=> (%u/%d) hMidi=0x%04x ret=%d lpMidiStrm=%p\n", *lpuDeviceID
, lpDesc
->wDevID
, *lphMidiStrm
, ret
, lpMidiStrm
);
3179 /**************************************************************************
3180 * midiStreamOpen [WINMM.91]
3182 MMRESULT WINAPI
midiStreamOpen(HMIDISTRM
* lphMidiStrm
, LPUINT lpuDeviceID
,
3183 DWORD cMidi
, DWORD dwCallback
,
3184 DWORD dwInstance
, DWORD fdwOpen
)
3186 return MMSYSTEM_MidiStream_Open(lphMidiStrm
, lpuDeviceID
, cMidi
, dwCallback
, dwInstance
, CALLBACK32CONV(fdwOpen
));
3189 /**************************************************************************
3190 * midiStreamOut [WINMM.92]
3192 MMRESULT WINAPI
midiStreamOut(HMIDISTRM hMidiStrm
, LPMIDIHDR lpMidiHdr
, UINT cbMidiHdr
)
3194 WINE_MIDIStream
* lpMidiStrm
;
3195 DWORD ret
= MMSYSERR_NOERROR
;
3197 TRACE("(%08x, %p, %u)!\n", hMidiStrm
, lpMidiHdr
, cbMidiHdr
);
3199 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
3200 ret
= MMSYSERR_INVALHANDLE
;
3202 if (!Callout
.PostThreadMessageA(lpMidiStrm
->dwThreadID
, WINE_MSM_HEADER
, cbMidiHdr
, (DWORD
)lpMidiHdr
)) {
3203 WARN("bad PostThreadMessageA\n");
3204 ret
= MMSYSERR_ERROR
;
3210 /**************************************************************************
3211 * midiStreamPause [WINMM.93]
3213 MMRESULT WINAPI
midiStreamPause(HMIDISTRM hMidiStrm
)
3215 WINE_MIDIStream
* lpMidiStrm
;
3216 DWORD ret
= MMSYSERR_NOERROR
;
3218 TRACE("(%08x)!\n", hMidiStrm
);
3220 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
3221 ret
= MMSYSERR_INVALHANDLE
;
3223 if (SuspendThread(lpMidiStrm
->hThread
) == 0xFFFFFFFF) {
3224 WARN("bad Suspend (%ld)\n", GetLastError());
3225 ret
= MMSYSERR_ERROR
;
3231 /**************************************************************************
3232 * midiStreamPosition [WINMM.94]
3234 MMRESULT WINAPI
midiStreamPosition(HMIDISTRM hMidiStrm
, LPMMTIME lpMMT
, UINT cbmmt
)
3236 WINE_MIDIStream
* lpMidiStrm
;
3237 DWORD ret
= MMSYSERR_NOERROR
;
3239 TRACE("(%08x, %p, %u)!\n", hMidiStrm
, lpMMT
, cbmmt
);
3241 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
3242 ret
= MMSYSERR_INVALHANDLE
;
3243 } else if (lpMMT
== NULL
|| cbmmt
!= sizeof(MMTIME
)) {
3244 ret
= MMSYSERR_INVALPARAM
;
3246 switch (lpMMT
->wType
) {
3248 lpMMT
->u
.ms
= lpMidiStrm
->dwPositionMS
;
3249 TRACE("=> %ld ms\n", lpMMT
->u
.ms
);
3252 lpMMT
->u
.ticks
= lpMidiStrm
->dwPulses
;
3253 TRACE("=> %ld ticks\n", lpMMT
->u
.ticks
);
3256 WARN("Unsupported time type %d\n", lpMMT
->wType
);
3257 lpMMT
->wType
= TIME_MS
;
3258 ret
= MMSYSERR_INVALPARAM
;
3265 /**************************************************************************
3266 * midiStreamProperty [WINMM.95]
3268 MMRESULT WINAPI
midiStreamProperty(HMIDISTRM hMidiStrm
, LPBYTE lpPropData
, DWORD dwProperty
)
3270 WINE_MIDIStream
* lpMidiStrm
;
3271 MMRESULT ret
= MMSYSERR_NOERROR
;
3273 TRACE("(%08x, %p, %lx)\n", hMidiStrm
, lpPropData
, dwProperty
);
3275 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
3276 ret
= MMSYSERR_INVALHANDLE
;
3277 } else if ((dwProperty
& (MIDIPROP_GET
|MIDIPROP_SET
)) == 0) {
3278 ret
= MMSYSERR_INVALPARAM
;
3279 } else if (dwProperty
& MIDIPROP_TEMPO
) {
3280 MIDIPROPTEMPO
* mpt
= (MIDIPROPTEMPO
*)lpPropData
;
3282 if (sizeof(MIDIPROPTEMPO
) != mpt
->cbStruct
) {
3283 ret
= MMSYSERR_INVALPARAM
;
3284 } else if (dwProperty
& MIDIPROP_SET
) {
3285 lpMidiStrm
->dwTempo
= mpt
->dwTempo
;
3286 TRACE("Setting tempo to %ld\n", mpt
->dwTempo
);
3287 } else if (dwProperty
& MIDIPROP_GET
) {
3288 mpt
->dwTempo
= lpMidiStrm
->dwTempo
;
3289 TRACE("Getting tempo <= %ld\n", mpt
->dwTempo
);
3291 } else if (dwProperty
& MIDIPROP_TIMEDIV
) {
3292 MIDIPROPTIMEDIV
* mptd
= (MIDIPROPTIMEDIV
*)lpPropData
;
3294 if (sizeof(MIDIPROPTIMEDIV
) != mptd
->cbStruct
) {
3295 ret
= MMSYSERR_INVALPARAM
;
3296 } else if (dwProperty
& MIDIPROP_SET
) {
3297 lpMidiStrm
->dwTimeDiv
= mptd
->dwTimeDiv
;
3298 TRACE("Setting time div to %ld\n", mptd
->dwTimeDiv
);
3299 } else if (dwProperty
& MIDIPROP_GET
) {
3300 mptd
->dwTimeDiv
= lpMidiStrm
->dwTimeDiv
;
3301 TRACE("Getting time div <= %ld\n", mptd
->dwTimeDiv
);
3304 ret
= MMSYSERR_INVALPARAM
;
3310 /**************************************************************************
3311 * midiStreamRestart [WINMM.96]
3313 MMRESULT WINAPI
midiStreamRestart(HMIDISTRM hMidiStrm
)
3315 WINE_MIDIStream
* lpMidiStrm
;
3316 MMRESULT ret
= MMSYSERR_NOERROR
;
3318 TRACE("(%08x)!\n", hMidiStrm
);
3320 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
3321 ret
= MMSYSERR_INVALHANDLE
;
3323 if (ResumeThread(lpMidiStrm
->hThread
) == 0xFFFFFFFF) {
3324 WARN("bad Resume (%ld)\n", GetLastError());
3325 ret
= MMSYSERR_ERROR
;
3327 lpMidiStrm
->dwStartTicks
= GetTickCount() - lpMidiStrm
->dwPositionMS
;
3333 /**************************************************************************
3334 * midiStreamStop [WINMM.97]
3336 MMRESULT WINAPI
midiStreamStop(HMIDISTRM hMidiStrm
)
3338 WINE_MIDIStream
* lpMidiStrm
;
3339 MMRESULT ret
= MMSYSERR_NOERROR
;
3341 TRACE("(%08x)!\n", hMidiStrm
);
3343 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
3344 ret
= MMSYSERR_INVALHANDLE
;
3346 /* in case stream has been paused... FIXME is the current state correct ? */
3347 midiStreamRestart(hMidiStrm
);
3348 MMSYSTEM_MidiStream_PostMessage(lpMidiStrm
, WINE_MSM_STOP
, 0, 0);
3353 /**************************************************************************
3354 * midiStreamClose [MMSYSTEM.252]
3356 MMRESULT16 WINAPI
midiStreamClose16(HMIDISTRM16 hMidiStrm
)
3358 return midiStreamClose(hMidiStrm
);
3361 /**************************************************************************
3362 * midiStreamOpen [MMSYSTEM.251]
3364 MMRESULT16 WINAPI
midiStreamOpen16(HMIDISTRM16
* phMidiStrm
, LPUINT16 devid
,
3365 DWORD cMidi
, DWORD dwCallback
,
3366 DWORD dwInstance
, DWORD fdwOpen
)
3368 HMIDISTRM hMidiStrm32
;
3372 if (!phMidiStrm
|| !devid
)
3373 return MMSYSERR_INVALPARAM
;
3375 ret
= MMSYSTEM_MidiStream_Open(&hMidiStrm32
, &devid32
, cMidi
, dwCallback
, dwInstance
, fdwOpen
);
3376 *phMidiStrm
= hMidiStrm32
;
3381 /**************************************************************************
3382 * midiStreamOut [MMSYSTEM.254]
3384 MMRESULT16 WINAPI
midiStreamOut16(HMIDISTRM16 hMidiStrm
, LPMIDIHDR16 lpMidiHdr
, UINT16 cbMidiHdr
)
3386 return midiStreamOut(hMidiStrm
, (LPMIDIHDR
)lpMidiHdr
, cbMidiHdr
);
3389 /**************************************************************************
3390 * midiStreamPause [MMSYSTEM.255]
3392 MMRESULT16 WINAPI
midiStreamPause16(HMIDISTRM16 hMidiStrm
)
3394 return midiStreamPause(hMidiStrm
);
3397 /**************************************************************************
3398 * midiStreamPosition [MMSYSTEM.253]
3400 MMRESULT16 WINAPI
midiStreamPosition16(HMIDISTRM16 hMidiStrm
, LPMMTIME16 lpmmt16
, UINT16 cbmmt
)
3406 return MMSYSERR_INVALPARAM
;
3407 MMSYSTEM_MMTIME16to32(&mmt32
, lpmmt16
);
3408 ret
= midiStreamPosition(hMidiStrm
, &mmt32
, sizeof(MMTIME
));
3409 MMSYSTEM_MMTIME32to16(lpmmt16
, &mmt32
);
3413 /**************************************************************************
3414 * midiStreamProperty [MMSYSTEM.250]
3416 MMRESULT16 WINAPI
midiStreamProperty16(HMIDISTRM16 hMidiStrm
, LPBYTE lpPropData
, DWORD dwProperty
)
3418 return midiStreamProperty(hMidiStrm
, lpPropData
, dwProperty
);
3421 /**************************************************************************
3422 * midiStreamRestart [MMSYSTEM.256]
3424 MMRESULT16 WINAPI
midiStreamRestart16(HMIDISTRM16 hMidiStrm
)
3426 return midiStreamRestart(hMidiStrm
);
3429 /**************************************************************************
3430 * midiStreamStop [MMSYSTEM.257]
3432 MMRESULT16 WINAPI
midiStreamStop16(HMIDISTRM16 hMidiStrm
)
3434 return midiStreamStop(hMidiStrm
);
3437 /**************************************************************************
3438 * waveOutGetNumDevs [MMSYSTEM.401]
3440 UINT WINAPI
waveOutGetNumDevs(void)
3442 return waveOutGetNumDevs16();
3445 /**************************************************************************
3446 * waveOutGetNumDevs [WINMM.167]
3448 UINT16 WINAPI
waveOutGetNumDevs16(void)
3451 TRACE("waveOutGetNumDevs\n");
3452 count
+= wodMessage(0, WODM_GETNUMDEVS
, 0L, 0L, 0L);
3453 TRACE("waveOutGetNumDevs return %u \n", count
);
3457 /**************************************************************************
3458 * waveOutGetDevCaps [MMSYSTEM.402]
3460 UINT16 WINAPI
waveOutGetDevCaps16(UINT16 uDeviceID
, LPWAVEOUTCAPS16 lpCaps
,
3463 TRACE("waveOutGetDevCaps\n");
3465 /* FIXME: do we have a wave mapper ? */
3466 if (uDeviceID
== (UINT16
)WAVE_MAPPER
)
3468 /* return MMSYSERR_BADDEVICEID; */
3470 if (uDeviceID
>= waveOutGetNumDevs16()) return MMSYSERR_BADDEVICEID
;
3472 return wodMessage(uDeviceID
, WODM_GETDEVCAPS
, 0L, (DWORD
)lpCaps
, uSize
);
3475 /**************************************************************************
3476 * waveOutGetDevCapsA [WINMM.162]
3478 UINT WINAPI
waveOutGetDevCapsA(UINT uDeviceID
, LPWAVEOUTCAPSA lpCaps
,
3481 WAVEOUTCAPS16 woc16
;
3482 UINT16 ret
= waveOutGetDevCaps16(uDeviceID
, &woc16
, sizeof(woc16
));
3484 lpCaps
->wMid
= woc16
.wMid
;
3485 lpCaps
->wPid
= woc16
.wPid
;
3486 lpCaps
->vDriverVersion
= woc16
.vDriverVersion
;
3487 strcpy(lpCaps
->szPname
, woc16
.szPname
);
3488 lpCaps
->dwFormats
= woc16
.dwFormats
;
3489 lpCaps
->wChannels
= woc16
.wChannels
;
3490 lpCaps
->dwSupport
= woc16
.dwSupport
;
3494 /**************************************************************************
3495 * waveOutGetDevCapsW [WINMM.163]
3497 UINT WINAPI
waveOutGetDevCapsW(UINT uDeviceID
, LPWAVEOUTCAPSW lpCaps
,
3500 WAVEOUTCAPS16 woc16
;
3501 UINT ret
= waveOutGetDevCaps16(uDeviceID
, &woc16
, sizeof(woc16
));
3503 lpCaps
->wMid
= woc16
.wMid
;
3504 lpCaps
->wPid
= woc16
.wPid
;
3505 lpCaps
->vDriverVersion
= woc16
.vDriverVersion
;
3506 lstrcpyAtoW(lpCaps
->szPname
, woc16
.szPname
);
3507 lpCaps
->dwFormats
= woc16
.dwFormats
;
3508 lpCaps
->wChannels
= woc16
.wChannels
;
3509 lpCaps
->dwSupport
= woc16
.dwSupport
;
3513 /**************************************************************************
3514 * WAVE_GetErrorText [internal]
3516 static UINT16
WAVE_GetErrorText(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
3518 UINT16 ret
= MMSYSERR_BADERRNUM
;
3520 if (lpText
== NULL
) {
3521 ret
= MMSYSERR_INVALPARAM
;
3522 } else if (uSize
== 0) {
3523 ret
= MMSYSERR_NOERROR
;
3525 /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
3526 * a warning for the test was always true */
3527 (/*uError >= MMSYSERR_BASE && */uError
<= MMSYSERR_LASTERROR
) ||
3528 (uError
>= WAVERR_BASE
&& uError
<= WAVERR_LASTERROR
)) {
3530 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
3533 ret
= MMSYSERR_ERROR
;
3534 } else if (LoadStringA(iData
->hWinMM32Instance
, uError
, lpText
, uSize
) > 0) {
3535 ret
= MMSYSERR_NOERROR
;
3541 /**************************************************************************
3542 * waveOutGetErrorText [MMSYSTEM.403]
3544 UINT16 WINAPI
waveOutGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
3546 return WAVE_GetErrorText(uError
, lpText
, uSize
);
3549 /**************************************************************************
3550 * waveOutGetErrorTextA [WINMM.164]
3552 UINT WINAPI
waveOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
3554 return WAVE_GetErrorText(uError
, lpText
, uSize
);
3557 /**************************************************************************
3558 * waveOutGetErrorTextW [WINMM.165]
3560 UINT WINAPI
waveOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
3562 LPSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
);
3563 UINT ret
= WAVE_GetErrorText(uError
, xstr
, uSize
);
3565 lstrcpyAtoW(lpText
, xstr
);
3566 HeapFree(GetProcessHeap(), 0, xstr
);
3570 /**************************************************************************
3571 * waveOutOpen [WINMM.173]
3572 * All the args/structs have the same layout as the win16 equivalents
3574 UINT WINAPI
waveOutOpen(HWAVEOUT
* lphWaveOut
, UINT uDeviceID
,
3575 const LPWAVEFORMATEX lpFormat
, DWORD dwCallback
,
3576 DWORD dwInstance
, DWORD dwFlags
)
3579 UINT ret
= waveOutOpen16(&hwo16
, uDeviceID
, lpFormat
, dwCallback
, dwInstance
,
3580 CALLBACK32CONV(dwFlags
));
3582 if (lphWaveOut
) *lphWaveOut
= hwo16
;
3586 /**************************************************************************
3587 * waveOutOpen [MMSYSTEM.404]
3589 UINT16 WINAPI
waveOutOpen16(HWAVEOUT16
* lphWaveOut
, UINT16 uDeviceID
,
3590 const LPWAVEFORMATEX lpFormat
, DWORD dwCallback
,
3591 DWORD dwInstance
, DWORD dwFlags
)
3593 HWAVEOUT16 hWaveOut
;
3594 LPWAVEOPENDESC lpDesc
;
3595 DWORD dwRet
= MMSYSERR_NOERROR
;
3596 BOOL bMapperFlg
= FALSE
;
3598 TRACE("(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3599 lphWaveOut
, uDeviceID
, lpFormat
, dwCallback
, dwInstance
, dwFlags
);
3600 if (dwFlags
& WAVE_FORMAT_QUERY
)
3601 TRACE("WAVE_FORMAT_QUERY requested !\n");
3602 if (uDeviceID
== (UINT16
)WAVE_MAPPER
) {
3603 TRACE("WAVE_MAPPER mode requested !\n");
3607 if (lpFormat
== NULL
) return WAVERR_BADFORMAT
;
3609 hWaveOut
= USER_HEAP_ALLOC(sizeof(WAVEOPENDESC
));
3610 if (hWaveOut
== 0) return MMSYSERR_NOMEM
;
3611 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3612 if (lpDesc
== NULL
) return MMSYSERR_NOMEM
;
3613 lpDesc
->hWave
= hWaveOut
;
3614 lpDesc
->lpFormat
= (LPWAVEFORMAT
)lpFormat
; /* should the struct be copied iso pointer? */
3615 lpDesc
->dwCallBack
= dwCallback
;
3616 lpDesc
->dwInstance
= dwInstance
;
3617 if (uDeviceID
>= MAXWAVEDRIVERS
)
3619 while (uDeviceID
< MAXWAVEDRIVERS
) {
3620 /* FIXME: dwUser parameter is wrong, it's not lpDesc->dwInstancen but
3621 * a pointer to a DWORD (see ms/ddkdoc/s2abc.htm)
3623 dwRet
= wodMessage(uDeviceID
, WODM_OPEN
,
3624 lpDesc
->dwInstance
, (DWORD
)lpDesc
, dwFlags
);
3625 if (dwRet
== MMSYSERR_NOERROR
) break;
3626 if (!bMapperFlg
) break;
3628 TRACE("WAVE_MAPPER mode ! try next driver...\n");
3630 lpDesc
->uDeviceID
= uDeviceID
; /* save physical Device ID */
3631 if (dwFlags
& WAVE_FORMAT_QUERY
) {
3632 TRACE("End of WAVE_FORMAT_QUERY !\n");
3633 USER_HEAP_FREE(hWaveOut
);
3636 else if (dwRet
!= MMSYSERR_NOERROR
)
3638 USER_HEAP_FREE(hWaveOut
);
3641 if (lphWaveOut
!= NULL
) *lphWaveOut
= hWaveOut
;
3642 TRACE("=> %ld\n", dwRet
);
3646 /**************************************************************************
3647 * waveOutClose [WINMM.161]
3649 UINT WINAPI
waveOutClose(HWAVEOUT hWaveOut
)
3651 return waveOutClose16(hWaveOut
);
3654 /**************************************************************************
3655 * waveOutClose [MMSYSTEM.405]
3657 UINT16 WINAPI
waveOutClose16(HWAVEOUT16 hWaveOut
)
3659 LPWAVEOPENDESC lpDesc
;
3662 TRACE("(%04X)\n", hWaveOut
);
3664 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3665 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3666 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3667 dwRet
= wodMessage(lpDesc
->uDeviceID
, WODM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
3668 USER_HEAP_FREE(hWaveOut
);
3672 /**************************************************************************
3673 * waveOutPrepareHeader [WINMM.175]
3675 UINT WINAPI
waveOutPrepareHeader(HWAVEOUT hWaveOut
,
3676 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
3678 LPWAVEOPENDESC lpDesc
;
3680 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3682 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3684 return MMSYSERR_INVALHANDLE
;
3685 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
;
3686 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3687 return wodMessage(lpDesc
->uDeviceID
, WODM_PREPARE
, lpDesc
->dwInstance
,
3688 (DWORD
)lpWaveOutHdr
, uSize
);
3691 /**************************************************************************
3692 * waveOutPrepareHeader [MMSYSTEM.406]
3694 UINT16 WINAPI
waveOutPrepareHeader16(HWAVEOUT16 hWaveOut
,
3695 WAVEHDR
* /*SEGPTR*/ _lpWaveOutHdr
, UINT16 uSize
)
3697 LPWAVEOPENDESC lpDesc
;
3698 LPWAVEHDR lpWaveOutHdr
= (LPWAVEHDR
)PTR_SEG_TO_LIN(_lpWaveOutHdr
);
3701 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3703 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3705 return MMSYSERR_INVALHANDLE
;
3706 lpWaveOutHdr
->reserved
= (DWORD
)_lpWaveOutHdr
;
3707 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3708 ret
= wodMessage(lpDesc
->uDeviceID
, WODM_PREPARE
, lpDesc
->dwInstance
,
3709 (DWORD
)lpWaveOutHdr
, uSize
);
3713 /**************************************************************************
3714 * waveOutUnprepareHeader [WINMM.181]
3716 UINT WINAPI
waveOutUnprepareHeader(HWAVEOUT hWaveOut
,
3717 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
3719 LPWAVEOPENDESC lpDesc
;
3721 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3723 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3724 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3725 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
;
3726 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3727 return wodMessage(lpDesc
->uDeviceID
, WODM_UNPREPARE
, lpDesc
->dwInstance
,
3728 (DWORD
)lpWaveOutHdr
, uSize
);
3731 /**************************************************************************
3732 * waveOutUnprepareHeader [MMSYSTEM.407]
3734 UINT16 WINAPI
waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut
,
3735 WAVEHDR
* lpWaveOutHdr
, UINT16 uSize
)
3737 LPWAVEOPENDESC lpDesc
;
3740 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3742 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3744 return MMSYSERR_INVALHANDLE
;
3745 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3746 ret
= wodMessage(lpDesc
->uDeviceID
, WODM_UNPREPARE
, lpDesc
->dwInstance
,
3747 (DWORD
)lpWaveOutHdr
, uSize
);
3751 /**************************************************************************
3752 * waveOutWrite [MMSYSTEM.408]
3754 UINT WINAPI
waveOutWrite(HWAVEOUT hWaveOut
, WAVEHDR
* lpWaveOutHdr
,
3757 LPWAVEOPENDESC lpDesc
;
3759 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3761 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3763 return MMSYSERR_INVALHANDLE
;
3764 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3765 return wodMessage(lpDesc
->uDeviceID
, WODM_WRITE
, lpDesc
->dwInstance
,
3766 (DWORD
)lpWaveOutHdr
, uSize
);
3769 /**************************************************************************
3770 * waveOutWrite [MMSYSTEM.408]
3772 UINT16 WINAPI
waveOutWrite16(HWAVEOUT16 hWaveOut
, WAVEHDR
* lpWaveOutHdr
,
3775 LPWAVEOPENDESC lpDesc
;
3778 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3780 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3782 return MMSYSERR_INVALHANDLE
;
3783 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3784 ret
= wodMessage(lpDesc
->uDeviceID
, WODM_WRITE
, lpDesc
->dwInstance
,
3785 (DWORD
)lpWaveOutHdr
, uSize
);
3789 /**************************************************************************
3790 * waveOutPause [WINMM.174]
3792 UINT WINAPI
waveOutPause(HWAVEOUT hWaveOut
)
3794 return waveOutPause16(hWaveOut
);
3797 /**************************************************************************
3798 * waveOutPause [MMSYSTEM.409]
3800 UINT16 WINAPI
waveOutPause16(HWAVEOUT16 hWaveOut
)
3802 LPWAVEOPENDESC lpDesc
;
3804 TRACE("(%04X)\n", hWaveOut
);
3806 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3807 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3808 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3809 return wodMessage(lpDesc
->uDeviceID
, WODM_PAUSE
, lpDesc
->dwInstance
, 0L, 0L);
3812 /**************************************************************************
3813 * waveOutRestart [WINMM.177]
3815 UINT WINAPI
waveOutRestart(HWAVEOUT hWaveOut
)
3817 return waveOutRestart16(hWaveOut
);
3820 /**************************************************************************
3821 * waveOutRestart [MMSYSTEM.410]
3823 UINT16 WINAPI
waveOutRestart16(HWAVEOUT16 hWaveOut
)
3825 LPWAVEOPENDESC lpDesc
;
3827 TRACE("(%04X)\n", hWaveOut
);
3829 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3830 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3831 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3832 return wodMessage(lpDesc
->uDeviceID
, WODM_RESTART
, lpDesc
->dwInstance
, 0L, 0L);
3835 /**************************************************************************
3836 * waveOutReset [WINMM.176]
3838 UINT WINAPI
waveOutReset(HWAVEOUT hWaveOut
)
3840 return waveOutReset16(hWaveOut
);
3843 /**************************************************************************
3844 * waveOutReset [MMSYSTEM.411]
3846 UINT16 WINAPI
waveOutReset16(HWAVEOUT16 hWaveOut
)
3848 LPWAVEOPENDESC lpDesc
;
3850 TRACE("(%04X)\n", hWaveOut
);
3852 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3853 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3854 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3855 return wodMessage(lpDesc
->uDeviceID
, WODM_RESET
, lpDesc
->dwInstance
, 0L, 0L);
3858 /**************************************************************************
3859 * waveOutGetPosition [WINMM.170]
3861 UINT WINAPI
waveOutGetPosition(HWAVEOUT hWaveOut
, LPMMTIME lpTime
,
3867 mmt16
.wType
= lpTime
->wType
;
3868 ret
= waveOutGetPosition16(hWaveOut
, &mmt16
, sizeof(mmt16
));
3869 MMSYSTEM_MMTIME16to32(lpTime
, &mmt16
);
3873 /**************************************************************************
3874 * waveOutGetPosition [MMSYSTEM.412]
3876 UINT16 WINAPI
waveOutGetPosition16(HWAVEOUT16 hWaveOut
, LPMMTIME16 lpTime
,
3879 LPWAVEOPENDESC lpDesc
;
3880 TRACE("(%04X, %p, %u);\n", hWaveOut
, lpTime
, uSize
);
3881 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3882 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3883 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */
3884 return wodMessage(lpDesc
->uDeviceID
, WODM_GETPOS
, lpDesc
->dwInstance
,
3885 (DWORD
)lpTime
, (DWORD
)uSize
);
3888 #define WAVEOUT_SHORTCUT_1(xx, XX, atype) \
3889 UINT WINAPI waveOut##xx(HWAVEOUT hWaveOut, atype x) \
3890 {return waveOut##xx##16(hWaveOut, x);} \
3891 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
3893 LPWAVEOPENDESC lpDesc; \
3894 TRACE("(%04X, %08lx);\n", hWaveOut, (DWORD)x); \
3895 lpDesc = (LPWAVEOPENDESC)USER_HEAP_LIN_ADDR(hWaveOut); \
3896 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */ \
3897 return (lpDesc == NULL) ? MMSYSERR_INVALHANDLE : \
3898 wodMessage(lpDesc->uDeviceID, WODM_##XX, \
3899 lpDesc->dwInstance, (DWORD)x, 0L); \
3902 WAVEOUT_SHORTCUT_1(GetPitch
, GETPITCH
, LPDWORD
)
3903 WAVEOUT_SHORTCUT_1(SetPitch
, SETPITCH
, DWORD
)
3904 WAVEOUT_SHORTCUT_1(GetPlaybackRate
, GETPLAYBACKRATE
, LPDWORD
)
3905 WAVEOUT_SHORTCUT_1(SetPlaybackRate
, SETPLAYBACKRATE
, DWORD
)
3906 #undef WAVEOUT_SHORTCUT_1
3908 #define WAVEOUT_SHORTCUT_2(xx, XX, atype) \
3909 UINT WINAPI waveOut##xx(UINT devid, atype x) \
3910 {return waveOut##xx##16(devid, x);} \
3911 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
3913 TRACE("(%04X, %08lx);\n", devid, (DWORD)x); \
3914 /* FIXME: dwUser parameter is wrong (cf waveOutOpen) */ \
3915 return wodMessage(devid, WODM_##XX, 0, (DWORD)x, 0L); \
3918 WAVEOUT_SHORTCUT_2(GetVolume
, GETVOLUME
, LPDWORD
)
3919 WAVEOUT_SHORTCUT_2(SetVolume
, SETVOLUME
, DWORD
)
3920 #undef WAVEOUT_SHORTCUT_1
3922 /**************************************************************************
3923 * waveOutBreakLoop [MMSYSTEM.419]
3925 UINT WINAPI
waveOutBreakLoop(HWAVEOUT hWaveOut
)
3927 return waveOutBreakLoop16(hWaveOut
);
3930 /**************************************************************************
3931 * waveOutBreakLoop [MMSYSTEM.419]
3933 UINT16 WINAPI
waveOutBreakLoop16(HWAVEOUT16 hWaveOut
)
3935 FIXME("(%04X)\n", hWaveOut
);
3936 return MMSYSERR_INVALHANDLE
;
3939 /**************************************************************************
3940 * waveOutGetID [MMSYSTEM.420]
3942 UINT WINAPI
waveOutGetID(HWAVEOUT hWaveOut
, UINT
* lpuDeviceID
)
3944 LPWAVEOPENDESC lpDesc
;
3946 TRACE("(%04X, %p);\n", hWaveOut
, lpuDeviceID
);
3948 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3949 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3950 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
3951 *lpuDeviceID
= lpDesc
->uDeviceID
;
3955 /**************************************************************************
3956 * waveOutGetID [MMSYSTEM.420]
3958 UINT16 WINAPI
waveOutGetID16(HWAVEOUT16 hWaveOut
, UINT16
* lpuDeviceID
)
3960 LPWAVEOPENDESC lpDesc
;
3962 TRACE("(%04X, %p);\n", hWaveOut
, lpuDeviceID
);
3964 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3965 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3966 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
3967 *lpuDeviceID
= lpDesc
->uDeviceID
;
3971 /**************************************************************************
3972 * waveOutMessage [MMSYSTEM.421]
3974 DWORD WINAPI
waveOutMessage(HWAVEOUT hWaveOut
, UINT uMessage
,
3975 DWORD dwParam1
, DWORD dwParam2
)
3977 LPWAVEOPENDESC lpDesc
;
3979 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3980 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3982 case WODM_GETNUMDEVS
:
3984 case WODM_GETVOLUME
:
3986 case WODM_GETPLAYBACKRATE
:
3987 case WODM_SETVOLUME
:
3989 case WODM_SETPLAYBACKRATE
:
3993 case WODM_UNPREPARE
:
3995 /* no argument conversion needed */
3998 return waveOutWrite(hWaveOut
, (LPWAVEHDR
)dwParam1
, dwParam2
);
3999 case WODM_GETDEVCAPS
:
4000 /* FIXME: UNICODE/ANSI? */
4001 return waveOutGetDevCapsA(hWaveOut
, (LPWAVEOUTCAPSA
)dwParam1
, dwParam2
);
4003 FIXME("can't handle WODM_OPEN, please report.\n");
4006 ERR("(0x%04x, 0x%04x, %08lx, %08lx): unhandled message\n",
4007 hWaveOut
, uMessage
, dwParam1
, dwParam2
);
4010 return wodMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4013 /**************************************************************************
4014 * waveOutMessage [MMSYSTEM.421]
4016 DWORD WINAPI
waveOutMessage16(HWAVEOUT16 hWaveOut
, UINT16 uMessage
,
4017 DWORD dwParam1
, DWORD dwParam2
)
4019 LPWAVEOPENDESC lpDesc
;
4021 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4022 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4024 case WODM_GETNUMDEVS
:
4025 case WODM_SETVOLUME
:
4027 case WODM_SETPLAYBACKRATE
:
4031 /* no argument conversion needed */
4034 return waveOutGetPosition16(hWaveOut
, (LPMMTIME16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4035 case WODM_GETVOLUME
:
4036 return waveOutGetVolume16(hWaveOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
4038 return waveOutGetPitch16(hWaveOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
4039 case WODM_GETPLAYBACKRATE
:
4040 return waveOutGetPlaybackRate16(hWaveOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
4041 case WODM_GETDEVCAPS
:
4042 return waveOutGetDevCaps16(hWaveOut
, (LPWAVEOUTCAPS16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4044 return waveOutPrepareHeader16(hWaveOut
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4045 case WODM_UNPREPARE
:
4046 return waveOutUnprepareHeader16(hWaveOut
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4048 return waveOutWrite16(hWaveOut
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4050 FIXME("can't handle WODM_OPEN, please report.\n");
4053 ERR("(0x%04x, 0x%04x, %08lx, %08lx): unhandled message\n",
4054 hWaveOut
, uMessage
, dwParam1
, dwParam2
);
4056 return wodMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4059 /**************************************************************************
4060 * waveInGetNumDevs [WINMM.151]
4062 UINT WINAPI
waveInGetNumDevs(void)
4064 return waveInGetNumDevs16();
4067 /**************************************************************************
4068 * waveInGetNumDevs [MMSYSTEM.501]
4070 UINT16 WINAPI
waveInGetNumDevs16(void)
4074 count
+= widMessage(0, WIDM_GETNUMDEVS
, 0L, 0L, 0L);
4075 TRACE("=> %u \n", count
);
4079 /**************************************************************************
4080 * waveInGetDevCapsA [WINMM.147]
4082 UINT WINAPI
waveInGetDevCapsW(UINT uDeviceID
, LPWAVEINCAPSW lpCaps
, UINT uSize
)
4085 UINT ret
= waveInGetDevCaps16(uDeviceID
, &wic16
, uSize
);
4087 lpCaps
->wMid
= wic16
.wMid
;
4088 lpCaps
->wPid
= wic16
.wPid
;
4089 lpCaps
->vDriverVersion
= wic16
.vDriverVersion
;
4090 lstrcpyAtoW(lpCaps
->szPname
, wic16
.szPname
);
4091 lpCaps
->dwFormats
= wic16
.dwFormats
;
4092 lpCaps
->wChannels
= wic16
.wChannels
;
4097 /**************************************************************************
4098 * waveInGetDevCapsA [WINMM.146]
4100 UINT WINAPI
waveInGetDevCapsA(UINT uDeviceID
, LPWAVEINCAPSA lpCaps
, UINT uSize
)
4103 UINT ret
= waveInGetDevCaps16(uDeviceID
, &wic16
, uSize
);
4105 lpCaps
->wMid
= wic16
.wMid
;
4106 lpCaps
->wPid
= wic16
.wPid
;
4107 lpCaps
->vDriverVersion
= wic16
.vDriverVersion
;
4108 strcpy(lpCaps
->szPname
, wic16
.szPname
);
4109 lpCaps
->dwFormats
= wic16
.dwFormats
;
4110 lpCaps
->wChannels
= wic16
.wChannels
;
4114 /**************************************************************************
4115 * waveInGetDevCaps [MMSYSTEM.502]
4117 UINT16 WINAPI
waveInGetDevCaps16(UINT16 uDeviceID
, LPWAVEINCAPS16 lpCaps
, UINT16 uSize
)
4119 return widMessage(uDeviceID
, WIDM_GETDEVCAPS
, 0L, (DWORD
)lpCaps
, uSize
);
4122 /**************************************************************************
4123 * waveInGetErrorTextA [WINMM.148]
4125 UINT WINAPI
waveInGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
4127 return WAVE_GetErrorText(uError
, lpText
, uSize
);
4130 /**************************************************************************
4131 * waveInGetErrorTextW [WINMM.149]
4133 UINT WINAPI
waveInGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
4135 LPSTR txt
= HeapAlloc(GetProcessHeap(), 0, uSize
);
4136 UINT ret
= WAVE_GetErrorText(uError
, txt
, uSize
);
4138 lstrcpyAtoW(lpText
, txt
);
4139 HeapFree(GetProcessHeap(), 0, txt
);
4143 /**************************************************************************
4144 * waveInGetErrorText [MMSYSTEM.503]
4146 UINT16 WINAPI
waveInGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
4148 return WAVE_GetErrorText(uError
, lpText
, uSize
);
4151 /**************************************************************************
4152 * waveInOpen [WINMM.154]
4154 UINT WINAPI
waveInOpen(HWAVEIN
* lphWaveIn
, UINT uDeviceID
,
4155 const LPWAVEFORMATEX lpFormat
, DWORD dwCallback
,
4156 DWORD dwInstance
, DWORD dwFlags
)
4159 UINT ret
= waveInOpen16(&hwin16
, uDeviceID
, lpFormat
, dwCallback
, dwInstance
,
4160 CALLBACK32CONV(dwFlags
));
4161 if (lphWaveIn
) *lphWaveIn
= hwin16
;
4165 /**************************************************************************
4166 * waveInOpen [MMSYSTEM.504]
4168 UINT16 WINAPI
waveInOpen16(HWAVEIN16
* lphWaveIn
, UINT16 uDeviceID
,
4169 const LPWAVEFORMATEX lpFormat
, DWORD dwCallback
,
4170 DWORD dwInstance
, DWORD dwFlags
)
4173 LPWAVEOPENDESC lpDesc
;
4175 BOOL bMapperFlg
= FALSE
;
4177 TRACE("(%p, %d, %p, %08lX, %08lX, %08lX);\n",
4178 lphWaveIn
, uDeviceID
, lpFormat
, dwCallback
, dwInstance
, dwFlags
);
4179 if (dwFlags
& WAVE_FORMAT_QUERY
)
4180 TRACE("WAVE_FORMAT_QUERY requested !\n");
4181 if (uDeviceID
== (UINT16
)WAVE_MAPPER
) {
4182 TRACE("WAVE_MAPPER mode requested !\n");
4186 if (lpFormat
== NULL
) return WAVERR_BADFORMAT
;
4187 hWaveIn
= USER_HEAP_ALLOC(sizeof(WAVEOPENDESC
));
4188 if (lphWaveIn
!= NULL
) *lphWaveIn
= hWaveIn
;
4189 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4190 if (lpDesc
== NULL
) return MMSYSERR_NOMEM
;
4191 lpDesc
->hWave
= hWaveIn
;
4192 lpDesc
->lpFormat
= (LPWAVEFORMAT
)lpFormat
;
4193 lpDesc
->dwCallBack
= dwCallback
;
4194 lpDesc
->dwInstance
= dwInstance
;
4195 while (uDeviceID
< MAXWAVEDRIVERS
) {
4196 dwRet
= widMessage(uDeviceID
, WIDM_OPEN
,
4197 lpDesc
->dwInstance
, (DWORD
)lpDesc
, 0L);
4198 if (dwRet
== MMSYSERR_NOERROR
) break;
4199 if (!bMapperFlg
) break;
4201 TRACE("WAVE_MAPPER mode ! try next driver...\n");
4203 lpDesc
->uDeviceID
= uDeviceID
;
4204 if (dwFlags
& WAVE_FORMAT_QUERY
) {
4205 TRACE("End of WAVE_FORMAT_QUERY !\n");
4206 dwRet
= waveInClose16(hWaveIn
);
4207 } else if (dwRet
!= MMSYSERR_NOERROR
) {
4208 USER_HEAP_FREE(hWaveIn
);
4209 if (lphWaveIn
) *lphWaveIn
= 0;
4215 /**************************************************************************
4216 * waveInClose [WINMM.145]
4218 UINT WINAPI
waveInClose(HWAVEIN hWaveIn
)
4220 return waveInClose16(hWaveIn
);
4223 /**************************************************************************
4224 * waveInClose [MMSYSTEM.505]
4226 UINT16 WINAPI
waveInClose16(HWAVEIN16 hWaveIn
)
4228 LPWAVEOPENDESC lpDesc
;
4231 TRACE("(%04X)\n", hWaveIn
);
4232 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4233 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4234 dwRet
= widMessage(lpDesc
->uDeviceID
, WIDM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
4235 USER_HEAP_FREE(hWaveIn
);
4239 /**************************************************************************
4240 * waveInPrepareHeader [WINMM.155]
4242 UINT WINAPI
waveInPrepareHeader(HWAVEIN hWaveIn
,
4243 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
4245 LPWAVEOPENDESC lpDesc
;
4247 TRACE("(%04X, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
4248 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4249 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4250 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4251 lpWaveInHdr
->lpNext
= NULL
;
4252 lpWaveInHdr
->dwBytesRecorded
= 0;
4253 lpWaveInHdr
->reserved
= (DWORD
)lpWaveInHdr
;
4255 return widMessage(lpDesc
->uDeviceID
, WIDM_PREPARE
, lpDesc
->dwInstance
,
4256 (DWORD
)lpWaveInHdr
, uSize
);
4259 /**************************************************************************
4260 * waveInPrepareHeader [MMSYSTEM.506]
4262 UINT16 WINAPI
waveInPrepareHeader16(HWAVEIN16 hWaveIn
,
4263 WAVEHDR
* /* SEGPTR */ _lpWaveInHdr
, UINT16 uSize
)
4265 LPWAVEOPENDESC lpDesc
;
4266 LPWAVEHDR lpWaveInHdr
= (LPWAVEHDR
)PTR_SEG_TO_LIN(_lpWaveInHdr
);
4269 TRACE("(%04X, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
4271 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4272 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4273 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4275 lpWaveInHdr
->lpNext
= NULL
;
4276 lpWaveInHdr
->dwBytesRecorded
= 0;
4278 lpWaveInHdr
->reserved
= (DWORD
)_lpWaveInHdr
;
4280 ret
= widMessage(lpDesc
->uDeviceID
, WIDM_PREPARE
, lpDesc
->dwInstance
,
4281 (DWORD
)lpWaveInHdr
, uSize
);
4285 /**************************************************************************
4286 * waveInUnprepareHeader [WINMM.159]
4288 UINT WINAPI
waveInUnprepareHeader(HWAVEIN hWaveIn
,
4289 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
4291 LPWAVEOPENDESC lpDesc
;
4293 TRACE("(%04X, %p, %u);\n",
4294 hWaveIn
, lpWaveInHdr
, uSize
);
4295 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4296 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4297 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4299 lpWaveInHdr
->lpNext
= NULL
;
4300 return widMessage(lpDesc
->uDeviceID
, WIDM_UNPREPARE
, lpDesc
->dwInstance
,
4301 (DWORD
)lpWaveInHdr
, uSize
);
4304 /**************************************************************************
4305 * waveInUnprepareHeader [MMSYSTEM.507]
4307 UINT16 WINAPI
waveInUnprepareHeader16(HWAVEIN16 hWaveIn
,
4308 WAVEHDR
* lpWaveInHdr
, UINT16 uSize
)
4310 LPWAVEOPENDESC lpDesc
;
4312 TRACE("(%04X, %p, %u);\n",
4313 hWaveIn
, lpWaveInHdr
, uSize
);
4314 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4315 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4316 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4318 return widMessage(lpDesc
->uDeviceID
, WIDM_UNPREPARE
, lpDesc
->dwInstance
,
4319 (DWORD
)lpWaveInHdr
, uSize
);
4322 /**************************************************************************
4323 * waveInAddBuffer [WINMM.144]
4325 UINT WINAPI
waveInAddBuffer(HWAVEIN hWaveIn
,
4326 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
4328 LPWAVEOPENDESC lpDesc
;
4330 TRACE("(%04X, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
4332 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4333 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4334 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4336 lpWaveInHdr
->lpNext
= NULL
;
4337 lpWaveInHdr
->dwBytesRecorded
= 0;
4339 return widMessage(lpDesc
->uDeviceID
, WIDM_ADDBUFFER
, lpDesc
->dwInstance
,
4340 (DWORD
)lpWaveInHdr
, uSize
);
4344 /**************************************************************************
4345 * waveInAddBuffer [MMSYSTEM.508]
4347 UINT16 WINAPI
waveInAddBuffer16(HWAVEIN16 hWaveIn
,
4348 WAVEHDR
* lpWaveInHdr
, UINT16 uSize
)
4350 LPWAVEOPENDESC lpDesc
;
4353 TRACE("(%04X, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
4355 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4356 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4357 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4358 lpWaveInHdr
->lpNext
= NULL
;
4359 lpWaveInHdr
->dwBytesRecorded
= 0;
4361 ret
= widMessage(lpDesc
->uDeviceID
, WIDM_ADDBUFFER
, lpDesc
->dwInstance
,
4362 (DWORD
)lpWaveInHdr
, uSize
);
4366 /**************************************************************************
4367 * waveInStart [WINMM.157]
4369 UINT WINAPI
waveInStart(HWAVEIN hWaveIn
)
4371 return waveInStart16(hWaveIn
);
4374 /**************************************************************************
4375 * waveInStart [MMSYSTEM.509]
4377 UINT16 WINAPI
waveInStart16(HWAVEIN16 hWaveIn
)
4379 LPWAVEOPENDESC lpDesc
;
4381 TRACE("(%04X)\n", hWaveIn
);
4382 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4383 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4384 return widMessage(lpDesc
->uDeviceID
, WIDM_START
, lpDesc
->dwInstance
, 0, 0);
4387 /**************************************************************************
4388 * waveInStop [WINMM.158]
4390 UINT WINAPI
waveInStop(HWAVEIN hWaveIn
)
4392 return waveInStop16(hWaveIn
);
4395 /**************************************************************************
4396 * waveInStop [MMSYSTEM.510]
4398 UINT16 WINAPI
waveInStop16(HWAVEIN16 hWaveIn
)
4400 LPWAVEOPENDESC lpDesc
;
4402 TRACE("(%04X)\n", hWaveIn
);
4403 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4404 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4405 return widMessage(lpDesc
->uDeviceID
, WIDM_STOP
, lpDesc
->dwInstance
, 0L, 0L);
4408 /**************************************************************************
4409 * waveInReset [WINMM.156]
4411 UINT WINAPI
waveInReset(HWAVEIN hWaveIn
)
4413 return waveInReset16(hWaveIn
);
4416 /**************************************************************************
4417 * waveInReset [MMSYSTEM.511]
4419 UINT16 WINAPI
waveInReset16(HWAVEIN16 hWaveIn
)
4421 LPWAVEOPENDESC lpDesc
;
4423 TRACE("(%04X)\n", hWaveIn
);
4424 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4425 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4426 return widMessage(lpDesc
->uDeviceID
, WIDM_RESET
, lpDesc
->dwInstance
, 0, 0);
4429 /**************************************************************************
4430 * waveInGetPosition [WINMM.152]
4432 UINT WINAPI
waveInGetPosition(HWAVEIN hWaveIn
, LPMMTIME lpTime
,
4438 mmt16
.wType
= lpTime
->wType
;
4439 ret
= waveInGetPosition16(hWaveIn
, &mmt16
, uSize
);
4441 MMSYSTEM_MMTIME16to32(lpTime
, &mmt16
);
4445 /**************************************************************************
4446 * waveInGetPosition [MMSYSTEM.512]
4448 UINT16 WINAPI
waveInGetPosition16(HWAVEIN16 hWaveIn
, LPMMTIME16 lpTime
,
4451 LPWAVEOPENDESC lpDesc
;
4453 TRACE("(%04X, %p, %u);\n", hWaveIn
, lpTime
, uSize
);
4454 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4455 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4456 return widMessage(lpDesc
->uDeviceID
, WIDM_GETPOS
, lpDesc
->dwInstance
,
4457 (DWORD
)lpTime
, (DWORD
)uSize
);
4460 /**************************************************************************
4461 * waveInGetID [WINMM.150]
4463 UINT WINAPI
waveInGetID(HWAVEIN hWaveIn
, UINT
* lpuDeviceID
)
4465 LPWAVEOPENDESC lpDesc
;
4467 TRACE("(%04x)\n", hWaveIn
);
4468 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
4469 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4470 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4471 *lpuDeviceID
= lpDesc
->uDeviceID
;
4475 /**************************************************************************
4476 * waveInGetID [MMSYSTEM.513]
4478 UINT16 WINAPI
waveInGetID16(HWAVEIN16 hWaveIn
, UINT16
* lpuDeviceID
)
4480 LPWAVEOPENDESC lpDesc
;
4482 TRACE("(%04x)\n", hWaveIn
);
4483 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
4484 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4485 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4486 *lpuDeviceID
= lpDesc
->uDeviceID
;
4490 /**************************************************************************
4491 * waveInMessage [WINMM.153]
4493 DWORD WINAPI
waveInMessage(HWAVEIN hWaveIn
, UINT uMessage
,
4494 DWORD dwParam1
, DWORD dwParam2
)
4496 LPWAVEOPENDESC lpDesc
;
4498 FIXME("(%04X, %04X, %08lX, %08lX)\n",
4499 hWaveIn
, uMessage
, dwParam1
, dwParam2
);
4501 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4502 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4505 FIXME("cannot handle WIDM_OPEN, please report.\n");
4507 case WIDM_GETNUMDEVS
:
4514 case WIDM_UNPREPARE
:
4515 case WIDM_ADDBUFFER
:
4516 /* no argument conversion needed */
4518 case WIDM_GETDEVCAPS
:
4519 /*FIXME: ANSI/UNICODE */
4520 return waveInGetDevCapsA(hWaveIn
, (LPWAVEINCAPSA
)dwParam1
, dwParam2
);
4522 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
4523 hWaveIn
, uMessage
, dwParam1
, dwParam2
);
4526 return widMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4529 /**************************************************************************
4530 * waveInMessage [MMSYSTEM.514]
4532 DWORD WINAPI
waveInMessage16(HWAVEIN16 hWaveIn
, UINT16 uMessage
,
4533 DWORD dwParam1
, DWORD dwParam2
)
4535 LPWAVEOPENDESC lpDesc
;
4537 FIXME("(%04X, %04X, %08lX, %08lX)\n",
4538 hWaveIn
, uMessage
, dwParam1
, dwParam2
);
4539 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4540 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4543 FIXME("cannot handle WIDM_OPEN, please report.\n");
4545 case WIDM_GETNUMDEVS
:
4550 /* no argument conversion needed */
4552 case WIDM_GETDEVCAPS
:
4553 return waveInGetDevCaps16(hWaveIn
, (LPWAVEINCAPS16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4555 return waveInGetPosition16(hWaveIn
, (LPMMTIME16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4557 return waveInPrepareHeader16(hWaveIn
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4558 case WIDM_UNPREPARE
:
4559 return waveInUnprepareHeader16(hWaveIn
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4560 case WIDM_ADDBUFFER
:
4561 return waveInAddBuffer16(hWaveIn
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4563 ERR("(%04x, %04x, %08lx, %08lx): unhandled message\n",
4564 hWaveIn
, uMessage
, dwParam1
, dwParam2
);
4567 return widMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4570 /**************************************************************************
4571 * DrvOpen [MMSYSTEM.1100]
4573 HDRVR16 WINAPI
DrvOpen(LPSTR lpDriverName
, LPSTR lpSectionName
, LPARAM lParam
)
4575 TRACE("('%s','%s', %08lX);\n", lpDriverName
, lpSectionName
, lParam
);
4577 return OpenDriver16(lpDriverName
, lpSectionName
, lParam
);
4580 /**************************************************************************
4581 * DrvClose [MMSYSTEM.1101]
4583 LRESULT WINAPI
DrvClose(HDRVR16 hDrv
, LPARAM lParam1
, LPARAM lParam2
)
4585 TRACE("(%04X, %08lX, %08lX);\n", hDrv
, lParam1
, lParam2
);
4587 return CloseDriver16(hDrv
, lParam1
, lParam2
);
4590 /**************************************************************************
4591 * DrvSendMessage [MMSYSTEM.1102]
4593 LRESULT WINAPI
DrvSendMessage(HDRVR16 hDrv
, WORD msg
, LPARAM lParam1
,
4596 return SendDriverMessage(hDrv
, msg
, lParam1
, lParam2
);
4599 /**************************************************************************
4600 * DrvGetModuleHandle [MMSYSTEM.1103]
4602 HANDLE16 WINAPI
DrvGetModuleHandle16(HDRVR16 hDrv
)
4604 return GetDriverModuleHandle16(hDrv
);
4607 /**************************************************************************
4608 * DrvDefDriverProc [MMSYSTEM.1104]
4610 LRESULT WINAPI
DrvDefDriverProc(DWORD dwDriverID
, HDRVR16 hDrv
, WORD wMsg
,
4611 DWORD dwParam1
, DWORD dwParam2
)
4613 /* FIXME : any mapping from 32 to 16 bit structure ? */
4614 return DefDriverProc16(dwDriverID
, hDrv
, wMsg
, dwParam1
, dwParam2
);
4617 /**************************************************************************
4618 * DefDriverProc [WINMM.5]
4620 LRESULT WINAPI
DefDriverProc(DWORD dwDriverIdentifier
, HDRVR hDrv
,
4621 UINT Msg
, LPARAM lParam1
, LPARAM lParam2
)
4637 /*#define USE_MM_TSK_WINE*/
4639 /**************************************************************************
4640 * mmTaskCreate [MMSYSTEM.900]
4642 * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
4643 * called upon creation with dwPmt as parameter.
4645 HINSTANCE16 WINAPI
mmTaskCreate16(SEGPTR spProc
, HINSTANCE16
*lphMmTask
, DWORD dwPmt
)
4647 DWORD showCmd
= 0x40002;
4654 TRACE("(%08lx, %p, %08lx);\n", spProc
, lphMmTask
, dwPmt
);
4655 /* This to work requires NE modules to be started with a binary command line
4656 * which is not currently the case. A patch exists but has never been committed.
4657 * A workaround would be to integrate code for mmtask.tsk into Wine, but
4658 * this requires tremendous work (starting with patching tools/build to
4659 * create NE executables (and not only DLLs) for builtins modules.
4662 FIXME("This is currently broken. It will fail\n");
4664 cmdline
= (LPSTR
)HeapAlloc(GetProcessHeap(), 0, 0x0d);
4666 *(LPDWORD
)(cmdline
+ 1) = (DWORD
)spProc
;
4667 *(LPDWORD
)(cmdline
+ 5) = dwPmt
;
4668 *(LPDWORD
)(cmdline
+ 9) = 0;
4670 sel1
= SELECTOR_AllocBlock(cmdline
, 0x0d, SEGMENT_DATA
, FALSE
, FALSE
);
4671 sel2
= SELECTOR_AllocBlock(&showCmd
, sizeof(showCmd
),
4672 SEGMENT_DATA
, FALSE
, FALSE
);
4674 lp
= (LOADPARAMS16
*)HeapAlloc(GetProcessHeap(), 0, sizeof(LOADPARAMS16
));
4675 lp
->hEnvironment
= 0;
4676 lp
->cmdLine
= PTR_SEG_OFF_TO_SEGPTR(sel1
, 0);
4677 lp
->showCmd
= PTR_SEG_OFF_TO_SEGPTR(sel2
, 0);
4680 #ifndef USE_MM_TSK_WINE
4681 handle
= LoadModule16("c:\\windows\\system\\mmtask.tsk", lp
);
4683 handle
= LoadModule16("mmtask.tsk", lp
);
4686 ret
= (handle
) ? 1 : 2;
4692 *lphMmTask
= handle
;
4694 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel2
, 0));
4695 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel1
, 0));
4697 HeapFree(GetProcessHeap(), 0, lp
);
4698 HeapFree(GetProcessHeap(), 0, cmdline
);
4700 TRACE("=> 0x%04x/%d\n", handle
, ret
);
4704 #ifdef USE_MM_TSK_WINE
4705 /* C equivalent to mmtask.tsk binary content */
4706 void mmTaskEntryPoint16(LPSTR cmdLine
, WORD di
, WORD si
)
4708 int len
= cmdLine
[0x80];
4711 void (*fpProc
)(DWORD
) = (void (*)(DWORD
))PTR_SEG_TO_LIN(*((DWORD
*)(cmdLine
+ 1)));
4712 DWORD dwPmt
= *((DWORD
*)(cmdLine
+ 5));
4715 InitTask16(); /* fixme: pmts / from context ? */
4718 if (SetMessageQueue16(0x40)) {
4720 if (HIWORD(fpProc
)) {
4722 /* EPP StackEnter16(); */
4734 /**************************************************************************
4735 * mmTaskBlock [MMSYSTEM.902]
4737 void WINAPI
mmTaskBlock16(HINSTANCE16 WINE_UNUSED hInst
)
4742 GetMessageA(&msg
, 0, 0, 0);
4744 TranslateMessage(&msg
);
4745 DispatchMessageA(&msg
);
4747 } while (msg
.message
< 0x3A0);
4750 /**************************************************************************
4751 * mmTaskSignal [MMSYSTEM.903]
4753 LRESULT WINAPI
mmTaskSignal16(HTASK16 ht
)
4755 TRACE("(%04x);\n", ht
);
4756 return Callout
.PostAppMessage16(ht
, WM_USER
, 0, 0);
4759 /**************************************************************************
4760 * mmTaskYield16 [MMSYSTEM.905]
4762 void WINAPI
mmTaskYield16(void)
4766 if (PeekMessageA(&msg
, 0, 0, 0, 0)) {
4771 DWORD WINAPI
GetProcessFlags(DWORD
);
4773 /**************************************************************************
4774 * mmThreadCreate [MMSYSTEM.1120]
4777 * Creates a MM thread, calling fpThreadAddr(dwPmt).
4779 * bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc
4780 * bit.1 set means to open a VxD for this thread (unsupported)
4782 LRESULT WINAPI
mmThreadCreate16(FARPROC16 fpThreadAddr
, LPHANDLE lpHndl
, DWORD dwPmt
, DWORD dwFlags
)
4787 TRACE("(%p, %p, %08lx, %08lx)!\n", fpThreadAddr
, lpHndl
, dwPmt
, dwFlags
);
4789 hndl
= GlobalAlloc16(sizeof(WINE_MMTHREAD
), GMEM_SHARE
|GMEM_ZEROINIT
);
4794 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
4797 /* force mmtask routines even if mmthread is required */
4798 /* this will work only if the patch about binary cmd line and NE tasks
4804 lpMMThd
->dwSignature
= WINE_MMTHREAD_CREATED
;
4805 lpMMThd
->dwCounter
= 0;
4806 lpMMThd
->hThread
= 0;
4807 lpMMThd
->dwThreadID
= 0;
4808 lpMMThd
->fpThread
= fpThreadAddr
;
4809 lpMMThd
->dwThreadPmt
= dwPmt
;
4810 lpMMThd
->dwSignalCount
= 0;
4811 lpMMThd
->hEvent
= 0;
4813 lpMMThd
->dwStatus
= 0;
4814 lpMMThd
->dwFlags
= dwFlags
;
4817 if ((dwFlags
& 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) {
4818 lpMMThd
->hEvent
= CreateEventA(0, 0, 1, 0);
4820 TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd
);
4821 if (lpMMThd
->dwFlags
& 2) {
4822 /* as long as we don't support MM VxD in wine, we don't need
4823 * to care about this flag
4825 /* FIXME("Don't know how to properly open VxD handles\n"); */
4826 /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */
4829 lpMMThd
->hThread
= CreateThread(0, 0, (LPTHREAD_START_ROUTINE
)WINE_mmThreadEntryPoint
,
4830 (LPVOID
)(DWORD
)hndl
, CREATE_SUSPENDED
, &lpMMThd
->dwThreadID
);
4831 if (lpMMThd
->hThread
== 0) {
4832 WARN("Couldn't create thread\n");
4833 /* clean-up(VxDhandle...); devicedirectio... */
4834 if (lpMMThd
->hEvent
!= 0)
4835 CloseHandle(lpMMThd
->hEvent
);
4838 TRACE("Got a nice thread hndl=0x%04x id=0x%08lx\n", lpMMThd
->hThread
, lpMMThd
->dwThreadID
);
4842 /* get WINE_mmThreadEntryPoint()
4843 * 2047 is its ordinal in mmsystem.spec
4845 FARPROC16 fp
= GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (SEGPTR
)2047);
4847 TRACE("farproc seg=0x%08lx lin=%p\n", (DWORD
)fp
, PTR_SEG_TO_LIN(fp
));
4849 ret
= (fp
== 0) ? 2 : mmTaskCreate16((DWORD
)fp
, 0, hndl
);
4853 if (lpMMThd
->hThread
&& !ResumeThread(lpMMThd
->hThread
))
4854 WARN("Couldn't resume thread\n");
4856 while (lpMMThd
->dwStatus
!= 0x10) { /* test also HIWORD of dwStatus */
4870 TRACE("ok => %ld\n", ret
);
4874 /**************************************************************************
4875 * mmThreadSignal [MMSYSTEM.1121]
4877 void WINAPI
mmThreadSignal16(HANDLE16 hndl
)
4879 TRACE("(%04x)!\n", hndl
);
4882 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
4884 lpMMThd
->dwCounter
++;
4885 if (lpMMThd
->hThread
!= 0) {
4886 InterlockedIncrement(&lpMMThd
->dwSignalCount
);
4887 SetEvent(lpMMThd
->hEvent
);
4889 mmTaskSignal16(lpMMThd
->hTask
);
4891 lpMMThd
->dwCounter
--;
4895 /**************************************************************************
4896 * MMSYSTEM_ThreadBlock [internal]
4898 static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD
* lpMMThd
)
4903 if (lpMMThd
->dwThreadID
!= GetCurrentThreadId())
4904 ERR("Not called by thread itself\n");
4907 ResetEvent(lpMMThd
->hEvent
);
4908 if (InterlockedDecrement(&lpMMThd
->dwSignalCount
) >= 0)
4910 InterlockedIncrement(&lpMMThd
->dwSignalCount
);
4914 ret
= MsgWaitForMultipleObjects(1, &lpMMThd
->hEvent
, FALSE
, INFINITE
, QS_ALLINPUT
);
4916 case WAIT_OBJECT_0
: /* Event */
4919 case WAIT_OBJECT_0
+ 1: /* Msg */
4921 if (Callout
.PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
)) {
4922 Callout
.TranslateMessage(&msg
);
4923 Callout
.DispatchMessageA(&msg
);
4927 WARN("S2.x unsupported ret val 0x%08lx\n", ret
);
4933 /**************************************************************************
4934 * mmThreadBlock [MMSYSTEM.1122]
4936 void WINAPI
mmThreadBlock16(HANDLE16 hndl
)
4938 TRACE("(%04x)!\n", hndl
);
4941 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
4943 if (lpMMThd
->hThread
!= 0) {
4944 SYSLEVEL_ReleaseWin16Lock();
4945 MMSYSTEM_ThreadBlock(lpMMThd
);
4946 SYSLEVEL_RestoreWin16Lock();
4948 mmTaskBlock16(lpMMThd
->hTask
);
4954 /**************************************************************************
4955 * mmThreadIsCurrent [MMSYSTEM.1123]
4957 BOOL16 WINAPI
mmThreadIsCurrent16(HANDLE16 hndl
)
4961 TRACE("(%04x)!\n", hndl
);
4963 if (hndl
&& mmThreadIsValid16(hndl
)) {
4964 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
4965 ret
= (GetCurrentThreadId() == lpMMThd
->dwThreadID
);
4967 /* FIXME: just a test */
4968 SYSLEVEL_ReleaseWin16Lock();
4969 SYSLEVEL_RestoreWin16Lock();
4972 TRACE("=> %d\n", ret
);
4976 /**************************************************************************
4977 * mmThreadIsValid [MMSYSTEM.1124]
4979 BOOL16 WINAPI
mmThreadIsValid16(HANDLE16 hndl
)
4983 TRACE("(%04x)!\n", hndl
);
4986 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
4988 if (!IsBadWritePtr(lpMMThd
, sizeof(WINE_MMTHREAD
)) &&
4989 lpMMThd
->dwSignature
== WINE_MMTHREAD_CREATED
&&
4990 IsTask16(lpMMThd
->hTask
)) {
4991 lpMMThd
->dwCounter
++;
4992 if (lpMMThd
->hThread
!= 0) {
4994 if (GetExitCodeThread(lpMMThd
->hThread
, &dwThreadRet
) &&
4995 dwThreadRet
== STATUS_PENDING
) {
5001 lpMMThd
->dwCounter
--;
5004 TRACE("=> %d\n", ret
);
5008 /**************************************************************************
5009 * mmThreadGetTask [MMSYSTEM.1125]
5011 HANDLE16 WINAPI
mmThreadGetTask16(HANDLE16 hndl
)
5015 TRACE("(%04x)\n", hndl
);
5017 if (mmThreadIsValid16(hndl
)) {
5018 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
5019 ret
= lpMMThd
->hTask
;
5024 /**************************************************************************
5025 * mmThreadGetTask [internal]
5027 void WINAPI
WINE_mmThreadEntryPoint(DWORD _pmt
)
5029 HANDLE16 hndl
= (HANDLE16
)_pmt
;
5030 WINE_MMTHREAD
* lpMMThd
= (WINE_MMTHREAD
*)PTR_SEG_OFF_TO_LIN(hndl
, 0);
5032 TRACE("(%04x %p)\n", hndl
, lpMMThd
);
5034 lpMMThd
->hTask
= LOWORD(GetCurrentTask());
5035 TRACE("[10-%08x] setting hTask to 0x%08x\n", lpMMThd
->hThread
, lpMMThd
->hTask
);
5036 lpMMThd
->dwStatus
= 0x10;
5037 MMSYSTEM_ThreadBlock(lpMMThd
);
5038 TRACE("[20-%08x]\n", lpMMThd
->hThread
);
5039 lpMMThd
->dwStatus
= 0x20;
5040 if (lpMMThd
->fpThread
) {
5041 /* it's not a WOW call back proc, but since the proc signature is the
5042 * same, why bother creating a new entry in Callbacks table ?
5044 WOWCallback16((DWORD
)lpMMThd
->fpThread
, lpMMThd
->dwThreadPmt
);
5046 lpMMThd
->dwStatus
= 0x30;
5047 TRACE("[30-%08x]\n", lpMMThd
->hThread
);
5048 while (lpMMThd
->dwCounter
) {
5052 TRACE("[XX-%08x]\n", lpMMThd
->hThread
);
5054 lpMMThd
->dwSignature
= WINE_MMTHREAD_DELETED
;
5055 /* close lpMMThread->hVxD directio */
5056 if (lpMMThd
->hEvent
)
5057 CloseHandle(lpMMThd
->hEvent
);
5062 typedef BOOL16 (WINAPI
*MMCPLCALLBACK
)(HWND
, LPCSTR
, LPCSTR
, LPCSTR
);
5064 /**************************************************************************
5065 * mmShowMMCPLPropertySheet [MMSYSTEM.1150]
5067 BOOL16 WINAPI
mmShowMMCPLPropertySheet16(HWND hWnd
, LPCSTR lpStrDevice
,
5068 LPCSTR lpStrTab
, LPCSTR lpStrTitle
)
5073 TRACE("(%04x \"%s\" \"%s\" \"%s\")\n", hWnd
, lpStrDevice
, lpStrTab
, lpStrTitle
);
5075 hndl
= LoadLibraryA("MMSYS.CPL");
5077 MMCPLCALLBACK fp
= (MMCPLCALLBACK
)GetProcAddress(hndl
, "ShowMMCPLPropertySheet");
5079 SYSLEVEL_ReleaseWin16Lock();
5080 ret
= (fp
)(hWnd
, lpStrDevice
, lpStrTab
, lpStrTitle
);
5081 SYSLEVEL_RestoreWin16Lock();
5089 /**************************************************************************
5090 * StackEnter & StackLeave [MMSYSTEM.32][MMSYSTEM.33]
5092 void WINAPI
StackEnterLeave16(void)
5095 /* mmsystem.dll from Win 95 does only this: so does Wine */