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