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