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