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

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