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