1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
6 * Copyright 1993 Martin Ayotte
11 * 98/9 added support for Win32 MCI
14 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
15 * and long term pointers to 16 bit space in here
22 #include <sys/ioctl.h>
26 #include "wine/winbase16.h"
31 #include "multimedia.h"
34 #include "selectors.h"
38 int mciInstalledCount
;
39 int mciInstalledListLen
;
40 LPSTR lpmciInstallNames
= NULL
;
42 struct WINE_MCIDRIVER mciDrv
[MAXMCIDRIVERS
];
44 UINT16 WINAPI
midiGetErrorText(UINT16 uError
, LPSTR lpText
, UINT16 uSize
);
45 static UINT16
waveGetErrorText(UINT16 uError
, LPSTR lpText
, UINT16 uSize
);
46 LONG WINAPI
DrvDefDriverProc(DWORD dwDevID
, HDRVR16 hDriv
, WORD wMsg
,
47 DWORD dwParam1
, DWORD dwParam2
);
49 #define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)])
50 #define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop))
52 /* The wDevID's returned by wine were originally in the range
53 * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices.
54 * Unfortunately, ms-windows uses wDevID of zero to indicate
55 * errors. Now, multimedia drivers must pass the wDevID through
56 * MCI_DevIDToIndex to get an index in that range. An
57 * arbitrary value, MCI_MAGIC is added to the wDevID seen
58 * by the windows programs.
61 #define MCI_MAGIC 0x0F00
63 /**************************************************************************
64 * MCI_GetProc32 [internal]
66 MCIPROC
MCI_GetProc(UINT16 uDevType
)
71 case MCI_DEVTYPE_CD_AUDIO
: proc
= MCICDAUDIO_DriverProc
; break;
72 case MCI_DEVTYPE_WAVEFORM_AUDIO
: proc
= MCIWAVE_DriverProc
; break;
73 case MCI_DEVTYPE_SEQUENCER
: proc
= MCIMIDI_DriverProc
; break;
74 case MCI_DEVTYPE_ANIMATION
: proc
= MCIANIM_DriverProc
; break;
75 case MCI_DEVTYPE_DIGITAL_VIDEO
: proc
= MCIAVI_DriverProc32
; break;
76 default: TRACE(mci
, "Unknown device type %u\n", uDevType
);
81 /**************************************************************************
82 * MCI_GetDevType [internal]
84 WORD
MCI_GetDevType(LPCSTR str
)
88 if (lstrcmpiA(str
, "CDAUDIO") == 0) {
89 uDevTyp
= MCI_DEVTYPE_CD_AUDIO
;
90 } else if (lstrcmpiA(str
, "WAVEAUDIO") == 0) {
91 uDevTyp
= MCI_DEVTYPE_WAVEFORM_AUDIO
;
92 } else if (lstrcmpiA(str
, "SEQUENCER") == 0) {
93 uDevTyp
= MCI_DEVTYPE_SEQUENCER
;
94 } else if (lstrcmpiA(str
, "ANIMATION1") == 0) {
95 uDevTyp
= MCI_DEVTYPE_ANIMATION
;
96 } else if (lstrcmpiA(str
, "AVIVIDEO") == 0) {
97 uDevTyp
= MCI_DEVTYPE_DIGITAL_VIDEO
;
99 TRACE(mci
, "str = %s => %u\n", str
, uDevTyp
);
103 /**************************************************************************
104 * MCI_GetDevTypeString [internal]
106 static LPCSTR
MCI_GetDevTypeString(WORD uDevTyp
)
108 LPCSTR str
= "??? MCI ???";
111 case MCI_DEVTYPE_CD_AUDIO
: str
= "CDAUDIO"; break;
112 case MCI_DEVTYPE_WAVEFORM_AUDIO
: str
= "WAVEAUDIO"; break;
113 case MCI_DEVTYPE_SEQUENCER
: str
= "SEQUENCER"; break;
114 case MCI_DEVTYPE_ANIMATION
: str
= "ANIMATION1"; break;
115 case MCI_DEVTYPE_DIGITAL_VIDEO
: str
= "AVIVIDEO"; break;
116 default: FIXME(mci
, "Incohenrent MCI definitions\n");
118 TRACE(mci
, "devType=%u => %s\n", uDevTyp
, str
);
122 /**************************************************************************
123 * MCI_DevIDToIndex [internal]
125 int MCI_DevIDToIndex(UINT16 wDevID
)
127 return wDevID
- MCI_MAGIC
;
130 /**************************************************************************
131 * MCI_FirstDevId [internal]
133 UINT16
MCI_FirstDevID(void)
138 /**************************************************************************
139 * MCI_NextDevId [internal]
141 UINT16
MCI_NextDevID(UINT16 wDevID
)
146 /**************************************************************************
147 * MCI_DevIDValid [internal]
149 BOOL
MCI_DevIDValid(UINT16 wDevID
)
151 return wDevID
>= MCI_MAGIC
&& wDevID
< (MCI_MAGIC
+ MAXMCIDRIVERS
);
154 /**************************************************************************
155 * MMSYSTEM_WEP [MMSYSTEM.1]
157 int WINAPI
MMSYSTEM_WEP(HINSTANCE16 hInstance
, WORD wDataSeg
,
158 WORD cbHeapSize
, LPSTR lpCmdLine
)
160 FIXME(mmsys
, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance
);
164 static void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16
, LPMMTIME mmt32
)
166 mmt16
->wType
= mmt32
->wType
;
167 /* layout of rest is the same for 32/16 */
168 memcpy(&(mmt32
->u
), &(mmt16
->u
), sizeof(mmt16
->u
));
171 static void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32
, LPMMTIME16 mmt16
)
173 mmt32
->wType
= mmt16
->wType
;
174 /* layout of rest is the same for 32/16,
175 * Note: mmt16->u is 2 bytes smaller than mmt32->u
177 memcpy(&(mmt16
->u
), &(mmt32
->u
), sizeof(mmt16
->u
));
180 static HANDLE PlaySound_hThread
= 0;
181 static HANDLE PlaySound_hPlayEvent
= 0;
182 static HANDLE PlaySound_hReadyEvent
= 0;
183 static HANDLE PlaySound_hMiddleEvent
= 0;
184 static BOOL PlaySound_Result
= FALSE
;
185 static int PlaySound_Stop
= FALSE
;
186 static int PlaySound_Playing
= FALSE
;
188 static LPCSTR PlaySound_pszSound
= NULL
;
189 static HMODULE PlaySound_hmod
= 0;
190 static DWORD PlaySound_fdwSound
= 0;
191 static int PlaySound_Loop
= FALSE
;
192 static int PlaySound_SearchMode
= 0; /* 1 - sndPlaySound search order
193 2 - PlaySound order */
195 static HMMIO16
get_mmioFromFile(LPCSTR lpszName
)
197 return mmioOpen16((LPSTR
)lpszName
, NULL
,
198 MMIO_ALLOCBUF
| MMIO_READ
| MMIO_DENYWRITE
);
201 static HMMIO16
get_mmioFromProfile(UINT uFlags
, LPCSTR lpszName
)
207 TRACE(mmsys
, "searching in SystemSound List !\n");
208 GetProfileStringA("Sounds", (LPSTR
)lpszName
, "", str
, sizeof(str
));
209 if (strlen(str
) == 0) {
210 if (uFlags
& SND_NODEFAULT
) return 0;
211 GetProfileStringA("Sounds", "Default", "", str
, sizeof(str
));
212 if (strlen(str
) == 0) return 0;
214 if ((ptr
= (LPSTR
)strchr(str
, ',')) != NULL
) *ptr
= '\0';
215 hmmio
= get_mmioFromFile(str
);
217 WARN(mmsys
, "can't find SystemSound='%s' !\n", str
);
223 static BOOL16 WINAPI
proc_PlaySound(LPCSTR lpszSoundName
, UINT uFlags
)
229 TRACE(mmsys
, "SoundName='%s' uFlags=%04X !\n", lpszSoundName
, uFlags
);
230 if (lpszSoundName
== NULL
) {
231 TRACE(mmsys
, "Stop !\n");
234 if (uFlags
& SND_MEMORY
) {
236 memset(&mminfo
, 0, sizeof(mminfo
));
237 mminfo
.fccIOProc
= FOURCC_MEM
;
238 mminfo
.pchBuffer
= (LPSTR
)lpszSoundName
;
239 mminfo
.cchBuffer
= -1;
240 TRACE(mmsys
, "Memory sound %p\n", lpszSoundName
);
241 hmmio
= mmioOpen16(NULL
, &mminfo
, MMIO_READ
);
244 if (uFlags
& SND_ALIAS
)
245 if ((hmmio
=get_mmioFromProfile(uFlags
, lpszSoundName
)) == 0)
248 if (uFlags
& SND_FILENAME
)
249 if ((hmmio
=get_mmioFromFile(lpszSoundName
)) == 0) return FALSE
;
251 if (PlaySound_SearchMode
== 1) {
252 PlaySound_SearchMode
= 0;
253 if ((hmmio
=get_mmioFromFile(lpszSoundName
)) == 0)
254 if ((hmmio
=get_mmioFromProfile(uFlags
, lpszSoundName
)) == 0)
258 if (PlaySound_SearchMode
== 2) {
259 PlaySound_SearchMode
= 0;
260 if ((hmmio
=get_mmioFromProfile(uFlags
| SND_NODEFAULT
, lpszSoundName
)) == 0)
261 if ((hmmio
=get_mmioFromFile(lpszSoundName
)) == 0)
262 if ((hmmio
=get_mmioFromProfile(uFlags
, lpszSoundName
)) == 0) return FALSE
;
266 if (mmioDescend(hmmio
, &ckMainRIFF
, NULL
, 0) == 0)
268 TRACE(mmsys
, "ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
269 (LPSTR
)&ckMainRIFF
.ckid
, (LPSTR
)&ckMainRIFF
.fccType
,
272 if ((ckMainRIFF
.ckid
== FOURCC_RIFF
) &&
273 (ckMainRIFF
.fccType
== mmioFOURCC('W', 'A', 'V', 'E'))) {
276 mmckInfo
.ckid
= mmioFOURCC('f', 'm', 't', ' ');
278 if (mmioDescend(hmmio
, &mmckInfo
, &ckMainRIFF
, MMIO_FINDCHUNK
) == 0) {
279 PCMWAVEFORMAT pcmWaveFormat
;
281 TRACE(mmsys
, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
282 (LPSTR
)&mmckInfo
.ckid
, (LPSTR
)&mmckInfo
.fccType
, mmckInfo
.cksize
);
284 if (mmioRead(hmmio
, (HPSTR
)&pcmWaveFormat
,
285 (long) sizeof(PCMWAVEFORMAT
)) == (long) sizeof(PCMWAVEFORMAT
)) {
286 TRACE(mmsys
, "wFormatTag=%04X !\n", pcmWaveFormat
.wf
.wFormatTag
);
287 TRACE(mmsys
, "nChannels=%d \n", pcmWaveFormat
.wf
.nChannels
);
288 TRACE(mmsys
, "nSamplesPerSec=%ld\n", pcmWaveFormat
.wf
.nSamplesPerSec
);
289 TRACE(mmsys
, "nAvgBytesPerSec=%ld\n", pcmWaveFormat
.wf
.nAvgBytesPerSec
);
290 TRACE(mmsys
, "nBlockAlign=%d \n", pcmWaveFormat
.wf
.nBlockAlign
);
291 TRACE(mmsys
, "wBitsPerSample=%u !\n", pcmWaveFormat
.wBitsPerSample
);
293 mmckInfo
.ckid
= mmioFOURCC('d', 'a', 't', 'a');
294 if (mmioDescend(hmmio
, &mmckInfo
, &ckMainRIFF
, MMIO_FINDCHUNK
) == 0) {
295 WAVEOPENDESC waveDesc
;
298 TRACE(mmsys
, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
299 (LPSTR
)&mmckInfo
.ckid
, (LPSTR
)&mmckInfo
.fccType
, mmckInfo
.cksize
);
301 pcmWaveFormat
.wf
.nAvgBytesPerSec
= pcmWaveFormat
.wf
.nSamplesPerSec
*
302 pcmWaveFormat
.wf
.nBlockAlign
;
304 waveDesc
.lpFormat
= (LPWAVEFORMAT
)&pcmWaveFormat
;
306 dwRet
= wodMessage(0, WODM_OPEN
, 0, (DWORD
)&waveDesc
, CALLBACK_NULL
);
307 if (dwRet
== MMSYSERR_NOERROR
) {
310 INT count
, bufsize
, left
= mmckInfo
.cksize
;
313 hData
= GlobalAlloc16(GMEM_MOVEABLE
, bufsize
);
314 waveHdr
.lpData
= (LPSTR
)GlobalLock16(hData
);
315 waveHdr
.dwBufferLength
= bufsize
;
317 waveHdr
.dwFlags
= 0L;
318 waveHdr
.dwLoops
= 0L;
320 dwRet
= wodMessage(0, WODM_PREPARE
, 0, (DWORD
)&waveHdr
, sizeof(WAVEHDR
));
321 if (dwRet
== MMSYSERR_NOERROR
) {
323 if (PlaySound_Stop
) {
324 PlaySound_Stop
= FALSE
;
325 PlaySound_Loop
= FALSE
;
328 if (bufsize
> left
) bufsize
= left
;
329 count
= mmioRead(hmmio
, waveHdr
.lpData
,bufsize
);
330 if (count
< 1) break;
332 waveHdr
.dwBufferLength
= count
;
333 /* waveHdr.dwBytesRecorded = count; */
334 /* FIXME: doesn't expect async ops */
335 wodMessage(0, WODM_WRITE
, 0, (DWORD
)&waveHdr
, sizeof(WAVEHDR
));
337 wodMessage(0, WODM_UNPREPARE
, 0, (DWORD
)&waveHdr
, sizeof(WAVEHDR
));
338 wodMessage(0, WODM_CLOSE
, 0, 0L, 0L);
342 WARN(mmsys
, "can't prepare WaveOut device !\n");
344 GlobalUnlock16(hData
);
351 } while (PlaySound_Loop
);
353 if (hmmio
!= 0) mmioClose(hmmio
, 0);
357 static DWORD WINAPI
PlaySound_Thread(LPVOID arg
)
362 PlaySound_Playing
= FALSE
;
363 SetEvent(PlaySound_hReadyEvent
);
364 res
= WaitForSingleObject(PlaySound_hPlayEvent
, INFINITE
);
365 ResetEvent(PlaySound_hReadyEvent
);
366 SetEvent(PlaySound_hMiddleEvent
);
367 if (res
== WAIT_FAILED
) ExitThread(2);
368 if (res
!= WAIT_OBJECT_0
) continue;
369 PlaySound_Playing
= TRUE
;
371 if ((PlaySound_fdwSound
& SND_RESOURCE
) == SND_RESOURCE
) {
376 if ((hRES
= FindResourceA(PlaySound_hmod
, PlaySound_pszSound
, "WAVE")) == 0) {
377 PlaySound_Result
= FALSE
;
380 if ((hGLOB
= LoadResource(PlaySound_hmod
, hRES
)) == 0) {
381 PlaySound_Result
= FALSE
;
384 if ((ptr
= LockResource(hGLOB
)) == NULL
) {
386 PlaySound_Result
= FALSE
;
389 PlaySound_Result
= proc_PlaySound(ptr
,
390 ((UINT16
)PlaySound_fdwSound
^ SND_RESOURCE
) | SND_MEMORY
);
394 PlaySound_Result
=proc_PlaySound(PlaySound_pszSound
, (UINT16
)PlaySound_fdwSound
);
398 /**************************************************************************
399 * PlaySoundA [WINMM.1]
401 BOOL WINAPI
PlaySoundA(LPCSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
403 static LPSTR StrDup
= NULL
;
405 TRACE(mmsys
, "pszSound='%p' hmod=%04X fdwSound=%08lX\n",
406 pszSound
, hmod
, fdwSound
);
408 if (PlaySound_hThread
== 0) { /* This is the first time they called us */
410 if ((PlaySound_hReadyEvent
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
)) == 0)
412 if ((PlaySound_hMiddleEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
)) == 0)
414 if ((PlaySound_hPlayEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
)) == 0)
416 if ((PlaySound_hThread
= CreateThread(NULL
, 0, PlaySound_Thread
, 0, 0, &id
)) == 0)
420 /* FIXME? I see no difference between SND_WAIT and SND_NOSTOP ! */
421 if ((fdwSound
& (SND_NOWAIT
| SND_NOSTOP
)) && PlaySound_Playing
)
424 /* Trying to stop if playing */
425 if (PlaySound_Playing
) PlaySound_Stop
= TRUE
;
427 /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave*/
428 if (WaitForSingleObject(PlaySound_hReadyEvent
, 1000*10) != WAIT_OBJECT_0
)
431 if (!pszSound
|| (fdwSound
& SND_PURGE
))
432 return FALSE
; /* We stoped playing so leaving */
434 if (PlaySound_SearchMode
!= 1) PlaySound_SearchMode
= 2;
435 if (!(fdwSound
& SND_ASYNC
)) {
436 if (fdwSound
& SND_LOOP
)
438 PlaySound_pszSound
= pszSound
;
439 PlaySound_hmod
= hmod
;
440 PlaySound_fdwSound
= fdwSound
;
441 PlaySound_Result
= FALSE
;
442 SetEvent(PlaySound_hPlayEvent
);
443 if (WaitForSingleObject(PlaySound_hMiddleEvent
, INFINITE
) != WAIT_OBJECT_0
)
445 if (WaitForSingleObject(PlaySound_hReadyEvent
, INFINITE
) != WAIT_OBJECT_0
)
447 return PlaySound_Result
;
449 PlaySound_hmod
= hmod
;
450 PlaySound_fdwSound
= fdwSound
;
451 PlaySound_Result
= FALSE
;
453 HeapFree(GetProcessHeap(), 0, StrDup
);
456 if (!((fdwSound
& SND_MEMORY
) || ((fdwSound
& SND_RESOURCE
) &&
457 !((DWORD
)pszSound
>> 16)) || !pszSound
)) {
458 StrDup
= HEAP_strdupA(GetProcessHeap(), 0,pszSound
);
459 PlaySound_pszSound
= StrDup
;
460 } else PlaySound_pszSound
= pszSound
;
461 PlaySound_Loop
= fdwSound
& SND_LOOP
;
462 SetEvent(PlaySound_hPlayEvent
);
463 ResetEvent(PlaySound_hMiddleEvent
);
469 /**************************************************************************
470 * PlaySoundW [WINMM.18]
472 BOOL WINAPI
PlaySoundW(LPCWSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
477 if (!((fdwSound
& SND_MEMORY
) || ((fdwSound
& SND_RESOURCE
) &&
478 !((DWORD
)pszSound
>> 16)) || !pszSound
)) {
479 pszSoundA
= HEAP_strdupWtoA(GetProcessHeap(), 0,pszSound
);
480 bSound
= PlaySoundA(pszSoundA
, hmod
, fdwSound
);
481 HeapFree(GetProcessHeap(), 0,pszSoundA
);
483 bSound
= PlaySoundA((LPCSTR
)pszSound
, hmod
, fdwSound
);
488 /**************************************************************************
489 * sndPlaySound [MMSYSTEM.2][WINMM135]
491 BOOL16 WINAPI
sndPlaySound(LPCSTR lpszSoundName
, UINT16 uFlags
)
493 PlaySound_SearchMode
= 1;
494 return PlaySoundA(lpszSoundName
, 0, uFlags
);
497 /**************************************************************************
498 * sndPlaySound [WINMM.136]
500 BOOL16 WINAPI
sndPlaySound32W(LPCWSTR lpszSoundName
, UINT16 uFlags
)
502 PlaySound_SearchMode
= 1;
503 return PlaySoundW(lpszSoundName
, 0, uFlags
);
506 /**************************************************************************
507 * mmsystemGetVersion [WINMM.134]
509 UINT WINAPI
mmsystemGetVersion()
511 return mmsystemGetVersion16();
514 /**************************************************************************
515 * mmsystemGetVersion [MMSYSTEM.5]
516 * return value borrowed from Win95 winmm.dll ;)
518 UINT16 WINAPI
mmsystemGetVersion16()
520 TRACE(mmsys
, "3.10 (Win95?)\n");
524 /**************************************************************************
525 * DriverProc [MMSYSTEM.6]
527 LRESULT WINAPI
DriverProc16(DWORD dwDevID
, HDRVR16 hDriv
, WORD wMsg
,
528 DWORD dwParam1
, DWORD dwParam2
)
530 return DrvDefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
533 /**************************************************************************
534 * DriverCallback [MMSYSTEM.31]
536 BOOL16 WINAPI
DriverCallback16(DWORD dwCallBack
, UINT16 uFlags
, HANDLE16 hDev
,
537 WORD wMsg
, DWORD dwUser
, DWORD dwParam1
, DWORD dwParam2
)
539 TRACE(mmsys
, "(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
540 dwCallBack
, uFlags
, hDev
, wMsg
, dwUser
, dwParam1
, dwParam2
);
542 switch (uFlags
& DCB_TYPEMASK
) {
544 TRACE(mmsys
, "CALLBACK_NULL !\n");
547 TRACE(mmsys
, "CALLBACK_WINDOW = %04lX handle = %04X!\n",
549 if (!IsWindow(dwCallBack
) || USER_HEAP_LIN_ADDR(hDev
) == NULL
)
552 PostMessageA((HWND16
)dwCallBack
, wMsg
, hDev
, dwParam1
);
555 TRACE(mmsys
, "CALLBACK_TASK !\n");
558 TRACE(mmsys
, "CALLBACK_FUNCTION !\n");
559 Callbacks
->CallDriverCallback((FARPROC16
)dwCallBack
,
561 dwParam1
, dwParam2
);
564 TRACE(mmsys
, "CALLBACK_FUNCTION !\n");
565 ((LPDRVCALLBACK
)dwCallBack
)(hDev
, wMsg
, dwUser
,
566 dwParam1
, dwParam2
);
569 WARN(mmsys
, "Unknown callback type\n");
575 /**************************************************************************
576 * Mixer devices. New to Win95
578 /**************************************************************************
579 * find out the real mixer ID depending on hmix (depends on dwFlags)
580 * FIXME: also fix dwInstance passing to mixMessage
582 static UINT
_get_mixerID_from_handle(HMIXEROBJ hmix
, DWORD dwFlags
)
584 /* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix
585 * accordingly. For now we always use mixerdevice 0.
590 /**************************************************************************
591 * mixerGetNumDevs [WINMM.108]
593 UINT WINAPI
mixerGetNumDevs()
595 return mixerGetNumDevs16();
598 /**************************************************************************
601 UINT16 WINAPI
mixerGetNumDevs16()
603 UINT16 count
= mixMessage(0, MXDM_GETNUMDEVS
, 0L, 0L, 0L);
605 TRACE(mmaux
,"mixerGetNumDevs returns %d\n",count
);
609 /**************************************************************************
610 * mixerGetDevCapsW [WINMM.102]
612 UINT WINAPI
mixerGetDevCapsW(UINT devid
, LPMIXERCAPSW mixcaps
,UINT size
)
615 UINT ret
= mixerGetDevCaps16(devid
, &mic16
, sizeof(mic16
));
617 mixcaps
->wMid
= mic16
.wMid
;
618 mixcaps
->wPid
= mic16
.wPid
;
619 mixcaps
->vDriverVersion
= mic16
.vDriverVersion
;
620 lstrcpyAtoW(mixcaps
->szPname
, mic16
.szPname
);
621 mixcaps
->fdwSupport
= mic16
.fdwSupport
;
622 mixcaps
->cDestinations
= mic16
.cDestinations
;
626 /**************************************************************************
627 * mixerGetDevCaps [WINMM.101]
629 UINT WINAPI
mixerGetDevCapsA(UINT devid
, LPMIXERCAPSA mixcaps
,UINT size
)
632 UINT ret
= mixerGetDevCaps16(devid
, &mic16
, sizeof(mic16
));
634 mixcaps
->wMid
= mic16
.wMid
;
635 mixcaps
->wPid
= mic16
.wPid
;
636 mixcaps
->vDriverVersion
= mic16
.vDriverVersion
;
637 strcpy(mixcaps
->szPname
, mic16
.szPname
);
638 mixcaps
->fdwSupport
= mic16
.fdwSupport
;
639 mixcaps
->cDestinations
= mic16
.cDestinations
;
643 /**************************************************************************
646 UINT16 WINAPI
mixerGetDevCaps16(UINT16 devid
, LPMIXERCAPS16 mixcaps
,UINT16 size
)
648 FIXME(mmsys
,"should this be a fixme?\n");
649 return mixMessage(devid
, MXDM_GETDEVCAPS
, 0L, (DWORD
)mixcaps
, (DWORD
)size
);
652 /**************************************************************************
653 * mixerOpen [WINMM.110]
655 UINT WINAPI
mixerOpen(LPHMIXER lphmix
,UINT uDeviceID
, DWORD dwCallback
,
656 DWORD dwInstance
, DWORD fdwOpen
)
661 FIXME(mmsys
,"(%p,%d,%08lx,%08lx,%08lx): semi stub?\n",
662 lphmix
,uDeviceID
, dwCallback
, dwInstance
, fdwOpen
);
663 ret
= mixerOpen16(&hmix16
,uDeviceID
, dwCallback
, dwInstance
,fdwOpen
);
664 if (lphmix
) *lphmix
= hmix16
;
668 /**************************************************************************
671 UINT16 WINAPI
mixerOpen16(LPHMIXER16 lphmix
,UINT16 uDeviceID
, DWORD dwCallback
,
672 DWORD dwInstance
, DWORD fdwOpen
)
675 LPMIXEROPENDESC lpmod
;
676 BOOL mapperflag
= (uDeviceID
==0);
679 TRACE(mmsys
,"(%p,%d,%08lx,%08lx,%08lx)\n",
680 lphmix
,uDeviceID
, dwCallback
, dwInstance
, fdwOpen
);
681 hmix
= USER_HEAP_ALLOC(sizeof(MIXEROPENDESC
));
682 if (lphmix
) *lphmix
= hmix
;
683 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
685 lpmod
->dwCallback
= dwCallback
;
686 lpmod
->dwInstance
= dwInstance
;
687 if (uDeviceID
>= MAXMIXERDRIVERS
)
689 while (uDeviceID
< MAXMIXERDRIVERS
) {
690 dwRet
=mixMessage(uDeviceID
, MXDM_OPEN
, dwInstance
, (DWORD
)lpmod
, fdwOpen
);
691 if (dwRet
== MMSYSERR_NOERROR
) break;
692 if (!mapperflag
) break;
695 lpmod
->uDeviceID
= uDeviceID
;
699 /**************************************************************************
700 * mixerClose [WINMM.98]
702 UINT WINAPI
mixerClose(HMIXER hmix
)
704 return mixerClose16(hmix
);
707 /**************************************************************************
710 UINT16 WINAPI
mixerClose16(HMIXER16 hmix
)
712 LPMIXEROPENDESC lpmod
;
714 FIXME(mmsys
,"(%04x): semi-stub?\n", hmix
);
715 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
716 return mixMessage(lpmod
->uDeviceID
, MXDM_CLOSE
, lpmod
->dwInstance
, 0L, 0L);
719 /**************************************************************************
720 * mixerGetID [WINMM.103]
722 UINT WINAPI
mixerGetID(HMIXEROBJ hmix
, LPUINT lpid
, DWORD fdwID
)
725 UINT ret
= mixerGetID16(hmix
, &xid
, fdwID
);
727 if (lpid
) *lpid
= xid
;
731 /**************************************************************************
734 UINT16 WINAPI
mixerGetID16(HMIXEROBJ16 hmix
,LPUINT16 lpid
,DWORD fdwID
)
736 FIXME(mmsys
,"(%04x): semi-stub\n",hmix
);
738 *lpid
= _get_mixerID_from_handle(hmix
,fdwID
);
739 return MMSYSERR_NOERROR
; /* FIXME: many error possibilities */
742 /**************************************************************************
743 * mixerGetControlDetailsA [WINMM.99]
745 UINT WINAPI
mixerGetControlDetailsA(HMIXEROBJ hmix
,LPMIXERCONTROLDETAILS lpmcd
,DWORD fdwDetails
)
747 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n",hmix
,lpmcd
,fdwDetails
);
748 return MMSYSERR_NOTENABLED
;
751 /**************************************************************************
752 * mixerGetControlDetailsW [WINMM.100]
754 UINT WINAPI
mixerGetControlDetailsW(HMIXEROBJ hmix
,LPMIXERCONTROLDETAILS lpmcd
,DWORD fdwDetails
)
756 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n", hmix
,lpmcd
,fdwDetails
);
757 return MMSYSERR_NOTENABLED
;
760 /**************************************************************************
761 * mixerGetControlDetails [MMSYSTEM.808]
763 UINT16 WINAPI
mixerGetControlDetails16(HMIXEROBJ16 hmix
,LPMIXERCONTROLDETAILS16 lpmcd
,DWORD fdwDetails
)
765 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n",hmix
,lpmcd
,fdwDetails
);
766 return MMSYSERR_NOTENABLED
;
769 /**************************************************************************
770 * mixerGetLineControlsA [WINMM.104]
772 UINT WINAPI
mixerGetLineControlsA(HMIXEROBJ hmix
,LPMIXERLINECONTROLSA lpmlc
,DWORD fdwControls
)
774 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n",hmix
,lpmlc
,fdwControls
);
775 return MMSYSERR_NOTENABLED
;
778 /**************************************************************************
779 * mixerGetLineControlsW [WINMM.105]
781 UINT WINAPI
mixerGetLineControlsW(HMIXEROBJ hmix
,LPMIXERLINECONTROLSW lpmlc
,DWORD fdwControls
)
783 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n",hmix
,lpmlc
,fdwControls
);
784 return MMSYSERR_NOTENABLED
;
787 /**************************************************************************
788 * mixerGetLineControls [MMSYSTEM.807]
790 UINT16 WINAPI
mixerGetLineControls16(HMIXEROBJ16 hmix
,LPMIXERLINECONTROLS16 lpmlc
,DWORD fdwControls
)
792 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n",hmix
,lpmlc
,fdwControls
);
793 return MMSYSERR_NOTENABLED
;
796 /**************************************************************************
797 * mixerGetLineInfoA [WINMM.106]
799 UINT WINAPI
mixerGetLineInfoA(HMIXEROBJ hmix
,LPMIXERLINEA lpml
,DWORD fdwInfo
)
804 ml16
.dwDestination
= lpml
->dwDestination
;
805 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n",hmix
,lpml
,fdwInfo
);
806 ret
= mixerGetLineInfo16(hmix
,&ml16
,fdwInfo
);
807 lpml
->cbStruct
= sizeof(*lpml
);
808 lpml
->dwSource
= ml16
.dwSource
;
809 lpml
->dwLineID
= ml16
.dwLineID
;
810 lpml
->fdwLine
= ml16
.fdwLine
;
811 lpml
->dwUser
= ml16
.dwUser
;
812 lpml
->dwComponentType
= ml16
.dwComponentType
;
813 lpml
->cChannels
= ml16
.cChannels
;
814 lpml
->cConnections
= ml16
.cConnections
;
815 lpml
->cControls
= ml16
.cControls
;
816 strcpy(lpml
->szShortName
, ml16
.szShortName
);
817 strcpy(lpml
->szName
, ml16
.szName
);
818 lpml
->Target
.dwType
= ml16
.Target
.dwType
;
819 lpml
->Target
.dwDeviceID
= ml16
.Target
.dwDeviceID
;
820 lpml
->Target
.wMid
= ml16
.Target
.wMid
;
821 lpml
->Target
.wPid
= ml16
.Target
.wPid
;
822 lpml
->Target
.vDriverVersion
= ml16
.Target
.vDriverVersion
;
823 strcpy(lpml
->Target
.szPname
, ml16
.Target
.szPname
);
827 /**************************************************************************
828 * mixerGetLineInfoW [WINMM.107]
830 UINT WINAPI
mixerGetLineInfoW(HMIXEROBJ hmix
, LPMIXERLINEW lpml
, DWORD fdwInfo
)
835 TRACE(mmsys
,"(%04x,%p,%08lx)\n", hmix
, lpml
, fdwInfo
);
837 if (lpml
== NULL
|| lpml
->cbStruct
!= sizeof(*lpml
))
838 return MMSYSERR_INVALPARAM
;
840 ml16
.cbStruct
= sizeof(ml16
);
841 ml16
.dwDestination
= lpml
->dwDestination
;
842 ml16
.dwSource
= lpml
->dwSource
;
843 ml16
.dwLineID
= lpml
->dwLineID
;
844 ml16
.dwUser
= lpml
->dwUser
;
845 ml16
.dwComponentType
= lpml
->dwComponentType
;
846 ml16
.cChannels
= lpml
->cChannels
;
847 ml16
.cConnections
= lpml
->cConnections
;
848 ml16
.cControls
= lpml
->cControls
;
850 ret
= mixerGetLineInfo16(hmix
, &ml16
, fdwInfo
);
852 lpml
->dwSource
= ml16
.dwSource
;
853 lpml
->dwLineID
= ml16
.dwLineID
;
854 lpml
->fdwLine
= ml16
.fdwLine
;
855 lpml
->dwUser
= ml16
.dwUser
;
856 lpml
->dwComponentType
= ml16
.dwComponentType
;
857 lpml
->cChannels
= ml16
.cChannels
;
858 lpml
->cConnections
= ml16
.cConnections
;
859 lpml
->cControls
= ml16
.cControls
;
860 lstrcpyAtoW(lpml
->szShortName
, ml16
.szShortName
);
861 lstrcpyAtoW(lpml
->szName
, ml16
.szName
);
862 lpml
->Target
.dwType
= ml16
.Target
.dwType
;
863 lpml
->Target
.dwDeviceID
= ml16
.Target
.dwDeviceID
;
864 lpml
->Target
.wMid
= ml16
.Target
.wMid
;
865 lpml
->Target
.wPid
= ml16
.Target
.wPid
;
866 lpml
->Target
.vDriverVersion
= ml16
.Target
.vDriverVersion
;
867 /*lstrcpyAtoW(lpml->Target.szPname, ml16.Target.szPname);*/
871 /**************************************************************************
872 * mixerGetLineInfo [MMSYSTEM.805]
874 UINT16 WINAPI
mixerGetLineInfo16(HMIXEROBJ16 hmix
, LPMIXERLINE16 lpml
, DWORD fdwInfo
)
876 UINT16 devid
= _get_mixerID_from_handle(hmix
, fdwInfo
);
878 FIXME(mmsys
, "(%04x, %p[line %08lx], %08lx)\n",
879 hmix
, lpml
, lpml
->dwDestination
, fdwInfo
);
880 return mixMessage(devid
, MXDM_GETLINEINFO
, 0, (DWORD
)lpml
, fdwInfo
);
883 /**************************************************************************
884 * mixerSetControlDetails [WINMM.111]
886 UINT WINAPI
mixerSetControlDetails(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcd
, DWORD fdwDetails
)
888 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n", hmix
, lpmcd
, fdwDetails
);
889 return MMSYSERR_NOTENABLED
;
892 /**************************************************************************
893 * mixerSetControlDetails [MMSYSTEM.809]
895 UINT16 WINAPI
mixerSetControlDetails16(HMIXEROBJ16 hmix
, LPMIXERCONTROLDETAILS16 lpmcd
, DWORD fdwDetails
)
897 FIXME(mmsys
,"(%04x,%p,%08lx): stub!\n", hmix
, lpmcd
, fdwDetails
);
898 return MMSYSERR_NOTENABLED
;
901 /**************************************************************************
902 * mixerMessage [WINMM.109]
904 UINT WINAPI
mixerMessage(HMIXER hmix
,UINT uMsg
, DWORD dwParam1
, DWORD dwParam2
)
906 LPMIXEROPENDESC lpmod
;
909 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
911 uDeviceID
= lpmod
->uDeviceID
;
914 FIXME(mmsys
,"(%04lx,%d,%08lx,%08lx): semi-stub?\n",
915 (DWORD
)hmix
,uMsg
, dwParam1
, dwParam2
);
916 return mixMessage(uDeviceID
,uMsg
, 0L, dwParam1
, dwParam2
);
919 /**************************************************************************
920 * mixerMessage [MMSYSTEM.804]
922 UINT16 WINAPI
mixerMessage16(HMIXER16 hmix
,UINT16 uMsg
, DWORD dwParam1
, DWORD dwParam2
)
924 LPMIXEROPENDESC lpmod
;
927 lpmod
= (LPMIXEROPENDESC
)USER_HEAP_LIN_ADDR(hmix
);
928 uDeviceID
= (lpmod
) ? lpmod
->uDeviceID
: 0;
929 FIXME(mmsys
,"(%04x,%d,%08lx,%08lx) - semi-stub?\n",
930 hmix
,uMsg
, dwParam1
, dwParam2
);
931 return mixMessage(uDeviceID
,uMsg
, 0L, dwParam1
, dwParam2
);
934 /**************************************************************************
935 * auxGetNumDevs [WINMM.22]
937 UINT WINAPI
auxGetNumDevs()
939 return auxGetNumDevs16();
942 /**************************************************************************
943 * auxGetNumDevs [MMSYSTEM.350]
945 UINT16 WINAPI
auxGetNumDevs16()
950 count
= auxMessage(0, AUXDM_GETNUMDEVS
, 0L, 0L, 0L);
951 TRACE(mmsys
, "=> %u\n", count
);
955 /**************************************************************************
956 * auxGetDevCaps [WINMM.20]
958 UINT WINAPI
auxGetDevCapsW(UINT uDeviceID
, LPAUXCAPSW lpCaps
,UINT uSize
)
961 UINT ret
= auxGetDevCaps16(uDeviceID
, &ac16
, sizeof(ac16
));
963 lpCaps
->wMid
= ac16
.wMid
;
964 lpCaps
->wPid
= ac16
.wPid
;
965 lpCaps
->vDriverVersion
= ac16
.vDriverVersion
;
966 lstrcpyAtoW(lpCaps
->szPname
,ac16
.szPname
);
967 lpCaps
->wTechnology
= ac16
.wTechnology
;
968 lpCaps
->dwSupport
= ac16
.dwSupport
;
972 /**************************************************************************
973 * auxGetDevCaps [WINMM.21]
975 UINT WINAPI
auxGetDevCapsA(UINT uDeviceID
, LPAUXCAPSA lpCaps
,UINT uSize
)
978 UINT ret
= auxGetDevCaps16(uDeviceID
, &ac16
, sizeof(ac16
));
980 lpCaps
->wMid
= ac16
.wMid
;
981 lpCaps
->wPid
= ac16
.wPid
;
982 lpCaps
->vDriverVersion
= ac16
.vDriverVersion
;
983 strcpy(lpCaps
->szPname
,ac16
.szPname
);
984 lpCaps
->wTechnology
= ac16
.wTechnology
;
985 lpCaps
->dwSupport
= ac16
.dwSupport
;
989 /**************************************************************************
990 * auxGetDevCaps [MMSYSTEM.351]
992 UINT16 WINAPI
auxGetDevCaps16(UINT16 uDeviceID
, LPAUXCAPS16 lpCaps
, UINT16 uSize
)
994 TRACE(mmsys
, "(%04X, %p, %d) !\n", uDeviceID
, lpCaps
, uSize
);
996 return auxMessage(uDeviceID
, AUXDM_GETDEVCAPS
,
997 0L, (DWORD
)lpCaps
, (DWORD
)uSize
);
1000 /**************************************************************************
1001 * auxGetVolume [WINM.23]
1003 UINT WINAPI
auxGetVolume(UINT uDeviceID
, DWORD
* lpdwVolume
)
1005 return auxGetVolume16(uDeviceID
, lpdwVolume
);
1008 /**************************************************************************
1009 * auxGetVolume [MMSYSTEM.352]
1011 UINT16 WINAPI
auxGetVolume16(UINT16 uDeviceID
, DWORD
* lpdwVolume
)
1013 TRACE(mmsys
, "(%04X, %p) !\n", uDeviceID
, lpdwVolume
);
1015 return auxMessage(uDeviceID
, AUXDM_GETVOLUME
, 0L, (DWORD
)lpdwVolume
, 0L);
1018 /**************************************************************************
1019 * auxSetVolume [WINMM.25]
1021 UINT WINAPI
auxSetVolume(UINT uDeviceID
, DWORD dwVolume
)
1023 return auxSetVolume16(uDeviceID
, dwVolume
);
1026 /**************************************************************************
1027 * auxSetVolume [MMSYSTEM.353]
1029 UINT16 WINAPI
auxSetVolume16(UINT16 uDeviceID
, DWORD dwVolume
)
1031 TRACE(mmsys
, "(%04X, %08lX) !\n", uDeviceID
, dwVolume
);
1033 return auxMessage(uDeviceID
, AUXDM_SETVOLUME
, 0L, dwVolume
, 0L);
1036 /**************************************************************************
1037 * auxOutMessage [MMSYSTEM.354]
1039 DWORD WINAPI
auxOutMessage(UINT uDeviceID
,UINT uMessage
, DWORD dw1
, DWORD dw2
)
1042 case AUXDM_GETNUMDEVS
:
1043 case AUXDM_GETVOLUME
:
1044 case AUXDM_SETVOLUME
:
1045 /* no argument conversion needed */
1047 case AUXDM_GETDEVCAPS
:
1048 return auxGetDevCapsA(uDeviceID
, (LPAUXCAPSA
)dw1
, dw2
);
1050 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1051 uDeviceID
,uMessage
, dw1
, dw2
);
1054 return auxMessage(uDeviceID
,uMessage
, 0L, dw1
, dw2
);
1057 /**************************************************************************
1058 * auxOutMessage [MMSYSTEM.354]
1060 DWORD WINAPI
auxOutMessage16(UINT16 uDeviceID
, UINT16 uMessage
, DWORD dw1
, DWORD dw2
)
1062 TRACE(mmsys
, "(%04X, %04X, %08lX, %08lX)\n", uDeviceID
, uMessage
, dw1
, dw2
);
1065 case AUXDM_GETNUMDEVS
:
1066 case AUXDM_SETVOLUME
:
1067 /* no argument conversion needed */
1069 case AUXDM_GETVOLUME
:
1070 return auxGetVolume16(uDeviceID
, (LPDWORD
)PTR_SEG_TO_LIN(dw1
));
1071 case AUXDM_GETDEVCAPS
:
1072 return auxGetDevCaps16(uDeviceID
, (LPAUXCAPS16
)PTR_SEG_TO_LIN(dw1
), dw2
);
1074 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1075 uDeviceID
,uMessage
, dw1
, dw2
);
1078 return auxMessage(uDeviceID
, uMessage
, 0L, dw1
, dw2
);
1081 /**************************************************************************
1082 * mciGetErrorStringW [WINMM.46]
1084 BOOL WINAPI
mciGetErrorStringW(DWORD wError
, LPWSTR lpstrBuffer
,UINT uLength
)
1086 LPSTR bufstr
= HeapAlloc(GetProcessHeap(), 0,uLength
);
1087 BOOL ret
= mciGetErrorStringA(wError
,bufstr
,uLength
);
1089 lstrcpyAtoW(lpstrBuffer
,bufstr
);
1090 HeapFree(GetProcessHeap(), 0,bufstr
);
1094 /**************************************************************************
1095 * mciGetErrorStringA [WINMM.45]
1097 BOOL WINAPI
mciGetErrorStringA(DWORD wError
, LPSTR lpstrBuffer
,UINT uLength
)
1099 return mciGetErrorString16(wError
, lpstrBuffer
,uLength
);
1102 /**************************************************************************
1103 * mciGetErrorString [MMSYSTEM.706]
1105 BOOL16 WINAPI
mciGetErrorString16(DWORD wError
, LPSTR lpstrBuffer
,UINT16 uLength
)
1109 TRACE(mmsys
, "(%08lX, %p, %d);\n", wError
, lpstrBuffer
, uLength
);
1111 if ((lpstrBuffer
== NULL
) || (uLength
< 1))
1113 lpstrBuffer
[0] = '\0';
1117 msgptr
= "The specified command has been executed.";
1119 case MCIERR_INVALID_DEVICE_ID
:
1120 msgptr
= "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
1122 case MCIERR_UNRECOGNIZED_KEYWORD
:
1123 msgptr
= "The driver cannot recognize the specified command parameter.";
1125 case MCIERR_UNRECOGNIZED_COMMAND
:
1126 msgptr
= "The driver cannot recognize the specified command.";
1128 case MCIERR_HARDWARE
:
1129 msgptr
= "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
1131 case MCIERR_INVALID_DEVICE_NAME
:
1132 msgptr
= "The specified device is not open or is not recognized by MCI.";
1134 case MCIERR_OUT_OF_MEMORY
:
1135 msgptr
= "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
1137 case MCIERR_DEVICE_OPEN
:
1138 msgptr
= "The device name is already being used as an alias by this application. Use a unique alias.";
1140 case MCIERR_CANNOT_LOAD_DRIVER
:
1141 msgptr
= "There is an undetectable problem in loading the specified device driver.";
1143 case MCIERR_MISSING_COMMAND_STRING
:
1144 msgptr
= "No command was specified.";
1146 case MCIERR_PARAM_OVERFLOW
:
1147 msgptr
= "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
1149 case MCIERR_MISSING_STRING_ARGUMENT
:
1150 msgptr
= "The specified command requires a character-string parameter. Please provide one.";
1152 case MCIERR_BAD_INTEGER
:
1153 msgptr
= "The specified integer is invalid for this command.";
1155 case MCIERR_PARSER_INTERNAL
:
1156 msgptr
= "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
1158 case MCIERR_DRIVER_INTERNAL
:
1159 msgptr
= "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
1161 case MCIERR_MISSING_PARAMETER
:
1162 msgptr
= "The specified command requires a parameter. Please supply one.";
1164 case MCIERR_UNSUPPORTED_FUNCTION
:
1165 msgptr
= "The MCI device you are using does not support the specified command.";
1167 case MCIERR_FILE_NOT_FOUND
:
1168 msgptr
= "Cannot find the specified file. Make sure the path and filename are correct.";
1170 case MCIERR_DEVICE_NOT_READY
:
1171 msgptr
= "The device driver is not ready.";
1173 case MCIERR_INTERNAL
:
1174 msgptr
= "A problem occurred in initializing MCI. Try restarting Windows.";
1177 msgptr
= "There is a problem with the device driver. The driver has closed. Cannot access error.";
1179 case MCIERR_CANNOT_USE_ALL
:
1180 msgptr
= "Cannot use 'all' as the device name with the specified command.";
1182 case MCIERR_MULTIPLE
:
1183 msgptr
= "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
1185 case MCIERR_EXTENSION_NOT_FOUND
:
1186 msgptr
= "Cannot determine the device type from the given filename extension.";
1188 case MCIERR_OUTOFRANGE
:
1189 msgptr
= "The specified parameter is out of range for the specified command.";
1191 case MCIERR_FLAGS_NOT_COMPATIBLE
:
1192 msgptr
= "The specified parameters cannot be used together.";
1194 case MCIERR_FILE_NOT_SAVED
:
1195 msgptr
= "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
1197 case MCIERR_DEVICE_TYPE_REQUIRED
:
1198 msgptr
= "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
1200 case MCIERR_DEVICE_LOCKED
:
1201 msgptr
= "The specified device is now being closed. Wait a few seconds, and then try again.";
1203 case MCIERR_DUPLICATE_ALIAS
:
1204 msgptr
= "The specified alias is already being used in this application. Use a unique alias.";
1206 case MCIERR_BAD_CONSTANT
:
1207 msgptr
= "The specified parameter is invalid for this command.";
1209 case MCIERR_MUST_USE_SHAREABLE
:
1210 msgptr
= "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
1212 case MCIERR_MISSING_DEVICE_NAME
:
1213 msgptr
= "The specified command requires an alias, file, driver, or device name. Please supply one.";
1215 case MCIERR_BAD_TIME_FORMAT
:
1216 msgptr
= "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
1218 case MCIERR_NO_CLOSING_QUOTE
:
1219 msgptr
= "A closing double-quotation mark is missing from the parameter value. Please supply one.";
1221 case MCIERR_DUPLICATE_FLAGS
:
1222 msgptr
= "A parameter or value was specified twice. Only specify it once.";
1224 case MCIERR_INVALID_FILE
:
1225 msgptr
= "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
1227 case MCIERR_NULL_PARAMETER_BLOCK
:
1228 msgptr
= "A null parameter block was passed to MCI.";
1230 case MCIERR_UNNAMED_RESOURCE
:
1231 msgptr
= "Cannot save an unnamed file. Supply a filename.";
1233 case MCIERR_NEW_REQUIRES_ALIAS
:
1234 msgptr
= "You must specify an alias when using the 'new' parameter.";
1236 case MCIERR_NOTIFY_ON_AUTO_OPEN
:
1237 msgptr
= "Cannot use the 'notify' flag with auto-opened devices.";
1239 case MCIERR_NO_ELEMENT_ALLOWED
:
1240 msgptr
= "Cannot use a filename with the specified device.";
1242 case MCIERR_NONAPPLICABLE_FUNCTION
:
1243 msgptr
= "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
1245 case MCIERR_ILLEGAL_FOR_AUTO_OPEN
:
1246 msgptr
= "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
1248 case MCIERR_FILENAME_REQUIRED
:
1249 msgptr
= "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
1251 case MCIERR_EXTRA_CHARACTERS
:
1252 msgptr
= "Cannot specify extra characters after a string enclosed in quotation marks.";
1254 case MCIERR_DEVICE_NOT_INSTALLED
:
1255 msgptr
= "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
1258 msgptr
= "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
1261 msgptr
= "Cannot access the specified file or MCI device because the application cannot change directories.";
1263 case MCIERR_SET_DRIVE
:
1264 msgptr
= "Cannot access specified file or MCI device because the application cannot change drives.";
1266 case MCIERR_DEVICE_LENGTH
:
1267 msgptr
= "Specify a device or driver name that is less than 79 characters.";
1269 case MCIERR_DEVICE_ORD_LENGTH
:
1270 msgptr
= "Specify a device or driver name that is less than 69 characters.";
1272 case MCIERR_NO_INTEGER
:
1273 msgptr
= "The specified command requires an integer parameter. Please provide one.";
1275 case MCIERR_WAVE_OUTPUTSINUSE
:
1276 msgptr
= "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again.";
1278 case MCIERR_WAVE_SETOUTPUTINUSE
:
1279 msgptr
= "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again.";
1281 case MCIERR_WAVE_INPUTSINUSE
:
1282 msgptr
= "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again.";
1284 case MCIERR_WAVE_SETINPUTINUSE
:
1285 msgptr
= "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
1287 case MCIERR_WAVE_OUTPUTUNSPECIFIED
:
1288 msgptr
= "Any compatible waveform playback device may be used.";
1290 case MCIERR_WAVE_INPUTUNSPECIFIED
:
1291 msgptr
= "Any compatible waveform recording device may be used.";
1293 case MCIERR_WAVE_OUTPUTSUNSUITABLE
:
1294 msgptr
= "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
1296 case MCIERR_WAVE_SETOUTPUTUNSUITABLE
:
1297 msgptr
= "The device you are trying to play to cannot recognize the current file format.";
1299 case MCIERR_WAVE_INPUTSUNSUITABLE
:
1300 msgptr
= "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
1302 case MCIERR_WAVE_SETINPUTUNSUITABLE
:
1303 msgptr
= "The device you are trying to record from cannot recognize the current file format.";
1305 case MCIERR_NO_WINDOW
:
1306 msgptr
= "There is no display window.";
1308 case MCIERR_CREATEWINDOW
:
1309 msgptr
= "Could not create or use window.";
1311 case MCIERR_FILE_READ
:
1312 msgptr
= "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
1314 case MCIERR_FILE_WRITE
:
1315 msgptr
= "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
1317 case MCIERR_SEQ_DIV_INCOMPATIBLE
:
1318 msgptr
= "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
1320 case MCIERR_SEQ_NOMIDIPRESENT
:
1321 msgptr
= "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
1323 case MCIERR_SEQ_PORT_INUSE
:
1324 msgptr
= "The specified MIDI port is already in use. Wait until it is free; the try again.";
1326 case MCIERR_SEQ_PORT_MAPNODEVICE
:
1327 msgptr
= "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup.";
1329 case MCIERR_SEQ_PORT_MISCERROR
:
1330 msgptr
= "An error occurred with the specified port.";
1332 case MCIERR_SEQ_PORT_NONEXISTENT
:
1333 msgptr
= "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
1335 case MCIERR_SEQ_PORTUNSPECIFIED
:
1336 msgptr
= "The system doesnot have a current MIDI port specified.";
1338 case MCIERR_SEQ_TIMER
:
1339 msgptr
= "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
1344 msg# 514 : videodisc
1349 msg# 519 : animation
1350 msg# 520 : digitalvideo
1352 msg# 522 : waveaudio
1353 msg# 523 : sequencer
1354 msg# 524 : not ready
1357 msg# 527 : recording
1363 msg# 533 : milliseconds
1370 msg# 540 : smpte 30 drop
1376 msgptr
= "Unknown MCI Error !\n";
1379 lstrcpynA(lpstrBuffer
, msgptr
, uLength
);
1380 TRACE(mmsys
, "msg = %s;\n", msgptr
);
1384 /**************************************************************************
1385 * mciDriverNotify [MMSYSTEM.711]
1387 BOOL16 WINAPI
mciDriverNotify16(HWND16 hWndCallBack
, UINT16 wDevID
, UINT16 wStatus
)
1389 TRACE(mmsys
, "(%04X, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
1391 if (!IsWindow(hWndCallBack
)) {
1392 WARN(mmsys
, "bad hWnd for call back\n");
1395 TRACE(mmsys
, "before PostMessage\n");
1396 PostMessageA(hWndCallBack
, MM_MCINOTIFY
, wStatus
, wDevID
);
1400 /**************************************************************************
1401 * mciDriverNotify32 [WINMM.36]
1403 BOOL WINAPI
mciDriverNotify(HWND hWndCallBack
, UINT wDevID
, UINT wStatus
)
1405 FIXME(mmsys
, "(%08X, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
1407 if (!IsWindow(hWndCallBack
)) {
1408 WARN(mmsys
, "bad hWnd for call back\n");
1411 TRACE(mmsys
, "before PostMessage\n");
1412 PostMessageA(hWndCallBack
, MM_MCINOTIFY
, wStatus
, wDevID
);
1416 /**************************************************************************
1417 * mciGetDriverData [MMSYSTEM.708]
1419 DWORD WINAPI
mciGetDriverData16(HDRVR16 hdrv
)
1421 return mciGetDriverData(hdrv
);
1424 /**************************************************************************
1425 * mciGetDriverData [WINMM.44]
1427 DWORD WINAPI
mciGetDriverData(HDRVR hdrv
)
1429 TRACE(mmsys
,"(%04x)\n", hdrv
);
1430 if (!MCI_DevIDValid(hdrv
) || MCI_GetDrv(hdrv
)->modp
.wType
== 0) {
1434 return MCI_GetDrv(hdrv
)->dwPrivate
;
1437 /**************************************************************************
1438 * mciSetDriverData [MMSYSTEM.707]
1440 BOOL16 WINAPI
mciSetDriverData16(HDRVR16 hdrv
, DWORD data
)
1442 return mciSetDriverData(hdrv
, data
);
1445 /**************************************************************************
1446 * mciSetDriverData [WINMM.53]
1448 BOOL WINAPI
mciSetDriverData(HDRVR hdrv
, DWORD data
)
1450 TRACE(mmsys
,"(%04x,%08lx)\n", hdrv
, data
);
1451 if (!MCI_DevIDValid(hdrv
) || MCI_GetDrv(hdrv
)->modp
.wType
== 0) {
1455 MCI_GetDrv(hdrv
)->dwPrivate
= data
;
1459 /**************************************************************************
1460 * mciLoadCommandResource [MMSYSTEM.705]
1462 UINT16 WINAPI
mciLoadCommandResource16(HANDLE16 hinst
, LPCSTR resname
,UINT16 type
)
1472 static UINT16 mcidevtype
= 0;
1474 FIXME(mmsys
,"(%04x,%s,%d): stub!\n", hinst
, resname
, type
);
1475 if (!lstrcmpiA(resname
,"core")) {
1476 FIXME(mmsys
, "(...,\"core\",...), have to use internal tables... (not there yet)\n");
1479 /* if file exists "resname.mci", then load resource "resname" from it
1480 * otherwise directly from driver
1482 strcpy(buf
,resname
);
1484 if (OpenFile(buf
, &ofs
,OF_EXIST
) != HFILE_ERROR
) {
1485 xhinst
= LoadLibrary16(buf
);
1488 } /* else use passed hinst */
1489 segstr
= SEGPTR_STRDUP(resname
);
1490 hrsrc
= FindResource16(hinst
, SEGPTR_GET(segstr
), type
);
1491 SEGPTR_FREE(segstr
);
1493 WARN(mmsys
,"no special commandlist found in resource\n");
1494 return MCI_NO_COMMAND_TABLE
;
1496 hmem
= LoadResource16(hinst
, hrsrc
);
1498 WARN(mmsys
,"couldn't load resource??\n");
1499 return MCI_NO_COMMAND_TABLE
;
1501 xmem
= WIN16_LockResource16(hmem
);
1503 WARN(mmsys
,"couldn't lock resource??\n");
1504 FreeResource16(hmem
);
1505 return MCI_NO_COMMAND_TABLE
;
1507 lmem
= PTR_SEG_TO_LIN(xmem
);
1508 TRACE(mmsys
, "first resource entry is %s\n", (char*)lmem
);
1509 /* parse resource, register stuff, return unique id */
1510 return ++mcidevtype
;
1513 /**************************************************************************
1514 * mciFreeCommandResource [MMSYSTEM.713]
1516 BOOL16 WINAPI
mciFreeCommandResource16(UINT16 uTable
)
1518 FIXME(mci
, "(%04x) stub\n", uTable
);
1522 /**************************************************************************
1523 * mciFreeCommandResource [WINMM.39]
1525 BOOL WINAPI
mciFreeCommandResource(UINT uTable
)
1527 FIXME(mci
, "(%08x) stub\n", uTable
);
1531 /**************************************************************************
1532 * mciLoadCommandResource [WINMM.48]
1534 UINT WINAPI
mciLoadCommandResource(HANDLE hinst
, LPCWSTR resname
,UINT type
)
1536 FIXME(mmsys
,"(%04x,%s,%d): stub!\n", hinst
, debugstr_w(resname
), type
);
1540 const char* MCI_CommandToString(UINT16 wMsg
)
1542 static char buffer
[100];
1544 #define CASE(s) case (s): return #s
1555 CASE(MCI_GETDEVCAPS
);
1579 sprintf(buffer
, "MCI_<<%04X>>", wMsg
);
1584 /**************************************************************************
1585 * MCI_SendCommand32 [internal]
1587 DWORD
MCI_SendCommand(UINT wDevID
, UINT16 wMsg
, DWORD dwParam1
, DWORD dwParam2
)
1589 DWORD dwRet
= MCIERR_DEVICE_NOT_INSTALLED
;
1591 if (!MCI_DevIDValid(wDevID
)) {
1592 dwRet
= MCIERR_INVALID_DEVICE_ID
;
1594 MCIPROC proc
= MCI_GetProc(MCI_GetDrv(wDevID
)->modp
.wType
);
1597 dwRet
= (*proc
)(MCI_GetDrv(wDevID
)->modp
.wDeviceID
,
1598 MCI_GetDrv(wDevID
)->hDrv
,
1599 wMsg
, dwParam1
, dwParam2
);
1600 } else if (MCI_GetDrv(wDevID
)->driverProc
) {
1601 FIXME(mmsys
, "is that correct ?\n");
1602 dwRet
= Callbacks
->CallDriverProc(MCI_GetDrv(wDevID
)->driverProc
,
1603 MCI_GetDrv(wDevID
)->modp
.wDeviceID
,
1604 MCI_GetDrv(wDevID
)->hDrv
,
1605 wMsg
, dwParam1
, dwParam2
);
1607 WARN(mmsys
, "unknown device type=%04X !\n", MCI_GetDrv(wDevID
)->modp
.wType
);
1613 /**************************************************************************
1614 * MCI_Open [internal]
1616 static DWORD
MCI_Open(DWORD dwParam
, LPMCI_OPEN_PARMSA lpParms
)
1620 UINT16 wDevID
= MCI_FirstDevID();
1623 TRACE(mmsys
, "(%08lX, %p)\n", dwParam
, lpParms
);
1624 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1626 if ((dwParam
& ~(MCI_OPEN_SHAREABLE
|MCI_OPEN_ELEMENT
|MCI_OPEN_ALIAS
|MCI_OPEN_TYPE
|MCI_OPEN_TYPE_ID
|MCI_NOTIFY
|MCI_WAIT
)) != 0) {
1627 FIXME(mmsys
, "unsupported yet dwFlags=%08lX\n",
1628 (dwParam
& ~(MCI_OPEN_SHAREABLE
|MCI_OPEN_ELEMENT
|MCI_OPEN_ALIAS
|MCI_OPEN_TYPE
|MCI_OPEN_TYPE_ID
|MCI_NOTIFY
|MCI_WAIT
)));
1631 while (MCI_GetDrv(wDevID
)->modp
.wType
!= 0) {
1632 wDevID
= MCI_NextDevID(wDevID
);
1633 if (!MCI_DevIDValid(wDevID
)) {
1634 TRACE(mmsys
, "MAXMCIDRIVERS reached !\n");
1635 return MCIERR_OUT_OF_MEMORY
;
1639 TRACE(mmsys
, "wDevID=%04X \n", wDevID
);
1640 memcpy(MCI_GetOpenDrv(wDevID
), lpParms
, sizeof(*lpParms
));
1642 if (dwParam
& MCI_OPEN_ELEMENT
) {
1645 TRACE(mmsys
,"lpstrElementName='%s'\n", lpParms
->lpstrElementName
);
1646 s
= lpParms
->lpstrElementName
;
1647 t
= strrchr(s
, '.');
1649 GetProfileStringA("mci extensions", t
+1, "*", str
, sizeof(str
));
1651 uDevTyp
= MCI_GetDevType(str
);
1653 if (strcmp(str
,"*") == 0) {
1654 TRACE(mmsys
,"No [mci extensions] entry for %s found.\n", t
);
1655 return MCIERR_EXTENSION_NOT_FOUND
;
1658 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
1660 HDRVR16 hdrv
= OpenDriver32(str
, "mci", NULL
);
1664 hmod
= GetDriverModuleHandle(hdrv
);
1665 MCI_GetDrv(wDevID
)->hDrv
= hdrv
;
1666 MCI_GetDrv(wDevID
)->driverProc
= GetProcAddress(hmod
,oouch
SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC")));
1667 uDevTyp
= MCI_DEVTYPE_OTHER
;
1669 FIXME(mmsys
, "[mci extensions] entry %s for %s not supported.\n", str
, t
);
1670 return MCIERR_DEVICE_NOT_INSTALLED
;
1675 } else if (GetDriveTypeA(s
) == DRIVE_CDROM
) {
1676 /* FIXME: this will not work if several CDROM drives are installed on the machine */
1677 uDevTyp
= MCI_DEVTYPE_CD_AUDIO
;
1679 return MCIERR_EXTENSION_NOT_FOUND
;
1683 if (dwParam
& MCI_OPEN_ALIAS
) {
1684 TRACE(mmsys
, "Alias='%s' !\n", lpParms
->lpstrAlias
);
1685 /* FIXME is there any memory leak here ? */
1686 MCI_GetOpenDrv(wDevID
)->lpstrAlias
= strdup(lpParms
->lpstrAlias
);
1687 /* mplayer does allocate alias to CDAUDIO */
1689 if (dwParam
& MCI_OPEN_TYPE
) {
1690 if (dwParam
& MCI_OPEN_TYPE_ID
) {
1691 TRACE(mmsys
, "Dev=%08lx!\n", (DWORD
)lpParms
->lpstrDeviceType
);
1692 uDevTyp
= LOWORD((DWORD
)lpParms
->lpstrDeviceType
);
1693 MCI_GetOpenDrv(wDevID
)->lpstrDeviceType
= lpParms
->lpstrDeviceType
;
1695 if (lpParms
->lpstrDeviceType
== NULL
)
1696 return MCIERR_NULL_PARAMETER_BLOCK
;
1697 TRACE(mmsys
, "Dev='%s' !\n", lpParms
->lpstrDeviceType
);
1698 /* FIXME is there any memory leak here ? */
1699 MCI_GetOpenDrv(wDevID
)->lpstrDeviceType
= strdup(lpParms
->lpstrDeviceType
);
1700 strcpy(str
, lpParms
->lpstrDeviceType
);
1702 uDevTyp
= MCI_GetDevType(str
);
1705 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
1707 TRACE(mmsys
,"trying to load driver...\n");
1708 hdrv
= OpenDriver32(str
,"mci",NULL
);
1712 hmod
= GetDriverModuleHandle(hdrv
);
1713 MCI_GetDrv(wDevID
)->hDrv
= hdrv
;
1714 MCI_GetDrv(wDevID
)->driverProc
= GetProcAddress(hmod
,oouch
SEGPTR_GET(SEGPTR_STRDUP("DriverProc")));
1715 uDevTyp
= MCI_DEVTYPE_OTHER
;
1718 return MCIERR_DEVICE_NOT_INSTALLED
;
1722 MCI_GetDrv(wDevID
)->modp
.wType
= uDevTyp
;
1723 MCI_GetDrv(wDevID
)->modp
.wDeviceID
= 0; /* FIXME? for multiple devices */
1724 MCI_GetDrv(wDevID
)->dwPrivate
= 0;
1725 lpParms
->wDeviceID
= wDevID
;
1726 TRACE(mmsys
, "mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
1727 wDevID
, uDevTyp
, lpParms
->wDeviceID
);
1728 dwRet
= MCI_SendCommand(wDevID
, MCI_OPEN_DRIVER
, dwParam
, (DWORD
)lpParms
);
1731 /* only handled devices fall through */
1732 TRACE(mmsys
, "wDevID = %04X wDeviceID = %d dwRet = %ld\n", wDevID
, lpParms
->wDeviceID
, dwRet
);
1734 TRACE(mmsys
, "failed to open driver (MCI_OPEN_DRIVER msg) [%08lx], closing\n", dwRet
);
1735 MCI_GetDrv(wDevID
)->modp
.wType
= 0;
1737 if (dwParam
& MCI_NOTIFY
)
1738 mciDriverNotify16(lpParms
->dwCallback
, wDevID
, dwRet
== 0 ? MCI_NOTIFY_SUCCESSFUL
: MCI_NOTIFY_FAILURE
);
1743 /**************************************************************************
1744 * MCI_Close [internal]
1746 static DWORD
MCI_Close(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
1750 TRACE(mmsys
, "(%04x, %08lX, %p)\n", wDevID
, dwParam
, lpParms
);
1752 if (wDevID
== MCI_ALL_DEVICE_ID
) {
1753 FIXME(mmsys
, "unhandled MCI_ALL_DEVICE_ID\n");
1754 return MCIERR_CANNOT_USE_ALL
;
1757 dwRet
= MCI_SendCommand(wDevID
, MCI_CLOSE_DRIVER
, dwParam
, (DWORD
)lpParms
);
1758 MCI_GetDrv(wDevID
)->modp
.wType
= 0;
1760 if (dwParam
&MCI_NOTIFY
)
1761 mciDriverNotify16(lpParms
->dwCallback
, wDevID
,
1762 (dwRet
==0?MCI_NOTIFY_SUCCESSFUL
:MCI_NOTIFY_FAILURE
));
1764 TRACE(mmsys
, "returns %ld\n", dwRet
);
1768 /**************************************************************************
1769 * MCI_WriteString [internal]
1771 DWORD
MCI_WriteString(LPSTR lpDstStr
, DWORD dstSize
, LPCSTR lpSrcStr
)
1775 if (dstSize
<= strlen(lpSrcStr
)) {
1776 lstrcpynA(lpDstStr
, lpSrcStr
, dstSize
- 1);
1777 ret
= MCIERR_PARAM_OVERFLOW
;
1779 strcpy(lpDstStr
, lpSrcStr
);
1785 /**************************************************************************
1786 * MCI_Sysinfo [internal]
1788 static DWORD
MCI_SysInfo(UINT uDevID
, DWORD dwFlags
, LPMCI_SYSINFO_PARMSA lpParms
)
1790 DWORD ret
= MCIERR_INVALID_DEVICE_ID
;
1792 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1794 TRACE(mci
, "(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
1795 uDevID
, dwFlags
, (DWORD
)lpParms
, lpParms
->dwNumber
, lpParms
->wDeviceType
);
1797 switch (dwFlags
& ~MCI_SYSINFO_OPEN
) {
1798 case MCI_SYSINFO_QUANTITY
:
1803 if (lpParms
->wDeviceType
< MCI_DEVTYPE_FIRST
|| lpParms
->wDeviceType
> MCI_DEVTYPE_LAST
) {
1804 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1805 TRACE(mci
, "MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1806 for (i
= 0; i
< MAXMCIDRIVERS
; i
++) {
1807 if (mciDrv
[i
].modp
.wType
!= 0) cnt
++;
1810 TRACE(mci
, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1811 cnt
= mciInstalledCount
;
1814 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1815 TRACE(mci
, "MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms
->wDeviceType
);
1816 for (i
= 0; i
< MAXMCIDRIVERS
; i
++) {
1817 if (mciDrv
[i
].modp
.wType
== lpParms
->wDeviceType
) cnt
++;
1820 TRACE(mci
, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms
->wDeviceType
);
1821 FIXME(mci
, "Don't know how to get # of MCI devices of a given type\n");
1825 *(DWORD
*)lpParms
->lpstrReturn
= cnt
;
1827 TRACE(mci
, "(%ld) => '%ld'\n", lpParms
->dwNumber
, *(DWORD
*)lpParms
->lpstrReturn
);
1830 case MCI_SYSINFO_INSTALLNAME
:
1831 TRACE(mci
, "MCI_SYSINFO_INSTALLNAME \n");
1832 if (MCI_DevIDValid(uDevID
)) {
1833 LPCSTR str
= MCI_GetDevTypeString(MCI_GetDrv(uDevID
)->modp
.wType
);
1834 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, str
);
1836 *lpParms
->lpstrReturn
= 0;
1837 ret
= MCIERR_INVALID_DEVICE_ID
;
1839 TRACE(mci
, "(%ld) => '%s'\n", lpParms
->dwNumber
, lpParms
->lpstrReturn
);
1841 case MCI_SYSINFO_NAME
:
1842 TRACE(mci
, "MCI_SYSINFO_NAME\n");
1843 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1844 FIXME(mci
, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
1845 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
1846 } else if (lpParms
->dwNumber
> mciInstalledCount
) {
1847 ret
= MCIERR_OUTOFRANGE
;
1849 DWORD count
= lpParms
->dwNumber
;
1850 LPSTR ptr
= lpmciInstallNames
;
1852 while (--count
> 0) ptr
+= strlen(ptr
) + 1;
1853 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, ptr
);
1855 TRACE(mci
, "(%ld) => '%s'\n", lpParms
->dwNumber
, lpParms
->lpstrReturn
);
1858 TRACE(mci
, "Unsupported flag value=%08lx\n", dwFlags
);
1859 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
1872 DWORD WINAPI
mciSendCommandA(UINT wDevID
, UINT wMsg
, DWORD dwParam1
, DWORD dwParam2
);
1874 /**************************************************************************
1875 * MCI_SCAStarter32 [internal]
1877 static DWORD WINAPI
MCI_SCAStarter(LPVOID arg
)
1879 struct SCA
* sca
= (struct SCA
*)arg
;
1882 TRACE(mci
, "In thread before async command (%08x,%s,%08lx,%08lx)\n",
1883 sca
->wDevID
, MCI_CommandToString(sca
->wMsg
), sca
->dwParam1
, sca
->dwParam2
);
1884 ret
= mciSendCommandA(sca
->wDevID
, sca
->wMsg
, sca
->dwParam1
| MCI_WAIT
, sca
->dwParam2
);
1885 TRACE(mci
, "In thread after async command (%08x,%s,%08lx,%08lx)\n",
1886 sca
->wDevID
, MCI_CommandToString(sca
->wMsg
), sca
->dwParam1
, sca
->dwParam2
);
1887 if (sca
->allocatedCopy
)
1888 HeapFree(GetProcessHeap(), 0, (LPVOID
)sca
->dwParam2
);
1889 HeapFree(GetProcessHeap(), 0, sca
);
1891 WARN(mci
, "Should not happen ? what's wrong \n");
1892 /* should not go after this point */
1896 /**************************************************************************
1897 * MCI_SendCommandAsync32 [internal]
1899 DWORD
MCI_SendCommandAsync(UINT wDevID
, UINT wMsg
, DWORD dwParam1
, DWORD dwParam2
, UINT size
)
1901 struct SCA
* sca
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA
));
1904 return MCIERR_OUT_OF_MEMORY
;
1906 sca
->wDevID
= wDevID
;
1908 sca
->dwParam1
= dwParam1
;
1911 sca
->dwParam2
= (DWORD
)HeapAlloc(GetProcessHeap(), 0, size
);
1912 if (sca
->dwParam2
== 0) {
1913 HeapFree(GetProcessHeap(), 0, sca
);
1914 return MCIERR_OUT_OF_MEMORY
;
1916 sca
->allocatedCopy
= TRUE
;
1917 /* copy structure passed by program in dwParam2 to be sure
1918 * we can still use it whatever the program does
1920 memcpy((LPVOID
)sca
->dwParam2
, (LPVOID
)dwParam2
, size
);
1922 sca
->dwParam2
= dwParam2
;
1923 sca
->allocatedCopy
= FALSE
;
1926 if (CreateThread(NULL
, 0, MCI_SCAStarter
, sca
, 0, NULL
) == 0) {
1927 WARN(mci
, "Couldn't allocate thread for async command handling, sending synchonously\n");
1928 return MCI_SCAStarter(&sca
);
1933 /**************************************************************************
1934 * MCI_MapMsg16To32A [internal]
1936 int MCI_MapMsg16To32A(WORD uDevType
, WORD wMsg
, DWORD
* lParam
)
1940 /* FIXME: to add also (with seg/linear modifications to do):
1941 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1942 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO, MCI_WINDOW
1945 /* case MCI_CAPTURE */
1947 case MCI_CLOSE_DRIVER
:
1948 /* case MCI_CONFIGURE:*/
1954 case MCI_GETDEVCAPS
:
1955 /* case MCI_INDEX: */
1956 /* case MCI_MARK: */
1957 /* case MCI_MONITOR: */
1967 /* case MCI_SETTIMECODE:*/
1968 /* case MCI_SIGNAL:*/
1970 case MCI_STATUS
: /* FIXME: is wrong for digital video */
1973 /* case MCI_UNDO: */
1977 *lParam
= (DWORD
)PTR_SEG_TO_LIN(*lParam
);
1981 LPMCI_BREAK_PARMS mbp32
= HeapAlloc(SystemHeap
, 0, sizeof(MCI_BREAK_PARMS
));
1982 LPMCI_BREAK_PARMS16 mbp16
= PTR_SEG_TO_LIN(*lParam
);
1985 mbp32
->dwCallback
= mbp16
->dwCallback
;
1986 mbp32
->nVirtKey
= mbp16
->nVirtKey
;
1987 mbp32
->hwndBreak
= mbp16
->hwndBreak
;
1991 *lParam
= (DWORD
)mbp32
;
1996 LPMCI_VD_ESCAPE_PARMSA mvep32a
= HeapAlloc(SystemHeap
, 0, sizeof(MCI_VD_ESCAPE_PARMSA
));
1997 LPMCI_VD_ESCAPE_PARMS16 mvep16
= PTR_SEG_TO_LIN(*lParam
);
2000 mvep32a
->dwCallback
= mvep16
->dwCallback
;
2001 mvep32a
->lpstrCommand
= PTR_SEG_TO_LIN(mvep16
->lpstrCommand
);
2005 *lParam
= (DWORD
)mvep32a
;
2010 LPMCI_INFO_PARMSA mip32a
= HeapAlloc(SystemHeap
, 0, sizeof(MCI_INFO_PARMSA
));
2011 LPMCI_INFO_PARMS16 mip16
= PTR_SEG_TO_LIN(*lParam
);
2013 /* FIXME this is wrong if device is of type
2014 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
2017 mip32a
->dwCallback
= mip16
->dwCallback
;
2018 mip32a
->lpstrReturn
= PTR_SEG_TO_LIN(mip16
->lpstrReturn
);
2019 mip32a
->dwRetSize
= mip16
->dwRetSize
;
2023 *lParam
= (DWORD
)mip32a
;
2027 case MCI_OPEN_DRIVER
:
2029 LPMCI_OPEN_PARMSA mop32a
= HeapAlloc(SystemHeap
, 0, sizeof(LPMCI_OPEN_PARMS16
) + sizeof(MCI_OPEN_PARMSA
) + 2 * sizeof(DWORD
));
2030 LPMCI_OPEN_PARMS16 mop16
= PTR_SEG_TO_LIN(*lParam
);
2033 *(LPMCI_OPEN_PARMS16
*)(mop32a
) = mop16
;
2034 mop32a
= (LPMCI_OPEN_PARMSA
)((char*)mop32a
+ sizeof(LPMCI_OPEN_PARMS16
));
2035 mop32a
->dwCallback
= mop16
->dwCallback
;
2036 mop32a
->wDeviceID
= mop16
->wDeviceID
;
2037 mop32a
->lpstrDeviceType
= PTR_SEG_TO_LIN(mop16
->lpstrDeviceType
);
2038 mop32a
->lpstrElementName
= PTR_SEG_TO_LIN(mop16
->lpstrElementName
);
2039 mop32a
->lpstrAlias
= PTR_SEG_TO_LIN(mop16
->lpstrAlias
);
2040 /* copy extended information if any...
2041 * FIXME: this may seg fault if initial structure does not contain them and
2042 * the reads after msip16 fail under LDT limits...
2043 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2044 * should not take care of extended parameters, and should be used by MCI_Open
2045 * to fetch uDevTyp. When, this is known, the mapping for sending the
2046 * MCI_OPEN_DRIVER shall be done depending on uDevTyp.
2048 ((DWORD
*)(mop32a
+ 1))[0] = ((DWORD
*)(mop16
+ 1))[0];
2049 ((DWORD
*)(mop32a
+ 1))[1] = ((DWORD
*)(mop16
+ 1))[1];
2053 *lParam
= (DWORD
)mop32a
;
2058 LPMCI_SYSINFO_PARMSA msip32a
= HeapAlloc(SystemHeap
, 0, sizeof(MCI_SYSINFO_PARMSA
));
2059 LPMCI_SYSINFO_PARMS16 msip16
= PTR_SEG_TO_LIN(*lParam
);
2062 msip32a
->dwCallback
= msip16
->dwCallback
;
2063 msip32a
->lpstrReturn
= PTR_SEG_TO_LIN(msip16
->lpstrReturn
);
2064 msip32a
->dwRetSize
= msip16
->dwRetSize
;
2065 msip32a
->dwNumber
= msip16
->dwNumber
;
2066 msip32a
->wDeviceType
= msip16
->wDeviceType
;
2070 *lParam
= (DWORD
)msip32a
;
2080 case DRV_QUERYCONFIGURE
:
2083 case DRV_EXITSESSION
:
2084 case DRV_EXITAPPLICATION
:
2086 FIXME(mci
, "This is a hack\n");
2090 WARN(mci
, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg
));
2095 /**************************************************************************
2096 * MCI_UnMapMsg16To32A [internal]
2098 int MCI_UnMapMsg16To32A(WORD uDevTyp
, WORD wMsg
, DWORD lParam
)
2101 /* case MCI_CAPTURE */
2103 case MCI_CLOSE_DRIVER
:
2104 /* case MCI_CONFIGURE:*/
2110 case MCI_GETDEVCAPS
:
2111 /* case MCI_INDEX: */
2112 /* case MCI_MARK: */
2113 /* case MCI_MONITOR: */
2123 /* case MCI_SETTIMECODE:*/
2124 /* case MCI_SIGNAL:*/
2129 /* case MCI_UNDO: */
2139 HeapFree(SystemHeap
, 0, (LPVOID
)lParam
);
2142 case MCI_OPEN_DRIVER
:
2144 LPMCI_OPEN_PARMSA mop32a
= (MCI_OPEN_PARMSA
*)lParam
;
2145 LPMCI_OPEN_PARMS16 mop16
= *(LPMCI_OPEN_PARMS16
*)((char*)mop32a
- sizeof(LPMCI_OPEN_PARMS16
*));
2147 mop16
->wDeviceID
= mop32a
->wDeviceID
;
2148 HeapFree(SystemHeap
, 0, (LPVOID
)(lParam
- sizeof(LPMCI_OPEN_PARMS16
)));
2158 case DRV_QUERYCONFIGURE
:
2161 case DRV_EXITSESSION
:
2162 case DRV_EXITAPPLICATION
:
2164 FIXME(mci
, "This is a hack\n");
2167 FIXME(mci
, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg
));
2172 /**************************************************************************
2173 * mciSendCommandA [WINMM.49]
2175 DWORD WINAPI
mciSendCommandA(UINT wDevID
, UINT wMsg
, DWORD dwParam1
, DWORD dwParam2
)
2177 TRACE(mci
, "(%08x,%s,%08lx,%08lx)\n", wDevID
, MCI_CommandToString(wMsg
), dwParam1
, dwParam2
);
2181 return MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSA
)dwParam2
);
2183 return MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
2185 return MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSA
)dwParam2
);
2187 if (wDevID
== MCI_ALL_DEVICE_ID
) {
2188 FIXME(mci
, "unhandled MCI_ALL_DEVICE_ID\n");
2189 return MCIERR_CANNOT_USE_ALL
;
2192 return MCI_SendCommand(wDevID
, wMsg
, dwParam1
, dwParam2
);
2196 /**************************************************************************
2197 * mciSendCommandW [WINMM.50]
2199 DWORD WINAPI
mciSendCommandW(UINT wDevID
, UINT wMsg
, DWORD dwParam1
, DWORD dwParam2
)
2201 return 0x1; /* !ok */
2204 /**************************************************************************
2205 * mciSendCommand [MMSYSTEM.701]
2207 DWORD WINAPI
mciSendCommand16(UINT16 wDevID
, UINT16 wMsg
, DWORD dwParam1
, DWORD dwParam2
)
2209 DWORD dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
2211 TRACE(mmsys
, "(%04X, %s, %08lX, %08lX)\n",
2212 wDevID
, MCI_CommandToString(wMsg
), dwParam1
, dwParam2
);
2216 if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID
)->modp
.wType
, wMsg
, &dwParam2
) >= 0) {
2217 dwRet
= MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSA
)dwParam2
);
2218 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID
)->modp
.wType
, wMsg
, dwParam2
);
2222 if (wDevID
== MCI_ALL_DEVICE_ID
) {
2223 FIXME(mci
, "unhandled MCI_ALL_DEVICE_ID\n");
2224 dwRet
= MCIERR_CANNOT_USE_ALL
;
2225 } else if (!MCI_DevIDValid(wDevID
)) {
2226 dwRet
= MCIERR_INVALID_DEVICE_ID
;
2227 } else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID
)->modp
.wType
, wMsg
, &dwParam2
) >= 0) {
2228 dwRet
= MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
2229 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID
)->modp
.wType
, wMsg
, dwParam2
);
2233 if (MCI_MapMsg16To32A(0, wDevID
, &dwParam2
) >= 0) {
2234 dwRet
= MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSA
)dwParam2
);
2235 MCI_UnMapMsg16To32A(0, wDevID
, dwParam2
);
2238 /* FIXME: it seems that MCI_BREAK and MCI_SOUND need the same handling */
2240 if (wDevID
== MCI_ALL_DEVICE_ID
) {
2241 FIXME(mci
, "unhandled MCI_ALL_DEVICE_ID\n");
2242 dwRet
= MCIERR_CANNOT_USE_ALL
;
2243 } else if (!MCI_DevIDValid(wDevID
)) {
2244 dwRet
= MCIERR_INVALID_DEVICE_ID
;
2248 switch (res
= MCI_MapMsg16To32A(MCI_GetDrv(wDevID
)->modp
.wType
, wMsg
, &dwParam2
)) {
2250 TRACE(mci
, "Not handled yet (%s)\n", MCI_CommandToString(wMsg
));
2253 TRACE(mci
, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg
));
2256 dwRet
= MCI_SendCommand(wDevID
, wMsg
, dwParam1
, dwParam2
);
2258 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID
)->modp
.wType
, wMsg
, dwParam2
);
2266 /**************************************************************************
2267 * mciGetDeviceID [MMSYSTEM.703]
2269 UINT16 WINAPI
mciGetDeviceID16(LPCSTR lpstrName
)
2272 TRACE(mmsys
, "(\"%s\")\n", lpstrName
);
2277 if (!lstrcmpiA(lpstrName
, "ALL"))
2278 return MCI_ALL_DEVICE_ID
;
2280 for (wDevID
= MCI_FirstDevID(); MCI_DevIDValid(wDevID
); wDevID
= MCI_NextDevID(wDevID
)) {
2281 if (MCI_GetDrv(wDevID
)->modp
.wType
) {
2282 FIXME(mmsys
, "This is wrong for compound devices\n");
2283 /* FIXME: for compound devices, lpstrName is matched against
2284 * the name of the file, not the name of the device...
2286 if (MCI_GetOpenDrv(wDevID
)->lpstrDeviceType
&&
2287 strcmp(MCI_GetOpenDrv(wDevID
)->lpstrDeviceType
, lpstrName
) == 0)
2290 if (MCI_GetOpenDrv(wDevID
)->lpstrAlias
&&
2291 strcmp(MCI_GetOpenDrv(wDevID
)->lpstrAlias
, lpstrName
) == 0)
2299 /**************************************************************************
2300 * mciGetDeviceIDA [WINMM.41]
2302 UINT WINAPI
mciGetDeviceIDA(LPCSTR lpstrName
)
2304 return mciGetDeviceID16(lpstrName
);
2307 /**************************************************************************
2308 * mciGetDeviceIDW [WINMM.43]
2310 UINT WINAPI
mciGetDeviceIDW(LPCWSTR lpwstrName
)
2315 lpstrName
= HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName
);
2316 ret
= mciGetDeviceID16(lpstrName
);
2317 HeapFree(GetProcessHeap(), 0, lpstrName
);
2321 /**************************************************************************
2322 * mciSetYieldProc [MMSYSTEM.714]
2324 BOOL16 WINAPI
mciSetYieldProc16(UINT16 uDeviceID
,
2325 YIELDPROC fpYieldProc
, DWORD dwYieldData
)
2327 FIXME(mci
, "(%u, %p, %08lx) stub\n", uDeviceID
, fpYieldProc
, dwYieldData
);
2331 /**************************************************************************
2332 * mciSetYieldProc [WINMM.54]
2334 BOOL WINAPI
mciSetYieldProc(UINT uDeviceID
,
2335 YIELDPROC fpYieldProc
, DWORD dwYieldData
)
2337 FIXME(mci
, "(%u, %p, %08lx) stub\n", uDeviceID
, fpYieldProc
, dwYieldData
);
2341 /**************************************************************************
2342 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
2344 UINT16 WINAPI
mciGetDeviceIDFromElementID16(DWORD dwElementID
, LPCSTR lpstrType
)
2346 FIXME(mci
, "(%lu, %s) stub\n", dwElementID
, lpstrType
);
2350 /**************************************************************************
2351 * mciGetDeviceIDFromElementIDW [WINMM.42]
2353 UINT WINAPI
mciGetDeviceIDFromElementIDW(DWORD dwElementID
, LPCWSTR lpstrType
)
2355 /* FIXME: that's rather strange, there is no
2356 * mciGetDeviceIDFromElementID32A in winmm.spec
2358 FIXME(mci
, "(%lu, %p) stub\n", dwElementID
, lpstrType
);
2362 /**************************************************************************
2363 * mciGetYieldProc [MMSYSTEM.716]
2365 YIELDPROC WINAPI
mciGetYieldProc16(UINT16 uDeviceID
, DWORD
* lpdwYieldData
)
2367 FIXME(mci
, "(%u, %p) stub\n", uDeviceID
, lpdwYieldData
);
2371 /**************************************************************************
2372 * mciGetYieldProc [WINMM.47]
2374 YIELDPROC WINAPI
mciGetYieldProc(UINT uDeviceID
, DWORD
* lpdwYieldData
)
2376 FIXME(mci
, "(%u, %p) stub\n", uDeviceID
, lpdwYieldData
);
2380 /**************************************************************************
2381 * mciGetCreatorTask [MMSYSTEM.717]
2383 HTASK16 WINAPI
mciGetCreatorTask16(UINT16 uDeviceID
)
2385 FIXME(mci
, "(%u) stub\n", uDeviceID
);
2389 /**************************************************************************
2390 * mciGetCreatorTask [WINMM.40]
2392 HTASK WINAPI
mciGetCreatorTask(UINT uDeviceID
)
2394 FIXME(mci
, "(%u) stub\n", uDeviceID
);
2398 /**************************************************************************
2399 * mciDriverYield [MMSYSTEM.710]
2401 UINT16 WINAPI
mciDriverYield16(HANDLE16 hnd
)
2403 FIXME(mmsys
,"(%04x): stub!\n", hnd
);
2407 /**************************************************************************
2408 * mciDriverYield [WINMM.37]
2410 UINT WINAPI
mciDriverYield(HANDLE hnd
)
2412 FIXME(mmsys
,"(%04x): stub!\n", hnd
);
2416 /**************************************************************************
2417 * midiOutGetNumDevs [WINMM.80]
2419 UINT WINAPI
midiOutGetNumDevs(void)
2421 return midiOutGetNumDevs16();
2424 /**************************************************************************
2425 * midiOutGetNumDevs [MMSYSTEM.201]
2427 UINT16 WINAPI
midiOutGetNumDevs16(void)
2429 UINT16 count
= modMessage(0, MODM_GETNUMDEVS
, 0L, 0L, 0L);
2431 TRACE(mmsys
, "returns %u\n", count
);
2435 /**************************************************************************
2436 * midiOutGetDevCapsW [WINMM.76]
2438 UINT WINAPI
midiOutGetDevCapsW(UINT uDeviceID
, LPMIDIOUTCAPSW lpCaps
, UINT uSize
)
2440 MIDIOUTCAPS16 moc16
;
2443 ret
= midiOutGetDevCaps16(uDeviceID
, &moc16
, sizeof(moc16
));
2444 lpCaps
->wMid
= moc16
.wMid
;
2445 lpCaps
->wPid
= moc16
.wPid
;
2446 lpCaps
->vDriverVersion
= moc16
.vDriverVersion
;
2447 lstrcpyAtoW(lpCaps
->szPname
, moc16
.szPname
);
2448 lpCaps
->wTechnology
= moc16
.wTechnology
;
2449 lpCaps
->wVoices
= moc16
.wVoices
;
2450 lpCaps
->wNotes
= moc16
.wNotes
;
2451 lpCaps
->wChannelMask
= moc16
.wChannelMask
;
2452 lpCaps
->dwSupport
= moc16
.dwSupport
;
2456 /**************************************************************************
2457 * midiOutGetDevCapsA [WINMM.75]
2459 UINT WINAPI
midiOutGetDevCapsA(UINT uDeviceID
, LPMIDIOUTCAPSA lpCaps
, UINT uSize
)
2461 MIDIOUTCAPS16 moc16
;
2464 ret
= midiOutGetDevCaps16(uDeviceID
, &moc16
, sizeof(moc16
));
2465 lpCaps
->wMid
= moc16
.wMid
;
2466 lpCaps
->wPid
= moc16
.wPid
;
2467 lpCaps
->vDriverVersion
= moc16
.vDriverVersion
;
2468 strcpy(lpCaps
->szPname
, moc16
.szPname
);
2469 lpCaps
->wTechnology
= moc16
.wTechnology
;
2470 lpCaps
->wVoices
= moc16
.wVoices
;
2471 lpCaps
->wNotes
= moc16
.wNotes
;
2472 lpCaps
->wChannelMask
= moc16
.wChannelMask
;
2473 lpCaps
->dwSupport
= moc16
.dwSupport
;
2477 /**************************************************************************
2478 * midiOutGetDevCaps [MMSYSTEM.202]
2480 UINT16 WINAPI
midiOutGetDevCaps16(UINT16 uDeviceID
, LPMIDIOUTCAPS16 lpCaps
, UINT16 uSize
)
2482 TRACE(mmsys
, "midiOutGetDevCaps\n");
2483 return modMessage(uDeviceID
, MODM_GETDEVCAPS
, 0, (DWORD
)lpCaps
,uSize
);
2486 /**************************************************************************
2487 * midiOutGetErrorTextA [WINMM.77]
2489 UINT WINAPI
midiOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
2491 TRACE(mmsys
, "midiOutGetErrorText\n");
2492 return midiGetErrorText(uError
, lpText
, uSize
);
2495 /**************************************************************************
2496 * midiOutGetErrorTextW [WINMM.78]
2498 UINT WINAPI
midiOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
2500 LPSTR xstr
= HeapAlloc(GetProcessHeap(), 0,uSize
);
2503 TRACE(mmsys
, "midiOutGetErrorText\n");
2504 ret
= midiGetErrorText(uError
, xstr
, uSize
);
2505 lstrcpyAtoW(lpText
,xstr
);
2506 HeapFree(GetProcessHeap(), 0,xstr
);
2510 /**************************************************************************
2511 * midiOutGetErrorText [MMSYSTEM.203]
2513 UINT16 WINAPI
midiOutGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
2515 TRACE(mmsys
, "midiOutGetErrorText\n");
2516 return midiGetErrorText(uError
, lpText
, uSize
);
2519 /**************************************************************************
2520 * midiGetErrorText [internal]
2522 UINT16 WINAPI
midiGetErrorText(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
2525 if ((lpText
== NULL
) || (uSize
< 1)) return(FALSE
);
2528 case MIDIERR_UNPREPARED
:
2529 msgptr
= "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
2531 case MIDIERR_STILLPLAYING
:
2532 msgptr
= "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
2535 msgptr
= "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing.";
2537 case MIDIERR_NOTREADY
:
2538 msgptr
= "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
2540 case MIDIERR_NODEVICE
:
2541 msgptr
= "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.";
2543 case MIDIERR_INVALIDSETUP
:
2544 msgptr
= "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
2547 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
2548 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
2549 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
2550 msg# 339 : The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.
2551 msg# 340 : An error occurred using the specified port.
2552 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
2553 msg# 342 : There is no current MIDI port.
2554 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
2557 msgptr
= "Unknown MIDI Error !\n";
2560 lstrcpynA(lpText
, msgptr
, uSize
);
2564 /**************************************************************************
2565 * midiOutOpen [WINM.84]
2567 UINT WINAPI
midiOutOpen(HMIDIOUT
* lphMidiOut
, UINT uDeviceID
,
2568 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
2573 ret
= midiOutOpen16(&hmo16
,uDeviceID
, dwCallback
, dwInstance
,
2574 CALLBACK32CONV(dwFlags
));
2575 if (lphMidiOut
) *lphMidiOut
= hmo16
;
2579 /**************************************************************************
2580 * midiOutOpen [MMSYSTEM.204]
2582 UINT16 WINAPI
midiOutOpen16(HMIDIOUT16
* lphMidiOut
, UINT16 uDeviceID
,
2583 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
2586 LPMIDIOPENDESC lpDesc
;
2588 BOOL bMapperFlg
= FALSE
;
2590 if (lphMidiOut
!= NULL
) *lphMidiOut
= 0;
2591 TRACE(mmsys
, "(%p, %d, %08lX, %08lX, %08lX);\n",
2592 lphMidiOut
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
2593 if (uDeviceID
== (UINT16
)MIDI_MAPPER
) {
2594 TRACE(mmsys
, "MIDI_MAPPER mode requested !\n");
2598 hMidiOut
= USER_HEAP_ALLOC(sizeof(MIDIOPENDESC
));
2599 if (lphMidiOut
!= NULL
)
2600 *lphMidiOut
= hMidiOut
;
2601 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2603 return MMSYSERR_NOMEM
;
2604 lpDesc
->hMidi
= hMidiOut
;
2605 lpDesc
->dwCallback
= dwCallback
;
2606 lpDesc
->dwInstance
= dwInstance
;
2608 while (uDeviceID
< MAXMIDIDRIVERS
) {
2609 dwRet
= modMessage(uDeviceID
, MODM_OPEN
,
2610 lpDesc
->dwInstance
, (DWORD
)lpDesc
, dwFlags
);
2611 if (dwRet
== MMSYSERR_NOERROR
) break;
2612 if (!bMapperFlg
) break;
2614 TRACE(mmsys
, "MIDI_MAPPER mode ! try next driver...\n");
2616 lpDesc
->wDevID
= uDeviceID
;
2620 /**************************************************************************
2621 * midiOutClose [WINMM.74]
2623 UINT WINAPI
midiOutClose(HMIDIOUT hMidiOut
)
2625 return midiOutClose16(hMidiOut
);
2628 /**************************************************************************
2629 * midiOutClose [MMSYSTEM.205]
2631 UINT16 WINAPI
midiOutClose16(HMIDIOUT16 hMidiOut
)
2633 LPMIDIOPENDESC lpDesc
;
2635 TRACE(mmsys
, "(%04X)\n", hMidiOut
);
2637 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2638 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2639 return modMessage(lpDesc
->wDevID
, MODM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
2642 /**************************************************************************
2643 * midiOutPrepareHeader [WINMM.85]
2645 UINT WINAPI
midiOutPrepareHeader(HMIDIOUT hMidiOut
,
2646 MIDIHDR16
* lpMidiOutHdr
, UINT uSize
)
2648 LPMIDIOPENDESC lpDesc
;
2650 TRACE(mmsys
, "(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2652 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2653 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2654 lpMidiOutHdr
->reserved
= (DWORD
)lpMidiOutHdr
->lpData
;
2655 return modMessage(lpDesc
->wDevID
, MODM_PREPARE
, lpDesc
->dwInstance
,
2656 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2659 /**************************************************************************
2660 * midiOutPrepareHeader [MMSYSTEM.206]
2662 UINT16 WINAPI
midiOutPrepareHeader16(HMIDIOUT16 hMidiOut
,
2663 MIDIHDR16
* lpMidiOutHdr
, UINT16 uSize
)
2665 LPMIDIOPENDESC lpDesc
;
2667 TRACE(mmsys
, "(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2669 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2670 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2671 lpMidiOutHdr
->reserved
= (DWORD
)PTR_SEG_TO_LIN(lpMidiOutHdr
->lpData
);
2672 return modMessage(lpDesc
->wDevID
, MODM_PREPARE
, lpDesc
->dwInstance
,
2673 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2676 /**************************************************************************
2677 * midiOutUnprepareHeader [WINMM.89]
2679 UINT WINAPI
midiOutUnprepareHeader(HMIDIOUT hMidiOut
,
2680 MIDIHDR16
* lpMidiOutHdr
, UINT uSize
)
2682 return midiOutUnprepareHeader16(hMidiOut
, lpMidiOutHdr
,uSize
);
2685 /**************************************************************************
2686 * midiOutUnprepareHeader [MMSYSTEM.207]
2688 UINT16 WINAPI
midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut
,
2689 MIDIHDR16
* lpMidiOutHdr
, UINT16 uSize
)
2691 LPMIDIOPENDESC lpDesc
;
2693 TRACE(mmsys
, "(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2695 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2696 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2697 return modMessage(lpDesc
->wDevID
, MODM_UNPREPARE
, lpDesc
->dwInstance
,
2698 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2701 /**************************************************************************
2702 * midiOutShortMsg [WINMM.88]
2704 UINT WINAPI
midiOutShortMsg(HMIDIOUT hMidiOut
, DWORD dwMsg
)
2706 return midiOutShortMsg16(hMidiOut
, dwMsg
);
2709 /**************************************************************************
2710 * midiOutShortMsg [MMSYSTEM.208]
2712 UINT16 WINAPI
midiOutShortMsg16(HMIDIOUT16 hMidiOut
, DWORD dwMsg
)
2714 LPMIDIOPENDESC lpDesc
;
2716 TRACE(mmsys
, "(%04X, %08lX)\n", hMidiOut
, dwMsg
);
2718 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2719 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2720 return modMessage(lpDesc
->wDevID
, MODM_DATA
, lpDesc
->dwInstance
, dwMsg
, 0L);
2723 /**************************************************************************
2724 * midiOutLongMsg [WINMM.82]
2726 UINT WINAPI
midiOutLongMsg(HMIDIOUT hMidiOut
,
2727 MIDIHDR16
* lpMidiOutHdr
, UINT uSize
)
2729 return midiOutLongMsg16(hMidiOut
, lpMidiOutHdr
,uSize
);
2732 /**************************************************************************
2733 * midiOutLongMsg [MMSYSTEM.209]
2735 UINT16 WINAPI
midiOutLongMsg16(HMIDIOUT16 hMidiOut
,
2736 MIDIHDR16
* lpMidiOutHdr
, UINT16 uSize
)
2738 LPMIDIOPENDESC lpDesc
;
2740 TRACE(mmsys
, "(%04X, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
2742 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2743 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2744 return modMessage(lpDesc
->wDevID
, MODM_LONGDATA
, lpDesc
->dwInstance
,
2745 (DWORD
)lpMidiOutHdr
, (DWORD
)uSize
);
2748 /**************************************************************************
2749 * midiOutReset [WINMM.86]
2751 UINT WINAPI
midiOutReset(HMIDIOUT hMidiOut
)
2753 return midiOutReset16(hMidiOut
);
2756 /**************************************************************************
2757 * midiOutReset [MMSYSTEM.210]
2759 UINT16 WINAPI
midiOutReset16(HMIDIOUT16 hMidiOut
)
2761 LPMIDIOPENDESC lpDesc
;
2763 TRACE(mmsys
, "(%04X)\n", hMidiOut
);
2765 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2766 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2767 return modMessage(lpDesc
->wDevID
, MODM_RESET
, lpDesc
->dwInstance
, 0L, 0L);
2770 /**************************************************************************
2771 * midiOutGetVolume [WINM.81]
2773 UINT WINAPI
midiOutGetVolume(UINT uDeviceID
, DWORD
* lpdwVolume
)
2775 return midiOutGetVolume16(uDeviceID
, lpdwVolume
);
2778 /**************************************************************************
2779 * midiOutGetVolume [MMSYSTEM.211]
2781 UINT16 WINAPI
midiOutGetVolume16(UINT16 uDeviceID
, DWORD
* lpdwVolume
)
2783 TRACE(mmsys
, "(%04X, %p);\n", uDeviceID
, lpdwVolume
);
2784 return modMessage(uDeviceID
, MODM_GETVOLUME
, 0L, (DWORD
)lpdwVolume
, 0L);
2787 /**************************************************************************
2788 * midiOutSetVolume [WINMM.87]
2790 UINT WINAPI
midiOutSetVolume(UINT uDeviceID
, DWORD dwVolume
)
2792 return midiOutSetVolume16(uDeviceID
, dwVolume
);
2795 /**************************************************************************
2796 * midiOutSetVolume [MMSYSTEM.212]
2798 UINT16 WINAPI
midiOutSetVolume16(UINT16 uDeviceID
, DWORD dwVolume
)
2800 TRACE(mmsys
, "(%04X, %08lX);\n", uDeviceID
, dwVolume
);
2801 return modMessage(uDeviceID
, MODM_SETVOLUME
, 0L, dwVolume
, 0L);
2804 /**************************************************************************
2805 * midiOutCachePatches [WINMM.73]
2807 UINT WINAPI
midiOutCachePatches(HMIDIOUT hMidiOut
, UINT uBank
,
2808 WORD
* lpwPatchArray
, UINT uFlags
)
2810 return midiOutCachePatches16(hMidiOut
,uBank
, lpwPatchArray
,uFlags
);
2813 /**************************************************************************
2814 * midiOutCachePatches [MMSYSTEM.213]
2816 UINT16 WINAPI
midiOutCachePatches16(HMIDIOUT16 hMidiOut
, UINT16 uBank
,
2817 WORD
* lpwPatchArray
, UINT16 uFlags
)
2819 /* not really necessary to support this */
2820 FIXME(mmsys
, "not supported yet\n");
2821 return MMSYSERR_NOTSUPPORTED
;
2824 /**************************************************************************
2825 * midiOutCacheDrumPatches [WINMM.72]
2827 UINT WINAPI
midiOutCacheDrumPatches(HMIDIOUT hMidiOut
, UINT uPatch
,
2828 WORD
* lpwKeyArray
, UINT uFlags
)
2830 return midiOutCacheDrumPatches16(hMidiOut
,uPatch
, lpwKeyArray
,uFlags
);
2833 /**************************************************************************
2834 * midiOutCacheDrumPatches [MMSYSTEM.214]
2836 UINT16 WINAPI
midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut
, UINT16 uPatch
,
2837 WORD
* lpwKeyArray
, UINT16 uFlags
)
2839 FIXME(mmsys
, "not supported yet\n");
2840 return MMSYSERR_NOTSUPPORTED
;
2843 /**************************************************************************
2844 * midiOutGetID [WINMM.79]
2846 UINT WINAPI
midiOutGetID(HMIDIOUT hMidiOut
, UINT
* lpuDeviceID
)
2851 ret
= midiOutGetID16(hMidiOut
, &xid
);
2856 /**************************************************************************
2857 * midiOutGetID [MMSYSTEM.215]
2859 UINT16 WINAPI
midiOutGetID16(HMIDIOUT16 hMidiOut
, UINT16
* lpuDeviceID
)
2861 TRACE(mmsys
, "midiOutGetID\n");
2865 /**************************************************************************
2866 * midiOutMessage [WINMM.83]
2868 DWORD WINAPI
midiOutMessage(HMIDIOUT hMidiOut
, UINT uMessage
,
2869 DWORD dwParam1
, DWORD dwParam2
)
2871 LPMIDIOPENDESC lpDesc
;
2873 TRACE(mmsys
, "(%04X, %04X, %08lX, %08lX)\n",
2874 hMidiOut
, uMessage
, dwParam1
, dwParam2
);
2875 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2876 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2879 FIXME(mmsys
,"can't handle MODM_OPEN!\n");
2881 case MODM_GETDEVCAPS
:
2882 return midiOutGetDevCapsA(hMidiOut
, (LPMIDIOUTCAPSA
)dwParam1
, dwParam2
);
2883 case MODM_GETNUMDEVS
:
2886 case MODM_GETVOLUME
:
2887 case MODM_SETVOLUME
:
2890 case MODM_UNPREPARE
:
2891 /* no argument conversion needed */
2894 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2895 hMidiOut
,uMessage
, dwParam1
, dwParam2
);
2898 return modMessage(lpDesc
->wDevID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
2901 /**************************************************************************
2902 * midiOutMessage [MMSYSTEM.216]
2904 DWORD WINAPI
midiOutMessage16(HMIDIOUT16 hMidiOut
, UINT16 uMessage
,
2905 DWORD dwParam1
, DWORD dwParam2
)
2907 LPMIDIOPENDESC lpDesc
;
2909 TRACE(mmsys
, "(%04X, %04X, %08lX, %08lX)\n",
2910 hMidiOut
, uMessage
, dwParam1
, dwParam2
);
2911 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiOut
);
2912 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
2915 FIXME(mmsys
,"can't handle MODM_OPEN!\n");
2917 case MODM_GETNUMDEVS
:
2920 case MODM_SETVOLUME
:
2921 /* no argument conversion needed */
2923 case MODM_GETVOLUME
:
2924 return midiOutGetVolume16(hMidiOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
2926 return midiOutLongMsg16(hMidiOut
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2928 return midiOutPrepareHeader16(hMidiOut
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2929 case MODM_UNPREPARE
:
2930 return midiOutUnprepareHeader16(hMidiOut
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
2932 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2933 hMidiOut
,uMessage
, dwParam1
, dwParam2
);
2936 return modMessage(lpDesc
->wDevID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
2939 /**************************************************************************
2940 * midiInGetNumDevs [WINMM.64]
2942 UINT WINAPI
midiInGetNumDevs(void)
2944 return midiInGetNumDevs16();
2947 /**************************************************************************
2948 * midiInGetNumDevs [MMSYSTEM.301]
2950 UINT16 WINAPI
midiInGetNumDevs16(void)
2953 TRACE(mmsys
, "midiInGetNumDevs\n");
2954 count
+= midMessage(0, MIDM_GETNUMDEVS
, 0L, 0L, 0L);
2955 TRACE(mmsys
, "midiInGetNumDevs return %u \n", count
);
2959 /**************************************************************************
2960 * midiInGetDevCaps [WINMM.60]
2962 UINT WINAPI
midiInGetDevCapsW(UINT uDeviceID
,
2963 LPMIDIINCAPSW lpCaps
, UINT uSize
)
2966 UINT ret
= midiInGetDevCaps16(uDeviceID
, &mic16
,uSize
);
2968 lpCaps
->wMid
= mic16
.wMid
;
2969 lpCaps
->wPid
= mic16
.wPid
;
2970 lpCaps
->vDriverVersion
= mic16
.vDriverVersion
;
2971 lstrcpyAtoW(lpCaps
->szPname
, mic16
.szPname
);
2972 lpCaps
->dwSupport
= mic16
.dwSupport
;
2976 /**************************************************************************
2977 * midiInGetDevCaps [WINMM.59]
2979 UINT WINAPI
midiInGetDevCapsA(UINT uDeviceID
,
2980 LPMIDIINCAPSA lpCaps
, UINT uSize
)
2983 UINT ret
= midiInGetDevCaps16(uDeviceID
, &mic16
,uSize
);
2985 lpCaps
->wMid
= mic16
.wMid
;
2986 lpCaps
->wPid
= mic16
.wPid
;
2987 lpCaps
->vDriverVersion
= mic16
.vDriverVersion
;
2988 strcpy(lpCaps
->szPname
, mic16
.szPname
);
2989 lpCaps
->dwSupport
= mic16
.dwSupport
;
2993 /**************************************************************************
2994 * midiInGetDevCaps [MMSYSTEM.302]
2996 UINT16 WINAPI
midiInGetDevCaps16(UINT16 uDeviceID
,
2997 LPMIDIINCAPS16 lpCaps
, UINT16 uSize
)
2999 TRACE(mmsys
, "midiInGetDevCaps\n");
3000 return midMessage(uDeviceID
, MIDM_GETDEVCAPS
, 0, (DWORD
)lpCaps
, uSize
);
3003 /**************************************************************************
3004 * midiInGetErrorText [WINMM.62]
3006 UINT WINAPI
midiInGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
3008 LPSTR xstr
= HeapAlloc(GetProcessHeap(), 0,uSize
);
3009 UINT ret
= midiInGetErrorText16(uError
,xstr
,uSize
);
3010 lstrcpyAtoW(lpText
,xstr
);
3011 HeapFree(GetProcessHeap(), 0,xstr
);
3015 /**************************************************************************
3016 * midiInGetErrorText [WINMM.61]
3018 UINT WINAPI
midiInGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
3020 return midiInGetErrorText16(uError
, lpText
,uSize
);
3023 /**************************************************************************
3024 * midiInGetErrorText [MMSYSTEM.303]
3026 UINT16 WINAPI
midiInGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
3028 TRACE(mmsys
, "midiInGetErrorText\n");
3029 return (midiGetErrorText(uError
, lpText
, uSize
));
3032 /**************************************************************************
3033 * midiInOpen [WINMM.66]
3035 UINT WINAPI
midiInOpen(HMIDIIN
* lphMidiIn
, UINT uDeviceID
,
3036 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
3039 UINT ret
= midiInOpen16(&xhmid16
,uDeviceID
, dwCallback
, dwInstance
,
3040 CALLBACK32CONV(dwFlags
));
3042 *lphMidiIn
= xhmid16
;
3046 /**************************************************************************
3047 * midiInOpen [MMSYSTEM.304]
3049 UINT16 WINAPI
midiInOpen16(HMIDIIN16
* lphMidiIn
, UINT16 uDeviceID
,
3050 DWORD dwCallback
, DWORD dwInstance
, DWORD dwFlags
)
3053 LPMIDIOPENDESC lpDesc
;
3055 BOOL bMapperFlg
= FALSE
;
3057 if (lphMidiIn
!= NULL
)
3059 TRACE(mmsys
, "(%p, %d, %08lX, %08lX, %08lX);\n",
3060 lphMidiIn
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
3061 if (uDeviceID
== (UINT16
)MIDI_MAPPER
) {
3062 TRACE(mmsys
, "MIDI_MAPPER mode requested !\n");
3066 hMidiIn
= USER_HEAP_ALLOC(sizeof(MIDIOPENDESC
));
3067 if (lphMidiIn
!= NULL
)
3068 *lphMidiIn
= hMidiIn
;
3069 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3071 return MMSYSERR_NOMEM
;
3072 lpDesc
->hMidi
= hMidiIn
;
3073 lpDesc
->dwCallback
= dwCallback
;
3074 lpDesc
->dwInstance
= dwInstance
;
3076 while (uDeviceID
< MAXMIDIDRIVERS
) {
3077 dwRet
= midMessage(uDeviceID
, MIDM_OPEN
,
3078 lpDesc
->dwInstance
, (DWORD
)lpDesc
, dwFlags
);
3079 if (dwRet
== MMSYSERR_NOERROR
)
3084 TRACE(mmsys
, "MIDI_MAPPER mode ! try next driver...\n");
3086 lpDesc
->wDevID
= uDeviceID
;
3090 /**************************************************************************
3091 * midiInClose [WINMM.58]
3093 UINT WINAPI
midiInClose(HMIDIIN hMidiIn
)
3095 return midiInClose16(hMidiIn
);
3098 /**************************************************************************
3099 * midiInClose [MMSYSTEM.305]
3101 UINT16 WINAPI
midiInClose16(HMIDIIN16 hMidiIn
)
3103 LPMIDIOPENDESC lpDesc
;
3104 TRACE(mmsys
, "(%04X)\n", hMidiIn
);
3105 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3106 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3107 return midMessage(lpDesc
->wDevID
, MIDM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
3110 /**************************************************************************
3111 * midiInPrepareHeader [WINMM.67]
3113 UINT WINAPI
midiInPrepareHeader(HMIDIIN hMidiIn
,
3114 MIDIHDR16
* lpMidiInHdr
, UINT uSize
)
3116 LPMIDIOPENDESC lpDesc
;
3118 TRACE(mmsys
, "(%04X, %p, %d)\n",
3119 hMidiIn
, lpMidiInHdr
, uSize
);
3120 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3121 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3122 lpMidiInHdr
->reserved
= (DWORD
)lpMidiInHdr
->lpData
;
3123 return midMessage(lpDesc
->wDevID
, MIDM_PREPARE
, lpDesc
->dwInstance
,
3124 (DWORD
)lpMidiInHdr
, (DWORD
)uSize
);
3127 /**************************************************************************
3128 * midiInPrepareHeader [MMSYSTEM.306]
3130 UINT16 WINAPI
midiInPrepareHeader16(HMIDIIN16 hMidiIn
,
3131 MIDIHDR16
* lpMidiInHdr
, UINT16 uSize
)
3133 LPMIDIOPENDESC lpDesc
;
3135 TRACE(mmsys
, "(%04X, %p, %d)\n",
3136 hMidiIn
, lpMidiInHdr
, uSize
);
3137 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3138 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3139 lpMidiInHdr
->reserved
= (DWORD
)PTR_SEG_TO_LIN(lpMidiInHdr
->lpData
);
3140 return midMessage(lpDesc
->wDevID
, MIDM_PREPARE
, lpDesc
->dwInstance
,
3141 (DWORD
)lpMidiInHdr
, (DWORD
)uSize
);
3144 /**************************************************************************
3145 * midiInUnprepareHeader [WINMM.71]
3147 UINT WINAPI
midiInUnprepareHeader(HMIDIIN hMidiIn
,
3148 MIDIHDR16
* lpMidiInHdr
, UINT uSize
)
3150 return midiInUnprepareHeader16(hMidiIn
, lpMidiInHdr
,uSize
);
3153 /**************************************************************************
3154 * midiInUnprepareHeader [MMSYSTEM.307]
3156 UINT16 WINAPI
midiInUnprepareHeader16(HMIDIIN16 hMidiIn
,
3157 MIDIHDR16
* lpMidiInHdr
, UINT16 uSize
)
3159 LPMIDIOPENDESC lpDesc
;
3160 TRACE(mmsys
, "(%04X, %p, %d)\n",
3161 hMidiIn
, lpMidiInHdr
, uSize
);
3162 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3163 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3164 return midMessage(lpDesc
->wDevID
, MIDM_UNPREPARE
, lpDesc
->dwInstance
,
3165 (DWORD
)lpMidiInHdr
, (DWORD
)uSize
);
3168 /**************************************************************************
3169 * midiInAddBuffer [WINMM.57]
3171 UINT WINAPI
midiInAddBuffer(HMIDIIN hMidiIn
,
3172 MIDIHDR16
* lpMidiInHdr
, UINT uSize
)
3174 return midiInAddBuffer16(hMidiIn
, lpMidiInHdr
,uSize
);
3177 /**************************************************************************
3178 * midiInAddBuffer [MMSYSTEM.308]
3180 UINT16 WINAPI
midiInAddBuffer16(HMIDIIN16 hMidiIn
,
3181 MIDIHDR16
* lpMidiInHdr
, UINT16 uSize
)
3183 TRACE(mmsys
, "midiInAddBuffer\n");
3187 /**************************************************************************
3188 * midiInStart [WINMM.69]
3190 UINT WINAPI
midiInStart(HMIDIIN hMidiIn
)
3192 return midiInStart16(hMidiIn
);
3195 /**************************************************************************
3196 * midiInStart [MMSYSTEM.309]
3198 UINT16 WINAPI
midiInStart16(HMIDIIN16 hMidiIn
)
3200 LPMIDIOPENDESC lpDesc
;
3202 TRACE(mmsys
, "(%04X)\n", hMidiIn
);
3203 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3205 return MMSYSERR_INVALHANDLE
;
3206 return midMessage(lpDesc
->wDevID
, MIDM_START
, lpDesc
->dwInstance
, 0L, 0L);
3209 /**************************************************************************
3210 * midiInStop [WINMM.70]
3212 UINT WINAPI
midiInStop(HMIDIIN hMidiIn
)
3214 return midiInStop16(hMidiIn
);
3217 /**************************************************************************
3218 * midiInStop [MMSYSTEM.310]
3220 UINT16 WINAPI
midiInStop16(HMIDIIN16 hMidiIn
)
3222 LPMIDIOPENDESC lpDesc
;
3224 TRACE(mmsys
, "(%04X)\n", hMidiIn
);
3225 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3227 return MMSYSERR_INVALHANDLE
;
3228 return midMessage(lpDesc
->wDevID
, MIDM_STOP
, lpDesc
->dwInstance
, 0L, 0L);
3231 /**************************************************************************
3232 * midiInReset [WINMM.68]
3234 UINT WINAPI
midiInReset(HMIDIIN hMidiIn
)
3236 return midiInReset16(hMidiIn
);
3239 /**************************************************************************
3240 * midiInReset [MMSYSTEM.311]
3242 UINT16 WINAPI
midiInReset16(HMIDIIN16 hMidiIn
)
3244 LPMIDIOPENDESC lpDesc
;
3246 TRACE(mmsys
, "(%04X)\n", hMidiIn
);
3247 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3249 return MMSYSERR_INVALHANDLE
;
3250 return midMessage(lpDesc
->wDevID
, MIDM_RESET
, lpDesc
->dwInstance
, 0L, 0L);
3253 /**************************************************************************
3254 * midiInGetID [WINMM.63]
3256 UINT WINAPI
midiInGetID(HMIDIIN hMidiIn
, UINT
* lpuDeviceID
)
3258 LPMIDIOPENDESC lpDesc
;
3260 TRACE(mmsys
, "(%04X, %p)\n", hMidiIn
, lpuDeviceID
);
3261 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3263 return MMSYSERR_INVALHANDLE
;
3264 if (lpuDeviceID
== NULL
)
3265 return MMSYSERR_INVALPARAM
;
3266 *lpuDeviceID
= lpDesc
->wDevID
;
3268 return MMSYSERR_NOERROR
;
3271 /**************************************************************************
3272 * midiInGetID [MMSYSTEM.312]
3274 UINT16 WINAPI
midiInGetID16(HMIDIIN16 hMidiIn
, UINT16
* lpuDeviceID
)
3276 LPMIDIOPENDESC lpDesc
;
3278 TRACE(mmsys
, "(%04X, %p)\n", hMidiIn
, lpuDeviceID
);
3279 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3281 return MMSYSERR_INVALHANDLE
;
3282 if (lpuDeviceID
== NULL
)
3283 return MMSYSERR_INVALPARAM
;
3284 *lpuDeviceID
= lpDesc
->wDevID
;
3286 return MMSYSERR_NOERROR
;
3289 /**************************************************************************
3290 * midiInMessage [WINMM.65]
3292 DWORD WINAPI
midiInMessage(HMIDIIN hMidiIn
, UINT uMessage
,
3293 DWORD dwParam1
, DWORD dwParam2
)
3295 LPMIDIOPENDESC lpDesc
;
3297 TRACE(mmsys
, "(%04X, %04X, %08lX, %08lX)\n",
3298 hMidiIn
, uMessage
, dwParam1
, dwParam2
);
3299 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3301 return MMSYSERR_INVALHANDLE
;
3305 FIXME(mmsys
,"can't handle MIDM_OPEN!\n");
3307 case MIDM_GETDEVCAPS
:
3308 return midiInGetDevCapsA(hMidiIn
, (LPMIDIINCAPSA
)dwParam1
, dwParam2
);
3309 case MIDM_GETNUMDEVS
:
3314 /* no argument conversion needed */
3317 return midiInPrepareHeader(hMidiIn
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
3318 case MIDM_UNPREPARE
:
3319 return midiInUnprepareHeader(hMidiIn
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
3320 case MIDM_ADDBUFFER
:
3321 return midiInAddBuffer(hMidiIn
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
3323 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
3324 hMidiIn
,uMessage
, dwParam1
, dwParam2
);
3327 return midMessage(0, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
3330 /**************************************************************************
3331 * midiInMessage [MMSYSTEM.313]
3333 DWORD WINAPI
midiInMessage16(HMIDIIN16 hMidiIn
, UINT16 uMessage
,
3334 DWORD dwParam1
, DWORD dwParam2
)
3336 LPMIDIOPENDESC lpDesc
;
3338 TRACE(mmsys
, "(%04X, %04X, %08lX, %08lX)\n", hMidiIn
, uMessage
, dwParam1
, dwParam2
);
3340 lpDesc
= (LPMIDIOPENDESC
) USER_HEAP_LIN_ADDR(hMidiIn
);
3341 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3344 WARN(mmsys
,"can't handle MIDM_OPEN!\n");
3346 case MIDM_GETDEVCAPS
:
3347 return midiInGetDevCaps16(hMidiIn
, (LPMIDIINCAPS16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
3348 case MIDM_GETNUMDEVS
:
3353 /* no argument conversion needed */
3356 return midiInPrepareHeader16(hMidiIn
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
3357 case MIDM_UNPREPARE
:
3358 return midiInUnprepareHeader16(hMidiIn
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
3359 case MIDM_ADDBUFFER
:
3360 return midiInAddBuffer16(hMidiIn
, (LPMIDIHDR16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
3362 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
3363 hMidiIn
,uMessage
, dwParam1
, dwParam2
);
3366 return midMessage(0, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
3369 #define MIDI_STREAM_MAGIC 0xC9080F17
3379 LPMIDIHDR lpMidiHdr
;
3382 /**************************************************************************
3383 * MMSYSTEM_MidiStreamPlayer [internal]
3385 static void WINE_UNUSED
MMSYSTEM_MidiStreamPlayer(WINE_MIDIStream
* ms
)
3387 /* FIXME: should I sleep a bit when there is no pending lpMidiHdr ?
3388 * => provide a better synchronization system
3389 * midiStreamPause/midiStreamRestart should freeze/thaw this thread
3390 * global resource should guard access to ms->lpMidiHdr list, or
3391 * use a MB to send new LPMIDIHDR
3392 * an empty ms->lpMidiHdr list should freeze this thread
3395 if (ms
->dwStatus
&& ms
->lpMidiHdr
) {
3396 LPMIDIEVENT me
= (LPMIDIEVENT
)(ms
->lpMidiHdr
->lpData
+ ms
->lpMidiHdr
->dwOffset
);
3398 FIXME(mmsys
, "Should wait for current time to be in sync with me->dwDeltaTime\n");
3400 if (me
->dwEvent
& MEVT_F_CALLBACK
) {
3401 WARN(mmsys
, "Should generate callback when encountering F_CALLBACK flagged midi events...\n");
3403 switch (MEVT_EVENTTYPE(me
->dwEvent
)) {
3405 /* do nothing, skip bytes */
3408 WARN(mmsys
, "NIY: sending Sysex Event");
3413 midiOutShortMsg(ms
->hDevice
, MEVT_EVENTPARM(me
->dwEvent
));
3416 ms
->dwTempo
= MEVT_EVENTPARM(me
->dwEvent
);
3421 ms
->lpMidiHdr
->dwOffset
+= sizeof(MIDIEVENT
);
3422 if (me
->dwEvent
& MEVT_F_LONG
) {
3423 ms
->lpMidiHdr
->dwOffset
+= MEVT_EVENTPARM(me
->dwEvent
);
3425 if (ms
->lpMidiHdr
->dwOffset
>= ms
->lpMidiHdr
->dwBufferLength
) {
3426 ms
->lpMidiHdr
->dwFlags
|= MHDR_DONE
;
3427 ms
->lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
3428 ms
->lpMidiHdr
= (LPMIDIHDR
)ms
->lpMidiHdr
->lpNext
;
3429 WARN(mmsys
, "Should generate callback when done with MIDIHDR...\n");
3431 FIXME(mmsys
, "Should accordingly update ms->dwMS with me->dwDeltaTime\n");
3436 /**************************************************************************
3437 * midiStreamClose [WINMM.90]
3439 MMRESULT WINAPI
midiStreamClose(HMIDISTRM hms
)
3441 WINE_MIDIStream
* ms
;
3443 TRACE(midi
, "(%08x)!\n", hms
);
3445 ms
= (WINE_MIDIStream
*)hms
;
3446 if (!ms
|| ms
->dwMagic
!= MIDI_STREAM_MAGIC
)
3447 return MMSYSERR_INVALHANDLE
;
3451 return MMSYSERR_NOTSUPPORTED
;
3454 /**************************************************************************
3455 * midiStreamOpen [WINMM.91]
3457 MMRESULT WINAPI
midiStreamOpen(HMIDISTRM
* phms
, LPUINT lpuDeviceID
,
3458 DWORD cMidi
, DWORD dwCallback
,
3459 DWORD dwInstance
, DWORD fdwOpen
)
3461 WINE_MIDIStream
* ms
;
3463 TRACE(midi
, "(%p,%p,%ld, 0x%08lx, 0x%08lx, 0x%08lx), stub!\n",
3464 phms
, lpuDeviceID
,cMidi
, dwCallback
, dwInstance
, fdwOpen
);
3466 if (cMidi
!= 1 || phms
== NULL
|| lpuDeviceID
== NULL
)
3467 return MMSYSERR_INVALPARAM
;
3469 ms
= malloc(sizeof(WINE_MIDIStream
));
3470 *phms
= (HMIDISTRM
)ms
;
3471 ms
->dwMagic
= MIDI_STREAM_MAGIC
;
3472 ms
->dwTempo
= 50000; /* FIXME */
3473 ms
->dwTimeDiv
= 1; /* FIXME */
3477 /* FIXME is this correct ? */
3479 /* FIXME is this correct ? */
3480 return midiOutOpen(&(ms
->hDevice
), *lpuDeviceID
, dwCallback
, dwInstance
, fdwOpen
);
3483 /**************************************************************************
3484 * midiStreamOut [WINMM.92]
3486 MMRESULT WINAPI
midiStreamOut(HMIDISTRM hms
, LPMIDIHDR16 lpMidiHdr
, UINT cbMidiHdr
)
3488 FIXME(midi
, "(%08x, %p, %u) stub!\n", hms
, lpMidiHdr
, cbMidiHdr
);
3489 return MMSYSERR_NOTSUPPORTED
;
3492 /**************************************************************************
3493 * midiStreamPause [WINMM.93]
3495 MMRESULT WINAPI
midiStreamPause(HMIDISTRM hms
)
3497 WINE_MIDIStream
* ms
;
3499 TRACE(midi
, "(%08x)!\n", hms
);
3501 ms
= (WINE_MIDIStream
*)hms
;
3502 if (!ms
|| ms
->dwMagic
!= MIDI_STREAM_MAGIC
)
3503 return MMSYSERR_INVALHANDLE
;
3506 return MMSYSERR_NOERROR
;
3509 /**************************************************************************
3510 * midiStreamPosition [WINMM.94]
3512 MMRESULT WINAPI
midiStreamPosition(HMIDISTRM hms
, LPMMTIME lpMMT
, UINT cbmmt
)
3514 WINE_MIDIStream
* ms
;
3515 DWORD ret
= MMSYSERR_NOERROR
;
3517 FIXME(midi
, "(%08x, %p, %u) stub!\n", hms
, lpMMT
, cbmmt
);
3519 ms
= (WINE_MIDIStream
*)hms
;
3521 if (!ms
|| ms
->dwMagic
!= MIDI_STREAM_MAGIC
) {
3522 ret
= MMSYSERR_INVALHANDLE
;
3523 } else if (lpMMT
== NULL
|| cbmmt
!= sizeof(MMTIME
)) {
3524 ret
= MMSYSERR_INVALPARAM
;
3526 switch (lpMMT
->wType
) {
3528 lpMMT
->u
.ms
= ms
->dwMS
;
3531 lpMMT
->wType
= TIME_MS
;
3532 ret
= MMSYSERR_INVALPARAM
;
3538 /**************************************************************************
3539 * midiStreamProperty [WINMM.95]
3541 MMRESULT WINAPI
midiStreamProperty(HMIDISTRM hms
, LPBYTE lpPropData
, DWORD dwProperty
)
3543 WINE_MIDIStream
* ms
= (WINE_MIDIStream
*)hms
;
3544 MMRESULT ret
= MMSYSERR_NOERROR
;
3546 TRACE(midi
, "(%08x, %p, %lx)\n", hms
, lpPropData
, dwProperty
);
3548 if (!ms
|| ms
->dwMagic
!= MIDI_STREAM_MAGIC
) {
3549 ret
= MMSYSERR_INVALHANDLE
;
3550 } else if ((dwProperty
& (MIDIPROP_GET
|MIDIPROP_SET
)) == 0) {
3551 return MMSYSERR_INVALPARAM
;
3552 } else if (dwProperty
& MIDIPROP_TEMPO
) {
3553 MIDIPROPTEMPO
* mpt
= (MIDIPROPTEMPO
*)lpPropData
;
3555 if (sizeof(MIDIPROPTEMPO
) != mpt
->cbStruct
) {
3556 ret
= MMSYSERR_INVALPARAM
;
3557 } else if (dwProperty
& MIDIPROP_GET
) {
3558 ms
->dwTempo
= mpt
->dwTempo
;
3559 } else if (dwProperty
& MIDIPROP_SET
) {
3560 mpt
->dwTempo
= ms
->dwTempo
;
3562 } else if (dwProperty
& MIDIPROP_TIMEDIV
) {
3563 MIDIPROPTIMEDIV
* mptd
= (MIDIPROPTIMEDIV
*)lpPropData
;
3565 if (sizeof(MIDIPROPTIMEDIV
) != mptd
->cbStruct
) {
3566 ret
= MMSYSERR_INVALPARAM
;
3567 } else if (dwProperty
& MIDIPROP_GET
) {
3568 ms
->dwTimeDiv
= mptd
->dwTimeDiv
;
3569 } else if (dwProperty
& MIDIPROP_SET
) {
3570 mptd
->dwTimeDiv
= ms
->dwTimeDiv
;
3573 ret
= MMSYSERR_INVALPARAM
;
3579 /**************************************************************************
3580 * midiStreamRestart [WINMM.96]
3582 MMRESULT WINAPI
midiStreamRestart(HMIDISTRM hms
)
3584 WINE_MIDIStream
* ms
;
3586 TRACE(midi
, "(%08x)!\n", hms
);
3588 ms
= (WINE_MIDIStream
*)hms
;
3589 if (!ms
|| ms
->dwMagic
!= MIDI_STREAM_MAGIC
)
3590 return MMSYSERR_INVALHANDLE
;
3593 return MMSYSERR_NOERROR
;
3596 /**************************************************************************
3597 * midiStreamStop [WINMM.97]
3599 MMRESULT WINAPI
midiStreamStop(HMIDISTRM hms
)
3601 FIXME(midi
, "(%08x stub!)\n", hms
);
3602 return MMSYSERR_NOTSUPPORTED
;
3605 /**************************************************************************
3606 * midiStreamClose [MMSYSTEM.252]
3608 MMRESULT16 WINAPI
midiStreamClose16(HMIDISTRM16 hms
)
3610 return midiStreamClose(hms
);
3613 /**************************************************************************
3614 * midiStreamOpen [MMSYSTEM.251]
3616 MMRESULT16 WINAPI
midiStreamOpen16(HMIDISTRM16
* phms
, LPUINT16 devid
,
3617 DWORD cMidi
, DWORD dwCallback
,
3618 DWORD dwInstance
, DWORD fdwOpen
)
3624 if (!phms
|| !devid
)
3625 return MMSYSERR_INVALPARAM
;
3627 ret
= midiStreamOpen(&hms32
, &devid32
, cMidi
, dwCallback
, dwInstance
, fdwOpen
);
3633 /**************************************************************************
3634 * midiStreamOut [MMSYSTEM.254]
3636 MMRESULT16 WINAPI
midiStreamOut16(HMIDISTRM16 hms
, LPMIDIHDR16 lpMidiHdr
, UINT16 cbMidiHdr
)
3638 return midiStreamOut(hms
, lpMidiHdr
, cbMidiHdr
);
3641 /**************************************************************************
3642 * midiStreamPause [MMSYSTEM.255]
3644 MMRESULT16 WINAPI
midiStreamPause16(HMIDISTRM16 hms
)
3646 return midiStreamPause(hms
);
3649 /**************************************************************************
3650 * midiStreamPosition [MMSYSTEM.253]
3652 MMRESULT16 WINAPI
midiStreamPosition16(HMIDISTRM16 hms
, LPMMTIME16 lpmmt
, UINT16 cbmmt
)
3658 return MMSYSERR_INVALPARAM
;
3659 MMSYSTEM_MMTIME16to32(&mmt32
, lpmmt
);
3660 ret
= midiStreamPosition(hms
, &mmt32
, cbmmt
);
3661 MMSYSTEM_MMTIME32to16(lpmmt
, &mmt32
);
3665 /**************************************************************************
3666 * midiStreamProperty [MMSYSTEM.250]
3668 MMRESULT16 WINAPI
midiStreamProperty16(HMIDISTRM16 hms
, LPBYTE lpPropData
, DWORD dwProperty
)
3670 return midiStreamProperty(hms
, lpPropData
, dwProperty
);
3673 /**************************************************************************
3674 * midiStreamRestart [MMSYSTEM.256]
3676 MMRESULT16 WINAPI
midiStreamRestart16(HMIDISTRM16 hms
)
3678 return midiStreamRestart(hms
);
3681 /**************************************************************************
3682 * midiStreamStop [MMSYSTEM.257]
3684 MMRESULT16 WINAPI
midiStreamStop16(HMIDISTRM16 hms
)
3686 return midiStreamStop(hms
);
3689 /**************************************************************************
3690 * waveOutGetNumDevs [MMSYSTEM.401]
3692 UINT WINAPI
waveOutGetNumDevs() {
3693 return waveOutGetNumDevs16();
3696 /**************************************************************************
3697 * waveOutGetNumDevs [WINMM.167]
3699 UINT16 WINAPI
waveOutGetNumDevs16()
3702 TRACE(mmsys
, "waveOutGetNumDevs\n");
3703 /* FIXME: I'm not sure MCI_FirstDevID() is correct */
3704 count
+= wodMessage(MCI_FirstDevID(), WODM_GETNUMDEVS
, 0L, 0L, 0L);
3705 TRACE(mmsys
, "waveOutGetNumDevs return %u \n", count
);
3709 /**************************************************************************
3710 * waveOutGetDevCaps [MMSYSTEM.402]
3712 UINT16 WINAPI
waveOutGetDevCaps16(UINT16 uDeviceID
, WAVEOUTCAPS16
* lpCaps
,
3715 if (uDeviceID
> waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID
;
3716 if (uDeviceID
== (UINT16
)WAVE_MAPPER
) return MMSYSERR_BADDEVICEID
; /* FIXME: do we have a wave mapper ? */
3717 TRACE(mmsys
, "waveOutGetDevCaps\n");
3718 return wodMessage(uDeviceID
, WODM_GETDEVCAPS
, 0L, (DWORD
)lpCaps
, uSize
);
3721 /**************************************************************************
3722 * waveOutGetDevCapsA [WINMM.162]
3724 UINT WINAPI
waveOutGetDevCapsA(UINT uDeviceID
, LPWAVEOUTCAPSA lpCaps
,
3727 WAVEOUTCAPS16 woc16
;
3728 UINT16 ret
= waveOutGetDevCaps16(uDeviceID
, &woc16
, sizeof(woc16
));
3730 lpCaps
->wMid
= woc16
.wMid
;
3731 lpCaps
->wPid
= woc16
.wPid
;
3732 lpCaps
->vDriverVersion
= woc16
.vDriverVersion
;
3733 strcpy(lpCaps
->szPname
, woc16
.szPname
);
3734 lpCaps
->dwFormats
= woc16
.dwFormats
;
3735 lpCaps
->wChannels
= woc16
.wChannels
;
3736 lpCaps
->dwSupport
= woc16
.dwSupport
;
3740 /**************************************************************************
3741 * waveOutGetDevCapsW [WINMM.163]
3743 UINT WINAPI
waveOutGetDevCapsW(UINT uDeviceID
, LPWAVEOUTCAPSW lpCaps
,
3746 WAVEOUTCAPS16 woc16
;
3747 UINT ret
= waveOutGetDevCaps16(uDeviceID
, &woc16
, sizeof(woc16
));
3749 lpCaps
->wMid
= woc16
.wMid
;
3750 lpCaps
->wPid
= woc16
.wPid
;
3751 lpCaps
->vDriverVersion
= woc16
.vDriverVersion
;
3752 lstrcpyAtoW(lpCaps
->szPname
, woc16
.szPname
);
3753 lpCaps
->dwFormats
= woc16
.dwFormats
;
3754 lpCaps
->wChannels
= woc16
.wChannels
;
3755 lpCaps
->dwSupport
= woc16
.dwSupport
;
3759 /**************************************************************************
3760 * waveOutGetErrorText [MMSYSTEM.403]
3762 UINT16 WINAPI
waveOutGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
3764 TRACE(mmsys
, "waveOutGetErrorText\n");
3765 return(waveGetErrorText(uError
, lpText
, uSize
));
3768 /**************************************************************************
3769 * waveOutGetErrorTextA [WINMM.164]
3771 UINT WINAPI
waveOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
3773 return(waveOutGetErrorText16(uError
, lpText
, uSize
));
3776 /**************************************************************************
3777 * waveOutGetErrorTextW [WINMM.165]
3779 UINT WINAPI
waveOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
3781 LPSTR xstr
= HeapAlloc(GetProcessHeap(), 0,uSize
);
3782 UINT ret
= waveOutGetErrorTextA(uError
, xstr
, uSize
);
3784 lstrcpyAtoW(lpText
,xstr
);
3785 HeapFree(GetProcessHeap(), 0,xstr
);
3789 /**************************************************************************
3790 * waveGetErrorText [internal]
3792 static UINT16
waveGetErrorText(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
3795 TRACE(mmsys
, "(%04X, %p, %d);\n",
3796 uError
, lpText
, uSize
);
3797 if ((lpText
== NULL
) || (uSize
< 1)) return(FALSE
);
3800 case MMSYSERR_NOERROR
:
3801 msgptr
= "The specified command was carried out.";
3803 case MMSYSERR_ERROR
:
3804 msgptr
= "Undefined external error.";
3806 case MMSYSERR_BADDEVICEID
:
3807 msgptr
= "A device ID has been used that is out of range for your system.";
3809 case MMSYSERR_NOTENABLED
:
3810 msgptr
= "The driver was not enabled.";
3812 case MMSYSERR_ALLOCATED
:
3813 msgptr
= "The specified device is already in use. Wait until it is free, and then try again.";
3815 case MMSYSERR_INVALHANDLE
:
3816 msgptr
= "The specified device handle is invalid.";
3818 case MMSYSERR_NODRIVER
:
3819 msgptr
= "There is no driver installed on your system !\n";
3821 case MMSYSERR_NOMEM
:
3822 msgptr
= "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
3824 case MMSYSERR_NOTSUPPORTED
:
3825 msgptr
= "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
3827 case MMSYSERR_BADERRNUM
:
3828 msgptr
= "An error number was specified that is not defined in the system.";
3830 case MMSYSERR_INVALFLAG
:
3831 msgptr
= "An invalid flag was passed to a system function.";
3833 case MMSYSERR_INVALPARAM
:
3834 msgptr
= "An invalid parameter was passed to a system function.";
3836 case WAVERR_BADFORMAT
:
3837 msgptr
= "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
3839 case WAVERR_STILLPLAYING
:
3840 msgptr
= "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
3842 case WAVERR_UNPREPARED
:
3843 msgptr
= "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
3846 msgptr
= "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
3849 msgptr
= "Unknown MMSYSTEM Error !\n";
3852 lstrcpynA(lpText
, msgptr
, uSize
);
3856 /**************************************************************************
3857 * waveOutOpen [WINMM.173]
3858 * All the args/structs have the same layout as the win16 equivalents
3860 UINT WINAPI
waveOutOpen(HWAVEOUT
* lphWaveOut
, UINT uDeviceID
,
3861 const LPWAVEFORMATEX lpFormat
, DWORD dwCallback
,
3862 DWORD dwInstance
, DWORD dwFlags
)
3865 UINT ret
= waveOutOpen16(&hwo16
,uDeviceID
, lpFormat
, dwCallback
, dwInstance
,
3866 CALLBACK32CONV(dwFlags
));
3868 if (lphWaveOut
) *lphWaveOut
=hwo16
;
3872 /**************************************************************************
3873 * waveOutOpen [MMSYSTEM.404]
3875 UINT16 WINAPI
waveOutOpen16(HWAVEOUT16
* lphWaveOut
, UINT16 uDeviceID
,
3876 const LPWAVEFORMATEX lpFormat
, DWORD dwCallback
,
3877 DWORD dwInstance
, DWORD dwFlags
)
3879 HWAVEOUT16 hWaveOut
;
3880 LPWAVEOPENDESC lpDesc
;
3882 BOOL bMapperFlg
= FALSE
;
3884 TRACE(mmsys
, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3885 lphWaveOut
, uDeviceID
, lpFormat
, dwCallback
, dwInstance
, dwFlags
);
3886 if (dwFlags
& WAVE_FORMAT_QUERY
)
3887 TRACE(mmsys
, "WAVE_FORMAT_QUERY requested !\n");
3888 if (uDeviceID
== (UINT16
)WAVE_MAPPER
) {
3889 TRACE(mmsys
, "WAVE_MAPPER mode requested !\n");
3893 if (lpFormat
== NULL
) return WAVERR_BADFORMAT
;
3895 hWaveOut
= USER_HEAP_ALLOC(sizeof(WAVEOPENDESC
));
3896 if (lphWaveOut
!= NULL
) *lphWaveOut
= hWaveOut
;
3897 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3898 if (lpDesc
== NULL
) return MMSYSERR_NOMEM
;
3899 lpDesc
->hWave
= hWaveOut
;
3900 lpDesc
->lpFormat
= (LPWAVEFORMAT
)lpFormat
; /* should the struct be copied iso pointer? */
3901 lpDesc
->dwCallBack
= dwCallback
;
3902 lpDesc
->dwInstance
= dwInstance
;
3903 if (uDeviceID
>= MAXWAVEDRIVERS
)
3905 while (uDeviceID
< MAXWAVEDRIVERS
) {
3906 dwRet
= wodMessage(uDeviceID
, WODM_OPEN
,
3907 lpDesc
->dwInstance
, (DWORD
)lpDesc
, dwFlags
);
3908 if (dwRet
== MMSYSERR_NOERROR
) break;
3909 if (!bMapperFlg
) break;
3911 TRACE(mmsys
, "WAVE_MAPPER mode ! try next driver...\n");
3913 lpDesc
->uDeviceID
= uDeviceID
; /* save physical Device ID */
3914 if (dwFlags
& WAVE_FORMAT_QUERY
) {
3915 TRACE(mmsys
, "End of WAVE_FORMAT_QUERY !\n");
3916 dwRet
= waveOutClose(hWaveOut
);
3921 /**************************************************************************
3922 * waveOutClose [WINMM.161]
3924 UINT WINAPI
waveOutClose(HWAVEOUT hWaveOut
)
3926 return waveOutClose16(hWaveOut
);
3929 /**************************************************************************
3930 * waveOutClose [MMSYSTEM.405]
3932 UINT16 WINAPI
waveOutClose16(HWAVEOUT16 hWaveOut
)
3934 LPWAVEOPENDESC lpDesc
;
3936 TRACE(mmsys
, "(%04X)\n", hWaveOut
);
3938 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3939 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3940 return wodMessage(lpDesc
->uDeviceID
, WODM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
3943 /**************************************************************************
3944 * waveOutPrepareHeader [WINMM.175]
3946 UINT WINAPI
waveOutPrepareHeader(HWAVEOUT hWaveOut
,
3947 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
3949 LPWAVEOPENDESC lpDesc
;
3951 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3953 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3954 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3955 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
->lpData
;
3956 return wodMessage(lpDesc
->uDeviceID
, WODM_PREPARE
, lpDesc
->dwInstance
,
3957 (DWORD
)lpWaveOutHdr
,uSize
);
3960 /**************************************************************************
3961 * waveOutPrepareHeader [MMSYSTEM.406]
3963 UINT16 WINAPI
waveOutPrepareHeader16(HWAVEOUT16 hWaveOut
,
3964 WAVEHDR
* lpWaveOutHdr
, UINT16 uSize
)
3966 LPWAVEOPENDESC lpDesc
;
3969 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3971 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3972 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3973 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
->lpData
;
3974 lpWaveOutHdr
->lpData
= PTR_SEG_TO_LIN(lpWaveOutHdr
->lpData
);
3975 ret
= wodMessage(lpDesc
->uDeviceID
, WODM_PREPARE
, lpDesc
->dwInstance
,
3976 (DWORD
)lpWaveOutHdr
,uSize
);
3977 lpWaveOutHdr
->lpData
= lpWaveOutHdr
->lpData
;
3981 /**************************************************************************
3982 * waveOutUnprepareHeader [WINMM.181]
3984 UINT WINAPI
waveOutUnprepareHeader(HWAVEOUT hWaveOut
,
3985 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
3987 LPWAVEOPENDESC lpDesc
;
3989 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
3991 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
3992 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
3993 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
->lpData
;
3994 return wodMessage(lpDesc
->uDeviceID
, WODM_UNPREPARE
, lpDesc
->dwInstance
,
3995 (DWORD
)lpWaveOutHdr
, uSize
);
3998 /**************************************************************************
3999 * waveOutUnprepareHeader [MMSYSTEM.407]
4001 UINT16 WINAPI
waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut
,
4002 WAVEHDR
* lpWaveOutHdr
, UINT16 uSize
)
4004 LPWAVEOPENDESC lpDesc
;
4007 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
4009 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4010 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4011 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
->lpData
;
4012 lpWaveOutHdr
->lpData
= PTR_SEG_TO_LIN(lpWaveOutHdr
->lpData
);
4013 ret
= wodMessage(lpDesc
->uDeviceID
, WODM_UNPREPARE
, lpDesc
->dwInstance
,
4014 (DWORD
)lpWaveOutHdr
, uSize
);
4015 lpWaveOutHdr
->lpData
= (LPBYTE
)lpWaveOutHdr
->reserved
;
4019 /**************************************************************************
4020 * waveOutWrite [MMSYSTEM.408]
4022 UINT WINAPI
waveOutWrite(HWAVEOUT hWaveOut
, WAVEHDR
* lpWaveOutHdr
,
4025 LPWAVEOPENDESC lpDesc
;
4027 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
4029 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4030 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4031 lpWaveOutHdr
->reserved
= (DWORD
)lpWaveOutHdr
->lpData
;
4032 return wodMessage(lpDesc
->uDeviceID
, WODM_WRITE
, lpDesc
->dwInstance
, (DWORD
)lpWaveOutHdr
, uSize
);
4035 /**************************************************************************
4036 * waveOutWrite [MMSYSTEM.408]
4038 UINT16 WINAPI
waveOutWrite16(HWAVEOUT16 hWaveOut
, WAVEHDR
* lpWaveOutHdr
,
4041 LPWAVEOPENDESC lpDesc
;
4044 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
4046 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4047 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4048 lpWaveOutHdr
->reserved
=(DWORD
)lpWaveOutHdr
->lpData
;/*save original ptr*/
4049 lpWaveOutHdr
->lpData
= PTR_SEG_TO_LIN(lpWaveOutHdr
->lpData
);
4050 ret
= wodMessage(lpDesc
->uDeviceID
, WODM_WRITE
, lpDesc
->dwInstance
, (DWORD
)lpWaveOutHdr
, uSize
);
4051 lpWaveOutHdr
->lpData
= (LPBYTE
)lpWaveOutHdr
->reserved
;
4055 /**************************************************************************
4056 * waveOutPause [WINMM.174]
4058 UINT WINAPI
waveOutPause(HWAVEOUT hWaveOut
)
4060 return waveOutPause16(hWaveOut
);
4063 /**************************************************************************
4064 * waveOutPause [MMSYSTEM.409]
4066 UINT16 WINAPI
waveOutPause16(HWAVEOUT16 hWaveOut
)
4068 LPWAVEOPENDESC lpDesc
;
4070 TRACE(mmsys
, "(%04X)\n", hWaveOut
);
4072 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4073 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4074 return wodMessage(lpDesc
->uDeviceID
, WODM_PAUSE
, lpDesc
->dwInstance
, 0L, 0L);
4077 /**************************************************************************
4078 * waveOutRestart [WINMM.177]
4080 UINT WINAPI
waveOutRestart(HWAVEOUT hWaveOut
)
4082 return waveOutRestart16(hWaveOut
);
4085 /**************************************************************************
4086 * waveOutRestart [MMSYSTEM.410]
4088 UINT16 WINAPI
waveOutRestart16(HWAVEOUT16 hWaveOut
)
4090 LPWAVEOPENDESC lpDesc
;
4092 TRACE(mmsys
, "(%04X)\n", hWaveOut
);
4094 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4095 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4096 return wodMessage(lpDesc
->uDeviceID
, WODM_RESTART
, lpDesc
->dwInstance
, 0L, 0L);
4099 /**************************************************************************
4100 * waveOutReset [WINMM.176]
4102 UINT WINAPI
waveOutReset(HWAVEOUT hWaveOut
)
4104 return waveOutReset16(hWaveOut
);
4107 /**************************************************************************
4108 * waveOutReset [MMSYSTEM.411]
4110 UINT16 WINAPI
waveOutReset16(HWAVEOUT16 hWaveOut
)
4112 LPWAVEOPENDESC lpDesc
;
4114 TRACE(mmsys
, "(%04X)\n", hWaveOut
);
4116 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4117 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4118 return wodMessage(lpDesc
->uDeviceID
, WODM_RESET
, lpDesc
->dwInstance
, 0L, 0L);
4121 /**************************************************************************
4122 * waveOutGetPosition [WINMM.170]
4124 UINT WINAPI
waveOutGetPosition(HWAVEOUT hWaveOut
, LPMMTIME lpTime
,
4130 mmt16
.wType
= lpTime
->wType
;
4131 ret
= waveOutGetPosition16(hWaveOut
, &mmt16
, sizeof(mmt16
));
4132 MMSYSTEM_MMTIME16to32(lpTime
, &mmt16
);
4136 /**************************************************************************
4137 * waveOutGetPosition [MMSYSTEM.412]
4139 UINT16 WINAPI
waveOutGetPosition16(HWAVEOUT16 hWaveOut
, LPMMTIME16 lpTime
,
4142 LPWAVEOPENDESC lpDesc
;
4143 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveOut
, lpTime
, uSize
);
4144 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4145 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4146 return wodMessage(lpDesc
->uDeviceID
, WODM_GETPOS
, lpDesc
->dwInstance
,
4147 (DWORD
)lpTime
, (DWORD
)uSize
);
4150 #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \
4151 UINT WINAPI waveOut##xx(HWAVEOUT hWaveOut, atype x) \
4153 return waveOut##xx##16(hWaveOut,x); \
4155 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
4157 LPWAVEOPENDESC lpDesc; \
4158 TRACE(mmsys, "(%04X, %08lx);\n", hWaveOut, (DWORD)x); \
4159 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \
4160 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \
4161 return wodMessage(lpDesc->uDeviceID, WODM_##XX, \
4162 lpDesc->dwInstance, (DWORD)x, 0L); \
4165 WAVEOUT_SHORTCUT_1(GetPitch
,GETPITCH
, DWORD
*)
4166 WAVEOUT_SHORTCUT_1(SetPitch
,SETPITCH
, DWORD
)
4167 WAVEOUT_SHORTCUT_1(GetPlaybackRate
,GETPLAYBACKRATE
, DWORD
*)
4168 WAVEOUT_SHORTCUT_1(SetPlaybackRate
,SETPLAYBACKRATE
, DWORD
)
4170 #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \
4171 UINT WINAPI waveOut##xx(UINT devid, atype x) \
4173 return waveOut##xx##16(devid,x); \
4175 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
4177 TRACE(mmsys, "(%04X, %08lx);\n", devid, (DWORD)x); \
4178 return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \
4181 WAVEOUT_SHORTCUT_2(GetVolume
,GETVOLUME
, DWORD
*)
4182 WAVEOUT_SHORTCUT_2(SetVolume
,SETVOLUME
, DWORD
)
4184 /**************************************************************************
4185 * waveOutBreakLoop [MMSYSTEM.419]
4187 UINT WINAPI
waveOutBreakLoop(HWAVEOUT hWaveOut
)
4189 return waveOutBreakLoop16(hWaveOut
);
4192 /**************************************************************************
4193 * waveOutBreakLoop [MMSYSTEM.419]
4195 UINT16 WINAPI
waveOutBreakLoop16(HWAVEOUT16 hWaveOut
)
4197 TRACE(mmsys
, "(%04X)\n", hWaveOut
);
4198 return MMSYSERR_INVALHANDLE
;
4201 /**************************************************************************
4202 * waveOutGetID [MMSYSTEM.420]
4204 UINT WINAPI
waveOutGetID(HWAVEOUT hWaveOut
, UINT
* lpuDeviceID
)
4206 LPWAVEOPENDESC lpDesc
;
4208 TRACE(mmsys
, "(%04X, %p);\n", hWaveOut
, lpuDeviceID
);
4210 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4211 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4212 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
4213 *lpuDeviceID
= lpDesc
->uDeviceID
;
4217 /**************************************************************************
4218 * waveOutGetID [MMSYSTEM.420]
4220 UINT16 WINAPI
waveOutGetID16(HWAVEOUT16 hWaveOut
, UINT16
* lpuDeviceID
)
4222 LPWAVEOPENDESC lpDesc
;
4224 TRACE(mmsys
, "(%04X, %p);\n", hWaveOut
, lpuDeviceID
);
4226 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4227 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4228 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
4229 *lpuDeviceID
= lpDesc
->uDeviceID
;
4233 /**************************************************************************
4234 * waveOutMessage [MMSYSTEM.421]
4236 DWORD WINAPI
waveOutMessage(HWAVEOUT hWaveOut
, UINT uMessage
,
4237 DWORD dwParam1
, DWORD dwParam2
)
4239 LPWAVEOPENDESC lpDesc
;
4241 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4242 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4244 case WODM_GETNUMDEVS
:
4246 case WODM_GETVOLUME
:
4248 case WODM_GETPLAYBACKRATE
:
4249 case WODM_SETVOLUME
:
4251 case WODM_SETPLAYBACKRATE
:
4255 case WODM_UNPREPARE
:
4258 /* no argument conversion needed */
4261 return waveOutWrite(hWaveOut
, (LPWAVEHDR
)dwParam1
, dwParam2
);
4262 case WODM_GETDEVCAPS
:
4263 /* FIXME: UNICODE/ANSI? */
4264 return waveOutGetDevCapsA(hWaveOut
, (LPWAVEOUTCAPSA
)dwParam1
, dwParam2
);
4266 FIXME(mmsys
,"can't handle WODM_OPEN, please report.\n");
4269 ERR(mmsys
,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n",
4270 hWaveOut
,uMessage
, dwParam1
, dwParam2
);
4273 return wodMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4276 /**************************************************************************
4277 * waveOutMessage [MMSYSTEM.421]
4279 DWORD WINAPI
waveOutMessage16(HWAVEOUT16 hWaveOut
, UINT16 uMessage
,
4280 DWORD dwParam1
, DWORD dwParam2
)
4282 LPWAVEOPENDESC lpDesc
;
4284 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveOut
);
4285 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4287 case WODM_GETNUMDEVS
:
4288 case WODM_SETVOLUME
:
4290 case WODM_SETPLAYBACKRATE
:
4295 /* no argument conversion needed */
4298 return waveOutGetPosition16(hWaveOut
, (LPMMTIME16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4299 case WODM_GETVOLUME
:
4300 return waveOutGetVolume16(hWaveOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
4302 return waveOutGetPitch16(hWaveOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
4303 case WODM_GETPLAYBACKRATE
:
4304 return waveOutGetPlaybackRate16(hWaveOut
, (LPDWORD
)PTR_SEG_TO_LIN(dwParam1
));
4305 case WODM_GETDEVCAPS
:
4306 return waveOutGetDevCaps16(hWaveOut
, (LPWAVEOUTCAPS16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4308 return waveOutPrepareHeader16(hWaveOut
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4309 case WODM_UNPREPARE
:
4310 return waveOutUnprepareHeader16(hWaveOut
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4312 return waveOutWrite16(hWaveOut
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4314 FIXME(mmsys
,"can't handle WODM_OPEN, please report.\n");
4317 ERR(mmsys
,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n",
4318 hWaveOut
,uMessage
, dwParam1
, dwParam2
);
4320 return wodMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4323 /**************************************************************************
4324 * waveInGetNumDevs [WINMM.151]
4326 UINT WINAPI
waveInGetNumDevs()
4328 return waveInGetNumDevs16();
4331 /**************************************************************************
4332 * waveInGetNumDevs [MMSYSTEM.501]
4334 UINT16 WINAPI
waveInGetNumDevs16()
4338 TRACE(mmsys
, "waveInGetNumDevs\n");
4339 count
+= widMessage(0, WIDM_GETNUMDEVS
, 0L, 0L, 0L);
4340 TRACE(mmsys
, "waveInGetNumDevs return %u \n", count
);
4344 /**************************************************************************
4345 * waveInGetDevCapsA [WINMM.147]
4347 UINT WINAPI
waveInGetDevCapsW(UINT uDeviceID
, LPWAVEINCAPSW lpCaps
, UINT uSize
)
4350 UINT ret
= waveInGetDevCaps16(uDeviceID
, &wic16
,uSize
);
4352 lpCaps
->wMid
= wic16
.wMid
;
4353 lpCaps
->wPid
= wic16
.wPid
;
4354 lpCaps
->vDriverVersion
= wic16
.vDriverVersion
;
4355 lstrcpyAtoW(lpCaps
->szPname
, wic16
.szPname
);
4356 lpCaps
->dwFormats
= wic16
.dwFormats
;
4357 lpCaps
->wChannels
= wic16
.wChannels
;
4362 /**************************************************************************
4363 * waveInGetDevCapsA [WINMM.146]
4365 UINT WINAPI
waveInGetDevCapsA(UINT uDeviceID
, LPWAVEINCAPSA lpCaps
, UINT uSize
)
4368 UINT ret
= waveInGetDevCaps16(uDeviceID
, &wic16
,uSize
);
4370 lpCaps
->wMid
= wic16
.wMid
;
4371 lpCaps
->wPid
= wic16
.wPid
;
4372 lpCaps
->vDriverVersion
= wic16
.vDriverVersion
;
4373 strcpy(lpCaps
->szPname
, wic16
.szPname
);
4374 lpCaps
->dwFormats
= wic16
.dwFormats
;
4375 lpCaps
->wChannels
= wic16
.wChannels
;
4379 /**************************************************************************
4380 * waveInGetDevCaps [MMSYSTEM.502]
4382 UINT16 WINAPI
waveInGetDevCaps16(UINT16 uDeviceID
, LPWAVEINCAPS16 lpCaps
, UINT16 uSize
)
4384 TRACE(mmsys
, "waveInGetDevCaps\n");
4386 return widMessage(uDeviceID
, WIDM_GETDEVCAPS
, 0L, (DWORD
)lpCaps
, uSize
);
4389 /**************************************************************************
4390 * waveInGetErrorTextA [WINMM.148]
4392 UINT WINAPI
waveInGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
4394 TRACE(mmsys
, "waveInGetErrorText\n");
4395 return(waveGetErrorText(uError
, lpText
, uSize
));
4398 /**************************************************************************
4399 * waveInGetErrorTextW [WINMM.149]
4401 UINT WINAPI
waveInGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
4403 LPSTR txt
= HeapAlloc(GetProcessHeap(), 0,uSize
);
4404 UINT ret
= waveGetErrorText(uError
, txt
, uSize
);
4406 lstrcpyAtoW(lpText
, txt
);
4407 HeapFree(GetProcessHeap(), 0, txt
);
4411 /**************************************************************************
4412 * waveInGetErrorText [MMSYSTEM.503]
4414 UINT16 WINAPI
waveInGetErrorText16(UINT16 uError
, LPSTR lpText
, UINT16 uSize
)
4416 TRACE(mmsys
, "waveInGetErrorText\n");
4417 return(waveGetErrorText(uError
, lpText
, uSize
));
4420 /**************************************************************************
4421 * waveInOpen [WINMM.154]
4423 UINT WINAPI
waveInOpen(HWAVEIN
* lphWaveIn
, UINT uDeviceID
,
4424 const LPWAVEFORMAT lpFormat
, DWORD dwCallback
,
4425 DWORD dwInstance
, DWORD dwFlags
)
4428 UINT ret
= waveInOpen16(&hwin16
,uDeviceID
, lpFormat
, dwCallback
, dwInstance
,
4429 CALLBACK32CONV(dwFlags
));
4430 if (lphWaveIn
) *lphWaveIn
= hwin16
;
4434 /**************************************************************************
4435 * waveInOpen [MMSYSTEM.504]
4437 UINT16 WINAPI
waveInOpen16(HWAVEIN16
* lphWaveIn
, UINT16 uDeviceID
,
4438 const LPWAVEFORMAT lpFormat
, DWORD dwCallback
,
4439 DWORD dwInstance
, DWORD dwFlags
)
4442 LPWAVEOPENDESC lpDesc
;
4444 BOOL bMapperFlg
= FALSE
;
4446 TRACE(mmsys
, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
4447 lphWaveIn
, uDeviceID
, lpFormat
, dwCallback
, dwInstance
, dwFlags
);
4448 if (dwFlags
& WAVE_FORMAT_QUERY
)
4449 TRACE(mmsys
, "WAVE_FORMAT_QUERY requested !\n");
4450 if (uDeviceID
== (UINT16
)WAVE_MAPPER
) {
4451 TRACE(mmsys
, "WAVE_MAPPER mode requested !\n");
4455 if (lpFormat
== NULL
) return WAVERR_BADFORMAT
;
4456 hWaveIn
= USER_HEAP_ALLOC(sizeof(WAVEOPENDESC
));
4457 if (lphWaveIn
!= NULL
) *lphWaveIn
= hWaveIn
;
4458 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4459 if (lpDesc
== NULL
) return MMSYSERR_NOMEM
;
4460 lpDesc
->hWave
= hWaveIn
;
4461 lpDesc
->lpFormat
= lpFormat
;
4462 lpDesc
->dwCallBack
= dwCallback
;
4463 lpDesc
->dwInstance
= dwInstance
;
4464 while (uDeviceID
< MAXWAVEDRIVERS
) {
4465 dwRet
= widMessage(uDeviceID
, WIDM_OPEN
,
4466 lpDesc
->dwInstance
, (DWORD
)lpDesc
, 0L);
4467 if (dwRet
== MMSYSERR_NOERROR
) break;
4468 if (!bMapperFlg
) break;
4470 TRACE(mmsys
, "WAVE_MAPPER mode ! try next driver...\n");
4472 lpDesc
->uDeviceID
= uDeviceID
;
4473 if (dwFlags
& WAVE_FORMAT_QUERY
) {
4474 TRACE(mmsys
, "End of WAVE_FORMAT_QUERY !\n");
4475 dwRet
= waveInClose16(hWaveIn
);
4480 /**************************************************************************
4481 * waveInClose [WINMM.145]
4483 UINT WINAPI
waveInClose(HWAVEIN hWaveIn
)
4485 return waveInClose16(hWaveIn
);
4488 /**************************************************************************
4489 * waveInClose [MMSYSTEM.505]
4491 UINT16 WINAPI
waveInClose16(HWAVEIN16 hWaveIn
)
4493 LPWAVEOPENDESC lpDesc
;
4495 TRACE(mmsys
, "(%04X)\n", hWaveIn
);
4496 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4497 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4498 return widMessage(lpDesc
->uDeviceID
, WIDM_CLOSE
, lpDesc
->dwInstance
, 0L, 0L);
4501 /**************************************************************************
4502 * waveInPrepareHeader [WINMM.155]
4504 UINT WINAPI
waveInPrepareHeader(HWAVEIN hWaveIn
,
4505 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
4507 LPWAVEOPENDESC lpDesc
;
4509 TRACE(mmsys
, "(%04X, %p, %u);\n",
4510 hWaveIn
, lpWaveInHdr
, uSize
);
4511 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4512 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4513 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4514 lpWaveInHdr
= lpWaveInHdr
;
4515 lpWaveInHdr
->lpNext
= NULL
;
4516 lpWaveInHdr
->dwBytesRecorded
= 0;
4517 TRACE(mmsys
, "lpData=%p size=%lu \n",
4518 lpWaveInHdr
->lpData
, lpWaveInHdr
->dwBufferLength
);
4519 return widMessage(lpDesc
->uDeviceID
, WIDM_PREPARE
, lpDesc
->dwInstance
,
4520 (DWORD
)lpWaveInHdr
, uSize
);
4523 /**************************************************************************
4524 * waveInPrepareHeader [MMSYSTEM.506]
4526 UINT16 WINAPI
waveInPrepareHeader16(HWAVEIN16 hWaveIn
,
4527 WAVEHDR
* lpWaveInHdr
, UINT16 uSize
)
4529 LPWAVEOPENDESC lpDesc
;
4530 LPBYTE saveddata
= lpWaveInHdr
->lpData
;
4533 TRACE(mmsys
, "(%04X, %p, %u);\n",
4534 hWaveIn
, lpWaveInHdr
, uSize
);
4535 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4536 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4537 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4538 lpWaveInHdr
= lpWaveInHdr
;
4539 lpWaveInHdr
->lpNext
= NULL
;
4540 lpWaveInHdr
->dwBytesRecorded
= 0;
4542 TRACE(mmsys
, "lpData=%p size=%lu \n",
4543 lpWaveInHdr
->lpData
, lpWaveInHdr
->dwBufferLength
);
4544 lpWaveInHdr
->lpData
= PTR_SEG_TO_LIN(lpWaveInHdr
->lpData
);
4545 ret
= widMessage(lpDesc
->uDeviceID
, WIDM_PREPARE
, lpDesc
->dwInstance
,
4546 (DWORD
)lpWaveInHdr
,uSize
);
4547 lpWaveInHdr
->lpData
= saveddata
;
4551 /**************************************************************************
4552 * waveInUnprepareHeader [WINMM.159]
4554 UINT WINAPI
waveInUnprepareHeader(HWAVEIN hWaveIn
,
4555 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
4557 LPWAVEOPENDESC lpDesc
;
4559 TRACE(mmsys
, "(%04X, %p, %u);\n",
4560 hWaveIn
, lpWaveInHdr
, uSize
);
4561 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4562 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4563 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4564 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4565 lpWaveInHdr
->lpData
= NULL
;
4566 lpWaveInHdr
->lpNext
= NULL
;
4567 return widMessage(lpDesc
->uDeviceID
, WIDM_UNPREPARE
, lpDesc
->dwInstance
,
4568 (DWORD
)lpWaveInHdr
, uSize
);
4571 /**************************************************************************
4572 * waveInUnprepareHeader [MMSYSTEM.507]
4574 UINT16 WINAPI
waveInUnprepareHeader16(HWAVEIN16 hWaveIn
,
4575 WAVEHDR
* lpWaveInHdr
, UINT16 uSize
)
4577 LPWAVEOPENDESC lpDesc
;
4579 TRACE(mmsys
, "(%04X, %p, %u);\n",
4580 hWaveIn
, lpWaveInHdr
, uSize
);
4581 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4582 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4583 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4584 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4585 lpWaveInHdr
->lpData
= NULL
;
4586 lpWaveInHdr
->lpNext
= NULL
;
4587 return widMessage(lpDesc
->uDeviceID
, WIDM_UNPREPARE
, lpDesc
->dwInstance
,
4588 (DWORD
)lpWaveInHdr
, uSize
);
4591 /**************************************************************************
4592 * waveInAddBuffer [WINMM.144]
4594 UINT WINAPI
waveInAddBuffer(HWAVEIN hWaveIn
,
4595 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
4597 LPWAVEOPENDESC lpDesc
;
4599 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
4600 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4601 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4602 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4603 lpWaveInHdr
->lpNext
= NULL
;
4604 lpWaveInHdr
->dwBytesRecorded
= 0;
4605 TRACE(mmsys
, "lpData=%p size=%lu \n",
4606 lpWaveInHdr
->lpData
, lpWaveInHdr
->dwBufferLength
);
4607 return widMessage(lpDesc
->uDeviceID
, WIDM_ADDBUFFER
, lpDesc
->dwInstance
,
4608 (DWORD
)lpWaveInHdr
, uSize
);
4612 /**************************************************************************
4613 * waveInAddBuffer [MMSYSTEM.508]
4615 UINT16 WINAPI
waveInAddBuffer16(HWAVEIN16 hWaveIn
,
4616 WAVEHDR
* lpWaveInHdr
, UINT16 uSize
)
4618 LPWAVEOPENDESC lpDesc
;
4621 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
4622 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4623 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4624 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALHANDLE
;
4625 lpWaveInHdr
->lpNext
= NULL
;
4626 lpWaveInHdr
->dwBytesRecorded
= 0;
4627 lpWaveInHdr
->lpData
= PTR_SEG_TO_LIN(lpWaveInHdr
->lpData
);
4628 TRACE(mmsys
, "lpData=%p size=%lu \n",
4629 lpWaveInHdr
->lpData
, lpWaveInHdr
->dwBufferLength
);
4630 ret
= widMessage(lpDesc
->uDeviceID
, WIDM_ADDBUFFER
, lpDesc
->dwInstance
,
4631 (DWORD
)lpWaveInHdr
, uSize
);
4632 /*lpWaveInHdr->lpData = saveddata;*/
4636 /**************************************************************************
4637 * waveInStart [WINMM.157]
4639 UINT WINAPI
waveInStart(HWAVEIN hWaveIn
)
4641 return waveInStart16(hWaveIn
);
4644 /**************************************************************************
4645 * waveInStart [MMSYSTEM.509]
4647 UINT16 WINAPI
waveInStart16(HWAVEIN16 hWaveIn
)
4649 LPWAVEOPENDESC lpDesc
;
4651 TRACE(mmsys
, "(%04X)\n", hWaveIn
);
4652 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4653 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4654 return widMessage(lpDesc
->uDeviceID
, WIDM_START
, lpDesc
->dwInstance
, 0, 0);
4657 /**************************************************************************
4658 * waveInStop [WINMM.158]
4660 UINT WINAPI
waveInStop(HWAVEIN hWaveIn
)
4662 return waveInStop16(hWaveIn
);
4665 /**************************************************************************
4666 * waveInStop [MMSYSTEM.510]
4668 UINT16 WINAPI
waveInStop16(HWAVEIN16 hWaveIn
)
4670 LPWAVEOPENDESC lpDesc
;
4672 TRACE(mmsys
, "(%04X)\n", hWaveIn
);
4673 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4674 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4675 return widMessage(lpDesc
->uDeviceID
, WIDM_STOP
, lpDesc
->dwInstance
, 0L, 0L);
4678 /**************************************************************************
4679 * waveInReset [WINMM.156]
4681 UINT WINAPI
waveInReset(HWAVEIN hWaveIn
)
4683 return waveInReset16(hWaveIn
);
4686 /**************************************************************************
4687 * waveInReset [MMSYSTEM.511]
4689 UINT16 WINAPI
waveInReset16(HWAVEIN16 hWaveIn
)
4691 LPWAVEOPENDESC lpDesc
;
4693 TRACE(mmsys
, "(%04X)\n", hWaveIn
);
4694 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4695 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4696 return widMessage(lpDesc
->uDeviceID
, WIDM_RESET
, lpDesc
->dwInstance
, 0, 0);
4699 /**************************************************************************
4700 * waveInGetPosition [WINMM.152]
4702 UINT WINAPI
waveInGetPosition(HWAVEIN hWaveIn
, LPMMTIME lpTime
,
4708 mmt16
.wType
= lpTime
->wType
;
4709 ret
= waveInGetPosition16(hWaveIn
, &mmt16
,uSize
);
4711 MMSYSTEM_MMTIME16to32(lpTime
, &mmt16
);
4715 /**************************************************************************
4716 * waveInGetPosition [MMSYSTEM.512]
4718 UINT16 WINAPI
waveInGetPosition16(HWAVEIN16 hWaveIn
, LPMMTIME16 lpTime
,
4721 LPWAVEOPENDESC lpDesc
;
4723 TRACE(mmsys
, "(%04X, %p, %u);\n", hWaveIn
, lpTime
, uSize
);
4724 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4725 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4726 return widMessage(lpDesc
->uDeviceID
, WIDM_GETPOS
, lpDesc
->dwInstance
,
4727 (DWORD
)lpTime
, (DWORD
)uSize
);
4730 /**************************************************************************
4731 * waveInGetID [WINMM.150]
4733 UINT WINAPI
waveInGetID(HWAVEIN hWaveIn
, UINT
* lpuDeviceID
)
4735 LPWAVEOPENDESC lpDesc
;
4737 TRACE(mmsys
, "waveInGetID\n");
4738 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
4739 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4740 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4741 *lpuDeviceID
= lpDesc
->uDeviceID
;
4745 /**************************************************************************
4746 * waveInGetID [MMSYSTEM.513]
4748 UINT16 WINAPI
waveInGetID16(HWAVEIN16 hWaveIn
, UINT16
* lpuDeviceID
)
4750 LPWAVEOPENDESC lpDesc
;
4752 TRACE(mmsys
, "waveInGetID\n");
4753 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
4754 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4755 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4756 *lpuDeviceID
= lpDesc
->uDeviceID
;
4760 /**************************************************************************
4761 * waveInMessage [WINMM.153]
4763 DWORD WINAPI
waveInMessage(HWAVEIN hWaveIn
, UINT uMessage
,
4764 DWORD dwParam1
, DWORD dwParam2
)
4766 LPWAVEOPENDESC lpDesc
;
4768 FIXME(mmsys
, "(%04X, %04X, %08lX, %08lX)\n",
4769 hWaveIn
, uMessage
, dwParam1
, dwParam2
);
4770 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4771 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4774 FIXME(mmsys
, "cannot handle WIDM_OPEN, please report.\n");
4776 case WIDM_GETNUMDEVS
:
4783 case WIDM_UNPREPARE
:
4784 case WIDM_ADDBUFFER
:
4786 /* no argument conversion needed */
4788 case WIDM_GETDEVCAPS
:
4789 /*FIXME: ANSI/UNICODE */
4790 return waveInGetDevCapsA(hWaveIn
, (LPWAVEINCAPSA
)dwParam1
, dwParam2
);
4792 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4793 hWaveIn
,uMessage
, dwParam1
, dwParam2
);
4796 return widMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4799 /**************************************************************************
4800 * waveInMessage [MMSYSTEM.514]
4802 DWORD WINAPI
waveInMessage16(HWAVEIN16 hWaveIn
, UINT16 uMessage
,
4803 DWORD dwParam1
, DWORD dwParam2
)
4805 LPWAVEOPENDESC lpDesc
;
4807 FIXME(mmsys
, "(%04X, %04X, %08lX, %08lX)\n",
4808 hWaveIn
, uMessage
, dwParam1
, dwParam2
);
4809 lpDesc
= (LPWAVEOPENDESC
) USER_HEAP_LIN_ADDR(hWaveIn
);
4810 if (lpDesc
== NULL
) return MMSYSERR_INVALHANDLE
;
4813 FIXME(mmsys
,"cannot handle WIDM_OPEN, please report.\n");
4815 case WIDM_GETNUMDEVS
:
4821 /* no argument conversion needed */
4823 case WIDM_GETDEVCAPS
:
4824 return waveInGetDevCaps16(hWaveIn
, (LPWAVEINCAPS16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4826 return waveInGetPosition16(hWaveIn
, (LPMMTIME16
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4828 return waveInPrepareHeader16(hWaveIn
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4829 case WIDM_UNPREPARE
:
4830 return waveInUnprepareHeader16(hWaveIn
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4831 case WIDM_ADDBUFFER
:
4832 return waveInAddBuffer16(hWaveIn
, (LPWAVEHDR
)PTR_SEG_TO_LIN(dwParam1
), dwParam2
);
4834 ERR(mmsys
,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4835 hWaveIn
,uMessage
, dwParam1
, dwParam2
);
4838 return widMessage(lpDesc
->uDeviceID
, uMessage
, lpDesc
->dwInstance
, dwParam1
, dwParam2
);
4841 /**************************************************************************
4842 * DrvOpen [MMSYSTEM.1100]
4844 HDRVR16 WINAPI
DrvOpen(LPSTR lpDriverName
, LPSTR lpSectionName
, LPARAM lParam
)
4846 TRACE(mmsys
,"('%s','%s',%08lX);\n", lpDriverName
, lpSectionName
, lParam
);
4848 return OpenDriver16(lpDriverName
, lpSectionName
, lParam
);
4851 /**************************************************************************
4852 * DrvClose [MMSYSTEM.1101]
4854 LRESULT WINAPI
DrvClose(HDRVR16 hDrvr
, LPARAM lParam1
, LPARAM lParam2
)
4856 TRACE(mmsys
, "(%04X, %08lX, %08lX);\n", hDrvr
, lParam1
, lParam2
);
4858 return CloseDriver16(hDrvr
, lParam1
, lParam2
);
4861 /**************************************************************************
4862 * DrvSendMessage [MMSYSTEM.1102]
4864 LRESULT WINAPI
DrvSendMessage(HDRVR16 hDriver
, WORD msg
, LPARAM lParam1
,
4867 /* DWORD dwDriverID = 0; */
4869 FIXME(mmsys
, "(%04X, %04X, %08lX, %08lX);\n", hDriver
, msg
, lParam1
, lParam2
);
4870 return MMSYSERR_NOTENABLED
;
4871 /* FIXME: wrong ... */
4872 /* should known the mapping between hDrv and wDevIDs */
4873 /* MCICDAUDIO_DriverProc16(dwDriverID, hDriver, msg, lParam1, lParam2); */
4876 /**************************************************************************
4877 * DrvGetModuleHandle [MMSYSTEM.1103]
4879 HANDLE16 WINAPI
DrvGetModuleHandle16(HDRVR16 hDrvr
)
4881 return GetDriverModuleHandle16(hDrvr
);
4884 /**************************************************************************
4885 * DrvDefDriverProc [MMSYSTEM.1104]
4887 LRESULT WINAPI
DrvDefDriverProc(DWORD dwDriverID
, HDRVR16 hDriv
, WORD wMsg
,
4888 DWORD dwParam1
, DWORD dwParam2
)
4890 return DefDriverProc16(dwDriverID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
4893 /**************************************************************************
4894 * DefDriverProc32 [WINMM.5]
4896 LRESULT WINAPI
DefDriverProc(DWORD dwDriverIdentifier
, HDRVR hdrvr
,
4897 UINT Msg
, LPARAM lParam1
, LPARAM lParam2
)
4913 /**************************************************************************
4914 * mmThreadCreate [MMSYSTEM.1120]
4916 LRESULT WINAPI
mmThreadCreate16(LPVOID x1
, LPWORD x2
, DWORD x3
, DWORD x4
)
4918 FIXME(mmsys
,"(%p,%p,%08lx,%08lx): stub!\n",x1
,x2
,x3
,x4
);
4923 /**************************************************************************
4924 * mmThreadGetTask [MMSYSTEM.1125]
4926 LRESULT WINAPI
mmThreadGetTask16(WORD hnd
)
4928 FIXME(mmsys
,"(%04x): stub!\n", hnd
);
4929 return GetCurrentTask();
4932 /**************************************************************************
4933 * mmThreadSignal [MMSYSTEM.1121]
4935 LRESULT WINAPI
mmThreadSignal16(WORD hnd
)
4937 FIXME(mmsys
,"(%04x): stub!\n", hnd
);
4941 /**************************************************************************
4942 * mmTaskCreate [MMSYSTEM.900]
4944 HINSTANCE16 WINAPI
mmTaskCreate16(LPWORD lphnd
,HINSTANCE16
*hMmTask
, DWORD x2
)
4946 DWORD showCmd
= 0x40002;
4950 HINSTANCE16 ret
, handle
;
4952 TRACE(mmsys
,"(%p,%p,%08lx);\n", lphnd
, hMmTask
,x2
);
4953 cmdline
= (LPSTR
)HeapAlloc(GetProcessHeap(), 0, 0x0d);
4955 (DWORD
)cmdline
[1] = (DWORD
)lphnd
;
4956 (DWORD
)cmdline
[5] = x2
;
4957 (DWORD
)cmdline
[9] = 0;
4959 sel1
= SELECTOR_AllocBlock(cmdline
, 0x0d, SEGMENT_DATA
, FALSE
, FALSE
);
4960 sel2
= SELECTOR_AllocBlock(&showCmd
, sizeof(showCmd
),
4961 SEGMENT_DATA
, FALSE
, FALSE
);
4963 lp
= (LOADPARAMS16
*)HeapAlloc(GetProcessHeap(), 0, sizeof(LOADPARAMS16
));
4964 lp
->hEnvironment
= 0;
4965 lp
->cmdLine
= PTR_SEG_OFF_TO_SEGPTR(sel1
, 0);
4966 lp
->showCmd
= PTR_SEG_OFF_TO_SEGPTR(sel2
, 0);
4969 ret
= LoadModule16("c:\\windows\\mmtask.tsk", lp
);
4982 *(HINSTANCE16
*)PTR_SEG_TO_LIN(hMmTask
) = handle
;
4984 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel2
, 0));
4985 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel1
, 0));
4987 HeapFree(GetProcessHeap(), 0, lp
);
4988 HeapFree(GetProcessHeap(), 0, cmdline
);
4993 /**************************************************************************
4994 * mmTaskSignal [MMSYSTEM.903]
4996 LRESULT WINAPI
mmTaskSignal16(HTASK16 ht
)
4998 TRACE(mmsys
,"(%04x);\n", ht
);
4999 return PostAppMessageA(ht
, WM_USER
, 0, 0);