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

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * WINMM functions
   5  *
   6  * Copyright 1993      Martin Ayotte
   7  *           1998-2002 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  *      98/9    added Win32 MCI support
  27  *      99/4    added midiStream support
  28  *      99/9    added support for loadable low level drivers
  29  */
  30
  31 /* TODO
  32  *      + it seems that some programs check what's installed in
  33  *        registry against the value returned by drivers. Wine is
  34  *        currently broken regarding this point.
  35  *      + check thread-safeness for MMSYSTEM and WINMM entry points
  36  *      + unicode entry points are badly supported (would require
  37  *        moving 32 bit drivers as Unicode as they are supposed to be)
  38  *      + allow joystick and timer external calls as we do for wave,
  39  *        midi, mixer and aux
  40  */
  41
  42 #include <stdio.h>
  43 #include <stdarg.h>
  44 #include <string.h>
  45
  46 #define NONAMELESSUNION
  47 #define NONAMELESSSTRUCT
  48 #include "windef.h"
  49 #include "winbase.h"
  50 #include "mmsystem.h"
  51 #include "winuser.h"
  52 #include "winnls.h"
  53 #include "winreg.h"
  54 #include "winternl.h"
  55 #include "winemm.h"
  56 #include "wownt32.h"
  57
  58 #include "wine/debug.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  61
  62 /******************************************************************
  63  *              MyUserYield
  64  *
  65  * Internal wrapper to call USER.UserYield16 (in fact through a Wine only export from USER32).
  66  */
  67 static void MyUserYield(void)
  68 {
  69     HMODULE mod = GetModuleHandleA( "user32.dll" );
  70     if (mod)
  71     {
  72         FARPROC proc = GetProcAddress( mod, "UserYield16" );
  73         if (proc) proc();
  74     }
  75 }
  76
  77 void    (WINAPI *pFnReleaseThunkLock)(DWORD*);
  78 void    (WINAPI *pFnRestoreThunkLock)(DWORD);
  79
  80 /* ========================================================================
  81  *                   G L O B A L   S E T T I N G S
  82  * ========================================================================*/
  83
  84 LPWINE_MM_IDATA         WINMM_IData /* = NULL */;
  85
  86 /**************************************************************************
  87  *                      WINMM_CreateIData                       [internal]
  88  */
  89 static  BOOL    WINMM_CreateIData(HINSTANCE hInstDLL)
  90 {
  91     WINMM_IData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MM_IDATA));
  92
  93     if (!WINMM_IData)
  94         return FALSE;
  95     WINMM_IData->hWinMM32Instance = hInstDLL;
  96     InitializeCriticalSection(&WINMM_IData->cs);
  97     WINMM_IData->cs.DebugInfo->Spare[1] = (DWORD)"WINMM_IData";
  98     WINMM_IData->psStopEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
  99     WINMM_IData->psLastEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 100     TRACE("Created IData (%p)\n", WINMM_IData);
 101     return TRUE;
 102 }
 103
 104 /**************************************************************************
 105  *                      WINMM_DeleteIData                       [internal]
 106  */
 107 static  void WINMM_DeleteIData(void)
 108 {
 109     if (WINMM_IData) {
 110         TIME_MMTimeStop();
 111
 112         /* FIXME: should also free content and resources allocated
 113          * inside WINMM_IData */
 114         CloseHandle(WINMM_IData->psStopEvent);
 115         CloseHandle(WINMM_IData->psLastEvent);
 116         DeleteCriticalSection(&WINMM_IData->cs);
 117         HeapFree(GetProcessHeap(), 0, WINMM_IData);
 118         WINMM_IData = NULL;
 119     }
 120 }
 121
 122 /******************************************************************
 123  *             WINMM_LoadMMSystem
 124  *
 125  */
 126 static HANDLE (WINAPI *pGetModuleHandle16)(LPCSTR);
 127 static DWORD (WINAPI *pLoadLibrary16)(LPCSTR);
 128
 129 BOOL WINMM_CheckForMMSystem(void)
 130 {
 131     /* 0 is not checked yet, -1 is not present, 1 is present */
 132     static      int    loaded /* = 0 */;
 133
 134     if (loaded == 0)
 135     {
 136         HANDLE      h = GetModuleHandleA("kernel32");
 137         loaded = -1;
 138         if (h)
 139         {
 140             pGetModuleHandle16 = (void*)GetProcAddress(h, "GetModuleHandle16");
 141             pLoadLibrary16 = (void*)GetProcAddress(h, "LoadLibrary16");
 142             if (pGetModuleHandle16 && pLoadLibrary16 &&
 143                 (pGetModuleHandle16("MMSYSTEM.DLL") || pLoadLibrary16("MMSYSTEM.DLL")))
 144                 loaded = 1;
 145         }
 146     }
 147     return loaded > 0;
 148 }
 149
 150 /******************************************************************
 151  *             WINMM_ErrorToString
 152  */
 153 const char* WINMM_ErrorToString(MMRESULT error)
 154 {
 155 #define ERR_TO_STR(dev) case dev: return #dev
 156     static char unknown[32];
 157     switch (error) {
 158     ERR_TO_STR(MMSYSERR_NOERROR);
 159     ERR_TO_STR(MMSYSERR_ERROR);
 160     ERR_TO_STR(MMSYSERR_BADDEVICEID);
 161     ERR_TO_STR(MMSYSERR_NOTENABLED);
 162     ERR_TO_STR(MMSYSERR_ALLOCATED);
 163     ERR_TO_STR(MMSYSERR_INVALHANDLE);
 164     ERR_TO_STR(MMSYSERR_NODRIVER);
 165     ERR_TO_STR(MMSYSERR_NOMEM);
 166     ERR_TO_STR(MMSYSERR_NOTSUPPORTED);
 167     ERR_TO_STR(MMSYSERR_BADERRNUM);
 168     ERR_TO_STR(MMSYSERR_INVALFLAG);
 169     ERR_TO_STR(MMSYSERR_INVALPARAM);
 170     ERR_TO_STR(MMSYSERR_HANDLEBUSY);
 171     ERR_TO_STR(MMSYSERR_INVALIDALIAS);
 172     ERR_TO_STR(MMSYSERR_BADDB);
 173     ERR_TO_STR(MMSYSERR_KEYNOTFOUND);
 174     ERR_TO_STR(MMSYSERR_READERROR);
 175     ERR_TO_STR(MMSYSERR_WRITEERROR);
 176     ERR_TO_STR(MMSYSERR_DELETEERROR);
 177     ERR_TO_STR(MMSYSERR_VALNOTFOUND);
 178     ERR_TO_STR(MMSYSERR_NODRIVERCB);
 179     ERR_TO_STR(WAVERR_BADFORMAT);
 180     ERR_TO_STR(WAVERR_STILLPLAYING);
 181     ERR_TO_STR(WAVERR_UNPREPARED);
 182     ERR_TO_STR(WAVERR_SYNC);
 183     }
 184     sprintf(unknown, "Unknown(0x%08x)", error);
 185     return unknown;
 186 #undef ERR_TO_STR
 187 }
 188
 189 /**************************************************************************
 190  *              DllMain (WINMM.init)
 191  *
 192  * WINMM DLL entry point
 193  *
 194  */
 195 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
 196 {
 197     TRACE("%p 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
 198
 199     switch (fdwReason) {
 200     case DLL_PROCESS_ATTACH:
 201         DisableThreadLibraryCalls(hInstDLL);
 202
 203         if (!WINMM_CreateIData(hInstDLL))
 204             return FALSE;
 205         if (!MMDRV_Init()) {
 206             WINMM_DeleteIData();
 207             return FALSE;
 208         }
 209         break;
 210     case DLL_PROCESS_DETACH:
 211         /* close all opened MCI drivers */
 212         MCI_SendCommand(MCI_ALL_DEVICE_ID, MCI_CLOSE, MCI_WAIT, 0L, TRUE);
 213         MMDRV_Exit();
 214         /* now unload all remaining drivers... */
 215         DRIVER_UnloadAll();
 216
 217         WINMM_DeleteIData();
 218         break;
 219     }
 220     return TRUE;
 221 }
 222
 223 /**************************************************************************
 224  *      Mixer devices. New to Win95
 225  */
 226
 227 /**************************************************************************
 228  * find out the real mixer ID depending on hmix (depends on dwFlags)
 229  */
 230 static UINT MIXER_GetDev(HMIXEROBJ hmix, DWORD dwFlags, LPWINE_MIXER * lplpwm)
 231 {
 232     LPWINE_MIXER        lpwm = NULL;
 233     UINT                uRet = MMSYSERR_NOERROR;
 234
 235     switch (dwFlags & 0xF0000000ul) {
 236     case MIXER_OBJECTF_MIXER:
 237         lpwm = (LPWINE_MIXER)MMDRV_Get(hmix, MMDRV_MIXER, TRUE);
 238         break;
 239     case MIXER_OBJECTF_HMIXER:
 240         lpwm = (LPWINE_MIXER)MMDRV_Get(hmix, MMDRV_MIXER, FALSE);
 241         break;
 242     case MIXER_OBJECTF_WAVEOUT:
 243         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEOUT, TRUE,  MMDRV_MIXER);
 244         break;
 245     case MIXER_OBJECTF_HWAVEOUT:
 246         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEOUT, FALSE, MMDRV_MIXER);
 247         break;
 248     case MIXER_OBJECTF_WAVEIN:
 249         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEIN,  TRUE,  MMDRV_MIXER);
 250         break;
 251     case MIXER_OBJECTF_HWAVEIN:
 252         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEIN,  FALSE, MMDRV_MIXER);
 253         break;
 254     case MIXER_OBJECTF_MIDIOUT:
 255         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIOUT, TRUE,  MMDRV_MIXER);
 256         break;
 257     case MIXER_OBJECTF_HMIDIOUT:
 258         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIOUT, FALSE, MMDRV_MIXER);
 259         break;
 260     case MIXER_OBJECTF_MIDIIN:
 261         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIIN,  TRUE,  MMDRV_MIXER);
 262         break;
 263     case MIXER_OBJECTF_HMIDIIN:
 264         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIIN,  FALSE, MMDRV_MIXER);
 265         break;
 266     case MIXER_OBJECTF_AUX:
 267         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_AUX,     TRUE,  MMDRV_MIXER);
 268         break;
 269     default:
 270         WARN("Unsupported flag (%08lx)\n", dwFlags & 0xF0000000ul);
 271         lpwm = 0;
 272         uRet = MMSYSERR_INVALFLAG;
 273         break;
 274     }
 275     *lplpwm = lpwm;
 276     if (lpwm == 0 && uRet == MMSYSERR_NOERROR)
 277         uRet = MMSYSERR_INVALPARAM;
 278     return uRet;
 279 }
 280
 281 /**************************************************************************
 282  *                              mixerGetNumDevs                 [WINMM.@]
 283  */
 284 UINT WINAPI mixerGetNumDevs(void)
 285 {
 286     return MMDRV_GetNum(MMDRV_MIXER);
 287 }
 288
 289 /**************************************************************************
 290  *                              mixerGetDevCapsA                [WINMM.@]
 291  */
 292 UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
 293 {
 294     MIXERCAPSW micW;
 295     UINT       ret;
 296
 297     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 298
 299     ret = mixerGetDevCapsW(uDeviceID, &micW, sizeof(micW));
 300
 301     if (ret == MMSYSERR_NOERROR) {
 302         MIXERCAPSA micA;
 303         micA.wMid           = micW.wMid;
 304         micA.wPid           = micW.wPid;
 305         micA.vDriverVersion = micW.vDriverVersion;
 306         WideCharToMultiByte( CP_ACP, 0, micW.szPname, -1, micA.szPname,
 307                              sizeof(micA.szPname), NULL, NULL );
 308         micA.fdwSupport     = micW.fdwSupport;
 309         micA.cDestinations  = micW.cDestinations;
 310         memcpy(lpCaps, &micA, min(uSize, sizeof(micA)));
 311     }
 312     return ret;
 313 }
 314
 315 /**************************************************************************
 316  *                              mixerGetDevCapsW                [WINMM.@]
 317  */
 318 UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
 319 {
 320     LPWINE_MLD wmld;
 321
 322     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
 323
 324     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIXER, TRUE)) == NULL)
 325         return MMSYSERR_BADDEVICEID;
 326
 327     return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
 328 }
 329
 330 UINT  MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
 331                  DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
 332 {
 333     HANDLE              hMix;
 334     LPWINE_MLD          wmld;
 335     DWORD               dwRet = 0;
 336     MIXEROPENDESC       mod;
 337
 338     TRACE("(%p, %d, %08lx, %08lx, %08lx)\n",
 339           lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen);
 340
 341     wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen,
 342                        &dwCallback, &dwInstance, bFrom32);
 343
 344     wmld->uDeviceID = uDeviceID;
 345     mod.hmx = (HMIXEROBJ)hMix;
 346     mod.dwCallback = dwCallback;
 347     mod.dwInstance = dwInstance;
 348
 349     dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD)&mod, fdwOpen);
 350
 351     if (dwRet != MMSYSERR_NOERROR) {
 352         MMDRV_Free(hMix, wmld);
 353         hMix = 0;
 354     }
 355     if (lphMix) *lphMix = hMix;
 356     TRACE("=> %ld hMixer=%p\n", dwRet, hMix);
 357
 358     return dwRet;
 359 }
 360
 361 /**************************************************************************
 362  *                              mixerOpen                       [WINMM.@]
 363  */
 364 UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
 365                      DWORD_PTR dwInstance, DWORD fdwOpen)
 366 {
 367     return MIXER_Open(lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen, TRUE);
 368 }
 369
 370 /**************************************************************************
 371  *                              mixerClose                      [WINMM.@]
 372  */
 373 UINT WINAPI mixerClose(HMIXER hMix)
 374 {
 375     LPWINE_MLD          wmld;
 376     DWORD               dwRet;
 377
 378     TRACE("(%p)\n", hMix);
 379
 380     if ((wmld = MMDRV_Get(hMix, MMDRV_MIXER, FALSE)) == NULL) return MMSYSERR_INVALHANDLE;
 381
 382     dwRet = MMDRV_Close(wmld, MXDM_CLOSE);
 383     MMDRV_Free(hMix, wmld);
 384
 385     return dwRet;
 386 }
 387
 388 /**************************************************************************
 389  *                              mixerGetID                      [WINMM.@]
 390  */
 391 UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
 392 {
 393     LPWINE_MIXER        lpwm;
 394     UINT                uRet = MMSYSERR_NOERROR;
 395
 396     TRACE("(%p %p %08lx)\n", hmix, lpid, fdwID);
 397
 398     if ((uRet = MIXER_GetDev(hmix, fdwID, &lpwm)) != MMSYSERR_NOERROR)
 399         return uRet;
 400
 401     if (lpid)
 402       *lpid = lpwm->mld.uDeviceID;
 403
 404     return uRet;
 405 }
 406
 407 /**************************************************************************
 408  *                              mixerGetControlDetailsW         [WINMM.@]
 409  */
 410 UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW,
 411                                     DWORD fdwDetails)
 412 {
 413     LPWINE_MIXER        lpwm;
 414     UINT                uRet = MMSYSERR_NOERROR;
 415
 416     TRACE("(%p, %p, %08lx)\n", hmix, lpmcdW, fdwDetails);
 417
 418     if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR)
 419         return uRet;
 420
 421     if (lpmcdW == NULL || lpmcdW->cbStruct != sizeof(*lpmcdW))
 422         return MMSYSERR_INVALPARAM;
 423
 424     return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD_PTR)lpmcdW,
 425                          fdwDetails, TRUE);
 426 }
 427
 428 /**************************************************************************
 429  *                              mixerGetControlDetailsA [WINMM.@]
 430  */
 431 UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
 432                                     DWORD fdwDetails)
 433 {
 434     DWORD                       ret = MMSYSERR_NOTENABLED;
 435
 436     TRACE("(%p, %p, %08lx)\n", hmix, lpmcdA, fdwDetails);
 437
 438     if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
 439         return MMSYSERR_INVALPARAM;
 440
 441     switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
 442     case MIXER_GETCONTROLDETAILSF_VALUE:
 443         /* can savely use A structure as it is, no string inside */
 444         ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
 445         break;
 446     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
 447         {
 448             MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = (MIXERCONTROLDETAILS_LISTTEXTA *)lpmcdA->paDetails;
 449             MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW;
 450             int size = max(1, lpmcdA->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
 451             unsigned int i;
 452
 453             if (lpmcdA->u.cMultipleItems != 0) {
 454                 size *= lpmcdA->u.cMultipleItems;
 455             }
 456             pDetailsW = (MIXERCONTROLDETAILS_LISTTEXTW *)HeapAlloc(GetProcessHeap(), 0, size);
 457             lpmcdA->paDetails = pDetailsW;
 458             lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTW);
 459             /* set up lpmcd->paDetails */
 460             ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails);
 461             /* copy from lpmcd->paDetails back to paDetailsW; */
 462             if (ret == MMSYSERR_NOERROR) {
 463                 for (i = 0; i < lpmcdA->u.cMultipleItems * lpmcdA->cChannels; i++) {
 464                     pDetailsA->dwParam1 = pDetailsW->dwParam1;
 465                     pDetailsA->dwParam2 = pDetailsW->dwParam2;
 466                     WideCharToMultiByte( CP_ACP, 0, pDetailsW->szName, -1,
 467                                          pDetailsA->szName,
 468                                          sizeof(pDetailsA->szName), NULL, NULL );
 469                     pDetailsA++;
 470                     pDetailsW++;
 471                 }
 472                 pDetailsA -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
 473                 pDetailsW -= lpmcdA->u.cMultipleItems * lpmcdA->cChannels;
 474             }
 475             HeapFree(GetProcessHeap(), 0, pDetailsW);
 476             lpmcdA->paDetails = pDetailsA;
 477             lpmcdA->cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
 478         }
 479         break;
 480     default:
 481         ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails);
 482     }
 483
 484     return ret;
 485 }
 486
 487 /**************************************************************************
 488  *                              mixerGetLineControlsA   [WINMM.@]
 489  */
 490 UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
 491                                   DWORD fdwControls)
 492 {
 493     MIXERLINECONTROLSW  mlcW;
 494     DWORD               ret;
 495     unsigned int        i;
 496
 497     TRACE("(%p, %p, %08lx)\n", hmix, lpmlcA, fdwControls);
 498
 499     if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
 500         lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
 501         return MMSYSERR_INVALPARAM;
 502
 503     mlcW.cbStruct = sizeof(mlcW);
 504     mlcW.dwLineID = lpmlcA->dwLineID;
 505     mlcW.u.dwControlID = lpmlcA->u.dwControlID;
 506     mlcW.u.dwControlType = lpmlcA->u.dwControlType;
 507     mlcW.cControls = lpmlcA->cControls;
 508     mlcW.cbmxctrl = sizeof(MIXERCONTROLW);
 509     mlcW.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
 510                               mlcW.cControls * mlcW.cbmxctrl);
 511
 512     ret = mixerGetLineControlsW(hmix, &mlcW, fdwControls);
 513
 514     if (ret == MMSYSERR_NOERROR) {
 515         lpmlcA->dwLineID = mlcW.dwLineID;
 516         lpmlcA->u.dwControlID = mlcW.u.dwControlID;
 517         lpmlcA->u.dwControlType = mlcW.u.dwControlType;
 518         lpmlcA->cControls = mlcW.cControls;
 519
 520         for (i = 0; i < mlcW.cControls; i++) {
 521             lpmlcA->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLA);
 522             lpmlcA->pamxctrl[i].dwControlID = mlcW.pamxctrl[i].dwControlID;
 523             lpmlcA->pamxctrl[i].dwControlType = mlcW.pamxctrl[i].dwControlType;
 524             lpmlcA->pamxctrl[i].fdwControl = mlcW.pamxctrl[i].fdwControl;
 525             lpmlcA->pamxctrl[i].cMultipleItems = mlcW.pamxctrl[i].cMultipleItems;
 526             WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szShortName, -1,
 527                                  lpmlcA->pamxctrl[i].szShortName,
 528                                  sizeof(lpmlcA->pamxctrl[i].szShortName), NULL, NULL );
 529             WideCharToMultiByte( CP_ACP, 0, mlcW.pamxctrl[i].szName, -1,
 530                                  lpmlcA->pamxctrl[i].szName,
 531                                  sizeof(lpmlcA->pamxctrl[i].szName), NULL, NULL );
 532             /* sizeof(lpmlcA->pamxctrl[i].Bounds) ==
 533              * sizeof(mlcW.pamxctrl[i].Bounds) */
 534             memcpy(&lpmlcA->pamxctrl[i].Bounds, &mlcW.pamxctrl[i].Bounds,
 535                    sizeof(mlcW.pamxctrl[i].Bounds));
 536             /* sizeof(lpmlcA->pamxctrl[i].Metrics) ==
 537              * sizeof(mlcW.pamxctrl[i].Metrics) */
 538             memcpy(&lpmlcA->pamxctrl[i].Metrics, &mlcW.pamxctrl[i].Metrics,
 539                    sizeof(mlcW.pamxctrl[i].Metrics));
 540         }
 541     }
 542
 543     HeapFree(GetProcessHeap(), 0, mlcW.pamxctrl);
 544
 545     return ret;
 546 }
 547
 548 /**************************************************************************
 549  *                              mixerGetLineControlsW           [WINMM.@]
 550  */
 551 UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
 552                                   DWORD fdwControls)
 553 {
 554     LPWINE_MIXER        lpwm;
 555     UINT                uRet = MMSYSERR_NOERROR;
 556
 557     TRACE("(%p, %p, %08lx)\n", hmix, lpmlcW, fdwControls);
 558
 559     if ((uRet = MIXER_GetDev(hmix, fdwControls, &lpwm)) != MMSYSERR_NOERROR)
 560         return uRet;
 561
 562     if (lpmlcW == NULL || lpmlcW->cbStruct != sizeof(*lpmlcW))
 563         return MMSYSERR_INVALPARAM;
 564
 565     return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD_PTR)lpmlcW,
 566                          fdwControls, TRUE);
 567 }
 568
 569 /**************************************************************************
 570  *                              mixerGetLineInfoW               [WINMM.@]
 571  */
 572 UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo)
 573 {
 574     LPWINE_MIXER        lpwm;
 575     UINT                uRet = MMSYSERR_NOERROR;
 576
 577     TRACE("(%p, %p, %08lx)\n", hmix, lpmliW, fdwInfo);
 578
 579     if ((uRet = MIXER_GetDev(hmix, fdwInfo, &lpwm)) != MMSYSERR_NOERROR)
 580         return uRet;
 581
 582     return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD_PTR)lpmliW,
 583                          fdwInfo, TRUE);
 584 }
 585
 586 /**************************************************************************
 587  *                              mixerGetLineInfoA               [WINMM.@]
 588  */
 589 UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
 590                               DWORD fdwInfo)
 591 {
 592     MIXERLINEW          mliW;
 593     UINT                ret;
 594
 595     TRACE("(%p, %p, %08lx)\n", hmix, lpmliA, fdwInfo);
 596
 597     if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
 598         return MMSYSERR_INVALPARAM;
 599
 600     mliW.cbStruct = sizeof(mliW);
 601     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
 602     case MIXER_GETLINEINFOF_COMPONENTTYPE:
 603         mliW.dwComponentType = lpmliA->dwComponentType;
 604         break;
 605     case MIXER_GETLINEINFOF_DESTINATION:
 606         mliW.dwDestination = lpmliA->dwDestination;
 607         break;
 608     case MIXER_GETLINEINFOF_LINEID:
 609         mliW.dwLineID = lpmliA->dwLineID;
 610         break;
 611     case MIXER_GETLINEINFOF_SOURCE:
 612         mliW.dwDestination = lpmliA->dwDestination;
 613         mliW.dwSource = lpmliA->dwSource;
 614         break;
 615     case MIXER_GETLINEINFOF_TARGETTYPE:
 616         mliW.Target.dwType = lpmliA->Target.dwType;
 617         mliW.Target.wMid = lpmliA->Target.wMid;
 618         mliW.Target.wPid = lpmliA->Target.wPid;
 619         mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion;
 620         MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname));
 621         break;
 622     default:
 623         WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo);
 624         return MMSYSERR_INVALFLAG;
 625     }
 626
 627     ret = mixerGetLineInfoW(hmix, &mliW, fdwInfo);
 628
 629     lpmliA->dwDestination = mliW.dwDestination;
 630     lpmliA->dwSource = mliW.dwSource;
 631     lpmliA->dwLineID = mliW.dwLineID;
 632     lpmliA->fdwLine = mliW.fdwLine;
 633     lpmliA->dwUser = mliW.dwUser;
 634     lpmliA->dwComponentType = mliW.dwComponentType;
 635     lpmliA->cChannels = mliW.cChannels;
 636     lpmliA->cConnections = mliW.cConnections;
 637     lpmliA->cControls = mliW.cControls;
 638     WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName,
 639                          sizeof(lpmliA->szShortName), NULL, NULL);
 640     WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName,
 641                          sizeof(lpmliA->szName), NULL, NULL );
 642     lpmliA->Target.dwType = mliW.Target.dwType;
 643     lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID;
 644     lpmliA->Target.wMid = mliW.Target.wMid;
 645     lpmliA->Target.wPid = mliW.Target.wPid;
 646     lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion;
 647     WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname,
 648                          sizeof(lpmliA->Target.szPname), NULL, NULL );
 649
 650     return ret;
 651 }
 652
 653 /**************************************************************************
 654  *                              mixerSetControlDetails  [WINMM.@]
 655  */
 656 UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
 657                                    DWORD fdwDetails)
 658 {
 659     LPWINE_MIXER        lpwm;
 660     UINT                uRet = MMSYSERR_NOERROR;
 661
 662     TRACE("(%p, %p, %08lx)\n", hmix, lpmcd, fdwDetails);
 663
 664     if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR)
 665         return uRet;
 666
 667     return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD_PTR)lpmcd,
 668                          fdwDetails, TRUE);
 669 }
 670
 671 /**************************************************************************
 672  *                              mixerMessage            [WINMM.@]
 673  */
 674 DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 675 {
 676     LPWINE_MLD          wmld;
 677
 678     TRACE("(%04lx, %d, %08lx, %08lx): semi-stub?\n",
 679           (DWORD)hmix, uMsg, dwParam1, dwParam2);
 680
 681     if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL)
 682         return MMSYSERR_INVALHANDLE;
 683
 684     return MMDRV_Message(wmld, uMsg, dwParam1, dwParam2, TRUE);
 685 }
 686
 687 /**************************************************************************
 688  *                              auxGetNumDevs           [WINMM.@]
 689  */
 690 UINT WINAPI auxGetNumDevs(void)
 691 {
 692     return MMDRV_GetNum(MMDRV_AUX);
 693 }
 694
 695 /**************************************************************************
 696  *                              auxGetDevCapsW          [WINMM.@]
 697  */
 698 UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
 699 {
 700     LPWINE_MLD          wmld;
 701
 702     TRACE("(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
 703
 704     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 705
 706     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
 707         return MMSYSERR_INVALHANDLE;
 708     return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
 709 }
 710
 711 /**************************************************************************
 712  *                              auxGetDevCapsA          [WINMM.@]
 713  */
 714 UINT WINAPI auxGetDevCapsA(UINT_PTR uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
 715 {
 716     AUXCAPSW    acW;
 717     UINT        ret;
 718
 719     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
 720
 721     ret = auxGetDevCapsW(uDeviceID, &acW, sizeof(acW));
 722
 723     if (ret == MMSYSERR_NOERROR) {
 724         AUXCAPSA acA;
 725         acA.wMid           = acW.wMid;
 726         acA.wPid           = acW.wPid;
 727         acA.vDriverVersion = acW.vDriverVersion;
 728         WideCharToMultiByte( CP_ACP, 0, acW.szPname, -1, acA.szPname,
 729                              sizeof(acA.szPname), NULL, NULL );
 730         acA.wTechnology    = acW.wTechnology;
 731         acA.dwSupport      = acW.dwSupport;
 732         memcpy(lpCaps, &acA, min(uSize, sizeof(acA)));
 733     }
 734     return ret;
 735 }
 736
 737 /**************************************************************************
 738  *                              auxGetVolume            [WINMM.@]
 739  */
 740 UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
 741 {
 742     LPWINE_MLD          wmld;
 743
 744     TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
 745
 746     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
 747         return MMSYSERR_INVALHANDLE;
 748     return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
 749 }
 750
 751 /**************************************************************************
 752  *                              auxSetVolume            [WINMM.@]
 753  */
 754 UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
 755 {
 756     LPWINE_MLD          wmld;
 757
 758     TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume);
 759
 760     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
 761         return MMSYSERR_INVALHANDLE;
 762     return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
 763 }
 764
 765 /**************************************************************************
 766  *                              auxOutMessage           [WINMM.@]
 767  */
 768 UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PTR dw2)
 769 {
 770     LPWINE_MLD          wmld;
 771
 772     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
 773         return MMSYSERR_INVALHANDLE;
 774
 775     return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
 776 }
 777
 778 /**************************************************************************
 779  *                              mciGetErrorStringW              [WINMM.@]
 780  */
 781 BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
 782 {
 783     char       bufstr[MAXERRORLENGTH];
 784     BOOL       ret = mciGetErrorStringA(wError, bufstr, MAXERRORLENGTH);
 785
 786     MultiByteToWideChar( CP_ACP, 0, bufstr, -1, lpstrBuffer, uLength );
 787     return ret;
 788 }
 789
 790 /**************************************************************************
 791  *                              mciGetErrorStringA              [WINMM.@]
 792  */
 793 BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
 794 {
 795     BOOL                ret = FALSE;
 796
 797     if (lpstrBuffer != NULL && uLength > 0 &&
 798         dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) {
 799
 800         if (LoadStringA(WINMM_IData->hWinMM32Instance,
 801                         dwError, lpstrBuffer, uLength) > 0) {
 802             ret = TRUE;
 803         }
 804     }
 805     return ret;
 806 }
 807
 808 /**************************************************************************
 809  *                      mciDriverNotify                         [WINMM.@]
 810  */
 811 BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
 812 {
 813     TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
 814
 815     return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
 816 }
 817
 818 /**************************************************************************
 819  *                      mciGetDriverData                        [WINMM.@]
 820  */
 821 DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
 822 {
 823     LPWINE_MCIDRIVER    wmd;
 824
 825     TRACE("(%04x)\n", uDeviceID);
 826
 827     wmd = MCI_GetDriver(uDeviceID);
 828
 829     if (!wmd) {
 830         WARN("Bad uDeviceID\n");
 831         return 0L;
 832     }
 833
 834     return wmd->dwPrivate;
 835 }
 836
 837 /**************************************************************************
 838  *                      mciSetDriverData                        [WINMM.@]
 839  */
 840 BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data)
 841 {
 842     LPWINE_MCIDRIVER    wmd;
 843
 844     TRACE("(%04x, %08lx)\n", uDeviceID, data);
 845
 846     wmd = MCI_GetDriver(uDeviceID);
 847
 848     if (!wmd) {
 849         WARN("Bad uDeviceID\n");
 850         return FALSE;
 851     }
 852
 853     wmd->dwPrivate = data;
 854     return TRUE;
 855 }
 856
 857 /**************************************************************************
 858  *                              mciSendCommandA                 [WINMM.@]
 859  */
 860 DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 861 {
 862     DWORD       dwRet;
 863
 864     TRACE("(%08x, %s, %08lx, %08lx)\n",
 865           wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
 866
 867     dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE);
 868     dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2);
 869     TRACE("=> %08lx\n", dwRet);
 870     return dwRet;
 871 }
 872
 873 inline static LPSTR strdupWtoA( LPCWSTR str )
 874 {
 875     LPSTR ret;
 876     INT len;
 877
 878     if (!str) return NULL;
 879     len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
 880     ret = HeapAlloc( GetProcessHeap(), 0, len );
 881     if(ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
 882     return ret;
 883 }
 884
 885 static int MCI_MapMsgWtoA(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
 886 {
 887     switch(msg)
 888     {
 889     case MCI_CLOSE:
 890     case MCI_PLAY:
 891     case MCI_SEEK:
 892     case MCI_STOP:
 893     case MCI_PAUSE:
 894     case MCI_GETDEVCAPS:
 895     case MCI_SPIN:
 896     case MCI_SET:
 897     case MCI_STEP:
 898     case MCI_RECORD:
 899     case MCI_BREAK:
 900     case MCI_SOUND:
 901     case MCI_STATUS:
 902     case MCI_CUE:
 903     case MCI_REALIZE:
 904     case MCI_PUT:
 905     case MCI_WHERE:
 906     case MCI_FREEZE:
 907     case MCI_UNFREEZE:
 908     case MCI_CUT:
 909     case MCI_COPY:
 910     case MCI_PASTE:
 911     case MCI_UPDATE:
 912     case MCI_RESUME:
 913     case MCI_DELETE:
 914         return 0;
 915
 916     case MCI_OPEN:
 917         {
 918             MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)*dwParam2;
 919             MCI_OPEN_PARMSA *mci_openA;
 920             DWORD_PTR *ptr;
 921
 922             ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_openA) + sizeof(DWORD_PTR));
 923             if (!ptr) return -1;
 924
 925             *ptr++ = *dwParam2; /* save the previous pointer */
 926             *dwParam2 = (DWORD_PTR)ptr;
 927             mci_openA = (MCI_OPEN_PARMSA *)ptr;
 928
 929             if (dwParam1 & MCI_NOTIFY)
 930                 mci_openA->dwCallback = mci_openW->dwCallback;
 931
 932             if (dwParam1 & MCI_OPEN_TYPE)
 933             {
 934                 if (dwParam1 & MCI_OPEN_TYPE_ID)
 935                     mci_openA->lpstrDeviceType = (LPSTR)mci_openW->lpstrDeviceType;
 936                 else
 937                     mci_openA->lpstrDeviceType = strdupWtoA(mci_openW->lpstrDeviceType);
 938             }
 939             if (dwParam1 & MCI_OPEN_ELEMENT)
 940             {
 941                 if (dwParam1 & MCI_OPEN_ELEMENT_ID)
 942                     mci_openA->lpstrElementName = (LPSTR)mci_openW->lpstrElementName;
 943                 else
 944                     mci_openA->lpstrElementName = strdupWtoA(mci_openW->lpstrElementName);
 945             }
 946             if (dwParam1 & MCI_OPEN_ALIAS)
 947                 mci_openA->lpstrAlias = strdupWtoA(mci_openW->lpstrAlias);
 948         }
 949         return 1;
 950
 951     case MCI_WINDOW:
 952         if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
 953         {
 954             MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)*dwParam2;
 955             MCI_ANIM_WINDOW_PARMSA *mci_windowA;
 956
 957             mci_windowA = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowA));
 958             if (!mci_windowA) return -1;
 959
 960             *dwParam2 = (DWORD_PTR)mci_windowA;
 961
 962             mci_windowA->lpstrText = strdupWtoA(mci_windowW->lpstrText);
 963
 964             if (dwParam1 & MCI_NOTIFY)
 965                 mci_windowA->dwCallback = mci_windowW->dwCallback;
 966             if (dwParam1 & MCI_ANIM_WINDOW_HWND)
 967                 mci_windowA->hWnd = mci_windowW->hWnd;
 968             if (dwParam1 & MCI_ANIM_WINDOW_STATE)
 969                 mci_windowA->nCmdShow = mci_windowW->nCmdShow;
 970
 971             return 1;
 972         }
 973         return 0;
 974
 975     case MCI_SYSINFO:
 976         {
 977             MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)*dwParam2;
 978             MCI_SYSINFO_PARMSA *mci_sysinfoA;
 979             DWORD_PTR *ptr;
 980
 981             ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoA) + sizeof(DWORD_PTR));
 982             if (!ptr) return -1;
 983
 984             *ptr++ = *dwParam2; /* save the previous pointer */
 985             *dwParam2 = (DWORD_PTR)ptr;
 986             mci_sysinfoA = (MCI_SYSINFO_PARMSA *)ptr;
 987
 988             if (dwParam1 & MCI_NOTIFY)
 989                 mci_sysinfoA->dwCallback = mci_sysinfoW->dwCallback;
 990
 991             mci_sysinfoA->dwRetSize = mci_sysinfoW->dwRetSize; /* FIXME */
 992             mci_sysinfoA->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoA->dwRetSize);
 993
 994             return 1;
 995         }
 996
 997     case MCI_INFO:
 998     case MCI_SAVE:
 999     case MCI_LOAD:
