?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
taskmgr: Remove a useless commented line.
[wine.git] / dlls / mmsystem.dll16 / mmsystem.c
blob1109ef467922a93d3819e69c98ecac8c0a4eb496
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MMSYSTEM functions
5 *
6 * Copyright 1993 Martin Ayotte
7 * 1998-2003 Eric Pouech
8 *
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.
13 *
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.
18 *
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
22 */
23
24 /*
25 * Eric POUECH :
26 * 99/4 added mmTask and mmThread functions support
27 */
28
29 #include <stdarg.h>
30 #include <string.h>
31
32 #define NONAMELESSUNION
33 #define NONAMELESSSTRUCT
34 #include "windef.h"
35 #include "winbase.h"
36 #include "mmsystem.h"
37 #include "winternl.h"
38 #include "wownt32.h"
39 #include "winnls.h"
40
41 #include "wine/list.h"
42 #include "wine/winuser16.h"
43 #include "winemm16.h"
44
45 #include "wine/debug.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
48
49
50 static CRITICAL_SECTION_DEBUG mmdrv_critsect_debug =
51 {
52 0, 0, &mmdrv_cs,
53 { &mmdrv_critsect_debug.ProcessLocksList, &mmdrv_critsect_debug.ProcessLocksList },
54 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmdrv_cs") }
55 };
56 CRITICAL_SECTION mmdrv_cs = { &mmdrv_critsect_debug, -1, 0, 0, 0, 0 };
57
58 /* ###################################################
59 * # LIBRARY #
60 * ###################################################
61 */
62
63 /**************************************************************************
64 * DllEntryPoint (MMSYSTEM.4)
65 *
66 * MMSYSTEM DLL entry point
67 *
68 */
69 BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
70 WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
71 {
72 static int done;
73
74 if (!done++) LoadLibrary16( "sound.drv" );
75 return TRUE;
76 }
77
78 /**************************************************************************
79 * WEP [MMSYSTEM.1]
80 */
81 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
82 WORD cbHeapSize, LPSTR lpCmdLine)
83 {
84 TRACE("STUB: Unloading MMSystem DLL ... hInst=%04X\n", hInstance);
85 return TRUE;
86 }
87
88 /* ###################################################
89 * # TIME #
90 * ###################################################
91 */
92
93 /******************************************************************
94 * MMSYSTEM_MMTIME32to16
95 *
96 *
97 */
98 void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32)
99 {
100 mmt16->wType = mmt32->wType;
101 /* layout of rest is the same for 32/16,
102 * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
103 */
104 memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
105 }
106
107 /******************************************************************
108 * MMSYSTEM_MMTIME16to32
109 *
110 *
111 */
112 static void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16)
113 {
114 mmt32->wType = mmt16->wType;
115 /* layout of rest is the same for 32/16,
116 * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
117 */
118 memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
119 }
120
121 /**************************************************************************
122 * timeGetSystemTime [MMSYSTEM.601]
123 */
124 MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
125 {
126 if (wSize >= sizeof(*lpTime)) {
127 lpTime->wType = TIME_MS;
128 lpTime->u.ms = GetTickCount();
129
130 TRACE("=> %u\n", lpTime->u.ms);
131 }
132
133 return 0;
134 }
135
136 struct timer_entry {
137 struct list entry;
138 UINT id;
139 LPTIMECALLBACK16 func16;
140 DWORD user;
141 };
142
143 static struct list timer_list = LIST_INIT(timer_list);
144
145 static void CALLBACK timeCB3216(UINT id, UINT uMsg, DWORD_PTR user, DWORD_PTR dw1, DWORD_PTR dw2)
146 {
147 struct timer_entry* te = (void*)user;
148 WORD args[8];
149 DWORD ret;
150
151 args[7] = LOWORD(id);
152 args[6] = LOWORD(uMsg);
153 args[5] = HIWORD(te->user);
154 args[4] = LOWORD(te->user);
155 args[3] = HIWORD(dw1);
156 args[2] = LOWORD(dw2);
157 args[1] = HIWORD(dw2);
158 args[0] = LOWORD(dw2);
159 WOWCallback16Ex((DWORD)te->func16, WCB16_PASCAL, sizeof(args), args, &ret);
160 }
161
162 /**************************************************************************
163 * timeSetEvent [MMSYSTEM.602]
164 */
165 MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
166 DWORD dwUser, UINT16 wFlags)
167 {
168 MMRESULT16 id;
169 struct timer_entry* te;
170
171 switch (wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE))
172 {
173 case TIME_CALLBACK_EVENT_SET:
174 case TIME_CALLBACK_EVENT_PULSE:
175 id = timeSetEvent(wDelay, wResol, (LPTIMECALLBACK)lpFunc, dwUser, wFlags);
176 break;
177 case TIME_CALLBACK_FUNCTION:
178 te = HeapAlloc(GetProcessHeap(), 0, sizeof(*te));
179 if (!te) return 0;
180 te->func16 = lpFunc;
181 te->user = dwUser;
182 id = te->id = timeSetEvent(wDelay, wResol, timeCB3216, (DWORD_PTR)te, wFlags);
183 if (id)
184 {
185 EnterCriticalSection(&mmdrv_cs);
186 list_add_tail(&timer_list, &te->entry);
187 LeaveCriticalSection(&mmdrv_cs);
188 }
189 else HeapFree(GetProcessHeap(), 0, te);
190 break;
191 default:
192 id = 0;
193 break;
194 }
195 return id;
196 }
197
198 /**************************************************************************
199 * timeKillEvent [MMSYSTEM.603]
200 */
201 MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
202 {
203 MMRESULT16 ret = timeKillEvent(wID);
204 struct timer_entry* te;
205
206 if (ret == TIMERR_NOERROR)
207 {
208 EnterCriticalSection(&mmdrv_cs);
209 LIST_FOR_EACH_ENTRY(te, &timer_list, struct timer_entry, entry)
210 {
211 if (wID == te->id)
212 {
213 list_remove(&te->entry);
214 HeapFree(GetProcessHeap(), 0, te);
215 break;
216 }
217 }
218 LeaveCriticalSection(&mmdrv_cs);
219 }
220 return ret;
221 }
222
223 /**************************************************************************
224 * timeGetDevCaps [MMSYSTEM.604]
225 */
226 MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16 lpCaps, UINT16 wSize)
227 {
228 TIMECAPS caps;
229 MMRESULT ret;
230 TRACE("(%p, %u) !\n", lpCaps, wSize);
231
232 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
233
234 ret = timeGetDevCaps(&caps, sizeof(caps));
235 if (ret == MMSYSERR_NOERROR) {
236 TIMECAPS16 tc16;
237 tc16.wPeriodMin = caps.wPeriodMin;
238 tc16.wPeriodMax = caps.wPeriodMax;
239 memcpy(lpCaps, &tc16, min(wSize, sizeof(tc16)));
240 }
241 return ret;
242 }
243
244 /**************************************************************************
245 * timeBeginPeriod [MMSYSTEM.605]
246 */
247 MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod)
248 {
249 TRACE("(%u) !\n", wPeriod);
250
251 return timeBeginPeriod(wPeriod);
252 }
253
254 /**************************************************************************
255 * timeEndPeriod [MMSYSTEM.606]
256 */
257 MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
258 {
259 TRACE("(%u) !\n", wPeriod);
260
261 return timeEndPeriod(wPeriod);
262 }
263
264 /**************************************************************************
265 * timeGetTime [MMSYSTEM.607]
266 */
267 DWORD WINAPI timeGetTime16(void)
268 {
269 return timeGetTime();
270 }
271
272 /* ###################################################
273 * # PlaySound #
274 * ###################################################
275 */
276
277 /**************************************************************************
278 * PlaySound [MMSYSTEM.3]
279 */
280 BOOL16 WINAPI PlaySound16(LPCSTR pszSound, HMODULE16 hmod, DWORD fdwSound)
281 {
282 BOOL16 retv;
283 DWORD lc;
284
285 if ((fdwSound & SND_RESOURCE) == SND_RESOURCE)
286 {
287 HGLOBAL16 handle;
288 HRSRC16 res;
289
290 if (!(res = FindResource16( hmod, pszSound, "WAVE" ))) return FALSE;
291 if (!(handle = LoadResource16( hmod, res ))) return FALSE;
292 pszSound = LockResource16(handle);
293 fdwSound = (fdwSound & ~SND_RESOURCE) | SND_MEMORY;
294 /* FIXME: FreeResource16 */
295 }
296
297 ReleaseThunkLock(&lc);
298 retv = PlaySoundA(pszSound, 0, fdwSound);
299 RestoreThunkLock(lc);
300
301 return retv;
302 }
303
304 /**************************************************************************
305 * sndPlaySound [MMSYSTEM.2]
306 */
307 BOOL16 WINAPI sndPlaySound16(LPCSTR lpszSoundName, UINT16 uFlags)
308 {
309 BOOL16 retv;
310 DWORD lc;
311
312 ReleaseThunkLock(&lc);
313 retv = sndPlaySoundA(lpszSoundName, uFlags);
314 RestoreThunkLock(lc);
315
316 return retv;
317 }
318
319 /* ###################################################
320 * # MISC #
321 * ###################################################
322 */
323
324 /**************************************************************************
325 * mmsystemGetVersion [MMSYSTEM.5]
326 *
327 */
328 UINT16 WINAPI mmsystemGetVersion16(void)
329 {
330 return mmsystemGetVersion();
331 }
332
333 /**************************************************************************
334 * DriverCallback [MMSYSTEM.31]
335 */
336 BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HDRVR16 hDev,
337 WORD wMsg, DWORD dwUser, DWORD dwParam1,
338 DWORD dwParam2)
339 {
340 return DriverCallback(dwCallBack, uFlags, HDRVR_32(hDev), wMsg, dwUser, dwParam1, dwParam2);
341 }
342
343 /**************************************************************************
344 * OutputDebugStr [MMSYSTEM.30]
345 */
346 void WINAPI OutputDebugStr16(LPCSTR str)
347 {
348 OutputDebugStringA( str );
349 }
350
351 /* ###################################################
352 * # MIXER #
353 * ###################################################
354 */
355
356 /**************************************************************************
357 * Mixer devices. New to Win95
358 */
359
360 /**************************************************************************
361 * mixerGetNumDevs [MMSYSTEM.800]
362 */
363 UINT16 WINAPI mixerGetNumDevs16(void)
364 {
365 return mixerGetNumDevs();
366 }
367
368 /**************************************************************************
369 * mixerGetDevCaps [MMSYSTEM.801]
370 */
371 UINT16 WINAPI mixerGetDevCaps16(UINT16 uDeviceID, LPMIXERCAPS16 lpCaps,
372 UINT16 uSize)
373 {
374 MIXERCAPSA micA;
375 UINT ret;
376
377 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
378
379 ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA));
380 if (ret == MMSYSERR_NOERROR) {
381 MIXERCAPS16 mic16;
382 mic16.wMid = micA.wMid;
383 mic16.wPid = micA.wPid;
384 mic16.vDriverVersion = micA.vDriverVersion;
385 strcpy(mic16.szPname, micA.szPname);
386 mic16.fdwSupport = micA.fdwSupport;
387 mic16.cDestinations = micA.cDestinations;
388 memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
389 }
390 return ret;
391 }
392
393 /**************************************************************************
394 * mixerOpen [MMSYSTEM.802]
395 */
396 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
397 DWORD dwInstance, DWORD fdwOpen)
398 {
399 HMIXER hmix;
400 UINT ret;
401 struct mmsystdrv_thunk* thunk;
402
403 if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, fdwOpen, MMSYSTDRV_MIXER)))
404 {
405 return MMSYSERR_NOMEM;
406 }
407 if ((fdwOpen & CALLBACK_TYPEMASK) != CALLBACK_NULL)
408 fdwOpen = (fdwOpen & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
409 ret = mixerOpen(&hmix, uDeviceID, (DWORD)thunk, dwInstance, fdwOpen);
410 if (ret == MMSYSERR_NOERROR)
411 {
412 if (lphmix) *lphmix = HMIXER_16(hmix);
413 if (thunk) MMSYSTDRV_SetHandle(thunk, hmix);
414 }
415 else MMSYSTDRV_DeleteThunk(thunk);
416 return ret;
417 }
418
419 /**************************************************************************
420 * mixerClose [MMSYSTEM.803]
421 */
422 UINT16 WINAPI mixerClose16(HMIXER16 hMix)
423 {
424 UINT ret = mixerClose(HMIXER_32(hMix));
425
426 if (ret == MMSYSERR_NOERROR)
427 MMSYSTDRV_CloseHandle((void*)HMIXER_32(hMix));
428 return ret;
429 }
430
431 /**************************************************************************
432 * mixerGetID (MMSYSTEM.806)
433 */
434 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
435 {
436 UINT xid;
437 UINT ret = mixerGetID(HMIXEROBJ_32(hmix), &xid, fdwID);
438
439 if (lpid)
440 *lpid = xid;
441 return ret;
442 }
443
444 /**************************************************************************
445 * mixerGetControlDetails [MMSYSTEM.808]
446 */
447 UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,
448 LPMIXERCONTROLDETAILS16 lpmcd,
449 DWORD fdwDetails)
450 {
451 DWORD ret = MMSYSERR_NOTENABLED;
452 SEGPTR sppaDetails;
453
454 TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
455
456 if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
457 return MMSYSERR_INVALPARAM;
458
459 sppaDetails = (SEGPTR)lpmcd->paDetails;
460 lpmcd->paDetails = MapSL(sppaDetails);
461 ret = mixerGetControlDetailsA(HMIXEROBJ_32(hmix),
462 (LPMIXERCONTROLDETAILS)lpmcd, fdwDetails);
463 lpmcd->paDetails = (LPVOID)sppaDetails;
464
465 return ret;
466 }
467
468 /**************************************************************************
469 * mixerGetLineControls [MMSYSTEM.807]
470 */
471 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,
472 LPMIXERLINECONTROLS16 lpmlc16,
473 DWORD fdwControls)
474 {
475 MIXERLINECONTROLSA mlcA;
476 DWORD ret;
477 unsigned int i;
478 LPMIXERCONTROL16 lpmc16;
479
480 TRACE("(%04x, %p, %08x)\n", hmix, lpmlc16, fdwControls);
481
482 if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) ||
483 lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16))
484 return MMSYSERR_INVALPARAM;
485
486 mlcA.cbStruct = sizeof(mlcA);
487 mlcA.dwLineID = lpmlc16->dwLineID;
488 mlcA.u.dwControlID = lpmlc16->u.dwControlID;
489 mlcA.u.dwControlType = lpmlc16->u.dwControlType;
490 mlcA.cControls = lpmlc16->cControls;
491 mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
492 mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
493 mlcA.cControls * mlcA.cbmxctrl);
494
495 ret = mixerGetLineControlsA(HMIXEROBJ_32(hmix), &mlcA, fdwControls);
496
497 if (ret == MMSYSERR_NOERROR) {
498 lpmlc16->dwLineID = mlcA.dwLineID;
499 lpmlc16->u.dwControlID = mlcA.u.dwControlID;
500 lpmlc16->u.dwControlType = mlcA.u.dwControlType;
501 lpmlc16->cControls = mlcA.cControls;
502
503 lpmc16 = MapSL(lpmlc16->pamxctrl);
504
505 for (i = 0; i < mlcA.cControls; i++) {
506 lpmc16[i].cbStruct = sizeof(MIXERCONTROL16);
507 lpmc16[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
508 lpmc16[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
509 lpmc16[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
510 lpmc16[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
511 strcpy(lpmc16[i].szShortName, mlcA.pamxctrl[i].szShortName);
512 strcpy(lpmc16[i].szName, mlcA.pamxctrl[i].szName);
513 /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
514 memcpy(&lpmc16[i].Bounds, &mlcA.pamxctrl[i].Bounds,
515 sizeof(mlcA.pamxctrl[i].Bounds));
516 /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
517 memcpy(&lpmc16[i].Metrics, &mlcA.pamxctrl[i].Metrics,
518 sizeof(mlcA.pamxctrl[i].Metrics));
519 }
520 }
521
522 HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
523
524 return ret;
525 }
526
527 /**************************************************************************
528 * mixerGetLineInfo [MMSYSTEM.805]
529 */
530 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
531 DWORD fdwInfo)
532 {
533 MIXERLINEA mliA;
534 UINT ret;
535
536 TRACE("(%04x, %p, %08x)\n", hmix, lpmli16, fdwInfo);
537
538 if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16))
539 return MMSYSERR_INVALPARAM;
540
541 mliA.cbStruct = sizeof(mliA);
542 switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
543 case MIXER_GETLINEINFOF_COMPONENTTYPE:
544 mliA.dwComponentType = lpmli16->dwComponentType;
545 break;
546 case MIXER_GETLINEINFOF_DESTINATION:
547 mliA.dwDestination = lpmli16->dwDestination;
548 break;
549 case MIXER_GETLINEINFOF_LINEID:
550 mliA.dwLineID = lpmli16->dwLineID;
551 break;
552 case MIXER_GETLINEINFOF_SOURCE:
553 mliA.dwDestination = lpmli16->dwDestination;
554 mliA.dwSource = lpmli16->dwSource;
555 break;
556 case MIXER_GETLINEINFOF_TARGETTYPE:
557 mliA.Target.dwType = lpmli16->Target.dwType;
558 mliA.Target.wMid = lpmli16->Target.wMid;
559 mliA.Target.wPid = lpmli16->Target.wPid;
560 mliA.Target.vDriverVersion = lpmli16->Target.vDriverVersion;
561 strcpy(mliA.Target.szPname, lpmli16->Target.szPname);
562 break;
563 default:
564 FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo);
565 }
566
567 ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo);
568
569 lpmli16->dwDestination = mliA.dwDestination;
570 lpmli16->dwSource = mliA.dwSource;
571 lpmli16->dwLineID = mliA.dwLineID;
572 lpmli16->fdwLine = mliA.fdwLine;
573 lpmli16->dwUser = mliA.dwUser;
574 lpmli16->dwComponentType = mliA.dwComponentType;
575 lpmli16->cChannels = mliA.cChannels;
576 lpmli16->cConnections = mliA.cConnections;
577 lpmli16->cControls = mliA.cControls;
578 strcpy(lpmli16->szShortName, mliA.szShortName);
579 strcpy(lpmli16->szName, mliA.szName);
580 lpmli16->Target.dwType = mliA.Target.dwType;
581 lpmli16->Target.dwDeviceID = mliA.Target.dwDeviceID;
582 lpmli16->Target.wMid = mliA.Target.wMid;
583 lpmli16->Target.wPid = mliA.Target.wPid;
584 lpmli16->Target.vDriverVersion = mliA.Target.vDriverVersion;
585 strcpy(lpmli16->Target.szPname, mliA.Target.szPname);
586
587 return ret;
588 }
589
590 /**************************************************************************
591 * mixerSetControlDetails [MMSYSTEM.809]
592 */
593 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,
594 LPMIXERCONTROLDETAILS16 lpmcd,
595 DWORD fdwDetails)
596 {
597 TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
598 return MMSYSERR_NOTENABLED;
599 }
600
601 /**************************************************************************
602 * mixerMessage [MMSYSTEM.804]
603 */
604 DWORD WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1,
605 DWORD dwParam2)
606 {
607 return mixerMessage(HMIXER_32(hmix), uMsg, dwParam1, dwParam2);
608 }
609
610 /* ###################################################
611 * # AUX #
612 * ###################################################
613 */
614
615 /**************************************************************************
616 * auxGetNumDevs [MMSYSTEM.350]
617 */
618 UINT16 WINAPI auxGetNumDevs16(void)
619 {
620 return auxGetNumDevs();
621 }
622
623 /**************************************************************************
624 * auxGetDevCaps [MMSYSTEM.351]
625 */
626 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
627 {
628 AUXCAPSA acA;
629 UINT ret;
630
631 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
632
633 ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
634 if (ret == MMSYSERR_NOERROR) {
635 AUXCAPS16 ac16;
636 ac16.wMid = acA.wMid;
637 ac16.wPid = acA.wPid;
638 ac16.vDriverVersion = acA.vDriverVersion;
639 strcpy(ac16.szPname, acA.szPname);
640 ac16.wTechnology = acA.wTechnology;
641 ac16.dwSupport = acA.dwSupport;
642 memcpy(lpCaps, &ac16, min(uSize, sizeof(ac16)));
643 }
644 return ret;
645 }
646
647 /**************************************************************************
648 * auxGetVolume [MMSYSTEM.352]
649 */
650 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume)
651 {
652 return auxGetVolume(uDeviceID, lpdwVolume);
653 }
654
655 /**************************************************************************
656 * auxSetVolume [MMSYSTEM.353]
657 */
658 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
659 {
660 return auxSetVolume(uDeviceID, dwVolume);
661 }
662
663 /**************************************************************************
664 * auxOutMessage [MMSYSTEM.354]
665 */
666 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
667 {
668 TRACE("(%04X, %04X, %08X, %08X)\n", uDeviceID, uMessage, dw1, dw2);
669
670 switch (uMessage) {
671 case AUXDM_GETNUMDEVS:
672 case AUXDM_SETVOLUME:
673 /* no argument conversion needed */
674 break;
675 case AUXDM_GETVOLUME:
676 return auxGetVolume(uDeviceID, MapSL(dw1));
677 case AUXDM_GETDEVCAPS:
678 return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2);
679 default:
680 TRACE("(%04x, %04x, %08x, %08x): unhandled message\n",
681 uDeviceID, uMessage, dw1, dw2);
682 break;
683 }
684 return auxOutMessage(uDeviceID, uMessage, dw1, dw2);
685 }
686
687 /* ###################################################
688 * # MIDI #
689 * ###################################################
690 */
691
692 /**************************************************************************
693 * midiOutGetNumDevs [MMSYSTEM.201]
694 */
695 UINT16 WINAPI midiOutGetNumDevs16(void)
696 {
697 return midiOutGetNumDevs();
698 }
699
700 /**************************************************************************
701 * midiOutGetDevCaps [MMSYSTEM.202]
702 */
703 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps,
704 UINT16 uSize)
705 {
706 MIDIOUTCAPSA mocA;
707 UINT ret;
708
709 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
710
711 ret = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(mocA));
712 if (ret == MMSYSERR_NOERROR) {
713 MIDIOUTCAPS16 moc16;
714 moc16.wMid = mocA.wMid;
715 moc16.wPid = mocA.wPid;
716 moc16.vDriverVersion = mocA.vDriverVersion;
717 strcpy(moc16.szPname, mocA.szPname);
718 moc16.wTechnology = mocA.wTechnology;
719 moc16.wVoices = mocA.wVoices;
720 moc16.wNotes = mocA.wNotes;
721 moc16.wChannelMask = mocA.wChannelMask;
722 moc16.dwSupport = mocA.dwSupport;
723 memcpy(lpCaps, &moc16, min(uSize, sizeof(moc16)));
724 }
725 return ret;
726 }
727
728 /**************************************************************************
729 * midiOutGetErrorText [MMSYSTEM.203]
730 * midiInGetErrorText [MMSYSTEM.303]
731 */
732 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
733 {
734 return midiOutGetErrorTextA(uError, lpText, uSize);
735 }
736
737 /**************************************************************************
738 * midiOutOpen [MMSYSTEM.204]
739 */
740 UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
741 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
742 {
743 HMIDIOUT hmo;
744 UINT ret;
745 struct mmsystdrv_thunk* thunk;
746
747 if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_MIDIOUT)))
748 {
749 return MMSYSERR_NOMEM;
750 }
751 if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
752 dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
753 ret = midiOutOpen(&hmo, uDeviceID, (DWORD)thunk, dwInstance, dwFlags);
754 if (ret == MMSYSERR_NOERROR)
755 {
756 if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo);
757 MMSYSTDRV_SetHandle(thunk, (void*)hmo);
758 }
759 else MMSYSTDRV_DeleteThunk(thunk);
760 return ret;
761 }
762
763 /**************************************************************************
764 * midiOutClose [MMSYSTEM.205]
765 */
766 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
767 {
768 UINT ret = midiOutClose(HMIDIOUT_32(hMidiOut));
769
770 if (ret == MMSYSERR_NOERROR)
771 MMSYSTDRV_CloseHandle((void*)HMIDIOUT_32(hMidiOut));
772 return ret;
773 }
774
775 /**************************************************************************
776 * midiOutPrepareHeader [MMSYSTEM.206]
777 */
778 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
779 SEGPTR lpsegMidiOutHdr, /* [???] */
780 UINT16 uSize) /* [in] */
781 {
782 TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
783
784 return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_PREPARE, lpsegMidiOutHdr, uSize);
785 }
786
787 /**************************************************************************
788 * midiOutUnprepareHeader [MMSYSTEM.207]
789 */
790 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
791 SEGPTR lpsegMidiOutHdr, /* [???] */
792 UINT16 uSize) /* [in] */
793 {
794 LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
795
796 TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
797
798 if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
799 return MMSYSERR_NOERROR;
800 }
801
802 return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_UNPREPARE, lpsegMidiOutHdr, uSize);
803 }
804
805 /**************************************************************************
806 * midiOutShortMsg [MMSYSTEM.208]
807 */
808 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
809 {
810 return midiOutShortMsg(HMIDIOUT_32(hMidiOut), dwMsg);
811 }
812
813 /**************************************************************************
814 * midiOutLongMsg [MMSYSTEM.209]
815 */
816 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut, /* [in] */
817 LPMIDIHDR16 lpsegMidiOutHdr, /* [???] NOTE: SEGPTR */
818 UINT16 uSize) /* [in] */
819 {
820 TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
821
822 return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize);
823 }
824
825 /**************************************************************************
826 * midiOutReset [MMSYSTEM.210]
827 */
828 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
829 {
830 return midiOutReset(HMIDIOUT_32(hMidiOut));
831 }
832
833 /**************************************************************************
834 * midiOutGetVolume [MMSYSTEM.211]
835 */
836 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
837 {
838 return midiOutGetVolume(HMIDIOUT_32(uDeviceID), lpdwVolume);
839 }
840
841 /**************************************************************************
842 * midiOutSetVolume [MMSYSTEM.212]
843 */
844 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
845 {
846 return midiOutSetVolume(HMIDIOUT_32(uDeviceID), dwVolume);
847 }
848
849 /**************************************************************************
850 * midiOutCachePatches [MMSYSTEM.213]
851 */
852 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
853 WORD* lpwPatchArray, UINT16 uFlags)
854 {
855 return midiOutCachePatches(HMIDIOUT_32(hMidiOut), uBank, lpwPatchArray,
856 uFlags);
857 }
858
859 /**************************************************************************
860 * midiOutCacheDrumPatches [MMSYSTEM.214]
861 */
862 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
863 WORD* lpwKeyArray, UINT16 uFlags)
864 {
865 return midiOutCacheDrumPatches(HMIDIOUT_32(hMidiOut), uPatch, lpwKeyArray, uFlags);
866 }
867
868 /**************************************************************************
869 * midiOutGetID [MMSYSTEM.215]
870 */
871 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
872 {
873 UINT devid;
874 UINT16 ret;
875
876 ret = midiOutGetID(HMIDIOUT_32(hMidiOut), &devid);
877 if (ret != MMSYSERR_NOERROR) return ret;
878 *lpuDeviceID = devid;
879 return ret;
880 }
881
882 /**************************************************************************
883 * midiOutMessage [MMSYSTEM.216]
884 */
885 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
886 DWORD dwParam1, DWORD dwParam2)
887 {
888 TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
889
890 switch (uMessage) {
891 case MODM_OPEN:
892 case MODM_CLOSE:
893 FIXME("can't handle OPEN or CLOSE message!\n");
894 return MMSYSERR_NOTSUPPORTED;
895
896 case MODM_GETVOLUME:
897 return midiOutGetVolume16(hMidiOut, MapSL(dwParam1));
898 case MODM_LONGDATA:
899 return midiOutLongMsg16(hMidiOut, MapSL(dwParam1), dwParam2);
900 case MODM_PREPARE:
901 /* lpMidiOutHdr is still a segmented pointer for this function */
902 return midiOutPrepareHeader16(hMidiOut, dwParam1, dwParam2);
903 case MODM_UNPREPARE:
904 return midiOutUnprepareHeader16(hMidiOut, dwParam1, dwParam2);
905 }
906 return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), uMessage, dwParam1, dwParam2);
907 }
908
909 /**************************************************************************
910 * midiInGetNumDevs [MMSYSTEM.301]
911 */
912 UINT16 WINAPI midiInGetNumDevs16(void)
913 {
914 return midiInGetNumDevs();
915 }
916
917 /**************************************************************************
918 * midiInGetDevCaps [MMSYSTEM.302]
919 */
920 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps,
921 UINT16 uSize)
922 {
923 MIDIINCAPSA micA;
924 UINT ret;
925
926 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
927
928 ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
929 if (ret == MMSYSERR_NOERROR) {
930 MIDIINCAPS16 mic16;
931 mic16.wMid = micA.wMid;
932 mic16.wPid = micA.wPid;
933 mic16.vDriverVersion = micA.vDriverVersion;
934 strcpy(mic16.szPname, micA.szPname);
935 mic16.dwSupport = micA.dwSupport;
936 memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
937 }
938 return ret;
939 }
940
941 /**************************************************************************
942 * midiInOpen [MMSYSTEM.304]
943 */
944 UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
945 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
946 {
947 HMIDIIN hmid;
948 UINT ret;
949 struct mmsystdrv_thunk* thunk;
950
951 if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_MIDIIN)))
952 {
953 return MMSYSERR_NOMEM;
954 }
955 if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
956 dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
957 ret = midiInOpen(&hmid, uDeviceID, (DWORD)thunk, dwInstance, dwFlags);
958 if (ret == MMSYSERR_NOERROR)
959 {
960 if (lphMidiIn) *lphMidiIn = HMIDIIN_16(hmid);
961 MMSYSTDRV_SetHandle(thunk, (void*)hmid);
962 }
963 else MMSYSTDRV_DeleteThunk(thunk);
964 return ret;
965 }
966
967 /**************************************************************************
968 * midiInClose [MMSYSTEM.305]
969 */
970 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
971 {
972 UINT ret = midiInClose(HMIDIIN_32(hMidiIn));
973
974 if (ret == MMSYSERR_NOERROR)
975 MMSYSTDRV_CloseHandle((void*)HMIDIIN_32(hMidiIn));
976 return ret;
977 }
978
979 /**************************************************************************
980 * midiInPrepareHeader [MMSYSTEM.306]
981 */
982 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
983 SEGPTR lpsegMidiInHdr, /* [???] */
984 UINT16 uSize) /* [in] */
985 {
986 TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
987
988 return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_PREPARE, lpsegMidiInHdr, uSize);
989 }
990
991 /**************************************************************************
992 * midiInUnprepareHeader [MMSYSTEM.307]
993 */
994 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
995 SEGPTR lpsegMidiInHdr, /* [???] */
996 UINT16 uSize) /* [in] */
997 {
998 LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr);
999
1000 TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
1001
1002 if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
1003 return MMSYSERR_NOERROR;
1004 }
1005
1006 return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_UNPREPARE, lpsegMidiInHdr, uSize);
1007 }
1008
1009 /**************************************************************************
1010 * midiInAddBuffer [MMSYSTEM.308]
1011 */
1012 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, /* [in] */
1013 MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
1014 UINT16 uSize) /* [in] */
1015 {
1016 TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
1017
1018 return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize);
1019 }
1020
1021 /**************************************************************************
1022 * midiInStart [MMSYSTEM.309]
1023 */
1024 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
1025 {
1026 return midiInStart(HMIDIIN_32(hMidiIn));
1027 }
1028
1029 /**************************************************************************
1030 * midiInStop [MMSYSTEM.310]
1031 */
1032 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
1033 {
1034 return midiInStop(HMIDIIN_32(hMidiIn));
1035 }
1036
1037 /**************************************************************************
1038 * midiInReset [MMSYSTEM.311]
1039 */
1040 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
1041 {
1042 return midiInReset(HMIDIIN_32(hMidiIn));
1043 }
1044
1045 /**************************************************************************
1046 * midiInGetID [MMSYSTEM.312]
1047 */
1048 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
1049 {
1050 UINT devid;
1051 UINT16 ret;
1052
1053 ret = midiInGetID(HMIDIIN_32(hMidiIn), &devid);
1054 if (ret != MMSYSERR_NOERROR) return ret;
1055 *lpuDeviceID = devid;
1056 return ret;
1057 }
1058
1059 /**************************************************************************
1060 * midiInMessage [MMSYSTEM.313]
1061 */
1062 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
1063 DWORD dwParam1, DWORD dwParam2)
1064 {
1065 TRACE("(%04X, %04X, %08X, %08X)\n", hMidiIn, uMessage, dwParam1, dwParam2);
1066
1067 switch (uMessage) {
1068 case MIDM_OPEN:
1069 case MIDM_CLOSE:
1070 FIXME("can't handle OPEN or CLOSE message!\n");
1071 return MMSYSERR_NOTSUPPORTED;
1072
1073 case MIDM_GETDEVCAPS:
1074 return midiInGetDevCaps16(hMidiIn, MapSL(dwParam1), dwParam2);
1075 case MIDM_PREPARE:
1076 return midiInPrepareHeader16(hMidiIn, dwParam1, dwParam2);
1077 case MIDM_UNPREPARE:
1078 return midiInUnprepareHeader16(hMidiIn, dwParam1, dwParam2);
1079 case MIDM_ADDBUFFER:
1080 return midiInAddBuffer16(hMidiIn, MapSL(dwParam1), dwParam2);
1081 }
1082 return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), uMessage, dwParam1, dwParam2);
1083 }
1084
1085 /**************************************************************************
1086 * midiStreamClose [MMSYSTEM.252]
1087 */
1088 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
1089 {
1090 UINT ret = midiStreamClose(HMIDISTRM_32(hMidiStrm));
1091 if (ret == MMSYSERR_NOERROR)
1092 MMSYSTDRV_CloseHandle((void*)HMIDISTRM_32(hMidiStrm));
1093 return ret;
1094 }
1095
1096 /**************************************************************************
1097 * midiStreamOpen [MMSYSTEM.251]
1098 */
1099 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
1100 DWORD cMidi, DWORD dwCallback,
1101 DWORD dwInstance, DWORD fdwOpen)
1102 {
1103 HMIDISTRM hMidiStrm32;
1104 MMRESULT ret;
1105 UINT devid32;
1106 struct mmsystdrv_thunk* thunk;
1107
1108 if (!phMidiStrm || !devid)
1109 return MMSYSERR_INVALPARAM;
1110 devid32 = *devid;
1111
1112 if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, fdwOpen, MMSYSTDRV_MIDIOUT)))
1113 {
1114 return MMSYSERR_NOMEM;
1115 }
1116 if ((fdwOpen & CALLBACK_TYPEMASK) != CALLBACK_NULL)
1117 fdwOpen = (fdwOpen & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
1118 ret = midiStreamOpen(&hMidiStrm32, &devid32, cMidi, (DWORD)thunk, dwInstance, fdwOpen);
1119 if (ret == MMSYSERR_NOERROR)
1120 {
1121 *phMidiStrm = HMIDISTRM_16(hMidiStrm32);
1122 *devid = devid32;
1123 MMSYSTDRV_SetHandle(thunk, hMidiStrm32);
1124 }
1125 else MMSYSTDRV_DeleteThunk(thunk);
1126 return ret;
1127 }
1128
1129 /**************************************************************************
1130 * midiStreamOut [MMSYSTEM.254]
1131 */
1132 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hMidiStrm, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr)
1133 {
1134 return midiStreamOut(HMIDISTRM_32(hMidiStrm), (LPMIDIHDR)lpMidiHdr,
1135 cbMidiHdr);
1136 }
1137
1138 /**************************************************************************
1139 * midiStreamPause [MMSYSTEM.255]
1140 */
1141 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hMidiStrm)
1142 {
1143 return midiStreamPause(HMIDISTRM_32(hMidiStrm));
1144 }
1145
1146 /**************************************************************************
1147 * midiStreamPosition [MMSYSTEM.253]
1148 */
1149 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hMidiStrm, LPMMTIME16 lpmmt16, UINT16 cbmmt)
1150 {
1151 MMTIME mmt32;
1152 MMRESULT ret;
1153
1154 if (!lpmmt16)
1155 return MMSYSERR_INVALPARAM;
1156 MMSYSTEM_MMTIME16to32(&mmt32, lpmmt16);
1157 ret = midiStreamPosition(HMIDISTRM_32(hMidiStrm), &mmt32, sizeof(MMTIME));
1158 MMSYSTEM_MMTIME32to16(lpmmt16, &mmt32);
1159 return ret;
1160 }
1161
1162 /**************************************************************************
1163 * midiStreamProperty [MMSYSTEM.250]
1164 */
1165 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
1166 {
1167 return midiStreamProperty(HMIDISTRM_32(hMidiStrm), lpPropData, dwProperty);
1168 }
1169
1170 /**************************************************************************
1171 * midiStreamRestart [MMSYSTEM.256]
1172 */
1173 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hMidiStrm)
1174 {
1175 return midiStreamRestart(HMIDISTRM_32(hMidiStrm));
1176 }
1177
1178 /**************************************************************************
1179 * midiStreamStop [MMSYSTEM.257]
1180 */
1181 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hMidiStrm)
1182 {
1183 return midiStreamStop(HMIDISTRM_32(hMidiStrm));
1184 }
1185
1186 /* ###################################################
1187 * # WAVE #
1188 * ###################################################
1189 */
1190
1191 /**************************************************************************
1192 * waveOutGetNumDevs [MMSYSTEM.401]
1193 */
1194 UINT16 WINAPI waveOutGetNumDevs16(void)
1195 {
1196 return waveOutGetNumDevs();
1197 }
1198
1199 /**************************************************************************
1200 * waveOutGetDevCaps [MMSYSTEM.402]
1201 */
1202 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID,
1203 LPWAVEOUTCAPS16 lpCaps, UINT16 uSize)
1204 {
1205 WAVEOUTCAPSA wocA;
1206 UINT ret;
1207 TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
1208
1209 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1210
1211 ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA));
1212 if (ret == MMSYSERR_NOERROR) {
1213 WAVEOUTCAPS16 woc16;
1214 woc16.wMid = wocA.wMid;
1215 woc16.wPid = wocA.wPid;
1216 woc16.vDriverVersion = wocA.vDriverVersion;
1217 strcpy(woc16.szPname, wocA.szPname);
1218 woc16.dwFormats = wocA.dwFormats;
1219 woc16.wChannels = wocA.wChannels;
1220 woc16.dwSupport = wocA.dwSupport;
1221 memcpy(lpCaps, &woc16, min(uSize, sizeof(woc16)));
1222 }
1223 return ret;
1224 }
1225
1226 /**************************************************************************
1227 * waveOutGetErrorText [MMSYSTEM.403]
1228 * waveInGetErrorText [MMSYSTEM.503]
1229 */
1230 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
1231 {
1232 return waveOutGetErrorTextA(uError, lpText, uSize);
1233 }
1234
1235 /**************************************************************************
1236 * waveOutOpen [MMSYSTEM.404]
1237 */
1238 UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
1239 LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
1240 DWORD dwInstance, DWORD dwFlags)
1241 {
1242 HWAVEOUT hWaveOut;
1243 UINT ret;
1244 struct mmsystdrv_thunk* thunk;
1245
1246 if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_WAVEOUT)))
1247 {
1248 return MMSYSERR_NOMEM;
1249 }
1250 if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
1251 dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
1252 /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
1253 * call the 32 bit version
1254 * however, we need to promote correctly the wave mapper id
1255 * (0xFFFFFFFF and not 0x0000FFFF)
1256 */
1257 ret = waveOutOpen(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
1258 lpFormat, (DWORD)thunk, dwInstance, dwFlags);
1259
1260 if (lphWaveOut != NULL && ret == MMSYSERR_NOERROR)
1261 *lphWaveOut = HWAVEOUT_16(hWaveOut);
1262 if (ret == MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY))
1263 MMSYSTDRV_SetHandle(thunk, (void*)hWaveOut);
1264 else MMSYSTDRV_DeleteThunk(thunk);
1265 return ret;
1266 }
1267
1268 /**************************************************************************
1269 * waveOutClose [MMSYSTEM.405]
1270 */
1271 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
1272 {
1273 DWORD level;
1274 UINT16 ret;
1275
1276 ReleaseThunkLock(&level);
1277 ret = waveOutClose(HWAVEOUT_32(hWaveOut));
1278 RestoreThunkLock(level);
1279 if (ret == MMSYSERR_NOERROR)
1280 MMSYSTDRV_CloseHandle((void*)HWAVEOUT_32(hWaveOut));
1281 return ret;
1282 }
1283
1284 /**************************************************************************
1285 * waveOutPrepareHeader [MMSYSTEM.406]
1286 */
1287 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
1288 SEGPTR lpsegWaveOutHdr, /* [???] */
1289 UINT16 uSize) /* [in] */
1290 {
1291 LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
1292 UINT16 result;
1293
1294 TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
1295
1296 if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
1297
1298 if ((result = MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_PREPARE, lpsegWaveOutHdr,
1299 uSize)) != MMSYSERR_NOTSUPPORTED)
1300 return result;
1301
1302 if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
1303 return WAVERR_STILLPLAYING;
1304
1305 lpWaveOutHdr->dwFlags |= WHDR_PREPARED;
1306 lpWaveOutHdr->dwFlags &= ~WHDR_DONE;
1307
1308 return MMSYSERR_NOERROR;
1309 }
1310
1311 /**************************************************************************
1312 * waveOutUnprepareHeader [MMSYSTEM.407]
1313 */
1314 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
1315 SEGPTR lpsegWaveOutHdr, /* [???] */
1316 UINT16 uSize) /* [in] */
1317 {
1318 LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
1319
1320 TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
1321
1322 if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
1323 return MMSYSERR_NOERROR;
1324 }
1325
1326 return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_UNPREPARE, lpsegWaveOutHdr, uSize);
1327 }
1328
1329 /**************************************************************************
1330 * waveOutWrite [MMSYSTEM.408]
1331 */
1332 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, /* [in] */
1333 LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
1334 UINT16 uSize) /* [in] */
1335 {
1336 TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
1337
1338 return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize);
1339 }
1340
1341 /**************************************************************************
1342 * waveOutBreakLoop [MMSYSTEM.419]
1343 */
1344 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut16)
1345 {
1346 DWORD level;
1347 UINT16 ret;
1348
1349 ReleaseThunkLock(&level);
1350 ret = waveOutBreakLoop(HWAVEOUT_32(hWaveOut16));
1351 RestoreThunkLock(level);
1352 return ret;
1353 }
1354
1355 /**************************************************************************
1356 * waveOutPause [MMSYSTEM.409]
1357 */
1358 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut16)
1359 {
1360 DWORD level;
1361 UINT16 ret;
1362
1363 ReleaseThunkLock(&level);
1364 ret = waveOutPause(HWAVEOUT_32(hWaveOut16));
1365 RestoreThunkLock(level);
1366 return ret;
1367 }
1368
1369 /**************************************************************************
1370 * waveOutReset [MMSYSTEM.411]
1371 */
1372 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut16)
1373 {
1374 DWORD level;
1375 UINT16 ret;
1376
1377 ReleaseThunkLock(&level);
1378 ret = waveOutReset(HWAVEOUT_32(hWaveOut16));
1379 RestoreThunkLock(level);
1380 return ret;
1381 }
1382
1383 /**************************************************************************
1384 * waveOutRestart [MMSYSTEM.410]
1385 */
1386 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut16)
1387 {
1388 DWORD level;
1389 UINT16 ret;
1390
1391 ReleaseThunkLock(&level);
1392 ret = waveOutRestart(HWAVEOUT_32(hWaveOut16));
1393 RestoreThunkLock(level);
1394 return ret;
1395 }
1396
1397 /**************************************************************************
1398 * waveOutGetPosition [MMSYSTEM.412]
1399 */
1400 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
1401 UINT16 uSize)
1402 {
1403 UINT ret;
1404 MMTIME mmt;
1405
1406 mmt.wType = lpTime->wType;
1407 ret = waveOutGetPosition(HWAVEOUT_32(hWaveOut), &mmt, sizeof(mmt));
1408 MMSYSTEM_MMTIME32to16(lpTime, &mmt);
1409 return ret;
1410 }
1411
1412 /**************************************************************************
1413 * waveOutGetPitch [MMSYSTEM.413]
1414 */
1415 UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
1416 {
1417 return waveOutGetPitch(HWAVEOUT_32(hWaveOut16), lpdw);
1418 }
1419
1420 /**************************************************************************
1421 * waveOutSetPitch [MMSYSTEM.414]
1422 */
1423 UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16 hWaveOut16, DWORD dw)
1424 {
1425 return waveOutSetPitch(HWAVEOUT_32(hWaveOut16), dw);
1426 }
1427
1428 /**************************************************************************
1429 * waveOutGetPlaybackRate [MMSYSTEM.417]
1430 */
1431 UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
1432 {
1433 return waveOutGetPlaybackRate(HWAVEOUT_32(hWaveOut16), lpdw);
1434 }
1435
1436 /**************************************************************************
1437 * waveOutSetPlaybackRate [MMSYSTEM.418]
1438 */
1439 UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16 hWaveOut16, DWORD dw)
1440 {
1441 return waveOutSetPlaybackRate(HWAVEOUT_32(hWaveOut16), dw);
1442 }
1443
1444 /**************************************************************************
1445 * waveOutGetVolume [MMSYSTEM.415]
1446 */
1447 UINT16 WINAPI waveOutGetVolume16(UINT16 devid, LPDWORD lpdw)
1448 {
1449 return waveOutGetVolume(HWAVEOUT_32(devid), lpdw);
1450 }
1451
1452 /**************************************************************************
1453 * waveOutSetVolume [MMSYSTEM.416]
1454 */
1455 UINT16 WINAPI waveOutSetVolume16(UINT16 devid, DWORD dw)
1456 {
1457 return waveOutSetVolume(HWAVEOUT_32(devid), dw);
1458 }
1459
1460 /**************************************************************************
1461 * waveOutGetID [MMSYSTEM.420]
1462 */
1463 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
1464 {
1465 UINT devid;
1466 UINT16 ret;
1467
1468 ret = waveOutGetID(HWAVEOUT_32(hWaveOut), &devid);
1469 if (ret != MMSYSERR_NOERROR) return ret;
1470 *lpuDeviceID = devid;
1471 return ret;
1472 }
1473
1474 /**************************************************************************
1475 * waveOutMessage [MMSYSTEM.421]
1476 */
1477 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
1478 DWORD dwParam1, DWORD dwParam2)
1479 {
1480 TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
1481
1482 if ((DWORD_PTR)hWaveOut < waveOutGetNumDevs())
1483 {
1484 if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
1485 dwParam1 = (DWORD)MapSL(dwParam1);
1486 }
1487 else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
1488 /* from M$ KB */
1489 return MMSYSERR_INVALPARAM;
1490
1491 return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), uMessage, dwParam1, dwParam2);
1492 }
1493
1494 /**************************************************************************
1495 * waveInGetNumDevs [MMSYSTEM.501]
1496 */
1497 UINT16 WINAPI waveInGetNumDevs16(void)
1498 {
1499 return waveInGetNumDevs();
1500 }
1501
1502 /**************************************************************************
1503 * waveInGetDevCaps [MMSYSTEM.502]
1504 */
1505 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps,
1506 UINT16 uSize)
1507 {
1508 WAVEINCAPSA wicA;
1509 UINT ret;
1510
1511 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1512
1513 ret = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(wicA));
1514 if (ret == MMSYSERR_NOERROR) {
1515 WAVEINCAPS16 wic16;
1516 wic16.wMid = wicA.wMid;
1517 wic16.wPid = wicA.wPid;
1518 wic16.vDriverVersion = wicA.vDriverVersion;
1519 strcpy(wic16.szPname, wicA.szPname);
1520 wic16.dwFormats = wicA.dwFormats;
1521 wic16.wChannels = wicA.wChannels;
1522 memcpy(lpCaps, &wic16, min(uSize, sizeof(wic16)));
1523 }
1524 return ret;
1525 }
1526
1527 /**************************************************************************
1528 * waveInOpen [MMSYSTEM.504]
1529 */
1530 UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
1531 LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
1532 DWORD dwInstance, DWORD dwFlags)
1533 {
1534 HWAVEIN hWaveIn;
1535 UINT ret;
1536 struct mmsystdrv_thunk* thunk;
1537
1538 if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_WAVEIN)))
1539 {
1540 return MMSYSERR_NOMEM;
1541 }
1542 if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
1543 dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
1544 /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
1545 * call the 32 bit version
1546 * however, we need to promote correctly the wave mapper id
1547 * (0xFFFFFFFF and not 0x0000FFFF)
1548 */
1549 ret = waveInOpen(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
1550 lpFormat, (DWORD)thunk, dwInstance, dwFlags);
1551
1552 if (lphWaveIn != NULL && ret == MMSYSERR_NOERROR)
1553 *lphWaveIn = HWAVEIN_16(hWaveIn);
1554 if (ret == MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY))
1555 MMSYSTDRV_SetHandle(thunk, (void*)hWaveIn);
1556 else MMSYSTDRV_DeleteThunk(thunk);
1557 return ret;
1558 }
1559
1560 /**************************************************************************
1561 * waveInClose [MMSYSTEM.505]
1562 */
1563 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
1564 {
1565 DWORD level;
1566 UINT16 ret;
1567
1568 ReleaseThunkLock(&level);
1569 ret = waveInClose(HWAVEIN_32(hWaveIn));
1570 RestoreThunkLock(level);
1571 if (ret == MMSYSERR_NOERROR)
1572 MMSYSTDRV_CloseHandle((void*)HWAVEIN_32(hWaveIn));
1573 return ret;
1574 }
1575
1576 /**************************************************************************
1577 * waveInPrepareHeader [MMSYSTEM.506]
1578 */
1579 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
1580 SEGPTR lpsegWaveInHdr, /* [???] */
1581 UINT16 uSize) /* [in] */
1582 {
1583 LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
1584 UINT16 ret;
1585
1586 TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
1587
1588 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1589 lpWaveInHdr->dwBytesRecorded = 0;
1590
1591 ret = MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_PREPARE, lpsegWaveInHdr, uSize);
1592 return ret;
1593 }
1594
1595 /**************************************************************************
1596 * waveInUnprepareHeader [MMSYSTEM.507]
1597 */
1598 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
1599 SEGPTR lpsegWaveInHdr, /* [???] */
1600 UINT16 uSize) /* [in] */
1601 {
1602 LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
1603
1604 TRACE("(%04X, %08x, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
1605
1606 if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
1607
1608 if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
1609 return MMSYSERR_NOERROR;
1610 }
1611
1612 return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_UNPREPARE, lpsegWaveInHdr, uSize);
1613 }
1614
1615 /**************************************************************************
1616 * waveInAddBuffer [MMSYSTEM.508]
1617 */
1618 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, /* [in] */
1619 WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
1620 UINT16 uSize) /* [in] */
1621 {
1622 TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
1623
1624 if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
1625
1626 return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize);
1627 }
1628
1629 /**************************************************************************
1630 * waveInReset [MMSYSTEM.511]
1631 */
1632 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn16)
1633 {
1634 DWORD level;
1635 UINT16 ret;
1636
1637 ReleaseThunkLock(&level);
1638 ret = waveInReset(HWAVEIN_32(hWaveIn16));
1639 RestoreThunkLock(level);
1640 return ret;
1641 }
1642
1643 /**************************************************************************
1644 * waveInStart [MMSYSTEM.509]
1645 */
1646 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn16)
1647 {
1648 DWORD level;
1649 UINT16 ret;
1650
1651 ReleaseThunkLock(&level);
1652 ret = waveInStart(HWAVEIN_32(hWaveIn16));
1653 RestoreThunkLock(level);
1654 return ret;
1655 }
1656
1657 /**************************************************************************
1658 * waveInStop [MMSYSTEM.510]
1659 */
1660 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn16)
1661 {
1662 DWORD level;
1663 UINT16 ret;
1664
1665 ReleaseThunkLock(&level);
1666 ret = waveInStop(HWAVEIN_32(hWaveIn16));
1667 RestoreThunkLock(level);
1668 return ret;
1669 }
1670
1671 /**************************************************************************
1672 * waveInGetPosition [MMSYSTEM.512]
1673 */
1674 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
1675 UINT16 uSize)
1676 {
1677 UINT ret;
1678 MMTIME mmt;
1679
1680 mmt.wType = lpTime->wType;
1681 ret = waveInGetPosition(HWAVEIN_32(hWaveIn), &mmt, sizeof(mmt));
1682 MMSYSTEM_MMTIME32to16(lpTime, &mmt);
1683 return ret;
1684 }
1685
1686 /**************************************************************************
1687 * waveInGetID [MMSYSTEM.513]
1688 */
1689 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
1690 {
1691 UINT devid;
1692 UINT16 ret;
1693
1694 ret = waveInGetID(HWAVEIN_32(hWaveIn), &devid);
1695 if (ret != MMSYSERR_NOERROR) return ret;
1696 *lpuDeviceID = devid;
1697 return ret;
1698 }
1699
1700 /**************************************************************************
1701 * waveInMessage [MMSYSTEM.514]
1702 */
1703 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
1704 DWORD dwParam1, DWORD dwParam2)
1705 {
1706 TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
1707
1708 if ((DWORD_PTR)hWaveIn < waveInGetNumDevs())
1709 {
1710 if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
1711 dwParam1 = (DWORD)MapSL(dwParam1);
1712 }
1713 else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
1714 /* from M$ KB */
1715 return MMSYSERR_INVALPARAM;
1716
1717 return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), uMessage, dwParam1, dwParam2);
1718 }
1719
1720 /* ###################################################
1721 * # TASK #
1722 * ###################################################
1723 */
1724
1725 /*#define USE_MM_TSK_WINE*/
1726
1727 /**************************************************************************
1728 * mmTaskCreate [MMSYSTEM.900]
1729 *
1730 * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
1731 * called upon creation with dwPmt as parameter.
1732 */
1733 HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt)
1734 {
1735 HINSTANCE16 ret;
1736 HINSTANCE16 handle;
1737 char cmdline[16];
1738 DWORD showCmd = 0x40002;
1739 LOADPARAMS16 lp;
1740
1741 TRACE("(%08x, %p, %08x);\n", spProc, lphMmTask, dwPmt);
1742 /* This to work requires NE modules to be started with a binary command line
1743 * which is not currently the case. A patch exists but has never been committed.
1744 * A workaround would be to integrate code for mmtask.tsk into Wine, but
1745 * this requires tremendous work (starting with patching tools/build to
1746 * create NE executables (and not only DLLs) for builtins modules.
1747 * EP 99/04/25
1748 */
1749 FIXME("This is currently broken. It will fail\n");
1750
1751 cmdline[0] = 0x0d;
1752 *(LPDWORD)(cmdline + 1) = (DWORD)spProc;
1753 *(LPDWORD)(cmdline + 5) = dwPmt;
1754 *(LPDWORD)(cmdline + 9) = 0;
1755
1756 lp.hEnvironment = 0;
1757 lp.cmdLine = MapLS(cmdline);
1758 lp.showCmd = MapLS(&showCmd);
1759 lp.reserved = 0;
1760
1761 #ifndef USE_MM_TSK_WINE
1762 handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", &lp);
1763 #else
1764 handle = LoadModule16("mmtask.tsk", &lp);
1765 #endif
1766 if (handle < 32) {
1767 ret = (handle) ? 1 : 2;
1768 handle = 0;
1769 } else {
1770 ret = 0;
1771 }
1772 if (lphMmTask)
1773 *lphMmTask = handle;
1774
1775 UnMapLS( lp.cmdLine );
1776 UnMapLS( lp.showCmd );
1777 TRACE("=> 0x%04x/%d\n", handle, ret);
1778 return ret;
1779 }
1780
1781 #ifdef USE_MM_TSK_WINE
1782 /* C equivalent to mmtask.tsk binary content */
1783 void mmTaskEntryPoint16(LPSTR cmdLine, WORD di, WORD si)
1784 {
1785 int len = cmdLine[0x80];
1786
1787 if (len / 2 == 6) {
1788 void (*fpProc)(DWORD) = MapSL(*((DWORD*)(cmdLine + 1)));
1789 DWORD dwPmt = *((DWORD*)(cmdLine + 5));
1790
1791 #if 0
1792 InitTask16(); /* FIXME: pmts / from context ? */
1793 InitApp(di);
1794 #endif
1795 if (SetMessageQueue16(0x40)) {
1796 WaitEvent16(0);
1797 if (HIWORD(fpProc)) {
1798 OldYield16();
1799 /* EPP StackEnter16(); */
1800 (fpProc)(dwPmt);
1801 }
1802 }
1803 }
1804 OldYield16();
1805 OldYield16();
1806 OldYield16();
1807 ExitProcess(0);
1808 }
1809 #endif
1810
1811 /**************************************************************************
1812 * mmTaskBlock [MMSYSTEM.902]
1813 */
1814 void WINAPI mmTaskBlock16(HINSTANCE16 hInst)
1815 {
1816 MSG msg;
1817
1818 do {
1819 GetMessageA(&msg, 0, 0, 0);
1820 if (msg.hwnd) {
1821 TranslateMessage(&msg);
1822 DispatchMessageA(&msg);
1823 }
1824 } while (msg.message < 0x3A0);
1825 }
1826
1827 /**************************************************************************
1828 * mmTaskSignal [MMSYSTEM.903]
1829 */
1830 LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
1831 {
1832 TRACE("(%04x);\n", ht);
1833 return PostThreadMessageW( HTASK_32(ht), WM_USER, 0, 0 );
1834 }
1835
1836 /**************************************************************************
1837 * mmGetCurrentTask [MMSYSTEM.904]
1838 */
1839 HTASK16 WINAPI mmGetCurrentTask16(void)
1840 {
1841 return GetCurrentTask();
1842 }
1843
1844 /**************************************************************************
1845 * mmTaskYield [MMSYSTEM.905]
1846 */
1847 void WINAPI mmTaskYield16(void)
1848 {
1849 MSG msg;
1850
1851 if (PeekMessageA(&msg, 0, 0, 0, 0)) {
1852 WOWYield16();
1853 }
1854 }
1855
1856 /******************************************************************
1857 * WINMM_GetmmThread
1858 *
1859 *
1860 */
1861 static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16 h)
1862 {
1863 return MapSL(MAKESEGPTR(h, 0));
1864 }
1865
1866 static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd)
1867 {
1868 MSG msg;
1869 DWORD ret;
1870
1871 if (lpMMThd->dwThreadID != GetCurrentThreadId())
1872 ERR("Not called by thread itself\n");
1873
1874 for (;;) {
1875 ResetEvent(lpMMThd->hEvent);
1876 if (InterlockedDecrement(&lpMMThd->dwSignalCount) >= 0)
1877 break;
1878 InterlockedIncrement(&lpMMThd->dwSignalCount);
1879
1880 TRACE("S1\n");
1881
1882 ret = MsgWaitForMultipleObjects(1, &lpMMThd->hEvent, FALSE, INFINITE, QS_ALLINPUT);
1883 switch (ret) {
1884 case WAIT_OBJECT_0: /* Event */
1885 TRACE("S2.1\n");
1886 break;
1887 case WAIT_OBJECT_0 + 1: /* Msg */
1888 TRACE("S2.2\n");
1889 if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
1890 TranslateMessage(&msg);
1891 DispatchMessageA(&msg);
1892 }
1893 break;
1894 default:
1895 WARN("S2.x unsupported ret val 0x%08x\n", ret);
1896 }
1897 TRACE("S3\n");
1898 }
1899 }
1900
1901 /**************************************************************************
1902 * mmThreadBlock [MMSYSTEM.1122]
1903 */
1904 void WINAPI mmThreadBlock16(HANDLE16 hndl)
1905 {
1906 TRACE("(%04x)!\n", hndl);
1907
1908 if (hndl) {
1909 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
1910
1911 if (lpMMThd->hThread != 0) {
1912 DWORD lc;
1913
1914 ReleaseThunkLock(&lc);
1915 MMSYSTEM_ThreadBlock(lpMMThd);
1916 RestoreThunkLock(lc);
1917 } else {
1918 mmTaskBlock16(lpMMThd->hTask);
1919 }
1920 }
1921 TRACE("done\n");
1922 }
1923
1924 /**************************************************************************
1925 * __wine_mmThreadEntryPoint (MMSYSTEM.2047)
1926 */
1927 DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID p)
1928 {
1929 HANDLE16 hndl = (HANDLE16)(DWORD_PTR)p;
1930 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
1931
1932 TRACE("(%04x %p)\n", hndl, lpMMThd);
1933
1934 lpMMThd->hTask = LOWORD(GetCurrentTask());
1935 TRACE("[10-%p] setting hTask to 0x%08x\n", lpMMThd->hThread, lpMMThd->hTask);
1936 lpMMThd->dwStatus = 0x10;
1937 MMSYSTEM_ThreadBlock(lpMMThd);
1938 TRACE("[20-%p]\n", lpMMThd->hThread);
1939 lpMMThd->dwStatus = 0x20;
1940 if (lpMMThd->fpThread) {
1941 WOWCallback16(lpMMThd->fpThread, lpMMThd->dwThreadPmt);
1942 }
1943 lpMMThd->dwStatus = 0x30;
1944 TRACE("[30-%p]\n", lpMMThd->hThread);
1945 while (lpMMThd->dwCounter) {
1946 Sleep(1);
1947 /* WOWYield16();*/
1948 }
1949 TRACE("[XX-%p]\n", lpMMThd->hThread);
1950 /* paranoia */
1951 lpMMThd->dwSignature = WINE_MMTHREAD_DELETED;
1952 /* close lpMMThread->hVxD directIO */
1953 if (lpMMThd->hEvent)
1954 CloseHandle(lpMMThd->hEvent);
1955 GlobalFree16(hndl);
1956 TRACE("done\n");
1957
1958 return 0;
1959 }
1960
1961 extern DWORD WINAPI GetProcessFlags(DWORD);
1962
1963 /**************************************************************************
1964 * mmThreadCreate [MMSYSTEM.1120]
1965 *
1966 * undocumented
1967 * Creates a MM thread, calling fpThreadAddr(dwPmt).
1968 * dwFlags:
1969 * bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc
1970 * bit.1 set means to open a VxD for this thread (unsupported)
1971 */
1972 LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD dwPmt, DWORD dwFlags)
1973 {
1974 HANDLE16 hndl;
1975 LRESULT ret;
1976
1977 TRACE("(%p, %p, %08x, %08x)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags);
1978
1979 hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT);
1980
1981 if (hndl == 0) {
1982 ret = 2;
1983 } else {
1984 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
1985
1986 #if 0
1987 /* force mmtask routines even if mmthread is required */
1988 /* this will work only if the patch about binary cmd line and NE tasks
1989 * is committed
1990 */
1991 dwFlags |= 1;
1992 #endif
1993
1994 lpMMThd->dwSignature = WINE_MMTHREAD_CREATED;
1995 lpMMThd->dwCounter = 0;
1996 lpMMThd->hThread = 0;
1997 lpMMThd->dwThreadID = 0;
1998 lpMMThd->fpThread = (DWORD)fpThreadAddr;
1999 lpMMThd->dwThreadPmt = dwPmt;
2000 lpMMThd->dwSignalCount = 0;
2001 lpMMThd->hEvent = 0;
2002 lpMMThd->hVxD = 0;
2003 lpMMThd->dwStatus = 0;
2004 lpMMThd->dwFlags = dwFlags;
2005 lpMMThd->hTask = 0;
2006
2007 if ((dwFlags & 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) {
2008 lpMMThd->hEvent = CreateEventW(NULL, FALSE, TRUE, NULL);
2009
2010 TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd);
2011 if (lpMMThd->dwFlags & 2) {
2012 /* as long as we don't support MM VxD in wine, we don't need
2013 * to care about this flag
2014 */
2015 /* FIXME("Don't know how to properly open VxD handles\n"); */
2016 /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */
2017 }
2018
2019 lpMMThd->hThread = CreateThread(0, 0, WINE_mmThreadEntryPoint,
2020 (LPVOID)(DWORD_PTR)hndl, CREATE_SUSPENDED, &lpMMThd->dwThreadID);
2021 if (lpMMThd->hThread == 0) {
2022 WARN("Couldn't create thread\n");
2023 /* clean-up(VxDhandle...); devicedirectio... */
2024 if (lpMMThd->hEvent != 0)
2025 CloseHandle(lpMMThd->hEvent);
2026 ret = 2;
2027 } else {
2028 SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL);
2029 TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID);
2030 ret = 0;
2031 }
2032 } else {
2033 /* get WINE_mmThreadEntryPoint()
2034 * 2047 is its ordinal in mmsystem.spec
2035 */
2036 FARPROC16 fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047);
2037
2038 TRACE("farproc seg=0x%p lin=%p\n", fp, MapSL((SEGPTR)fp));
2039
2040 ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl);
2041 }
2042
2043 if (ret == 0) {
2044 if (lpMMThd->hThread && !ResumeThread(lpMMThd->hThread))
2045 WARN("Couldn't resume thread\n");
2046
2047 while (lpMMThd->dwStatus != 0x10) { /* test also HIWORD of dwStatus */
2048 MSG msg;
2049 PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
2050 }
2051 }
2052 }
2053
2054 if (ret != 0) {
2055 GlobalFree16(hndl);
2056 hndl = 0;
2057 }
2058
2059 if (lpHndl)
2060 *lpHndl = hndl;
2061
2062 TRACE("ok => %ld\n", ret);
2063 return ret;
2064 }
2065
2066 /**************************************************************************
2067 * mmThreadSignal [MMSYSTEM.1121]
2068 */
2069 void WINAPI mmThreadSignal16(HANDLE16 hndl)
2070 {
2071 TRACE("(%04x)!\n", hndl);
2072
2073 if (hndl) {
2074 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
2075
2076 lpMMThd->dwCounter++;
2077 if (lpMMThd->hThread != 0) {
2078 InterlockedIncrement(&lpMMThd->dwSignalCount);
2079 SetEvent(lpMMThd->hEvent);
2080 } else {
2081 mmTaskSignal16(lpMMThd->hTask);
2082 }
2083 lpMMThd->dwCounter--;
2084 }
2085 }
2086
2087 /**************************************************************************
2088 * mmThreadIsCurrent [MMSYSTEM.1123]
2089 */
2090 BOOL16 WINAPI mmThreadIsCurrent16(HANDLE16 hndl)
2091 {
2092 BOOL16 ret = FALSE;
2093
2094 TRACE("(%04x)!\n", hndl);
2095
2096 if (hndl && mmThreadIsValid16(hndl)) {
2097 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
2098 ret = (GetCurrentThreadId() == lpMMThd->dwThreadID);
2099 }
2100 TRACE("=> %d\n", ret);
2101 return ret;
2102 }
2103
2104 /**************************************************************************
2105 * mmThreadIsValid [MMSYSTEM.1124]
2106 */
2107 BOOL16 WINAPI mmThreadIsValid16(HANDLE16 hndl)
2108 {
2109 BOOL16 ret = FALSE;
2110
2111 TRACE("(%04x)!\n", hndl);
2112
2113 if (hndl) {
2114 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
2115
2116 if (!IsBadWritePtr(lpMMThd, sizeof(WINE_MMTHREAD)) &&
2117 lpMMThd->dwSignature == WINE_MMTHREAD_CREATED &&
2118 IsTask16(lpMMThd->hTask)) {
2119 lpMMThd->dwCounter++;
2120 if (lpMMThd->hThread != 0) {
2121 DWORD dwThreadRet;
2122 if (GetExitCodeThread(lpMMThd->hThread, &dwThreadRet) &&
2123 dwThreadRet == STATUS_PENDING) {
2124 ret = TRUE;
2125 }
2126 } else {
2127 ret = TRUE;
2128 }
2129 lpMMThd->dwCounter--;
2130 }
2131 }
2132 TRACE("=> %d\n", ret);
2133 return ret;
2134 }
2135
2136 /**************************************************************************
2137 * mmThreadGetTask [MMSYSTEM.1125]
2138 */
2139 HANDLE16 WINAPI mmThreadGetTask16(HANDLE16 hndl)
2140 {
2141 HANDLE16 ret = 0;
2142
2143 TRACE("(%04x)\n", hndl);
2144
2145 if (mmThreadIsValid16(hndl)) {
2146 WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
2147 ret = lpMMThd->hTask;
2148 }
2149 return ret;
2150 }
2151
2152 typedef BOOL16 (WINAPI *MMCPLCALLBACK)(HWND, LPCSTR, LPCSTR, LPCSTR);
2153
2154 /**************************************************************************
2155 * mmShowMMCPLPropertySheet [MMSYSTEM.1150]
2156 */
2157 BOOL16 WINAPI mmShowMMCPLPropertySheet16(HWND hWnd, LPCSTR lpStrDevice,
2158 LPCSTR lpStrTab, LPCSTR lpStrTitle)
2159 {
2160 HANDLE hndl;
2161 BOOL16 ret = FALSE;
2162
2163 TRACE("(%p \"%s\" \"%s\" \"%s\")\n", hWnd, lpStrDevice, lpStrTab, lpStrTitle);
2164
2165 hndl = LoadLibraryA("MMSYS.CPL");
2166 if (hndl != 0) {
2167 MMCPLCALLBACK fp = (MMCPLCALLBACK)GetProcAddress(hndl, "ShowMMCPLPropertySheet");
2168 if (fp != NULL) {
2169 DWORD lc;
2170 ReleaseThunkLock(&lc);
2171 ret = (fp)(hWnd, lpStrDevice, lpStrTab, lpStrTitle);
2172 RestoreThunkLock(lc);
2173 }
2174 FreeLibrary(hndl);
2175 }
2176
2177 return ret;
2178 }
2179
2180 /**************************************************************************
2181 * StackEnter [MMSYSTEM.32]
2182 */
2183 void WINAPI StackEnter16(void)
2184 {
2185 #ifdef __i386__
2186 /* mmsystem.dll from Win 95 does only this: so does Wine */
2187 __asm__("stc");
2188 #endif
2189 }
2190
2191 /**************************************************************************
2192 * StackLeave [MMSYSTEM.33]
2193 */
2194 void WINAPI StackLeave16(void)
2195 {
2196 #ifdef __i386__
2197 /* mmsystem.dll from Win 95 does only this: so does Wine */
2198 __asm__("stc");
2199 #endif
2200 }
2201
2202 /**************************************************************************
2203 * WMMMidiRunOnce [MMSYSTEM.8]
2204 */
2205 void WINAPI WMMMidiRunOnce16(void)
2206 {
2207 FIXME("(), stub!\n");
2208 }
2209
2210
2211
2212 /* ###################################################
2213 * # JOYSTICK #
2214 * ###################################################
2215 */
2216
2217 /**************************************************************************
2218 * joyGetNumDevs [MMSYSTEM.101]
2219 */
2220 UINT16 WINAPI joyGetNumDevs16(void)
2221 {
2222 return joyGetNumDevs();
2223 }
2224
2225 /**************************************************************************
2226 * joyGetDevCaps [MMSYSTEM.102]
2227 */
2228 MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
2229 {
2230 JOYCAPSA jca;
2231 MMRESULT ret;
2232
2233 if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
2234
2235 ret = joyGetDevCapsA(wID, &jca, sizeof(jca));
2236
2237 if (ret != JOYERR_NOERROR) return ret;
2238 lpCaps->wMid = jca.wMid;
2239 lpCaps->wPid = jca.wPid;
2240 strcpy(lpCaps->szPname, jca.szPname);
2241 lpCaps->wXmin = jca.wXmin;
2242 lpCaps->wXmax = jca.wXmax;
2243 lpCaps->wYmin = jca.wYmin;
2244 lpCaps->wYmax = jca.wYmax;
2245 lpCaps->wZmin = jca.wZmin;
2246 lpCaps->wZmax = jca.wZmax;
2247 lpCaps->wNumButtons = jca.wNumButtons;
2248 lpCaps->wPeriodMin = jca.wPeriodMin;
2249 lpCaps->wPeriodMax = jca.wPeriodMax;
2250
2251 if (wSize >= sizeof(JOYCAPS16)) { /* Win95 extensions ? */
2252 lpCaps->wRmin = jca.wRmin;
2253 lpCaps->wRmax = jca.wRmax;
2254 lpCaps->wUmin = jca.wUmin;
2255 lpCaps->wUmax = jca.wUmax;
2256 lpCaps->wVmin = jca.wVmin;
2257 lpCaps->wVmax = jca.wVmax;
2258 lpCaps->wCaps = jca.wCaps;
2259 lpCaps->wMaxAxes = jca.wMaxAxes;
2260 lpCaps->wNumAxes = jca.wNumAxes;
2261 lpCaps->wMaxButtons = jca.wMaxButtons;
2262 strcpy(lpCaps->szRegKey, jca.szRegKey);
2263 strcpy(lpCaps->szOEMVxD, jca.szOEMVxD);
2264 }
2265
2266 return ret;
2267 }
2268
2269 /**************************************************************************
2270 * joyGetPosEx [MMSYSTEM.110]
2271 */
2272 MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo)
2273 {
2274 return joyGetPosEx(wID, lpInfo);
2275 }
2276
2277 /**************************************************************************
2278 * joyGetPos [MMSYSTEM.103]
2279 */
2280 MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
2281 {
2282 JOYINFO ji;
2283 MMRESULT ret;
2284
2285 TRACE("(%d, %p);\n", wID, lpInfo);
2286
2287 if ((ret = joyGetPos(wID, &ji)) == JOYERR_NOERROR) {
2288 lpInfo->wXpos = ji.wXpos;
2289 lpInfo->wYpos = ji.wYpos;
2290 lpInfo->wZpos = ji.wZpos;
2291 lpInfo->wButtons = ji.wButtons;
2292 }
2293 return ret;
2294 }
2295
2296 /**************************************************************************
2297 * joyGetThreshold [MMSYSTEM.104]
2298 */
2299 MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
2300 {
2301 UINT t;
2302 MMRESULT ret;
2303
2304 ret = joyGetThreshold(wID, &t);
2305 if (ret == JOYERR_NOERROR)
2306 *lpThreshold = t;
2307 return ret;
2308 }
2309
2310 /**************************************************************************
2311 * joyReleaseCapture [MMSYSTEM.105]
2312 */
2313 MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
2314 {
2315 return joyReleaseCapture(wID);
2316 }
2317
2318 /**************************************************************************
2319 * joySetCapture [MMSYSTEM.106]
2320 */
2321 MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL16 bChanged)
2322 {
2323 return joySetCapture(HWND_32(hWnd), wID, wPeriod, bChanged);
2324 }
2325
2326 /**************************************************************************
2327 * joySetThreshold [MMSYSTEM.107]
2328 */
2329 MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
2330 {
2331 return joySetThreshold(wID,wThreshold);
2332 }
2333
2334 /**************************************************************************
2335 * joySetCalibration [MMSYSTEM.109]
2336 */
2337 MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
2338 {
2339 FIXME("(%04X): stub.\n", wID);
2340 return JOYERR_NOCANDO;
2341 }
Windows API implementation