dlls/winmm/mmsystem.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * MMSYTEM functions
   5  *
   6  * Copyright 1993 Martin Ayotte
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 /*
  24  * Eric POUECH :
  25  *      98/9    added Win32 MCI support
  26  *      99/4    added mmTask and mmThread functions support
  27  *              added midiStream support
  28  *      99/9    added support for loadable low level drivers
  29  */
  30
  31 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
  32  *        and long term pointers to 16 bit space in here
  33  */
  34
  35 #include <string.h>
  36
  37 #include "mmsystem.h"
  38 #include "winbase.h"
  39 #include "wingdi.h"
  40
  41 #include "wine/mmsystem16.h"
  42 #include "wine/winuser16.h"
  43 #include "heap.h"
  44 #include "ntddk.h"
  45 #include "winemm.h"
  46
  47 #include "wine/debug.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
  50
  51 static LPWINE_MM_IDATA          lpFirstIData = NULL;
  52
  53 static  LPWINE_MM_IDATA MULTIMEDIA_GetIDataNoCheck(void)
  54 {
  55     DWORD               pid = GetCurrentProcessId();
  56     LPWINE_MM_IDATA     iData;
  57
  58     for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
  59         if (iData->dwThisProcess == pid)
  60             break;
  61     }
  62     return iData;
  63 }
  64
  65 /**************************************************************************
  66  *                      MULTIMEDIA_GetIData                     [internal]
  67  */
  68 LPWINE_MM_IDATA MULTIMEDIA_GetIData(void)
  69 {
  70     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIDataNoCheck();
  71
  72     if (!iData) {
  73         ERR("IData not found for pid=%08lx. Suicide !!!\n", GetCurrentProcessId());
  74         DbgBreakPoint();
  75         ExitProcess(0);
  76     }
  77     return iData;
  78 }
  79
  80 /**************************************************************************
  81  *                      MULTIMEDIA_CreateIData                  [internal]
  82  */
  83 static  BOOL    MULTIMEDIA_CreateIData(HINSTANCE hInstDLL)
  84 {
  85     LPWINE_MM_IDATA     iData;
  86
  87     iData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MM_IDATA));
  88
  89     if (!iData)
  90         return FALSE;
  91     iData->hWinMM32Instance = hInstDLL;
  92     iData->dwThisProcess = GetCurrentProcessId();
  93     iData->lpNextIData = lpFirstIData;
  94     lpFirstIData = iData;
  95     InitializeCriticalSection(&iData->cs);
  96     TRACE("Created IData (%p) for pid %08lx\n", iData, iData->dwThisProcess);
  97     return TRUE;
  98 }
  99
 100 /**************************************************************************
 101  *                      MULTIMEDIA_DeleteIData                  [internal]
 102  */
 103 static  void MULTIMEDIA_DeleteIData(void)
 104 {
 105     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIDataNoCheck();
 106     LPWINE_MM_IDATA*    ppid;
 107
 108     if (iData) {
 109         TIME_MMTimeStop();
 110
 111         for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
 112             if (*ppid == iData) {
 113                 *ppid = iData->lpNextIData;
 114                 break;
 115             }
 116         }
 117         /* FIXME: should also free content and resources allocated
 118          * inside iData */
 119         HeapFree(GetProcessHeap(), 0, iData);
 120     }
 121 }
 122
 123 /**************************************************************************
 124  *              DllEntryPoint (WINMM.init)
 125  *
 126  * WINMM DLL entry point
 127  *
 128  */
 129 BOOL WINAPI WINMM_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
 130 {
 131     TRACE("0x%x 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
 132
 133     switch (fdwReason) {
 134     case DLL_PROCESS_ATTACH:
 135         if (!MULTIMEDIA_CreateIData(hInstDLL))
 136             return FALSE;
 137         if (!MULTIMEDIA_MciInit() || !MMDRV_Init()) {
 138             MULTIMEDIA_DeleteIData();
 139             return FALSE;
 140         }
 141         break;
 142     case DLL_PROCESS_DETACH:
 143         MULTIMEDIA_DeleteIData();
 144         break;
 145     case DLL_THREAD_ATTACH:
 146     case DLL_THREAD_DETACH:
 147         break;
 148     }
 149     return TRUE;
 150 }
 151
 152 /**************************************************************************
 153  *                      DllEntryPoint (MMSYSTEM.2046)
 154  *
 155  * MMSYSTEM DLL entry point
 156  *
 157  */
 158 BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
 159                              WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
 160 {
 161     HANDLE                      hndl;
 162     LPWINE_MM_IDATA             iData;
 163
 164     TRACE("0x%x 0x%lx\n", hinstDLL, fdwReason);
 165
 166     switch (fdwReason) {
 167     case DLL_PROCESS_ATTACH:
 168         /* need to load WinMM in order to:
 169          * - initiate correctly shared variables (MULTIMEDIA_Init())
 170          * - create correctly the per process WINE_MM_IDATA chunk
 171          */
 172         hndl = LoadLibraryA("WINMM.DLL");
 173
 174         if (!hndl) {
 175             ERR("Could not load sibling WinMM.dll\n");
 176             return FALSE;
 177         }
 178         iData = MULTIMEDIA_GetIData();
 179         iData->hWinMM16Instance = hinstDLL;
 180         iData->h16Module32 = hndl;
 181         break;
 182     case DLL_PROCESS_DETACH:
 183         iData = MULTIMEDIA_GetIData();
 184         FreeLibrary(iData->h16Module32);
 185         break;
 186     case DLL_THREAD_ATTACH:
 187     case DLL_THREAD_DETACH:
 188         break;
 189     }
 190     return TRUE;
 191 }
 192
 193 /**************************************************************************
 194  *                              MMSYSTEM_WEP                    [MMSYSTEM.1]
 195  */
 196 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
 197                         WORD cbHeapSize, LPSTR lpCmdLine)
 198 {
 199     FIXME("STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
 200     return TRUE;
 201 }
 202
 203 void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32)
 204 {
 205     mmt16->wType = mmt32->wType;
 206     /* layout of rest is the same for 32/16,
 207      * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
 208      */
 209     memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
 210 }
 211
 212 void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16)
 213 {
 214     mmt32->wType = mmt16->wType;
 215     /* layout of rest is the same for 32/16,
 216      * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
 217      */
 218     memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
 219 }
 220
 221 static HMMIO    get_mmioFromFile(LPCWSTR lpszName)
 222 {
 223     return mmioOpenW((LPWSTR)lpszName, NULL,
 224                      MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 225 }
 226
 227 static HMMIO    get_mmioFromProfile(UINT uFlags, LPCWSTR lpszName)
 228 {
 229     WCHAR       str[128];
 230     LPWSTR      ptr;
 231     HMMIO       hmmio;
 232 static  WCHAR       wszSounds[] = {'S','o','u','n','d','s',0};
 233 static  WCHAR       wszDefault[] = {'D','e','f','a','u','l','t',0};
 234 static  WCHAR       wszNull[] = {0};
 235     TRACE("searching in SystemSound List !\n");
 236     GetProfileStringW(wszSounds, (LPWSTR)lpszName, wszNull, str, sizeof(str)/sizeof(str[0]));
 237     if (lstrlenW(str) == 0) {
 238         if (uFlags & SND_NODEFAULT) return 0;
 239         GetProfileStringW(wszSounds, wszDefault, wszNull, str, sizeof(str)/sizeof(str[0]));
 240         if (lstrlenW(str) == 0) return 0;
 241     }
 242     for (ptr = str; *ptr && *ptr != ','; ptr++);
 243     if (*ptr) *ptr = 0;
 244     hmmio = mmioOpenW(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 245     if (hmmio == 0) {
 246         WARN("can't find SystemSound='%s' !\n", debugstr_w(str));
 247         return 0;
 248     }
 249     return hmmio;
 250 }
 251
 252 struct playsound_data
 253 {
 254     HANDLE      hEvent;
 255     DWORD       dwEventCount;
 256 };
 257
 258 static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg,
 259                                         DWORD dwInstance,
 260                                         DWORD dwParam1, DWORD dwParam2)
 261 {
 262     struct playsound_data*      s = (struct playsound_data*)dwInstance;
 263
 264     switch (uMsg) {
 265     case WOM_OPEN:
 266     case WOM_CLOSE:
 267         break;
 268     case WOM_DONE:
 269         InterlockedIncrement(&s->dwEventCount);
 270         TRACE("Returning waveHdr=%lx\n", dwParam1);
 271         SetEvent(s->hEvent);
 272         break;
 273     default:
 274         ERR("Unknown uMsg=%d\n", uMsg);
 275     }
 276 }
 277
 278 static void PlaySound_WaitDone(struct playsound_data* s)
 279 {
 280     for (;;) {
 281         ResetEvent(s->hEvent);
 282         if (InterlockedDecrement(&s->dwEventCount) >= 0) break;
 283         InterlockedIncrement(&s->dwEventCount);
 284
 285         WaitForSingleObject(s->hEvent, INFINITE);
 286     }
 287 }
 288
 289 static DWORD WINAPI proc_PlaySound(LPVOID arg)
 290 {
 291     WINE_PLAYSOUND*     wps = (WINE_PLAYSOUND*)arg;
 292     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
 293     BOOL                bRet = FALSE;
 294     HMMIO               hmmio = 0;
 295     MMCKINFO            ckMainRIFF;
 296     MMCKINFO            mmckInfo;
 297     LPWAVEFORMATEX      lpWaveFormat = NULL;
 298     HWAVE               hWave = 0;
 299     LPWAVEHDR           waveHdr = NULL;
 300     INT                 count, bufsize, left, index;
 301     struct playsound_data       s;
 302     void*               data;
 303
 304     s.hEvent = 0;
 305
 306     TRACE("SoundName='%s' !\n", debugstr_w(wps->pszSound));
 307
 308     /* if resource, grab it */
 309     if ((wps->fdwSound & SND_RESOURCE) == SND_RESOURCE) {
 310         static WCHAR wszWave[] = {'W','A','V','E',0};
 311         HRSRC   hRes;
 312         HGLOBAL hGlob;
 313
 314         if ((hRes = FindResourceW(wps->hMod, wps->pszSound, wszWave)) == 0 ||
 315             (hGlob = LoadResource(wps->hMod, hRes)) == 0) {
 316             return FALSE;
 317         }
 318         if ((data = LockResource(hGlob)) == NULL) {
 319             FreeResource(hGlob);
 320             return FALSE;
 321         }
 322         FreeResource(hGlob);
 323     } else
 324         data = (void*)wps->pszSound;
 325
 326     /* construct an MMIO stream (either in memory, or from a file */
 327     if (wps->fdwSound & SND_MEMORY) { /* NOTE: SND_RESOURCE has the SND_MEMORY bit set */
 328         MMIOINFO        mminfo;
 329
 330         memset(&mminfo, 0, sizeof(mminfo));
 331         mminfo.fccIOProc = FOURCC_MEM;
 332         mminfo.pchBuffer = (LPSTR)data;
 333         mminfo.cchBuffer = -1; /* FIXME: when a resource, could grab real size */
 334         TRACE("Memory sound %p\n", data);
 335         hmmio = mmioOpenW(NULL, &mminfo, MMIO_READ);
 336     } else {
 337         hmmio = 0;
 338         if (wps->fdwSound & SND_ALIAS)
 339             if ((hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound)) == 0)
 340                 return FALSE;
 341
 342         if (wps->fdwSound & SND_FILENAME)
 343             if ((hmmio = get_mmioFromFile(wps->pszSound)) == 0) return FALSE;
 344
 345         switch (wps->searchMode) {
 346         case 1:
 347             if ((hmmio = get_mmioFromFile(wps->pszSound)) == 0)
 348                 hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound);
 349             break;
 350         case 2:
 351             if ((hmmio = get_mmioFromProfile(wps->fdwSound | SND_NODEFAULT, wps->pszSound)) == 0)
 352                 if ((hmmio = get_mmioFromFile(wps->pszSound)) == 0)
 353                     hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound);
 354             break;
 355         }
 356     }
 357     if (hmmio == 0) return FALSE;
 358
 359     if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0))
 360         goto errCleanUp;
 361
 362     TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
 363           (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
 364
 365     if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
 366         (ckMainRIFF.fccType != mmioFOURCC('W', 'A', 'V', 'E')))
 367         goto errCleanUp;
 368
 369     mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
 370     if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
 371         goto errCleanUp;
 372
 373     TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
 374           (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
 375
 376     lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
 377     if (mmioRead(hmmio, (HPSTR)lpWaveFormat, mmckInfo.cksize) < sizeof(WAVEFORMAT))
 378         goto errCleanUp;
 379
 380     TRACE("wFormatTag=%04X !\n",        lpWaveFormat->wFormatTag);
 381     TRACE("nChannels=%d \n",            lpWaveFormat->nChannels);
 382     TRACE("nSamplesPerSec=%ld\n",       lpWaveFormat->nSamplesPerSec);
 383     TRACE("nAvgBytesPerSec=%ld\n",      lpWaveFormat->nAvgBytesPerSec);
 384     TRACE("nBlockAlign=%d \n",          lpWaveFormat->nBlockAlign);
 385     TRACE("wBitsPerSample=%u !\n",      lpWaveFormat->wBitsPerSample);
 386
 387     /* move to end of 'fmt ' chunk */
 388     mmioAscend(hmmio, &mmckInfo, 0);
 389
 390     mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
 391     if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
 392         goto errCleanUp;
 393
 394     TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
 395           (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
 396
 397     s.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
 398
 399     if (waveOutOpen(&hWave, WAVE_MAPPER, lpWaveFormat, (DWORD)PlaySound_Callback,
 400                     (DWORD)&s, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
 401         goto errCleanUp;
 402
 403     /* make it so that 3 buffers per second are needed */
 404     bufsize = (((lpWaveFormat->nAvgBytesPerSec / 3) - 1) / lpWaveFormat->nBlockAlign + 1) *
 405         lpWaveFormat->nBlockAlign;
 406     waveHdr = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR) + 2 * bufsize);
 407     waveHdr[0].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR);
 408     waveHdr[1].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR) + bufsize;
 409     waveHdr[0].dwUser = waveHdr[1].dwUser = 0L;
 410     waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L;
 411     waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L;
 412     waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize;
 413     if (waveOutPrepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
 414         waveOutPrepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR))) {
 415         goto errCleanUp;
 416     }
 417
 418     do {
 419         index = 0;
 420         left = mmckInfo.cksize;
 421         s.dwEventCount = 1L; /* for first buffer */
 422
 423         mmioSeek(hmmio, mmckInfo.dwDataOffset, SEEK_SET);
 424         while (left) {
 425             if (wps->bStop) {
 426                 wps->bStop = wps->bLoop = FALSE;
 427                 break;
 428             }
 429             count = mmioRead(hmmio, waveHdr[index].lpData, min(bufsize, left));
 430             if (count < 1) break;
 431             left -= count;
 432             waveHdr[index].dwBufferLength = count;
 433             waveHdr[index].dwFlags &= ~WHDR_DONE;
 434             if (waveOutWrite(hWave, &waveHdr[index], sizeof(WAVEHDR)) == MMSYSERR_NOERROR) {
 435                 index ^= 1;
 436                 PlaySound_WaitDone(&s);
 437             }
 438             else FIXME("Couldn't play header\n");
 439         }
 440         bRet = TRUE;
 441     } while (wps->bLoop);
 442
 443     PlaySound_WaitDone(&s); /* for last buffer */
 444     waveOutReset(hWave);
 445
 446     waveOutUnprepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR));
 447     waveOutUnprepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR));
 448
 449 errCleanUp:
 450     TRACE("Done playing='%s' !\n", debugstr_w(wps->pszSound));
 451     CloseHandle(s.hEvent);
 452     HeapFree(GetProcessHeap(), 0, waveHdr);
 453     HeapFree(GetProcessHeap(), 0, lpWaveFormat);
 454     if (hWave)          while (waveOutClose(hWave) == WAVERR_STILLPLAYING) Sleep(100);
 455     if (hmmio)          mmioClose(hmmio, 0);
 456
 457     SetEvent(wps->hReadyEvent);
 458     iData->lpPlaySound = NULL;
 459
 460     /* when filename: HeapFree(GetProcessHeap(), 0, wps->pszSound); */
 461     CloseHandle(wps->hReadyEvent);
 462     HeapFree(GetProcessHeap(), 0, wps);
 463
 464     return bRet;
 465 }
 466
 467 static BOOL MULTIMEDIA_IsString(DWORD fdwSound, const void* psz)
 468 {
 469     /* SND_RESOURCE is 0x40004 while
 470      * SND_MEMORY is 0x00004
 471      */
 472     switch (fdwSound & SND_RESOURCE)
 473     {
 474     case SND_RESOURCE:  return HIWORD(psz) != 0; /* by name or by ID ? */
 475     case SND_MEMORY:    return FALSE;
 476     /* any other case (SND_ALIAS, SND_FILENAME... shall drop into this one) */
 477     case 0:             return TRUE;
 478     default:            FIXME("WTF\n"); return FALSE;
 479     }
 480 }
 481
 482 static BOOL MULTIMEDIA_PlaySound(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound, DWORD search)
 483 {
 484     WINE_PLAYSOUND*     wps = NULL;
 485     DWORD               id;
 486     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
 487     BOOL                bRet = FALSE;
 488
 489     TRACE("pszSound='%p' hmod=%04X fdwSound=%08lX\n",
 490           pszSound, hmod, fdwSound);
 491
 492     /* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP !
 493      * there could be one if several sounds can be played at once...
 494      */
 495     if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && iData->lpPlaySound)
 496         return FALSE;
 497
 498     do {
 499         HANDLE  hEvt = 0;
 500
 501         /* Trying to stop if playing */
 502         EnterCriticalSection(&iData->cs);
 503         if (iData->lpPlaySound) {
 504             LPWINE_PLAYSOUND        ps2stop = iData->lpPlaySound;
 505
 506             hEvt = ps2stop->hReadyEvent;
 507             ps2stop->bStop = TRUE;
 508         }
 509         LeaveCriticalSection(&iData->cs);
 510         /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave
 511          * FIXME: race here (if hEvt is destroyed and reallocated - as a handle - to
 512          * another object)... unlikely but possible
 513          */
 514         if (hEvt) WaitForSingleObject(hEvt, 1000*10);
 515
 516         if (!pszSound || (fdwSound & SND_PURGE))
 517             return TRUE; /* We stopped playing so leaving */
 518
 519         if (wps == NULL)
 520         {
 521             wps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wps));
 522             if (!wps) return FALSE;
 523
 524             wps->searchMode = search;
 525             wps->hMod = hmod;
 526             wps->fdwSound = fdwSound;
 527             wps->pszSound = pszSound;
 528             if ((wps->hReadyEvent = CreateEventA(NULL, TRUE, FALSE, NULL)) == 0)
 529                 goto cleanup;
 530         }
 531     } while (InterlockedCompareExchangePointer((void**)&iData->lpPlaySound, wps, NULL) != NULL);
 532
 533     if (fdwSound & SND_ASYNC) {
 534         if (MULTIMEDIA_IsString(fdwSound, pszSound))
 535         {
 536             wps->pszSound = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(pszSound)+1) * sizeof(WCHAR));
 537             lstrcpyW((LPWSTR)wps->pszSound, pszSound);
 538         }
 539         wps->bLoop = fdwSound & SND_LOOP;
 540         /* FIXME: memory leak in case of error & cs is still lock */
 541         if ((wps->hThread = CreateThread(NULL, 0, proc_PlaySound, wps, 0, &id)) == 0)
 542             return FALSE;
 543
 544         return TRUE;
 545     }
 546
 547     bRet = proc_PlaySound(wps);
 548  cleanup:
 549     return bRet;
 550 }
 551
 552 /**************************************************************************
 553  *                              PlaySoundA              [WINMM.@]
 554  */
 555 BOOL WINAPI PlaySoundA(LPCSTR pszSoundA, HMODULE hmod, DWORD fdwSound)
 556 {
 557     LPWSTR      pszSoundW;
 558     BOOL        bSound;
 559
 560     pszSoundW = (MULTIMEDIA_IsString(fdwSound, pszSoundA)) ?
 561         HEAP_strdupAtoW(GetProcessHeap(), 0, pszSoundA) : (LPWSTR)pszSoundA;
 562
 563     bSound = PlaySoundW(pszSoundW, hmod, fdwSound);
 564     if ((void*)pszSoundW != (void*)pszSoundA) HeapFree(GetProcessHeap(), 0, pszSoundW);
 565
 566     return bSound;
 567 }
 568
 569 /**************************************************************************
 570  *                              PlaySoundW              [WINMM.@]
 571  */
 572 BOOL WINAPI PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
 573 {
 574     return MULTIMEDIA_PlaySound(pszSound, hmod, fdwSound, 2);
 575 }
 576
 577 /**************************************************************************
 578  *                              PlaySound               [MMSYSTEM.3]
 579  */
 580 BOOL16 WINAPI PlaySound16(LPCSTR pszSound, HMODULE16 hmod, DWORD fdwSound)
 581 {
 582     BOOL16      retv;
 583     DWORD       lc;
 584
 585     ReleaseThunkLock(&lc);
 586     retv = PlaySoundA(pszSound, hmod, fdwSound);
 587     RestoreThunkLock(lc);
 588
 589     return retv;
 590 }
 591
 592 /**************************************************************************
 593  *                              sndPlaySoundA           [WINMM.@]
 594  */
 595 BOOL WINAPI sndPlaySoundA(LPCSTR pszSoundA, UINT uFlags)
 596 {
 597     LPWSTR      pszSoundW;
 598     BOOL        bSound;
 599
 600     pszSoundW = (MULTIMEDIA_IsString(uFlags, pszSoundA)) ?
 601         HEAP_strdupAtoW(GetProcessHeap(), 0, pszSoundA) : (LPWSTR)pszSoundA;
 602
 603     bSound = sndPlaySoundW(pszSoundW, uFlags);
 604     if ((void*)pszSoundW != (void*)pszSoundA)
 605         HeapFree(GetProcessHeap(), 0, pszSoundW);
 606
 607     return bSound;
 608 }
 609
 610 /**************************************************************************
 611  *                              sndPlaySoundW           [WINMM.@]
 612  */
 613 BOOL WINAPI sndPlaySoundW(LPCWSTR pszSound, UINT uFlags)
 614 {
 615     return MULTIMEDIA_PlaySound(pszSound, 0, uFlags, 1);
 616 }
 617
 618 /**************************************************************************
 619  *                              sndPlaySound            [MMSYSTEM.2]
 620  */
 621 BOOL16 WINAPI sndPlaySound16(LPCSTR lpszSoundName, UINT16 uFlags)
 622 {
 623     BOOL16      retv;
 624     DWORD       lc;
 625
 626     ReleaseThunkLock(&lc);
 627     retv = sndPlaySoundA(lpszSoundName, uFlags);
 628     RestoreThunkLock(lc);
 629
 630     return retv;
 631 }
 632
 633 /**************************************************************************
 634  *                              mmsystemGetVersion      [MMSYSTEM.5]
 635  * return value borrowed from Win95 winmm.dll ;)
 636  */
 637 UINT16 WINAPI mmsystemGetVersion16(void)
 638 {
 639     return mmsystemGetVersion();
 640 }
 641
 642 /**************************************************************************
 643  *                              mmsystemGetVersion      [WINMM.@]
 644  */
 645 UINT WINAPI mmsystemGetVersion(void)
 646 {
 647     TRACE("3.10 (Win95?)\n");
 648     return 0x030a;
 649 }
 650
 651 /**************************************************************************
 652  *                              DriverCallback                  [WINMM.@]
 653  */
 654 BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
 655                            UINT wMsg, DWORD dwUser, DWORD dwParam1,
 656                            DWORD dwParam2)
 657 {
 658     TRACE("(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
 659           dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
 660
 661     switch (uFlags & DCB_TYPEMASK) {
 662     case DCB_NULL:
 663         TRACE("Null !\n");
 664         if (dwCallBack)
 665             WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
 666         break;
 667     case DCB_WINDOW:
 668         TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
 669         PostMessageA((HWND)dwCallBack, wMsg, hDev, dwParam1);
 670         break;
 671     case DCB_TASK: /* aka DCB_THREAD */
 672         TRACE("Task(%04lx) !\n", dwCallBack);
 673         PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
 674         break;
 675     case DCB_FUNCTION:
 676         TRACE("Function (32 bit) !\n");
 677         ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
 678         break;
 679     case DCB_EVENT:
 680         TRACE("Event(%08lx) !\n", dwCallBack);
 681         SetEvent((HANDLE)dwCallBack);
 682         break;
 683     case 6: /* I would dub it DCB_MMTHREADSIGNAL */
 684         /* this is an undocumented DCB_ value used for mmThreads
 685          * loword of dwCallBack contains the handle of the lpMMThd block
 686          * which dwSignalCount has to be incremented
 687          */
 688         {
 689             WINE_MMTHREAD*      lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
 690
 691             TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
 692             /* same as mmThreadSignal16 */
 693             InterlockedIncrement(&lpMMThd->dwSignalCount);
 694             SetEvent(lpMMThd->hEvent);
 695             /* some other stuff on lpMMThd->hVxD */
 696         }
 697         break;
 698 #if 0
 699     case 4:
 700         /* this is an undocumented DCB_ value for... I don't know */
 701         break;
 702 #endif
 703     default:
 704         WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
 705         return FALSE;
 706     }
 707     TRACE("Done\n");
 708     return TRUE;
 709 }
 710
 711 /**************************************************************************
 712  *                              DriverCallback                  [MMSYSTEM.31]
 713  */
 714 BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HDRVR16 hDev,
 715                                WORD wMsg, DWORD dwUser, DWORD dwParam1,
 716                                DWORD dwParam2)
 717 {
 718     return DriverCallback(dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
 719 }
 720
 721 /**************************************************************************
 722  *      Mixer devices. New to Win95
 723  */
 724
 725 /**************************************************************************
 726  * find out the real mixer ID depending on hmix (depends on dwFlags)
 727  */
 728 static LPWINE_MIXER MIXER_GetDev(HMIXEROBJ hmix, DWORD dwFlags)
 729 {
 730     LPWINE_MIXER        lpwm = NULL;
 731
 732     switch (dwFlags & 0xF0000000ul) {
 733     case MIXER_OBJECTF_MIXER:
 734         lpwm = (LPWINE_MIXER)MMDRV_Get(hmix, MMDRV_MIXER, TRUE);
 735         break;
 736     case MIXER_OBJECTF_HMIXER:
 737         lpwm = (LPWINE_MIXER)MMDRV_Get(hmix, MMDRV_MIXER, FALSE);
 738         break;
 739     case MIXER_OBJECTF_WAVEOUT:
 740         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEOUT, TRUE,  MMDRV_MIXER);
 741         break;
 742     case MIXER_OBJECTF_HWAVEOUT:
 743         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEOUT, FALSE, MMDRV_MIXER);
 744         break;
 745     case MIXER_OBJECTF_WAVEIN:
 746         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEIN,  TRUE,  MMDRV_MIXER);
 747         break;
 748     case MIXER_OBJECTF_HWAVEIN:
 749         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_WAVEIN,  FALSE, MMDRV_MIXER);
 750         break;
 751     case MIXER_OBJECTF_MIDIOUT:
 752         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIOUT, TRUE,  MMDRV_MIXER);
 753         break;
 754     case MIXER_OBJECTF_HMIDIOUT:
 755         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIOUT, FALSE, MMDRV_MIXER);
 756         break;
 757     case MIXER_OBJECTF_MIDIIN:
 758         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIIN,  TRUE,  MMDRV_MIXER);
 759         break;
 760     case MIXER_OBJECTF_HMIDIIN:
 761         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_MIDIIN,  FALSE, MMDRV_MIXER);
 762         break;
 763     case MIXER_OBJECTF_AUX:
 764         lpwm = (LPWINE_MIXER)MMDRV_GetRelated(hmix, MMDRV_AUX,     TRUE,  MMDRV_MIXER);
 765         break;
 766     default:
 767         FIXME("Unsupported flag (%08lx)\n", dwFlags & 0xF0000000ul);
 768         break;
 769     }
 770     return lpwm;
 771 }
 772
 773 /**************************************************************************
 774  *                              mixerGetNumDevs                 [WINMM.@]
 775  */
 776 UINT WINAPI mixerGetNumDevs(void)
 777 {
 778     return MMDRV_GetNum(MMDRV_MIXER);
 779 }
 780
 781 /**************************************************************************
 782  *                              mixerGetNumDevs                 [MMSYSTEM.800]
 783  */
 784 UINT16 WINAPI mixerGetNumDevs16(void)
 785 {
 786     return MMDRV_GetNum(MMDRV_MIXER);
 787 }
 788
 789 /**************************************************************************
 790  *                              mixerGetDevCapsA                [WINMM.@]
 791  */
 792 UINT WINAPI mixerGetDevCapsA(UINT devid, LPMIXERCAPSA mixcaps, UINT size)
 793 {
 794     LPWINE_MLD  wmld;
 795
 796     if ((wmld = MMDRV_Get(devid, MMDRV_MIXER, TRUE)) == NULL)
 797         return MMSYSERR_BADDEVICEID;
 798
 799     return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD)mixcaps, size, TRUE);
 800 }
 801
 802 /**************************************************************************
 803  *                              mixerGetDevCapsW                [WINMM.@]
 804  */
 805 UINT WINAPI mixerGetDevCapsW(UINT devid, LPMIXERCAPSW mixcaps, UINT size)
 806 {
 807     MIXERCAPSA  micA;
 808     UINT        ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
 809
 810     if (ret == MMSYSERR_NOERROR) {
 811         mixcaps->wMid           = micA.wMid;
 812         mixcaps->wPid           = micA.wPid;
 813         mixcaps->vDriverVersion = micA.vDriverVersion;
 814         MultiByteToWideChar( CP_ACP, 0, micA.szPname, -1, mixcaps->szPname,
 815                              sizeof(mixcaps->szPname)/sizeof(WCHAR) );
 816         mixcaps->fdwSupport     = micA.fdwSupport;
 817         mixcaps->cDestinations  = micA.cDestinations;
 818     }
 819     return ret;
 820 }
 821
 822 /**************************************************************************
 823  *                              mixerGetDevCaps                 [MMSYSTEM.801]
 824  */
 825 UINT16 WINAPI mixerGetDevCaps16(UINT16 devid, LPMIXERCAPS16 mixcaps,
 826                                 UINT16 size)
 827 {
 828     MIXERCAPSA  micA;
 829     UINT        ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
 830
 831     if (ret == MMSYSERR_NOERROR) {
 832         mixcaps->wMid           = micA.wMid;
 833         mixcaps->wPid           = micA.wPid;
 834         mixcaps->vDriverVersion = micA.vDriverVersion;
 835         strcpy(mixcaps->szPname, micA.szPname);
 836         mixcaps->fdwSupport     = micA.fdwSupport;
 837         mixcaps->cDestinations  = micA.cDestinations;
 838     }
 839     return ret;
 840 }
 841
 842 static  UINT  MMSYSTEM_mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
 843                                  DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32)
 844 {
 845     HMIXER              hMix;
 846     LPWINE_MLD          wmld;
 847     DWORD               dwRet = 0;
 848     MIXEROPENDESC       mod;
 849
 850     TRACE("(%p, %d, %08lx, %08lx, %08lx)\n",
 851           lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen);
 852
 853     wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen,
 854                        &dwCallback, &dwInstance, bFrom32);
 855
 856     wmld->uDeviceID = uDeviceID;
 857     mod.hmx = hMix;
 858     mod.dwCallback = dwCallback;
 859     mod.dwInstance = dwInstance;
 860
 861     dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD)&mod, fdwOpen);
 862
 863     if (dwRet != MMSYSERR_NOERROR) {
 864         MMDRV_Free(hMix, wmld);
 865         hMix = 0;
 866     }
 867     if (lphMix) *lphMix = hMix;
 868     TRACE("=> %ld hMixer=%04x\n", dwRet, hMix);
 869
 870     return dwRet;
 871 }
 872
 873 /**************************************************************************
 874  *                              mixerOpen                       [WINMM.@]
 875  */
 876 UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
 877                       DWORD dwInstance, DWORD fdwOpen)
 878 {
 879     return MMSYSTEM_mixerOpen(lphMix, uDeviceID,
 880                               dwCallback, dwInstance, fdwOpen, TRUE);
 881 }
 882
 883 /**************************************************************************
 884  *                              mixerOpen                       [MMSYSTEM.802]
 885  */
 886 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
 887                           DWORD dwInstance, DWORD fdwOpen)
 888 {
 889     HMIXER      hmix;
 890     UINT        ret;
 891
 892     ret = MMSYSTEM_mixerOpen(&hmix, uDeviceID,
 893                              dwCallback, dwInstance, fdwOpen, FALSE);
 894     if (lphmix) *lphmix = hmix;
 895     return ret;
 896 }
 897
 898 /**************************************************************************
 899  *                              mixerClose                      [WINMM.@]
 900  */
 901 UINT WINAPI mixerClose(HMIXER hMix)
 902 {
 903     LPWINE_MLD          wmld;
 904     DWORD               dwRet;
 905
 906     TRACE("(%04x)\n", hMix);
 907
 908     if ((wmld = MMDRV_Get(hMix, MMDRV_MIXER, FALSE)) == NULL) return MMSYSERR_INVALHANDLE;
 909
 910     dwRet = MMDRV_Close(wmld, MXDM_CLOSE);
 911     MMDRV_Free(hMix, wmld);
 912
 913     return dwRet;
 914 }
 915
 916 /**************************************************************************
 917  *                              mixerClose                      [MMSYSTEM.803]
 918  */
 919 UINT16 WINAPI mixerClose16(HMIXER16 hMix)
 920 {
 921     return mixerClose(hMix);
 922 }
 923
 924 /**************************************************************************
 925  *                              mixerGetID                      [WINMM.@]
 926  */
 927 UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
 928 {
 929     LPWINE_MIXER        lpwm;
 930
 931     TRACE("(%04x %p %08lx)\n", hmix, lpid, fdwID);
 932
 933     if ((lpwm = MIXER_GetDev(hmix, fdwID)) == NULL) {
 934         return MMSYSERR_INVALHANDLE;
 935     }
 936
 937     if (lpid)
 938       *lpid = lpwm->mld.uDeviceID;
 939
 940     return MMSYSERR_NOERROR;
 941 }
 942
 943 /**************************************************************************
 944  *                              mixerGetID (MMSYSTEM.806)
 945  */
 946 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
 947 {
 948     UINT        xid;
 949     UINT        ret = mixerGetID(hmix, &xid, fdwID);
 950
 951     if (lpid)
 952         *lpid = xid;
 953     return ret;
 954 }
 955
 956 /**************************************************************************
 957  *                              mixerGetControlDetailsA         [WINMM.@]
 958  */
 959 UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
 960                                     DWORD fdwDetails)
 961 {
 962     LPWINE_MIXER        lpwm;
 963
 964     TRACE("(%04x, %p, %08lx)\n", hmix, lpmcdA, fdwDetails);
 965
 966     if ((lpwm = MIXER_GetDev(hmix, fdwDetails)) == NULL)
 967         return MMSYSERR_INVALHANDLE;
 968
 969     if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
 970         return MMSYSERR_INVALPARAM;
 971
 972     return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD)lpmcdA,
 973                          fdwDetails, TRUE);
 974 }
 975
 976 /**************************************************************************
 977  *                              mixerGetControlDetailsW [WINMM.@]
 978  */
 979 UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
 980 {
 981     DWORD                       ret = MMSYSERR_NOTENABLED;
 982
 983     TRACE("(%04x, %p, %08lx)\n", hmix, lpmcd, fdwDetails);
 984
 985     if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
 986         return MMSYSERR_INVALPARAM;
 987
 988     switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
 989     case MIXER_GETCONTROLDETAILSF_VALUE:
 990         /* can savely use W structure as it is, no string inside */
 991         ret = mixerGetControlDetailsA(hmix, lpmcd, fdwDetails);
 992         break;
 993     case MIXER_GETCONTROLDETAILSF_LISTTEXT:
 994         {
 995             LPVOID      paDetailsW = lpmcd->paDetails;
 996             int         size = max(1, lpmcd->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTA);
 997
 998             if (lpmcd->u.cMultipleItems != 0 && lpmcd->u.cMultipleItems != lpmcd->u.hwndOwner) {
 999                 size *= lpmcd->u.cMultipleItems;
1000             }
1001             lpmcd->paDetails = HeapAlloc(GetProcessHeap(), 0, size);
1002             /* set up lpmcd->paDetails */
1003             ret = mixerGetControlDetailsA(hmix, lpmcd, fdwDetails);
1004             /* copy from lpmcd->paDetails back to paDetailsW; */
1005             HeapFree(GetProcessHeap(), 0, lpmcd->paDetails);
1006             lpmcd->paDetails = paDetailsW;
1007         }
1008         break;
1009     default:
1010         ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails);
1011     }
1012
1013     return ret;
1014 }
1015
1016 /**************************************************************************
1017  *                              mixerGetControlDetails  [MMSYSTEM.808]
1018  */
1019 UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,
1020                                        LPMIXERCONTROLDETAILS16 lpmcd,
1021                                        DWORD fdwDetails)
1022 {
1023     DWORD       ret = MMSYSERR_NOTENABLED;
1024     SEGPTR      sppaDetails;
1025
1026     TRACE("(%04x, %p, %08lx)\n", hmix, lpmcd, fdwDetails);
1027
1028     if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
1029         return MMSYSERR_INVALPARAM;
1030
1031     sppaDetails = (SEGPTR)lpmcd->paDetails;
1032     lpmcd->paDetails = MapSL(sppaDetails);
1033     ret = mixerGetControlDetailsA(hmix, (LPMIXERCONTROLDETAILS)lpmcd, fdwDetails);
1034     lpmcd->paDetails = (LPVOID)sppaDetails;
1035
1036     return ret;
1037 }
1038
1039 /**************************************************************************
1040  *                              mixerGetLineControlsA   [WINMM.@]
1041  */
1042 UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
1043                                   DWORD fdwControls)
1044 {
1045     LPWINE_MIXER        lpwm;
1046
1047     TRACE("(%04x, %p, %08lx)\n", hmix, lpmlcA, fdwControls);
1048
1049     if ((lpwm = MIXER_GetDev(hmix, fdwControls)) == NULL)
1050         return MMSYSERR_INVALHANDLE;
1051
1052     if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA))
1053         return MMSYSERR_INVALPARAM;
1054
1055     return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD)lpmlcA,
1056                          fdwControls, TRUE);
1057 }
1058
1059 /**************************************************************************
1060  *                              mixerGetLineControlsW           [WINMM.@]
1061  */
1062 UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
1063                                   DWORD fdwControls)
1064 {
1065     MIXERLINECONTROLSA  mlcA;
1066     DWORD               ret;
1067     int                 i;
1068
1069     TRACE("(%04x, %p, %08lx)\n", hmix, lpmlcW, fdwControls);
1070
1071     if (lpmlcW == NULL || lpmlcW->cbStruct != sizeof(*lpmlcW) ||
1072         lpmlcW->cbmxctrl != sizeof(MIXERCONTROLW))
1073         return MMSYSERR_INVALPARAM;
1074
1075     mlcA.cbStruct = sizeof(mlcA);
1076     mlcA.dwLineID = lpmlcW->dwLineID;
1077     mlcA.u.dwControlID = lpmlcW->u.dwControlID;
1078     mlcA.u.dwControlType = lpmlcW->u.dwControlType;
1079     mlcA.cControls = lpmlcW->cControls;
1080     mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
1081     mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
1082                               mlcA.cControls * mlcA.cbmxctrl);
1083
1084     ret = mixerGetLineControlsA(hmix, &mlcA, fdwControls);
1085
1086     if (ret == MMSYSERR_NOERROR) {
1087         lpmlcW->dwLineID = mlcA.dwLineID;
1088         lpmlcW->u.dwControlID = mlcA.u.dwControlID;
1089         lpmlcW->u.dwControlType = mlcA.u.dwControlType;
1090         lpmlcW->cControls = mlcA.cControls;
1091
1092         for (i = 0; i < mlcA.cControls; i++) {
1093             lpmlcW->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLW);
1094             lpmlcW->pamxctrl[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
1095             lpmlcW->pamxctrl[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
1096             lpmlcW->pamxctrl[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
1097             lpmlcW->pamxctrl[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
1098             MultiByteToWideChar( CP_ACP, 0, mlcA.pamxctrl[i].szShortName, -1,
1099                                  lpmlcW->pamxctrl[i].szShortName,
1100                                  sizeof(lpmlcW->pamxctrl[i].szShortName)/sizeof(WCHAR) );
1101             MultiByteToWideChar( CP_ACP, 0, mlcA.pamxctrl[i].szName, -1,
1102                                  lpmlcW->pamxctrl[i].szName,
1103                                  sizeof(lpmlcW->pamxctrl[i].szName)/sizeof(WCHAR) );
1104             /* sizeof(lpmlcW->pamxctrl[i].Bounds) ==
1105              * sizeof(mlcA.pamxctrl[i].Bounds) */
1106             memcpy(&lpmlcW->pamxctrl[i].Bounds, &mlcA.pamxctrl[i].Bounds,
1107                    sizeof(mlcA.pamxctrl[i].Bounds));
1108             /* sizeof(lpmlcW->pamxctrl[i].Metrics) ==
1109              * sizeof(mlcA.pamxctrl[i].Metrics) */
1110             memcpy(&lpmlcW->pamxctrl[i].Metrics, &mlcA.pamxctrl[i].Metrics,
1111                    sizeof(mlcA.pamxctrl[i].Metrics));
1112         }
1113     }
1114
1115     HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
1116
1117     return ret;
1118 }
1119
1120 /**************************************************************************
1121  *                              mixerGetLineControls            [MMSYSTEM.807]
1122  */
1123 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,
1124                                      LPMIXERLINECONTROLS16 lpmlc16,
1125                                      DWORD fdwControls)
1126 {
1127     MIXERLINECONTROLSA  mlcA;
1128     DWORD               ret;
1129     int                 i;
1130     LPMIXERCONTROL16    lpmc16;
1131
1132     TRACE("(%04x, %p, %08lx)\n", hmix, lpmlc16, fdwControls);
1133
1134     if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) ||
1135         lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16))
1136         return MMSYSERR_INVALPARAM;
1137
1138     mlcA.cbStruct = sizeof(mlcA);
1139     mlcA.dwLineID = lpmlc16->dwLineID;
1140     mlcA.u.dwControlID = lpmlc16->u.dwControlID;
1141     mlcA.u.dwControlType = lpmlc16->u.dwControlType;
1142     mlcA.cControls = lpmlc16->cControls;
1143     mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
1144     mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
1145                               mlcA.cControls * mlcA.cbmxctrl);
1146
1147     ret = mixerGetLineControlsA(hmix, &mlcA, fdwControls);
1148
1149     if (ret == MMSYSERR_NOERROR) {
1150         lpmlc16->dwLineID = mlcA.dwLineID;
1151         lpmlc16->u.dwControlID = mlcA.u.dwControlID;
1152         lpmlc16->u.dwControlType = mlcA.u.dwControlType;
1153         lpmlc16->cControls = mlcA.cControls;
1154
1155         lpmc16 = MapSL(lpmlc16->pamxctrl);
1156
1157         for (i = 0; i < mlcA.cControls; i++) {
1158             lpmc16[i].cbStruct = sizeof(MIXERCONTROL16);
1159             lpmc16[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
1160             lpmc16[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
1161             lpmc16[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
1162             lpmc16[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
1163             strcpy(lpmc16[i].szShortName, mlcA.pamxctrl[i].szShortName);
1164             strcpy(lpmc16[i].szName, mlcA.pamxctrl[i].szName);
1165             /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
1166             memcpy(&lpmc16[i].Bounds, &mlcA.pamxctrl[i].Bounds,
1167                    sizeof(mlcA.pamxctrl[i].Bounds));
1168             /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
1169             memcpy(&lpmc16[i].Metrics, &mlcA.pamxctrl[i].Metrics,
1170                    sizeof(mlcA.pamxctrl[i].Metrics));
1171         }
1172     }
1173
1174     HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
1175
1176     return ret;
1177 }
1178
1179 /**************************************************************************
1180  *                              mixerGetLineInfoA               [WINMM.@]
1181  */
1182 UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliW, DWORD fdwInfo)
1183 {
1184     LPWINE_MIXER        lpwm;
1185
1186     TRACE("(%04x, %p, %08lx)\n", hmix, lpmliW, fdwInfo);
1187
1188     if ((lpwm = MIXER_GetDev(hmix, fdwInfo)) == NULL)
1189         return MMSYSERR_INVALHANDLE;
1190
1191     return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD)lpmliW,
1192                          fdwInfo, TRUE);
1193 }
1194
1195 /**************************************************************************
1196  *                              mixerGetLineInfoW               [WINMM.@]
1197  */
1198 UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW,
1199                               DWORD fdwInfo)
1200 {
1201     MIXERLINEA          mliA;
1202     UINT                ret;
1203
1204     TRACE("(%04x, %p, %08lx)\n", hmix, lpmliW, fdwInfo);
1205
1206     if (lpmliW == NULL || lpmliW->cbStruct != sizeof(*lpmliW))
1207         return MMSYSERR_INVALPARAM;
1208
1209     mliA.cbStruct = sizeof(mliA);
1210     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
1211     case MIXER_GETLINEINFOF_COMPONENTTYPE:
1212         mliA.dwComponentType = lpmliW->dwComponentType;
1213         break;
1214     case MIXER_GETLINEINFOF_DESTINATION:
1215         mliA.dwDestination = lpmliW->dwDestination;
1216         break;
1217     case MIXER_GETLINEINFOF_LINEID:
1218         mliA.dwLineID = lpmliW->dwLineID;
1219         break;
1220     case MIXER_GETLINEINFOF_SOURCE:
1221         mliA.dwDestination = lpmliW->dwDestination;
1222         mliA.dwSource = lpmliW->dwSource;
1223         break;
1224     case MIXER_GETLINEINFOF_TARGETTYPE:
1225         mliA.Target.dwType = lpmliW->Target.dwType;
1226         mliA.Target.wMid = lpmliW->Target.wMid;
1227         mliA.Target.wPid = lpmliW->Target.wPid;
1228         mliA.Target.vDriverVersion = lpmliW->Target.vDriverVersion;
1229         WideCharToMultiByte( CP_ACP, 0, lpmliW->Target.szPname, -1, mliA.Target.szPname, sizeof(mliA.Target.szPname), NULL, NULL);
1230         break;
1231     default:
1232         FIXME("Unsupported fdwControls=0x%08lx\n", fdwInfo);
1233     }
1234
1235     ret = mixerGetLineInfoA(hmix, &mliA, fdwInfo);
1236
1237     lpmliW->dwDestination = mliA.dwDestination;
1238     lpmliW->dwSource = mliA.dwSource;
1239     lpmliW->dwLineID = mliA.dwLineID;
1240     lpmliW->fdwLine = mliA.fdwLine;
1241     lpmliW->dwUser = mliA.dwUser;
1242     lpmliW->dwComponentType = mliA.dwComponentType;
1243     lpmliW->cChannels = mliA.cChannels;
1244     lpmliW->cConnections = mliA.cConnections;
1245     lpmliW->cControls = mliA.cControls;
1246     MultiByteToWideChar( CP_ACP, 0, mliA.szShortName, -1, lpmliW->szShortName,
1247                          sizeof(lpmliW->szShortName)/sizeof(WCHAR) );
1248     MultiByteToWideChar( CP_ACP, 0, mliA.szName, -1, lpmliW->szName,
1249                          sizeof(lpmliW->szName)/sizeof(WCHAR) );
1250     lpmliW->Target.dwType = mliA.Target.dwType;
1251     lpmliW->Target.dwDeviceID = mliA.Target.dwDeviceID;
1252     lpmliW->Target.wMid = mliA.Target.wMid;
1253     lpmliW->Target.wPid = mliA.Target.wPid;
1254     lpmliW->Target.vDriverVersion = mliA.Target.vDriverVersion;
1255     MultiByteToWideChar( CP_ACP, 0, mliA.Target.szPname, -1, lpmliW->Target.szPname,
1256                          sizeof(lpmliW->Target.szPname)/sizeof(WCHAR) );
1257
1258     return ret;
1259 }
1260
1261 /**************************************************************************
1262  *                              mixerGetLineInfo        [MMSYSTEM.805]
1263  */
1264 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
1265                                  DWORD fdwInfo)
1266 {
1267     MIXERLINEA          mliA;
1268     UINT                ret;
1269
1270     TRACE("(%04x, %p, %08lx)\n", hmix, lpmli16, fdwInfo);
1271
1272     if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16))
1273         return MMSYSERR_INVALPARAM;
1274
1275     mliA.cbStruct = sizeof(mliA);
1276     switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
1277     case MIXER_GETLINEINFOF_COMPONENTTYPE:
1278         mliA.dwComponentType = lpmli16->dwComponentType;
1279         break;
1280     case MIXER_GETLINEINFOF_DESTINATION:
1281         mliA.dwDestination = lpmli16->dwDestination;
1282         break;
1283     case MIXER_GETLINEINFOF_LINEID:
1284         mliA.dwLineID = lpmli16->dwLineID;
1285         break;
1286     case MIXER_GETLINEINFOF_SOURCE:
1287         mliA.dwDestination = lpmli16->dwDestination;
1288         mliA.dwSource = lpmli16->dwSource;
1289         break;
1290     case MIXER_GETLINEINFOF_TARGETTYPE:
1291         mliA.Target.dwType = lpmli16->Target.dwType;
1292         mliA.Target.wMid = lpmli16->Target.wMid;
1293         mliA.Target.wPid = lpmli16->Target.wPid;
1294         mliA.Target.vDriverVersion = lpmli16->Target.vDriverVersion;
1295         strcpy(mliA.Target.szPname, lpmli16->Target.szPname);
1296         break;
1297     default:
1298         FIXME("Unsupported fdwControls=0x%08lx\n", fdwInfo);
1299     }
1300
1301     ret = mixerGetLineInfoA(hmix, &mliA, fdwInfo);
1302
1303     lpmli16->dwDestination      = mliA.dwDestination;
1304     lpmli16->dwSource           = mliA.dwSource;
1305     lpmli16->dwLineID           = mliA.dwLineID;
1306     lpmli16->fdwLine            = mliA.fdwLine;
1307     lpmli16->dwUser             = mliA.dwUser;
1308     lpmli16->dwComponentType    = mliA.dwComponentType;
1309     lpmli16->cChannels          = mliA.cChannels;
1310     lpmli16->cConnections       = mliA.cConnections;
1311     lpmli16->cControls          = mliA.cControls;
1312     strcpy(lpmli16->szShortName, mliA.szShortName);
1313     strcpy(lpmli16->szName, mliA.szName);
1314     lpmli16->Target.dwType      = mliA.Target.dwType;
1315     lpmli16->Target.dwDeviceID  = mliA.Target.dwDeviceID;
1316     lpmli16->Target.wMid        = mliA.Target.wMid;
1317     lpmli16->Target.wPid        = mliA.Target.wPid;
1318     lpmli16->Target.vDriverVersion = mliA.Target.vDriverVersion;
1319     strcpy(lpmli16->Target.szPname, mliA.Target.szPname);
1320
1321     return ret;
1322 }
1323
1324 /**************************************************************************
1325  *                              mixerSetControlDetails  [WINMM.@]
1326  */
1327 UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
1328                                    DWORD fdwDetails)
1329 {
1330     LPWINE_MIXER        lpwm;
1331
1332     TRACE("(%04x, %p, %08lx)\n", hmix, lpmcdA, fdwDetails);
1333
1334     if ((lpwm = MIXER_GetDev(hmix, fdwDetails)) == NULL)
1335         return MMSYSERR_INVALHANDLE;
1336
1337     return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD)lpmcdA,
1338                          fdwDetails, TRUE);
1339 }
1340
1341 /**************************************************************************
1342  *                              mixerSetControlDetails  [MMSYSTEM.809]
1343  */
1344 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,
1345                                        LPMIXERCONTROLDETAILS16 lpmcd,
1346                                        DWORD fdwDetails)
1347 {
1348     TRACE("(%04x, %p, %08lx)\n", hmix, lpmcd, fdwDetails);
1349     return MMSYSERR_NOTENABLED;
1350 }
1351
1352 /**************************************************************************
1353  *                              mixerMessage            [WINMM.@]
1354  */
1355 UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
1356 {
1357     LPWINE_MLD          wmld;
1358
1359     TRACE("(%04lx, %d, %08lx, %08lx): semi-stub?\n",
1360           (DWORD)hmix, uMsg, dwParam1, dwParam2);
1361
1362     if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL)
1363         return MMSYSERR_INVALHANDLE;
1364
1365     return MMDRV_Message(wmld, uMsg, dwParam1, dwParam2, TRUE);
1366 }
1367
1368 /**************************************************************************
1369  *                              mixerMessage            [MMSYSTEM.804]
1370  */
1371 DWORD WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1,
1372                              DWORD dwParam2)
1373 {
1374     return mixerMessage(hmix, uMsg, dwParam1, dwParam2);
1375 }
1376
1377 /**************************************************************************
1378  *                              auxGetNumDevs           [WINMM.@]
1379  */
1380 UINT WINAPI auxGetNumDevs(void)
1381 {
1382     return MMDRV_GetNum(MMDRV_AUX);
1383 }
1384
1385 /**************************************************************************
1386  *                              auxGetNumDevs           [MMSYSTEM.350]
1387  */
1388 UINT16 WINAPI auxGetNumDevs16(void)
1389 {
1390     return MMDRV_GetNum(MMDRV_AUX);
1391 }
1392
1393 /**************************************************************************
1394  *                              auxGetDevCapsW          [WINMM.@]
1395  */
1396 UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
1397 {
1398     AUXCAPSA    acA;
1399     UINT        ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
1400
1401     lpCaps->wMid = acA.wMid;
1402     lpCaps->wPid = acA.wPid;
1403     lpCaps->vDriverVersion = acA.vDriverVersion;
1404     MultiByteToWideChar( CP_ACP, 0, acA.szPname, -1, lpCaps->szPname,
1405                          sizeof(lpCaps->szPname)/sizeof(WCHAR) );
1406     lpCaps->wTechnology = acA.wTechnology;
1407     lpCaps->dwSupport = acA.dwSupport;
1408     return ret;
1409 }
1410
1411 /**************************************************************************
1412  *                              auxGetDevCapsA          [WINMM.@]
1413  */
1414 UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
1415 {
1416     LPWINE_MLD          wmld;
1417
1418     TRACE("(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
1419
1420     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1421         return MMSYSERR_INVALHANDLE;
1422     return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
1423 }
1424
1425 /**************************************************************************
1426  *                              auxGetDevCaps           [MMSYSTEM.351]
1427  */
1428 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
1429 {
1430     LPWINE_MLD          wmld;
1431
1432     TRACE("(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
1433
1434     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1435         return MMSYSERR_INVALHANDLE;
1436     return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
1437 }
1438
1439 /**************************************************************************
1440  *                              auxGetVolume            [WINMM.@]
1441  */
1442 UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
1443 {
1444     LPWINE_MLD          wmld;
1445
1446     TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
1447
1448     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1449         return MMSYSERR_INVALHANDLE;
1450     return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
1451 }
1452
1453 /**************************************************************************
1454  *                              auxGetVolume            [MMSYSTEM.352]
1455  */
1456 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume)
1457 {
1458     LPWINE_MLD          wmld;
1459
1460     TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
1461
1462     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1463         return MMSYSERR_INVALHANDLE;
1464     return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
1465 }
1466
1467 /**************************************************************************
1468  *                              auxSetVolume            [WINMM.@]
1469  */
1470 UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
1471 {
1472     LPWINE_MLD          wmld;
1473
1474     TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume);
1475
1476     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1477         return MMSYSERR_INVALHANDLE;
1478     return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
1479 }
1480
1481 /**************************************************************************
1482  *                              auxSetVolume            [MMSYSTEM.353]
1483  */
1484 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
1485 {
1486     LPWINE_MLD          wmld;
1487
1488     TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume);
1489
1490     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1491         return MMSYSERR_INVALHANDLE;
1492     return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
1493 }
1494
1495 /**************************************************************************
1496  *                              auxOutMessage           [WINMM.@]
1497  */
1498 DWORD WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2)
1499 {
1500     LPWINE_MLD          wmld;
1501
1502     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1503         return MMSYSERR_INVALHANDLE;
1504
1505     return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
1506 }
1507
1508 /**************************************************************************
1509  *                              auxOutMessage           [MMSYSTEM.354]
1510  */
1511 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
1512 {
1513     LPWINE_MLD          wmld;
1514
1515     TRACE("(%04X, %04X, %08lX, %08lX)\n", uDeviceID, uMessage, dw1, dw2);
1516
1517     switch (uMessage) {
1518     case AUXDM_GETNUMDEVS:
1519     case AUXDM_SETVOLUME:
1520         /* no argument conversion needed */
1521         break;
1522     case AUXDM_GETVOLUME:
1523         return auxGetVolume16(uDeviceID, MapSL(dw1));
1524     case AUXDM_GETDEVCAPS:
1525         return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2);
1526     default:
1527         TRACE("(%04x, %04x, %08lx, %08lx): unhandled message\n",
1528               uDeviceID, uMessage, dw1, dw2);
1529         break;
1530     }
1531     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_AUX, TRUE)) == NULL)
1532         return MMSYSERR_INVALHANDLE;
1533
1534     return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
1535 }
1536
1537 /**************************************************************************
1538  *                              mciGetErrorStringW              [WINMM.@]
1539  */
1540 BOOL WINAPI mciGetErrorStringW(DWORD wError, LPWSTR lpstrBuffer, UINT uLength)
1541 {
1542     LPSTR       bufstr = HeapAlloc(GetProcessHeap(), 0, uLength);
1543     BOOL        ret = mciGetErrorStringA(wError, bufstr, uLength);
1544
1545     MultiByteToWideChar( CP_ACP, 0, bufstr, -1, lpstrBuffer, uLength );
1546     HeapFree(GetProcessHeap(), 0, bufstr);
1547     return ret;
1548 }
1549
1550 /**************************************************************************
1551  *                              mciGetErrorString               [MMSYSTEM.706]
1552  */
1553 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
1554 {
1555     return mciGetErrorStringA(wError, lpstrBuffer, uLength);
1556 }
1557
1558 /**************************************************************************
1559  *                              mciGetErrorStringA              [WINMM.@]
1560  */
1561 BOOL WINAPI mciGetErrorStringA(DWORD dwError, LPSTR lpstrBuffer, UINT uLength)
1562 {
1563     BOOL16              ret = FALSE;
1564
1565     if (lpstrBuffer != NULL && uLength > 0 &&
1566         dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) {
1567
1568         if (LoadStringA(MULTIMEDIA_GetIData()->hWinMM32Instance,
1569                         dwError, lpstrBuffer, uLength) > 0) {
1570             ret = TRUE;
1571         }
1572     }
1573     return ret;
1574 }
1575
1576 /**************************************************************************
1577  *                              mciDriverNotify                 [MMSYSTEM.711]
1578  */
1579 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
1580 {
1581     TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
1582
1583     return PostMessageA(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
1584 }
1585
1586 /**************************************************************************
1587  *                      mciDriverNotify                         [WINMM.@]
1588  */
1589 BOOL WINAPI mciDriverNotify(HWND hWndCallBack, UINT wDevID, UINT wStatus)
1590 {
1591
1592     TRACE("(%08X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
1593
1594     return PostMessageA(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
1595 }
1596
1597 /**************************************************************************
1598  *                      mciGetDriverData                        [MMSYSTEM.708]
1599  */
1600 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
1601 {
1602     return mciGetDriverData(uDeviceID);
1603 }
1604
1605 /**************************************************************************
1606  *                      mciGetDriverData                        [WINMM.@]
1607  */
1608 DWORD WINAPI mciGetDriverData(UINT uDeviceID)
1609 {
1610     LPWINE_MCIDRIVER    wmd;
1611
1612     TRACE("(%04x)\n", uDeviceID);
1613
1614     wmd = MCI_GetDriver(uDeviceID);
1615
1616     if (!wmd) {
1617         WARN("Bad uDeviceID\n");
1618         return 0L;
1619     }
1620
1621     return wmd->dwPrivate;
1622 }
1623
1624 /**************************************************************************
1625  *                      mciSetDriverData                        [MMSYSTEM.707]
1626  */
1627 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
1628 {
1629     return mciSetDriverData(uDeviceID, data);
1630 }
1631
1632 /**************************************************************************
1633  *                      mciSetDriverData                        [WINMM.@]
1634  */
1635 BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD data)
1636 {
1637     LPWINE_MCIDRIVER    wmd;
1638
1639     TRACE("(%04x, %08lx)\n", uDeviceID, data);
1640
1641     wmd = MCI_GetDriver(uDeviceID);
1642
1643     if (!wmd) {
1644         WARN("Bad uDeviceID\n");
1645         return FALSE;
1646     }
1647
1648     wmd->dwPrivate = data;
1649     return TRUE;
1650 }
1651
1652 /**************************************************************************
1653  *                              mciSendCommandA                 [WINMM.@]
1654  */
1655 DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
1656 {
1657     DWORD       dwRet;
1658
1659     TRACE("(%08x, %s, %08lx, %08lx)\n",
1660           wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
1661
1662     dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE);
1663     dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2, TRUE);
1664     TRACE("=> %08lx\n", dwRet);
1665     return dwRet;
1666 }
1667
1668 /**************************************************************************
1669  *                              mciSendCommandW                 [WINMM.@]
1670  */
1671 DWORD WINAPI mciSendCommandW(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
1672 {
1673     FIXME("(%08x, %s, %08lx, %08lx): stub\n",
1674           wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
1675     return MCIERR_UNSUPPORTED_FUNCTION;
1676 }
1677
1678 /**************************************************************************
1679  *                              mciSendCommand                  [MMSYSTEM.701]
1680  */
1681 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1682 {
1683     DWORD               dwRet;
1684
1685     TRACE("(%04X, %s, %08lX, %08lX)\n",
1686           wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
1687
1688     dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE);
1689     dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2, FALSE);
1690     TRACE("=> %ld\n", dwRet);
1691     return dwRet;
1692 }
1693
1694 /**************************************************************************
1695  *                              mciGetDeviceID                  [MMSYSTEM.703]
1696  */
1697 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
1698 {
1699     TRACE("(\"%s\")\n", lpstrName);
1700
1701     return MCI_GetDriverFromString(lpstrName);
1702 }
1703
1704 /**************************************************************************
1705  *                              mciGetDeviceIDA                 [WINMM.@]
1706  */
1707 UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
1708 {
1709     return MCI_GetDriverFromString(lpstrName);
1710 }
1711
1712 /**************************************************************************
1713  *                              mciGetDeviceIDW                 [WINMM.@]
1714  */
1715 UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
1716 {
1717     LPSTR       lpstrName;
1718     UINT        ret;
1719
1720     lpstrName = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName);
1721     ret = MCI_GetDriverFromString(lpstrName);
1722     HeapFree(GetProcessHeap(), 0, lpstrName);
1723     return ret;
1724 }
1725
1726 /**************************************************************************
1727  *                              MCI_DefYieldProc                [internal]
1728  */
1729 UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
1730 {
1731     INT16       ret;
1732
1733     TRACE("(0x%04x, 0x%08lx)\n", wDevID, data);
1734
1735     if ((HIWORD(data) != 0 && GetActiveWindow() != HIWORD(data)) ||
1736         (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
1737         UserYield16();
1738         ret = 0;
1739     } else {
1740         MSG             msg;
1741
1742         msg.hwnd = HIWORD(data);
1743         while (!PeekMessageA(&msg, HIWORD(data), WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
1744         ret = -1;
1745     }
1746     return ret;
1747 }
1748
1749 /**************************************************************************
1750  *                              mciSetYieldProc                 [MMSYSTEM.714]
1751  */
1752 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
1753 {
1754     LPWINE_MCIDRIVER    wmd;
1755
1756     TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
1757
1758     if (!(wmd = MCI_GetDriver(uDeviceID))) {
1759         WARN("Bad uDeviceID\n");
1760         return FALSE;
1761     }
1762
1763     wmd->lpfnYieldProc = (YIELDPROC)fpYieldProc;
1764     wmd->dwYieldData   = dwYieldData;
1765     wmd->bIs32         = FALSE;
1766
1767     return TRUE;
1768 }
1769
1770 /**************************************************************************
1771  *                              mciSetYieldProc                 [WINMM.@]
1772  */
1773 BOOL WINAPI mciSetYieldProc(UINT uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
1774 {
1775     LPWINE_MCIDRIVER    wmd;
1776
1777     TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
1778
1779     if (!(wmd = MCI_GetDriver(uDeviceID))) {
1780         WARN("Bad uDeviceID\n");
1781         return FALSE;
1782     }
1783
1784     wmd->lpfnYieldProc = fpYieldProc;
1785     wmd->dwYieldData   = dwYieldData;
1786     wmd->bIs32         = TRUE;
1787
1788     return TRUE;
1789 }
1790
1791 /**************************************************************************
1792  *                              mciGetDeviceIDFromElementID     [MMSYSTEM.715]
1793  */
1794 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
1795 {
1796     FIXME("(%lu, %s) stub\n", dwElementID, lpstrType);
1797     return 0;
1798 }
1799
1800 /**************************************************************************
1801  *                              mciGetDeviceIDFromElementIDW    [WINMM.@]
1802  */
1803 UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
1804 {
1805     /* FIXME: that's rather strange, there is no
1806      * mciGetDeviceIDFromElementID32A in winmm.spec
1807      */
1808     FIXME("(%lu, %p) stub\n", dwElementID, lpstrType);
1809     return 0;
1810 }
1811
1812 /**************************************************************************
1813  *                              mciGetYieldProc                 [MMSYSTEM.716]
1814  */
1815 YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
1816 {
1817     LPWINE_MCIDRIVER    wmd;
1818
1819     TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
1820
1821     if (!(wmd = MCI_GetDriver(uDeviceID))) {
1822         WARN("Bad uDeviceID\n");
1823         return NULL;
1824     }
1825     if (!wmd->lpfnYieldProc) {
1826         WARN("No proc set\n");
1827         return NULL;
1828     }
1829     if (wmd->bIs32) {
1830         WARN("Proc is 32 bit\n");
1831         return NULL;
1832     }
1833     return (YIELDPROC16)wmd->lpfnYieldProc;
1834 }
1835
1836 /**************************************************************************
1837  *                              mciGetYieldProc                 [WINMM.@]
1838  */
1839 YIELDPROC WINAPI mciGetYieldProc(UINT uDeviceID, DWORD* lpdwYieldData)
1840 {
1841     LPWINE_MCIDRIVER    wmd;
1842
1843     TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
1844
1845     if (!(wmd = MCI_GetDriver(uDeviceID))) {
1846         WARN("Bad uDeviceID\n");
1847         return NULL;
1848     }
1849     if (!wmd->lpfnYieldProc) {
1850         WARN("No proc set\n");
1851         return NULL;
1852     }
1853     if (!wmd->bIs32) {
1854         WARN("Proc is 32 bit\n");
1855         return NULL;
1856     }
1857     return wmd->lpfnYieldProc;
1858 }
1859
1860 /**************************************************************************
1861  *                              mciGetCreatorTask               [MMSYSTEM.717]
1862  */
1863 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
1864 {
1865     return mciGetCreatorTask(uDeviceID);
1866 }
1867
1868 /**************************************************************************
1869  *                              mciGetCreatorTask               [WINMM.@]
1870  */
1871 HTASK WINAPI mciGetCreatorTask(UINT uDeviceID)
1872 {
1873     LPWINE_MCIDRIVER    wmd;
1874     HTASK               ret;
1875
1876     TRACE("(%u)\n", uDeviceID);
1877
1878     ret = (!(wmd = MCI_GetDriver(uDeviceID))) ? 0 : wmd->hCreatorTask;
1879
1880     TRACE("=> %04x\n", ret);
1881     return ret;
1882 }
1883
1884 /**************************************************************************
1885  *                              mciDriverYield                  [MMSYSTEM.710]
1886  */
1887 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
1888 {
1889     LPWINE_MCIDRIVER    wmd;
1890     UINT16              ret = 0;
1891
1892     /*    TRACE("(%04x)\n", uDeviceID); */
1893
1894     if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || wmd->bIs32) {
1895         UserYield16();
1896     } else {
1897         ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
1898     }
1899
1900     return ret;
1901 }
1902
1903 /**************************************************************************
1904  *                      mciDriverYield                          [WINMM.@]
1905  */
1906 UINT WINAPI mciDriverYield(UINT uDeviceID)
1907 {
1908     LPWINE_MCIDRIVER    wmd;
1909     UINT                ret = 0;
1910
1911     TRACE("(%04x)\n", uDeviceID);
1912
1913     if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || !wmd->bIs32) {
1914         UserYield16();
1915     } else {
1916         ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
1917     }
1918
1919     return ret;
1920 }
1921
1922 /**************************************************************************
1923  *                              midiOutGetNumDevs       [WINMM.@]
1924  */
1925 UINT WINAPI midiOutGetNumDevs(void)
1926 {
1927     return MMDRV_GetNum(MMDRV_MIDIOUT);
1928 }
1929
1930 /**************************************************************************
1931  *                              midiOutGetNumDevs       [MMSYSTEM.201]
1932  */
1933 UINT16 WINAPI midiOutGetNumDevs16(void)
1934 {
1935     return MMDRV_GetNum(MMDRV_MIDIOUT);
1936 }
1937
1938 /**************************************************************************
1939  *                              midiOutGetDevCapsW      [WINMM.@]
1940  */
1941 UINT WINAPI midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps,
1942                                UINT uSize)
1943 {
1944     MIDIOUTCAPSA        mocA;
1945     UINT                ret;
1946
1947     ret = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(mocA));
1948     lpCaps->wMid                = mocA.wMid;
1949     lpCaps->wPid                = mocA.wPid;
1950     lpCaps->vDriverVersion      = mocA.vDriverVersion;
1951     MultiByteToWideChar( CP_ACP, 0, mocA.szPname, -1, lpCaps->szPname,
1952                          sizeof(lpCaps->szPname)/sizeof(WCHAR) );
1953     lpCaps->wTechnology         = mocA.wTechnology;
1954     lpCaps->wVoices             = mocA.wVoices;
1955     lpCaps->wNotes              = mocA.wNotes;
1956     lpCaps->wChannelMask        = mocA.wChannelMask;
1957     lpCaps->dwSupport           = mocA.dwSupport;
1958     return ret;
1959 }
1960
1961 /**************************************************************************
1962  *                              midiOutGetDevCapsA      [WINMM.@]
1963  */
1964 UINT WINAPI midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps,
1965                                UINT uSize)
1966 {
1967     LPWINE_MLD  wmld;
1968
1969     TRACE("(%u, %p, %u);\n", uDeviceID, lpCaps, uSize);
1970
1971     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1972
1973     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
1974         return MMSYSERR_INVALHANDLE;
1975
1976     return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
1977 }
1978
1979 /**************************************************************************
1980  *                              midiOutGetDevCaps       [MMSYSTEM.202]
1981  */
1982 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps,
1983                                   UINT16 uSize)
1984 {
1985     MIDIOUTCAPSA        capsA;
1986     UINT                dwRet;
1987
1988     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
1989
1990     dwRet = midiOutGetDevCapsA(uDeviceID, &capsA, sizeof(capsA));
1991     if (dwRet == MMSYSERR_NOERROR) {
1992         lpCaps->wMid            = capsA.wMid;
1993         lpCaps->wPid            = capsA.wPid;
1994         lpCaps->vDriverVersion  = capsA.vDriverVersion;
1995         strcpy(lpCaps->szPname, capsA.szPname);
1996         lpCaps->wTechnology     = capsA.wTechnology;
1997         lpCaps->wVoices         = capsA.wVoices;
1998         lpCaps->wNotes          = capsA.wNotes;
1999         lpCaps->wChannelMask    = capsA.wChannelMask;
2000         lpCaps->dwSupport       = capsA.dwSupport;
2001     }
2002     return dwRet;
2003  }
2004
2005 /**************************************************************************
2006  *                              MIDI_GetErrorText               [internal]
2007  */
2008 static  UINT16  MIDI_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
2009 {
2010     UINT16              ret = MMSYSERR_BADERRNUM;
2011
2012     if (lpText == NULL) {
2013         ret = MMSYSERR_INVALPARAM;
2014     } else if (uSize == 0) {
2015         ret = MMSYSERR_NOERROR;
2016     } else if (
2017                /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
2018                 * a warning for the test was always true */
2019                (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) ||
2020                (uError >= MIDIERR_BASE  && uError <= MIDIERR_LASTERROR)) {
2021
2022         if (LoadStringA(MULTIMEDIA_GetIData()->hWinMM32Instance,
2023                         uError, lpText, uSize) > 0) {
2024             ret = MMSYSERR_NOERROR;
2025         }
2026     }
2027     return ret;
2028 }
2029
2030 /**************************************************************************
2031  *                              midiOutGetErrorTextA    [WINMM.@]
2032  */
2033 UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2034 {
2035     return MIDI_GetErrorText(uError, lpText, uSize);
2036 }
2037
2038 /**************************************************************************
2039  *                              midiOutGetErrorTextW    [WINMM.@]
2040  */
2041 UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2042 {
2043     LPSTR       xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
2044     UINT        ret;
2045
2046     ret = MIDI_GetErrorText(uError, xstr, uSize);
2047     MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
2048     HeapFree(GetProcessHeap(), 0, xstr);
2049     return ret;
2050 }
2051
2052 /**************************************************************************
2053  *                              midiOutGetErrorText     [MMSYSTEM.203]
2054  */
2055 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2056 {
2057     return MIDI_GetErrorText(uError, lpText, uSize);
2058 }
2059
2060 /**************************************************************************
2061  *                              MIDI_OutAlloc                   [internal]
2062  */
2063 static  LPWINE_MIDI     MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback,
2064                                       LPDWORD lpdwInstance, LPDWORD lpdwFlags,
2065                                       DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32)
2066 {
2067     HMIDIOUT            hMidiOut;
2068     LPWINE_MIDI         lpwm;
2069     UINT                size;
2070
2071     size = sizeof(WINE_MIDI) + (cIDs ? (cIDs-1) : 0) * sizeof(MIDIOPENSTRMID);
2072
2073     lpwm = (LPWINE_MIDI)MMDRV_Alloc(size, MMDRV_MIDIOUT, &hMidiOut, lpdwFlags,
2074                                     lpdwCallback, lpdwInstance, bFrom32);
2075
2076     if (lphMidiOut != NULL)
2077         *lphMidiOut = hMidiOut;
2078
2079     if (lpwm) {
2080         lpwm->mod.hMidi = hMidiOut;
2081         lpwm->mod.dwCallback = *lpdwCallback;
2082         lpwm->mod.dwInstance = *lpdwInstance;
2083         lpwm->mod.dnDevNode = 0;
2084         lpwm->mod.cIds = cIDs;
2085         if (cIDs)
2086             memcpy(&(lpwm->mod.rgIds), lpIDs, cIDs * sizeof(MIDIOPENSTRMID));
2087     }
2088     return lpwm;
2089 }
2090
2091 UINT MMSYSTEM_midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback,
2092                           DWORD dwInstance, DWORD dwFlags, BOOL bFrom32)
2093 {
2094     HMIDIOUT            hMidiOut;
2095     LPWINE_MIDI         lpwm;
2096     UINT                dwRet = 0;
2097
2098     TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
2099           lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
2100
2101     if (lphMidiOut != NULL) *lphMidiOut = 0;
2102
2103     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags,
2104                          0, NULL, bFrom32);
2105
2106     if (lpwm == NULL)
2107         return MMSYSERR_NOMEM;
2108
2109     lpwm->mld.uDeviceID = uDeviceID;
2110
2111     dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD)&lpwm->mod,
2112                        dwFlags);
2113
2114     if (dwRet != MMSYSERR_NOERROR) {
2115         MMDRV_Free(hMidiOut, (LPWINE_MLD)lpwm);
2116         hMidiOut = 0;
2117     }
2118
2119     if (lphMidiOut) *lphMidiOut = hMidiOut;
2120     TRACE("=> %d hMidi=%04x\n", dwRet, hMidiOut);
2121
2122     return dwRet;
2123 }
2124
2125 /**************************************************************************
2126  *                              midiOutOpen             [WINMM.@]
2127  */
2128 UINT WINAPI midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID,
2129                         DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2130 {
2131     return MMSYSTEM_midiOutOpen(lphMidiOut, uDeviceID, dwCallback,
2132                                 dwInstance, dwFlags, TRUE);
2133 }
2134
2135 /**************************************************************************
2136  *                              midiOutOpen             [MMSYSTEM.204]
2137  */
2138 UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
2139                             DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2140 {
2141     HMIDIOUT    hmo;
2142     UINT        ret;
2143
2144     ret = MMSYSTEM_midiOutOpen(&hmo, uDeviceID, dwCallback, dwInstance,
2145                                dwFlags, FALSE);
2146
2147     if (lphMidiOut != NULL) *lphMidiOut = hmo;
2148     return ret;
2149 }
2150
2151 /**************************************************************************
2152  *                              midiOutClose            [WINMM.@]
2153  */
2154 UINT WINAPI midiOutClose(HMIDIOUT hMidiOut)
2155 {
2156     LPWINE_MLD          wmld;
2157     DWORD               dwRet;
2158
2159     TRACE("(%04X)\n", hMidiOut);
2160
2161     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2162         return MMSYSERR_INVALHANDLE;
2163
2164     dwRet = MMDRV_Close(wmld, MODM_CLOSE);
2165     MMDRV_Free(hMidiOut, wmld);
2166
2167     return dwRet;
2168 }
2169
2170 /**************************************************************************
2171  *                              midiOutClose            [MMSYSTEM.205]
2172  */
2173 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
2174 {
2175     return midiOutClose(hMidiOut);
2176 }
2177
2178 /**************************************************************************
2179  *                              midiOutPrepareHeader    [WINMM.@]
2180  */
2181 UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
2182                                  MIDIHDR* lpMidiOutHdr, UINT uSize)
2183 {
2184     LPWINE_MLD          wmld;
2185
2186     TRACE("(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2187
2188     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2189         return MMSYSERR_INVALHANDLE;
2190
2191     return MMDRV_Message(wmld, MODM_PREPARE, (DWORD)lpMidiOutHdr, uSize, TRUE);
2192 }
2193
2194 /**************************************************************************
2195  *                              midiOutPrepareHeader    [MMSYSTEM.206]
2196  */
2197 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
2198                                      SEGPTR lpsegMidiOutHdr,      /* [???] */
2199                                      UINT16 uSize)                /* [in] */
2200 {
2201     LPWINE_MLD          wmld;
2202
2203     TRACE("(%04X, %08lx, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
2204
2205     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2206         return MMSYSERR_INVALHANDLE;
2207
2208     return MMDRV_Message(wmld, MODM_PREPARE, lpsegMidiOutHdr, uSize, FALSE);
2209 }
2210
2211 /**************************************************************************
2212  *                              midiOutUnprepareHeader  [WINMM.@]
2213  */
2214 UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
2215                                    MIDIHDR* lpMidiOutHdr, UINT uSize)
2216 {
2217     LPWINE_MLD          wmld;
2218
2219     TRACE("(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2220
2221     if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
2222         return MMSYSERR_NOERROR;
2223     }
2224
2225     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2226         return MMSYSERR_INVALHANDLE;
2227
2228     return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD)lpMidiOutHdr, uSize, TRUE);
2229 }
2230
2231 /**************************************************************************
2232  *                              midiOutUnprepareHeader  [MMSYSTEM.207]
2233  */
2234 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
2235                                        SEGPTR lpsegMidiOutHdr,      /* [???] */
2236                                        UINT16 uSize)                /* [in] */
2237 {
2238     LPWINE_MLD          wmld;
2239     LPMIDIHDR16         lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
2240
2241     TRACE("(%04X, %08lx, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
2242
2243     if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
2244         return MMSYSERR_NOERROR;
2245     }
2246
2247     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2248         return MMSYSERR_INVALHANDLE;
2249
2250     return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD)lpsegMidiOutHdr, uSize, FALSE);
2251 }
2252
2253 /**************************************************************************
2254  *                              midiOutShortMsg         [WINMM.@]
2255  */
2256 UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
2257 {
2258     LPWINE_MLD          wmld;
2259
2260     TRACE("(%04X, %08lX)\n", hMidiOut, dwMsg);
2261
2262     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2263         return MMSYSERR_INVALHANDLE;
2264
2265     return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L, FALSE);
2266 }
2267
2268 /**************************************************************************
2269  *                              midiOutShortMsg         [MMSYSTEM.208]
2270  */
2271 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
2272 {
2273     return midiOutShortMsg(hMidiOut, dwMsg);
2274 }
2275
2276 /**************************************************************************
2277  *                              midiOutLongMsg          [WINMM.@]
2278  */
2279 UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
2280                            MIDIHDR* lpMidiOutHdr, UINT uSize)
2281 {
2282     LPWINE_MLD          wmld;
2283
2284     TRACE("(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2285
2286     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2287         return MMSYSERR_INVALHANDLE;
2288
2289     return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD)lpMidiOutHdr, uSize, TRUE);
2290 }
2291
2292 /**************************************************************************
2293  *                              midiOutLongMsg          [MMSYSTEM.209]
2294  */
2295 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,          /* [in] */
2296                                LPMIDIHDR16 lpsegMidiOutHdr,  /* [???] NOTE: SEGPTR */
2297                                UINT16 uSize)                 /* [in] */
2298 {
2299     LPWINE_MLD          wmld;
2300
2301     TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
2302
2303     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2304         return MMSYSERR_INVALHANDLE;
2305
2306     return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD)lpsegMidiOutHdr, uSize, FALSE);
2307 }
2308
2309 /**************************************************************************
2310  *                              midiOutReset            [WINMM.@]
2311  */
2312 UINT WINAPI midiOutReset(HMIDIOUT hMidiOut)
2313 {
2314     LPWINE_MLD          wmld;
2315
2316     TRACE("(%04X)\n", hMidiOut);
2317
2318     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2319         return MMSYSERR_INVALHANDLE;
2320
2321     return MMDRV_Message(wmld, MODM_RESET, 0L, 0L, TRUE);
2322 }
2323
2324 /**************************************************************************
2325  *                              midiOutReset            [MMSYSTEM.210]
2326  */
2327 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
2328 {
2329     return midiOutReset(hMidiOut);
2330 }
2331
2332 /**************************************************************************
2333  *                              midiOutGetVolume        [WINMM.@]
2334  */
2335 UINT WINAPI midiOutGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
2336 {
2337     LPWINE_MLD          wmld;
2338
2339     TRACE("(%04X, %p);\n", uDeviceID, lpdwVolume);
2340
2341     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
2342         return MMSYSERR_INVALHANDLE;
2343
2344     return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
2345 }
2346
2347 /**************************************************************************
2348  *                              midiOutGetVolume        [MMSYSTEM.211]
2349  */
2350 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
2351 {
2352     return midiOutGetVolume(uDeviceID, lpdwVolume);
2353 }
2354
2355 /**************************************************************************
2356  *                              midiOutSetVolume        [WINMM.@]
2357  */
2358 UINT WINAPI midiOutSetVolume(UINT uDeviceID, DWORD dwVolume)
2359 {
2360     LPWINE_MLD          wmld;
2361
2362     TRACE("(%04X, %ld);\n", uDeviceID, dwVolume);
2363
2364     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
2365         return MMSYSERR_INVALHANDLE;
2366
2367     return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L, TRUE);
2368 }
2369
2370 /**************************************************************************
2371  *                              midiOutSetVolume        [MMSYSTEM.212]
2372  */
2373 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
2374 {
2375     return midiOutSetVolume(uDeviceID, dwVolume);
2376 }
2377
2378 /**************************************************************************
2379  *                              midiOutCachePatches             [WINMM.@]
2380  */
2381 UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut, UINT uBank,
2382                                 WORD* lpwPatchArray, UINT uFlags)
2383 {
2384     /* not really necessary to support this */
2385     FIXME("not supported yet\n");
2386     return MMSYSERR_NOTSUPPORTED;
2387 }
2388
2389 /**************************************************************************
2390  *                              midiOutCachePatches             [MMSYSTEM.213]
2391  */
2392 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
2393                                     WORD* lpwPatchArray, UINT16 uFlags)
2394 {
2395     return midiOutCachePatches(hMidiOut, uBank, lpwPatchArray, uFlags);
2396 }
2397
2398 /**************************************************************************
2399  *                              midiOutCacheDrumPatches [WINMM.@]
2400  */
2401 UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut, UINT uPatch,
2402                                     WORD* lpwKeyArray, UINT uFlags)
2403 {
2404     FIXME("not supported yet\n");
2405     return MMSYSERR_NOTSUPPORTED;
2406 }
2407
2408 /**************************************************************************
2409  *                              midiOutCacheDrumPatches [MMSYSTEM.214]
2410  */
2411 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
2412                                         WORD* lpwKeyArray, UINT16 uFlags)
2413 {
2414     return midiOutCacheDrumPatches16(hMidiOut, uPatch, lpwKeyArray, uFlags);
2415 }
2416
2417 /**************************************************************************
2418  *                              midiOutGetID            [WINMM.@]
2419  */
2420 UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
2421 {
2422     LPWINE_MLD          wmld;
2423
2424     TRACE("(%04X, %p)\n", hMidiOut, lpuDeviceID);
2425
2426     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
2427     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2428         return MMSYSERR_INVALHANDLE;
2429
2430     *lpuDeviceID = wmld->uDeviceID;
2431     return MMSYSERR_NOERROR;
2432 }
2433
2434 /**************************************************************************
2435  *                              midiOutGetID            [MMSYSTEM.215]
2436  */
2437 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
2438 {
2439     LPWINE_MLD          wmld;
2440
2441     TRACE("(%04X, %p)\n", hMidiOut, lpuDeviceID);
2442
2443     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
2444     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2445         return MMSYSERR_INVALHANDLE;
2446
2447     *lpuDeviceID = wmld->uDeviceID;
2448     return MMSYSERR_NOERROR;
2449 }
2450
2451 /**************************************************************************
2452  *                              midiOutMessage          [WINMM.@]
2453  */
2454 DWORD WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
2455                             DWORD dwParam1, DWORD dwParam2)
2456 {
2457     LPWINE_MLD          wmld;
2458
2459     TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
2460
2461     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2462         return MMSYSERR_INVALHANDLE;
2463
2464     switch (uMessage) {
2465     case MODM_OPEN:
2466     case MODM_CLOSE:
2467         FIXME("can't handle OPEN or CLOSE message!\n");
2468         return MMSYSERR_NOTSUPPORTED;
2469     }
2470     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
2471 }
2472
2473 /**************************************************************************
2474  *                              midiOutMessage          [MMSYSTEM.216]
2475  */
2476 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
2477                               DWORD dwParam1, DWORD dwParam2)
2478 {
2479     LPWINE_MLD          wmld;
2480
2481     TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
2482
2483     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
2484         return MMSYSERR_INVALHANDLE;
2485
2486     switch (uMessage) {
2487     case MODM_OPEN:
2488     case MODM_CLOSE:
2489         FIXME("can't handle OPEN or CLOSE message!\n");
2490         return MMSYSERR_NOTSUPPORTED;
2491
2492     case MODM_GETVOLUME:
2493         return midiOutGetVolume16(hMidiOut, MapSL(dwParam1));
2494     case MODM_LONGDATA:
2495         return midiOutLongMsg16(hMidiOut, MapSL(dwParam1), dwParam2);
2496     case MODM_PREPARE:
2497         /* lpMidiOutHdr is still a segmented pointer for this function */
2498         return midiOutPrepareHeader16(hMidiOut, dwParam1, dwParam2);
2499     case MODM_UNPREPARE:
2500         return midiOutUnprepareHeader16(hMidiOut, dwParam1, dwParam2);
2501     }
2502     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
2503 }
2504
2505 /**************************************************************************
2506  *                              midiInGetNumDevs        [WINMM.@]
2507  */
2508 UINT WINAPI midiInGetNumDevs(void)
2509 {
2510     return MMDRV_GetNum(MMDRV_MIDIIN);
2511 }
2512
2513 /**************************************************************************
2514  *                              midiInGetNumDevs        [MMSYSTEM.301]
2515  */
2516 UINT16 WINAPI midiInGetNumDevs16(void)
2517 {
2518     return MMDRV_GetNum(MMDRV_MIDIIN);
2519 }
2520
2521 /**************************************************************************
2522  *                              midiInGetDevCapsW       [WINMM.@]
2523  */
2524 UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
2525 {
2526     MIDIINCAPSA         micA;
2527     UINT                ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
2528
2529     if (ret == MMSYSERR_NOERROR) {
2530         lpCaps->wMid = micA.wMid;
2531         lpCaps->wPid = micA.wPid;
2532         lpCaps->vDriverVersion = micA.vDriverVersion;
2533         MultiByteToWideChar( CP_ACP, 0, micA.szPname, -1, lpCaps->szPname,
2534                              sizeof(lpCaps->szPname)/sizeof(WCHAR) );
2535         lpCaps->dwSupport = micA.dwSupport;
2536     }
2537     return ret;
2538 }
2539
2540 /**************************************************************************
2541  *                              midiInGetDevCapsA       [WINMM.@]
2542  */
2543 UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
2544 {
2545     LPWINE_MLD  wmld;
2546
2547     TRACE("(%d, %p, %d);\n", uDeviceID, lpCaps, uSize);
2548
2549     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL)
2550         return MMSYSERR_INVALHANDLE;
2551
2552    return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
2553 }
2554
2555 /**************************************************************************
2556  *                              midiInGetDevCaps        [MMSYSTEM.302]
2557  */
2558 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps,
2559                                  UINT16 uSize)
2560 {
2561     MIDIINCAPSA         micA;
2562     UINT                ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
2563
2564     if (ret == MMSYSERR_NOERROR) {
2565         lpCaps->wMid = micA.wMid;
2566         lpCaps->wPid = micA.wPid;
2567         lpCaps->vDriverVersion = micA.vDriverVersion;
2568         strcpy(lpCaps->szPname, micA.szPname);
2569         lpCaps->dwSupport = micA.dwSupport;
2570     }
2571
2572     return ret;
2573 }
2574
2575 /**************************************************************************
2576  *                              midiInGetErrorTextW             [WINMM.@]
2577  */
2578 UINT WINAPI midiInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2579 {
2580     LPSTR       xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
2581     UINT        ret = MIDI_GetErrorText(uError, xstr, uSize);
2582
2583     MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
2584     HeapFree(GetProcessHeap(), 0, xstr);
2585     return ret;
2586 }
2587
2588 /**************************************************************************
2589  *                              midiInGetErrorTextA             [WINMM.@]
2590  */
2591 UINT WINAPI midiInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2592 {
2593     return MIDI_GetErrorText(uError, lpText, uSize);
2594 }
2595
2596 /**************************************************************************
2597  *                              midiInGetErrorText              [MMSYSTEM.303]
2598  */
2599 UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2600 {
2601     return MIDI_GetErrorText(uError, lpText, uSize);
2602 }
2603
2604 static  UINT MMSYSTEM_midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD dwCallback,
2605                                  DWORD dwInstance, DWORD dwFlags, BOOL bFrom32)
2606 {
2607     HMIDIIN             hMidiIn;
2608     LPWINE_MIDI         lpwm;
2609     DWORD               dwRet = 0;
2610
2611     TRACE("(%p, %d, %08lX, %08lX, %08lX);\n",
2612           lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
2613
2614     if (lphMidiIn != NULL) *lphMidiIn = 0;
2615
2616     lpwm = (LPWINE_MIDI)MMDRV_Alloc(sizeof(WINE_MIDI), MMDRV_MIDIIN, &hMidiIn,
2617                                     &dwFlags, &dwCallback, &dwInstance, bFrom32);
2618
2619     if (lpwm == NULL)
2620         return MMSYSERR_NOMEM;
2621
2622     lpwm->mod.hMidi = hMidiIn;
2623     lpwm->mod.dwCallback = dwCallback;
2624     lpwm->mod.dwInstance = dwInstance;
2625
2626     lpwm->mld.uDeviceID = uDeviceID;
2627     dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD)&lpwm->mod, dwFlags);
2628
2629     if (dwRet != MMSYSERR_NOERROR) {
2630         MMDRV_Free(hMidiIn, &lpwm->mld);
2631         hMidiIn = 0;
2632     }
2633     if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
2634     TRACE("=> %ld hMidi=%04x\n", dwRet, hMidiIn);
2635
2636     return dwRet;
2637 }
2638
2639 /**************************************************************************
2640  *                              midiInOpen              [WINMM.@]
2641  */
2642 UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
2643                        DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2644 {
2645     return MMSYSTEM_midiInOpen(lphMidiIn, uDeviceID, dwCallback,
2646                                dwInstance, dwFlags, TRUE);
2647 }
2648
2649 /**************************************************************************
2650  *                              midiInOpen              [MMSYSTEM.304]
2651  */
2652 UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
2653                            DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2654 {
2655     HMIDIIN     xhmid;
2656     UINT        ret;
2657
2658     ret = MMSYSTEM_midiInOpen(&xhmid, uDeviceID, dwCallback, dwInstance,
2659                               dwFlags, FALSE);
2660
2661     if (lphMidiIn) *lphMidiIn = xhmid;
2662     return ret;
2663 }
2664
2665 /**************************************************************************
2666  *                              midiInClose             [WINMM.@]
2667  */
2668 UINT WINAPI midiInClose(HMIDIIN hMidiIn)
2669 {
2670     LPWINE_MLD          wmld;
2671     DWORD               dwRet;
2672
2673     TRACE("(%04X)\n", hMidiIn);
2674
2675     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2676         return MMSYSERR_INVALHANDLE;
2677
2678     dwRet = MMDRV_Close(wmld, MIDM_CLOSE);
2679     MMDRV_Free(hMidiIn, wmld);
2680     return dwRet;
2681 }
2682
2683 /**************************************************************************
2684  *                              midiInClose             [MMSYSTEM.305]
2685  */
2686 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
2687 {
2688     return midiInClose(hMidiIn);
2689 }
2690
2691 /**************************************************************************
2692  *                              midiInPrepareHeader     [WINMM.@]
2693  */
2694 UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
2695                                 MIDIHDR* lpMidiInHdr, UINT uSize)
2696 {
2697     LPWINE_MLD          wmld;
2698
2699     TRACE("(%04X, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
2700
2701     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2702         return MMSYSERR_INVALHANDLE;
2703
2704     return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD)lpMidiInHdr, uSize, TRUE);
2705 }
2706
2707 /**************************************************************************
2708  *                              midiInPrepareHeader     [MMSYSTEM.306]
2709  */
2710 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
2711                                     SEGPTR lpsegMidiInHdr,     /* [???] */
2712                                     UINT16 uSize)              /* [in] */
2713 {
2714     LPWINE_MLD          wmld;
2715
2716     TRACE("(%04X, %08lx, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
2717
2718     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2719         return MMSYSERR_INVALHANDLE;
2720
2721     return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD)lpsegMidiInHdr, uSize, FALSE);
2722 }
2723
2724 /**************************************************************************
2725  *                              midiInUnprepareHeader   [WINMM.@]
2726  */
2727 UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
2728                                   MIDIHDR* lpMidiInHdr, UINT uSize)
2729 {
2730     LPWINE_MLD          wmld;
2731
2732     TRACE("(%04X, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
2733
2734     if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
2735         return MMSYSERR_NOERROR;
2736     }
2737
2738     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2739         return MMSYSERR_INVALHANDLE;
2740
2741     return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD)lpMidiInHdr, uSize, TRUE);
2742 }
2743
2744 /**************************************************************************
2745  *                              midiInUnprepareHeader   [MMSYSTEM.307]
2746  */
2747 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
2748                                       SEGPTR lpsegMidiInHdr,     /* [???] */
2749                                       UINT16 uSize)              /* [in] */
2750 {
2751     LPWINE_MLD          wmld;
2752     LPMIDIHDR16         lpMidiInHdr = MapSL(lpsegMidiInHdr);
2753
2754     TRACE("(%04X, %08lx, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
2755
2756     if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
2757         return MMSYSERR_NOERROR;
2758     }
2759
2760     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2761         return MMSYSERR_INVALHANDLE;
2762
2763     return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD)lpsegMidiInHdr, uSize, FALSE);
2764 }
2765
2766 /**************************************************************************
2767  *                              midiInAddBuffer         [WINMM.@]
2768  */
2769 UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
2770                             MIDIHDR* lpMidiInHdr, UINT uSize)
2771 {
2772     LPWINE_MLD          wmld;
2773
2774     TRACE("(%04X, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
2775
2776     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2777         return MMSYSERR_INVALHANDLE;
2778
2779     return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD)lpMidiInHdr, uSize, TRUE);
2780 }
2781
2782 /**************************************************************************
2783  *                              midiInAddBuffer         [MMSYSTEM.308]
2784  */
2785 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,         /* [in] */
2786                                 MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
2787                                 UINT16 uSize)              /* [in] */
2788 {
2789     LPWINE_MLD          wmld;
2790
2791     TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
2792
2793     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2794         return MMSYSERR_INVALHANDLE;
2795
2796     return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD)lpsegMidiInHdr, uSize, FALSE);
2797 }
2798
2799 /**************************************************************************
2800  *                              midiInStart                     [WINMM.@]
2801  */
2802 UINT WINAPI midiInStart(HMIDIIN hMidiIn)
2803 {
2804     LPWINE_MLD          wmld;
2805
2806     TRACE("(%04X)\n", hMidiIn);
2807
2808     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2809         return MMSYSERR_INVALHANDLE;
2810
2811     return MMDRV_Message(wmld, MIDM_START, 0L, 0L, TRUE);
2812 }
2813
2814 /**************************************************************************
2815  *                              midiInStart                     [MMSYSTEM.309]
2816  */
2817 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
2818 {
2819     return midiInStart(hMidiIn);
2820 }
2821
2822 /**************************************************************************
2823  *                              midiInStop                      [WINMM.@]
2824  */
2825 UINT WINAPI midiInStop(HMIDIIN hMidiIn)
2826 {
2827     LPWINE_MLD          wmld;
2828
2829     TRACE("(%04X)\n", hMidiIn);
2830
2831     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2832         return MMSYSERR_INVALHANDLE;
2833
2834     return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L, TRUE);
2835 }
2836
2837 /**************************************************************************
2838  *                              midiInStop                      [MMSYSTEM.310]
2839  */
2840 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
2841 {
2842     return midiInStop(hMidiIn);
2843 }
2844
2845 /**************************************************************************
2846  *                              midiInReset                     [WINMM.@]
2847  */
2848 UINT WINAPI midiInReset(HMIDIIN hMidiIn)
2849 {
2850     LPWINE_MLD          wmld;
2851
2852     TRACE("(%04X)\n", hMidiIn);
2853
2854     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2855         return MMSYSERR_INVALHANDLE;
2856
2857     return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L, TRUE);
2858 }
2859
2860 /**************************************************************************
2861  *                              midiInReset                     [MMSYSTEM.311]
2862  */
2863 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
2864 {
2865     return midiInReset(hMidiIn);
2866 }
2867
2868 /**************************************************************************
2869  *                              midiInGetID                     [WINMM.@]
2870  */
2871 UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT* lpuDeviceID)
2872 {
2873     LPWINE_MLD          wmld;
2874
2875     TRACE("(%04X, %p)\n", hMidiIn, lpuDeviceID);
2876
2877     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
2878
2879     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, TRUE)) == NULL)
2880         return MMSYSERR_INVALHANDLE;
2881
2882     *lpuDeviceID = wmld->uDeviceID;
2883
2884     return MMSYSERR_NOERROR;
2885 }
2886
2887 /**************************************************************************
2888  *                              midiInGetID                     [MMSYSTEM.312]
2889  */
2890 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
2891 {
2892     LPWINE_MLD          wmld;
2893
2894     TRACE("(%04X, %p)\n", hMidiIn, lpuDeviceID);
2895
2896     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
2897
2898     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, TRUE)) == NULL)
2899         return MMSYSERR_INVALHANDLE;
2900
2901     *lpuDeviceID = wmld->uDeviceID;
2902
2903     return MMSYSERR_NOERROR;
2904 }
2905
2906 /**************************************************************************
2907  *                              midiInMessage           [WINMM.@]
2908  */
2909 DWORD WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
2910                            DWORD dwParam1, DWORD dwParam2)
2911 {
2912     LPWINE_MLD          wmld;
2913
2914     TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
2915
2916     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2917         return MMSYSERR_INVALHANDLE;
2918
2919     switch (uMessage) {
2920     case MIDM_OPEN:
2921     case MIDM_CLOSE:
2922         FIXME("can't handle OPEN or CLOSE message!\n");
2923         return MMSYSERR_NOTSUPPORTED;
2924     }
2925     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
2926 }
2927
2928 /**************************************************************************
2929  *                              midiInMessage           [MMSYSTEM.313]
2930  */
2931 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
2932                              DWORD dwParam1, DWORD dwParam2)
2933 {
2934     LPWINE_MLD          wmld;
2935
2936     TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
2937
2938     switch (uMessage) {
2939     case MIDM_OPEN:
2940     case MIDM_CLOSE:
2941         FIXME("can't handle OPEN or CLOSE message!\n");
2942         return MMSYSERR_NOTSUPPORTED;
2943
2944     case MIDM_GETDEVCAPS:
2945         return midiInGetDevCaps16(hMidiIn, MapSL(dwParam1), dwParam2);
2946     case MIDM_PREPARE:
2947         return midiInPrepareHeader16(hMidiIn, dwParam1, dwParam2);
2948     case MIDM_UNPREPARE:
2949         return midiInUnprepareHeader16(hMidiIn, dwParam1, dwParam2);
2950     case MIDM_ADDBUFFER:
2951         return midiInAddBuffer16(hMidiIn, MapSL(dwParam1), dwParam2);
2952     }
2953
2954     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
2955         return MMSYSERR_INVALHANDLE;
2956
2957     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
2958 }
2959
2960 typedef struct WINE_MIDIStream {
2961     HMIDIOUT                    hDevice;
2962     HANDLE                      hThread;
2963     DWORD                       dwThreadID;
2964     DWORD                       dwTempo;
2965     DWORD                       dwTimeDiv;
2966     DWORD                       dwPositionMS;
2967     DWORD                       dwPulses;
2968     DWORD                       dwStartTicks;
2969     WORD                        wFlags;
2970     HANDLE                      hEvent;
2971     LPMIDIHDR                   lpMidiHdr;
2972 } WINE_MIDIStream;
2973
2974 #define WINE_MSM_HEADER         (WM_USER+0)
2975 #define WINE_MSM_STOP           (WM_USER+1)
2976
2977 /**************************************************************************
2978  *                              MMSYSTEM_GetMidiStream          [internal]
2979  */
2980 static  BOOL    MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm, WINE_MIDIStream** lpMidiStrm, WINE_MIDI** lplpwm)
2981 {
2982     WINE_MIDI* lpwm = (LPWINE_MIDI)MMDRV_Get(hMidiStrm, MMDRV_MIDIOUT, FALSE);
2983
2984     if (lplpwm)
2985         *lplpwm = lpwm;
2986
2987     if (lpwm == NULL) {
2988         return FALSE;
2989     }
2990
2991     *lpMidiStrm = (WINE_MIDIStream*)lpwm->mod.rgIds.dwStreamID;
2992
2993     return *lpMidiStrm != NULL;
2994 }
2995
2996 /**************************************************************************
2997  *                              MMSYSTEM_MidiStream_Convert     [internal]
2998  */
2999 static  DWORD   MMSYSTEM_MidiStream_Convert(WINE_MIDIStream* lpMidiStrm, DWORD pulse)
3000 {
3001     DWORD       ret = 0;
3002
3003     if (lpMidiStrm->dwTimeDiv == 0) {
3004         FIXME("Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
3005     } else if (lpMidiStrm->dwTimeDiv > 0x8000) { /* SMPTE, unchecked FIXME? */
3006         int     nf = -(char)HIBYTE(lpMidiStrm->dwTimeDiv);      /* number of frames     */
3007         int     nsf = LOBYTE(lpMidiStrm->dwTimeDiv);            /* number of sub-frames */
3008         ret = (pulse * 1000) / (nf * nsf);
3009     } else {
3010         ret = (DWORD)((double)pulse * ((double)lpMidiStrm->dwTempo / 1000) /
3011                       (double)lpMidiStrm->dwTimeDiv);
3012     }
3013
3014     return ret;
3015 }
3016
3017 /**************************************************************************
3018  *                      MMSYSTEM_MidiStream_MessageHandler      [internal]
3019  */
3020 static  BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWINE_MIDI lpwm, LPMSG msg)
3021 {
3022     LPMIDIHDR   lpMidiHdr;
3023     LPMIDIHDR*  lpmh;
3024     LPBYTE      lpData;
3025
3026     switch (msg->message) {
3027     case WM_QUIT:
3028         SetEvent(lpMidiStrm->hEvent);
3029         return FALSE;
3030     case WINE_MSM_STOP:
3031         TRACE("STOP\n");
3032         /* this is not quite what MS doc says... */
3033         midiOutReset(lpMidiStrm->hDevice);
3034         /* empty list of already submitted buffers */
3035         for (lpMidiHdr = lpMidiStrm->lpMidiHdr; lpMidiHdr; lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext) {
3036             lpMidiHdr->dwFlags |= MHDR_DONE;
3037             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
3038
3039             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, lpMidiStrm->hDevice,
3040                            MM_MOM_DONE, lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
3041         }
3042         lpMidiStrm->lpMidiHdr = 0;
3043         SetEvent(lpMidiStrm->hEvent);
3044         break;
3045     case WINE_MSM_HEADER:
3046         /* sets initial tick count for first MIDIHDR */
3047         if (!lpMidiStrm->dwStartTicks)
3048             lpMidiStrm->dwStartTicks = GetTickCount();
3049
3050         /* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
3051          * by native mcimidi, it doesn't look like a correct one".
3052          * this trick allows to throw it away... but I don't like it.
3053          * It looks like part of the file I'm trying to play and definitively looks
3054          * like raw midi content
3055          * I'd really like to understand why native mcimidi sends it. Perhaps a bad
3056          * synchronization issue where native mcimidi is still processing raw MIDI
3057          * content before generating MIDIEVENTs ?
3058          *
3059          * 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
3060          * 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
3061          * 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
3062          * 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
3063          * 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
3064          * 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
3065          * 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
3066          * 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
3067          * 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
3068          * 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
3069          * 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
3070          * 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
3071          * 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
3072          * 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
3073          * 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
3074          * 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
3075          * 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
3076          */
3077         lpMidiHdr = (LPMIDIHDR)msg->lParam;
3078         lpData = lpMidiHdr->lpData;
3079         TRACE("Adding %s lpMidiHdr=%p [lpData=0x%08lx dwBufferLength=%lu/%lu dwFlags=0x%08lx size=%u]\n",
3080               (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
3081               (DWORD)lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded,
3082               lpMidiHdr->dwFlags, msg->wParam);
3083 #if 0
3084         /* dumps content of lpMidiHdr->lpData
3085          * FIXME: there should be a debug routine somewhere that already does this
3086          * I hate spreading this type of shit all around the code
3087          */
3088         for (dwToGo = 0; dwToGo < lpMidiHdr->dwBufferLength; dwToGo += 16) {
3089             DWORD       i;
3090             BYTE        ch;
3091
3092             for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++)
3093                 printf("%02x ", lpData[dwToGo + i]);
3094             for (; i < 16; i++)
3095                 printf("   ");
3096             for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++) {
3097                 ch = lpData[dwToGo + i];
3098                 printf("%c", (ch >= 0x20 && ch <= 0x7F) ? ch : '.');
3099             }
3100             printf("\n");
3101         }
3102 #endif
3103         if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
3104             ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
3105             ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
3106             FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n",
3107                   (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
3108                   ((LPMIDIEVENT)lpData)->dwStreamID);
3109             lpMidiHdr->dwFlags |= MHDR_DONE;
3110             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
3111
3112             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, lpMidiStrm->hDevice,
3113                            MM_MOM_DONE, lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
3114             break;
3115         }
3116
3117         for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = (LPMIDIHDR*)&((*lpmh)->lpNext));
3118         *lpmh = lpMidiHdr;
3119         lpMidiHdr = (LPMIDIHDR)msg->lParam;
3120         lpMidiHdr->lpNext = 0;
3121         lpMidiHdr->dwFlags |= MHDR_INQUEUE;
3122         lpMidiHdr->dwFlags &= MHDR_DONE;
3123         lpMidiHdr->dwOffset = 0;
3124
3125         break;
3126     default:
3127         FIXME("Unknown message %d\n", msg->message);
3128         break;
3129     }
3130     return TRUE;
3131 }
3132
3133 /**************************************************************************
3134  *                              MMSYSTEM_MidiStream_Player      [internal]
3135  */
3136 static  DWORD   CALLBACK        MMSYSTEM_MidiStream_Player(LPVOID pmt)
3137 {
3138     WINE_MIDIStream*    lpMidiStrm = pmt;
3139     WINE_MIDI*          lpwm;
3140     MSG                 msg;
3141     DWORD               dwToGo;
3142     DWORD               dwCurrTC;
3143     LPMIDIHDR           lpMidiHdr;
3144     LPMIDIEVENT         me;
3145     LPBYTE              lpData = 0;
3146
3147     TRACE("(%p)!\n", lpMidiStrm);
3148
3149     if (!lpMidiStrm ||
3150         (lpwm = (LPWINE_MIDI)MMDRV_Get(lpMidiStrm->hDevice, MMDRV_MIDIOUT, FALSE)) == NULL)
3151         goto the_end;
3152
3153     /* force thread's queue creation */
3154     /* Used to be InitThreadInput16(0, 5); */
3155     /* but following works also with hack in midiStreamOpen */
3156     PeekMessageA(&msg, 0, 0, 0, 0);
3157
3158     /* FIXME: this next line must be called before midiStreamOut or midiStreamRestart are called */
3159     SetEvent(lpMidiStrm->hEvent);
3160     TRACE("Ready to go 1\n");
3161     /* thread is started in paused mode */
3162     SuspendThread(lpMidiStrm->hThread);
3163     TRACE("Ready to go 2\n");
3164
3165     lpMidiStrm->dwStartTicks = 0;
3166     lpMidiStrm->dwPulses = 0;
3167
3168     lpMidiStrm->lpMidiHdr = 0;
3169
3170     for (;;) {
3171         lpMidiHdr = lpMidiStrm->lpMidiHdr;
3172         if (!lpMidiHdr) {
3173             /* for first message, block until one arrives, then process all that are available */
3174             GetMessageA(&msg, 0, 0, 0);
3175             do {
3176                 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm, lpwm, &msg))
3177                     goto the_end;
3178             } while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE));
3179             lpData = 0;
3180             continue;
3181         }
3182
3183         if (!lpData)
3184             lpData = lpMidiHdr->lpData;
3185
3186         me = (LPMIDIEVENT)(lpData + lpMidiHdr->dwOffset);
3187
3188         /* do we have to wait ? */
3189         if (me->dwDeltaTime) {
3190             lpMidiStrm->dwPositionMS += MMSYSTEM_MidiStream_Convert(lpMidiStrm, me->dwDeltaTime);
3191             lpMidiStrm->dwPulses += me->dwDeltaTime;
3192
3193             dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS;
3194
3195             TRACE("%ld/%ld/%ld\n", dwToGo, GetTickCount(), me->dwDeltaTime);
3196             while ((dwCurrTC = GetTickCount()) < dwToGo) {
3197                 if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) {
3198                     /* got a message, handle it */
3199                     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
3200                         if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm, lpwm, &msg))
3201                             goto the_end;
3202                     }
3203                     lpData = 0;
3204                 } else {
3205                     /* timeout, so me->dwDeltaTime is elapsed, can break the while loop */
3206                     break;
3207                 }
3208             }
3209         }
3210         switch (MEVT_EVENTTYPE(me->dwEvent & ~MEVT_F_CALLBACK)) {
3211         case MEVT_COMMENT:
3212             FIXME("NIY: MEVT_COMMENT\n");
3213             /* do nothing, skip bytes */
3214             break;
3215         case MEVT_LONGMSG:
3216             FIXME("NIY: MEVT_LONGMSG, aka sending Sysex event\n");
3217             break;
3218         case MEVT_NOP:
3219             break;
3220         case MEVT_SHORTMSG:
3221             midiOutShortMsg(lpMidiStrm->hDevice, MEVT_EVENTPARM(me->dwEvent));
3222             break;
3223         case MEVT_TEMPO:
3224             lpMidiStrm->dwTempo = MEVT_EVENTPARM(me->dwEvent);
3225             break;
3226         case MEVT_VERSION:
3227             break;
3228         default:
3229             FIXME("Unknown MEVT (0x%02x)\n", MEVT_EVENTTYPE(me->dwEvent & ~MEVT_F_CALLBACK));
3230             break;
3231         }
3232         if (me->dwEvent & MEVT_F_CALLBACK) {
3233             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, lpMidiStrm->hDevice,
3234                            MM_MOM_POSITIONCB, lpwm->mod.dwInstance, (LPARAM)lpMidiHdr, 0L);
3235         }
3236         lpMidiHdr->dwOffset += sizeof(MIDIEVENT) - sizeof(me->dwParms);
3237         if (me->dwEvent & MEVT_F_LONG)
3238             lpMidiHdr->dwOffset += (MEVT_EVENTPARM(me->dwEvent) + 3) & ~3;
3239         if (lpMidiHdr->dwOffset >= lpMidiHdr->dwBufferLength) {
3240             /* done with this header */
3241             lpMidiHdr->dwFlags |= MHDR_DONE;
3242             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
3243
3244             lpMidiStrm->lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext;
3245             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, lpMidiStrm->hDevice,
3246                            MM_MOM_DONE, lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L);
3247             lpData = 0;
3248         }
3249     }
3250 the_end:
3251     TRACE("End of thread\n");
3252     ExitThread(0);
3253     return 0;   /* for removing the warning, never executed */
3254 }
3255
3256 /**************************************************************************
3257  *                              MMSYSTEM_MidiStream_PostMessage [internal]
3258  */
3259 static  BOOL MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream* lpMidiStrm, WORD msg, DWORD pmt1, DWORD pmt2)
3260 {
3261     if (PostThreadMessageA(lpMidiStrm->dwThreadID, msg, pmt1, pmt2)) {
3262         DWORD   count;
3263
3264         ReleaseThunkLock(&count);
3265         WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
3266         RestoreThunkLock(count);
3267     } else {
3268         WARN("bad PostThreadMessageA\n");
3269         return FALSE;
3270     }
3271     return TRUE;
3272 }
3273
3274 /**************************************************************************
3275  *                              midiStreamClose                 [WINMM.@]
3276  */
3277 MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm)
3278 {
3279     WINE_MIDIStream*    lpMidiStrm;
3280
3281     TRACE("(%08x)!\n", hMidiStrm);
3282
3283     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
3284         return MMSYSERR_INVALHANDLE;
3285
3286     midiStreamStop(hMidiStrm);
3287     MMSYSTEM_MidiStream_PostMessage(lpMidiStrm, WM_QUIT, 0, 0);
3288     HeapFree(GetProcessHeap(), 0, lpMidiStrm);
3289     CloseHandle(lpMidiStrm->hEvent);
3290
3291     return midiOutClose(hMidiStrm);
3292 }
3293
3294 /**************************************************************************
3295  *                              MMSYSTEM_MidiStream_Open        [internal]
3296  */
3297 static  MMRESULT WINAPI MMSYSTEM_MidiStream_Open(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
3298                                                  DWORD cMidi, DWORD dwCallback,
3299                                                  DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32)
3300 {
3301     WINE_MIDIStream*    lpMidiStrm;
3302     MMRESULT            ret;
3303     MIDIOPENSTRMID      mosm;
3304     LPWINE_MIDI         lpwm;
3305     HMIDIOUT            hMidiOut;
3306
3307     TRACE("(%p, %p, %ld, 0x%08lx, 0x%08lx, 0x%08lx)!\n",
3308           lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
3309
3310     if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
3311         return MMSYSERR_INVALPARAM;
3312
3313     lpMidiStrm = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream));
3314     if (!lpMidiStrm)
3315         return MMSYSERR_NOMEM;
3316
3317     lpMidiStrm->dwTempo = 500000;
3318     lpMidiStrm->dwTimeDiv = 480;        /* 480 is 120 quater notes per minute *//* FIXME ??*/
3319     lpMidiStrm->dwPositionMS = 0;
3320
3321     mosm.dwStreamID = (DWORD)lpMidiStrm;
3322     /* FIXME: the correct value is not allocated yet for MAPPER */
3323     mosm.wDeviceID  = *lpuDeviceID;
3324     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm, bFrom32);
3325     lpMidiStrm->hDevice = hMidiOut;
3326     if (lphMidiStrm)
3327         *lphMidiStrm = hMidiOut;
3328
3329     /* FIXME: is lpuDevice initialized upon entering midiStreamOpen ? */
3330     FIXME("*lpuDeviceID=%x\n", *lpuDeviceID);
3331     lpwm->mld.uDeviceID = *lpuDeviceID = 0;
3332
3333     ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD)&lpwm->mod, fdwOpen);
3334     lpMidiStrm->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
3335     lpMidiStrm->wFlags = HIWORD(fdwOpen);
3336
3337     lpMidiStrm->hThread = CreateThread(NULL, 0, MMSYSTEM_MidiStream_Player,
3338                                        lpMidiStrm, 0, &(lpMidiStrm->dwThreadID));
3339
3340     if (!lpMidiStrm->hThread) {
3341         midiStreamClose((HMIDISTRM)hMidiOut);
3342         return MMSYSERR_NOMEM;
3343     }
3344
3345     /* wait for thread to have started, and for its queue to be created */
3346     {
3347         DWORD   count;
3348
3349         /* (Release|Restore)ThunkLock() is needed when this method is called from 16 bit code,
3350          * (meaning the Win16Lock is set), so that it's released and the 32 bit thread running
3351          * MMSYSTEM_MidiStreamPlayer can acquire Win16Lock to create its queue.
3352          */
3353         ReleaseThunkLock(&count);
3354         WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
3355         RestoreThunkLock(count);
3356     }
3357
3358     TRACE("=> (%u/%d) hMidi=0x%04x ret=%d lpMidiStrm=%p\n",
3359           *lpuDeviceID, lpwm->mld.uDeviceID, *lphMidiStrm, ret, lpMidiStrm);
3360     return ret;
3361 }
3362
3363 /**************************************************************************
3364  *                              midiStreamOpen                  [WINMM.@]
3365  */
3366 MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
3367                                DWORD cMidi, DWORD dwCallback,
3368                                DWORD dwInstance, DWORD fdwOpen)
3369 {
3370     return MMSYSTEM_MidiStream_Open(lphMidiStrm, lpuDeviceID, cMidi, dwCallback,
3371                                     dwInstance, fdwOpen, TRUE);
3372 }
3373
3374 /**************************************************************************
3375  *                              midiStreamOut                   [WINMM.@]
3376  */
3377 MMRESULT WINAPI midiStreamOut(HMIDISTRM hMidiStrm, LPMIDIHDR lpMidiHdr,
3378                               UINT cbMidiHdr)
3379 {
3380     WINE_MIDIStream*    lpMidiStrm;
3381     DWORD               ret = MMSYSERR_NOERROR;
3382
3383     TRACE("(%08x, %p, %u)!\n", hMidiStrm, lpMidiHdr, cbMidiHdr);
3384
3385     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
3386         ret = MMSYSERR_INVALHANDLE;
3387     } else {
3388         if (!PostThreadMessageA(lpMidiStrm->dwThreadID,
3389                                         WINE_MSM_HEADER, cbMidiHdr,
3390                                         (DWORD)lpMidiHdr)) {
3391             WARN("bad PostThreadMessageA\n");
3392             ret = MMSYSERR_ERROR;
3393         }
3394     }
3395     return ret;
3396 }
3397
3398 /**************************************************************************
3399  *                              midiStreamPause                 [WINMM.@]
3400  */
3401 MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm)
3402 {
3403     WINE_MIDIStream*    lpMidiStrm;
3404     DWORD               ret = MMSYSERR_NOERROR;
3405
3406     TRACE("(%08x)!\n", hMidiStrm);
3407
3408     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
3409         ret = MMSYSERR_INVALHANDLE;
3410     } else {
3411         if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) {
3412             WARN("bad Suspend (%ld)\n", GetLastError());
3413             ret = MMSYSERR_ERROR;
3414         }
3415     }
3416     return ret;
3417 }
3418
3419 /**************************************************************************
3420  *                              midiStreamPosition              [WINMM.@]
3421  */
3422 MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbmmt)
3423 {
3424     WINE_MIDIStream*    lpMidiStrm;
3425     DWORD               ret = MMSYSERR_NOERROR;
3426
3427     TRACE("(%08x, %p, %u)!\n", hMidiStrm, lpMMT, cbmmt);
3428
3429     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
3430         ret = MMSYSERR_INVALHANDLE;
3431     } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME)) {
3432         ret = MMSYSERR_INVALPARAM;
3433     } else {
3434         switch (lpMMT->wType) {
3435         case TIME_MS:
3436             lpMMT->u.ms = lpMidiStrm->dwPositionMS;
3437             TRACE("=> %ld ms\n", lpMMT->u.ms);
3438             break;
3439         case TIME_TICKS:
3440             lpMMT->u.ticks = lpMidiStrm->dwPulses;
3441             TRACE("=> %ld ticks\n", lpMMT->u.ticks);
3442             break;
3443         default:
3444             WARN("Unsupported time type %d\n", lpMMT->wType);
3445             lpMMT->wType = TIME_MS;
3446             ret = MMSYSERR_INVALPARAM;
3447             break;
3448         }
3449     }
3450     return ret;
3451 }
3452
3453 /**************************************************************************
3454  *                              midiStreamProperty              [WINMM.@]
3455  */
3456 MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
3457 {
3458     WINE_MIDIStream*    lpMidiStrm;
3459     MMRESULT            ret = MMSYSERR_NOERROR;
3460
3461     TRACE("(%08x, %p, %lx)\n", hMidiStrm, lpPropData, dwProperty);
3462
3463     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
3464         ret = MMSYSERR_INVALHANDLE;
3465     } else if ((dwProperty & (MIDIPROP_GET|MIDIPROP_SET)) == 0) {
3466         ret = MMSYSERR_INVALPARAM;
3467     } else if (dwProperty & MIDIPROP_TEMPO) {
3468         MIDIPROPTEMPO*  mpt = (MIDIPROPTEMPO*)lpPropData;
3469
3470         if (sizeof(MIDIPROPTEMPO) != mpt->cbStruct) {
3471             ret = MMSYSERR_INVALPARAM;
3472         } else if (dwProperty & MIDIPROP_SET) {
3473             lpMidiStrm->dwTempo = mpt->dwTempo;
3474             TRACE("Setting tempo to %ld\n", mpt->dwTempo);
3475         } else if (dwProperty & MIDIPROP_GET) {
3476             mpt->dwTempo = lpMidiStrm->dwTempo;
3477             TRACE("Getting tempo <= %ld\n", mpt->dwTempo);
3478         }
3479     } else if (dwProperty & MIDIPROP_TIMEDIV) {
3480         MIDIPROPTIMEDIV*        mptd = (MIDIPROPTIMEDIV*)lpPropData;
3481
3482         if (sizeof(MIDIPROPTIMEDIV) != mptd->cbStruct) {
3483             ret = MMSYSERR_INVALPARAM;
3484         } else if (dwProperty & MIDIPROP_SET) {
3485             lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv;
3486             TRACE("Setting time div to %ld\n", mptd->dwTimeDiv);
3487         } else if (dwProperty & MIDIPROP_GET) {
3488             mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv;
3489             TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv);
3490         }
3491     } else {
3492         ret = MMSYSERR_INVALPARAM;
3493     }
3494
3495     return ret;
3496 }
3497
3498 /**************************************************************************
3499  *                              midiStreamRestart               [WINMM.@]
3500  */
3501 MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm)
3502 {
3503     WINE_MIDIStream*    lpMidiStrm;
3504     MMRESULT            ret = MMSYSERR_NOERROR;
3505
3506     TRACE("(%08x)!\n", hMidiStrm);
3507
3508     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
3509         ret = MMSYSERR_INVALHANDLE;
3510     } else {
3511         DWORD   ret;
3512
3513         /* since we increase the thread suspend count on each midiStreamPause
3514          * there may be a need for several midiStreamResume
3515          */
3516         do {
3517             ret = ResumeThread(lpMidiStrm->hThread);
3518         } while (ret != 0xFFFFFFFF && ret != 0);
3519         if (ret == 0xFFFFFFFF) {
3520             WARN("bad Resume (%ld)\n", GetLastError());
3521             ret = MMSYSERR_ERROR;
3522         } else {
3523             lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS;
3524         }
3525     }
3526     return ret;
3527 }
3528
3529 /**************************************************************************
3530  *                              midiStreamStop                  [WINMM.@]
3531  */
3532 MMRESULT WINAPI midiStreamStop(HMIDISTRM hMidiStrm)
3533 {
3534     WINE_MIDIStream*    lpMidiStrm;
3535     MMRESULT            ret = MMSYSERR_NOERROR;
3536
3537     TRACE("(%08x)!\n", hMidiStrm);
3538
3539     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
3540         ret = MMSYSERR_INVALHANDLE;
3541     } else {
3542         /* in case stream has been paused... FIXME is the current state correct ? */
3543         midiStreamRestart(hMidiStrm);
3544         MMSYSTEM_MidiStream_PostMessage(lpMidiStrm, WINE_MSM_STOP, 0, 0);
3545     }
3546     return ret;
3547 }
3548
3549 /**************************************************************************
3550  *                              midiStreamClose                 [MMSYSTEM.252]
3551  */
3552 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
3553 {
3554     return midiStreamClose(hMidiStrm);
3555 }
3556
3557 /**************************************************************************
3558  *                              midiStreamOpen                  [MMSYSTEM.251]
3559  */
3560 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
3561                                    DWORD cMidi, DWORD dwCallback,
3562                                    DWORD dwInstance, DWORD fdwOpen)
3563 {
3564     HMIDISTRM   hMidiStrm32;
3565     MMRESULT    ret;
3566     UINT        devid32;
3567
3568     if (!phMidiStrm || !devid)
3569         return MMSYSERR_INVALPARAM;
3570     devid32 = *devid;
3571     ret = MMSYSTEM_MidiStream_Open(&hMidiStrm32, &devid32, cMidi, dwCallback,
3572                                    dwInstance, fdwOpen, FALSE);
3573     *phMidiStrm = hMidiStrm32;
3574     *devid = devid32;
3575     return ret;
3576 }
3577
3578 /**************************************************************************
3579  *                              midiStreamOut                   [MMSYSTEM.254]
3580  */
3581 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hMidiStrm, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr)
3582 {
3583     return midiStreamOut(hMidiStrm, (LPMIDIHDR)lpMidiHdr, cbMidiHdr);
3584 }
3585
3586 /**************************************************************************
3587  *                              midiStreamPause                 [MMSYSTEM.255]
3588  */
3589 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hMidiStrm)
3590 {
3591     return midiStreamPause(hMidiStrm);
3592 }
3593
3594 /**************************************************************************
3595  *                              midiStreamPosition              [MMSYSTEM.253]
3596  */
3597 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hMidiStrm, LPMMTIME16 lpmmt16, UINT16 cbmmt)
3598 {
3599     MMTIME      mmt32;
3600     MMRESULT    ret;
3601
3602     if (!lpmmt16)
3603         return MMSYSERR_INVALPARAM;
3604     MMSYSTEM_MMTIME16to32(&mmt32, lpmmt16);
3605     ret = midiStreamPosition(hMidiStrm, &mmt32, sizeof(MMTIME));
3606     MMSYSTEM_MMTIME32to16(lpmmt16, &mmt32);
3607     return ret;
3608 }
3609
3610 /**************************************************************************
3611  *                              midiStreamProperty              [MMSYSTEM.250]
3612  */
3613 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
3614 {
3615     return midiStreamProperty(hMidiStrm, lpPropData, dwProperty);
3616 }
3617
3618 /**************************************************************************
3619  *                              midiStreamRestart               [MMSYSTEM.256]
3620  */
3621 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hMidiStrm)
3622 {
3623     return midiStreamRestart(hMidiStrm);
3624 }
3625
3626 /**************************************************************************
3627  *                              midiStreamStop                  [MMSYSTEM.257]
3628  */
3629 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hMidiStrm)
3630 {
3631     return midiStreamStop(hMidiStrm);
3632 }
3633
3634 static  UINT WINAPI MMSYSTEM_waveOpen(HANDLE* lphndl, UINT uDeviceID, UINT uType,
3635                                       const LPWAVEFORMATEX lpFormat,
3636                                       DWORD dwCallback, DWORD dwInstance,
3637                                       DWORD dwFlags, BOOL bFrom32)
3638 {
3639     HANDLE              handle;
3640     LPWINE_MLD          wmld;
3641     DWORD               dwRet = MMSYSERR_NOERROR;
3642     WAVEOPENDESC        wod;
3643
3644     TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08lX, %d);\n",
3645           lphndl, (int)uDeviceID, (uType==MMDRV_WAVEOUT)?"Out":"In", lpFormat, dwCallback,
3646           dwInstance, dwFlags, bFrom32?32:16);
3647
3648     if (dwFlags & WAVE_FORMAT_QUERY)    TRACE("WAVE_FORMAT_QUERY requested !\n");
3649
3650     if (lpFormat == NULL) return WAVERR_BADFORMAT;
3651     if ((dwFlags & WAVE_MAPPED) && (uDeviceID == (UINT)-1))
3652         return MMSYSERR_INVALPARAM;
3653
3654     TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u\n",
3655           lpFormat->wFormatTag, lpFormat->nChannels, lpFormat->nSamplesPerSec,
3656           lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample, lpFormat->cbSize);
3657
3658     if ((wmld = MMDRV_Alloc(sizeof(WINE_WAVE), uType, &handle,
3659                             &dwFlags, &dwCallback, &dwInstance, bFrom32)) == NULL)
3660         return MMSYSERR_NOMEM;
3661
3662     wod.hWave = handle;
3663     wod.lpFormat = lpFormat;  /* should the struct be copied iso pointer? */
3664     wod.dwCallback = dwCallback;
3665     wod.dwInstance = dwInstance;
3666     wod.dnDevNode = 0L;
3667
3668     if (dwFlags & WAVE_MAPPED) {
3669         wod.uMappedDeviceID = uDeviceID;
3670         uDeviceID = WAVE_MAPPER;
3671     } else {
3672         wod.uMappedDeviceID = -1;
3673     }
3674     wmld->uDeviceID = uDeviceID;
3675
3676     dwRet = MMDRV_Open(wmld, (uType == MMDRV_WAVEOUT) ? WODM_OPEN : WIDM_OPEN, (DWORD)&wod, dwFlags);
3677
3678     if ((dwFlags & WAVE_FORMAT_QUERY) || dwRet != MMSYSERR_NOERROR) {
3679         MMDRV_Free(handle, wmld);
3680         handle = 0;
3681     }
3682
3683     if (lphndl != NULL) *lphndl = handle;
3684     TRACE("=> %ld hWave=%04x\n", dwRet, handle);
3685
3686     return dwRet;
3687 }
3688
3689 /**************************************************************************
3690  *                              waveOutGetNumDevs               [WINMM.@]
3691  */
3692 UINT WINAPI waveOutGetNumDevs(void)
3693 {
3694     return MMDRV_GetNum(MMDRV_WAVEOUT);
3695 }
3696
3697 /**************************************************************************
3698  *                              waveOutGetNumDevs               [MMSYSTEM.401]
3699  */
3700 UINT16 WINAPI waveOutGetNumDevs16(void)
3701 {
3702     return MMDRV_GetNum(MMDRV_WAVEOUT);
3703 }
3704
3705 /**************************************************************************
3706  *                              waveOutGetDevCaps               [MMSYSTEM.402]
3707  */
3708 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID,
3709                                   LPWAVEOUTCAPS16 lpCaps, UINT16 uSize)
3710 {
3711     WAVEOUTCAPSA        wocA;
3712     UINT                ret;
3713
3714     TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
3715     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
3716
3717     ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA));
3718
3719     if (ret == MMSYSERR_NOERROR) {
3720         lpCaps->wMid = wocA.wMid;
3721         lpCaps->wPid = wocA.wPid;
3722         lpCaps->vDriverVersion = wocA.vDriverVersion;
3723         strcpy(lpCaps->szPname, wocA.szPname);
3724         lpCaps->dwFormats = wocA.dwFormats;
3725         lpCaps->wChannels = wocA.wChannels;
3726         lpCaps->dwSupport = wocA.dwSupport;
3727     }
3728     return ret;
3729 }
3730
3731 /**************************************************************************
3732  *                              waveOutGetDevCapsA              [WINMM.@]
3733  */
3734 UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
3735                                UINT uSize)
3736 {
3737     LPWINE_MLD          wmld;
3738
3739     TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
3740
3741     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
3742
3743     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_WAVEOUT, TRUE)) == NULL)
3744         return MMSYSERR_INVALHANDLE;
3745
3746     return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
3747
3748 }
3749
3750 /**************************************************************************
3751  *                              waveOutGetDevCapsW              [WINMM.@]
3752  */
3753 UINT WINAPI waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW lpCaps,
3754                                UINT uSize)
3755 {
3756     WAVEOUTCAPSA        wocA;
3757     UINT                ret;
3758
3759     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
3760
3761     ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA));
3762
3763     if (ret == MMSYSERR_NOERROR) {
3764         lpCaps->wMid = wocA.wMid;
3765         lpCaps->wPid = wocA.wPid;
3766         lpCaps->vDriverVersion = wocA.vDriverVersion;
3767         MultiByteToWideChar( CP_ACP, 0, wocA.szPname, -1, lpCaps->szPname,
3768                              sizeof(lpCaps->szPname)/sizeof(WCHAR) );
3769         lpCaps->dwFormats = wocA.dwFormats;
3770         lpCaps->wChannels = wocA.wChannels;
3771         lpCaps->dwSupport = wocA.dwSupport;
3772     }
3773     return ret;
3774 }
3775
3776 /**************************************************************************
3777  *                              WAVE_GetErrorText               [internal]
3778  */
3779 static  UINT16  WAVE_GetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
3780 {
3781     UINT16              ret = MMSYSERR_BADERRNUM;
3782
3783     if (lpText == NULL) {
3784         ret = MMSYSERR_INVALPARAM;
3785     } else if (uSize == 0) {
3786         ret = MMSYSERR_NOERROR;
3787     } else if (
3788                /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit
3789                 * a warning for the test was always true */
3790                (/*uError >= MMSYSERR_BASE && */uError <= MMSYSERR_LASTERROR) ||
3791                (uError >= WAVERR_BASE  && uError <= WAVERR_LASTERROR)) {
3792
3793         if (LoadStringA(MULTIMEDIA_GetIData()->hWinMM32Instance,
3794                         uError, lpText, uSize) > 0) {
3795             ret = MMSYSERR_NOERROR;
3796         }
3797     }
3798     return ret;
3799 }
3800
3801 /**************************************************************************
3802  *                              waveOutGetErrorText     [MMSYSTEM.403]
3803  */
3804 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3805 {
3806     return WAVE_GetErrorText(uError, lpText, uSize);
3807 }
3808
3809 /**************************************************************************
3810  *                              waveOutGetErrorTextA    [WINMM.@]
3811  */
3812 UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
3813 {
3814     return WAVE_GetErrorText(uError, lpText, uSize);
3815 }
3816
3817 /**************************************************************************
3818  *                              waveOutGetErrorTextW    [WINMM.@]
3819  */
3820 UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
3821 {
3822     LPSTR       xstr = HeapAlloc(GetProcessHeap(), 0, uSize);
3823     UINT        ret = WAVE_GetErrorText(uError, xstr, uSize);
3824
3825     MultiByteToWideChar( CP_ACP, 0, xstr, -1, lpText, uSize );
3826     HeapFree(GetProcessHeap(), 0, xstr);
3827     return ret;
3828 }
3829
3830 /**************************************************************************
3831  *                      waveOutOpen                     [WINMM.@]
3832  * All the args/structs have the same layout as the win16 equivalents
3833  */
3834 UINT WINAPI waveOutOpen(HWAVEOUT* lphWaveOut, UINT uDeviceID,
3835                         const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3836                         DWORD dwInstance, DWORD dwFlags)
3837 {
3838     return MMSYSTEM_waveOpen(lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat,
3839                              dwCallback, dwInstance, dwFlags, TRUE);
3840 }
3841
3842 /**************************************************************************
3843  *                      waveOutOpen                     [MMSYSTEM.404]
3844  */
3845 UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
3846                             const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3847                             DWORD dwInstance, DWORD dwFlags)
3848 {
3849     HWAVEOUT            hWaveOut;
3850     UINT                ret;
3851
3852     /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
3853      * call the 32 bit version
3854      * however, we need to promote correctly the wave mapper id
3855      * (0xFFFFFFFF and not 0x0000FFFF)
3856      */
3857     ret = MMSYSTEM_waveOpen(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
3858                             MMDRV_WAVEOUT, lpFormat, dwCallback, dwInstance, dwFlags, FALSE);
3859
3860     if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
3861     return ret;
3862 }
3863
3864 /**************************************************************************
3865  *                              waveOutClose            [WINMM.@]
3866  */
3867 UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
3868 {
3869     LPWINE_MLD          wmld;
3870     DWORD               dwRet;
3871
3872     TRACE("(%04X)\n", hWaveOut);
3873
3874     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
3875         return MMSYSERR_INVALHANDLE;
3876
3877     dwRet = MMDRV_Close(wmld, WODM_CLOSE);
3878     MMDRV_Free(hWaveOut, wmld);
3879
3880     return dwRet;
3881 }
3882
3883 /**************************************************************************
3884  *                              waveOutClose            [MMSYSTEM.405]
3885  */
3886 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
3887 {
3888     DWORD       level;
3889     UINT16      ret;
3890
3891     ReleaseThunkLock(&level);
3892     ret = waveOutClose(hWaveOut);
3893     RestoreThunkLock(level);
3894     return ret;
3895 }
3896
3897 /**************************************************************************
3898  *                              waveOutPrepareHeader    [WINMM.@]
3899  */
3900 UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
3901                                  WAVEHDR* lpWaveOutHdr, UINT uSize)
3902 {
3903     LPWINE_MLD          wmld;
3904
3905     TRACE("(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3906
3907     if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
3908
3909     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
3910         return MMSYSERR_INVALHANDLE;
3911
3912     return MMDRV_Message(wmld, WODM_PREPARE, (DWORD)lpWaveOutHdr, uSize, TRUE);
3913 }
3914
3915 /**************************************************************************
3916  *                              waveOutPrepareHeader    [MMSYSTEM.406]
3917  */
3918 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,      /* [in] */
3919                                      SEGPTR lpsegWaveOutHdr,   /* [???] */
3920                                      UINT16 uSize)             /* [in] */
3921 {
3922     LPWINE_MLD          wmld;
3923     LPWAVEHDR           lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
3924
3925     TRACE("(%04X, %08lx, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
3926
3927     if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
3928
3929     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
3930         return MMSYSERR_INVALHANDLE;
3931
3932     return MMDRV_Message(wmld, WODM_PREPARE, (DWORD)lpsegWaveOutHdr, uSize, FALSE);
3933 }
3934
3935 /**************************************************************************
3936  *                              waveOutUnprepareHeader  [WINMM.@]
3937  */
3938 UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
3939                                    LPWAVEHDR lpWaveOutHdr, UINT uSize)
3940 {
3941     LPWINE_MLD          wmld;
3942
3943     TRACE("(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3944
3945     if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
3946         return MMSYSERR_NOERROR;
3947     }
3948
3949     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
3950         return MMSYSERR_INVALHANDLE;
3951
3952     return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD)lpWaveOutHdr, uSize, TRUE);
3953 }
3954
3955 /**************************************************************************
3956  *                              waveOutUnprepareHeader  [MMSYSTEM.407]
3957  */
3958 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,       /* [in] */
3959                                        SEGPTR lpsegWaveOutHdr,    /* [???] */
3960                                        UINT16 uSize)              /* [in] */
3961 {
3962     LPWINE_MLD          wmld;
3963     LPWAVEHDR           lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
3964
3965     TRACE("(%04X, %08lx, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
3966
3967     if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
3968         return MMSYSERR_NOERROR;
3969     }
3970
3971     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
3972         return MMSYSERR_INVALHANDLE;
3973
3974     return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD)lpsegWaveOutHdr, uSize, FALSE);
3975 }
3976
3977 /**************************************************************************
3978  *                              waveOutWrite            [WINMM.@]
3979  */
3980 UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr,
3981                          UINT uSize)
3982 {
3983     LPWINE_MLD          wmld;
3984
3985     TRACE("(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3986
3987     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
3988         return MMSYSERR_INVALHANDLE;
3989
3990     return MMDRV_Message(wmld, WODM_WRITE, (DWORD)lpWaveOutHdr, uSize, TRUE);
3991 }
3992
3993 /**************************************************************************
3994  *                              waveOutWrite            [MMSYSTEM.408]
3995  */
3996 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut,       /* [in] */
3997                              LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
3998                              UINT16 uSize)              /* [in] */
3999 {
4000     LPWINE_MLD          wmld;
4001
4002     TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
4003
4004     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4005         return MMSYSERR_INVALHANDLE;
4006
4007     return MMDRV_Message(wmld, WODM_WRITE, (DWORD)lpsegWaveOutHdr, uSize, FALSE);
4008 }
4009
4010 /**************************************************************************
4011  *                              waveOutBreakLoop        [WINMM.@]
4012  */
4013 UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
4014 {
4015     LPWINE_MLD          wmld;
4016
4017     TRACE("(%04X);\n", hWaveOut);
4018
4019     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4020         return MMSYSERR_INVALHANDLE;
4021     return MMDRV_Message(wmld, WODM_BREAKLOOP, 0L, 0L, TRUE);
4022 }
4023
4024 /**************************************************************************
4025  *                              waveOutBreakLoop        [MMSYSTEM.419]
4026  */
4027 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut16)
4028 {
4029     DWORD       level;
4030     UINT16      ret;
4031
4032     ReleaseThunkLock(&level);
4033     ret = waveOutBreakLoop(hWaveOut16);
4034     RestoreThunkLock(level);
4035     return ret;
4036 }
4037
4038 /**************************************************************************
4039  *                              waveOutPause            [WINMM.@]
4040  */
4041 UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
4042 {
4043     LPWINE_MLD          wmld;
4044
4045     TRACE("(%04X);\n", hWaveOut);
4046
4047     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4048         return MMSYSERR_INVALHANDLE;
4049     return MMDRV_Message(wmld, WODM_PAUSE, 0L, 0L, TRUE);
4050 }
4051
4052 /**************************************************************************
4053  *                              waveOutPause            [MMSYSTEM.409]
4054  */
4055 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut16)
4056 {
4057     DWORD       level;
4058     UINT16      ret;
4059
4060     ReleaseThunkLock(&level);
4061     ret = waveOutPause(hWaveOut16);
4062     RestoreThunkLock(level);
4063     return ret;
4064 }
4065
4066 /**************************************************************************
4067  *                              waveOutReset            [WINMM.@]
4068  */
4069 UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
4070 {
4071     LPWINE_MLD          wmld;
4072
4073     TRACE("(%04X);\n", hWaveOut);
4074
4075     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4076         return MMSYSERR_INVALHANDLE;
4077     return MMDRV_Message(wmld, WODM_RESET, 0L, 0L, TRUE);
4078 }
4079
4080 /**************************************************************************
4081  *                              waveOutReset            [MMSYSTEM.411]
4082  */
4083 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut16)
4084 {
4085     DWORD       level;
4086     UINT16      ret;
4087
4088     ReleaseThunkLock(&level);
4089     ret = waveOutReset(hWaveOut16);
4090     RestoreThunkLock(level);
4091     return ret;
4092 }
4093
4094 /**************************************************************************
4095  *                              waveOutRestart          [WINMM.@]
4096  */
4097 UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
4098 {
4099     LPWINE_MLD          wmld;
4100
4101     TRACE("(%04X);\n", hWaveOut);
4102
4103     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4104         return MMSYSERR_INVALHANDLE;
4105     return MMDRV_Message(wmld, WODM_RESTART, 0L, 0L, TRUE);
4106 }
4107
4108 /**************************************************************************
4109  *                              waveOutRestart  [MMSYSTEM.410]
4110  */
4111 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut16)
4112 {
4113     DWORD       level;
4114     UINT16      ret;
4115
4116     ReleaseThunkLock(&level);
4117     ret = waveOutRestart(hWaveOut16);
4118     RestoreThunkLock(level);
4119     return ret;
4120 }
4121
4122 /**************************************************************************
4123  *                              waveOutGetPosition      [WINMM.@]
4124  */
4125 UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
4126                                UINT uSize)
4127 {
4128     LPWINE_MLD          wmld;
4129
4130     TRACE("(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
4131
4132     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4133         return MMSYSERR_INVALHANDLE;
4134
4135     return MMDRV_Message(wmld, WODM_GETPOS, (DWORD)lpTime, uSize, TRUE);
4136 }
4137
4138 /**************************************************************************
4139  *                              waveOutGetPosition      [MMSYSTEM.412]
4140  */
4141 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
4142                                    UINT16 uSize)
4143 {
4144     UINT        ret;
4145     MMTIME      mmt;
4146
4147     mmt.wType = lpTime->wType;
4148     ret = waveOutGetPosition(hWaveOut, &mmt, sizeof(mmt));
4149     MMSYSTEM_MMTIME32to16(lpTime, &mmt);
4150     return ret;
4151 }
4152
4153 /**************************************************************************
4154  *                              waveOutGetPitch         [WINMM.@]
4155  */
4156 UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
4157 {
4158     LPWINE_MLD          wmld;
4159
4160     TRACE("(%04X, %08lx);\n", hWaveOut, (DWORD)lpdw);
4161
4162     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4163         return MMSYSERR_INVALHANDLE;
4164     return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD)lpdw, 0L, TRUE);
4165 }
4166
4167 /**************************************************************************
4168  *                              waveOutGetPitch         [MMSYSTEM.413]
4169  */
4170 UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
4171 {
4172     return waveOutGetPitch(hWaveOut16, lpdw);
4173 }
4174
4175 /**************************************************************************
4176  *                              waveOutSetPitch         [WINMM.@]
4177  */
4178 UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
4179 {
4180     LPWINE_MLD          wmld;
4181
4182     TRACE("(%04X, %08lx);\n", hWaveOut, (DWORD)dw);
4183
4184     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4185         return MMSYSERR_INVALHANDLE;
4186     return MMDRV_Message(wmld, WODM_SETPITCH, dw, 0L, TRUE);
4187 }
4188
4189 /**************************************************************************
4190  *                              waveOutSetPitch         [MMSYSTEM.414]
4191  */
4192 UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16 hWaveOut16, DWORD dw)
4193 {
4194     return waveOutSetPitch(hWaveOut16, dw);
4195 }
4196
4197 /**************************************************************************
4198  *                              waveOutGetPlaybackRate  [WINMM.@]
4199  */
4200 UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
4201 {
4202     LPWINE_MLD          wmld;
4203
4204     TRACE("(%04X, %08lx);\n", hWaveOut, (DWORD)lpdw);
4205
4206     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4207         return MMSYSERR_INVALHANDLE;
4208     return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD)lpdw, 0L, TRUE);
4209 }
4210
4211 /**************************************************************************
4212  *                              waveOutGetPlaybackRate  [MMSYSTEM.417]
4213  */
4214 UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
4215 {
4216     return waveOutGetPlaybackRate(hWaveOut16, lpdw);
4217 }
4218
4219 /**************************************************************************
4220  *                              waveOutSetPlaybackRate  [WINMM.@]
4221  */
4222 UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
4223 {
4224     LPWINE_MLD          wmld;
4225
4226     TRACE("(%04X, %08lx);\n", hWaveOut, (DWORD)dw);
4227
4228     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4229         return MMSYSERR_INVALHANDLE;
4230     return MMDRV_Message(wmld, WODM_SETPLAYBACKRATE, dw, 0L, TRUE);
4231 }
4232
4233 /**************************************************************************
4234  *                              waveOutSetPlaybackRate  [MMSYSTEM.418]
4235  */
4236 UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16 hWaveOut16, DWORD dw)
4237 {
4238     return waveOutSetPlaybackRate(hWaveOut16, dw);
4239 }
4240
4241 /**************************************************************************
4242  *                              waveOutGetVolume        [WINMM.@]
4243  */
4244 UINT WINAPI waveOutGetVolume(UINT devid, LPDWORD lpdw)
4245 {
4246     LPWINE_MLD          wmld;
4247
4248     TRACE("(%04X, %08lx);\n", devid, (DWORD)lpdw);
4249
4250      if ((wmld = MMDRV_Get(devid, MMDRV_WAVEOUT, TRUE)) == NULL)
4251         return MMSYSERR_INVALHANDLE;
4252
4253     return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD)lpdw, 0L, TRUE);
4254 }
4255
4256 /**************************************************************************
4257  *                              waveOutGetVolume        [MMSYSTEM.415]
4258  */
4259 UINT16 WINAPI waveOutGetVolume16(UINT16 devid, LPDWORD lpdw)
4260 {
4261     return waveOutGetVolume(devid, lpdw);
4262 }
4263
4264 /**************************************************************************
4265  *                              waveOutSetVolume        [WINMM.@]
4266  */
4267 UINT WINAPI waveOutSetVolume(UINT devid, DWORD dw)
4268 {
4269     LPWINE_MLD          wmld;
4270
4271     TRACE("(%04X, %08lx);\n", devid, dw);
4272
4273      if ((wmld = MMDRV_Get(devid, MMDRV_WAVEOUT, TRUE)) == NULL)
4274         return MMSYSERR_INVALHANDLE;
4275
4276     return MMDRV_Message(wmld, WODM_SETVOLUME, dw, 0L, TRUE);
4277 }
4278
4279 /**************************************************************************
4280  *                              waveOutSetVolume        [MMSYSTEM.416]
4281  */
4282 UINT16 WINAPI waveOutSetVolume16(UINT16 devid, DWORD dw)
4283 {
4284     return waveOutSetVolume(devid, dw);
4285 }
4286
4287 /**************************************************************************
4288  *                              waveOutGetID            [WINMM.@]
4289  */
4290 UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
4291 {
4292     LPWINE_MLD          wmld;
4293
4294     TRACE("(%04X, %p);\n", hWaveOut, lpuDeviceID);
4295
4296     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4297
4298     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4299         return MMSYSERR_INVALHANDLE;
4300
4301     *lpuDeviceID = wmld->uDeviceID;
4302     return 0;
4303 }
4304
4305 /**************************************************************************
4306  *                              waveOutGetID            [MMSYSTEM.420]
4307  */
4308 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
4309 {
4310     LPWINE_MLD          wmld;
4311
4312     TRACE("(%04X, %p);\n", hWaveOut, lpuDeviceID);
4313
4314     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4315
4316     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
4317         return MMSYSERR_INVALHANDLE;
4318
4319     *lpuDeviceID = wmld->uDeviceID;
4320     return 0;
4321 }
4322
4323 /**************************************************************************
4324  *                              waveOutMessage          [WINMM.@]
4325  */
4326 DWORD WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
4327                             DWORD dwParam1, DWORD dwParam2)
4328 {
4329     LPWINE_MLD          wmld;
4330
4331     TRACE("(%04x, %u, %ld, %ld)\n", hWaveOut, uMessage, dwParam1, dwParam2);
4332
4333     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) {
4334         if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) != NULL) {
4335             return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
4336         }
4337         return MMSYSERR_INVALHANDLE;
4338     }
4339
4340     /* from M$ KB */
4341     if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
4342         return MMSYSERR_INVALPARAM;
4343
4344     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
4345 }
4346
4347 /**************************************************************************
4348  *                              waveOutMessage          [MMSYSTEM.421]
4349  */
4350 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
4351                               DWORD dwParam1, DWORD dwParam2)
4352 {
4353     LPWINE_MLD          wmld;
4354
4355     TRACE("(%04x, %u, %ld, %ld)\n", hWaveOut, uMessage, dwParam1, dwParam2);
4356
4357     if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) {
4358         if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) != NULL) {
4359             return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
4360         }
4361         return MMSYSERR_INVALHANDLE;
4362     }
4363
4364     /* from M$ KB */
4365     if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
4366         return MMSYSERR_INVALPARAM;
4367
4368     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
4369 }
4370
4371 /**************************************************************************
4372  *                              waveInGetNumDevs                [WINMM.@]
4373  */
4374 UINT WINAPI waveInGetNumDevs(void)
4375 {
4376     return MMDRV_GetNum(MMDRV_WAVEIN);
4377 }
4378
4379 /**************************************************************************
4380  *                              waveInGetNumDevs                [MMSYSTEM.501]
4381  */
4382 UINT16 WINAPI waveInGetNumDevs16(void)
4383 {
4384     return MMDRV_GetNum(MMDRV_WAVEIN);
4385 }
4386
4387 /**************************************************************************
4388  *                              waveInGetDevCapsW               [WINMM.@]
4389  */
4390 UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
4391 {
4392     WAVEINCAPSA         wicA;
4393     UINT                ret = waveInGetDevCapsA(uDeviceID, &wicA, uSize);
4394
4395     if (ret == MMSYSERR_NOERROR) {
4396         lpCaps->wMid = wicA.wMid;
4397         lpCaps->wPid = wicA.wPid;
4398         lpCaps->vDriverVersion = wicA.vDriverVersion;
4399         MultiByteToWideChar( CP_ACP, 0, wicA.szPname, -1, lpCaps->szPname,
4400                              sizeof(lpCaps->szPname)/sizeof(WCHAR) );
4401         lpCaps->dwFormats = wicA.dwFormats;
4402         lpCaps->wChannels = wicA.wChannels;
4403     }
4404
4405     return ret;
4406 }
4407
4408 /**************************************************************************
4409  *                              waveInGetDevCapsA               [WINMM.@]
4410  */
4411 UINT WINAPI waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
4412 {
4413     LPWINE_MLD          wmld;
4414
4415     TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
4416
4417     if ((wmld = MMDRV_Get(uDeviceID, MMDRV_WAVEIN, TRUE)) == NULL)
4418         return MMSYSERR_INVALHANDLE;
4419
4420     return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
4421 }
4422
4423 /**************************************************************************
4424  *                              waveInGetDevCaps                [MMSYSTEM.502]
4425  */
4426 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps,
4427                                  UINT16 uSize)
4428 {
4429     WAVEINCAPSA wicA;
4430     UINT        ret = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(wicA));
4431
4432     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
4433
4434     if (ret == MMSYSERR_NOERROR) {
4435         lpCaps->wMid = wicA.wMid;
4436         lpCaps->wPid = wicA.wPid;
4437         lpCaps->vDriverVersion = wicA.vDriverVersion;
4438         strcpy(lpCaps->szPname, wicA.szPname);
4439         lpCaps->dwFormats = wicA.dwFormats;
4440         lpCaps->wChannels = wicA.wChannels;
4441     }
4442     return ret;
4443 }
4444
4445 /**************************************************************************
4446  *                              waveInGetErrorTextA     [WINMM.@]
4447  */
4448 UINT WINAPI waveInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
4449 {
4450     return WAVE_GetErrorText(uError, lpText, uSize);
4451 }
4452
4453 /**************************************************************************
4454  *                              waveInGetErrorTextW     [WINMM.@]
4455  */
4456 UINT WINAPI waveInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
4457 {
4458     LPSTR txt = HeapAlloc(GetProcessHeap(), 0, uSize);
4459     UINT        ret = WAVE_GetErrorText(uError, txt, uSize);
4460
4461     MultiByteToWideChar( CP_ACP, 0, txt, -1, lpText, uSize );
4462     HeapFree(GetProcessHeap(), 0, txt);
4463     return ret;
4464 }
4465
4466 /**************************************************************************
4467  *                              waveInGetErrorText      [MMSYSTEM.503]
4468  */
4469 UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
4470 {
4471     return WAVE_GetErrorText(uError, lpText, uSize);
4472 }
4473
4474 /**************************************************************************
4475  *                              waveInOpen                      [WINMM.@]
4476  */
4477 UINT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
4478                        const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
4479                        DWORD dwInstance, DWORD dwFlags)
4480 {
4481     return MMSYSTEM_waveOpen(lphWaveIn, uDeviceID, MMDRV_WAVEIN, lpFormat,
4482                              dwCallback, dwInstance, dwFlags, TRUE);
4483 }
4484
4485 /**************************************************************************
4486  *                              waveInOpen                      [MMSYSTEM.504]
4487  */
4488 UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
4489                            const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
4490                            DWORD dwInstance, DWORD dwFlags)
4491 {
4492     HWAVEIN             hWaveIn;
4493     UINT                ret;
4494
4495     /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
4496      * call the 32 bit version
4497      * however, we need to promote correctly the wave mapper id
4498      * (0xFFFFFFFF and not 0x0000FFFF)
4499      */
4500     ret = MMSYSTEM_waveOpen(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
4501                             MMDRV_WAVEIN, lpFormat, dwCallback, dwInstance, dwFlags, FALSE);
4502
4503     if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
4504     return ret;
4505 }
4506
4507 /**************************************************************************
4508  *                              waveInClose                     [WINMM.@]
4509  */
4510 UINT WINAPI waveInClose(HWAVEIN hWaveIn)
4511 {
4512     LPWINE_MLD          wmld;
4513     DWORD               dwRet;
4514
4515     TRACE("(%04X)\n", hWaveIn);
4516
4517     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4518         return MMSYSERR_INVALHANDLE;
4519
4520     dwRet = MMDRV_Message(wmld, WIDM_CLOSE, 0L, 0L, TRUE);
4521     MMDRV_Free(hWaveIn, wmld);
4522     return dwRet;
4523 }
4524
4525 /**************************************************************************
4526  *                              waveInClose                     [MMSYSTEM.505]
4527  */
4528 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
4529 {
4530     DWORD       level;
4531     UINT16      ret;
4532
4533     ReleaseThunkLock(&level);
4534     ret = waveInClose(hWaveIn);
4535     RestoreThunkLock(level);
4536     return ret;
4537 }
4538
4539 /**************************************************************************
4540  *                              waveInPrepareHeader             [WINMM.@]
4541  */
4542 UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
4543                                 UINT uSize)
4544 {
4545     LPWINE_MLD          wmld;
4546
4547     TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4548
4549     if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
4550     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4551         return MMSYSERR_INVALHANDLE;
4552
4553     lpWaveInHdr->dwBytesRecorded = 0;
4554
4555     return MMDRV_Message(wmld, WIDM_PREPARE, (DWORD)lpWaveInHdr, uSize, TRUE);
4556 }
4557
4558 /**************************************************************************
4559  *                              waveInPrepareHeader             [MMSYSTEM.506]
4560  */
4561 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
4562                                     SEGPTR lpsegWaveInHdr,   /* [???] */
4563                                     UINT16 uSize)            /* [in] */
4564 {
4565     LPWINE_MLD          wmld;
4566     LPWAVEHDR           lpWaveInHdr = MapSL(lpsegWaveInHdr);
4567     UINT16              ret;
4568
4569     TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4570
4571     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4572     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4573         return MMSYSERR_INVALHANDLE;
4574
4575     lpWaveInHdr->dwBytesRecorded = 0;
4576
4577     ret = MMDRV_Message(wmld, WIDM_PREPARE, (DWORD)lpsegWaveInHdr, uSize, FALSE);
4578     return ret;
4579 }
4580
4581 /**************************************************************************
4582  *                              waveInUnprepareHeader   [WINMM.@]
4583  */
4584 UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
4585                                   UINT uSize)
4586 {
4587     LPWINE_MLD          wmld;
4588
4589     TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4590
4591     if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
4592     if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
4593         return MMSYSERR_NOERROR;
4594     }
4595
4596     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4597         return MMSYSERR_INVALHANDLE;
4598
4599     return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD)lpWaveInHdr, uSize, TRUE);
4600 }
4601
4602 /**************************************************************************
4603  *                              waveInUnprepareHeader   [MMSYSTEM.507]
4604  */
4605 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
4606                                       SEGPTR lpsegWaveInHdr,   /* [???] */
4607                                       UINT16 uSize)            /* [in] */
4608 {
4609     LPWINE_MLD          wmld;
4610     LPWAVEHDR           lpWaveInHdr = MapSL(lpsegWaveInHdr);
4611
4612     TRACE("(%04X, %08lx, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
4613
4614     if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
4615
4616     if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
4617         return MMSYSERR_NOERROR;
4618     }
4619
4620     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4621         return MMSYSERR_INVALHANDLE;
4622
4623     return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD)lpsegWaveInHdr, uSize, FALSE);
4624 }
4625
4626 /**************************************************************************
4627  *                              waveInAddBuffer         [WINMM.@]
4628  */
4629 UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
4630                             WAVEHDR* lpWaveInHdr, UINT uSize)
4631 {
4632     LPWINE_MLD          wmld;
4633
4634     TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4635
4636     if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
4637     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4638         return MMSYSERR_INVALHANDLE;
4639
4640     return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD)lpWaveInHdr, uSize, TRUE);
4641 }
4642
4643 /**************************************************************************
4644  *                              waveInAddBuffer         [MMSYSTEM.508]
4645  */
4646 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,       /* [in] */
4647                                 WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
4648                                 UINT16 uSize)            /* [in] */
4649 {
4650     LPWINE_MLD          wmld;
4651
4652     TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
4653
4654     if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
4655     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4656         return MMSYSERR_INVALHANDLE;
4657
4658     return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD)lpsegWaveInHdr, uSize, FALSE);
4659 }
4660
4661 /**************************************************************************
4662  *                              waveInReset             [WINMM.@]
4663  */
4664 UINT WINAPI waveInReset(HWAVEIN hWaveIn)
4665 {
4666     LPWINE_MLD          wmld;
4667
4668     TRACE("(%04X);\n", hWaveIn);
4669
4670     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4671         return MMSYSERR_INVALHANDLE;
4672
4673     return MMDRV_Message(wmld, WIDM_RESET, 0L, 0L, TRUE);
4674 }
4675
4676 /**************************************************************************
4677  *                              waveInReset             [MMSYSTEM.511]
4678  */
4679 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn16)
4680 {
4681     DWORD       level;
4682     UINT16      ret;
4683
4684     ReleaseThunkLock(&level);
4685     ret = waveInReset(hWaveIn16);
4686     RestoreThunkLock(level);
4687     return ret;
4688 }
4689
4690 /**************************************************************************
4691  *                              waveInStart             [WINMM.@]
4692  */
4693 UINT WINAPI waveInStart(HWAVEIN hWaveIn)
4694 {
4695     LPWINE_MLD          wmld;
4696
4697     TRACE("(%04X);\n", hWaveIn);
4698
4699     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4700         return MMSYSERR_INVALHANDLE;
4701
4702     return MMDRV_Message(wmld, WIDM_START, 0L, 0L, TRUE);
4703 }
4704
4705 /**************************************************************************
4706  *                              waveInStart             [MMSYSTEM.509]
4707  */
4708 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn16)
4709 {
4710     DWORD       level;
4711     UINT16      ret;
4712
4713     ReleaseThunkLock(&level);
4714     ret = waveInStart(hWaveIn16);
4715     RestoreThunkLock(level);
4716     return ret;
4717 }
4718
4719 /**************************************************************************
4720  *                              waveInStop              [WINMM.@]
4721  */
4722 UINT WINAPI waveInStop(HWAVEIN hWaveIn)
4723 {
4724     LPWINE_MLD          wmld;
4725
4726     TRACE("(%04X);\n", hWaveIn);
4727
4728     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4729         return MMSYSERR_INVALHANDLE;
4730
4731     return MMDRV_Message(wmld,WIDM_STOP, 0L, 0L, TRUE);
4732 }
4733
4734 /**************************************************************************
4735  *                              waveInStop              [MMSYSTEM.510]
4736  */
4737 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn16)
4738 {
4739     DWORD       level;
4740     UINT16      ret;
4741
4742     ReleaseThunkLock(&level);
4743     ret = waveInStop(hWaveIn16);
4744     RestoreThunkLock(level);
4745     return ret;
4746 }
4747
4748 /**************************************************************************
4749  *                              waveInGetPosition       [WINMM.@]
4750  */
4751 UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
4752                               UINT uSize)
4753 {
4754     LPWINE_MLD          wmld;
4755
4756     TRACE("(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
4757
4758     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4759         return MMSYSERR_INVALHANDLE;
4760
4761     return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD)lpTime, uSize, TRUE);
4762 }
4763
4764 /**************************************************************************
4765  *                              waveInGetPosition       [MMSYSTEM.512]
4766  */
4767 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
4768                                   UINT16 uSize)
4769 {
4770     UINT        ret;
4771     MMTIME      mmt;
4772
4773     mmt.wType = lpTime->wType;
4774     ret = waveInGetPosition(hWaveIn, &mmt, sizeof(mmt));
4775     MMSYSTEM_MMTIME32to16(lpTime, &mmt);
4776     return ret;
4777 }
4778
4779 /**************************************************************************
4780  *                              waveInGetID                     [WINMM.@]
4781  */
4782 UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
4783 {
4784     LPWINE_MLD          wmld;
4785
4786     TRACE("(%04X, %p);\n", hWaveIn, lpuDeviceID);
4787
4788     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4789
4790     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4791         return MMSYSERR_INVALHANDLE;
4792
4793     *lpuDeviceID = wmld->uDeviceID;
4794     return MMSYSERR_NOERROR;
4795 }
4796
4797 /**************************************************************************
4798  *                              waveInGetID                     [MMSYSTEM.513]
4799  */
4800 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
4801 {
4802     LPWINE_MLD          wmld;
4803
4804     TRACE("(%04X, %p);\n", hWaveIn, lpuDeviceID);
4805
4806     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4807
4808     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4809         return MMSYSERR_INVALHANDLE;
4810
4811     *lpuDeviceID = wmld->uDeviceID;
4812     return MMSYSERR_NOERROR;
4813 }
4814
4815 /**************************************************************************
4816  *                              waveInMessage           [WINMM.@]
4817  */
4818 DWORD WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
4819                            DWORD dwParam1, DWORD dwParam2)
4820 {
4821     LPWINE_MLD          wmld;
4822
4823     TRACE("(%04x, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
4824
4825     /* from M$ KB */
4826     if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
4827         return MMSYSERR_INVALPARAM;
4828
4829     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4830         return MMSYSERR_INVALHANDLE;
4831
4832     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
4833 }
4834
4835 /**************************************************************************
4836  *                              waveInMessage           [MMSYSTEM.514]
4837  */
4838 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
4839                              DWORD dwParam1, DWORD dwParam2)
4840 {
4841     LPWINE_MLD          wmld;
4842
4843     TRACE("(%04x, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
4844
4845     /* from M$ KB */
4846     if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
4847         return MMSYSERR_INVALPARAM;
4848
4849     if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
4850         return MMSYSERR_INVALHANDLE;
4851
4852     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
4853 }
4854
4855 /*#define USE_MM_TSK_WINE*/
4856
4857 /**************************************************************************
4858  *                              mmTaskCreate            [MMSYSTEM.900]
4859  *
4860  * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
4861  * called upon creation with dwPmt as parameter.
4862  */
4863 HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt)
4864 {
4865     HINSTANCE16         ret;
4866     HINSTANCE16         handle;
4867     char cmdline[16];
4868     DWORD showCmd = 0x40002;
4869     LOADPARAMS16 lp;
4870
4871     TRACE("(%08lx, %p, %08lx);\n", spProc, lphMmTask, dwPmt);
4872     /* This to work requires NE modules to be started with a binary command line
4873      * which is not currently the case. A patch exists but has never been committed.
4874      * A workaround would be to integrate code for mmtask.tsk into Wine, but
4875      * this requires tremendous work (starting with patching tools/build to
4876      * create NE executables (and not only DLLs) for builtins modules.
4877      * EP 99/04/25
4878      */
4879     FIXME("This is currently broken. It will fail\n");
4880
4881     cmdline[0] = 0x0d;
4882     *(LPDWORD)(cmdline + 1) = (DWORD)spProc;
4883     *(LPDWORD)(cmdline + 5) = dwPmt;
4884     *(LPDWORD)(cmdline + 9) = 0;
4885
4886     lp.hEnvironment = 0;
4887     lp.cmdLine = MapLS(cmdline);
4888     lp.showCmd = MapLS(&showCmd);
4889     lp.reserved = 0;
4890
4891 #ifndef USE_MM_TSK_WINE
4892     handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", &lp);
4893 #else
4894     handle = LoadModule16("mmtask.tsk", &lp);
4895 #endif
4896     if (handle < 32) {
4897         ret = (handle) ? 1 : 2;
4898         handle = 0;
4899     } else {
4900         ret = 0;
4901     }
4902     if (lphMmTask)
4903         *lphMmTask = handle;
4904
4905     UnMapLS( lp.cmdLine );
4906     UnMapLS( lp.showCmd );
4907     TRACE("=> 0x%04x/%d\n", handle, ret);
4908     return ret;
4909 }
4910
4911 #ifdef USE_MM_TSK_WINE
4912 /* C equivalent to mmtask.tsk binary content */
4913 void    mmTaskEntryPoint16(LPSTR cmdLine, WORD di, WORD si)
4914 {
4915     int len = cmdLine[0x80];
4916
4917     if (len / 2 == 6) {
4918         void    (*fpProc)(DWORD) = MapSL(*((DWORD*)(cmdLine + 1)));
4919         DWORD   dwPmt  = *((DWORD*)(cmdLine + 5));
4920
4921 #if 0
4922         InitTask16(); /* FIXME: pmts / from context ? */
4923         InitApp(di);
4924 #endif
4925         if (SetMessageQueue16(0x40)) {
4926             WaitEvent16(0);
4927             if (HIWORD(fpProc)) {
4928                 OldYield16();
4929 /* EPP          StackEnter16(); */
4930                 (fpProc)(dwPmt);
4931             }
4932         }
4933     }
4934     OldYield16();
4935     OldYield16();
4936     OldYield16();
4937     ExitProcess(0);
4938 }
4939 #endif
4940
4941 /**************************************************************************
4942  *                              mmTaskBlock             [MMSYSTEM.902]
4943  */
4944 void    WINAPI  mmTaskBlock16(HINSTANCE16 WINE_UNUSED hInst)
4945 {
4946     MSG         msg;
4947
4948     do {
4949         GetMessageA(&msg, 0, 0, 0);
4950         if (msg.hwnd) {
4951             TranslateMessage(&msg);
4952             DispatchMessageA(&msg);
4953         }
4954     } while (msg.message < 0x3A0);
4955 }
4956
4957 /**************************************************************************
4958  *                              mmTaskSignal            [MMSYSTEM.903]
4959  */
4960 LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
4961 {
4962     TRACE("(%04x);\n", ht);
4963     return PostAppMessage16(ht, WM_USER, 0, 0);
4964 }
4965
4966 /**************************************************************************
4967  *                              mmGetCurrentTask        [MMSYSTEM.904]
4968  */
4969 HTASK16 WINAPI mmGetCurrentTask16(void)
4970 {
4971     return GetCurrentTask();
4972 }
4973
4974 /**************************************************************************
4975  *                              mmTaskYield             [MMSYSTEM.905]
4976  */
4977 void    WINAPI  mmTaskYield16(void)
4978 {
4979     MSG         msg;
4980
4981     if (PeekMessageA(&msg, 0, 0, 0, 0)) {
4982         K32WOWYield16();
4983     }
4984 }
4985
4986 DWORD   WINAPI  GetProcessFlags(DWORD);
4987
4988 /**************************************************************************
4989  *                              mmThreadCreate          [MMSYSTEM.1120]
4990  *
4991  * undocumented
4992  * Creates a MM thread, calling fpThreadAddr(dwPmt).
4993  * dwFlags:
4994  *      bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc
4995  *      bit.1 set means to open a VxD for this thread (unsupported)
4996  */
4997 LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE lpHndl, DWORD dwPmt, DWORD dwFlags)
4998 {
4999     HANDLE16            hndl;
5000     LRESULT             ret;
5001
5002     TRACE("(%p, %p, %08lx, %08lx)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags);
5003
5004     hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT);
5005
5006     if (hndl == 0) {
5007         ret = 2;
5008     } else {
5009         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5010
5011 #if 0
5012         /* force mmtask routines even if mmthread is required */
5013         /* this will work only if the patch about binary cmd line and NE tasks
5014          * is committed
5015          */
5016         dwFlags |= 1;
5017 #endif
5018
5019         lpMMThd->dwSignature    = WINE_MMTHREAD_CREATED;
5020         lpMMThd->dwCounter      = 0;
5021         lpMMThd->hThread        = 0;
5022         lpMMThd->dwThreadID     = 0;
5023         lpMMThd->fpThread       = fpThreadAddr;
5024         lpMMThd->dwThreadPmt    = dwPmt;
5025         lpMMThd->dwSignalCount  = 0;
5026         lpMMThd->hEvent         = 0;
5027         lpMMThd->hVxD           = 0;
5028         lpMMThd->dwStatus       = 0;
5029         lpMMThd->dwFlags        = dwFlags;
5030         lpMMThd->hTask          = 0;
5031
5032         if ((dwFlags & 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) {
5033             lpMMThd->hEvent = CreateEventA(0, 0, 1, 0);
5034
5035             TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd);
5036             if (lpMMThd->dwFlags & 2) {
5037                 /* as long as we don't support MM VxD in wine, we don't need
5038                  * to care about this flag
5039                  */
5040                 /* FIXME("Don't know how to properly open VxD handles\n"); */
5041                 /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */
5042             }
5043
5044             lpMMThd->hThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)WINE_mmThreadEntryPoint,
5045                                             (LPVOID)(DWORD)hndl, CREATE_SUSPENDED, &lpMMThd->dwThreadID);
5046             if (lpMMThd->hThread == 0) {
5047                 WARN("Couldn't create thread\n");
5048                 /* clean-up(VxDhandle...); devicedirectio... */
5049                 if (lpMMThd->hEvent != 0)
5050                     CloseHandle(lpMMThd->hEvent);
5051                 ret = 2;
5052             } else {
5053                 TRACE("Got a nice thread hndl=0x%04x id=0x%08lx\n", lpMMThd->hThread, lpMMThd->dwThreadID);
5054                 ret = 0;
5055             }
5056         } else {
5057             /* get WINE_mmThreadEntryPoint()
5058              * 2047 is its ordinal in mmsystem.spec
5059              */
5060             FARPROC16   fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047);
5061
5062             TRACE("farproc seg=0x%08lx lin=%p\n", (DWORD)fp, MapSL((SEGPTR)fp));
5063
5064             ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl);
5065         }
5066
5067         if (ret == 0) {
5068             if (lpMMThd->hThread && !ResumeThread(lpMMThd->hThread))
5069                 WARN("Couldn't resume thread\n");
5070
5071             while (lpMMThd->dwStatus != 0x10) { /* test also HIWORD of dwStatus */
5072                 UserYield16();
5073             }
5074         }
5075     }
5076
5077     if (ret != 0) {
5078         GlobalFree16(hndl);
5079         hndl = 0;
5080     }
5081
5082     if (lpHndl)
5083         *lpHndl = hndl;
5084
5085     TRACE("ok => %ld\n", ret);
5086     return ret;
5087 }
5088
5089 /**************************************************************************
5090  *                              mmThreadSignal          [MMSYSTEM.1121]
5091  */
5092 void WINAPI mmThreadSignal16(HANDLE16 hndl)
5093 {
5094     TRACE("(%04x)!\n", hndl);
5095
5096     if (hndl) {
5097         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5098
5099         lpMMThd->dwCounter++;
5100         if (lpMMThd->hThread != 0) {
5101             InterlockedIncrement(&lpMMThd->dwSignalCount);
5102             SetEvent(lpMMThd->hEvent);
5103         } else {
5104             mmTaskSignal16(lpMMThd->hTask);
5105         }
5106         lpMMThd->dwCounter--;
5107     }
5108 }
5109
5110 /**************************************************************************
5111  *                              MMSYSTEM_ThreadBlock            [internal]
5112  */
5113 static  void    MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd)
5114 {
5115     MSG         msg;
5116     DWORD       ret;
5117
5118     if (lpMMThd->dwThreadID != GetCurrentThreadId())
5119         ERR("Not called by thread itself\n");
5120
5121     for (;;) {
5122         ResetEvent(lpMMThd->hEvent);
5123         if (InterlockedDecrement(&lpMMThd->dwSignalCount) >= 0)
5124             break;
5125         InterlockedIncrement(&lpMMThd->dwSignalCount);
5126
5127         TRACE("S1\n");
5128
5129         ret = MsgWaitForMultipleObjects(1, &lpMMThd->hEvent, FALSE, INFINITE, QS_ALLINPUT);
5130         switch (ret) {
5131         case WAIT_OBJECT_0:     /* Event */
5132             TRACE("S2.1\n");
5133             break;
5134         case WAIT_OBJECT_0 + 1: /* Msg */
5135             TRACE("S2.2\n");
5136             if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
5137                 TranslateMessage(&msg);
5138                 DispatchMessageA(&msg);
5139             }
5140             break;
5141         default:
5142             WARN("S2.x unsupported ret val 0x%08lx\n", ret);
5143         }
5144         TRACE("S3\n");
5145     }
5146 }
5147
5148 /**************************************************************************
5149  *                              mmThreadBlock           [MMSYSTEM.1122]
5150  */
5151 void    WINAPI mmThreadBlock16(HANDLE16 hndl)
5152 {
5153     TRACE("(%04x)!\n", hndl);
5154
5155     if (hndl) {
5156         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5157
5158         if (lpMMThd->hThread != 0) {
5159             DWORD       lc;
5160
5161             ReleaseThunkLock(&lc);
5162             MMSYSTEM_ThreadBlock(lpMMThd);
5163             RestoreThunkLock(lc);
5164         } else {
5165             mmTaskBlock16(lpMMThd->hTask);
5166         }
5167     }
5168     TRACE("done\n");
5169 }
5170
5171 /**************************************************************************
5172  *                              mmThreadIsCurrent       [MMSYSTEM.1123]
5173  */
5174 BOOL16  WINAPI mmThreadIsCurrent16(HANDLE16 hndl)
5175 {
5176     BOOL16              ret = FALSE;
5177
5178     TRACE("(%04x)!\n", hndl);
5179
5180     if (hndl && mmThreadIsValid16(hndl)) {
5181         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5182         ret = (GetCurrentThreadId() == lpMMThd->dwThreadID);
5183     }
5184     TRACE("=> %d\n", ret);
5185     return ret;
5186 }
5187
5188 /**************************************************************************
5189  *                              mmThreadIsValid         [MMSYSTEM.1124]
5190  */
5191 BOOL16  WINAPI  mmThreadIsValid16(HANDLE16 hndl)
5192 {
5193     BOOL16              ret = FALSE;
5194
5195     TRACE("(%04x)!\n", hndl);
5196
5197     if (hndl) {
5198         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5199
5200         if (!IsBadWritePtr(lpMMThd, sizeof(WINE_MMTHREAD)) &&
5201             lpMMThd->dwSignature == WINE_MMTHREAD_CREATED &&
5202             IsTask16(lpMMThd->hTask)) {
5203             lpMMThd->dwCounter++;
5204             if (lpMMThd->hThread != 0) {
5205                 DWORD   dwThreadRet;
5206                 if (GetExitCodeThread(lpMMThd->hThread, &dwThreadRet) &&
5207                     dwThreadRet == STATUS_PENDING) {
5208                     ret = TRUE;
5209                 }
5210             } else {
5211                 ret = TRUE;
5212             }
5213             lpMMThd->dwCounter--;
5214         }
5215     }
5216     TRACE("=> %d\n", ret);
5217     return ret;
5218 }
5219
5220 /**************************************************************************
5221  *                              mmThreadGetTask         [MMSYSTEM.1125]
5222  */
5223 HANDLE16 WINAPI mmThreadGetTask16(HANDLE16 hndl)
5224 {
5225     HANDLE16    ret = 0;
5226
5227     TRACE("(%04x)\n", hndl);
5228
5229     if (mmThreadIsValid16(hndl)) {
5230         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5231         ret = lpMMThd->hTask;
5232     }
5233     return ret;
5234 }
5235
5236 /* ### start build ### */
5237 extern LONG CALLBACK MMSYSTEM_CallTo16_long_l    (FARPROC16,LONG);
5238 /* ### stop build ### */
5239
5240 /**************************************************************************
5241  *                              __wine_mmThreadEntryPoint (MMSYSTEM.2047)
5242  */
5243 void WINAPI WINE_mmThreadEntryPoint(DWORD _pmt)
5244 {
5245     HANDLE16            hndl = (HANDLE16)_pmt;
5246     WINE_MMTHREAD*      lpMMThd = MapSL( MAKESEGPTR(hndl, 0) );
5247
5248     TRACE("(%04x %p)\n", hndl, lpMMThd);
5249
5250     lpMMThd->hTask = LOWORD(GetCurrentTask());
5251     TRACE("[10-%08x] setting hTask to 0x%08x\n", lpMMThd->hThread, lpMMThd->hTask);
5252     lpMMThd->dwStatus = 0x10;
5253     MMSYSTEM_ThreadBlock(lpMMThd);
5254     TRACE("[20-%08x]\n", lpMMThd->hThread);
5255     lpMMThd->dwStatus = 0x20;
5256     if (lpMMThd->fpThread) {
5257         MMSYSTEM_CallTo16_long_l(lpMMThd->fpThread, lpMMThd->dwThreadPmt);
5258     }
5259     lpMMThd->dwStatus = 0x30;
5260     TRACE("[30-%08x]\n", lpMMThd->hThread);
5261     while (lpMMThd->dwCounter) {
5262         Sleep(1);
5263         /* K32WOWYield16();*/
5264     }
5265     TRACE("[XX-%08x]\n", lpMMThd->hThread);
5266     /* paranoia */
5267     lpMMThd->dwSignature = WINE_MMTHREAD_DELETED;
5268     /* close lpMMThread->hVxD directIO */
5269     if (lpMMThd->hEvent)
5270         CloseHandle(lpMMThd->hEvent);
5271     GlobalFree16(hndl);
5272     TRACE("done\n");
5273 }
5274
5275 typedef BOOL16 (WINAPI *MMCPLCALLBACK)(HWND, LPCSTR, LPCSTR, LPCSTR);
5276
5277 /**************************************************************************
5278  *                      mmShowMMCPLPropertySheet        [MMSYSTEM.1150]
5279  */
5280 BOOL16  WINAPI  mmShowMMCPLPropertySheet16(HWND hWnd, LPCSTR lpStrDevice,
5281                                            LPCSTR lpStrTab, LPCSTR lpStrTitle)
5282 {
5283     HANDLE      hndl;
5284     BOOL16      ret = FALSE;
5285
5286     TRACE("(%04x \"%s\" \"%s\" \"%s\")\n", hWnd, lpStrDevice, lpStrTab, lpStrTitle);
5287
5288     hndl = LoadLibraryA("MMSYS.CPL");
5289     if (hndl != 0) {
5290         MMCPLCALLBACK   fp = (MMCPLCALLBACK)GetProcAddress(hndl, "ShowMMCPLPropertySheet");
5291         if (fp != NULL) {
5292             DWORD       lc;
5293             ReleaseThunkLock(&lc);
5294             ret = (fp)(hWnd, lpStrDevice, lpStrTab, lpStrTitle);
5295             RestoreThunkLock(lc);
5296         }
5297         FreeLibrary(hndl);
5298     }
5299
5300     return ret;
5301 }
5302
5303 /**************************************************************************
5304  *                      StackEnter              [MMSYSTEM.32]
5305  */
5306 void WINAPI StackEnter16(void)
5307 {
5308 #ifdef __i386__
5309     /* mmsystem.dll from Win 95 does only this: so does Wine */
5310     __asm__("stc");
5311 #endif
5312 }
5313
5314 /**************************************************************************
5315  *                      StackLeave              [MMSYSTEM.33]
5316  */
5317 void WINAPI StackLeave16(void)
5318 {
5319 #ifdef __i386__
5320     /* mmsystem.dll from Win 95 does only this: so does Wine */
5321     __asm__("stc");
5322 #endif
5323 }
5324
5325 /**************************************************************************
5326  *                      WMMMidiRunOnce          [MMSYSTEM.8]
5327  */
5328 void WINAPI WMMMidiRunOnce16(void)
5329 {
5330         FIXME("(), stub!\n");
5331 }
5332
5333 /**************************************************************************
5334  *                      OutputDebugStr          [MMSYSTEM.30]
5335  */
5336 void WINAPI OutputDebugStr16(
5337     LPCSTR str) /* [in] The message to be logged and given to the debugger. */
5338 {
5339     OutputDebugStringA( str );
5340 }