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