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