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