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