multimedia/mmsystem.c

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