git.oblomov.eu Git - wine/blob - dlls/winmm/mmsystem.c

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