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

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * MMSYSTEM functions
   5  *
   6  * Copyright 1993      Martin Ayotte
   7  *           1998-2003 Eric Pouech
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 /*
  25  * Eric POUECH :
  26  *      99/4    added mmTask and mmThread functions support
  27  */
  28
  29 #include <stdarg.h>
  30 #include <string.h>
  31
  32 #define NONAMELESSUNION
  33 #define NONAMELESSSTRUCT
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "mmsystem.h"
  37 #include "winternl.h"
  38 #include "wownt32.h"
  39 #include "winnls.h"
  40
  41 #include "wine/list.h"
  42 #include "wine/winuser16.h"
  43 #include "winemm16.h"
  44
  45 #include "wine/debug.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
  48
  49
  50 static CRITICAL_SECTION_DEBUG mmdrv_critsect_debug =
  51 {
  52     0, 0, &mmdrv_cs,
  53     { &mmdrv_critsect_debug.ProcessLocksList, &mmdrv_critsect_debug.ProcessLocksList },
  54       0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmdrv_cs") }
  55 };
  56 CRITICAL_SECTION mmdrv_cs = { &mmdrv_critsect_debug, -1, 0, 0, 0, 0 };
  57
  58 /* ###################################################
  59  * #                  LIBRARY                        #
  60  * ###################################################
  61  */
  62
  63 /**************************************************************************
  64  *                      DllEntryPoint (MMSYSTEM.4)
  65  *
  66  * MMSYSTEM DLL entry point
  67  *
  68  */
  69 BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
  70                              WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
  71 {
  72     static int done;
  73
  74     if (!done++) LoadLibrary16( "sound.drv" );
  75     return TRUE;
  76 }
  77
  78 /**************************************************************************
  79  *                              WEP                     [MMSYSTEM.1]
  80  */
  81 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
  82                         WORD cbHeapSize, LPSTR lpCmdLine)
  83 {
  84     TRACE("STUB: Unloading MMSystem DLL ... hInst=%04X\n", hInstance);
  85     return TRUE;
  86 }
  87
  88 /* ###################################################
  89  * #                     TIME                        #
  90  * ###################################################
  91  */
  92
  93 /******************************************************************
  94  *              MMSYSTEM_MMTIME32to16
  95  *
  96  *
  97  */
  98 void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32)
  99 {
 100     mmt16->wType = mmt32->wType;
 101     /* layout of rest is the same for 32/16,
 102      * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
 103      */
 104     memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
 105 }
 106
 107 /******************************************************************
 108  *              MMSYSTEM_MMTIME16to32
 109  *
 110  *
 111  */
 112 static void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16)
 113 {
 114     mmt32->wType = mmt16->wType;
 115     /* layout of rest is the same for 32/16,
 116      * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
 117      */
 118     memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
 119 }
 120
 121 /**************************************************************************
 122  *                              timeGetSystemTime       [MMSYSTEM.601]
 123  */
 124 MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
 125 {
 126     if (wSize >= sizeof(*lpTime)) {
 127         lpTime->wType = TIME_MS;
 128         lpTime->u.ms = GetTickCount();
 129
 130         TRACE("=> %u\n", lpTime->u.ms);
 131     }
 132
 133     return 0;
 134 }
 135
 136 struct timer_entry {
 137     struct list         entry;
 138     UINT                id;
 139     LPTIMECALLBACK16    func16;
 140     DWORD               user;
 141 };
 142
 143 static struct list timer_list = LIST_INIT(timer_list);
 144
 145 static void CALLBACK timeCB3216(UINT id, UINT uMsg, DWORD_PTR user, DWORD_PTR dw1, DWORD_PTR dw2)
 146 {
 147     struct timer_entry* te = (void*)user;
 148     WORD                args[8];
 149     DWORD               ret;
 150
 151     args[7] = LOWORD(id);
 152     args[6] = LOWORD(uMsg);
 153     args[5] = HIWORD(te->user);
 154     args[4] = LOWORD(te->user);
 155     args[3] = HIWORD(dw1);
 156     args[2] = LOWORD(dw2);
 157     args[1] = HIWORD(dw2);
 158     args[0] = LOWORD(dw2);
 159     WOWCallback16Ex((DWORD)te->func16, WCB16_PASCAL, sizeof(args), args, &ret);
 160 }
 161
 162 /**************************************************************************
 163  *                              timeSetEvent            [MMSYSTEM.602]
 164  */
 165 MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
 166                                  DWORD dwUser, UINT16 wFlags)
 167 {
 168     MMRESULT16          id;
 169     struct timer_entry* te;
 170
 171     switch (wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE))
 172     {
 173     case TIME_CALLBACK_EVENT_SET:
 174     case TIME_CALLBACK_EVENT_PULSE:
 175         id = timeSetEvent(wDelay, wResol, (LPTIMECALLBACK)lpFunc, dwUser, wFlags);
 176         break;
 177     case TIME_CALLBACK_FUNCTION:
 178         te = HeapAlloc(GetProcessHeap(), 0, sizeof(*te));
 179         if (!te) return 0;
 180         te->func16 = lpFunc;
 181         te->user = dwUser;
 182         id = te->id = timeSetEvent(wDelay, wResol, timeCB3216, (DWORD_PTR)te, wFlags);
 183         if (id)
 184         {
 185             EnterCriticalSection(&mmdrv_cs);
 186             list_add_tail(&timer_list, &te->entry);
 187             LeaveCriticalSection(&mmdrv_cs);
 188         }
 189         else HeapFree(GetProcessHeap(), 0, te);
 190         break;
 191     default:
 192         id = 0;
 193         break;
 194     }
 195     return id;
 196 }
 197
 198 /**************************************************************************
 199  *                              timeKillEvent           [MMSYSTEM.603]
 200  */
 201 MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
 202 {
 203     MMRESULT16  ret = timeKillEvent(wID);
 204     struct timer_entry* te;
 205
 206     if (ret == TIMERR_NOERROR)
 207     {
 208         EnterCriticalSection(&mmdrv_cs);
 209         LIST_FOR_EACH_ENTRY(te, &timer_list, struct timer_entry, entry)
 210         {
 211             if (wID == te->id)
 212             {
 213                 list_remove(&te->entry);
 214                 HeapFree(GetProcessHeap(), 0, te);
 215                 break;
 216             }
 217         }
 218         LeaveCriticalSection(&mmdrv_cs);
 219     }
 220     return ret;
 221 }
 222
 223 /**************************************************************************
 224  *                              timeGetDevCaps          [MMSYSTEM.604]
 225  */
 226 MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16 lpCaps, UINT16 wSize)
 227 {
 228     TIMECAPS    caps;
 229     MMRESULT    ret;
 230     TRACE("(%p, %u) !\n", lpCaps, wSize);
 231
 232     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 233
 234     ret = timeGetDevCaps(&caps, sizeof(caps));
 235     if (ret == MMSYSERR_NOERROR) {
 236         TIMECAPS16 tc16;
 237         tc16.wPeriodMin = caps.wPeriodMin;
 238         tc16.wPeriodMax = caps.wPeriodMax;
 239         memcpy(lpCaps, &tc16, min(wSize, sizeof(tc16)));
 240     }
 241     return ret;
 242 }
 243
 244 /**************************************************************************
 245  *                              timeBeginPeriod [MMSYSTEM.605]
 246  */
 247 MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod)
 248 {
 249     TRACE("(%u) !\n", wPeriod);
 250
 251     return timeBeginPeriod(wPeriod);
 252 }
 253
 254 /**************************************************************************
 255  *                              timeEndPeriod           [MMSYSTEM.606]
 256  */
 257 MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
 258 {
 259     TRACE("(%u) !\n", wPeriod);
 260
 261     return timeEndPeriod(wPeriod);
 262 }
 263
 264 /**************************************************************************
 265  *                              timeGetTime    [MMSYSTEM.607]
 266  */
 267 DWORD WINAPI timeGetTime16(void)
 268 {
 269     return timeGetTime();
 270 }
 271
 272 /* ###################################################
 273  * #                  PlaySound                      #
 274  * ###################################################
 275  */
 276
 277 /**************************************************************************
 278  *                              PlaySound               [MMSYSTEM.3]
 279  */
 280 BOOL16 WINAPI PlaySound16(LPCSTR pszSound, HMODULE16 hmod, DWORD fdwSound)
 281 {
 282     BOOL16      retv;
 283     DWORD       lc;
 284
 285     if ((fdwSound & SND_RESOURCE) == SND_RESOURCE)
 286     {
 287         HGLOBAL16 handle;
 288         HRSRC16 res;
 289
 290         if (!(res = FindResource16( hmod, pszSound, "WAVE" ))) return FALSE;
 291         if (!(handle = LoadResource16( hmod, res ))) return FALSE;
 292         pszSound = LockResource16(handle);
 293         fdwSound = (fdwSound & ~SND_RESOURCE) | SND_MEMORY;
 294         /* FIXME: FreeResource16 */
 295     }
 296
 297     ReleaseThunkLock(&lc);
 298     retv = PlaySoundA(pszSound, 0, fdwSound);
 299     RestoreThunkLock(lc);
 300
 301     return retv;
 302 }
 303
 304 /**************************************************************************
 305  *                              sndPlaySound            [MMSYSTEM.2]
 306  */
 307 BOOL16 WINAPI sndPlaySound16(LPCSTR lpszSoundName, UINT16 uFlags)
 308 {
 309     BOOL16      retv;
 310     DWORD       lc;
 311
 312     ReleaseThunkLock(&lc);
 313     retv = sndPlaySoundA(lpszSoundName, uFlags);
 314     RestoreThunkLock(lc);
 315
 316     return retv;
 317 }
 318
 319 /* ###################################################
 320  * #                    MISC                         #
 321  * ###################################################
 322  */
 323
 324 /**************************************************************************
 325  *                              mmsystemGetVersion      [MMSYSTEM.5]
 326  *
 327  */
 328 UINT16 WINAPI mmsystemGetVersion16(void)
 329 {
 330     return mmsystemGetVersion();
 331 }
 332
 333 /**************************************************************************
 334  *                              DriverCallback                  [MMSYSTEM.31]
 335  */
 336 BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HDRVR16 hDev,
 337                                WORD wMsg, DWORD dwUser, DWORD dwParam1,
 338                                DWORD dwParam2)
 339 {
 340     return DriverCallback(dwCallBack, uFlags, HDRVR_32(hDev), wMsg, dwUser, dwParam1, dwParam2);
 341 }
 342
 343 /**************************************************************************
 344  *                      OutputDebugStr          [MMSYSTEM.30]
 345  */
 346 void WINAPI OutputDebugStr16(LPCSTR str)
 347 {
 348     OutputDebugStringA( str );
 349 }
 350
 351 /* ###################################################
 352  * #                    MIXER                        #
 353  * ###################################################
 354  */
 355
 356 /**************************************************************************
 357  *      Mixer devices. New to Win95
 358  */
 359
 360 /**************************************************************************
 361  *                              mixerGetNumDevs                 [MMSYSTEM.800]
 362  */
 363 UINT16 WINAPI mixerGetNumDevs16(void)
 364 {
 365     return mixerGetNumDevs();
 366 }
 367
 368 /**************************************************************************
 369  *                              mixerGetDevCaps                 [MMSYSTEM.801]
 370  */
 371 UINT16 WINAPI mixerGetDevCaps16(UINT16 uDeviceID, LPMIXERCAPS16 lpCaps,
 372                                 UINT16 uSize)
 373 {
 374     MIXERCAPSA  micA;
 375     UINT        ret;
 376
 377     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 378
 379     ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA));
 380     if (ret == MMSYSERR_NOERROR) {
 381         MIXERCAPS16 mic16;
 382         mic16.wMid           = micA.wMid;
 383         mic16.wPid           = micA.wPid;
 384         mic16.vDriverVersion = micA.vDriverVersion;
 385         strcpy(mic16.szPname, micA.szPname);
 386         mic16.fdwSupport     = micA.fdwSupport;
 387         mic16.cDestinations  = micA.cDestinations;
 388         memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
 389     }
 390     return ret;
 391 }
 392
 393 /**************************************************************************
 394  *                              mixerOpen                       [MMSYSTEM.802]
 395  */
 396 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
 397                           DWORD dwInstance, DWORD fdwOpen)
 398 {
 399     HMIXER                      hmix;
 400     UINT                        ret;
 401     struct mmsystdrv_thunk*     thunk;
 402
 403     if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, fdwOpen, MMSYSTDRV_MIXER)))
 404     {
 405         return MMSYSERR_NOMEM;
 406     }
 407     if ((fdwOpen & CALLBACK_TYPEMASK) != CALLBACK_NULL)
 408         fdwOpen = (fdwOpen & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
 409     ret = mixerOpen(&hmix, uDeviceID, (DWORD)thunk, dwInstance, fdwOpen);
 410     if (ret == MMSYSERR_NOERROR)
 411     {
 412         if (lphmix) *lphmix = HMIXER_16(hmix);
 413         if (thunk) MMSYSTDRV_SetHandle(thunk, hmix);
 414     }
 415     else MMSYSTDRV_DeleteThunk(thunk);
 416     return ret;
 417 }
 418
 419 /**************************************************************************
 420  *                              mixerClose                      [MMSYSTEM.803]
 421  */
 422 UINT16 WINAPI mixerClose16(HMIXER16 hMix)
 423 {
 424     UINT        ret = mixerClose(HMIXER_32(hMix));
 425
 426     if (ret == MMSYSERR_NOERROR)
 427         MMSYSTDRV_CloseHandle((void*)HMIXER_32(hMix));
 428     return ret;
 429 }
 430
 431 /**************************************************************************
 432  *                              mixerGetID (MMSYSTEM.806)
 433  */
 434 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
 435 {
 436     UINT        xid;
 437     UINT        ret = mixerGetID(HMIXEROBJ_32(hmix), &xid, fdwID);
 438
 439     if (lpid)
 440         *lpid = xid;
 441     return ret;
 442 }
 443
 444 /**************************************************************************
 445  *                              mixerGetControlDetails  [MMSYSTEM.808]
 446  */
 447 UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,
 448                                        LPMIXERCONTROLDETAILS16 lpmcd,
 449                                        DWORD fdwDetails)
 450 {
 451     DWORD       ret = MMSYSERR_NOTENABLED;
 452     SEGPTR      sppaDetails;
 453
 454     TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
 455
 456     if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
 457         return MMSYSERR_INVALPARAM;
 458
 459     sppaDetails = (SEGPTR)lpmcd->paDetails;
 460     lpmcd->paDetails = MapSL(sppaDetails);
 461     ret = mixerGetControlDetailsA(HMIXEROBJ_32(hmix),
 462                                  (LPMIXERCONTROLDETAILS)lpmcd, fdwDetails);
 463     lpmcd->paDetails = (LPVOID)sppaDetails;
 464
 465     return ret;
 466 }
 467
 468 /**************************************************************************
 469  *                              mixerGetLineControls            [MMSYSTEM.807]
 470  */
 471 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,
 472                                      LPMIXERLINECONTROLS16 lpmlc16,
 473                                      DWORD fdwControls)
 474 {
 475     MIXERLINECONTROLSA  mlcA;
 476     DWORD               ret;
 477     unsigned int        i;
 478     LPMIXERCONTROL16    lpmc16;
 479
 480     TRACE("(%04x, %p, %08x)\n", hmix, lpmlc16, fdwControls);
 481
 482     if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) ||
 483         lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16))
 484         return MMSYSERR_INVALPARAM;
 485
 486     mlcA.cbStruct = sizeof(mlcA);
 487     mlcA.dwLineID = lpmlc16->dwLineID;
 488     mlcA.u.dwControlID = lpmlc16->u.dwControlID;
 489     mlcA.u.dwControlType = lpmlc16->u.dwControlType;
 490     mlcA.cControls = lpmlc16->cControls;
 491     mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
 492     mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
 493                               mlcA.cControls * mlcA.cbmxctrl);
 494
 495     ret = mixerGetLineControlsA(HMIXEROBJ_32(hmix), &mlcA, fdwControls);
 496
 497     if (ret == MMSYSERR_NOERROR) {
 498         lpmlc16->dwLineID = mlcA.dwLineID;
 499         lpmlc16->u.dwControlID = mlcA.u.dwControlID;
 500         lpmlc16->u.dwControlType = mlcA.u.dwControlType;
 501         lpmlc16->cControls = mlcA.cControls;
 502
 503         lpmc16 = MapSL(lpmlc16->pamxctrl);
 504
 505         for (i = 0; i < mlcA.cControls; i++) {
 506             lpmc16[i].cbStruct = sizeof(MIXERCONTROL16);
 507             lpmc16[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
 508             lpmc16[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
 509             lpmc16[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
 510             lpmc16[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
 511             strcpy(lpmc16[i].szShortName, mlcA.pamxctrl[i].szShortName);
 512             strcpy(lpmc16[i].szName, mlcA.pamxctrl[i].szName);
 513             /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
 514             memcpy(&lpmc16[i].Bounds, &mlcA.pamxctrl[i].Bounds,
 515                    sizeof(mlcA.pamxctrl[i].Bounds));
 516             /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
 517             memcpy(&lpmc16[i].Metrics, &mlcA.pamxctrl[i].Metrics,
 518                    sizeof(mlcA.pamxctrl[i].Metrics));
 519         }
 520     }
 521
 522     HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
 523
 524     return ret;
 525 }
 526
 527 /**************************************************************************
 528  *                              mixerGetLineInfo        [MMSYSTEM.805]
 529  */
 530 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
 531                                  DWORD fdwInfo)
 532 {
 533     MIXERLINEA          mliA;
 534     UINT                ret;
 535
 536     TRACE("(%04x, %p, %08x)\n", hmix, lpmli16, fdwInfo);
 537
 538     if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16))
 539         return MMSYSERR_INVALPARAM;
 540
 541     mliA.cbStruct = sizeof(mliA);
 542     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
 543     case MIXER_GETLINEINFOF_COMPONENTTYPE:
 544         mliA.dwComponentType = lpmli16->dwComponentType;
 545         break;
 546     case MIXER_GETLINEINFOF_DESTINATION:
 547         mliA.dwDestination = lpmli16->dwDestination;
 548         break;
 549     case MIXER_GETLINEINFOF_LINEID:
 550         mliA.dwLineID = lpmli16->dwLineID;
 551         break;
 552     case MIXER_GETLINEINFOF_SOURCE:
 553         mliA.dwDestination = lpmli16->dwDestination;
 554         mliA.dwSource = lpmli16->dwSource;
 555         break;
 556     case MIXER_GETLINEINFOF_TARGETTYPE:
 557         mliA.Target.dwType = lpmli16->Target.dwType;
 558         mliA.Target.wMid = lpmli16->Target.wMid;
 559         mliA.Target.wPid = lpmli16->Target.wPid;
 560         mliA.Target.vDriverVersion = lpmli16->Target.vDriverVersion;
 561         strcpy(mliA.Target.szPname, lpmli16->Target.szPname);
 562         break;
 563     default:
 564         FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo);
 565     }
 566
 567     ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo);
 568
 569     lpmli16->dwDestination      = mliA.dwDestination;
 570     lpmli16->dwSource           = mliA.dwSource;
 571     lpmli16->dwLineID           = mliA.dwLineID;
 572     lpmli16->fdwLine            = mliA.fdwLine;
 573     lpmli16->dwUser             = mliA.dwUser;
 574     lpmli16->dwComponentType    = mliA.dwComponentType;
 575     lpmli16->cChannels          = mliA.cChannels;
 576     lpmli16->cConnections       = mliA.cConnections;
 577     lpmli16->cControls          = mliA.cControls;
 578     strcpy(lpmli16->szShortName, mliA.szShortName);
 579     strcpy(lpmli16->szName, mliA.szName);
 580     lpmli16->Target.dwType      = mliA.Target.dwType;
 581     lpmli16->Target.dwDeviceID  = mliA.Target.dwDeviceID;
 582     lpmli16->Target.wMid        = mliA.Target.wMid;
 583     lpmli16->Target.wPid        = mliA.Target.wPid;
 584     lpmli16->Target.vDriverVersion = mliA.Target.vDriverVersion;
 585     strcpy(lpmli16->Target.szPname, mliA.Target.szPname);
 586
 587     return ret;
 588 }
 589
 590 /**************************************************************************
 591  *                              mixerSetControlDetails  [MMSYSTEM.809]
 592  */
 593 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,
 594                                        LPMIXERCONTROLDETAILS16 lpmcd,
 595                                        DWORD fdwDetails)
 596 {
 597     TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
 598     return MMSYSERR_NOTENABLED;
 599 }
 600
 601 /**************************************************************************
 602  *                              mixerMessage            [MMSYSTEM.804]
 603  */
 604 DWORD WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1,
 605                              DWORD dwParam2)
 606 {
 607     return mixerMessage(HMIXER_32(hmix), uMsg, dwParam1, dwParam2);
 608 }
 609
 610 /* ###################################################
 611  * #                     AUX                         #
 612  * ###################################################
 613  */
 614
 615 /**************************************************************************
 616  *                              auxGetNumDevs           [MMSYSTEM.350]
 617  */
 618 UINT16 WINAPI auxGetNumDevs16(void)
 619 {
 620     return auxGetNumDevs();
 621 }
 622
 623 /**************************************************************************
 624  *                              auxGetDevCaps           [MMSYSTEM.351]
 625  */
 626 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
 627 {
 628     AUXCAPSA  acA;
 629     UINT      ret;
 630
 631     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 632
 633     ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
 634     if (ret == MMSYSERR_NOERROR) {
 635         AUXCAPS16 ac16;
 636         ac16.wMid           = acA.wMid;
 637         ac16.wPid           = acA.wPid;
 638         ac16.vDriverVersion = acA.vDriverVersion;
 639         strcpy(ac16.szPname, acA.szPname);
 640         ac16.wTechnology    = acA.wTechnology;
 641         ac16.dwSupport      = acA.dwSupport;
 642         memcpy(lpCaps, &ac16, min(uSize, sizeof(ac16)));
 643     }
 644     return ret;
 645 }
 646
 647 /**************************************************************************
 648  *                              auxGetVolume            [MMSYSTEM.352]
 649  */
 650 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume)
 651 {
 652     return auxGetVolume(uDeviceID, lpdwVolume);
 653 }
 654
 655 /**************************************************************************
 656  *                              auxSetVolume            [MMSYSTEM.353]
 657  */
 658 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
 659 {
 660     return auxSetVolume(uDeviceID, dwVolume);
 661 }
 662
 663 /**************************************************************************
 664  *                              auxOutMessage           [MMSYSTEM.354]
 665  */
 666 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
 667 {
 668     TRACE("(%04X, %04X, %08X, %08X)\n", uDeviceID, uMessage, dw1, dw2);
 669
 670     switch (uMessage) {
 671     case AUXDM_GETNUMDEVS:
 672     case AUXDM_SETVOLUME:
 673         /* no argument conversion needed */
 674         break;
 675     case AUXDM_GETVOLUME:
 676         return auxGetVolume(uDeviceID, MapSL(dw1));
 677     case AUXDM_GETDEVCAPS:
 678         return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2);
 679     default:
 680         TRACE("(%04x, %04x, %08x, %08x): unhandled message\n",
 681               uDeviceID, uMessage, dw1, dw2);
 682         break;
 683     }
 684     return auxOutMessage(uDeviceID, uMessage, dw1, dw2);
 685 }
 686
 687 /* ###################################################
 688  * #                     MIDI                        #
 689  * ###################################################
 690  */
 691
 692 /**************************************************************************
 693  *                              midiOutGetNumDevs       [MMSYSTEM.201]
 694  */
 695 UINT16 WINAPI midiOutGetNumDevs16(void)
 696 {
 697     return midiOutGetNumDevs();
 698 }
 699
 700 /**************************************************************************
 701  *                              midiOutGetDevCaps       [MMSYSTEM.202]
 702  */
 703 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps,
 704                                   UINT16 uSize)
 705 {
 706     MIDIOUTCAPSA        mocA;
 707     UINT                ret;
 708
 709     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 710
 711     ret = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(mocA));
 712     if (ret == MMSYSERR_NOERROR) {
 713         MIDIOUTCAPS16 moc16;
 714         moc16.wMid            = mocA.wMid;
 715         moc16.wPid            = mocA.wPid;
 716         moc16.vDriverVersion  = mocA.vDriverVersion;
 717         strcpy(moc16.szPname, mocA.szPname);
 718         moc16.wTechnology     = mocA.wTechnology;
 719         moc16.wVoices         = mocA.wVoices;
 720         moc16.wNotes          = mocA.wNotes;
 721         moc16.wChannelMask    = mocA.wChannelMask;
 722         moc16.dwSupport       = mocA.dwSupport;
 723         memcpy(lpCaps, &moc16, min(uSize, sizeof(moc16)));
 724     }
 725     return ret;
 726  }
 727
 728 /**************************************************************************
 729  *                              midiOutGetErrorText     [MMSYSTEM.203]
 730  *                              midiInGetErrorText      [MMSYSTEM.303]
 731  */
 732 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
 733 {
 734     return midiOutGetErrorTextA(uError, lpText, uSize);
 735 }
 736
 737 /**************************************************************************
 738  *                              midiOutOpen             [MMSYSTEM.204]
 739  */
 740 UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
 741                             DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
 742 {
 743     HMIDIOUT                    hmo;
 744     UINT                        ret;
 745     struct mmsystdrv_thunk*     thunk;
 746
 747     if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_MIDIOUT)))
 748     {
 749         return MMSYSERR_NOMEM;
 750     }
 751     if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
 752         dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
 753     ret = midiOutOpen(&hmo, uDeviceID, (DWORD)thunk, dwInstance, dwFlags);
 754     if (ret == MMSYSERR_NOERROR)
 755     {
 756         if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo);
 757         MMSYSTDRV_SetHandle(thunk, (void*)hmo);
 758     }
 759     else MMSYSTDRV_DeleteThunk(thunk);
 760     return ret;
 761 }
 762
 763 /**************************************************************************
 764  *                              midiOutClose            [MMSYSTEM.205]
 765  */
 766 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
 767 {
 768     UINT        ret = midiOutClose(HMIDIOUT_32(hMidiOut));
 769
 770     if (ret == MMSYSERR_NOERROR)
 771         MMSYSTDRV_CloseHandle((void*)HMIDIOUT_32(hMidiOut));
 772     return ret;
 773 }
 774
 775 /**************************************************************************
 776  *                              midiOutPrepareHeader    [MMSYSTEM.206]
 777  */
 778 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
 779                                      SEGPTR lpsegMidiOutHdr,      /* [???] */
 780                                      UINT16 uSize)                /* [in] */
 781 {
 782     TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
 783
 784     return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_PREPARE, lpsegMidiOutHdr, uSize);
 785 }
 786
 787 /**************************************************************************
 788  *                              midiOutUnprepareHeader  [MMSYSTEM.207]
 789  */
 790 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
 791                                        SEGPTR lpsegMidiOutHdr,      /* [???] */
 792                                        UINT16 uSize)                /* [in] */
 793 {
 794     LPMIDIHDR16         lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
 795
 796     TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
 797
 798     if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
 799         return MMSYSERR_NOERROR;
 800     }
 801
 802     return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_UNPREPARE, lpsegMidiOutHdr, uSize);
 803 }
 804
 805 /**************************************************************************
 806  *                              midiOutShortMsg         [MMSYSTEM.208]
 807  */
 808 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
 809 {
 810     return midiOutShortMsg(HMIDIOUT_32(hMidiOut), dwMsg);
 811 }
 812
 813 /**************************************************************************
 814  *                              midiOutLongMsg          [MMSYSTEM.209]
 815  */
 816 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,          /* [in] */
 817                                LPMIDIHDR16 lpsegMidiOutHdr,  /* [???] NOTE: SEGPTR */
 818                                UINT16 uSize)                 /* [in] */
 819 {
 820     TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
 821
 822     return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize);
 823 }
 824
 825 /**************************************************************************
 826  *                              midiOutReset            [MMSYSTEM.210]
 827  */
 828 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
 829 {
 830     return midiOutReset(HMIDIOUT_32(hMidiOut));
 831 }
 832
 833 /**************************************************************************
 834  *                              midiOutGetVolume        [MMSYSTEM.211]
 835  */
 836 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
 837 {
 838     return midiOutGetVolume(HMIDIOUT_32(uDeviceID), lpdwVolume);
 839 }
 840
 841 /**************************************************************************
 842  *                              midiOutSetVolume        [MMSYSTEM.212]
 843  */
 844 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
 845 {
 846     return midiOutSetVolume(HMIDIOUT_32(uDeviceID), dwVolume);
 847 }
 848
 849 /**************************************************************************
 850  *                              midiOutCachePatches             [MMSYSTEM.213]
 851  */
 852 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
 853                                     WORD* lpwPatchArray, UINT16 uFlags)
 854 {
 855     return midiOutCachePatches(HMIDIOUT_32(hMidiOut), uBank, lpwPatchArray,
 856                                uFlags);
 857 }
 858
 859 /**************************************************************************
 860  *                              midiOutCacheDrumPatches [MMSYSTEM.214]
 861  */
 862 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
 863                                         WORD* lpwKeyArray, UINT16 uFlags)
 864 {
 865     return midiOutCacheDrumPatches(HMIDIOUT_32(hMidiOut), uPatch, lpwKeyArray, uFlags);
 866 }
 867
 868 /**************************************************************************
 869  *                              midiOutGetID            [MMSYSTEM.215]
 870  */
 871 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
 872 {
 873     UINT        devid;
 874     UINT16      ret;
 875
 876     ret = midiOutGetID(HMIDIOUT_32(hMidiOut), &devid);
 877     if (ret != MMSYSERR_NOERROR) return ret;
 878     *lpuDeviceID = devid;
 879     return ret;
 880 }
 881
 882 /**************************************************************************
 883  *                              midiOutMessage          [MMSYSTEM.216]
 884  */
 885 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
 886                               DWORD dwParam1, DWORD dwParam2)
 887 {
 888     TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
 889
 890     switch (uMessage) {
 891     case MODM_OPEN:
 892     case MODM_CLOSE:
 893         FIXME("can't handle OPEN or CLOSE message!\n");
 894         return MMSYSERR_NOTSUPPORTED;
 895
 896     case MODM_GETVOLUME:
 897         return midiOutGetVolume16(hMidiOut, MapSL(dwParam1));
 898     case MODM_LONGDATA:
 899         return midiOutLongMsg16(hMidiOut, MapSL(dwParam1), dwParam2);
 900     case MODM_PREPARE:
 901         /* lpMidiOutHdr is still a segmented pointer for this function */
 902         return midiOutPrepareHeader16(hMidiOut, dwParam1, dwParam2);
 903     case MODM_UNPREPARE:
 904         return midiOutUnprepareHeader16(hMidiOut, dwParam1, dwParam2);
 905     }
 906     return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), uMessage, dwParam1, dwParam2);
 907 }
 908
 909 /**************************************************************************
 910  *                              midiInGetNumDevs        [MMSYSTEM.301]
 911  */
 912 UINT16 WINAPI midiInGetNumDevs16(void)
 913 {
 914     return midiInGetNumDevs();
 915 }
 916
 917 /**************************************************************************
 918  *                              midiInGetDevCaps        [MMSYSTEM.302]
 919  */
 920 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps,
 921                                  UINT16 uSize)
 922 {
 923     MIDIINCAPSA         micA;
 924     UINT                ret;
 925
 926     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 927
 928     ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
 929     if (ret == MMSYSERR_NOERROR) {
 930         MIDIINCAPS16 mic16;
 931         mic16.wMid           = micA.wMid;
 932         mic16.wPid           = micA.wPid;
 933         mic16.vDriverVersion = micA.vDriverVersion;
 934         strcpy(mic16.szPname, micA.szPname);
 935         mic16.dwSupport      = micA.dwSupport;
 936         memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
 937     }
 938     return ret;
 939 }
 940
 941 /**************************************************************************
 942  *                              midiInOpen              [MMSYSTEM.304]
 943  */
 944 UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
 945                            DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
 946 {
 947     HMIDIIN     hmid;
 948     UINT        ret;
 949     struct mmsystdrv_thunk*     thunk;
 950
 951     if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_MIDIIN)))
 952     {
 953         return MMSYSERR_NOMEM;
 954     }
 955     if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
 956         dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
 957     ret = midiInOpen(&hmid, uDeviceID, (DWORD)thunk, dwInstance, dwFlags);
 958     if (ret == MMSYSERR_NOERROR)
 959     {
 960         if (lphMidiIn) *lphMidiIn = HMIDIIN_16(hmid);
 961         MMSYSTDRV_SetHandle(thunk, (void*)hmid);
 962     }
 963     else MMSYSTDRV_DeleteThunk(thunk);
 964     return ret;
 965 }
 966
 967 /**************************************************************************
 968  *                              midiInClose             [MMSYSTEM.305]
 969  */
 970 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
 971 {
 972     UINT        ret = midiInClose(HMIDIIN_32(hMidiIn));
 973
 974     if (ret == MMSYSERR_NOERROR)
 975         MMSYSTDRV_CloseHandle((void*)HMIDIIN_32(hMidiIn));
 976     return ret;
 977 }
 978
 979 /**************************************************************************
 980  *                              midiInPrepareHeader     [MMSYSTEM.306]
 981  */
 982 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
 983                                     SEGPTR lpsegMidiInHdr,     /* [???] */
 984                                     UINT16 uSize)              /* [in] */
 985 {
 986     TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
 987
 988     return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_PREPARE, lpsegMidiInHdr, uSize);
 989 }
 990
 991 /**************************************************************************
 992  *                              midiInUnprepareHeader   [MMSYSTEM.307]
 993  */
 994 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
 995                                       SEGPTR lpsegMidiInHdr,     /* [???] */
 996                                       UINT16 uSize)              /* [in] */
 997 {
 998     LPMIDIHDR16         lpMidiInHdr = MapSL(lpsegMidiInHdr);
 999
1000     TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
1001
1002     if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
1003         return MMSYSERR_NOERROR;
1004     }
1005
1006     return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_UNPREPARE, lpsegMidiInHdr, uSize);
1007 }
1008
1009 /**************************************************************************
1010  *                              midiInAddBuffer         [MMSYSTEM.308]
1011  */
1012 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,         /* [in] */
1013                                 MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
1014                                 UINT16 uSize)              /* [in] */
1015 {
1016     TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
1017
1018     return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize);
1019 }
1020
1021 /**************************************************************************
1022  *                              midiInStart                     [MMSYSTEM.309]
1023  */
1024 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
1025 {
1026     return midiInStart(HMIDIIN_32(hMidiIn));
1027 }
1028
1029 /**************************************************************************
1030  *                              midiInStop                      [MMSYSTEM.310]
1031  */
1032 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
1033 {
1034     return midiInStop(HMIDIIN_32(hMidiIn));
1035 }
1036
1037 /**************************************************************************
1038  *                              midiInReset                     [MMSYSTEM.311]
1039  */
1040 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
1041 {
1042     return midiInReset(HMIDIIN_32(hMidiIn));
1043 }
1044
1045 /**************************************************************************
1046  *                              midiInGetID                     [MMSYSTEM.312]
1047  */
1048 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
1049 {
1050     UINT        devid;
1051     UINT16      ret;
1052
1053     ret = midiInGetID(HMIDIIN_32(hMidiIn), &devid);
1054     if (ret != MMSYSERR_NOERROR) return ret;
1055     *lpuDeviceID = devid;
1056     return ret;
1057 }
1058
1059 /**************************************************************************
1060  *                              midiInMessage           [MMSYSTEM.313]
1061  */
1062 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
1063                              DWORD dwParam1, DWORD dwParam2)
1064 {
1065     TRACE("(%04X, %04X, %08X, %08X)\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     return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), uMessage, dwParam1, dwParam2);
1083 }
1084
1085 /**************************************************************************
1086  *                              midiStreamClose                 [MMSYSTEM.252]
1087  */
1088 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
1089 {
1090     UINT        ret = midiStreamClose(HMIDISTRM_32(hMidiStrm));
1091     if (ret == MMSYSERR_NOERROR)
1092         MMSYSTDRV_CloseHandle((void*)HMIDISTRM_32(hMidiStrm));
1093     return ret;
1094 }
1095
1096 /**************************************************************************
1097  *                              midiStreamOpen                  [MMSYSTEM.251]
1098  */
1099 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
1100                                    DWORD cMidi, DWORD dwCallback,
1101                                    DWORD dwInstance, DWORD fdwOpen)
1102 {
1103     HMIDISTRM                   hMidiStrm32;
1104     MMRESULT                    ret;
1105     UINT                        devid32;
1106     struct mmsystdrv_thunk*     thunk;
1107
1108     if (!phMidiStrm || !devid)
1109         return MMSYSERR_INVALPARAM;
1110     devid32 = *devid;
1111
1112     if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, fdwOpen, MMSYSTDRV_MIDIOUT)))
1113     {
1114         return MMSYSERR_NOMEM;
1115     }
1116     if ((fdwOpen & CALLBACK_TYPEMASK) != CALLBACK_NULL)
1117         fdwOpen = (fdwOpen & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
1118     ret = midiStreamOpen(&hMidiStrm32, &devid32, cMidi, (DWORD)thunk, dwInstance, fdwOpen);
1119     if (ret == MMSYSERR_NOERROR)
1120     {
1121         *phMidiStrm = HMIDISTRM_16(hMidiStrm32);
1122         *devid = devid32;
1123         MMSYSTDRV_SetHandle(thunk, hMidiStrm32);
1124     }
1125     else MMSYSTDRV_DeleteThunk(thunk);
1126     return ret;
1127 }
1128
1129 /**************************************************************************
1130  *                              midiStreamOut                   [MMSYSTEM.254]
1131  */
1132 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hMidiStrm, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr)
1133 {
1134     return midiStreamOut(HMIDISTRM_32(hMidiStrm), (LPMIDIHDR)lpMidiHdr,
1135                          cbMidiHdr);
1136 }
1137
1138 /**************************************************************************
1139  *                              midiStreamPause                 [MMSYSTEM.255]
1140  */
1141 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hMidiStrm)
1142 {
1143     return midiStreamPause(HMIDISTRM_32(hMidiStrm));
1144 }
1145
1146 /**************************************************************************
1147  *                              midiStreamPosition              [MMSYSTEM.253]
1148  */
1149 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hMidiStrm, LPMMTIME16 lpmmt16, UINT16 cbmmt)
1150 {
1151     MMTIME      mmt32;
1152     MMRESULT    ret;
1153
1154     if (!lpmmt16)
1155         return MMSYSERR_INVALPARAM;
1156     MMSYSTEM_MMTIME16to32(&mmt32, lpmmt16);
1157     ret = midiStreamPosition(HMIDISTRM_32(hMidiStrm), &mmt32, sizeof(MMTIME));
1158     MMSYSTEM_MMTIME32to16(lpmmt16, &mmt32);
1159     return ret;
1160 }
1161
1162 /**************************************************************************
1163  *                              midiStreamProperty              [MMSYSTEM.250]
1164  */
1165 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
1166 {
1167     return midiStreamProperty(HMIDISTRM_32(hMidiStrm), lpPropData, dwProperty);
1168 }
1169
1170 /**************************************************************************
1171  *                              midiStreamRestart               [MMSYSTEM.256]
1172  */
1173 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hMidiStrm)
1174 {
1175     return midiStreamRestart(HMIDISTRM_32(hMidiStrm));
1176 }
1177
1178 /**************************************************************************
1179  *                              midiStreamStop                  [MMSYSTEM.257]
1180  */
1181 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hMidiStrm)
1182 {
1183     return midiStreamStop(HMIDISTRM_32(hMidiStrm));
1184 }
1185
1186 /* ###################################################
1187  * #                     WAVE                        #
1188  * ###################################################
1189  */
1190
1191 /**************************************************************************
1192  *                              waveOutGetNumDevs               [MMSYSTEM.401]
1193  */
1194 UINT16 WINAPI waveOutGetNumDevs16(void)
1195 {
1196     return waveOutGetNumDevs();
1197 }
1198
1199 /**************************************************************************
1200  *                              waveOutGetDevCaps               [MMSYSTEM.402]
1201  */
1202 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID,
1203                                   LPWAVEOUTCAPS16 lpCaps, UINT16 uSize)
1204 {
1205     WAVEOUTCAPSA        wocA;
1206     UINT                ret;
1207     TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
1208
1209     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1210
1211     ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA));
1212     if (ret == MMSYSERR_NOERROR) {
1213         WAVEOUTCAPS16 woc16;
1214         woc16.wMid           = wocA.wMid;
1215         woc16.wPid           = wocA.wPid;
1216         woc16.vDriverVersion = wocA.vDriverVersion;
1217         strcpy(woc16.szPname, wocA.szPname);
1218         woc16.dwFormats      = wocA.dwFormats;
1219         woc16.wChannels      = wocA.wChannels;
1220         woc16.dwSupport      = wocA.dwSupport;
1221         memcpy(lpCaps, &woc16, min(uSize, sizeof(woc16)));
1222     }
1223     return ret;
1224 }
1225
1226 /**************************************************************************
1227  *                              waveOutGetErrorText     [MMSYSTEM.403]
1228  *                              waveInGetErrorText      [MMSYSTEM.503]
1229  */
1230 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
1231 {
1232     return waveOutGetErrorTextA(uError, lpText, uSize);
1233 }
1234
1235 /**************************************************************************
1236  *                      waveOutOpen                     [MMSYSTEM.404]
1237  */
1238 UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
1239                             LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
1240                             DWORD dwInstance, DWORD dwFlags)
1241 {
1242     HWAVEOUT                    hWaveOut;
1243     UINT                        ret;
1244     struct mmsystdrv_thunk*     thunk;
1245
1246     if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_WAVEOUT)))
1247     {
1248         return MMSYSERR_NOMEM;
1249     }
1250     if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
1251         dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
1252     /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
1253      * call the 32 bit version
1254      * however, we need to promote correctly the wave mapper id
1255      * (0xFFFFFFFF and not 0x0000FFFF)
1256      */
1257     ret = waveOutOpen(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
1258                       lpFormat, (DWORD)thunk, dwInstance, dwFlags);
1259
1260     if (lphWaveOut != NULL && ret == MMSYSERR_NOERROR)
1261        *lphWaveOut = HWAVEOUT_16(hWaveOut);
1262     if (ret == MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY))
1263          MMSYSTDRV_SetHandle(thunk, (void*)hWaveOut);
1264     else MMSYSTDRV_DeleteThunk(thunk);
1265     return ret;
1266 }
1267
1268 /**************************************************************************
1269  *                              waveOutClose            [MMSYSTEM.405]
1270  */
1271 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
1272 {
1273     DWORD       level;
1274     UINT16      ret;
1275
1276     ReleaseThunkLock(&level);
1277     ret = waveOutClose(HWAVEOUT_32(hWaveOut));
1278     RestoreThunkLock(level);
1279     if (ret == MMSYSERR_NOERROR)
1280         MMSYSTDRV_CloseHandle((void*)HWAVEOUT_32(hWaveOut));
1281     return ret;
1282 }
1283
1284 /**************************************************************************
1285  *                              waveOutPrepareHeader    [MMSYSTEM.406]
1286  */
1287 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,      /* [in] */
1288                                      SEGPTR lpsegWaveOutHdr,   /* [???] */
1289                                      UINT16 uSize)             /* [in] */
1290 {
1291     LPWAVEHDR           lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
1292     UINT16              result;
1293
1294     TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
1295
1296     if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
1297
1298     if ((result = MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_PREPARE, lpsegWaveOutHdr,
1299                                     uSize)) != MMSYSERR_NOTSUPPORTED)
1300         return result;
1301
1302     if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
1303         return WAVERR_STILLPLAYING;
1304
1305     lpWaveOutHdr->dwFlags |= WHDR_PREPARED;
1306     lpWaveOutHdr->dwFlags &= ~WHDR_DONE;
1307
1308     return MMSYSERR_NOERROR;
1309 }
1310
1311 /**************************************************************************
1312  *                              waveOutUnprepareHeader  [MMSYSTEM.407]
1313  */
1314 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,       /* [in] */
1315                                        SEGPTR lpsegWaveOutHdr,    /* [???] */
1316                                        UINT16 uSize)              /* [in] */
1317 {
1318     LPWAVEHDR           lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
1319
1320     TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
1321
1322     if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
1323         return MMSYSERR_NOERROR;
1324     }
1325
1326     return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_UNPREPARE, lpsegWaveOutHdr, uSize);
1327 }
1328
1329 /**************************************************************************
1330  *                              waveOutWrite            [MMSYSTEM.408]
1331  */
1332 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut,       /* [in] */
1333                              LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
1334                              UINT16 uSize)              /* [in] */
1335 {
1336     TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
1337
1338     return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize);
1339 }
1340
1341 /**************************************************************************
1342  *                              waveOutBreakLoop        [MMSYSTEM.419]
1343  */
1344 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut16)
1345 {
1346     DWORD       level;
1347     UINT16      ret;
1348
1349     ReleaseThunkLock(&level);
1350     ret = waveOutBreakLoop(HWAVEOUT_32(hWaveOut16));
1351     RestoreThunkLock(level);
1352     return ret;
1353 }
1354
1355 /**************************************************************************
1356  *                              waveOutPause            [MMSYSTEM.409]
1357  */
1358 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut16)
1359 {
1360     DWORD       level;
1361     UINT16      ret;
1362
1363     ReleaseThunkLock(&level);
1364     ret = waveOutPause(HWAVEOUT_32(hWaveOut16));
1365     RestoreThunkLock(level);
1366     return ret;
1367 }
1368
1369 /**************************************************************************
1370  *                              waveOutReset            [MMSYSTEM.411]
1371  */
1372 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut16)
1373 {
1374     DWORD       level;
1375     UINT16      ret;
1376
1377     ReleaseThunkLock(&level);
1378     ret = waveOutReset(HWAVEOUT_32(hWaveOut16));
1379     RestoreThunkLock(level);
1380     return ret;
1381 }
1382
1383 /**************************************************************************
1384  *                              waveOutRestart  [MMSYSTEM.410]
1385  */
1386 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut16)
1387 {
1388     DWORD       level;
1389     UINT16      ret;
1390
1391     ReleaseThunkLock(&level);
1392     ret = waveOutRestart(HWAVEOUT_32(hWaveOut16));
1393     RestoreThunkLock(level);
1394     return ret;
1395 }
1396
1397 /**************************************************************************
1398  *                              waveOutGetPosition      [MMSYSTEM.412]
1399  */
1400 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
1401                                    UINT16 uSize)
1402 {
1403     UINT        ret;
1404     MMTIME      mmt;
1405
1406     mmt.wType = lpTime->wType;
1407     ret = waveOutGetPosition(HWAVEOUT_32(hWaveOut), &mmt, sizeof(mmt));
1408     MMSYSTEM_MMTIME32to16(lpTime, &mmt);
1409     return ret;
1410 }
1411
1412 /**************************************************************************
1413  *                              waveOutGetPitch         [MMSYSTEM.413]
1414  */
1415 UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
1416 {
1417     return waveOutGetPitch(HWAVEOUT_32(hWaveOut16), lpdw);
1418 }
1419
1420 /**************************************************************************
1421  *                              waveOutSetPitch         [MMSYSTEM.414]
1422  */
1423 UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16 hWaveOut16, DWORD dw)
1424 {
1425     return waveOutSetPitch(HWAVEOUT_32(hWaveOut16), dw);
1426 }
1427
1428 /**************************************************************************
1429  *                              waveOutGetPlaybackRate  [MMSYSTEM.417]
1430  */
1431 UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
1432 {
1433     return waveOutGetPlaybackRate(HWAVEOUT_32(hWaveOut16), lpdw);
1434 }
1435
1436 /**************************************************************************
1437  *                              waveOutSetPlaybackRate  [MMSYSTEM.418]
1438  */
1439 UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16 hWaveOut16, DWORD dw)
1440 {
1441     return waveOutSetPlaybackRate(HWAVEOUT_32(hWaveOut16), dw);
1442 }
1443
1444 /**************************************************************************
1445  *                              waveOutGetVolume        [MMSYSTEM.415]
1446  */
1447 UINT16 WINAPI waveOutGetVolume16(UINT16 devid, LPDWORD lpdw)
1448 {
1449     return waveOutGetVolume(HWAVEOUT_32(devid), lpdw);
1450 }
1451
1452 /**************************************************************************
1453  *                              waveOutSetVolume        [MMSYSTEM.416]
1454  */
1455 UINT16 WINAPI waveOutSetVolume16(UINT16 devid, DWORD dw)
1456 {
1457     return waveOutSetVolume(HWAVEOUT_32(devid), dw);
1458 }
1459
1460 /**************************************************************************
1461  *                              waveOutGetID            [MMSYSTEM.420]
1462  */
1463 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
1464 {
1465     UINT        devid;
1466     UINT16      ret;
1467
1468     ret = waveOutGetID(HWAVEOUT_32(hWaveOut), &devid);
1469     if (ret != MMSYSERR_NOERROR) return ret;
1470     *lpuDeviceID = devid;
1471     return ret;
1472 }
1473
1474 /**************************************************************************
1475  *                              waveOutMessage          [MMSYSTEM.421]
1476  */
1477 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
1478                               DWORD dwParam1, DWORD dwParam2)
1479 {
1480     TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
1481
1482     if ((DWORD_PTR)hWaveOut < waveOutGetNumDevs())
1483     {
1484         if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
1485             dwParam1 = (DWORD)MapSL(dwParam1);
1486     }
1487     else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
1488         /* from M$ KB */
1489         return MMSYSERR_INVALPARAM;
1490
1491     return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), uMessage, dwParam1, dwParam2);
1492 }
1493
1494 /**************************************************************************
1495  *                              waveInGetNumDevs                [MMSYSTEM.501]
1496  */
1497 UINT16 WINAPI waveInGetNumDevs16(void)
1498 {
1499     return waveInGetNumDevs();
1500 }
1501
1502 /**************************************************************************
1503  *                              waveInGetDevCaps                [MMSYSTEM.502]
1504  */
1505 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps,
1506                                  UINT16 uSize)
1507 {
1508     WAVEINCAPSA wicA;
1509     UINT        ret;
1510
1511     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1512
1513     ret = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(wicA));
1514     if (ret == MMSYSERR_NOERROR) {
1515         WAVEINCAPS16 wic16;
1516         wic16.wMid           = wicA.wMid;
1517         wic16.wPid           = wicA.wPid;
1518         wic16.vDriverVersion = wicA.vDriverVersion;
1519         strcpy(wic16.szPname, wicA.szPname);
1520         wic16.dwFormats      = wicA.dwFormats;
1521         wic16.wChannels      = wicA.wChannels;
1522         memcpy(lpCaps, &wic16, min(uSize, sizeof(wic16)));
1523     }
1524     return ret;
1525 }
1526
1527 /**************************************************************************
1528  *                              waveInOpen                      [MMSYSTEM.504]
1529  */
1530 UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
1531                            LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
1532                            DWORD dwInstance, DWORD dwFlags)
1533 {
1534     HWAVEIN                     hWaveIn;
1535     UINT                        ret;
1536     struct mmsystdrv_thunk*     thunk;
1537
1538     if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, dwFlags, MMSYSTDRV_WAVEIN)))
1539     {
1540         return MMSYSERR_NOMEM;
1541     }
1542     if ((dwFlags & CALLBACK_TYPEMASK) != CALLBACK_NULL)
1543         dwFlags = (dwFlags & ~CALLBACK_TYPEMASK) | CALLBACK_FUNCTION;
1544     /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
1545      * call the 32 bit version
1546      * however, we need to promote correctly the wave mapper id
1547      * (0xFFFFFFFF and not 0x0000FFFF)
1548      */
1549     ret = waveInOpen(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
1550                      lpFormat, (DWORD)thunk, dwInstance, dwFlags);
1551
1552     if (lphWaveIn != NULL && ret == MMSYSERR_NOERROR)
1553        *lphWaveIn = HWAVEIN_16(hWaveIn);
1554     if (ret == MMSYSERR_NOERROR && !(dwFlags & WAVE_FORMAT_QUERY))
1555          MMSYSTDRV_SetHandle(thunk, (void*)hWaveIn);
1556     else MMSYSTDRV_DeleteThunk(thunk);
1557     return ret;
1558 }
1559
1560 /**************************************************************************
1561  *                              waveInClose                     [MMSYSTEM.505]
1562  */
1563 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
1564 {
1565     DWORD       level;
1566     UINT16      ret;
1567
1568     ReleaseThunkLock(&level);
1569     ret = waveInClose(HWAVEIN_32(hWaveIn));
1570     RestoreThunkLock(level);
1571     if (ret == MMSYSERR_NOERROR)
1572         MMSYSTDRV_CloseHandle((void*)HWAVEIN_32(hWaveIn));
1573     return ret;
1574 }
1575
1576 /**************************************************************************
1577  *                              waveInPrepareHeader             [MMSYSTEM.506]
1578  */
1579 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
1580                                     SEGPTR lpsegWaveInHdr,   /* [???] */
1581                                     UINT16 uSize)            /* [in] */
1582 {
1583     LPWAVEHDR           lpWaveInHdr = MapSL(lpsegWaveInHdr);
1584     UINT16              ret;
1585
1586     TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
1587
1588     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1589     lpWaveInHdr->dwBytesRecorded = 0;
1590
1591     ret = MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_PREPARE, lpsegWaveInHdr, uSize);
1592     return ret;
1593 }
1594
1595 /**************************************************************************
1596  *                              waveInUnprepareHeader   [MMSYSTEM.507]
1597  */
1598 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
1599                                       SEGPTR lpsegWaveInHdr,   /* [???] */
1600                                       UINT16 uSize)            /* [in] */
1601 {
1602     LPWAVEHDR           lpWaveInHdr = MapSL(lpsegWaveInHdr);
1603
1604     TRACE("(%04X, %08x, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
1605
1606     if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
1607
1608     if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
1609         return MMSYSERR_NOERROR;
1610     }
1611
1612     return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_UNPREPARE, lpsegWaveInHdr, uSize);
1613 }
1614
1615 /**************************************************************************
1616  *                              waveInAddBuffer         [MMSYSTEM.508]
1617  */
1618 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,       /* [in] */
1619                                 WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
1620                                 UINT16 uSize)            /* [in] */
1621 {
1622     TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
1623
1624     if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
1625
1626     return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize);
1627 }
1628
1629 /**************************************************************************
1630  *                              waveInReset             [MMSYSTEM.511]
1631  */
1632 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn16)
1633 {
1634     DWORD       level;
1635     UINT16      ret;
1636
1637     ReleaseThunkLock(&level);
1638     ret = waveInReset(HWAVEIN_32(hWaveIn16));
1639     RestoreThunkLock(level);
1640     return ret;
1641 }
1642
1643 /**************************************************************************
1644  *                              waveInStart             [MMSYSTEM.509]
1645  */
1646 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn16)
1647 {
1648     DWORD       level;
1649     UINT16      ret;
1650
1651     ReleaseThunkLock(&level);
1652     ret = waveInStart(HWAVEIN_32(hWaveIn16));
1653     RestoreThunkLock(level);
1654     return ret;
1655 }
1656
1657 /**************************************************************************
1658  *                              waveInStop              [MMSYSTEM.510]
1659  */
1660 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn16)
1661 {
1662     DWORD       level;
1663     UINT16      ret;
1664
1665     ReleaseThunkLock(&level);
1666     ret = waveInStop(HWAVEIN_32(hWaveIn16));
1667     RestoreThunkLock(level);
1668     return ret;
1669 }
1670
1671 /**************************************************************************
1672  *                              waveInGetPosition       [MMSYSTEM.512]
1673  */
1674 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
1675                                   UINT16 uSize)
1676 {
1677     UINT        ret;
1678     MMTIME      mmt;
1679
1680     mmt.wType = lpTime->wType;
1681     ret = waveInGetPosition(HWAVEIN_32(hWaveIn), &mmt, sizeof(mmt));
1682     MMSYSTEM_MMTIME32to16(lpTime, &mmt);
1683     return ret;
1684 }
1685
1686 /**************************************************************************
1687  *                              waveInGetID                     [MMSYSTEM.513]
1688  */
1689 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
1690 {
1691     UINT        devid;
1692     UINT16      ret;
1693
1694     ret = waveInGetID(HWAVEIN_32(hWaveIn), &devid);
1695     if (ret != MMSYSERR_NOERROR) return ret;
1696     *lpuDeviceID = devid;
1697     return ret;
1698 }
1699
1700 /**************************************************************************
1701  *                              waveInMessage           [MMSYSTEM.514]
1702  */
1703 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
1704                              DWORD dwParam1, DWORD dwParam2)
1705 {
1706     TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
1707
1708     if ((DWORD_PTR)hWaveIn < waveInGetNumDevs())
1709     {
1710         if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
1711             dwParam1 = (DWORD)MapSL(dwParam1);
1712     }
1713     else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
1714         /* from M$ KB */
1715         return MMSYSERR_INVALPARAM;
1716
1717     return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), uMessage, dwParam1, dwParam2);
1718 }
1719
1720 /* ###################################################
1721  * #                     TASK                        #
1722  * ###################################################
1723  */
1724
1725 /*#define USE_MM_TSK_WINE*/
1726
1727 /**************************************************************************
1728  *                              mmTaskCreate            [MMSYSTEM.900]
1729  *
1730  * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
1731  * called upon creation with dwPmt as parameter.
1732  */
1733 HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt)
1734 {
1735     HINSTANCE16         ret;
1736     HINSTANCE16         handle;
1737     char cmdline[16];
1738     DWORD showCmd = 0x40002;
1739     LOADPARAMS16 lp;
1740
1741     TRACE("(%08x, %p, %08x);\n", spProc, lphMmTask, dwPmt);
1742     /* This to work requires NE modules to be started with a binary command line
1743      * which is not currently the case. A patch exists but has never been committed.
1744      * A workaround would be to integrate code for mmtask.tsk into Wine, but
1745      * this requires tremendous work (starting with patching tools/build to
1746      * create NE executables (and not only DLLs) for builtins modules.
1747      * EP 99/04/25
1748      */
1749     FIXME("This is currently broken. It will fail\n");
1750
1751     cmdline[0] = 0x0d;
1752     *(LPDWORD)(cmdline + 1) = (DWORD)spProc;
1753     *(LPDWORD)(cmdline + 5) = dwPmt;
1754     *(LPDWORD)(cmdline + 9) = 0;
1755
1756     lp.hEnvironment = 0;
1757     lp.cmdLine = MapLS(cmdline);
1758     lp.showCmd = MapLS(&showCmd);
1759     lp.reserved = 0;
1760
1761 #ifndef USE_MM_TSK_WINE
1762     handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", &lp);
1763 #else
1764     handle = LoadModule16("mmtask.tsk", &lp);
1765 #endif
1766     if (handle < 32) {
1767         ret = (handle) ? 1 : 2;
1768         handle = 0;
1769     } else {
1770         ret = 0;
1771     }
1772     if (lphMmTask)
1773         *lphMmTask = handle;
1774
1775     UnMapLS( lp.cmdLine );
1776     UnMapLS( lp.showCmd );
1777     TRACE("=> 0x%04x/%d\n", handle, ret);
1778     return ret;
1779 }
1780
1781 #ifdef USE_MM_TSK_WINE
1782 /* C equivalent to mmtask.tsk binary content */
1783 void    mmTaskEntryPoint16(LPSTR cmdLine, WORD di, WORD si)
1784 {
1785     int len = cmdLine[0x80];
1786
1787     if (len / 2 == 6) {
1788         void    (*fpProc)(DWORD) = MapSL(*((DWORD*)(cmdLine + 1)));
1789         DWORD   dwPmt  = *((DWORD*)(cmdLine + 5));
1790
1791 #if 0
1792         InitTask16(); /* FIXME: pmts / from context ? */
1793         InitApp(di);
1794 #endif
1795         if (SetMessageQueue16(0x40)) {
1796             WaitEvent16(0);
1797             if (HIWORD(fpProc)) {
1798                 OldYield16();
1799 /* EPP          StackEnter16(); */
1800                 (fpProc)(dwPmt);
1801             }
1802         }
1803     }
1804     OldYield16();
1805     OldYield16();
1806     OldYield16();
1807     ExitProcess(0);
1808 }
1809 #endif
1810
1811 /**************************************************************************
1812  *                              mmTaskBlock             [MMSYSTEM.902]
1813  */
1814 void WINAPI mmTaskBlock16(HINSTANCE16 hInst)
1815 {
1816     MSG         msg;
1817
1818     do {
1819         GetMessageA(&msg, 0, 0, 0);
1820         if (msg.hwnd) {
1821             TranslateMessage(&msg);
1822             DispatchMessageA(&msg);
1823         }
1824     } while (msg.message < 0x3A0);
1825 }
1826
1827 /**************************************************************************
1828  *                              mmTaskSignal            [MMSYSTEM.903]
1829  */
1830 LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
1831 {
1832     TRACE("(%04x);\n", ht);
1833     return PostThreadMessageW( HTASK_32(ht), WM_USER, 0, 0 );
1834 }
1835
1836 /**************************************************************************
1837  *                              mmGetCurrentTask        [MMSYSTEM.904]
1838  */
1839 HTASK16 WINAPI mmGetCurrentTask16(void)
1840 {
1841     return GetCurrentTask();
1842 }
1843
1844 /**************************************************************************
1845  *                              mmTaskYield             [MMSYSTEM.905]
1846  */
1847 void    WINAPI  mmTaskYield16(void)
1848 {
1849     MSG         msg;
1850
1851     if (PeekMessageA(&msg, 0, 0, 0, 0)) {
1852         WOWYield16();
1853     }
1854 }
1855
1856 /******************************************************************
1857  *              WINMM_GetmmThread
1858  *
1859  *
1860  */
1861 static  WINE_MMTHREAD*  WINMM_GetmmThread(HANDLE16 h)
1862 {
1863     return MapSL(MAKESEGPTR(h, 0));
1864 }
1865
1866 static  void    MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd)
1867 {
1868     MSG         msg;
1869     DWORD       ret;
1870
1871     if (lpMMThd->dwThreadID != GetCurrentThreadId())
1872         ERR("Not called by thread itself\n");
1873
1874     for (;;) {
1875         ResetEvent(lpMMThd->hEvent);
1876         if (InterlockedDecrement(&lpMMThd->dwSignalCount) >= 0)
1877             break;
1878         InterlockedIncrement(&lpMMThd->dwSignalCount);
1879
1880         TRACE("S1\n");
1881
1882         ret = MsgWaitForMultipleObjects(1, &lpMMThd->hEvent, FALSE, INFINITE, QS_ALLINPUT);
1883         switch (ret) {
1884         case WAIT_OBJECT_0:     /* Event */
1885             TRACE("S2.1\n");
1886             break;
1887         case WAIT_OBJECT_0 + 1: /* Msg */
1888             TRACE("S2.2\n");
1889             if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
1890                 TranslateMessage(&msg);
1891                 DispatchMessageA(&msg);
1892             }
1893             break;
1894         default:
1895             WARN("S2.x unsupported ret val 0x%08x\n", ret);
1896         }
1897         TRACE("S3\n");
1898     }
1899 }
1900
1901 /**************************************************************************
1902  *                              mmThreadBlock           [MMSYSTEM.1122]
1903  */
1904 void    WINAPI mmThreadBlock16(HANDLE16 hndl)
1905 {
1906     TRACE("(%04x)!\n", hndl);
1907
1908     if (hndl) {
1909         WINE_MMTHREAD*  lpMMThd = WINMM_GetmmThread(hndl);
1910
1911         if (lpMMThd->hThread != 0) {
1912             DWORD       lc;
1913
1914             ReleaseThunkLock(&lc);
1915             MMSYSTEM_ThreadBlock(lpMMThd);
1916             RestoreThunkLock(lc);
1917         } else {
1918             mmTaskBlock16(lpMMThd->hTask);
1919         }
1920     }
1921     TRACE("done\n");
1922 }
1923
1924 /**************************************************************************
1925  *                              __wine_mmThreadEntryPoint (MMSYSTEM.2047)
1926  */
1927 DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID p)
1928 {
1929     HANDLE16            hndl = (HANDLE16)(DWORD_PTR)p;
1930     WINE_MMTHREAD*      lpMMThd = WINMM_GetmmThread(hndl);
1931
1932     TRACE("(%04x %p)\n", hndl, lpMMThd);
1933
1934     lpMMThd->hTask = LOWORD(GetCurrentTask());
1935     TRACE("[10-%p] setting hTask to 0x%08x\n", lpMMThd->hThread, lpMMThd->hTask);
1936     lpMMThd->dwStatus = 0x10;
1937     MMSYSTEM_ThreadBlock(lpMMThd);
1938     TRACE("[20-%p]\n", lpMMThd->hThread);
1939     lpMMThd->dwStatus = 0x20;
1940     if (lpMMThd->fpThread) {
1941         WOWCallback16(lpMMThd->fpThread, lpMMThd->dwThreadPmt);
1942     }
1943     lpMMThd->dwStatus = 0x30;
1944     TRACE("[30-%p]\n", lpMMThd->hThread);
1945     while (lpMMThd->dwCounter) {
1946         Sleep(1);
1947         /* WOWYield16();*/
1948     }
1949     TRACE("[XX-%p]\n", lpMMThd->hThread);
1950     /* paranoia */
1951     lpMMThd->dwSignature = WINE_MMTHREAD_DELETED;
1952     /* close lpMMThread->hVxD directIO */
1953     if (lpMMThd->hEvent)
1954         CloseHandle(lpMMThd->hEvent);
1955     GlobalFree16(hndl);
1956     TRACE("done\n");
1957
1958     return 0;
1959 }
1960
1961 extern DWORD    WINAPI  GetProcessFlags(DWORD);
1962
1963 /**************************************************************************
1964  *                              mmThreadCreate          [MMSYSTEM.1120]
1965  *
1966  * undocumented
1967  * Creates a MM thread, calling fpThreadAddr(dwPmt).
1968  * dwFlags:
1969  *      bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc
1970  *      bit.1 set means to open a VxD for this thread (unsupported)
1971  */
1972 LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD dwPmt, DWORD dwFlags)
1973 {
1974     HANDLE16            hndl;
1975     LRESULT             ret;
1976
1977     TRACE("(%p, %p, %08x, %08x)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags);
1978
1979     hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT);
1980
1981     if (hndl == 0) {
1982         ret = 2;
1983     } else {
1984         WINE_MMTHREAD*  lpMMThd = WINMM_GetmmThread(hndl);
1985
1986 #if 0
1987         /* force mmtask routines even if mmthread is required */
1988         /* this will work only if the patch about binary cmd line and NE tasks
1989          * is committed
1990          */
1991         dwFlags |= 1;
1992 #endif
1993
1994         lpMMThd->dwSignature    = WINE_MMTHREAD_CREATED;
1995         lpMMThd->dwCounter      = 0;
1996         lpMMThd->hThread        = 0;
1997         lpMMThd->dwThreadID     = 0;
1998         lpMMThd->fpThread       = (DWORD)fpThreadAddr;
1999         lpMMThd->dwThreadPmt    = dwPmt;
2000         lpMMThd->dwSignalCount  = 0;
2001         lpMMThd->hEvent         = 0;
2002         lpMMThd->hVxD           = 0;
2003         lpMMThd->dwStatus       = 0;
2004         lpMMThd->dwFlags        = dwFlags;
2005         lpMMThd->hTask          = 0;
2006
2007         if ((dwFlags & 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) {
2008             lpMMThd->hEvent = CreateEventW(NULL, FALSE, TRUE, NULL);
2009
2010             TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd);
2011             if (lpMMThd->dwFlags & 2) {
2012                 /* as long as we don't support MM VxD in wine, we don't need
2013                  * to care about this flag
2014                  */
2015                 /* FIXME("Don't know how to properly open VxD handles\n"); */
2016                 /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */
2017             }
2018
2019             lpMMThd->hThread = CreateThread(0, 0, WINE_mmThreadEntryPoint,
2020                                             (LPVOID)(DWORD_PTR)hndl, CREATE_SUSPENDED, &lpMMThd->dwThreadID);
2021             if (lpMMThd->hThread == 0) {
2022                 WARN("Couldn't create thread\n");
2023                 /* clean-up(VxDhandle...); devicedirectio... */
2024                 if (lpMMThd->hEvent != 0)
2025                     CloseHandle(lpMMThd->hEvent);
2026                 ret = 2;
2027             } else {
2028                 SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL);
2029                 TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID);
2030                 ret = 0;
2031             }
2032         } else {
2033             /* get WINE_mmThreadEntryPoint()
2034              * 2047 is its ordinal in mmsystem.spec
2035              */
2036             FARPROC16   fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047);
2037
2038             TRACE("farproc seg=0x%p lin=%p\n", fp, MapSL((SEGPTR)fp));
2039
2040             ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl);
2041         }
2042
2043         if (ret == 0) {
2044             if (lpMMThd->hThread && !ResumeThread(lpMMThd->hThread))
2045                 WARN("Couldn't resume thread\n");
2046
2047             while (lpMMThd->dwStatus != 0x10) { /* test also HIWORD of dwStatus */
2048                 MSG msg;
2049                 PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
2050             }
2051         }
2052     }
2053
2054     if (ret != 0) {
2055         GlobalFree16(hndl);
2056         hndl = 0;
2057     }
2058
2059     if (lpHndl)
2060         *lpHndl = hndl;
2061
2062     TRACE("ok => %ld\n", ret);
2063     return ret;
2064 }
2065
2066 /**************************************************************************
2067  *                              mmThreadSignal          [MMSYSTEM.1121]
2068  */
2069 void WINAPI mmThreadSignal16(HANDLE16 hndl)
2070 {
2071     TRACE("(%04x)!\n", hndl);
2072
2073     if (hndl) {
2074         WINE_MMTHREAD*  lpMMThd = WINMM_GetmmThread(hndl);
2075
2076         lpMMThd->dwCounter++;
2077         if (lpMMThd->hThread != 0) {
2078             InterlockedIncrement(&lpMMThd->dwSignalCount);
2079             SetEvent(lpMMThd->hEvent);
2080         } else {
2081             mmTaskSignal16(lpMMThd->hTask);
2082         }
2083         lpMMThd->dwCounter--;
2084     }
2085 }
2086
2087 /**************************************************************************
2088  *                              mmThreadIsCurrent       [MMSYSTEM.1123]
2089  */
2090 BOOL16  WINAPI mmThreadIsCurrent16(HANDLE16 hndl)
2091 {
2092     BOOL16              ret = FALSE;
2093
2094     TRACE("(%04x)!\n", hndl);
2095
2096     if (hndl && mmThreadIsValid16(hndl)) {
2097         WINE_MMTHREAD*  lpMMThd = WINMM_GetmmThread(hndl);
2098         ret = (GetCurrentThreadId() == lpMMThd->dwThreadID);
2099     }
2100     TRACE("=> %d\n", ret);
2101     return ret;
2102 }
2103
2104 /**************************************************************************
2105  *                              mmThreadIsValid         [MMSYSTEM.1124]
2106  */
2107 BOOL16  WINAPI  mmThreadIsValid16(HANDLE16 hndl)
2108 {
2109     BOOL16              ret = FALSE;
2110
2111     TRACE("(%04x)!\n", hndl);
2112
2113     if (hndl) {
2114         WINE_MMTHREAD*  lpMMThd = WINMM_GetmmThread(hndl);
2115
2116         if (!IsBadWritePtr(lpMMThd, sizeof(WINE_MMTHREAD)) &&
2117             lpMMThd->dwSignature == WINE_MMTHREAD_CREATED &&
2118             IsTask16(lpMMThd->hTask)) {
2119             lpMMThd->dwCounter++;
2120             if (lpMMThd->hThread != 0) {
2121                 DWORD   dwThreadRet;
2122                 if (GetExitCodeThread(lpMMThd->hThread, &dwThreadRet) &&
2123                     dwThreadRet == STATUS_PENDING) {
2124                     ret = TRUE;
2125                 }
2126             } else {
2127                 ret = TRUE;
2128             }
2129             lpMMThd->dwCounter--;
2130         }
2131     }
2132     TRACE("=> %d\n", ret);
2133     return ret;
2134 }
2135
2136 /**************************************************************************
2137  *                              mmThreadGetTask         [MMSYSTEM.1125]
2138  */
2139 HANDLE16 WINAPI mmThreadGetTask16(HANDLE16 hndl)
2140 {
2141     HANDLE16    ret = 0;
2142
2143     TRACE("(%04x)\n", hndl);
2144
2145     if (mmThreadIsValid16(hndl)) {
2146         WINE_MMTHREAD*  lpMMThd = WINMM_GetmmThread(hndl);
2147         ret = lpMMThd->hTask;
2148     }
2149     return ret;
2150 }
2151
2152 typedef BOOL16 (WINAPI *MMCPLCALLBACK)(HWND, LPCSTR, LPCSTR, LPCSTR);
2153
2154 /**************************************************************************
2155  *                      mmShowMMCPLPropertySheet        [MMSYSTEM.1150]
2156  */
2157 BOOL16  WINAPI  mmShowMMCPLPropertySheet16(HWND hWnd, LPCSTR lpStrDevice,
2158                                            LPCSTR lpStrTab, LPCSTR lpStrTitle)
2159 {
2160     HANDLE      hndl;
2161     BOOL16      ret = FALSE;
2162
2163     TRACE("(%p \"%s\" \"%s\" \"%s\")\n", hWnd, lpStrDevice, lpStrTab, lpStrTitle);
2164
2165     hndl = LoadLibraryA("MMSYS.CPL");
2166     if (hndl != 0) {
2167         MMCPLCALLBACK   fp = (MMCPLCALLBACK)GetProcAddress(hndl, "ShowMMCPLPropertySheet");
2168         if (fp != NULL) {
2169             DWORD       lc;
2170             ReleaseThunkLock(&lc);
2171             ret = (fp)(hWnd, lpStrDevice, lpStrTab, lpStrTitle);
2172             RestoreThunkLock(lc);
2173         }
2174         FreeLibrary(hndl);
2175     }
2176
2177     return ret;
2178 }
2179
2180 /**************************************************************************
2181  *                      StackEnter              [MMSYSTEM.32]
2182  */
2183 void WINAPI StackEnter16(void)
2184 {
2185 #ifdef __i386__
2186     /* mmsystem.dll from Win 95 does only this: so does Wine */
2187     __asm__("stc");
2188 #endif
2189 }
2190
2191 /**************************************************************************
2192  *                      StackLeave              [MMSYSTEM.33]
2193  */
2194 void WINAPI StackLeave16(void)
2195 {
2196 #ifdef __i386__
2197     /* mmsystem.dll from Win 95 does only this: so does Wine */
2198     __asm__("stc");
2199 #endif
2200 }
2201
2202 /**************************************************************************
2203  *                      WMMMidiRunOnce          [MMSYSTEM.8]
2204  */
2205 void WINAPI WMMMidiRunOnce16(void)
2206 {
2207     FIXME("(), stub!\n");
2208 }
2209
2210
2211
2212 /* ###################################################
2213  * #                     JOYSTICK                    #
2214  * ###################################################
2215  */
2216
2217 /**************************************************************************
2218  *                              joyGetNumDevs           [MMSYSTEM.101]
2219  */
2220 UINT16 WINAPI joyGetNumDevs16(void)
2221 {
2222     return joyGetNumDevs();
2223 }
2224
2225 /**************************************************************************
2226  *                              joyGetDevCaps           [MMSYSTEM.102]
2227  */
2228 MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
2229 {
2230     JOYCAPSA    jca;
2231     MMRESULT    ret;
2232
2233     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
2234
2235     ret = joyGetDevCapsA(wID, &jca, sizeof(jca));
2236
2237     if (ret != JOYERR_NOERROR) return ret;
2238     lpCaps->wMid = jca.wMid;
2239     lpCaps->wPid = jca.wPid;
2240     strcpy(lpCaps->szPname, jca.szPname);
2241     lpCaps->wXmin = jca.wXmin;
2242     lpCaps->wXmax = jca.wXmax;
2243     lpCaps->wYmin = jca.wYmin;
2244     lpCaps->wYmax = jca.wYmax;
2245     lpCaps->wZmin = jca.wZmin;
2246     lpCaps->wZmax = jca.wZmax;
2247     lpCaps->wNumButtons = jca.wNumButtons;
2248     lpCaps->wPeriodMin = jca.wPeriodMin;
2249     lpCaps->wPeriodMax = jca.wPeriodMax;
2250
2251     if (wSize >= sizeof(JOYCAPS16)) { /* Win95 extensions ? */
2252         lpCaps->wRmin = jca.wRmin;
2253         lpCaps->wRmax = jca.wRmax;
2254         lpCaps->wUmin = jca.wUmin;
2255         lpCaps->wUmax = jca.wUmax;
2256         lpCaps->wVmin = jca.wVmin;
2257         lpCaps->wVmax = jca.wVmax;
2258         lpCaps->wCaps = jca.wCaps;
2259         lpCaps->wMaxAxes = jca.wMaxAxes;
2260         lpCaps->wNumAxes = jca.wNumAxes;
2261         lpCaps->wMaxButtons = jca.wMaxButtons;
2262         strcpy(lpCaps->szRegKey, jca.szRegKey);
2263         strcpy(lpCaps->szOEMVxD, jca.szOEMVxD);
2264     }
2265
2266     return ret;
2267 }
2268
2269 /**************************************************************************
2270  *                              joyGetPosEx           [MMSYSTEM.110]
2271  */
2272 MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo)
2273 {
2274     return joyGetPosEx(wID, lpInfo);
2275 }
2276
2277 /**************************************************************************
2278  *                              joyGetPos               [MMSYSTEM.103]
2279  */
2280 MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
2281 {
2282     JOYINFO     ji;
2283     MMRESULT    ret;
2284
2285     TRACE("(%d, %p);\n", wID, lpInfo);
2286
2287     if ((ret = joyGetPos(wID, &ji)) == JOYERR_NOERROR) {
2288         lpInfo->wXpos = ji.wXpos;
2289         lpInfo->wYpos = ji.wYpos;
2290         lpInfo->wZpos = ji.wZpos;
2291         lpInfo->wButtons = ji.wButtons;
2292     }
2293     return ret;
2294 }
2295
2296 /**************************************************************************
2297  *                              joyGetThreshold         [MMSYSTEM.104]
2298  */
2299 MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
2300 {
2301     UINT        t;
2302     MMRESULT    ret;
2303
2304     ret = joyGetThreshold(wID, &t);
2305     if (ret == JOYERR_NOERROR)
2306         *lpThreshold = t;
2307     return ret;
2308 }
2309
2310 /**************************************************************************
2311  *                              joyReleaseCapture       [MMSYSTEM.105]
2312  */
2313 MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
2314 {
2315     return joyReleaseCapture(wID);
2316 }
2317
2318 /**************************************************************************
2319  *                              joySetCapture           [MMSYSTEM.106]
2320  */
2321 MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL16 bChanged)
2322 {
2323     return joySetCapture(HWND_32(hWnd), wID, wPeriod, bChanged);
2324 }
2325
2326 /**************************************************************************
2327  *                              joySetThreshold         [MMSYSTEM.107]
2328  */
2329 MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
2330 {
2331     return joySetThreshold(wID,wThreshold);
2332 }
2333
2334 /**************************************************************************
2335  *                              joySetCalibration       [MMSYSTEM.109]
2336  */
2337 MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
2338 {
2339     FIXME("(%04X): stub.\n", wID);
2340     return JOYERR_NOCANDO;
2341 }