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

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