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