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