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