1000     case MCI_ESCAPE:
1001     default:
1002         FIXME("Message 0x%04x needs translation\n", msg);
1003         return -1;
1004     }
1005 }
1006
1007 static DWORD MCI_UnmapMsgWtoA(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2,
1008                               DWORD result)
1009 {
1010     switch(msg)
1011     {
1012     case MCI_OPEN:
1013         {
1014             DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
1015             MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)*ptr;
1016             MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)(ptr + 1);
1017
1018             mci_openW->wDeviceID = mci_openA->wDeviceID;
1019
1020             if (dwParam1 & MCI_OPEN_TYPE)
1021             {
1022                 if (!(dwParam1 & MCI_OPEN_TYPE_ID))
1023                     HeapFree(GetProcessHeap(), 0, mci_openA->lpstrDeviceType);
1024             }
1025             if (dwParam1 & MCI_OPEN_ELEMENT)
1026             {
1027                 if (!(dwParam1 & MCI_OPEN_ELEMENT_ID))
1028                     HeapFree(GetProcessHeap(), 0, mci_openA->lpstrElementName);
1029             }
1030             if (dwParam1 & MCI_OPEN_ALIAS)
1031                 HeapFree(GetProcessHeap(), 0, mci_openA->lpstrAlias);
1032             HeapFree(GetProcessHeap(), 0, ptr);
1033         }
1034         break;
1035
1036     case MCI_WINDOW:
1037         if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
1038         {
1039             MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)dwParam2;
1040
1041             HeapFree(GetProcessHeap(), 0, (void *)mci_windowA->lpstrText);
1042             HeapFree(GetProcessHeap(), 0, mci_windowA);
1043         }
1044         break;
1045
1046     case MCI_SYSINFO:
1047         {
1048             DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
1049             MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)*ptr;
1050             MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)(ptr + 1);
1051
1052             if (!result)
1053             {
1054                 mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber;
1055                 mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType;
1056                 MultiByteToWideChar(CP_ACP, 0,
1057                                     mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize,
1058                                     mci_sysinfoW->lpstrReturn, mci_sysinfoW->dwRetSize);
1059             }
1060
1061             HeapFree(GetProcessHeap(), 0, mci_sysinfoA->lpstrReturn);
1062             HeapFree(GetProcessHeap(), 0, ptr);
1063         }
1064         break;
1065
1066     default:
1067         FIXME("Message 0x%04x needs unmapping\n", msg);
1068         break;
1069     }
1070
1071     return result;
1072 }
1073
1074
1075 /**************************************************************************
1076  *                              mciSendCommandW                 [WINMM.@]
1077  *
1078  * FIXME: we should do the things other way around, but since our
1079  * MM subsystem is not unicode aware...
1080  */
1081 DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1082 {
1083     DWORD ret;
1084     int mapped;
1085
1086     TRACE("(%08x, %s, %08lx, %08lx)\n",
1087           wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
1088
1089     mapped = MCI_MapMsgWtoA(wMsg, dwParam1, &dwParam2);
1090     if (mapped == -1)
1091     {
1092         FIXME("message %04x mapping failed\n", wMsg);
1093         return MMSYSERR_NOMEM;
1094     }
1095     ret = mciSendCommandA(wDevID, wMsg, dwParam1, dwParam2);
1096     if (mapped)
1097         MCI_UnmapMsgWtoA(wMsg, dwParam1, dwParam2, ret);
1098     return ret;
1099 }
1100
1101 /**************************************************************************
1102  *                              mciGetDeviceIDA                 [WINMM.@]
1103  */
1104 UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
1105 {
1106     return MCI_GetDriverFromString(lpstrName);
1107 }
1108
1109 /**************************************************************************
1110  *                              mciGetDeviceIDW                 [WINMM.@]
1111  */
1112 UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
1113 {
1114     LPSTR       lpstrName = NULL;
1115     UINT        ret;
1116     INT         len;
1117
1118     if (lpwstrName) {
1119         len = WideCharToMultiByte( CP_ACP, 0, lpwstrName, -1, NULL, 0, NULL, NULL );
1120         lpstrName = HeapAlloc( GetProcessHeap(), 0, len );
1121         if (lpstrName) WideCharToMultiByte( CP_ACP, 0, lpwstrName, -1, lpstrName, len, NULL, NULL );
1122     }
1123     ret = MCI_GetDriverFromString(lpstrName);
1124     HeapFree(GetProcessHeap(), 0, lpstrName);
1125     return ret;
1126 }
1127
1128 /**************************************************************************
1129  *                              MCI_DefYieldProc                [internal]
1130  */
1131 UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
1132 {
1133     INT16       ret;
1134
1135     TRACE("(0x%04x, 0x%08lx)\n", wDevID, data);
1136
1137     if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
1138         (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
1139         MyUserYield();
1140         ret = 0;
1141     } else {
1142         MSG             msg;
1143
1144         msg.hwnd = HWND_32(HIWORD(data));
1145         while (!PeekMessageA(&msg, msg.hwnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
1146         ret = -1;
1147     }
1148     return ret;
1149 }
1150
1151 /**************************************************************************
1152  *                              mciSetYieldProc                 [WINMM.@]
1153  */
1154 BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
1155 {
1156     LPWINE_MCIDRIVER    wmd;
1157
1158     TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
1159
1160     if (!(wmd = MCI_GetDriver(uDeviceID))) {
1161         WARN("Bad uDeviceID\n");
1162         return FALSE;
1163     }
1164
1165     wmd->lpfnYieldProc = fpYieldProc;
1166     wmd->dwYieldData   = dwYieldData;
1167     wmd->bIs32         = TRUE;
1168
1169     return TRUE;
1170 }
1171
1172 /**************************************************************************
1173  *                              mciGetDeviceIDFromElementIDW    [WINMM.@]
1174  */
1175 UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
1176 {
1177     /* FIXME: that's rather strange, there is no
1178      * mciGetDeviceIDFromElementID32A in winmm.spec
1179      */
1180     FIXME("(%lu, %p) stub\n", dwElementID, lpstrType);
1181     return 0;
1182 }
1183
1184 /**************************************************************************
1185  *                              mciGetYieldProc                 [WINMM.@]
1186  */
1187 YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData)
1188 {
1189     LPWINE_MCIDRIVER    wmd;
1190
1191     TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
1192
1193     if (!(wmd = MCI_GetDriver(uDeviceID))) {
1194         WARN("Bad uDeviceID\n");
1195         return NULL;
1196     }
1197     if (!wmd->lpfnYieldProc) {
1198         WARN("No proc set\n");
1199         return NULL;
1200     }
1201     if (!wmd->bIs32) {
1202         WARN("Proc is 32 bit\n");
1203         return NULL;
1204     }
1205     return wmd->lpfnYieldProc;
1206 }
1207
1208 /**************************************************************************
1209  *                              mciGetCreatorTask               [WINMM.@]
1210  */
1211 HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
1212 {
1213     LPWINE_MCIDRIVER    wmd;
1214     HTASK ret = 0;
1215
1216     if ((wmd = MCI_GetDriver(uDeviceID))) ret = (HTASK)wmd->CreatorThread;
1217
1218     TRACE("(%u) => %p\n", uDeviceID, ret);
1219     return ret;
1220 }
1221
1222 /**************************************************************************
1223  *                      mciDriverYield                          [WINMM.@]
1224  */
1225 UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
1226 {
1227     LPWINE_MCIDRIVER    wmd;
1228     UINT                ret = 0;
1229
1230     TRACE("(%04x)\n", uDeviceID);
1231
1232     if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || !wmd->bIs32) {
1233         MyUserYield();
1234     } else {
1235         ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
1236     }
1237
1238     return ret;
1239 }
1240
1241 /**************************************************************************
1242  *                              midiOutGetNumDevs       [WINMM.@]
1243  */
1244 UINT WINAPI midiOutGetNumDevs(void)
1245 {
1246     return MMDRV_GetNum(MMDRV_MIDIOUT);
1247 }
1248
1249 /**************************************************************************
1250  *                              midiOutGetDevCapsW      [WINMM.@]
1251  */
1252 UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps,
1253                                UINT uSize)
1254 {
1255     LPWINE_MLD  wmld;
1256
1257     TRACE("(%u, %p, %u);\n", uDeviceID, lpCaps, uSize);
1258
1259     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1260
1261     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
1262         return MMSYSERR_INVALHANDLE;
1263
1264     return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
1265 }
1266
1267 /**************************************************************************
1268  *                              midiOutGetDevCapsA      [WINMM.@]
1269  */
1270 UINT WINAPI midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA lpCaps,
1271                                UINT uSize)
1272 {
1273     MIDIOUTCAPSW        mocW;
1274     UINT                ret;
1275
1276     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
1277
1278     ret = midiOutGetDevCapsW(uDeviceID, &mocW, sizeof(mocW));
1279
1280     if (ret == MMSYSERR_NOERROR) {
1281         MIDIOUTCAPSA mocA;
1282         mocA.wMid               = mocW.wMid;
1283         mocA.wPid               = mocW.wPid;
1284         mocA.vDriverVersion     = mocW.vDriverVersion;
1285         WideCharToMultiByte( CP_ACP, 0, mocW.szPname, -1, mocA.szPname,
1286                              sizeof(mocA.szPname), NULL, NULL );
1287         mocA.wTechnology        = mocW.wTechnology;
1288         mocA.wVoices            = mocW.wVoices;
1289         mocA.wNotes             = mocW.wNotes;
1290         mocA.wChannelMask       = mocW.wChannelMask;
1291         mocA.dwSupport          = mocW.dwSupport;
1292         memcpy(lpCaps, &mocA, min(uSize, sizeof(mocA)));
1293     }
1294     return ret;
1295 }
1296
1297 /**************************************************************************
1298  *                              MIDI_GetErrorText               [internal]
1299  */
1300 static  UINT16  MIDI_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1301 {
1302     UINT16              ret = MMSYSERR_BADERRNUM;
1303
1304     if (lpText == NULL) {
1305         ret = MMSYSERR_INVALPARAM;
1306     } else if (uSize == 0) {
1307         ret = MMSYSERR_NOERROR;
1308     } else if (
1309                /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
1310                 * a warning for the test was always true */
1311                (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
1312                (uError >= MIDIERR_BASE  && uError <= MIDIERR_LASTERROR)) {
1313
1314         if (LoadStringA(WINMM_IData->hWinMM32Instance,
1315                         uError, lpText, uSize) > 0) {
1316             ret = MMSYSERR_NOERROR;
1317         }
1318     }
1319     return ret;
1320 }
1321
1322 /**************************************************************************
1323  *                              midiOutGetErrorTextA    [WINMM.@]
1324  */
1325 UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
1326 {
1327     return MIDI_GetErrorText(uError, lpText, uSize);
1328 }
1329
1330 /**************************************************************************
1331  *                              midiOutGetErrorTextW    [WINMM.@]
1332  */
1333 UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
1334 {
1335     LPSTR       xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
1336     UINT        ret;
1337
1338     ret = MIDI_GetErrorText(uError, xstr, uSize);
1339     MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
1340     HeapFree(GetProcessHeap(), 0, xstr);
1341     return ret;
1342 }
1343
1344 /**************************************************************************
1345  *                              MIDI_OutAlloc                   [internal]
1346  */
1347 static  LPWINE_MIDI     MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback,
1348                                       LPDWORD lpdwInstance, LPDWORD lpdwFlags,
1349                                       DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32)
1350 {
1351     HANDLE              hMidiOut;
1352     LPWINE_MIDI         lpwm;
1353     UINT                size;
1354
1355     size = sizeof(WINE_MIDI) + (cIDs ? (cIDs-1) : 0) * sizeof(MIDIOPENSTRMID);
1356
1357     lpwm = (LPWINE_MIDI)MMDRV_Alloc(size, MMDRV_MIDIOUT, &hMidiOut, lpdwFlags,
1358                                     lpdwCallback, lpdwInstance, bFrom32);
1359
1360     if (lphMidiOut != NULL)
1361         *lphMidiOut = hMidiOut;
1362
1363     if (lpwm) {
1364         lpwm->mod.hMidi = (HMIDI) hMidiOut;
1365         lpwm->mod.dwCallback = *lpdwCallback;
1366         lpwm->mod.dwInstance = *lpdwInstance;
1367         lpwm->mod.dnDevNode = 0;
1368         lpwm->mod.cIds = cIDs;
1369         if (cIDs)
1370             memcpy(&(lpwm->mod.rgIds), lpIDs, cIDs * sizeof(MIDIOPENSTRMID));
1371     }
1372     return lpwm;
1373 }
1374
1375 UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
1376                   DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
1377 {
1378     HMIDIOUT            hMidiOut;
1379     LPWINE_MIDI         lpwm;
1380     UINT                dwRet = 0;
1381
1382     TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
1383           lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
1384
1385     if (lphMidiOut != NULL) *lphMidiOut = 0;
1386
1387     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags,
1388                          0, NULL, bFrom32);
1389
1390     if (lpwm == NULL)
1391         return MMSYSERR_NOMEM;
1392
1393     lpwm->mld.uDeviceID = uDeviceID;
1394
1395     dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD)&lpwm->mod, dwFlags);
1396
1397     if (dwRet != MMSYSERR_NOERROR) {
1398         MMDRV_Free(hMidiOut, (LPWINE_MLD)lpwm);
1399         hMidiOut = 0;
1400     }
1401
1402     if (lphMidiOut) *lphMidiOut = hMidiOut;
1403     TRACE("=> %d hMidi=%p\n", dwRet, hMidiOut);
1404
1405     return dwRet;
1406 }
1407
1408 /**************************************************************************
1409  *                              midiOutOpen             [WINMM.@]
1410  */
1411 UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
1412                        DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
1413 {
1414     return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
1415 }
1416
1417 /**************************************************************************
1418  *                              midiOutClose            [WINMM.@]
1419  */
1420 UINT WINAPI midiOutClose(HMIDIOUT hMidiOut)
1421 {
1422     LPWINE_MLD          wmld;
1423     DWORD               dwRet;
1424
1425     TRACE("(%p)\n", hMidiOut);
1426
1427     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1428         return MMSYSERR_INVALHANDLE;
1429
1430     dwRet = MMDRV_Close(wmld, MODM_CLOSE);
1431     MMDRV_Free(hMidiOut, wmld);
1432
1433     return dwRet;
1434 }
1435
1436 /**************************************************************************
1437  *                              midiOutPrepareHeader    [WINMM.@]
1438  */
1439 UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
1440                                  MIDIHDR* lpMidiOutHdr, UINT uSize)
1441 {
1442     LPWINE_MLD          wmld;
1443
1444     TRACE("(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
1445
1446     if (lpMidiOutHdr == NULL || uSize < sizeof (MIDIHDR))
1447         return MMSYSERR_INVALPARAM;
1448
1449     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1450         return MMSYSERR_INVALHANDLE;
1451
1452     return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
1453 }
1454
1455 /**************************************************************************
1456  *                              midiOutUnprepareHeader  [WINMM.@]
1457  */
1458 UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
1459                                    MIDIHDR* lpMidiOutHdr, UINT uSize)
1460 {
1461     LPWINE_MLD          wmld;
1462
1463     TRACE("(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
1464
1465     if (lpMidiOutHdr == NULL || uSize < sizeof (MIDIHDR))
1466         return MMSYSERR_INVALPARAM;
1467
1468     if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
1469         return MMSYSERR_NOERROR;
1470     }
1471
1472     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1473         return MMSYSERR_INVALHANDLE;
1474
1475     return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
1476 }
1477
1478 /**************************************************************************
1479  *                              midiOutShortMsg         [WINMM.@]
1480  */
1481 UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
1482 {
1483     LPWINE_MLD          wmld;
1484
1485     TRACE("(%p, %08lX)\n", hMidiOut, dwMsg);
1486
1487     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1488         return MMSYSERR_INVALHANDLE;
1489
1490     return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L, TRUE);
1491 }
1492
1493 /**************************************************************************
1494  *                              midiOutLongMsg          [WINMM.@]
1495  */
1496 UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
1497                            MIDIHDR* lpMidiOutHdr, UINT uSize)
1498 {
1499     LPWINE_MLD          wmld;
1500
1501     TRACE("(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
1502
1503     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1504         return MMSYSERR_INVALHANDLE;
1505
1506     return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
1507 }
1508
1509 /**************************************************************************
1510  *                              midiOutReset            [WINMM.@]
1511  */
1512 UINT WINAPI midiOutReset(HMIDIOUT hMidiOut)
1513 {
1514     LPWINE_MLD          wmld;
1515
1516     TRACE("(%p)\n", hMidiOut);
1517
1518     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1519         return MMSYSERR_INVALHANDLE;
1520
1521     return MMDRV_Message(wmld, MODM_RESET, 0L, 0L, TRUE);
1522 }
1523
1524 /**************************************************************************
1525  *                              midiOutGetVolume        [WINMM.@]
1526  */
1527 UINT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, DWORD* lpdwVolume)
1528 {
1529     LPWINE_MLD          wmld;
1530
1531     TRACE("(%p, %p);\n", hMidiOut, lpdwVolume);
1532
1533     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
1534         return MMSYSERR_INVALHANDLE;
1535
1536     return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
1537 }
1538
1539 /**************************************************************************
1540  *                              midiOutSetVolume        [WINMM.@]
1541  */
1542 UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume)
1543 {
1544     LPWINE_MLD          wmld;
1545
1546     TRACE("(%p, %ld);\n", hMidiOut, dwVolume);
1547
1548     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
1549         return MMSYSERR_INVALHANDLE;
1550
1551     return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L, TRUE);
1552 }
1553
1554 /**************************************************************************
1555  *                              midiOutCachePatches             [WINMM.@]
1556  */
1557 UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut, UINT uBank,
1558                                 WORD* lpwPatchArray, UINT uFlags)
1559 {
1560     /* not really necessary to support this */
1561     FIXME("not supported yet\n");
1562     return MMSYSERR_NOTSUPPORTED;
1563 }
1564
1565 /**************************************************************************
1566  *                              midiOutCacheDrumPatches [WINMM.@]
1567  */
1568 UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut, UINT uPatch,
1569                                     WORD* lpwKeyArray, UINT uFlags)
1570 {
1571     FIXME("not supported yet\n");
1572     return MMSYSERR_NOTSUPPORTED;
1573 }
1574
1575 /**************************************************************************
1576  *                              midiOutGetID            [WINMM.@]
1577  */
1578 UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
1579 {
1580     LPWINE_MLD          wmld;
1581
1582     TRACE("(%p, %p)\n", hMidiOut, lpuDeviceID);
1583
1584     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
1585     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
1586         return MMSYSERR_INVALHANDLE;
1587
1588     *lpuDeviceID = wmld->uDeviceID;
1589     return MMSYSERR_NOERROR;
1590 }
1591
1592 /**************************************************************************
1593  *                              midiOutMessage          [WINMM.@]
1594  */
1595 UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
1596                            DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1597 {
1598     LPWINE_MLD          wmld;
1599
1600     TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
1601
1602     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) {
1603         /* HACK... */
1604         if (uMessage == 0x0001) {
1605             *(LPDWORD)dwParam1 = 1;
1606             return 0;
1607         }
1608         if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) != NULL) {
1609             return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
1610         }
1611         return MMSYSERR_INVALHANDLE;
1612     }
1613
1614     switch (uMessage) {
1615     case MODM_OPEN:
1616     case MODM_CLOSE:
1617         FIXME("can't handle OPEN or CLOSE message!\n");
1618         return MMSYSERR_NOTSUPPORTED;
1619     }
1620     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
1621 }
1622
1623 /**************************************************************************
1624  *                              midiInGetNumDevs        [WINMM.@]
1625  */
1626 UINT WINAPI midiInGetNumDevs(void)
1627 {
1628     return MMDRV_GetNum(MMDRV_MIDIIN);
1629 }
1630
1631 /**************************************************************************
1632  *                              midiInGetDevCapsW       [WINMM.@]
1633  */
1634 UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
1635 {
1636     LPWINE_MLD  wmld;
1637
1638     TRACE("(%d, %p, %d);\n", uDeviceID, lpCaps, uSize);
1639
1640     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1641
1642     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL)
1643         return MMSYSERR_INVALHANDLE;
1644
1645    return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
1646 }
1647
1648 /**************************************************************************
1649  *                              midiInGetDevCapsA       [WINMM.@]
1650  */
1651 UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
1652 {
1653     MIDIINCAPSW         micW;
1654     UINT                ret;
1655
1656     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
1657
1658     ret = midiInGetDevCapsW(uDeviceID, &micW, sizeof(micW));
1659
1660     if (ret == MMSYSERR_NOERROR) {
1661         MIDIINCAPSA micA;
1662         micA.wMid           = micW.wMid;
1663         micA.wPid           = micW.wPid;
1664         micA.vDriverVersion = micW.vDriverVersion;
1665         WideCharToMultiByte( CP_ACP, 0, micW.szPname, -1, micA.szPname,
1666                              sizeof(micA.szPname), NULL, NULL );
1667         micA.dwSupport      = micW.dwSupport;
1668         memcpy(lpCaps, &micA, min(uSize, sizeof(micA)));
1669     }
1670     return ret;
1671 }
1672
1673 /**************************************************************************
1674  *                              midiInGetErrorTextW             [WINMM.@]
1675  */
1676 UINT WINAPI midiInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
1677 {
1678     LPSTR       xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
1679     UINT        ret = MIDI_GetErrorText(uError, xstr, uSize);
1680
1681     MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
1682     HeapFree(GetProcessHeap(), 0, xstr);
1683     return ret;
1684 }
1685
1686 /**************************************************************************
1687  *                              midiInGetErrorTextA             [WINMM.@]
1688  */
1689 UINT WINAPI midiInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
1690 {
1691     return MIDI_GetErrorText(uError, lpText, uSize);
1692 }
1693
1694 UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
1695                  DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
1696 {
1697     HANDLE              hMidiIn;
1698     LPWINE_MIDI         lpwm;
1699     DWORD               dwRet = 0;
1700
1701     TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
1702           lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
1703
1704     if (lphMidiIn != NULL) *lphMidiIn = 0;
1705
1706     lpwm = (LPWINE_MIDI)MMDRV_Alloc(sizeof(WINE_MIDI), MMDRV_MIDIIN, &hMidiIn,
1707                                     &dwFlags, &dwCallback, &dwInstance, bFrom32);
1708
1709     if (lpwm == NULL)
1710         return MMSYSERR_NOMEM;
1711
1712     lpwm->mod.hMidi = (HMIDI) hMidiIn;
1713     lpwm->mod.dwCallback = dwCallback;
1714     lpwm->mod.dwInstance = dwInstance;
1715
1716     lpwm->mld.uDeviceID = uDeviceID;
1717     dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD)&lpwm->mod, dwFlags);
1718
1719     if (dwRet != MMSYSERR_NOERROR) {
1720         MMDRV_Free(hMidiIn, &lpwm->mld);
1721         hMidiIn = 0;
1722     }
1723     if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
1724     TRACE("=> %ld hMidi=%p\n", dwRet, hMidiIn);
1725
1726     return dwRet;
1727 }
1728
1729 /**************************************************************************
1730  *                              midiInOpen              [WINMM.@]
1731  */
1732 UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
1733                        DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
1734 {
1735     return MIDI_InOpen(lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
1736 }
1737
1738 /**************************************************************************
1739  *                              midiInClose             [WINMM.@]
1740  */
1741 UINT WINAPI midiInClose(HMIDIIN hMidiIn)
1742 {
1743     LPWINE_MLD          wmld;
1744     DWORD               dwRet;
1745
1746     TRACE("(%p)\n", hMidiIn);
1747
1748     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1749         return MMSYSERR_INVALHANDLE;
1750
1751     dwRet = MMDRV_Close(wmld, MIDM_CLOSE);
1752     MMDRV_Free(hMidiIn, wmld);
1753     return dwRet;
1754 }
1755
1756 /**************************************************************************
1757  *                              midiInPrepareHeader     [WINMM.@]
1758  */
1759 UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
1760                                 MIDIHDR* lpMidiInHdr, UINT uSize)
1761 {
1762     LPWINE_MLD          wmld;
1763
1764     TRACE("(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
1765
1766     if (lpMidiInHdr == NULL || uSize < sizeof (MIDIHDR))
1767         return MMSYSERR_INVALPARAM;
1768
1769     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1770         return MMSYSERR_INVALHANDLE;
1771
1772     return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
1773 }
1774
1775 /**************************************************************************
1776  *                              midiInUnprepareHeader   [WINMM.@]
1777  */
1778 UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
1779                                   MIDIHDR* lpMidiInHdr, UINT uSize)
1780 {
1781     LPWINE_MLD          wmld;
1782
1783     TRACE("(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
1784
1785     if (lpMidiInHdr == NULL || uSize < sizeof (MIDIHDR))
1786         return MMSYSERR_INVALPARAM;
1787
1788     if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
1789         return MMSYSERR_NOERROR;
1790     }
1791
1792     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1793         return MMSYSERR_INVALHANDLE;
1794
1795     return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
1796 }
1797
1798 /**************************************************************************
1799  *                              midiInAddBuffer         [WINMM.@]
1800  */
1801 UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
1802                             MIDIHDR* lpMidiInHdr, UINT uSize)
1803 {
1804     LPWINE_MLD          wmld;
1805
1806     TRACE("(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
1807
1808     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1809         return MMSYSERR_INVALHANDLE;
1810
1811     return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
1812 }
1813
1814 /**************************************************************************
1815  *                              midiInStart                     [WINMM.@]
1816  */
1817 UINT WINAPI midiInStart(HMIDIIN hMidiIn)
1818 {
1819     LPWINE_MLD          wmld;
1820
1821     TRACE("(%p)\n", hMidiIn);
1822
1823     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1824         return MMSYSERR_INVALHANDLE;
1825
1826     return MMDRV_Message(wmld, MIDM_START, 0L, 0L, TRUE);
1827 }
1828
1829 /**************************************************************************
1830  *                              midiInStop                      [WINMM.@]
1831  */
1832 UINT WINAPI midiInStop(HMIDIIN hMidiIn)
1833 {
1834     LPWINE_MLD          wmld;
1835
1836     TRACE("(%p)\n", hMidiIn);
1837
1838     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1839         return MMSYSERR_INVALHANDLE;
1840
1841     return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L, TRUE);
1842 }
1843
1844 /**************************************************************************
1845  *                              midiInReset                     [WINMM.@]
1846  */
1847 UINT WINAPI midiInReset(HMIDIIN hMidiIn)
1848 {
1849     LPWINE_MLD          wmld;
1850
1851     TRACE("(%p)\n", hMidiIn);
1852
1853     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1854         return MMSYSERR_INVALHANDLE;
1855
1856     return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L, TRUE);
1857 }
1858
1859 /**************************************************************************
1860  *                              midiInGetID                     [WINMM.@]
1861  */
1862 UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT* lpuDeviceID)
1863 {
1864     LPWINE_MLD          wmld;
1865
1866     TRACE("(%p, %p)\n", hMidiIn, lpuDeviceID);
1867
1868     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
1869
1870     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, TRUE)) == NULL)
1871         return MMSYSERR_INVALHANDLE;
1872
1873     *lpuDeviceID = wmld->uDeviceID;
1874
1875     return MMSYSERR_NOERROR;
1876 }
1877
1878 /**************************************************************************
1879  *                              midiInMessage           [WINMM.@]
1880  */
1881 UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
1882                           DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1883 {
1884     LPWINE_MLD          wmld;
1885
1886     TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
1887
1888     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
1889         return MMSYSERR_INVALHANDLE;
1890
1891     switch (uMessage) {
1892     case MIDM_OPEN:
1893     case MIDM_CLOSE:
1894         FIXME("can't handle OPEN or CLOSE message!\n");
1895         return MMSYSERR_NOTSUPPORTED;
1896     }
1897     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
1898 }
1899
1900 typedef struct WINE_MIDIStream {
1901     HMIDIOUT                    hDevice;
1902     HANDLE                      hThread;
1903     DWORD                       dwThreadID;
1904     DWORD                       dwTempo;
1905     DWORD                       dwTimeDiv;
1906     DWORD                       dwPositionMS;
1907     DWORD                       dwPulses;
1908     DWORD                       dwStartTicks;
1909     WORD                        wFlags;
1910     HANDLE                      hEvent;
1911     LPMIDIHDR                   lpMidiHdr;
1912 } WINE_MIDIStream;
1913
1914 #define WINE_MSM_HEADER         (WM_USER+0)
1915 #define WINE_MSM_STOP           (WM_USER+1)
1916
1917 /**************************************************************************
1918  *                              MMSYSTEM_GetMidiStream          [internal]
1919  */
1920 static  BOOL    MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm, WINE_MIDIStream** lpMidiStrm, WINE_MIDI** lplpwm)
1921 {
1922     WINE_MIDI* lpwm = (LPWINE_MIDI)MMDRV_Get(hMidiStrm, MMDRV_MIDIOUT, FALSE);
1923
1924     if (lplpwm)
1925         *lplpwm = lpwm;
1926
1927     if (lpwm == NULL) {
1928         return FALSE;
1929     }
1930
1931     *lpMidiStrm = (WINE_MIDIStream*)lpwm->mod.rgIds.dwStreamID;
1932
1933     return *lpMidiStrm != NULL;
1934 }
1935
1936 /**************************************************************************
1937  *                              MMSYSTEM_MidiStream_Convert     [internal]
1938  */
1939 static  DWORD   MMSYSTEM_MidiStream_Convert(WINE_MIDIStream* lpMidiStrm, DWORD pulse)
1940 {
1941     DWORD       ret = 0;
1942
1943     if (lpMidiStrm->dwTimeDiv == 0) {
1944         FIXME("Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
1945     } else if (lpMidiStrm->dwTimeDiv > 0x8000) { /* SMPTE, unchecked FIXME? */
1946         int     nf = -(char)HIBYTE(lpMidiStrm->dwTimeDiv);      /* number of frames     */
1947         int     nsf = LOBYTE(lpMidiStrm->dwTimeDiv);            /* number of sub-frames */
1948         ret = (pulse * 1000) / (nf * nsf);
1949     } else {
1950         ret = (DWORD)((double)pulse * ((double)lpMidiStrm->dwTempo / 1000) /
1951                       (double)lpMidiStrm->dwTimeDiv);
1952     }
1953
1954     return ret;
1955 }
1956
1957 /**************************************************************************
1958  *                      MMSYSTEM_MidiStream_MessageHandler      [internal]
1959  */
1960 static  BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWINE_MIDI lpwm, LPMSG msg)
1961 {
1962     LPMIDIHDR   lpMidiHdr;
1963     LPMIDIHDR*  lpmh;
1964     LPBYTE      lpData;
1965
1966     switch (msg->message) {
1967     case WM_QUIT:
1968         SetEvent(lpMidiStrm->hEvent);
1969         return FALSE;
1970     case WINE_MSM_STOP:
1971         TRACE("STOP\n");
1972         /* this is not quite what MS doc says... */
1973         midiOutReset(lpMidiStrm->hDevice);
1974         /* empty list of already submitted buffers */
1975         for (lpMidiHdr = lpMidiStrm->lpMidiHdr; lpMidiHdr; lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext) {
1976             lpMidiHdr->dwFlags |= MHDR_DONE;
1977             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1978
1979             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
1980                            (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
1981                            lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
1982         }
1983         lpMidiStrm->lpMidiHdr = 0;
1984         SetEvent(lpMidiStrm->hEvent);
1985         break;
1986     case WINE_MSM_HEADER:
1987         /* sets initial tick count for first MIDIHDR */
1988         if (!lpMidiStrm->dwStartTicks)
1989             lpMidiStrm->dwStartTicks = GetTickCount();
1990
1991         /* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
1992          * by native mcimidi, it doesn't look like a correct one".
1993          * this trick allows to throw it away... but I don't like it.
1994          * It looks like part of the file I'm trying to play and definitively looks
1995          * like raw midi content
1996          * I'd really like to understand why native mcimidi sends it. Perhaps a bad
1997          * synchronization issue where native mcimidi is still processing raw MIDI
1998          * content before generating MIDIEVENTs ?
1999          *
2000          * 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
2001          * 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
2002          * 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
2003          * 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
2004          * 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
2005          * 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
2006          * 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
2007          * 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
2008          * 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
2009          * 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
2010          * 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
2011          * 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
2012          * 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
2013          * 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
2014          * 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
2015          * 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
2016          * 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
2017          */
2018         lpMidiHdr = (LPMIDIHDR)msg->lParam;
2019         lpData = lpMidiHdr->lpData;
2020         TRACE("Adding %s lpMidiHdr=%p [lpData=0x%08lx dwBufferLength=%lu/%lu dwFlags=0x%08lx size=%u]\n",
2021               (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
2022               (DWORD)lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded,
2023               lpMidiHdr->dwFlags, msg->wParam);
2024 #if 0
2025         /* dumps content of lpMidiHdr->lpData
2026          * FIXME: there should be a debug routine somewhere that already does this
2027          * I hate spreading this type of shit all around the code
2028          */
2029         for (dwToGo = 0; dwToGo < lpMidiHdr->dwBufferLength; dwToGo += 16) {
2030             DWORD       i;
2031             BYTE        ch;
2032
2033             for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++)
2034                 printf("%02x ", lpData[dwToGo + i]);
2035             for (; i < 16; i++)
2036                 printf("   ");
2037             for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++) {
2038                 ch = lpData[dwToGo + i];
2039                 printf("%c", (ch >= 0x20 && ch <= 0x7F) ? ch : '.');
2040             }
2041             printf("\n");
2042         }
2043 #endif
2044         if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
2045             ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
2046             ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
2047             FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n",
2048                   (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
2049                   ((LPMIDIEVENT)lpData)->dwStreamID);
2050             lpMidiHdr->dwFlags |= MHDR_DONE;
2051             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
2052
2053             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
2054                            (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
2055                            lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
2056             break;
2057         }
2058
2059         for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = (LPMIDIHDR*)&((*lpmh)->lpNext));
2060         *lpmh = lpMidiHdr;
2061         lpMidiHdr = (LPMIDIHDR)msg->lParam;
2062         lpMidiHdr->lpNext = 0;
2063         lpMidiHdr->dwFlags |= MHDR_INQUEUE;
2064         lpMidiHdr->dwFlags &= ~MHDR_DONE;
2065         lpMidiHdr->dwOffset = 0;
2066
2067         break;
2068     default:
2069         FIXME("Unknown message %d\n", msg->message);
2070         break;
2071     }
2072     return TRUE;
2073 }
2074
2075 /**************************************************************************
2076  *                              MMSYSTEM_MidiStream_Player      [internal]
2077  */
2078 static  DWORD   CALLBACK        MMSYSTEM_MidiStream_Player(LPVOID pmt)
2079 {
2080     WINE_MIDIStream*    lpMidiStrm = pmt;
2081     WINE_MIDI*          lpwm;
2082     MSG                 msg;
2083     DWORD               dwToGo;
2084     DWORD               dwCurrTC;
2085     LPMIDIHDR           lpMidiHdr;
2086     LPMIDIEVENT         me;
2087     LPBYTE              lpData = 0;
2088
2089     TRACE("(%p)!\n", lpMidiStrm);
2090
2091     if (!lpMidiStrm ||
2092         (lpwm = (LPWINE_MIDI)MMDRV_Get(lpMidiStrm->hDevice, MMDRV_MIDIOUT, FALSE)) == NULL)
2093         goto the_end;
2094
2095     /* force thread's queue creation */
2096     /* Used to be InitThreadInput16(0, 5); */
2097     /* but following works also with hack in midiStreamOpen */
2098     PeekMessageA(&msg, 0, 0, 0, 0);
2099
2100     /* FIXME: this next line must be called before midiStreamOut or midiStreamRestart are called */
2101     SetEvent(lpMidiStrm->hEvent);
2102     TRACE("Ready to go 1\n");
2103     /* thread is started in paused mode */
2104     SuspendThread(lpMidiStrm->hThread);
2105     TRACE("Ready to go 2\n");
2106
2107     lpMidiStrm->dwStartTicks = 0;
2108     lpMidiStrm->dwPulses = 0;
2109
2110     lpMidiStrm->lpMidiHdr = 0;
2111
2112     for (;;) {
2113         lpMidiHdr = lpMidiStrm->lpMidiHdr;
2114         if (!lpMidiHdr) {
2115             /* for first message, block until one arrives, then process all that are available */
2116             GetMessageA(&msg, 0, 0, 0);
2117             do {
2118                 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm, lpwm, &msg))
2119                     goto the_end;
2120             } while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE));
2121             lpData = 0;
2122             continue;
2123         }
2124
2125         if (!lpData)
2126             lpData = lpMidiHdr->lpData;
2127
2128         me = (LPMIDIEVENT)(lpData + lpMidiHdr->dwOffset);
2129
2130         /* do we have to wait ? */
2131         if (me->dwDeltaTime) {
2132             lpMidiStrm->dwPositionMS += MMSYSTEM_MidiStream_Convert(lpMidiStrm, me->dwDeltaTime);
2133             lpMidiStrm->dwPulses += me->dwDeltaTime;
2134
2135             dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS;
2136
2137             TRACE("%ld/%ld/%ld\n", dwToGo, GetTickCount(), me->dwDeltaTime);
2138             while ((dwCurrTC = GetTickCount()) < dwToGo) {
2139                 if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) {
2140                     /* got a message, handle it */
2141                     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
2142                         if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm, lpwm, &msg))
2143                             goto the_end;
2144                     }
2145                     lpData = 0;
2146                 } else {
2147                     /* timeout, so me->dwDeltaTime is elapsed, can break the while loop */
2148                     break;
2149                 }
2150             }
2151         }
2152         switch (MEVT_EVENTTYPE(me->dwEvent & ~MEVT_F_CALLBACK)) {
2153         case MEVT_COMMENT:
2154             FIXME("NIY: MEVT_COMMENT\n");
2155             /* do nothing, skip bytes */
2156             break;
2157         case MEVT_LONGMSG:
2158             FIXME("NIY: MEVT_LONGMSG, aka sending Sysex event\n");
2159             break;
2160         case MEVT_NOP:
2161             break;
2162         case MEVT_SHORTMSG:
2163             midiOutShortMsg(lpMidiStrm->hDevice, MEVT_EVENTPARM(me->dwEvent));
2164             break;
2165         case MEVT_TEMPO:
2166             lpMidiStrm->dwTempo = MEVT_EVENTPARM(me->dwEvent);
2167             break;
2168         case MEVT_VERSION:
2169             break;
2170         default:
2171             FIXME("Unknown MEVT (0x%02x)\n", MEVT_EVENTTYPE(me->dwEvent & ~MEVT_F_CALLBACK));
2172             break;
2173         }
2174         if (me->dwEvent & MEVT_F_CALLBACK) {
2175             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
2176                            (HDRVR)lpMidiStrm->hDevice, MM_MOM_POSITIONCB,
2177                            lpwm->mod.dwInstance, (LPARAM)lpMidiHdr, 0L);
2178         }
2179         lpMidiHdr->dwOffset += sizeof(MIDIEVENT) - sizeof(me->dwParms);
2180         if (me->dwEvent & MEVT_F_LONG)
2181             lpMidiHdr->dwOffset += (MEVT_EVENTPARM(me->dwEvent) + 3) & ~3;
2182         if (lpMidiHdr->dwOffset >= lpMidiHdr->dwBufferLength) {
2183             /* done with this header */
2184             lpMidiHdr->dwFlags |= MHDR_DONE;
2185             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
2186
2187             lpMidiStrm->lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext;
2188             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
2189                            (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
2190                            lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
2191             lpData = 0;
2192         }
2193     }
2194 the_end:
2195     TRACE("End of thread\n");
2196     ExitThread(0);
2197     return 0;   /* for removing the warning, never executed */
2198 }
2199
2200 /**************************************************************************
2201  *                              MMSYSTEM_MidiStream_PostMessage [internal]
2202  */
2203 static  BOOL MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream* lpMidiStrm, WORD msg, DWORD pmt1, DWORD pmt2)
2204 {
2205     if (PostThreadMessageA(lpMidiStrm->dwThreadID, msg, pmt1, pmt2)) {
2206         DWORD   count;
2207
2208         if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
2209         WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
2210         if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
2211     } else {
2212         WARN("bad PostThreadMessageA\n");
2213         return FALSE;
2214     }
2215     return TRUE;
2216 }
2217
2218 /**************************************************************************
2219  *                              midiStreamClose                 [WINMM.@]
2220  */
2221 MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm)
2222 {
2223     WINE_MIDIStream*    lpMidiStrm;
2224
2225     TRACE("(%p)!\n", hMidiStrm);
2226
2227     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
2228         return MMSYSERR_INVALHANDLE;
2229
2230     midiStreamStop(hMidiStrm);
2231     MMSYSTEM_MidiStream_PostMessage(lpMidiStrm, WM_QUIT, 0, 0);
2232     HeapFree(GetProcessHeap(), 0, lpMidiStrm);
2233     CloseHandle(lpMidiStrm->hEvent);
2234
2235     return midiOutClose((HMIDIOUT)hMidiStrm);
2236 }
2237
2238 /**************************************************************************
2239  *                              MMSYSTEM_MidiStream_Open        [internal]
2240  */
2241 MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi,
2242                          DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen,
2243                          BOOL bFrom32)
2244 {
2245     WINE_MIDIStream*    lpMidiStrm;
2246     MMRESULT            ret;
2247     MIDIOPENSTRMID      mosm;
2248     LPWINE_MIDI         lpwm;
2249     HMIDIOUT            hMidiOut;
2250
2251     TRACE("(%p, %p, %ld, 0x%08lx, 0x%08lx, 0x%08lx)!\n",
2252           lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
2253
2254     if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
2255         return MMSYSERR_INVALPARAM;
2256
2257     lpMidiStrm = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream));
2258     if (!lpMidiStrm)
2259         return MMSYSERR_NOMEM;
2260
2261     lpMidiStrm->dwTempo = 500000;
2262     lpMidiStrm->dwTimeDiv = 480;        /* 480 is 120 quater notes per minute *//* FIXME ??*/
2263     lpMidiStrm->dwPositionMS = 0;
2264
2265     mosm.dwStreamID = (DWORD)lpMidiStrm;
2266     /* FIXME: the correct value is not allocated yet for MAPPER */
2267     mosm.wDeviceID  = *lpuDeviceID;
2268     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm, bFrom32);
2269     lpMidiStrm->hDevice = hMidiOut;
2270     if (lphMidiStrm)
2271         *lphMidiStrm = (HMIDISTRM)hMidiOut;
2272
2273     lpwm->mld.uDeviceID = *lpuDeviceID;
2274
2275     ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD)&lpwm->mod, fdwOpen);
2276     lpMidiStrm->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
2277     lpMidiStrm->wFlags = HIWORD(fdwOpen);
2278
2279     lpMidiStrm->hThread = CreateThread(NULL, 0, MMSYSTEM_MidiStream_Player,
2280                                        lpMidiStrm, 0, &(lpMidiStrm->dwThreadID));
2281
2282     if (!lpMidiStrm->hThread) {
2283         midiStreamClose((HMIDISTRM)hMidiOut);
2284         return MMSYSERR_NOMEM;
2285     }
2286
2287     /* wait for thread to have started, and for its queue to be created */
2288     {
2289         DWORD   count;
2290
2291         /* (Release|Restore)ThunkLock() is needed when this method is called from 16 bit code,
2292          * (meaning the Win16Lock is set), so that it's released and the 32 bit thread running
2293          * MMSYSTEM_MidiStreamPlayer can acquire Win16Lock to create its queue.
2294          */
2295         if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
2296         WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
2297         if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
2298     }
2299
2300     TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
2301           *lpuDeviceID, lpwm->mld.uDeviceID, *lphMidiStrm, ret, lpMidiStrm);
2302     return ret;
2303 }
2304
2305 /**************************************************************************
2306  *                              midiStreamOpen                  [WINMM.@]
2307  */
2308 MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
2309                                DWORD cMidi, DWORD_PTR dwCallback,
2310                                DWORD_PTR dwInstance, DWORD fdwOpen)
2311 {
2312     return MIDI_StreamOpen(lphMidiStrm, lpuDeviceID, cMidi, dwCallback,
2313                            dwInstance, fdwOpen, TRUE);
2314 }
2315
2316 /**************************************************************************
2317  *                              midiStreamOut                   [WINMM.@]
2318  */
2319 MMRESULT WINAPI midiStreamOut(HMIDISTRM hMidiStrm, LPMIDIHDR lpMidiHdr,
2320                               UINT cbMidiHdr)
2321 {
2322     WINE_MIDIStream*    lpMidiStrm;
2323     DWORD               ret = MMSYSERR_NOERROR;
2324
2325     TRACE("(%p, %p, %u)!\n", hMidiStrm, lpMidiHdr, cbMidiHdr);
2326
2327     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
2328         ret = MMSYSERR_INVALHANDLE;
2329     } else if (!lpMidiHdr) {
2330         ret = MMSYSERR_INVALPARAM;
2331     } else {
2332         if (!PostThreadMessageA(lpMidiStrm->dwThreadID,
2333                                 WINE_MSM_HEADER, cbMidiHdr,
2334                                 (DWORD)lpMidiHdr)) {
2335             WARN("bad PostThreadMessageA\n");
2336             ret = MMSYSERR_ERROR;
2337         }
2338     }
2339     return ret;
2340 }
2341
2342 /**************************************************************************
2343  *                              midiStreamPause                 [WINMM.@]
2344  */
2345 MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm)
2346 {
2347     WINE_MIDIStream*    lpMidiStrm;
2348     DWORD               ret = MMSYSERR_NOERROR;
2349
2350     TRACE("(%p)!\n", hMidiStrm);
2351
2352     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
2353         ret = MMSYSERR_INVALHANDLE;
2354     } else {
2355         if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) {
2356             WARN("bad Suspend (%ld)\n", GetLastError());
2357             ret = MMSYSERR_ERROR;
2358         }
2359     }
2360     return ret;
2361 }
2362
2363 /**************************************************************************
2364  *                              midiStreamPosition              [WINMM.@]
2365  */
2366 MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbmmt)
2367 {
2368     WINE_MIDIStream*    lpMidiStrm;
2369     DWORD               ret = MMSYSERR_NOERROR;
2370
2371     TRACE("(%p, %p, %u)!\n", hMidiStrm, lpMMT, cbmmt);
2372
2373     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
2374         ret = MMSYSERR_INVALHANDLE;
2375     } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME)) {
2376         ret = MMSYSERR_INVALPARAM;
2377     } else {
2378         switch (lpMMT->wType) {
2379         case TIME_MS:
2380             lpMMT->u.ms = lpMidiStrm->dwPositionMS;
2381             TRACE("=> %ld ms\n", lpMMT->u.ms);
2382             break;
2383         case TIME_TICKS:
2384             lpMMT->u.ticks = lpMidiStrm->dwPulses;
2385             TRACE("=> %ld ticks\n", lpMMT->u.ticks);
2386             break;
2387         default:
2388             WARN("Unsupported time type %d\n", lpMMT->wType);
2389             lpMMT->wType = TIME_MS;
2390             ret = MMSYSERR_INVALPARAM;
2391             break;
2392         }
2393     }
2394     return ret;
2395 }
2396
2397 /**************************************************************************
2398  *                              midiStreamProperty              [WINMM.@]
2399  */
2400 MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
2401 {
2402     WINE_MIDIStream*    lpMidiStrm;
2403     MMRESULT            ret = MMSYSERR_NOERROR;
2404
2405     TRACE("(%p, %p, %lx)\n", hMidiStrm, lpPropData, dwProperty);
2406
2407     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
2408         ret = MMSYSERR_INVALHANDLE;
2409     } else if ((dwProperty & (MIDIPROP_GET|MIDIPROP_SET)) == 0) {
2410         ret = MMSYSERR_INVALPARAM;
2411     } else if (dwProperty & MIDIPROP_TEMPO) {
2412         MIDIPROPTEMPO*  mpt = (MIDIPROPTEMPO*)lpPropData;
2413
2414         if (sizeof(MIDIPROPTEMPO) != mpt->cbStruct) {
2415             ret = MMSYSERR_INVALPARAM;
2416         } else if (dwProperty & MIDIPROP_SET) {
2417             lpMidiStrm->dwTempo = mpt->dwTempo;
2418             TRACE("Setting tempo to %ld\n", mpt->dwTempo);
2419         } else if (dwProperty & MIDIPROP_GET) {
2420             mpt->dwTempo = lpMidiStrm->dwTempo;
2421             TRACE("Getting tempo <= %ld\n", mpt->dwTempo);
2422         }
2423     } else if (dwProperty & MIDIPROP_TIMEDIV) {
2424         MIDIPROPTIMEDIV*        mptd = (MIDIPROPTIMEDIV*)lpPropData;
2425
2426         if (sizeof(MIDIPROPTIMEDIV) != mptd->cbStruct) {
2427             ret = MMSYSERR_INVALPARAM;
2428         } else if (dwProperty & MIDIPROP_SET) {
2429             lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv;
2430             TRACE("Setting time div to %ld\n", mptd->dwTimeDiv);
2431         } else if (dwProperty & MIDIPROP_GET) {
2432             mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv;
2433             TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv);
2434         }
2435     } else {
2436         ret = MMSYSERR_INVALPARAM;
2437     }
2438
2439     return ret;
2440 }
2441
2442 /**************************************************************************
2443  *                              midiStreamRestart               [WINMM.@]
2444  */
2445 MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm)
2446 {
2447     WINE_MIDIStream*    lpMidiStrm;
2448     MMRESULT            ret = MMSYSERR_NOERROR;
2449
2450     TRACE("(%p)!\n", hMidiStrm);
2451
2452     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
2453         ret = MMSYSERR_INVALHANDLE;
2454     } else {
2455         DWORD   ret;
2456
2457         /* since we increase the thread suspend count on each midiStreamPause
2458          * there may be a need for several midiStreamResume
2459          */
2460         do {
2461             ret = ResumeThread(lpMidiStrm->hThread);
2462         } while (ret != 0xFFFFFFFF && ret != 0);
2463         if (ret == 0xFFFFFFFF) {
2464             WARN("bad Resume (%ld)\n", GetLastError());
2465             ret = MMSYSERR_ERROR;
2466         } else {
2467             lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS;
2468         }
2469     }
2470     return ret;
2471 }
2472
2473 /**************************************************************************
2474  *                              midiStreamStop                  [WINMM.@]
2475  */
2476 MMRESULT WINAPI midiStreamStop(HMIDISTRM hMidiStrm)
2477 {
2478     WINE_MIDIStream*    lpMidiStrm;
2479     MMRESULT            ret = MMSYSERR_NOERROR;
2480
2481     TRACE("(%p)!\n", hMidiStrm);
2482
2483     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
2484         ret = MMSYSERR_INVALHANDLE;
2485     } else {
2486         /* in case stream has been paused... FIXME is the current state correct ? */
2487         midiStreamRestart(hMidiStrm);
2488         MMSYSTEM_MidiStream_PostMessage(lpMidiStrm, WINE_MSM_STOP, 0, 0);
2489     }
2490     return ret;
2491 }
2492
2493 UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
2494                LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
2495                DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
2496 {
2497     HANDLE              handle;
2498     LPWINE_MLD          wmld;
2499     DWORD               dwRet = MMSYSERR_NOERROR;
2500     WAVEOPENDESC        wod;
2501
2502     TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08lX, %d);\n",
2503           lphndl, (int)uDeviceID, (uType==MMDRV_WAVEOUT)?"Out":"In", lpFormat, dwCallback,
2504           dwInstance, dwFlags, bFrom32?32:16);
2505
2506     if (dwFlags & WAVE_FORMAT_QUERY)
2507         TRACE("WAVE_FORMAT_QUERY requested !\n");
2508
2509     if (lpFormat == NULL) {
2510         WARN("bad format\n");
2511         return WAVERR_BADFORMAT;
2512     }
2513
2514     if ((dwFlags & WAVE_MAPPED) && (uDeviceID == (UINT)-1)) {
2515         WARN("invalid parameter\n");
2516         return MMSYSERR_INVALPARAM;
2517     }
2518
2519     /* may have a PCMWAVEFORMAT rather than a WAVEFORMATEX so don't read cbSize */
2520     TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u\n",
2521           lpFormat->wFormatTag, lpFormat->nChannels, lpFormat->nSamplesPerSec,
2522           lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample);
2523
2524     if ((wmld = MMDRV_Alloc(sizeof(WINE_WAVE), uType, &handle,
2525                             &dwFlags, &dwCallback, &dwInstance, bFrom32)) == NULL) {
2526         WARN("no memory\n");
2527         return MMSYSERR_NOMEM;
2528     }
2529
2530     wod.hWave = handle;
2531     wod.lpFormat = (LPWAVEFORMATEX)lpFormat;  /* should the struct be copied iso pointer? */
2532     wod.dwCallback = dwCallback;
2533     wod.dwInstance = dwInstance;
2534     wod.dnDevNode = 0L;
2535
2536     TRACE("cb=%08lx\n", wod.dwCallback);
2537
2538     for (;;) {
2539         if (dwFlags & WAVE_MAPPED) {
2540             wod.uMappedDeviceID = uDeviceID;
2541             uDeviceID = WAVE_MAPPER;
2542         } else {
2543             wod.uMappedDeviceID = -1;
2544         }
2545         wmld->uDeviceID = uDeviceID;
2546
2547         dwRet = MMDRV_Open(wmld, (uType == MMDRV_WAVEOUT) ? WODM_OPEN : WIDM_OPEN,
2548                            (DWORD)&wod, dwFlags);
2549
2550         TRACE("dwRet = %s\n", WINMM_ErrorToString(dwRet));
2551         if (dwRet != WAVERR_BADFORMAT ||
2552             ((dwFlags & (WAVE_MAPPED|WAVE_FORMAT_DIRECT)) != 0) || (uDeviceID == WAVE_MAPPER)) break;
2553         /* if we ask for a format which isn't supported by the physical driver,
2554          * let's try to map it through the wave mapper (except, if we already tried
2555          * or user didn't allow us to use acm codecs or the device is already the mapper)
2556          */
2557         dwFlags |= WAVE_MAPPED;
2558         /* we shall loop only one */
2559     }
2560
2561     if ((dwFlags & WAVE_FORMAT_QUERY) || dwRet != MMSYSERR_NOERROR) {
2562         MMDRV_Free(handle, wmld);
2563         handle = 0;
2564     }
2565
2566     if (lphndl != NULL) *lphndl = handle;
2567     TRACE("=> %s hWave=%p\n", WINMM_ErrorToString(dwRet), handle);
2568
2569     return dwRet;
2570 }
2571
2572 /**************************************************************************
2573  *                              waveOutGetNumDevs               [WINMM.@]
2574  */
2575 UINT WINAPI waveOutGetNumDevs(void)
2576 {
2577     return MMDRV_GetNum(MMDRV_WAVEOUT);
2578 }
2579
2580 /**************************************************************************
2581  *                              waveOutGetDevCapsA              [WINMM.@]
2582  */
2583 UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
2584                                UINT uSize)
2585 {
2586     WAVEOUTCAPSW        wocW;
2587     UINT                ret;
2588
2589     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
2590
2591     ret = waveOutGetDevCapsW(uDeviceID, &wocW, sizeof(wocW));
2592
2593     if (ret == MMSYSERR_NOERROR) {
2594         WAVEOUTCAPSA wocA;
2595         wocA.wMid           = wocW.wMid;
2596         wocA.wPid           = wocW.wPid;
2597         wocA.vDriverVersion = wocW.vDriverVersion;
2598         WideCharToMultiByte( CP_ACP, 0, wocW.szPname, -1, wocA.szPname,
2599                              sizeof(wocA.szPname), NULL, NULL );
2600         wocA.dwFormats      = wocW.dwFormats;
2601         wocA.wChannels      = wocW.wChannels;
2602         wocA.dwSupport      = wocW.dwSupport;
2603         memcpy(lpCaps, &wocA, min(uSize, sizeof(wocA)));
2604     }
2605     return ret;
2606 }
2607
2608 /**************************************************************************
2609  *                              waveOutGetDevCapsW              [WINMM.@]
2610  */
2611 UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
2612                                UINT uSize)
2613 {
2614     LPWINE_MLD          wmld;
2615
2616     TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
2617
2618     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
2619
2620     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEOUT, TRUE)) == NULL)
2621         return MMSYSERR_BADDEVICEID;
2622
2623     return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
2624
2625 }
2626
2627 /**************************************************************************
2628  *                              WAVE_GetErrorText               [internal]
2629  */
2630 static  UINT16  WAVE_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
2631 {
2632     UINT16              ret = MMSYSERR_BADERRNUM;
2633
2634     if (lpText == NULL) {
2635         ret = MMSYSERR_INVALPARAM;
2636     } else if (uSize == 0) {
2637         ret = MMSYSERR_NOERROR;
2638     } else if (
2639                /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
2640                 * a warning for the test was always true */
2641                (/*uError >= MMSYSERR_BASE && */uError <= MMSYSERR_LASTERROR) ||
2642                (uError >= WAVERR_BASE  && uError <= WAVERR_LASTERROR)) {
2643
2644         if (LoadStringA(WINMM_IData->hWinMM32Instance,
2645                         uError, lpText, uSize) > 0) {
2646             ret = MMSYSERR_NOERROR;
2647         }
2648     }
2649     return ret;
2650 }
2651
2652 /**************************************************************************
2653  *                              waveOutGetErrorTextA    [WINMM.@]
2654  */
2655 UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2656 {
2657     return WAVE_GetErrorText(uError, lpText, uSize);
2658 }
2659
2660 /**************************************************************************
2661  *                              waveOutGetErrorTextW    [WINMM.@]
2662  */
2663 UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2664 {
2665     LPSTR       xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
2666     UINT        ret = WAVE_GetErrorText(uError, xstr, uSize);
2667
2668     MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
2669     HeapFree(GetProcessHeap(), 0, xstr);
2670     return ret;
2671 }
2672
2673 /**************************************************************************
2674  *                      waveOutOpen                     [WINMM.@]
2675  * All the args/structs have the same layout as the win16 equivalents
2676  */
2677 MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
2678                        LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
2679                        DWORD_PTR dwInstance, DWORD dwFlags)
2680 {
2681     return WAVE_Open((HANDLE*)lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat,
2682                      dwCallback, dwInstance, dwFlags, TRUE);
2683 }
2684
2685 /**************************************************************************
2686  *                              waveOutClose            [WINMM.@]
2687  */
2688 UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
2689 {
2690     LPWINE_MLD          wmld;
2691     DWORD               dwRet;
2692
2693     TRACE("(%p)\n", hWaveOut);
2694
2695     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2696         return MMSYSERR_INVALHANDLE;
2697
2698     dwRet = MMDRV_Close(wmld, WODM_CLOSE);
2699     if (dwRet != WAVERR_STILLPLAYING)
2700         MMDRV_Free(hWaveOut, wmld);
2701
2702     return dwRet;
2703 }
2704
2705 /**************************************************************************
2706  *                              waveOutPrepareHeader    [WINMM.@]
2707  */
2708 UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
2709                                  WAVEHDR* lpWaveOutHdr, UINT uSize)
2710 {
2711     LPWINE_MLD          wmld;
2712     UINT                result;
2713
2714     TRACE("(%p, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2715
2716     if (lpWaveOutHdr == NULL || uSize < sizeof (WAVEHDR))
2717         return MMSYSERR_INVALPARAM;
2718
2719     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2720         return MMSYSERR_INVALHANDLE;
2721
2722     if ((result = MMDRV_Message(wmld, WODM_PREPARE, (DWORD_PTR)lpWaveOutHdr,
2723                                 uSize, TRUE)) != MMSYSERR_NOTSUPPORTED)
2724         return result;
2725
2726     if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2727         return WAVERR_STILLPLAYING;
2728
2729     lpWaveOutHdr->dwFlags |= WHDR_PREPARED;
2730     lpWaveOutHdr->dwFlags &= ~WHDR_DONE;
2731
2732     return MMSYSERR_NOERROR;
2733 }
2734
2735 /**************************************************************************
2736  *                              waveOutUnprepareHeader  [WINMM.@]
2737  */
2738 UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
2739                                    LPWAVEHDR lpWaveOutHdr, UINT uSize)
2740 {
2741     LPWINE_MLD          wmld;
2742     UINT                result;
2743
2744     TRACE("(%p, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2745
2746     if (lpWaveOutHdr == NULL || uSize < sizeof (WAVEHDR))
2747         return MMSYSERR_INVALPARAM;
2748
2749     if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
2750         return MMSYSERR_NOERROR;
2751     }
2752
2753     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2754         return MMSYSERR_INVALHANDLE;
2755
2756     if ((result = MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD_PTR)lpWaveOutHdr,
2757                                 uSize, TRUE)) != MMSYSERR_NOTSUPPORTED)
2758         return result;
2759
2760     if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
2761         return WAVERR_STILLPLAYING;
2762
2763     lpWaveOutHdr->dwFlags &= ~WHDR_PREPARED;
2764     lpWaveOutHdr->dwFlags |= WHDR_DONE;
2765
2766     return MMSYSERR_NOERROR;
2767 }
2768
2769 /**************************************************************************
2770  *                              waveOutWrite            [WINMM.@]
2771  */
2772 UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr,
2773                          UINT uSize)
2774 {
2775     LPWINE_MLD          wmld;
2776
2777     TRACE("(%p, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2778
2779     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2780         return MMSYSERR_INVALHANDLE;
2781
2782     return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
2783 }
2784
2785 /**************************************************************************
2786  *                              waveOutBreakLoop        [WINMM.@]
2787  */
2788 UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
2789 {
2790     LPWINE_MLD          wmld;
2791
2792     TRACE("(%p);\n", hWaveOut);
2793
2794     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2795         return MMSYSERR_INVALHANDLE;
2796     return MMDRV_Message(wmld, WODM_BREAKLOOP, 0L, 0L, TRUE);
2797 }
2798
2799 /**************************************************************************
2800  *                              waveOutPause            [WINMM.@]
2801  */
2802 UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
2803 {
2804     LPWINE_MLD          wmld;
2805
2806     TRACE("(%p);\n", hWaveOut);
2807
2808     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2809         return MMSYSERR_INVALHANDLE;
2810     return MMDRV_Message(wmld, WODM_PAUSE, 0L, 0L, TRUE);
2811 }
2812
2813 /**************************************************************************
2814  *                              waveOutReset            [WINMM.@]
2815  */
2816 UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
2817 {
2818     LPWINE_MLD          wmld;
2819
2820     TRACE("(%p);\n", hWaveOut);
2821
2822     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2823         return MMSYSERR_INVALHANDLE;
2824     return MMDRV_Message(wmld, WODM_RESET, 0L, 0L, TRUE);
2825 }
2826
2827 /**************************************************************************
2828  *                              waveOutRestart          [WINMM.@]
2829  */
2830 UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
2831 {
2832     LPWINE_MLD          wmld;
2833
2834     TRACE("(%p);\n", hWaveOut);
2835
2836     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2837         return MMSYSERR_INVALHANDLE;
2838     return MMDRV_Message(wmld, WODM_RESTART, 0L, 0L, TRUE);
2839 }
2840
2841 /**************************************************************************
2842  *                              waveOutGetPosition      [WINMM.@]
2843  */
2844 UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
2845                                UINT uSize)
2846 {
2847     LPWINE_MLD          wmld;
2848
2849     TRACE("(%p, %p, %u);\n", hWaveOut, lpTime, uSize);
2850
2851     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2852         return MMSYSERR_INVALHANDLE;
2853
2854     return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
2855 }
2856
2857 /**************************************************************************
2858  *                              waveOutGetPitch         [WINMM.@]
2859  */
2860 UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
2861 {
2862     LPWINE_MLD          wmld;
2863
2864     TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw);
2865
2866     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2867         return MMSYSERR_INVALHANDLE;
2868     return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L, TRUE);
2869 }
2870
2871 /**************************************************************************
2872  *                              waveOutSetPitch         [WINMM.@]
2873  */
2874 UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
2875 {
2876     LPWINE_MLD          wmld;
2877
2878     TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw);
2879
2880     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2881         return MMSYSERR_INVALHANDLE;
2882     return MMDRV_Message(wmld, WODM_SETPITCH, dw, 0L, TRUE);
2883 }
2884
2885 /**************************************************************************
2886  *                              waveOutGetPlaybackRate  [WINMM.@]
2887  */
2888 UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
2889 {
2890     LPWINE_MLD          wmld;
2891
2892     TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw);
2893
2894     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2895         return MMSYSERR_INVALHANDLE;
2896     return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L, TRUE);
2897 }
2898
2899 /**************************************************************************
2900  *                              waveOutSetPlaybackRate  [WINMM.@]
2901  */
2902 UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
2903 {
2904     LPWINE_MLD          wmld;
2905
2906     TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw);
2907
2908     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2909         return MMSYSERR_INVALHANDLE;
2910     return MMDRV_Message(wmld, WODM_SETPLAYBACKRATE, dw, 0L, TRUE);
2911 }
2912
2913 /**************************************************************************
2914  *                              waveOutGetVolume        [WINMM.@]
2915  */
2916 UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw)
2917 {
2918     LPWINE_MLD          wmld;
2919
2920     TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw);
2921
2922      if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
2923         return MMSYSERR_INVALHANDLE;
2924
2925     return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L, TRUE);
2926 }
2927
2928 /**************************************************************************
2929  *                              waveOutSetVolume        [WINMM.@]
2930  */
2931 UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD dw)
2932 {
2933     LPWINE_MLD          wmld;
2934
2935     TRACE("(%p, %08lx);\n", hWaveOut, dw);
2936
2937      if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
2938         return MMSYSERR_INVALHANDLE;
2939
2940     return MMDRV_Message(wmld, WODM_SETVOLUME, dw, 0L, TRUE);
2941 }
2942
2943 /**************************************************************************
2944  *                              waveOutGetID            [WINMM.@]
2945  */
2946 UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
2947 {
2948     LPWINE_MLD          wmld;
2949
2950     TRACE("(%p, %p);\n", hWaveOut, lpuDeviceID);
2951
2952     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
2953
2954     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
2955         return MMSYSERR_INVALHANDLE;
2956
2957     *lpuDeviceID = wmld->uDeviceID;
2958     return 0;
2959 }
2960
2961 /**************************************************************************
2962  *                              waveOutMessage          [WINMM.@]
2963  */
2964 UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
2965                            DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2966 {
2967     LPWINE_MLD          wmld;
2968
2969     TRACE("(%p, %u, %ld, %ld)\n", hWaveOut, uMessage, dwParam1, dwParam2);
2970
2971     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) {
2972         if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) != NULL) {
2973             return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
2974         }
2975         WARN("invalid handle\n");
2976         return MMSYSERR_INVALHANDLE;
2977     }
2978
2979     /* from M$ KB */
2980     if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER)) {
2981         WARN("invalid parameter\n");
2982         return MMSYSERR_INVALPARAM;
2983     }
2984
2985     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
2986 }
2987
2988 /**************************************************************************
2989  *                              waveInGetNumDevs                [WINMM.@]
2990  */
2991 UINT WINAPI waveInGetNumDevs(void)
2992 {
2993     return MMDRV_GetNum(MMDRV_WAVEIN);
2994 }
2995
2996 /**************************************************************************
2997  *                              waveInGetDevCapsW               [WINMM.@]
2998  */
2999 UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
3000 {
3001     LPWINE_MLD          wmld;
3002
3003     TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
3004
3005     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
3006
3007     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEIN, TRUE)) == NULL)
3008         return MMSYSERR_BADDEVICEID;
3009
3010     return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
3011 }
3012
3013 /**************************************************************************
3014  *                              waveInGetDevCapsA               [WINMM.@]
3015  */
3016 UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
3017 {
3018     WAVEINCAPSW         wicW;
3019     UINT                ret;
3020
3021     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
3022
3023     ret = waveInGetDevCapsW(uDeviceID, &wicW, sizeof(wicW));
3024
3025     if (ret == MMSYSERR_NOERROR) {
3026         WAVEINCAPSA wicA;
3027         wicA.wMid           = wicW.wMid;
3028         wicA.wPid           = wicW.wPid;
3029         wicA.vDriverVersion = wicW.vDriverVersion;
3030         WideCharToMultiByte( CP_ACP, 0, wicW.szPname, -1, wicA.szPname,
3031                              sizeof(wicA.szPname), NULL, NULL );
3032         wicA.dwFormats      = wicW.dwFormats;
3033         wicA.wChannels      = wicW.wChannels;
3034         memcpy(lpCaps, &wicA, min(uSize, sizeof(wicA)));
3035     }
3036     return ret;
3037 }
3038
3039 /**************************************************************************
3040  *                              waveInGetErrorTextA     [WINMM.@]
3041  */
3042 UINT WINAPI waveInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
3043 {
3044     return WAVE_GetErrorText(uError, lpText, uSize);
3045 }
3046
3047 /**************************************************************************
3048  *                              waveInGetErrorTextW     [WINMM.@]
3049  */
3050 UINT WINAPI waveInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
3051 {
3052     LPSTR txt = HeapAlloc(GetProcessHeap(), 0, uSize);
3053     UINT        ret = WAVE_GetErrorText(uError, txt, uSize);
3054
3055     MultiByteToWideChar( CP_ACP, 0, txt, -1, lpText, uSize );
3056     HeapFree(GetProcessHeap(), 0, txt);
3057     return ret;
3058 }
3059
3060 /**************************************************************************
3061  *                              waveInOpen                      [WINMM.@]
3062  */
3063 MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
3064                        LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
3065                        DWORD_PTR dwInstance, DWORD dwFlags)
3066 {
3067     return WAVE_Open((HANDLE*)lphWaveIn, uDeviceID, MMDRV_WAVEIN, lpFormat,
3068                      dwCallback, dwInstance, dwFlags, TRUE);
3069 }
3070
3071 /**************************************************************************
3072  *                              waveInClose                     [WINMM.@]
3073  */
3074 UINT WINAPI waveInClose(HWAVEIN hWaveIn)
3075 {
3076     LPWINE_MLD          wmld;
3077     DWORD               dwRet;
3078
3079     TRACE("(%p)\n", hWaveIn);
3080
3081     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3082         return MMSYSERR_INVALHANDLE;
3083
3084     dwRet = MMDRV_Message(wmld, WIDM_CLOSE, 0L, 0L, TRUE);
3085     if (dwRet != WAVERR_STILLPLAYING)
3086         MMDRV_Free(hWaveIn, wmld);
3087     return dwRet;
3088 }
3089
3090 /**************************************************************************
3091  *                              waveInPrepareHeader             [WINMM.@]
3092  */
3093 UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
3094                                 UINT uSize)
3095 {
3096     LPWINE_MLD          wmld;
3097
3098     TRACE("(%p, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3099
3100     if (lpWaveInHdr == NULL || uSize < sizeof (WAVEHDR))
3101         return MMSYSERR_INVALPARAM;
3102
3103     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3104         return MMSYSERR_INVALHANDLE;
3105
3106     lpWaveInHdr->dwBytesRecorded = 0;
3107
3108     return MMDRV_Message(wmld, WIDM_PREPARE, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
3109 }
3110
3111 /**************************************************************************
3112  *                              waveInUnprepareHeader   [WINMM.@]
3113  */
3114 UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
3115                                   UINT uSize)
3116 {
3117     LPWINE_MLD          wmld;
3118
3119     TRACE("(%p, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3120
3121     if (lpWaveInHdr == NULL || uSize < sizeof (WAVEHDR))
3122         return MMSYSERR_INVALPARAM;
3123
3124     if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
3125         return MMSYSERR_NOERROR;
3126     }
3127
3128     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3129         return MMSYSERR_INVALHANDLE;
3130
3131     return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
3132 }
3133
3134 /**************************************************************************
3135  *                              waveInAddBuffer         [WINMM.@]
3136  */
3137 UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
3138                             WAVEHDR* lpWaveInHdr, UINT uSize)
3139 {
3140     LPWINE_MLD          wmld;
3141
3142     TRACE("(%p, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3143
3144     if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
3145     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3146         return MMSYSERR_INVALHANDLE;
3147
3148     return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
3149 }
3150
3151 /**************************************************************************
3152  *                              waveInReset             [WINMM.@]
3153  */
3154 UINT WINAPI waveInReset(HWAVEIN hWaveIn)
3155 {
3156     LPWINE_MLD          wmld;
3157
3158     TRACE("(%p);\n", hWaveIn);
3159
3160     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3161         return MMSYSERR_INVALHANDLE;
3162
3163     return MMDRV_Message(wmld, WIDM_RESET, 0L, 0L, TRUE);
3164 }
3165
3166 /**************************************************************************
3167  *                              waveInStart             [WINMM.@]
3168  */
3169 UINT WINAPI waveInStart(HWAVEIN hWaveIn)
3170 {
3171     LPWINE_MLD          wmld;
3172
3173     TRACE("(%p);\n", hWaveIn);
3174
3175     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3176         return MMSYSERR_INVALHANDLE;
3177
3178     return MMDRV_Message(wmld, WIDM_START, 0L, 0L, TRUE);
3179 }
3180
3181 /**************************************************************************
3182  *                              waveInStop              [WINMM.@]
3183  */
3184 UINT WINAPI waveInStop(HWAVEIN hWaveIn)
3185 {
3186     LPWINE_MLD          wmld;
3187
3188     TRACE("(%p);\n", hWaveIn);
3189
3190     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3191         return MMSYSERR_INVALHANDLE;
3192
3193     return MMDRV_Message(wmld,WIDM_STOP, 0L, 0L, TRUE);
3194 }
3195
3196 /**************************************************************************
3197  *                              waveInGetPosition       [WINMM.@]
3198  */
3199 UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
3200                               UINT uSize)
3201 {
3202     LPWINE_MLD          wmld;
3203
3204     TRACE("(%p, %p, %u);\n", hWaveIn, lpTime, uSize);
3205
3206     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3207         return MMSYSERR_INVALHANDLE;
3208
3209     return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
3210 }
3211
3212 /**************************************************************************
3213  *                              waveInGetID                     [WINMM.@]
3214  */
3215 UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
3216 {
3217     LPWINE_MLD          wmld;
3218
3219     TRACE("(%p, %p);\n", hWaveIn, lpuDeviceID);
3220
3221     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3222
3223     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
3224         return MMSYSERR_INVALHANDLE;
3225
3226     *lpuDeviceID = wmld->uDeviceID;
3227     return MMSYSERR_NOERROR;
3228 }
3229
3230 /**************************************************************************
3231  *                              waveInMessage           [WINMM.@]
3232  */
3233 UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
3234                           DWORD_PTR dwParam1, DWORD_PTR dwParam2)
3235 {
3236     LPWINE_MLD          wmld;
3237
3238     TRACE("(%p, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
3239
3240     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) {
3241         if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, TRUE)) != NULL) {
3242             return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
3243         }
3244         return MMSYSERR_INVALHANDLE;
3245     }
3246
3247     /* from M$ KB */
3248     if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
3249         return MMSYSERR_INVALPARAM;
3250
3251
3252     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
3253 }
3254
3255 struct mm_starter
3256 {
3257     LPTASKCALLBACK      cb;
3258     DWORD               client;
3259     HANDLE              event;
3260 };
3261
3262 static DWORD WINAPI mmTaskRun(void* pmt)
3263 {
3264     struct mm_starter mms;
3265
3266     memcpy(&mms, pmt, sizeof(struct mm_starter));
3267     HeapFree(GetProcessHeap(), 0, pmt);
3268     mms.cb(mms.client);
3269     if (mms.event) SetEvent(mms.event);
3270     return 0;
3271 }
3272
3273 /******************************************************************
3274  *              mmTaskCreate (WINMM.@)
3275  */
3276 MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD client)
3277 {
3278     HANDLE               hThread;
3279     HANDLE               hEvent = 0;
3280     struct mm_starter   *mms;
3281
3282     mms = HeapAlloc(GetProcessHeap(), 0, sizeof(struct mm_starter));
3283     if (mms == NULL) return TASKERR_OUTOFMEMORY;
3284
3285     mms->cb = cb;
3286     mms->client = client;
3287     if (ph) hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
3288     mms->event = hEvent;
3289
3290     hThread = CreateThread(0, 0, mmTaskRun, mms, 0, NULL);
3291     if (!hThread) {
3292         HeapFree(GetProcessHeap(), 0, mms);
3293         if (hEvent) CloseHandle(hEvent);
3294         return TASKERR_OUTOFMEMORY;
3295     }
3296     if (ph) *ph = hEvent;
3297     CloseHandle(hThread);
3298     return 0;
3299 }
3300
3301 /******************************************************************
3302  *              mmTaskBlock (WINMM.@)
3303  */
3304 void     WINAPI mmTaskBlock(HANDLE tid)
3305 {
3306     MSG         msg;
3307
3308     do
3309     {
3310         GetMessageA(&msg, 0, 0, 0);
3311         if (msg.hwnd) DispatchMessageA(&msg);
3312     } while (msg.message != WM_USER);
3313 }
3314
3315 /******************************************************************
3316  *              mmTaskSignal (WINMM.@)
3317  */
3318 BOOL     WINAPI mmTaskSignal(HANDLE tid)
3319 {
3320     return PostThreadMessageW((DWORD)tid, WM_USER, 0, 0);
3321 }
3322
3323 /******************************************************************
3324  *              mmTaskYield (WINMM.@)
3325  */
3326 void     WINAPI mmTaskYield(void) {}
3327
3328 /******************************************************************
3329  *              mmGetCurrentTask (WINMM.@)
3330  */
3331 HANDLE   WINAPI mmGetCurrentTask(void)
3332 {
3333     return (HANDLE)GetCurrentThreadId();
3334 }