1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
6 * Copyright 1993 Martin Ayotte
7 * 1998-2002 Eric Pouech
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 * 98/9 added Win32 MCI support
27 * 99/4 added midiStream support
28 * 99/9 added support for loadable low level drivers
32 * + it seems that some programs check what's installed in
33 * registry against the value returned by drivers. Wine is
34 * currently broken regarding this point.
35 * + check thread-safeness for MMSYSTEM and WINMM entry points
36 * + unicode entry points are badly supported (would require
37 * moving 32 bit drivers as Unicode as they are supposed to be)
38 * + allow joystick and timer external calls as we do for wave,
46 #define NONAMELESSUNION
47 #define NONAMELESSSTRUCT
56 #include "wine/debug.h"
58 WINE_DEFAULT_DEBUG_CHANNEL(winmm
);
60 /* ========================================================================
61 * G L O B A L S E T T I N G S
62 * ========================================================================*/
64 HINSTANCE hWinMM32Instance
;
67 static CRITICAL_SECTION_DEBUG critsect_debug
=
70 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
71 0, 0, { (DWORD_PTR
)(__FILE__
": WINMM_cs") }
73 CRITICAL_SECTION WINMM_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
75 /**************************************************************************
76 * WINMM_CreateIData [internal]
78 static BOOL
WINMM_CreateIData(HINSTANCE hInstDLL
)
80 hWinMM32Instance
= hInstDLL
;
81 psLastEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
85 /**************************************************************************
86 * WINMM_DeleteIData [internal]
88 static void WINMM_DeleteIData(void)
92 /* FIXME: should also free content and resources allocated
93 * inside WINMM_IData */
94 CloseHandle(psLastEvent
);
95 DeleteCriticalSection(&WINMM_cs
);
98 /******************************************************************
101 const char* WINMM_ErrorToString(MMRESULT error
)
103 #define ERR_TO_STR(dev) case dev: return #dev
105 ERR_TO_STR(MMSYSERR_NOERROR
);
106 ERR_TO_STR(MMSYSERR_ERROR
);
107 ERR_TO_STR(MMSYSERR_BADDEVICEID
);
108 ERR_TO_STR(MMSYSERR_NOTENABLED
);
109 ERR_TO_STR(MMSYSERR_ALLOCATED
);
110 ERR_TO_STR(MMSYSERR_INVALHANDLE
);
111 ERR_TO_STR(MMSYSERR_NODRIVER
);
112 ERR_TO_STR(MMSYSERR_NOMEM
);
113 ERR_TO_STR(MMSYSERR_NOTSUPPORTED
);
114 ERR_TO_STR(MMSYSERR_BADERRNUM
);
115 ERR_TO_STR(MMSYSERR_INVALFLAG
);
116 ERR_TO_STR(MMSYSERR_INVALPARAM
);
117 ERR_TO_STR(MMSYSERR_HANDLEBUSY
);
118 ERR_TO_STR(MMSYSERR_INVALIDALIAS
);
119 ERR_TO_STR(MMSYSERR_BADDB
);
120 ERR_TO_STR(MMSYSERR_KEYNOTFOUND
);
121 ERR_TO_STR(MMSYSERR_READERROR
);
122 ERR_TO_STR(MMSYSERR_WRITEERROR
);
123 ERR_TO_STR(MMSYSERR_DELETEERROR
);
124 ERR_TO_STR(MMSYSERR_VALNOTFOUND
);
125 ERR_TO_STR(MMSYSERR_NODRIVERCB
);
126 ERR_TO_STR(WAVERR_BADFORMAT
);
127 ERR_TO_STR(WAVERR_STILLPLAYING
);
128 ERR_TO_STR(WAVERR_UNPREPARED
);
129 ERR_TO_STR(WAVERR_SYNC
);
130 ERR_TO_STR(MIDIERR_INVALIDSETUP
);
131 ERR_TO_STR(MIDIERR_NODEVICE
);
132 ERR_TO_STR(MIDIERR_STILLPLAYING
);
133 ERR_TO_STR(MIDIERR_UNPREPARED
);
136 return wine_dbg_sprintf("Unknown(0x%08x)", error
);
139 /**************************************************************************
140 * DllMain (WINMM.init)
142 * WINMM DLL entry point
145 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID fImpLoad
)
147 TRACE("%p 0x%x %p\n", hInstDLL
, fdwReason
, fImpLoad
);
150 case DLL_PROCESS_ATTACH
:
151 DisableThreadLibraryCalls(hInstDLL
);
153 if (!WINMM_CreateIData(hInstDLL
))
156 case DLL_PROCESS_DETACH
:
157 /* close all opened MCI drivers */
158 MCI_SendCommand(MCI_ALL_DEVICE_ID
, MCI_CLOSE
, MCI_WAIT
, 0L);
160 /* There's no guarantee the drivers haven't already been unloaded on
165 /* now unload all remaining drivers... */
175 /**************************************************************************
176 * Mixer devices. New to Win95
179 /**************************************************************************
180 * find out the real mixer ID depending on hmix (depends on dwFlags)
182 static UINT
MIXER_GetDev(HMIXEROBJ hmix
, DWORD dwFlags
, LPWINE_MIXER
* lplpwm
)
184 LPWINE_MIXER lpwm
= NULL
;
185 UINT uRet
= MMSYSERR_NOERROR
;
187 switch (dwFlags
& 0xF0000000ul
) {
188 case MIXER_OBJECTF_MIXER
:
189 lpwm
= (LPWINE_MIXER
)MMDRV_Get(hmix
, MMDRV_MIXER
, TRUE
);
191 case MIXER_OBJECTF_HMIXER
:
192 lpwm
= (LPWINE_MIXER
)MMDRV_Get(hmix
, MMDRV_MIXER
, FALSE
);
194 case MIXER_OBJECTF_WAVEOUT
:
195 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_WAVEOUT
, TRUE
, MMDRV_MIXER
);
197 case MIXER_OBJECTF_HWAVEOUT
:
198 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_WAVEOUT
, FALSE
, MMDRV_MIXER
);
200 case MIXER_OBJECTF_WAVEIN
:
201 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_WAVEIN
, TRUE
, MMDRV_MIXER
);
203 case MIXER_OBJECTF_HWAVEIN
:
204 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_WAVEIN
, FALSE
, MMDRV_MIXER
);
206 case MIXER_OBJECTF_MIDIOUT
:
207 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_MIDIOUT
, TRUE
, MMDRV_MIXER
);
209 case MIXER_OBJECTF_HMIDIOUT
:
210 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_MIDIOUT
, FALSE
, MMDRV_MIXER
);
212 case MIXER_OBJECTF_MIDIIN
:
213 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_MIDIIN
, TRUE
, MMDRV_MIXER
);
215 case MIXER_OBJECTF_HMIDIIN
:
216 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_MIDIIN
, FALSE
, MMDRV_MIXER
);
218 case MIXER_OBJECTF_AUX
:
219 lpwm
= (LPWINE_MIXER
)MMDRV_GetRelated(hmix
, MMDRV_AUX
, TRUE
, MMDRV_MIXER
);
222 WARN("Unsupported flag (%08lx)\n", dwFlags
& 0xF0000000ul
);
224 uRet
= MMSYSERR_INVALFLAG
;
228 if (lpwm
== 0 && uRet
== MMSYSERR_NOERROR
)
229 uRet
= MMSYSERR_INVALPARAM
;
233 /**************************************************************************
234 * mixerGetNumDevs [WINMM.@]
236 UINT WINAPI
mixerGetNumDevs(void)
238 return MMDRV_GetNum(MMDRV_MIXER
);
241 /**************************************************************************
242 * mixerGetDevCapsA [WINMM.@]
244 UINT WINAPI
mixerGetDevCapsA(UINT_PTR uDeviceID
, LPMIXERCAPSA lpCaps
, UINT uSize
)
249 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
251 ret
= mixerGetDevCapsW(uDeviceID
, &micW
, sizeof(micW
));
253 if (ret
== MMSYSERR_NOERROR
) {
255 micA
.wMid
= micW
.wMid
;
256 micA
.wPid
= micW
.wPid
;
257 micA
.vDriverVersion
= micW
.vDriverVersion
;
258 WideCharToMultiByte( CP_ACP
, 0, micW
.szPname
, -1, micA
.szPname
,
259 sizeof(micA
.szPname
), NULL
, NULL
);
260 micA
.fdwSupport
= micW
.fdwSupport
;
261 micA
.cDestinations
= micW
.cDestinations
;
262 memcpy(lpCaps
, &micA
, min(uSize
, sizeof(micA
)));
267 /**************************************************************************
268 * mixerGetDevCapsW [WINMM.@]
270 UINT WINAPI
mixerGetDevCapsW(UINT_PTR uDeviceID
, LPMIXERCAPSW lpCaps
, UINT uSize
)
274 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
276 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_MIXER
, TRUE
)) == NULL
)
277 return MMSYSERR_BADDEVICEID
;
279 return MMDRV_Message(wmld
, MXDM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
282 static void CALLBACK
MIXER_WCallback(HMIXEROBJ hmx
, UINT uMsg
, DWORD_PTR dwInstance
, DWORD_PTR dwParam
, DWORD_PTR param2
)
284 HWND hWnd
= (HWND
)dwInstance
;
289 PostMessageW(hWnd
, uMsg
, (WPARAM
)hmx
, (LPARAM
)dwParam
);
292 /**************************************************************************
293 * mixerOpen [WINMM.@]
295 UINT WINAPI
mixerOpen(LPHMIXER lphMix
, UINT uDeviceID
, DWORD_PTR dwCallback
,
296 DWORD_PTR dwInstance
, DWORD fdwOpen
)
303 TRACE("(%p, %d, %08lx, %08lx, %08x)\n",
304 lphMix
, uDeviceID
, dwCallback
, dwInstance
, fdwOpen
);
306 mod
.dwCallback
= (DWORD_PTR
)MIXER_WCallback
;
309 /* If callback is a function,
310 * dwCallback contains function pointer
311 * dwInstance private data
313 * if callback is a window
314 * dwCallback contains a window handle
316 switch (fdwOpen
& CALLBACK_TYPEMASK
) {
318 return MMSYSERR_INVALFLAG
;
323 case CALLBACK_WINDOW
:
324 mod
.dwInstance
= dwCallback
;
325 if (dwCallback
&& !IsWindow((HWND
)dwCallback
))
326 return MMSYSERR_INVALPARAM
;
330 wmld
= MMDRV_Alloc(sizeof(WINE_MIXER
), MMDRV_MIXER
, &hMix
, &fdwOpen
,
331 &dwCallback
, &dwInstance
);
332 wmld
->uDeviceID
= uDeviceID
;
335 dwRet
= MMDRV_Open(wmld
, MXDM_OPEN
, (DWORD_PTR
)&mod
, CALLBACK_FUNCTION
);
337 if (dwRet
!= MMSYSERR_NOERROR
) {
338 MMDRV_Free(hMix
, wmld
);
341 if (lphMix
) *lphMix
= hMix
;
342 TRACE("=> %d hMixer=%p\n", dwRet
, hMix
);
347 /**************************************************************************
348 * mixerClose [WINMM.@]
350 UINT WINAPI
mixerClose(HMIXER hMix
)
355 TRACE("(%p)\n", hMix
);
357 if ((wmld
= MMDRV_Get(hMix
, MMDRV_MIXER
, FALSE
)) == NULL
) return MMSYSERR_INVALHANDLE
;
359 dwRet
= MMDRV_Close(wmld
, MXDM_CLOSE
);
360 MMDRV_Free(hMix
, wmld
);
365 /**************************************************************************
366 * mixerGetID [WINMM.@]
368 UINT WINAPI
mixerGetID(HMIXEROBJ hmix
, LPUINT lpid
, DWORD fdwID
)
371 UINT uRet
= MMSYSERR_NOERROR
;
373 TRACE("(%p %p %08x)\n", hmix
, lpid
, fdwID
);
375 if ((uRet
= MIXER_GetDev(hmix
, fdwID
, &lpwm
)) != MMSYSERR_NOERROR
)
379 *lpid
= lpwm
->mld
.uDeviceID
;
384 /**************************************************************************
385 * mixerGetControlDetailsW [WINMM.@]
387 UINT WINAPI
mixerGetControlDetailsW(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdW
,
391 UINT uRet
= MMSYSERR_NOERROR
;
393 TRACE("(%p, %p, %08x)\n", hmix
, lpmcdW
, fdwDetails
);
395 if ((uRet
= MIXER_GetDev(hmix
, fdwDetails
, &lpwm
)) != MMSYSERR_NOERROR
)
398 if (lpmcdW
== NULL
|| lpmcdW
->cbStruct
!= sizeof(*lpmcdW
))
399 return MMSYSERR_INVALPARAM
;
401 return MMDRV_Message(&lpwm
->mld
, MXDM_GETCONTROLDETAILS
, (DWORD_PTR
)lpmcdW
,
405 /**************************************************************************
406 * mixerGetControlDetailsA [WINMM.@]
408 UINT WINAPI
mixerGetControlDetailsA(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcdA
,
411 DWORD ret
= MMSYSERR_NOTENABLED
;
413 TRACE("(%p, %p, %08x)\n", hmix
, lpmcdA
, fdwDetails
);
415 if (lpmcdA
== NULL
|| lpmcdA
->cbStruct
!= sizeof(*lpmcdA
))
416 return MMSYSERR_INVALPARAM
;
418 switch (fdwDetails
& MIXER_GETCONTROLDETAILSF_QUERYMASK
) {
419 case MIXER_GETCONTROLDETAILSF_VALUE
:
420 /* can safely use A structure as it is, no string inside */
421 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
423 case MIXER_GETCONTROLDETAILSF_LISTTEXT
:
425 MIXERCONTROLDETAILS_LISTTEXTA
*pDetailsA
= lpmcdA
->paDetails
;
426 MIXERCONTROLDETAILS_LISTTEXTW
*pDetailsW
;
427 int size
= max(1, lpmcdA
->cChannels
) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
430 if (lpmcdA
->u
.cMultipleItems
!= 0) {
431 size
*= lpmcdA
->u
.cMultipleItems
;
433 pDetailsW
= HeapAlloc(GetProcessHeap(), 0, size
);
434 lpmcdA
->paDetails
= pDetailsW
;
435 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTW
);
436 /* set up lpmcd->paDetails */
437 ret
= mixerGetControlDetailsW(hmix
, lpmcdA
, fdwDetails
);
438 /* copy from lpmcd->paDetails back to paDetailsW; */
439 if (ret
== MMSYSERR_NOERROR
) {
440 for (i
= 0; i
< lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
; i
++) {
441 pDetailsA
->dwParam1
= pDetailsW
->dwParam1
;
442 pDetailsA
->dwParam2
= pDetailsW
->dwParam2
;
443 WideCharToMultiByte( CP_ACP
, 0, pDetailsW
->szName
, -1,
445 sizeof(pDetailsA
->szName
), NULL
, NULL
);
449 pDetailsA
-= lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
;
450 pDetailsW
-= lpmcdA
->u
.cMultipleItems
* lpmcdA
->cChannels
;
452 HeapFree(GetProcessHeap(), 0, pDetailsW
);
453 lpmcdA
->paDetails
= pDetailsA
;
454 lpmcdA
->cbDetails
= sizeof(MIXERCONTROLDETAILS_LISTTEXTA
);
458 ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails
);
464 /**************************************************************************
465 * mixerGetLineControlsA [WINMM.@]
467 UINT WINAPI
mixerGetLineControlsA(HMIXEROBJ hmix
, LPMIXERLINECONTROLSA lpmlcA
,
470 MIXERLINECONTROLSW mlcW
;
474 TRACE("(%p, %p, %08x)\n", hmix
, lpmlcA
, fdwControls
);
476 if (lpmlcA
== NULL
|| lpmlcA
->cbStruct
!= sizeof(*lpmlcA
) ||
477 lpmlcA
->cbmxctrl
!= sizeof(MIXERCONTROLA
))
478 return MMSYSERR_INVALPARAM
;
480 mlcW
.cbStruct
= sizeof(mlcW
);
481 mlcW
.dwLineID
= lpmlcA
->dwLineID
;
482 mlcW
.u
.dwControlID
= lpmlcA
->u
.dwControlID
;
483 mlcW
.u
.dwControlType
= lpmlcA
->u
.dwControlType
;
485 /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only,
486 the control count is assumed to be 1 - This is relied upon by a game,
488 if (MIXER_GETLINECONTROLSF_ONEBYTYPE
== (fdwControls
& MIXER_GETLINECONTROLSF_QUERYMASK
)) {
491 mlcW
.cControls
= lpmlcA
->cControls
;
493 mlcW
.cbmxctrl
= sizeof(MIXERCONTROLW
);
494 mlcW
.pamxctrl
= HeapAlloc(GetProcessHeap(), 0,
495 mlcW
.cControls
* mlcW
.cbmxctrl
);
497 ret
= mixerGetLineControlsW(hmix
, &mlcW
, fdwControls
);
499 if (ret
== MMSYSERR_NOERROR
) {
500 lpmlcA
->dwLineID
= mlcW
.dwLineID
;
501 lpmlcA
->u
.dwControlID
= mlcW
.u
.dwControlID
;
502 lpmlcA
->u
.dwControlType
= mlcW
.u
.dwControlType
;
504 for (i
= 0; i
< mlcW
.cControls
; i
++) {
505 lpmlcA
->pamxctrl
[i
].cbStruct
= sizeof(MIXERCONTROLA
);
506 lpmlcA
->pamxctrl
[i
].dwControlID
= mlcW
.pamxctrl
[i
].dwControlID
;
507 lpmlcA
->pamxctrl
[i
].dwControlType
= mlcW
.pamxctrl
[i
].dwControlType
;
508 lpmlcA
->pamxctrl
[i
].fdwControl
= mlcW
.pamxctrl
[i
].fdwControl
;
509 lpmlcA
->pamxctrl
[i
].cMultipleItems
= mlcW
.pamxctrl
[i
].cMultipleItems
;
510 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szShortName
, -1,
511 lpmlcA
->pamxctrl
[i
].szShortName
,
512 sizeof(lpmlcA
->pamxctrl
[i
].szShortName
), NULL
, NULL
);
513 WideCharToMultiByte( CP_ACP
, 0, mlcW
.pamxctrl
[i
].szName
, -1,
514 lpmlcA
->pamxctrl
[i
].szName
,
515 sizeof(lpmlcA
->pamxctrl
[i
].szName
), NULL
, NULL
);
516 /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
517 * sizeof(mlcW.pamxctrl[i].Bounds) */
518 memcpy(&lpmlcA
->pamxctrl
[i
].Bounds
, &mlcW
.pamxctrl
[i
].Bounds
,
519 sizeof(mlcW
.pamxctrl
[i
].Bounds
));
520 /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
521 * sizeof(mlcW.pamxctrl[i].Metrics) */
522 memcpy(&lpmlcA
->pamxctrl
[i
].Metrics
, &mlcW
.pamxctrl
[i
].Metrics
,
523 sizeof(mlcW
.pamxctrl
[i
].Metrics
));
527 HeapFree(GetProcessHeap(), 0, mlcW
.pamxctrl
);
532 /**************************************************************************
533 * mixerGetLineControlsW [WINMM.@]
535 UINT WINAPI
mixerGetLineControlsW(HMIXEROBJ hmix
, LPMIXERLINECONTROLSW lpmlcW
,
539 UINT uRet
= MMSYSERR_NOERROR
;
541 TRACE("(%p, %p, %08x)\n", hmix
, lpmlcW
, fdwControls
);
543 if ((uRet
= MIXER_GetDev(hmix
, fdwControls
, &lpwm
)) != MMSYSERR_NOERROR
)
546 if (lpmlcW
== NULL
|| lpmlcW
->cbStruct
!= sizeof(*lpmlcW
))
547 return MMSYSERR_INVALPARAM
;
549 return MMDRV_Message(&lpwm
->mld
, MXDM_GETLINECONTROLS
, (DWORD_PTR
)lpmlcW
,
553 /**************************************************************************
554 * mixerGetLineInfoW [WINMM.@]
556 UINT WINAPI
mixerGetLineInfoW(HMIXEROBJ hmix
, LPMIXERLINEW lpmliW
, DWORD fdwInfo
)
559 UINT uRet
= MMSYSERR_NOERROR
;
561 TRACE("(%p, %p, %08x)\n", hmix
, lpmliW
, fdwInfo
);
563 if ((uRet
= MIXER_GetDev(hmix
, fdwInfo
, &lpwm
)) != MMSYSERR_NOERROR
)
566 return MMDRV_Message(&lpwm
->mld
, MXDM_GETLINEINFO
, (DWORD_PTR
)lpmliW
,
570 /**************************************************************************
571 * mixerGetLineInfoA [WINMM.@]
573 UINT WINAPI
mixerGetLineInfoA(HMIXEROBJ hmix
, LPMIXERLINEA lpmliA
,
579 TRACE("(%p, %p, %08x)\n", hmix
, lpmliA
, fdwInfo
);
581 if (lpmliA
== NULL
|| lpmliA
->cbStruct
!= sizeof(*lpmliA
))
582 return MMSYSERR_INVALPARAM
;
584 mliW
.cbStruct
= sizeof(mliW
);
585 switch (fdwInfo
& MIXER_GETLINEINFOF_QUERYMASK
) {
586 case MIXER_GETLINEINFOF_COMPONENTTYPE
:
587 mliW
.dwComponentType
= lpmliA
->dwComponentType
;
589 case MIXER_GETLINEINFOF_DESTINATION
:
590 mliW
.dwDestination
= lpmliA
->dwDestination
;
592 case MIXER_GETLINEINFOF_LINEID
:
593 mliW
.dwLineID
= lpmliA
->dwLineID
;
595 case MIXER_GETLINEINFOF_SOURCE
:
596 mliW
.dwDestination
= lpmliA
->dwDestination
;
597 mliW
.dwSource
= lpmliA
->dwSource
;
599 case MIXER_GETLINEINFOF_TARGETTYPE
:
600 mliW
.Target
.dwType
= lpmliA
->Target
.dwType
;
601 mliW
.Target
.wMid
= lpmliA
->Target
.wMid
;
602 mliW
.Target
.wPid
= lpmliA
->Target
.wPid
;
603 mliW
.Target
.vDriverVersion
= lpmliA
->Target
.vDriverVersion
;
604 MultiByteToWideChar( CP_ACP
, 0, lpmliA
->Target
.szPname
, -1, mliW
.Target
.szPname
, sizeof(mliW
.Target
.szPname
)/sizeof(WCHAR
));
607 WARN("Unsupported fdwControls=0x%08x\n", fdwInfo
);
608 return MMSYSERR_INVALFLAG
;
611 ret
= mixerGetLineInfoW(hmix
, &mliW
, fdwInfo
);
613 if(ret
== MMSYSERR_NOERROR
)
615 lpmliA
->dwDestination
= mliW
.dwDestination
;
616 lpmliA
->dwSource
= mliW
.dwSource
;
617 lpmliA
->dwLineID
= mliW
.dwLineID
;
618 lpmliA
->fdwLine
= mliW
.fdwLine
;
619 lpmliA
->dwUser
= mliW
.dwUser
;
620 lpmliA
->dwComponentType
= mliW
.dwComponentType
;
621 lpmliA
->cChannels
= mliW
.cChannels
;
622 lpmliA
->cConnections
= mliW
.cConnections
;
623 lpmliA
->cControls
= mliW
.cControls
;
624 WideCharToMultiByte( CP_ACP
, 0, mliW
.szShortName
, -1, lpmliA
->szShortName
,
625 sizeof(lpmliA
->szShortName
), NULL
, NULL
);
626 WideCharToMultiByte( CP_ACP
, 0, mliW
.szName
, -1, lpmliA
->szName
,
627 sizeof(lpmliA
->szName
), NULL
, NULL
);
628 lpmliA
->Target
.dwType
= mliW
.Target
.dwType
;
629 lpmliA
->Target
.dwDeviceID
= mliW
.Target
.dwDeviceID
;
630 lpmliA
->Target
.wMid
= mliW
.Target
.wMid
;
631 lpmliA
->Target
.wPid
= mliW
.Target
.wPid
;
632 lpmliA
->Target
.vDriverVersion
= mliW
.Target
.vDriverVersion
;
633 WideCharToMultiByte( CP_ACP
, 0, mliW
.Target
.szPname
, -1, lpmliA
->Target
.szPname
,
634 sizeof(lpmliA
->Target
.szPname
), NULL
, NULL
);
639 /**************************************************************************
640 * mixerSetControlDetails [WINMM.@]
642 UINT WINAPI
mixerSetControlDetails(HMIXEROBJ hmix
, LPMIXERCONTROLDETAILS lpmcd
,
646 UINT uRet
= MMSYSERR_NOERROR
;
648 TRACE("(%p, %p, %08x)\n", hmix
, lpmcd
, fdwDetails
);
650 if ((uRet
= MIXER_GetDev(hmix
, fdwDetails
, &lpwm
)) != MMSYSERR_NOERROR
)
653 return MMDRV_Message(&lpwm
->mld
, MXDM_SETCONTROLDETAILS
, (DWORD_PTR
)lpmcd
,
657 /**************************************************************************
658 * mixerMessage [WINMM.@]
660 DWORD WINAPI
mixerMessage(HMIXER hmix
, UINT uMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
664 TRACE("(%p, %d, %08lx, %08lx): semi-stub?\n",
665 hmix
, uMsg
, dwParam1
, dwParam2
);
667 if ((wmld
= MMDRV_Get(hmix
, MMDRV_MIXER
, FALSE
)) == NULL
)
668 return MMSYSERR_INVALHANDLE
;
670 return MMDRV_Message(wmld
, uMsg
, dwParam1
, dwParam2
);
673 /**************************************************************************
674 * auxGetNumDevs [WINMM.@]
676 UINT WINAPI
auxGetNumDevs(void)
678 return MMDRV_GetNum(MMDRV_AUX
);
681 /**************************************************************************
682 * auxGetDevCapsW [WINMM.@]
684 UINT WINAPI
auxGetDevCapsW(UINT_PTR uDeviceID
, LPAUXCAPSW lpCaps
, UINT uSize
)
688 TRACE("(%04lX, %p, %d) !\n", uDeviceID
, lpCaps
, uSize
);
690 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
692 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
693 return MMSYSERR_BADDEVICEID
;
694 return MMDRV_Message(wmld
, AUXDM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
697 /**************************************************************************
698 * auxGetDevCapsA [WINMM.@]
700 UINT WINAPI
auxGetDevCapsA(UINT_PTR uDeviceID
, LPAUXCAPSA lpCaps
, UINT uSize
)
705 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
707 ret
= auxGetDevCapsW(uDeviceID
, &acW
, sizeof(acW
));
709 if (ret
== MMSYSERR_NOERROR
) {
713 acA
.vDriverVersion
= acW
.vDriverVersion
;
714 WideCharToMultiByte( CP_ACP
, 0, acW
.szPname
, -1, acA
.szPname
,
715 sizeof(acA
.szPname
), NULL
, NULL
);
716 acA
.wTechnology
= acW
.wTechnology
;
717 acA
.dwSupport
= acW
.dwSupport
;
718 memcpy(lpCaps
, &acA
, min(uSize
, sizeof(acA
)));
723 /**************************************************************************
724 * auxGetVolume [WINMM.@]
726 UINT WINAPI
auxGetVolume(UINT uDeviceID
, DWORD
* lpdwVolume
)
730 TRACE("(%04X, %p) !\n", uDeviceID
, lpdwVolume
);
732 if ((wmld
= MMDRV_Get((HANDLE
)(DWORD_PTR
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
733 return MMSYSERR_INVALHANDLE
;
734 return MMDRV_Message(wmld
, AUXDM_GETVOLUME
, (DWORD_PTR
)lpdwVolume
, 0L);
737 /**************************************************************************
738 * auxSetVolume [WINMM.@]
740 UINT WINAPI
auxSetVolume(UINT uDeviceID
, DWORD dwVolume
)
744 TRACE("(%04X, %u) !\n", uDeviceID
, dwVolume
);
746 if ((wmld
= MMDRV_Get((HANDLE
)(DWORD_PTR
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
747 return MMSYSERR_INVALHANDLE
;
748 return MMDRV_Message(wmld
, AUXDM_SETVOLUME
, dwVolume
, 0L);
751 /**************************************************************************
752 * auxOutMessage [WINMM.@]
754 UINT WINAPI
auxOutMessage(UINT uDeviceID
, UINT uMessage
, DWORD_PTR dw1
, DWORD_PTR dw2
)
758 if ((wmld
= MMDRV_Get((HANDLE
)(DWORD_PTR
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
759 return MMSYSERR_INVALHANDLE
;
761 return MMDRV_Message(wmld
, uMessage
, dw1
, dw2
);
764 /**************************************************************************
765 * midiOutGetNumDevs [WINMM.@]
767 UINT WINAPI
midiOutGetNumDevs(void)
769 return MMDRV_GetNum(MMDRV_MIDIOUT
);
772 /**************************************************************************
773 * midiOutGetDevCapsW [WINMM.@]
775 UINT WINAPI
midiOutGetDevCapsW(UINT_PTR uDeviceID
, LPMIDIOUTCAPSW lpCaps
,
780 TRACE("(%lu, %p, %u);\n", uDeviceID
, lpCaps
, uSize
);
782 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
784 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_MIDIOUT
, TRUE
)) == NULL
)
785 return MMSYSERR_BADDEVICEID
;
787 return MMDRV_Message(wmld
, MODM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
790 /**************************************************************************
791 * midiOutGetDevCapsA [WINMM.@]
793 UINT WINAPI
midiOutGetDevCapsA(UINT_PTR uDeviceID
, LPMIDIOUTCAPSA lpCaps
,
799 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
801 ret
= midiOutGetDevCapsW(uDeviceID
, &mocW
, sizeof(mocW
));
803 if (ret
== MMSYSERR_NOERROR
) {
805 mocA
.wMid
= mocW
.wMid
;
806 mocA
.wPid
= mocW
.wPid
;
807 mocA
.vDriverVersion
= mocW
.vDriverVersion
;
808 WideCharToMultiByte( CP_ACP
, 0, mocW
.szPname
, -1, mocA
.szPname
,
809 sizeof(mocA
.szPname
), NULL
, NULL
);
810 mocA
.wTechnology
= mocW
.wTechnology
;
811 mocA
.wVoices
= mocW
.wVoices
;
812 mocA
.wNotes
= mocW
.wNotes
;
813 mocA
.wChannelMask
= mocW
.wChannelMask
;
814 mocA
.dwSupport
= mocW
.dwSupport
;
815 memcpy(lpCaps
, &mocA
, min(uSize
, sizeof(mocA
)));
820 /**************************************************************************
821 * midiOutGetErrorTextA [WINMM.@]
822 * midiInGetErrorTextA [WINMM.@]
824 UINT WINAPI
midiOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
828 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
829 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
832 LPWSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
* sizeof(WCHAR
));
833 if (!xstr
) ret
= MMSYSERR_NOMEM
;
836 ret
= midiOutGetErrorTextW(uError
, xstr
, uSize
);
837 if (ret
== MMSYSERR_NOERROR
)
838 WideCharToMultiByte(CP_ACP
, 0, xstr
, -1, lpText
, uSize
, NULL
, NULL
);
839 HeapFree(GetProcessHeap(), 0, xstr
);
845 /**************************************************************************
846 * midiOutGetErrorTextW [WINMM.@]
847 * midiInGetErrorTextW [WINMM.@]
849 UINT WINAPI
midiOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
851 UINT ret
= MMSYSERR_BADERRNUM
;
853 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
854 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
856 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
857 * a warning for the test was always true */
858 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
859 (uError
>= MIDIERR_BASE
&& uError
<= MIDIERR_LASTERROR
)) {
860 if (LoadStringW(hWinMM32Instance
, uError
, lpText
, uSize
) > 0) {
861 ret
= MMSYSERR_NOERROR
;
867 /**************************************************************************
868 * MIDI_OutAlloc [internal]
870 static LPWINE_MIDI
MIDI_OutAlloc(HMIDIOUT
* lphMidiOut
, DWORD_PTR
* lpdwCallback
,
871 DWORD_PTR
* lpdwInstance
, LPDWORD lpdwFlags
,
872 DWORD cIDs
, MIDIOPENSTRMID
* lpIDs
)
878 size
= sizeof(WINE_MIDI
) + (cIDs
? (cIDs
-1) : 0) * sizeof(MIDIOPENSTRMID
);
880 lpwm
= (LPWINE_MIDI
)MMDRV_Alloc(size
, MMDRV_MIDIOUT
, &hMidiOut
, lpdwFlags
,
881 lpdwCallback
, lpdwInstance
);
882 *lphMidiOut
= hMidiOut
;
885 lpwm
->mod
.hMidi
= hMidiOut
;
886 lpwm
->mod
.dwCallback
= *lpdwCallback
;
887 lpwm
->mod
.dwInstance
= *lpdwInstance
;
888 lpwm
->mod
.dnDevNode
= 0;
889 lpwm
->mod
.cIds
= cIDs
;
891 memcpy(&(lpwm
->mod
.rgIds
), lpIDs
, cIDs
* sizeof(MIDIOPENSTRMID
));
896 /**************************************************************************
897 * midiOutOpen [WINMM.@]
899 UINT WINAPI
midiOutOpen(LPHMIDIOUT lphMidiOut
, UINT uDeviceID
,
900 DWORD_PTR dwCallback
, DWORD_PTR dwInstance
, DWORD dwFlags
)
906 TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
907 lphMidiOut
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
909 if (lphMidiOut
!= NULL
) *lphMidiOut
= 0;
911 switch (dwFlags
& CALLBACK_TYPEMASK
) {
912 case CALLBACK_WINDOW
:
913 if (dwCallback
&& !IsWindow((HWND
)dwCallback
))
914 return MMSYSERR_INVALPARAM
;
918 lpwm
= MIDI_OutAlloc(&hMidiOut
, &dwCallback
, &dwInstance
, &dwFlags
, 0, NULL
);
921 return MMSYSERR_NOMEM
;
923 lpwm
->mld
.uDeviceID
= uDeviceID
;
925 dwRet
= MMDRV_Open((LPWINE_MLD
)lpwm
, MODM_OPEN
, (DWORD_PTR
)&lpwm
->mod
, dwFlags
);
927 if (dwRet
!= MMSYSERR_NOERROR
) {
928 MMDRV_Free(hMidiOut
, (LPWINE_MLD
)lpwm
);
932 if (lphMidiOut
) *lphMidiOut
= hMidiOut
;
933 TRACE("=> %d hMidi=%p\n", dwRet
, hMidiOut
);
938 /**************************************************************************
939 * midiOutClose [WINMM.@]
941 UINT WINAPI
midiOutClose(HMIDIOUT hMidiOut
)
946 TRACE("(%p)\n", hMidiOut
);
948 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
949 return MMSYSERR_INVALHANDLE
;
951 dwRet
= MMDRV_Close(wmld
, MODM_CLOSE
);
952 MMDRV_Free(hMidiOut
, wmld
);
957 /**************************************************************************
958 * midiOutPrepareHeader [WINMM.@]
960 UINT WINAPI
midiOutPrepareHeader(HMIDIOUT hMidiOut
,
961 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
965 TRACE("(%p, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
967 if (lpMidiOutHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
968 return MMSYSERR_INVALPARAM
;
970 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
971 return MMSYSERR_INVALHANDLE
;
972 /* FIXME: detect MIDIStream handles and enforce 64KB buffer limit on those */
974 return MMDRV_Message(wmld
, MODM_PREPARE
, (DWORD_PTR
)lpMidiOutHdr
, uSize
);
977 /**************************************************************************
978 * midiOutUnprepareHeader [WINMM.@]
980 UINT WINAPI
midiOutUnprepareHeader(HMIDIOUT hMidiOut
,
981 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
985 TRACE("(%p, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
987 if (lpMidiOutHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
988 return MMSYSERR_INVALPARAM
;
990 if (!(lpMidiOutHdr
->dwFlags
& MHDR_PREPARED
)) {
991 return MMSYSERR_NOERROR
;
994 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
995 return MMSYSERR_INVALHANDLE
;
997 return MMDRV_Message(wmld
, MODM_UNPREPARE
, (DWORD_PTR
)lpMidiOutHdr
, uSize
);
1000 /**************************************************************************
1001 * midiOutShortMsg [WINMM.@]
1003 UINT WINAPI
midiOutShortMsg(HMIDIOUT hMidiOut
, DWORD dwMsg
)
1007 TRACE("(%p, %08X)\n", hMidiOut
, dwMsg
);
1009 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
1010 return MMSYSERR_INVALHANDLE
;
1012 return MMDRV_Message(wmld
, MODM_DATA
, dwMsg
, 0L);
1015 /**************************************************************************
1016 * midiOutLongMsg [WINMM.@]
1018 UINT WINAPI
midiOutLongMsg(HMIDIOUT hMidiOut
,
1019 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
1023 TRACE("(%p, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
1025 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
1026 return MMSYSERR_INVALHANDLE
;
1028 return MMDRV_Message(wmld
, MODM_LONGDATA
, (DWORD_PTR
)lpMidiOutHdr
, uSize
);
1031 /**************************************************************************
1032 * midiOutReset [WINMM.@]
1034 UINT WINAPI
midiOutReset(HMIDIOUT hMidiOut
)
1038 TRACE("(%p)\n", hMidiOut
);
1040 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
1041 return MMSYSERR_INVALHANDLE
;
1043 return MMDRV_Message(wmld
, MODM_RESET
, 0L, 0L);
1046 /**************************************************************************
1047 * midiOutGetVolume [WINMM.@]
1049 UINT WINAPI
midiOutGetVolume(HMIDIOUT hMidiOut
, DWORD
* lpdwVolume
)
1053 TRACE("(%p, %p);\n", hMidiOut
, lpdwVolume
);
1055 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, TRUE
)) == NULL
)
1056 return MMSYSERR_INVALHANDLE
;
1058 return MMDRV_Message(wmld
, MODM_GETVOLUME
, (DWORD_PTR
)lpdwVolume
, 0L);
1061 /**************************************************************************
1062 * midiOutSetVolume [WINMM.@]
1064 UINT WINAPI
midiOutSetVolume(HMIDIOUT hMidiOut
, DWORD dwVolume
)
1068 TRACE("(%p, %d);\n", hMidiOut
, dwVolume
);
1070 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, TRUE
)) == NULL
)
1071 return MMSYSERR_INVALHANDLE
;
1073 return MMDRV_Message(wmld
, MODM_SETVOLUME
, dwVolume
, 0L);
1076 /**************************************************************************
1077 * midiOutCachePatches [WINMM.@]
1079 UINT WINAPI
midiOutCachePatches(HMIDIOUT hMidiOut
, UINT uBank
,
1080 WORD
* lpwPatchArray
, UINT uFlags
)
1082 /* not really necessary to support this */
1083 FIXME("not supported yet\n");
1084 return MMSYSERR_NOTSUPPORTED
;
1087 /**************************************************************************
1088 * midiOutCacheDrumPatches [WINMM.@]
1090 UINT WINAPI
midiOutCacheDrumPatches(HMIDIOUT hMidiOut
, UINT uPatch
,
1091 WORD
* lpwKeyArray
, UINT uFlags
)
1093 FIXME("not supported yet\n");
1094 return MMSYSERR_NOTSUPPORTED
;
1097 /**************************************************************************
1098 * midiOutGetID [WINMM.@]
1100 UINT WINAPI
midiOutGetID(HMIDIOUT hMidiOut
, UINT
* lpuDeviceID
)
1104 TRACE("(%p, %p)\n", hMidiOut
, lpuDeviceID
);
1106 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALPARAM
;
1107 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
1108 return MMSYSERR_INVALHANDLE
;
1110 *lpuDeviceID
= wmld
->uDeviceID
;
1111 return MMSYSERR_NOERROR
;
1114 /**************************************************************************
1115 * midiOutMessage [WINMM.@]
1117 UINT WINAPI
midiOutMessage(HMIDIOUT hMidiOut
, UINT uMessage
,
1118 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1122 TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiOut
, uMessage
, dwParam1
, dwParam2
);
1124 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
) {
1126 if (uMessage
== 0x0001) {
1127 *(LPDWORD
)dwParam1
= 1;
1130 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, TRUE
)) != NULL
) {
1131 return MMDRV_PhysicalFeatures(wmld
, uMessage
, dwParam1
, dwParam2
);
1133 return MMSYSERR_INVALHANDLE
;
1139 FIXME("can't handle OPEN or CLOSE message!\n");
1140 return MMSYSERR_NOTSUPPORTED
;
1142 return MMDRV_Message(wmld
, uMessage
, dwParam1
, dwParam2
);
1145 /**************************************************************************
1146 * midiInGetNumDevs [WINMM.@]
1148 UINT WINAPI
midiInGetNumDevs(void)
1150 return MMDRV_GetNum(MMDRV_MIDIIN
);
1153 /**************************************************************************
1154 * midiInGetDevCapsW [WINMM.@]
1156 UINT WINAPI
midiInGetDevCapsW(UINT_PTR uDeviceID
, LPMIDIINCAPSW lpCaps
, UINT uSize
)
1160 TRACE("(%ld, %p, %d);\n", uDeviceID
, lpCaps
, uSize
);
1162 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
1164 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_MIDIIN
, TRUE
)) == NULL
)
1165 return MMSYSERR_BADDEVICEID
;
1167 return MMDRV_Message(wmld
, MIDM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
1170 /**************************************************************************
1171 * midiInGetDevCapsA [WINMM.@]
1173 UINT WINAPI
midiInGetDevCapsA(UINT_PTR uDeviceID
, LPMIDIINCAPSA lpCaps
, UINT uSize
)
1178 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
1180 ret
= midiInGetDevCapsW(uDeviceID
, &micW
, sizeof(micW
));
1182 if (ret
== MMSYSERR_NOERROR
) {
1184 micA
.wMid
= micW
.wMid
;
1185 micA
.wPid
= micW
.wPid
;
1186 micA
.vDriverVersion
= micW
.vDriverVersion
;
1187 WideCharToMultiByte( CP_ACP
, 0, micW
.szPname
, -1, micA
.szPname
,
1188 sizeof(micA
.szPname
), NULL
, NULL
);
1189 micA
.dwSupport
= micW
.dwSupport
;
1190 memcpy(lpCaps
, &micA
, min(uSize
, sizeof(micA
)));
1195 /**************************************************************************
1196 * midiInOpen [WINMM.@]
1198 UINT WINAPI
midiInOpen(HMIDIIN
* lphMidiIn
, UINT uDeviceID
,
1199 DWORD_PTR dwCallback
, DWORD_PTR dwInstance
, DWORD dwFlags
)
1205 TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
1206 lphMidiIn
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
1208 if (lphMidiIn
!= NULL
) *lphMidiIn
= 0;
1210 lpwm
= (LPWINE_MIDI
)MMDRV_Alloc(sizeof(WINE_MIDI
), MMDRV_MIDIIN
, &hMidiIn
,
1211 &dwFlags
, &dwCallback
, &dwInstance
);
1214 return MMSYSERR_NOMEM
;
1216 lpwm
->mod
.hMidi
= hMidiIn
;
1217 lpwm
->mod
.dwCallback
= dwCallback
;
1218 lpwm
->mod
.dwInstance
= dwInstance
;
1220 lpwm
->mld
.uDeviceID
= uDeviceID
;
1221 dwRet
= MMDRV_Open(&lpwm
->mld
, MIDM_OPEN
, (DWORD_PTR
)&lpwm
->mod
, dwFlags
);
1223 if (dwRet
!= MMSYSERR_NOERROR
) {
1224 MMDRV_Free(hMidiIn
, &lpwm
->mld
);
1227 if (lphMidiIn
!= NULL
) *lphMidiIn
= hMidiIn
;
1228 TRACE("=> %d hMidi=%p\n", dwRet
, hMidiIn
);
1233 /**************************************************************************
1234 * midiInClose [WINMM.@]
1236 UINT WINAPI
midiInClose(HMIDIIN hMidiIn
)
1241 TRACE("(%p)\n", hMidiIn
);
1243 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1244 return MMSYSERR_INVALHANDLE
;
1246 dwRet
= MMDRV_Close(wmld
, MIDM_CLOSE
);
1247 MMDRV_Free(hMidiIn
, wmld
);
1251 /**************************************************************************
1252 * midiInPrepareHeader [WINMM.@]
1254 UINT WINAPI
midiInPrepareHeader(HMIDIIN hMidiIn
,
1255 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
1259 TRACE("(%p, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
1261 if (lpMidiInHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
1262 return MMSYSERR_INVALPARAM
;
1264 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1265 return MMSYSERR_INVALHANDLE
;
1267 return MMDRV_Message(wmld
, MIDM_PREPARE
, (DWORD_PTR
)lpMidiInHdr
, uSize
);
1270 /**************************************************************************
1271 * midiInUnprepareHeader [WINMM.@]
1273 UINT WINAPI
midiInUnprepareHeader(HMIDIIN hMidiIn
,
1274 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
1278 TRACE("(%p, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
1280 if (lpMidiInHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
1281 return MMSYSERR_INVALPARAM
;
1283 if (!(lpMidiInHdr
->dwFlags
& MHDR_PREPARED
)) {
1284 return MMSYSERR_NOERROR
;
1287 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1288 return MMSYSERR_INVALHANDLE
;
1290 return MMDRV_Message(wmld
, MIDM_UNPREPARE
, (DWORD_PTR
)lpMidiInHdr
, uSize
);
1293 /**************************************************************************
1294 * midiInAddBuffer [WINMM.@]
1296 UINT WINAPI
midiInAddBuffer(HMIDIIN hMidiIn
,
1297 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
1301 TRACE("(%p, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
1303 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1304 return MMSYSERR_INVALHANDLE
;
1306 return MMDRV_Message(wmld
, MIDM_ADDBUFFER
, (DWORD_PTR
)lpMidiInHdr
, uSize
);
1309 /**************************************************************************
1310 * midiInStart [WINMM.@]
1312 UINT WINAPI
midiInStart(HMIDIIN hMidiIn
)
1316 TRACE("(%p)\n", hMidiIn
);
1318 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1319 return MMSYSERR_INVALHANDLE
;
1321 return MMDRV_Message(wmld
, MIDM_START
, 0L, 0L);
1324 /**************************************************************************
1325 * midiInStop [WINMM.@]
1327 UINT WINAPI
midiInStop(HMIDIIN hMidiIn
)
1331 TRACE("(%p)\n", hMidiIn
);
1333 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1334 return MMSYSERR_INVALHANDLE
;
1336 return MMDRV_Message(wmld
, MIDM_STOP
, 0L, 0L);
1339 /**************************************************************************
1340 * midiInReset [WINMM.@]
1342 UINT WINAPI
midiInReset(HMIDIIN hMidiIn
)
1346 TRACE("(%p)\n", hMidiIn
);
1348 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1349 return MMSYSERR_INVALHANDLE
;
1351 return MMDRV_Message(wmld
, MIDM_RESET
, 0L, 0L);
1354 /**************************************************************************
1355 * midiInGetID [WINMM.@]
1357 UINT WINAPI
midiInGetID(HMIDIIN hMidiIn
, UINT
* lpuDeviceID
)
1361 TRACE("(%p, %p)\n", hMidiIn
, lpuDeviceID
);
1363 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALPARAM
;
1365 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, TRUE
)) == NULL
)
1366 return MMSYSERR_INVALHANDLE
;
1368 *lpuDeviceID
= wmld
->uDeviceID
;
1370 return MMSYSERR_NOERROR
;
1373 /**************************************************************************
1374 * midiInMessage [WINMM.@]
1376 UINT WINAPI
midiInMessage(HMIDIIN hMidiIn
, UINT uMessage
,
1377 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1381 TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiIn
, uMessage
, dwParam1
, dwParam2
);
1383 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
1384 return MMSYSERR_INVALHANDLE
;
1389 FIXME("can't handle OPEN or CLOSE message!\n");
1390 return MMSYSERR_NOTSUPPORTED
;
1392 return MMDRV_Message(wmld
, uMessage
, dwParam1
, dwParam2
);
1395 /**************************************************************************
1396 * midiConnect [WINMM.@]
1398 MMRESULT WINAPI
midiConnect(HMIDI hMidi
, HMIDIOUT hmo
, LPVOID pReserved
)
1400 FIXME("(%p, %p, %p): Stub\n", hMidi
, hmo
, pReserved
);
1401 return MMSYSERR_ERROR
;
1404 /**************************************************************************
1405 * midiDisconnect [WINMM.@]
1407 MMRESULT WINAPI
midiDisconnect(HMIDI hMidi
, HMIDIOUT hmo
, LPVOID pReserved
)
1409 FIXME("(%p, %p, %p): Stub\n", hMidi
, hmo
, pReserved
);
1410 return MMSYSERR_ERROR
;
1413 typedef struct WINE_MIDIStream
{
1424 LPMIDIHDR lpMidiHdr
;
1427 #define WINE_MSM_HEADER (WM_USER+0)
1428 #define WINE_MSM_STOP (WM_USER+1)
1430 /**************************************************************************
1431 * MMSYSTEM_GetMidiStream [internal]
1433 static BOOL
MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm
, WINE_MIDIStream
** lpMidiStrm
, WINE_MIDI
** lplpwm
)
1435 WINE_MIDI
* lpwm
= (LPWINE_MIDI
)MMDRV_Get(hMidiStrm
, MMDRV_MIDIOUT
, FALSE
);
1444 *lpMidiStrm
= (WINE_MIDIStream
*)lpwm
->mod
.rgIds
.dwStreamID
;
1446 return *lpMidiStrm
!= NULL
;
1449 /**************************************************************************
1450 * MMSYSTEM_MidiStream_Convert [internal]
1452 static DWORD
MMSYSTEM_MidiStream_Convert(WINE_MIDIStream
* lpMidiStrm
, DWORD pulse
)
1456 if (lpMidiStrm
->dwTimeDiv
== 0) {
1457 FIXME("Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
1458 } else if (lpMidiStrm
->dwTimeDiv
> 0x8000) { /* SMPTE, unchecked FIXME? */
1459 int nf
= -(char)HIBYTE(lpMidiStrm
->dwTimeDiv
); /* number of frames */
1460 int nsf
= LOBYTE(lpMidiStrm
->dwTimeDiv
); /* number of sub-frames */
1461 ret
= (pulse
* 1000) / (nf
* nsf
);
1463 ret
= (DWORD
)((double)pulse
* ((double)lpMidiStrm
->dwTempo
/ 1000) /
1464 (double)lpMidiStrm
->dwTimeDiv
);
1470 /**************************************************************************
1471 * MMSYSTEM_MidiStream_MessageHandler [internal]
1473 static BOOL
MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream
* lpMidiStrm
, LPWINE_MIDI lpwm
, LPMSG msg
)
1475 LPMIDIHDR lpMidiHdr
;
1479 switch (msg
->message
) {
1481 SetEvent(lpMidiStrm
->hEvent
);
1485 /* this is not quite what MS doc says... */
1486 midiOutReset(lpMidiStrm
->hDevice
);
1487 /* empty list of already submitted buffers */
1488 for (lpMidiHdr
= lpMidiStrm
->lpMidiHdr
; lpMidiHdr
; ) {
1489 LPMIDIHDR lphdr
= lpMidiHdr
;
1490 lpMidiHdr
= lpMidiHdr
->lpNext
;
1491 lphdr
->dwFlags
|= MHDR_DONE
;
1492 lphdr
->dwFlags
&= ~MHDR_INQUEUE
;
1494 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1495 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_DONE
,
1496 lpwm
->mod
.dwInstance
, (DWORD_PTR
)lphdr
, 0);
1498 lpMidiStrm
->lpMidiHdr
= 0;
1499 SetEvent(lpMidiStrm
->hEvent
);
1501 case WINE_MSM_HEADER
:
1502 /* sets initial tick count for first MIDIHDR */
1503 if (!lpMidiStrm
->dwStartTicks
)
1504 lpMidiStrm
->dwStartTicks
= GetTickCount();
1506 /* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
1507 * by native mcimidi, it doesn't look like a correct one".
1508 * this trick allows to throw it away... but I don't like it.
1509 * It looks like part of the file I'm trying to play and definitively looks
1510 * like raw midi content
1511 * I'd really like to understand why native mcimidi sends it. Perhaps a bad
1512 * synchronization issue where native mcimidi is still processing raw MIDI
1513 * content before generating MIDIEVENTs ?
1515 * 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
1516 * 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
1517 * 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
1518 * 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
1519 * 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
1520 * 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
1521 * 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
1522 * 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
1523 * 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
1524 * 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
1525 * 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
1526 * 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
1527 * 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
1528 * 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
1529 * 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
1530 * 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
1531 * 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
1533 lpMidiHdr
= (LPMIDIHDR
)msg
->lParam
;
1534 lpData
= (LPBYTE
)lpMidiHdr
->lpData
;
1535 TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBytesRecorded=%u/%u dwFlags=0x%08x size=%lu]\n",
1536 (lpMidiHdr
->dwFlags
& MHDR_ISSTRM
) ? "stream" : "regular", lpMidiHdr
,
1537 lpMidiHdr
, lpMidiHdr
->dwBytesRecorded
, lpMidiHdr
->dwBufferLength
,
1538 lpMidiHdr
->dwFlags
, msg
->wParam
);
1540 /* dumps content of lpMidiHdr->lpData
1541 * FIXME: there should be a debug routine somewhere that already does this
1542 * I hate spreading this type of shit all around the code
1544 for (dwToGo
= 0; dwToGo
< lpMidiHdr
->dwBufferLength
; dwToGo
+= 16) {
1548 for (i
= 0; i
< min(16, lpMidiHdr
->dwBufferLength
- dwToGo
); i
++)
1549 printf("%02x ", lpData
[dwToGo
+ i
]);
1552 for (i
= 0; i
< min(16, lpMidiHdr
->dwBufferLength
- dwToGo
); i
++) {
1553 ch
= lpData
[dwToGo
+ i
];
1554 printf("%c", (ch
>= 0x20 && ch
<= 0x7F) ? ch
: '.');
1559 if (((LPMIDIEVENT
)lpData
)->dwStreamID
!= 0 &&
1560 ((LPMIDIEVENT
)lpData
)->dwStreamID
!= 0xFFFFFFFF &&
1561 ((LPMIDIEVENT
)lpData
)->dwStreamID
!= (DWORD
)lpMidiStrm
) {
1562 FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
1563 (lpMidiHdr
->dwFlags
& MHDR_ISSTRM
) ? "stream" : "regular",
1564 ((LPMIDIEVENT
)lpData
)->dwStreamID
);
1565 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1566 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1568 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1569 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_DONE
,
1570 lpwm
->mod
.dwInstance
, (DWORD_PTR
)lpMidiHdr
, 0);
1574 for (lpmh
= &lpMidiStrm
->lpMidiHdr
; *lpmh
; lpmh
= &(*lpmh
)->lpNext
);
1576 lpMidiHdr
= (LPMIDIHDR
)msg
->lParam
;
1577 lpMidiHdr
->lpNext
= 0;
1578 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1579 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1583 FIXME("Unknown message %d\n", msg
->message
);
1589 /**************************************************************************
1590 * MMSYSTEM_MidiStream_Player [internal]
1592 static DWORD CALLBACK
MMSYSTEM_MidiStream_Player(LPVOID pmt
)
1594 WINE_MIDIStream
* lpMidiStrm
= pmt
;
1599 LPMIDIHDR lpMidiHdr
;
1602 TRACE("(%p)!\n", lpMidiStrm
);
1605 (lpwm
= (LPWINE_MIDI
)MMDRV_Get(lpMidiStrm
->hDevice
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
1608 /* force thread's queue creation */
1609 PeekMessageA(&msg
, 0, 0, 0, PM_NOREMOVE
);
1611 lpMidiStrm
->dwStartTicks
= 0;
1612 lpMidiStrm
->dwPulses
= 0;
1614 lpMidiStrm
->lpMidiHdr
= 0;
1616 /* midiStreamOpen is waiting for ack */
1617 SetEvent(lpMidiStrm
->hEvent
);
1620 lpMidiHdr
= lpMidiStrm
->lpMidiHdr
;
1622 /* for first message, block until one arrives, then process all that are available */
1623 GetMessageA(&msg
, 0, 0, 0);
1625 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm
, lpwm
, &msg
))
1627 } while (PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
));
1632 while (dwOffset
+ offsetof(MIDIEVENT
,dwParms
) <= lpMidiHdr
->dwBytesRecorded
) {
1633 LPMIDIEVENT me
= (LPMIDIEVENT
)(lpMidiHdr
->lpData
+dwOffset
);
1635 /* do we have to wait ? */
1636 if (me
->dwDeltaTime
) {
1637 lpMidiStrm
->dwPositionMS
+= MMSYSTEM_MidiStream_Convert(lpMidiStrm
, me
->dwDeltaTime
);
1638 lpMidiStrm
->dwPulses
+= me
->dwDeltaTime
;
1640 dwToGo
= lpMidiStrm
->dwStartTicks
+ lpMidiStrm
->dwPositionMS
;
1642 TRACE("%d/%d/%d\n", dwToGo
, GetTickCount(), me
->dwDeltaTime
);
1643 while ((dwCurrTC
= GetTickCount()) < dwToGo
) {
1644 if (MsgWaitForMultipleObjects(0, NULL
, FALSE
, dwToGo
- dwCurrTC
, QS_ALLINPUT
) == WAIT_OBJECT_0
) {
1645 /* got a message, handle it */
1646 while (PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
)) {
1647 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm
, lpwm
, &msg
))
1649 /* is lpMidiHdr still current? */
1650 if (lpMidiHdr
!= lpMidiStrm
->lpMidiHdr
) {
1655 /* timeout, so me->dwDeltaTime is elapsed, can break the while loop */
1660 switch (MEVT_EVENTTYPE(me
->dwEvent
& ~MEVT_F_CALLBACK
)) {
1662 FIXME("NIY: MEVT_COMMENT\n");
1663 /* do nothing, skip bytes */
1666 FIXME("NIY: MEVT_LONGMSG, aka sending Sysex event\n");
1671 midiOutShortMsg(lpMidiStrm
->hDevice
, MEVT_EVENTPARM(me
->dwEvent
));
1674 lpMidiStrm
->dwTempo
= MEVT_EVENTPARM(me
->dwEvent
);
1679 FIXME("Unknown MEVT (0x%02x)\n", MEVT_EVENTTYPE(me
->dwEvent
& ~MEVT_F_CALLBACK
));
1682 if (me
->dwEvent
& MEVT_F_CALLBACK
) {
1683 /* native fills dwOffset regardless of the cbMidiHdr size argument to midiStreamOut */
1684 lpMidiHdr
->dwOffset
= dwOffset
;
1685 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1686 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_POSITIONCB
,
1687 lpwm
->mod
.dwInstance
, (LPARAM
)lpMidiHdr
, 0L);
1689 dwOffset
+= offsetof(MIDIEVENT
,dwParms
);
1690 if (me
->dwEvent
& MEVT_F_LONG
)
1691 dwOffset
+= (MEVT_EVENTPARM(me
->dwEvent
) + 3) & ~3;
1693 /* done with this header */
1694 lpMidiStrm
->lpMidiHdr
= lpMidiHdr
->lpNext
;
1695 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1696 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1698 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1699 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_DONE
,
1700 lpwm
->mod
.dwInstance
, (DWORD_PTR
)lpMidiHdr
, 0);
1704 TRACE("End of thread\n");
1708 /**************************************************************************
1709 * MMSYSTEM_MidiStream_PostMessage [internal]
1711 static BOOL
MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream
* lpMidiStrm
, WORD msg
, DWORD pmt1
, DWORD pmt2
)
1713 if (PostThreadMessageA(lpMidiStrm
->dwThreadID
, msg
, pmt1
, pmt2
)) {
1714 MsgWaitForMultipleObjects( 1, &lpMidiStrm
->hEvent
, FALSE
, INFINITE
, 0 );
1716 ERR("bad PostThreadMessageA\n");
1722 /**************************************************************************
1723 * midiStreamClose [WINMM.@]
1725 MMRESULT WINAPI
midiStreamClose(HMIDISTRM hMidiStrm
)
1727 WINE_MIDIStream
* lpMidiStrm
;
1729 TRACE("(%p)!\n", hMidiStrm
);
1731 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
))
1732 return MMSYSERR_INVALHANDLE
;
1734 midiStreamStop(hMidiStrm
);
1735 MMSYSTEM_MidiStream_PostMessage(lpMidiStrm
, WM_QUIT
, 0, 0);
1736 CloseHandle(lpMidiStrm
->hEvent
);
1737 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
1739 return midiOutClose((HMIDIOUT
)hMidiStrm
);
1742 /**************************************************************************
1743 * midiStreamOpen [WINMM.@]
1745 MMRESULT WINAPI
midiStreamOpen(HMIDISTRM
* lphMidiStrm
, LPUINT lpuDeviceID
,
1746 DWORD cMidi
, DWORD_PTR dwCallback
,
1747 DWORD_PTR dwInstance
, DWORD fdwOpen
)
1749 WINE_MIDIStream
* lpMidiStrm
;
1751 MIDIOPENSTRMID mosm
;
1755 TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
1756 lphMidiStrm
, lpuDeviceID
, cMidi
, dwCallback
, dwInstance
, fdwOpen
);
1758 if (cMidi
!= 1 || lphMidiStrm
== NULL
|| lpuDeviceID
== NULL
)
1759 return MMSYSERR_INVALPARAM
;
1761 switch (fdwOpen
& CALLBACK_TYPEMASK
) {
1762 case CALLBACK_WINDOW
:
1763 if (dwCallback
&& !IsWindow((HWND
)dwCallback
))
1764 return MMSYSERR_INVALPARAM
;
1768 lpMidiStrm
= HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream
));
1770 return MMSYSERR_NOMEM
;
1772 lpMidiStrm
->dwTempo
= 500000;
1773 lpMidiStrm
->dwTimeDiv
= 480; /* 480 is 120 quarter notes per minute *//* FIXME ??*/
1774 lpMidiStrm
->dwPositionMS
= 0;
1776 mosm
.dwStreamID
= (DWORD
)lpMidiStrm
;
1777 /* FIXME: the correct value is not allocated yet for MAPPER */
1778 mosm
.wDeviceID
= *lpuDeviceID
;
1779 lpwm
= MIDI_OutAlloc(&hMidiOut
, &dwCallback
, &dwInstance
, &fdwOpen
, 1, &mosm
);
1781 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
1782 return MMSYSERR_NOMEM
;
1784 lpMidiStrm
->hDevice
= hMidiOut
;
1785 *lphMidiStrm
= (HMIDISTRM
)hMidiOut
;
1787 lpwm
->mld
.uDeviceID
= *lpuDeviceID
;
1789 ret
= MMDRV_Open(&lpwm
->mld
, MODM_OPEN
, (DWORD_PTR
)&lpwm
->mod
, fdwOpen
);
1790 if (ret
!= MMSYSERR_NOERROR
) {
1791 MMDRV_Free(hMidiOut
, &lpwm
->mld
);
1792 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
1796 lpMidiStrm
->hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1797 lpMidiStrm
->wFlags
= HIWORD(fdwOpen
);
1799 lpMidiStrm
->hThread
= CreateThread(NULL
, 0, MMSYSTEM_MidiStream_Player
,
1800 lpMidiStrm
, 0, &(lpMidiStrm
->dwThreadID
));
1802 if (!lpMidiStrm
->hThread
) {
1803 midiStreamClose((HMIDISTRM
)hMidiOut
);
1804 return MMSYSERR_NOMEM
;
1806 SetThreadPriority(lpMidiStrm
->hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
1808 /* wait for thread to have started, and for its queue to be created */
1809 WaitForSingleObject(lpMidiStrm
->hEvent
, INFINITE
);
1810 /* start in paused mode */
1811 SuspendThread(lpMidiStrm
->hThread
);
1813 TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
1814 *lpuDeviceID
, lpwm
->mld
.uDeviceID
, *lphMidiStrm
, ret
, lpMidiStrm
);
1818 /**************************************************************************
1819 * midiStreamOut [WINMM.@]
1821 MMRESULT WINAPI
midiStreamOut(HMIDISTRM hMidiStrm
, LPMIDIHDR lpMidiHdr
,
1824 WINE_MIDIStream
* lpMidiStrm
;
1825 DWORD ret
= MMSYSERR_NOERROR
;
1827 TRACE("(%p, %p, %u)!\n", hMidiStrm
, lpMidiHdr
, cbMidiHdr
);
1829 if (cbMidiHdr
< offsetof(MIDIHDR
,dwOffset
) || !lpMidiHdr
|| !lpMidiHdr
->lpData
1830 || lpMidiHdr
->dwBufferLength
< lpMidiHdr
->dwBytesRecorded
1831 || lpMidiHdr
->dwBytesRecorded
% 4 /* player expects DWORD padding */)
1832 return MMSYSERR_INVALPARAM
;
1833 /* FIXME: Native additionally checks if the MIDIEVENTs in lpData
1834 * exactly fit dwBytesRecorded. */
1836 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
))
1837 return MIDIERR_UNPREPARED
;
1839 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1840 return MIDIERR_STILLPLAYING
;
1842 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1843 ret
= MMSYSERR_INVALHANDLE
;
1845 lpMidiHdr
->dwFlags
|= MHDR_ISSTRM
| MHDR_INQUEUE
;
1846 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1847 if (!PostThreadMessageA(lpMidiStrm
->dwThreadID
,
1848 WINE_MSM_HEADER
, cbMidiHdr
,
1849 (LPARAM
)lpMidiHdr
)) {
1850 ERR("bad PostThreadMessageA\n");
1851 ret
= MMSYSERR_ERROR
;
1857 /**************************************************************************
1858 * midiStreamPause [WINMM.@]
1860 MMRESULT WINAPI
midiStreamPause(HMIDISTRM hMidiStrm
)
1862 WINE_MIDIStream
* lpMidiStrm
;
1863 DWORD ret
= MMSYSERR_NOERROR
;
1865 TRACE("(%p)!\n", hMidiStrm
);
1867 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1868 ret
= MMSYSERR_INVALHANDLE
;
1870 if (SuspendThread(lpMidiStrm
->hThread
) == 0xFFFFFFFF) {
1871 ERR("bad Suspend (%d)\n", GetLastError());
1872 ret
= MMSYSERR_ERROR
;
1878 /**************************************************************************
1879 * midiStreamPosition [WINMM.@]
1881 MMRESULT WINAPI
midiStreamPosition(HMIDISTRM hMidiStrm
, LPMMTIME lpMMT
, UINT cbmmt
)
1883 WINE_MIDIStream
* lpMidiStrm
;
1884 DWORD ret
= MMSYSERR_NOERROR
;
1886 TRACE("(%p, %p, %u)!\n", hMidiStrm
, lpMMT
, cbmmt
);
1888 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1889 ret
= MMSYSERR_INVALHANDLE
;
1890 } else if (lpMMT
== NULL
|| cbmmt
!= sizeof(MMTIME
)) {
1891 ret
= MMSYSERR_INVALPARAM
;
1893 switch (lpMMT
->wType
) {
1895 FIXME("Unsupported time type %x\n", lpMMT
->wType
);
1898 lpMMT
->wType
= TIME_MS
;
1899 /* fall through to alternative format */
1901 lpMMT
->u
.ms
= lpMidiStrm
->dwPositionMS
;
1902 TRACE("=> %d ms\n", lpMMT
->u
.ms
);
1905 lpMMT
->u
.ticks
= lpMidiStrm
->dwPulses
;
1906 TRACE("=> %d ticks\n", lpMMT
->u
.ticks
);
1913 /**************************************************************************
1914 * midiStreamProperty [WINMM.@]
1916 MMRESULT WINAPI
midiStreamProperty(HMIDISTRM hMidiStrm
, LPBYTE lpPropData
, DWORD dwProperty
)
1918 WINE_MIDIStream
* lpMidiStrm
;
1919 MMRESULT ret
= MMSYSERR_NOERROR
;
1921 TRACE("(%p, %p, %x)\n", hMidiStrm
, lpPropData
, dwProperty
);
1923 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1924 ret
= MMSYSERR_INVALHANDLE
;
1925 } else if ((dwProperty
& (MIDIPROP_GET
|MIDIPROP_SET
)) == 0) {
1926 ret
= MMSYSERR_INVALPARAM
;
1927 } else if (dwProperty
& MIDIPROP_TEMPO
) {
1928 MIDIPROPTEMPO
* mpt
= (MIDIPROPTEMPO
*)lpPropData
;
1930 if (sizeof(MIDIPROPTEMPO
) != mpt
->cbStruct
) {
1931 ret
= MMSYSERR_INVALPARAM
;
1932 } else if (dwProperty
& MIDIPROP_SET
) {
1933 lpMidiStrm
->dwTempo
= mpt
->dwTempo
;
1934 TRACE("Setting tempo to %d\n", mpt
->dwTempo
);
1935 } else if (dwProperty
& MIDIPROP_GET
) {
1936 mpt
->dwTempo
= lpMidiStrm
->dwTempo
;
1937 TRACE("Getting tempo <= %d\n", mpt
->dwTempo
);
1939 } else if (dwProperty
& MIDIPROP_TIMEDIV
) {
1940 MIDIPROPTIMEDIV
* mptd
= (MIDIPROPTIMEDIV
*)lpPropData
;
1942 if (sizeof(MIDIPROPTIMEDIV
) != mptd
->cbStruct
) {
1943 ret
= MMSYSERR_INVALPARAM
;
1944 } else if (dwProperty
& MIDIPROP_SET
) {
1945 lpMidiStrm
->dwTimeDiv
= mptd
->dwTimeDiv
;
1946 TRACE("Setting time div to %d\n", mptd
->dwTimeDiv
);
1947 } else if (dwProperty
& MIDIPROP_GET
) {
1948 mptd
->dwTimeDiv
= lpMidiStrm
->dwTimeDiv
;
1949 TRACE("Getting time div <= %d\n", mptd
->dwTimeDiv
);
1952 ret
= MMSYSERR_INVALPARAM
;
1958 /**************************************************************************
1959 * midiStreamRestart [WINMM.@]
1961 MMRESULT WINAPI
midiStreamRestart(HMIDISTRM hMidiStrm
)
1963 WINE_MIDIStream
* lpMidiStrm
;
1964 MMRESULT ret
= MMSYSERR_NOERROR
;
1966 TRACE("(%p)!\n", hMidiStrm
);
1968 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1969 ret
= MMSYSERR_INVALHANDLE
;
1973 /* since we increase the thread suspend count on each midiStreamPause
1974 * there may be a need for several ResumeThread
1977 ret
= ResumeThread(lpMidiStrm
->hThread
);
1978 } while (ret
!= 0xFFFFFFFF && ret
> 1);
1979 if (ret
== 0xFFFFFFFF) {
1980 ERR("bad Resume (%d)\n", GetLastError());
1981 ret
= MMSYSERR_ERROR
;
1983 lpMidiStrm
->dwStartTicks
= GetTickCount() - lpMidiStrm
->dwPositionMS
;
1989 /**************************************************************************
1990 * midiStreamStop [WINMM.@]
1992 MMRESULT WINAPI
midiStreamStop(HMIDISTRM hMidiStrm
)
1994 WINE_MIDIStream
* lpMidiStrm
;
1995 MMRESULT ret
= MMSYSERR_NOERROR
;
1997 TRACE("(%p)!\n", hMidiStrm
);
1999 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
2000 ret
= MMSYSERR_INVALHANDLE
;
2002 /* in case stream has been paused... FIXME is the current state correct ? */
2003 midiStreamRestart(hMidiStrm
);
2004 MMSYSTEM_MidiStream_PostMessage(lpMidiStrm
, WINE_MSM_STOP
, 0, 0);
2009 static UINT
WAVE_Open(HANDLE
* lphndl
, UINT uDeviceID
, UINT uType
,
2010 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2011 DWORD_PTR dwInstance
, DWORD dwFlags
)
2015 DWORD dwRet
= MMSYSERR_NOERROR
;
2018 TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08X);\n",
2019 lphndl
, (int)uDeviceID
, (uType
==MMDRV_WAVEOUT
)?"Out":"In", lpFormat
, dwCallback
,
2020 dwInstance
, dwFlags
);
2022 if (dwFlags
& WAVE_FORMAT_QUERY
)
2023 TRACE("WAVE_FORMAT_QUERY requested !\n");
2025 if (lpFormat
== NULL
) {
2026 WARN("bad format\n");
2027 return WAVERR_BADFORMAT
;
2030 if ((dwFlags
& WAVE_MAPPED
) && (uDeviceID
== (UINT
)-1)) {
2031 WARN("invalid parameter\n");
2032 return MMSYSERR_INVALPARAM
;
2035 /* may have a PCMWAVEFORMAT rather than a WAVEFORMATEX so don't read cbSize */
2036 TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u\n",
2037 lpFormat
->wFormatTag
, lpFormat
->nChannels
, lpFormat
->nSamplesPerSec
,
2038 lpFormat
->nAvgBytesPerSec
, lpFormat
->nBlockAlign
, lpFormat
->wBitsPerSample
);
2040 if ((wmld
= MMDRV_Alloc(sizeof(WINE_WAVE
), uType
, &handle
,
2041 &dwFlags
, &dwCallback
, &dwInstance
)) == NULL
) {
2042 WARN("no memory\n");
2043 return MMSYSERR_NOMEM
;
2047 wod
.lpFormat
= (LPWAVEFORMATEX
)lpFormat
; /* should the struct be copied iso pointer? */
2048 wod
.dwCallback
= dwCallback
;
2049 wod
.dwInstance
= dwInstance
;
2052 TRACE("cb=%08lx\n", wod
.dwCallback
);
2055 if (dwFlags
& WAVE_MAPPED
) {
2056 wod
.uMappedDeviceID
= uDeviceID
;
2057 uDeviceID
= WAVE_MAPPER
;
2059 wod
.uMappedDeviceID
= -1;
2061 wmld
->uDeviceID
= uDeviceID
;
2063 dwRet
= MMDRV_Open(wmld
, (uType
== MMDRV_WAVEOUT
) ? WODM_OPEN
: WIDM_OPEN
,
2064 (DWORD_PTR
)&wod
, dwFlags
);
2066 TRACE("dwRet = %s\n", WINMM_ErrorToString(dwRet
));
2067 if (dwRet
!= WAVERR_BADFORMAT
||
2068 ((dwFlags
& (WAVE_MAPPED
|WAVE_FORMAT_DIRECT
)) != 0) || (uDeviceID
== WAVE_MAPPER
)) break;
2069 /* if we ask for a format which isn't supported by the physical driver,
2070 * let's try to map it through the wave mapper (except, if we already tried
2071 * or user didn't allow us to use acm codecs or the device is already the mapper)
2073 dwFlags
|= WAVE_MAPPED
;
2074 /* we shall loop only one */
2077 if ((dwFlags
& WAVE_FORMAT_QUERY
) || dwRet
!= MMSYSERR_NOERROR
) {
2078 MMDRV_Free(handle
, wmld
);
2082 if (lphndl
!= NULL
) *lphndl
= handle
;
2083 TRACE("=> %s hWave=%p\n", WINMM_ErrorToString(dwRet
), handle
);
2088 /**************************************************************************
2089 * waveOutGetNumDevs [WINMM.@]
2091 UINT WINAPI
waveOutGetNumDevs(void)
2093 return MMDRV_GetNum(MMDRV_WAVEOUT
);
2096 /**************************************************************************
2097 * waveOutGetDevCapsA [WINMM.@]
2099 UINT WINAPI
waveOutGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEOUTCAPSA lpCaps
,
2105 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2107 ret
= waveOutGetDevCapsW(uDeviceID
, &wocW
, sizeof(wocW
));
2109 if (ret
== MMSYSERR_NOERROR
) {
2111 wocA
.wMid
= wocW
.wMid
;
2112 wocA
.wPid
= wocW
.wPid
;
2113 wocA
.vDriverVersion
= wocW
.vDriverVersion
;
2114 WideCharToMultiByte( CP_ACP
, 0, wocW
.szPname
, -1, wocA
.szPname
,
2115 sizeof(wocA
.szPname
), NULL
, NULL
);
2116 wocA
.dwFormats
= wocW
.dwFormats
;
2117 wocA
.wChannels
= wocW
.wChannels
;
2118 wocA
.dwSupport
= wocW
.dwSupport
;
2119 memcpy(lpCaps
, &wocA
, min(uSize
, sizeof(wocA
)));
2124 /**************************************************************************
2125 * waveOutGetDevCapsW [WINMM.@]
2127 UINT WINAPI
waveOutGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEOUTCAPSW lpCaps
,
2132 TRACE("(%lu %p %u)!\n", uDeviceID
, lpCaps
, uSize
);
2134 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2136 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_WAVEOUT
, TRUE
)) == NULL
)
2137 return MMSYSERR_BADDEVICEID
;
2139 return MMDRV_Message(wmld
, WODM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
2142 /**************************************************************************
2143 * waveOutGetErrorTextA [WINMM.@]
2144 * waveInGetErrorTextA [WINMM.@]
2146 UINT WINAPI
waveOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
2150 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2151 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2154 LPWSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
* sizeof(WCHAR
));
2155 if (!xstr
) ret
= MMSYSERR_NOMEM
;
2158 ret
= waveOutGetErrorTextW(uError
, xstr
, uSize
);
2159 if (ret
== MMSYSERR_NOERROR
)
2160 WideCharToMultiByte(CP_ACP
, 0, xstr
, -1, lpText
, uSize
, NULL
, NULL
);
2161 HeapFree(GetProcessHeap(), 0, xstr
);
2167 /**************************************************************************
2168 * waveOutGetErrorTextW [WINMM.@]
2169 * waveInGetErrorTextW [WINMM.@]
2171 UINT WINAPI
waveOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
2173 UINT ret
= MMSYSERR_BADERRNUM
;
2175 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
2176 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
2178 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
2179 * a warning for the test was always true */
2180 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
2181 (uError
>= WAVERR_BASE
&& uError
<= WAVERR_LASTERROR
)) {
2182 if (LoadStringW(hWinMM32Instance
,
2183 uError
, lpText
, uSize
) > 0) {
2184 ret
= MMSYSERR_NOERROR
;
2190 /**************************************************************************
2191 * waveOutOpen [WINMM.@]
2192 * All the args/structs have the same layout as the win16 equivalents
2194 MMRESULT WINAPI
waveOutOpen(LPHWAVEOUT lphWaveOut
, UINT uDeviceID
,
2195 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2196 DWORD_PTR dwInstance
, DWORD dwFlags
)
2198 return WAVE_Open((HANDLE
*)lphWaveOut
, uDeviceID
, MMDRV_WAVEOUT
, lpFormat
,
2199 dwCallback
, dwInstance
, dwFlags
);
2202 /**************************************************************************
2203 * waveOutClose [WINMM.@]
2205 UINT WINAPI
waveOutClose(HWAVEOUT hWaveOut
)
2210 TRACE("(%p)\n", hWaveOut
);
2212 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2213 return MMSYSERR_INVALHANDLE
;
2215 dwRet
= MMDRV_Close(wmld
, WODM_CLOSE
);
2216 if (dwRet
!= WAVERR_STILLPLAYING
)
2217 MMDRV_Free(hWaveOut
, wmld
);
2222 /**************************************************************************
2223 * waveOutPrepareHeader [WINMM.@]
2225 UINT WINAPI
waveOutPrepareHeader(HWAVEOUT hWaveOut
,
2226 WAVEHDR
* lpWaveOutHdr
, UINT uSize
)
2231 TRACE("(%p, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2233 if (lpWaveOutHdr
== NULL
|| uSize
< sizeof (WAVEHDR
))
2234 return MMSYSERR_INVALPARAM
;
2236 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2237 return MMSYSERR_INVALHANDLE
;
2239 if ((result
= MMDRV_Message(wmld
, WODM_PREPARE
, (DWORD_PTR
)lpWaveOutHdr
,
2240 uSize
)) != MMSYSERR_NOTSUPPORTED
)
2243 if (lpWaveOutHdr
->dwFlags
& WHDR_INQUEUE
)
2244 return WAVERR_STILLPLAYING
;
2246 lpWaveOutHdr
->dwFlags
|= WHDR_PREPARED
;
2247 lpWaveOutHdr
->dwFlags
&= ~WHDR_DONE
;
2249 return MMSYSERR_NOERROR
;
2252 /**************************************************************************
2253 * waveOutUnprepareHeader [WINMM.@]
2255 UINT WINAPI
waveOutUnprepareHeader(HWAVEOUT hWaveOut
,
2256 LPWAVEHDR lpWaveOutHdr
, UINT uSize
)
2261 TRACE("(%p, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2263 if (lpWaveOutHdr
== NULL
|| uSize
< sizeof (WAVEHDR
))
2264 return MMSYSERR_INVALPARAM
;
2266 if (!(lpWaveOutHdr
->dwFlags
& WHDR_PREPARED
)) {
2267 return MMSYSERR_NOERROR
;
2270 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2271 return MMSYSERR_INVALHANDLE
;
2273 if ((result
= MMDRV_Message(wmld
, WODM_UNPREPARE
, (DWORD_PTR
)lpWaveOutHdr
,
2274 uSize
)) != MMSYSERR_NOTSUPPORTED
)
2277 if (lpWaveOutHdr
->dwFlags
& WHDR_INQUEUE
)
2278 return WAVERR_STILLPLAYING
;
2280 lpWaveOutHdr
->dwFlags
&= ~WHDR_PREPARED
;
2281 lpWaveOutHdr
->dwFlags
|= WHDR_DONE
;
2283 return MMSYSERR_NOERROR
;
2286 /**************************************************************************
2287 * waveOutWrite [WINMM.@]
2289 UINT WINAPI
waveOutWrite(HWAVEOUT hWaveOut
, LPWAVEHDR lpWaveOutHdr
,
2294 TRACE("(%p, %p, %u);\n", hWaveOut
, lpWaveOutHdr
, uSize
);
2296 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2297 return MMSYSERR_INVALHANDLE
;
2299 return MMDRV_Message(wmld
, WODM_WRITE
, (DWORD_PTR
)lpWaveOutHdr
, uSize
);
2302 /**************************************************************************
2303 * waveOutBreakLoop [WINMM.@]
2305 UINT WINAPI
waveOutBreakLoop(HWAVEOUT hWaveOut
)
2309 TRACE("(%p);\n", hWaveOut
);
2311 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2312 return MMSYSERR_INVALHANDLE
;
2313 return MMDRV_Message(wmld
, WODM_BREAKLOOP
, 0L, 0L);
2316 /**************************************************************************
2317 * waveOutPause [WINMM.@]
2319 UINT WINAPI
waveOutPause(HWAVEOUT hWaveOut
)
2323 TRACE("(%p);\n", hWaveOut
);
2325 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2326 return MMSYSERR_INVALHANDLE
;
2327 return MMDRV_Message(wmld
, WODM_PAUSE
, 0L, 0L);
2330 /**************************************************************************
2331 * waveOutReset [WINMM.@]
2333 UINT WINAPI
waveOutReset(HWAVEOUT hWaveOut
)
2337 TRACE("(%p);\n", hWaveOut
);
2339 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2340 return MMSYSERR_INVALHANDLE
;
2341 return MMDRV_Message(wmld
, WODM_RESET
, 0L, 0L);
2344 /**************************************************************************
2345 * waveOutRestart [WINMM.@]
2347 UINT WINAPI
waveOutRestart(HWAVEOUT hWaveOut
)
2351 TRACE("(%p);\n", hWaveOut
);
2353 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2354 return MMSYSERR_INVALHANDLE
;
2355 return MMDRV_Message(wmld
, WODM_RESTART
, 0L, 0L);
2358 /**************************************************************************
2359 * waveOutGetPosition [WINMM.@]
2361 UINT WINAPI
waveOutGetPosition(HWAVEOUT hWaveOut
, LPMMTIME lpTime
,
2366 TRACE("(%p, %p, %u);\n", hWaveOut
, lpTime
, uSize
);
2368 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2369 return MMSYSERR_INVALHANDLE
;
2371 return MMDRV_Message(wmld
, WODM_GETPOS
, (DWORD_PTR
)lpTime
, uSize
);
2374 /**************************************************************************
2375 * waveOutGetPitch [WINMM.@]
2377 UINT WINAPI
waveOutGetPitch(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
2381 TRACE("(%p, %p);\n", hWaveOut
, lpdw
);
2383 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2384 return MMSYSERR_INVALHANDLE
;
2385 return MMDRV_Message(wmld
, WODM_GETPITCH
, (DWORD_PTR
)lpdw
, 0L);
2388 /**************************************************************************
2389 * waveOutSetPitch [WINMM.@]
2391 UINT WINAPI
waveOutSetPitch(HWAVEOUT hWaveOut
, DWORD dw
)
2395 TRACE("(%p, %08x);\n", hWaveOut
, dw
);
2397 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2398 return MMSYSERR_INVALHANDLE
;
2399 return MMDRV_Message(wmld
, WODM_SETPITCH
, dw
, 0L);
2402 /**************************************************************************
2403 * waveOutGetPlaybackRate [WINMM.@]
2405 UINT WINAPI
waveOutGetPlaybackRate(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
2409 TRACE("(%p, %p);\n", hWaveOut
, lpdw
);
2411 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2412 return MMSYSERR_INVALHANDLE
;
2413 return MMDRV_Message(wmld
, WODM_GETPLAYBACKRATE
, (DWORD_PTR
)lpdw
, 0L);
2416 /**************************************************************************
2417 * waveOutSetPlaybackRate [WINMM.@]
2419 UINT WINAPI
waveOutSetPlaybackRate(HWAVEOUT hWaveOut
, DWORD dw
)
2423 TRACE("(%p, %08x);\n", hWaveOut
, dw
);
2425 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2426 return MMSYSERR_INVALHANDLE
;
2427 return MMDRV_Message(wmld
, WODM_SETPLAYBACKRATE
, dw
, 0L);
2430 /**************************************************************************
2431 * waveOutGetVolume [WINMM.@]
2433 UINT WINAPI
waveOutGetVolume(HWAVEOUT hWaveOut
, LPDWORD lpdw
)
2437 TRACE("(%p, %p);\n", hWaveOut
, lpdw
);
2440 WARN("invalid parameter\n");
2441 return MMSYSERR_INVALPARAM
;
2444 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, TRUE
)) == NULL
)
2445 return MMSYSERR_INVALHANDLE
;
2447 return MMDRV_Message(wmld
, WODM_GETVOLUME
, (DWORD_PTR
)lpdw
, 0L);
2450 /**************************************************************************
2451 * waveOutSetVolume [WINMM.@]
2453 UINT WINAPI
waveOutSetVolume(HWAVEOUT hWaveOut
, DWORD dw
)
2457 TRACE("(%p, %08x);\n", hWaveOut
, dw
);
2459 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, TRUE
)) == NULL
)
2460 return MMSYSERR_INVALHANDLE
;
2462 return MMDRV_Message(wmld
, WODM_SETVOLUME
, dw
, 0L);
2465 /**************************************************************************
2466 * waveOutGetID [WINMM.@]
2468 UINT WINAPI
waveOutGetID(HWAVEOUT hWaveOut
, UINT
* lpuDeviceID
)
2472 TRACE("(%p, %p);\n", hWaveOut
, lpuDeviceID
);
2474 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
2476 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
)
2477 return MMSYSERR_INVALHANDLE
;
2479 *lpuDeviceID
= wmld
->uDeviceID
;
2483 /**************************************************************************
2484 * waveOutMessage [WINMM.@]
2486 UINT WINAPI
waveOutMessage(HWAVEOUT hWaveOut
, UINT uMessage
,
2487 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2491 TRACE("(%p, %u, %ld, %ld)\n", hWaveOut
, uMessage
, dwParam1
, dwParam2
);
2493 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, FALSE
)) == NULL
) {
2494 if ((wmld
= MMDRV_Get(hWaveOut
, MMDRV_WAVEOUT
, TRUE
)) != NULL
) {
2495 return MMDRV_PhysicalFeatures(wmld
, uMessage
, dwParam1
, dwParam2
);
2497 WARN("invalid handle\n");
2498 return MMSYSERR_INVALHANDLE
;
2502 if (uMessage
< DRVM_IOCTL
|| (uMessage
>= DRVM_IOCTL_LAST
&& uMessage
< DRVM_MAPPER
)) {
2503 WARN("invalid parameter\n");
2504 return MMSYSERR_INVALPARAM
;
2507 return MMDRV_Message(wmld
, uMessage
, dwParam1
, dwParam2
);
2510 /**************************************************************************
2511 * waveInGetNumDevs [WINMM.@]
2513 UINT WINAPI
waveInGetNumDevs(void)
2515 return MMDRV_GetNum(MMDRV_WAVEIN
);
2518 /**************************************************************************
2519 * waveInGetDevCapsW [WINMM.@]
2521 UINT WINAPI
waveInGetDevCapsW(UINT_PTR uDeviceID
, LPWAVEINCAPSW lpCaps
, UINT uSize
)
2525 TRACE("(%lu %p %u)!\n", uDeviceID
, lpCaps
, uSize
);
2527 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2529 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_WAVEIN
, TRUE
)) == NULL
)
2530 return MMSYSERR_BADDEVICEID
;
2532 return MMDRV_Message(wmld
, WIDM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
2535 /**************************************************************************
2536 * waveInGetDevCapsA [WINMM.@]
2538 UINT WINAPI
waveInGetDevCapsA(UINT_PTR uDeviceID
, LPWAVEINCAPSA lpCaps
, UINT uSize
)
2543 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
2545 ret
= waveInGetDevCapsW(uDeviceID
, &wicW
, sizeof(wicW
));
2547 if (ret
== MMSYSERR_NOERROR
) {
2549 wicA
.wMid
= wicW
.wMid
;
2550 wicA
.wPid
= wicW
.wPid
;
2551 wicA
.vDriverVersion
= wicW
.vDriverVersion
;
2552 WideCharToMultiByte( CP_ACP
, 0, wicW
.szPname
, -1, wicA
.szPname
,
2553 sizeof(wicA
.szPname
), NULL
, NULL
);
2554 wicA
.dwFormats
= wicW
.dwFormats
;
2555 wicA
.wChannels
= wicW
.wChannels
;
2556 memcpy(lpCaps
, &wicA
, min(uSize
, sizeof(wicA
)));
2561 /**************************************************************************
2562 * waveInOpen [WINMM.@]
2564 MMRESULT WINAPI
waveInOpen(HWAVEIN
* lphWaveIn
, UINT uDeviceID
,
2565 LPCWAVEFORMATEX lpFormat
, DWORD_PTR dwCallback
,
2566 DWORD_PTR dwInstance
, DWORD dwFlags
)
2568 return WAVE_Open((HANDLE
*)lphWaveIn
, uDeviceID
, MMDRV_WAVEIN
, lpFormat
,
2569 dwCallback
, dwInstance
, dwFlags
);
2572 /**************************************************************************
2573 * waveInClose [WINMM.@]
2575 UINT WINAPI
waveInClose(HWAVEIN hWaveIn
)
2580 TRACE("(%p)\n", hWaveIn
);
2582 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2583 return MMSYSERR_INVALHANDLE
;
2585 dwRet
= MMDRV_Message(wmld
, WIDM_CLOSE
, 0L, 0L);
2586 if (dwRet
!= WAVERR_STILLPLAYING
)
2587 MMDRV_Free(hWaveIn
, wmld
);
2591 /**************************************************************************
2592 * waveInPrepareHeader [WINMM.@]
2594 UINT WINAPI
waveInPrepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
2600 TRACE("(%p, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
2602 if (lpWaveInHdr
== NULL
|| uSize
< sizeof (WAVEHDR
))
2603 return MMSYSERR_INVALPARAM
;
2605 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2606 return MMSYSERR_INVALHANDLE
;
2608 if ((result
= MMDRV_Message(wmld
, WIDM_PREPARE
, (DWORD_PTR
)lpWaveInHdr
,
2609 uSize
)) != MMSYSERR_NOTSUPPORTED
)
2612 if (lpWaveInHdr
->dwFlags
& WHDR_INQUEUE
)
2613 return WAVERR_STILLPLAYING
;
2615 lpWaveInHdr
->dwFlags
|= WHDR_PREPARED
;
2616 lpWaveInHdr
->dwFlags
&= ~WHDR_DONE
;
2617 lpWaveInHdr
->dwBytesRecorded
= 0;
2619 return MMSYSERR_NOERROR
;
2622 /**************************************************************************
2623 * waveInUnprepareHeader [WINMM.@]
2625 UINT WINAPI
waveInUnprepareHeader(HWAVEIN hWaveIn
, WAVEHDR
* lpWaveInHdr
,
2631 TRACE("(%p, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
2633 if (lpWaveInHdr
== NULL
|| uSize
< sizeof (WAVEHDR
))
2634 return MMSYSERR_INVALPARAM
;
2636 if (!(lpWaveInHdr
->dwFlags
& WHDR_PREPARED
))
2637 return MMSYSERR_NOERROR
;
2639 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2640 return MMSYSERR_INVALHANDLE
;
2642 if ((result
= MMDRV_Message(wmld
, WIDM_UNPREPARE
, (DWORD_PTR
)lpWaveInHdr
,
2643 uSize
)) != MMSYSERR_NOTSUPPORTED
)
2646 if (lpWaveInHdr
->dwFlags
& WHDR_INQUEUE
)
2647 return WAVERR_STILLPLAYING
;
2649 lpWaveInHdr
->dwFlags
&= ~WHDR_PREPARED
;
2650 lpWaveInHdr
->dwFlags
|= WHDR_DONE
;
2652 return MMSYSERR_NOERROR
;
2655 /**************************************************************************
2656 * waveInAddBuffer [WINMM.@]
2658 UINT WINAPI
waveInAddBuffer(HWAVEIN hWaveIn
,
2659 WAVEHDR
* lpWaveInHdr
, UINT uSize
)
2663 TRACE("(%p, %p, %u);\n", hWaveIn
, lpWaveInHdr
, uSize
);
2665 if (lpWaveInHdr
== NULL
) return MMSYSERR_INVALPARAM
;
2666 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2667 return MMSYSERR_INVALHANDLE
;
2669 return MMDRV_Message(wmld
, WIDM_ADDBUFFER
, (DWORD_PTR
)lpWaveInHdr
, uSize
);
2672 /**************************************************************************
2673 * waveInReset [WINMM.@]
2675 UINT WINAPI
waveInReset(HWAVEIN hWaveIn
)
2679 TRACE("(%p);\n", hWaveIn
);
2681 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2682 return MMSYSERR_INVALHANDLE
;
2684 return MMDRV_Message(wmld
, WIDM_RESET
, 0L, 0L);
2687 /**************************************************************************
2688 * waveInStart [WINMM.@]
2690 UINT WINAPI
waveInStart(HWAVEIN hWaveIn
)
2694 TRACE("(%p);\n", hWaveIn
);
2696 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2697 return MMSYSERR_INVALHANDLE
;
2699 return MMDRV_Message(wmld
, WIDM_START
, 0L, 0L);
2702 /**************************************************************************
2703 * waveInStop [WINMM.@]
2705 UINT WINAPI
waveInStop(HWAVEIN hWaveIn
)
2709 TRACE("(%p);\n", hWaveIn
);
2711 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2712 return MMSYSERR_INVALHANDLE
;
2714 return MMDRV_Message(wmld
,WIDM_STOP
, 0L, 0L);
2717 /**************************************************************************
2718 * waveInGetPosition [WINMM.@]
2720 UINT WINAPI
waveInGetPosition(HWAVEIN hWaveIn
, LPMMTIME lpTime
,
2725 TRACE("(%p, %p, %u);\n", hWaveIn
, lpTime
, uSize
);
2727 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2728 return MMSYSERR_INVALHANDLE
;
2730 return MMDRV_Message(wmld
, WIDM_GETPOS
, (DWORD_PTR
)lpTime
, uSize
);
2733 /**************************************************************************
2734 * waveInGetID [WINMM.@]
2736 UINT WINAPI
waveInGetID(HWAVEIN hWaveIn
, UINT
* lpuDeviceID
)
2740 TRACE("(%p, %p);\n", hWaveIn
, lpuDeviceID
);
2742 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALHANDLE
;
2744 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
)
2745 return MMSYSERR_INVALHANDLE
;
2747 *lpuDeviceID
= wmld
->uDeviceID
;
2748 return MMSYSERR_NOERROR
;
2751 /**************************************************************************
2752 * waveInMessage [WINMM.@]
2754 UINT WINAPI
waveInMessage(HWAVEIN hWaveIn
, UINT uMessage
,
2755 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2759 TRACE("(%p, %u, %ld, %ld)\n", hWaveIn
, uMessage
, dwParam1
, dwParam2
);
2761 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, FALSE
)) == NULL
) {
2762 if ((wmld
= MMDRV_Get(hWaveIn
, MMDRV_WAVEIN
, TRUE
)) != NULL
) {
2763 return MMDRV_PhysicalFeatures(wmld
, uMessage
, dwParam1
, dwParam2
);
2765 return MMSYSERR_INVALHANDLE
;
2769 if (uMessage
< DRVM_IOCTL
|| (uMessage
>= DRVM_IOCTL_LAST
&& uMessage
< DRVM_MAPPER
))
2770 return MMSYSERR_INVALPARAM
;
2773 return MMDRV_Message(wmld
, uMessage
, dwParam1
, dwParam2
);
2783 static DWORD WINAPI
mmTaskRun(void* pmt
)
2785 struct mm_starter mms
;
2787 memcpy(&mms
, pmt
, sizeof(struct mm_starter
));
2788 HeapFree(GetProcessHeap(), 0, pmt
);
2790 if (mms
.event
) SetEvent(mms
.event
);
2794 /******************************************************************
2795 * mmTaskCreate (WINMM.@)
2797 UINT WINAPI
mmTaskCreate(LPTASKCALLBACK cb
, HANDLE
* ph
, DWORD_PTR client
)
2801 struct mm_starter
*mms
;
2803 mms
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct mm_starter
));
2804 if (mms
== NULL
) return TASKERR_OUTOFMEMORY
;
2807 mms
->client
= client
;
2808 if (ph
) hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2809 mms
->event
= hEvent
;
2811 hThread
= CreateThread(0, 0, mmTaskRun
, mms
, 0, NULL
);
2813 HeapFree(GetProcessHeap(), 0, mms
);
2814 if (hEvent
) CloseHandle(hEvent
);
2815 return TASKERR_OUTOFMEMORY
;
2817 SetThreadPriority(hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
2818 if (ph
) *ph
= hEvent
;
2819 CloseHandle(hThread
);
2823 /******************************************************************
2824 * mmTaskBlock (WINMM.@)
2826 VOID WINAPI
mmTaskBlock(DWORD tid
)
2832 GetMessageA(&msg
, 0, 0, 0);
2833 if (msg
.hwnd
) DispatchMessageA(&msg
);
2834 } while (msg
.message
!= WM_USER
);
2837 /******************************************************************
2838 * mmTaskSignal (WINMM.@)
2840 BOOL WINAPI
mmTaskSignal(DWORD tid
)
2842 return PostThreadMessageW(tid
, WM_USER
, 0, 0);
2845 /******************************************************************
2846 * mmTaskYield (WINMM.@)
2848 VOID WINAPI
mmTaskYield(VOID
) {}
2850 /******************************************************************
2851 * mmGetCurrentTask (WINMM.@)
2853 DWORD WINAPI
mmGetCurrentTask(VOID
)
2855 return GetCurrentThreadId();