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