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