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 support for Win32 MCI
  12  */
  13
  14 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
  15  *        and long term pointers to 16 bit space in here
  16  */
  17
  18 #include <unistd.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <fcntl.h>
  22 #include <errno.h>
  23 #include <sys/ioctl.h>
  24 #include "windows.h"
  25 #include "win.h"
  26 #include "heap.h"
  27 #include "ldt.h"
  28 #include "user.h"
  29 #include "driver.h"
  30 #include "file.h"
  31 #include "mmsystem.h"
  32 #include "multimedia.h"
  33 #include "xmalloc.h"
  34 #include "callback.h"
  35 #include "module.h"
  36 #include "selectors.h"
  37 #include "debug.h"
  38
  39 int     mciInstalledCount;
  40 int     mciInstalledListLen;
  41 LPSTR   lpmciInstallNames = NULL;
  42
  43 struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
  44
  45 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
  46 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
  47 LONG   WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
  48                                DWORD dwParam1, DWORD dwParam2);
  49
  50 #define MCI_GetDrv(wDevID)      (&mciDrv[MCI_DevIDToIndex(wDevID)])
  51 #define MCI_GetOpenDrv(wDevID)  (&(MCI_GetDrv(wDevID)->mop))
  52
  53 /* The wDevID's returned by wine were originally in the range
  54  * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices.
  55  * Unfortunately, ms-windows uses wDevID of zero to indicate
  56  * errors.  Now, multimedia drivers must pass the wDevID through
  57  * MCI_DevIDToIndex to get an index in that range.  An
  58  * arbitrary value, MCI_MAGIC is added to the wDevID seen
  59  * by the windows programs.
  60  */
  61
  62 #define MCI_MAGIC 0x0F00
  63
  64 /**************************************************************************
  65  *                              MCI_GetProc32                   [internal]
  66  */
  67 MCIPROC32       MCI_GetProc32(UINT16 uDevType)
  68 {
  69     MCIPROC32   proc = 0;
  70
  71     switch (uDevType) {
  72     case MCI_DEVTYPE_CD_AUDIO:          proc = MCICDAUDIO_DriverProc32; break;
  73     case MCI_DEVTYPE_WAVEFORM_AUDIO:    proc = MCIWAVE_DriverProc32;    break;
  74     case MCI_DEVTYPE_SEQUENCER:         proc = MCIMIDI_DriverProc32;    break;
  75     case MCI_DEVTYPE_ANIMATION:         proc = MCIANIM_DriverProc32;    break;
  76     default:    TRACE(mci, "Unknown device type %u\n", uDevType);
  77     }
  78     return proc;
  79 }
  80
  81 /**************************************************************************
  82  *                              MCI_GetDevType                  [internal]
  83  */
  84 WORD            MCI_GetDevType(LPCSTR str)
  85 {
  86     WORD        uDevTyp = 0;
  87
  88     if (strcmp(str, "CDAUDIO") == 0) {
  89         uDevTyp = MCI_DEVTYPE_CD_AUDIO;
  90     } else if (strcmp(str, "WAVEAUDIO") == 0) {
  91         uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
  92     } else if (strcmp(str, "SEQUENCER") == 0)   {
  93         uDevTyp = MCI_DEVTYPE_SEQUENCER;
  94     } else if (strcmp(str, "ANIMATION1") == 0) {
  95         uDevTyp = MCI_DEVTYPE_ANIMATION;
  96     } else if (strcmp(str, "AVIVIDEO") == 0) {
  97         uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
  98     }
  99     TRACE(mci, "str = %s => %u\n", str, uDevTyp);
 100     return uDevTyp;
 101 }
 102
 103 /**************************************************************************
 104  *                              MCI_GetDevTypeString            [internal]
 105  */
 106 static  LPCSTR          MCI_GetDevTypeString(WORD uDevTyp)
 107 {
 108     LPCSTR      str = "??? MCI ???";
 109
 110     switch (uDevTyp) {
 111     case MCI_DEVTYPE_CD_AUDIO:          str = "CDAUDIO";        break;
 112     case MCI_DEVTYPE_WAVEFORM_AUDIO:    str = "WAVEAUDIO";      break;
 113     case MCI_DEVTYPE_SEQUENCER:         str = "SEQUENCER";      break;
 114     case MCI_DEVTYPE_ANIMATION:         str = "ANIMATION1";     break;
 115     case MCI_DEVTYPE_DIGITAL_VIDEO:     str = "AVIVIDEO";       break;
 116     default:    FIXME(mci, "Incohenrent MCI definitions\n");
 117     }
 118     TRACE(mci, "devType=%u => %s\n", uDevTyp, str);
 119     return str;
 120 }
 121
 122 /**************************************************************************
 123  *                              MCI_DevIDToIndex        [internal]
 124  */
 125 int MCI_DevIDToIndex(UINT16 wDevID)
 126 {
 127     return wDevID - MCI_MAGIC;
 128 }
 129
 130 /**************************************************************************
 131  *                              MCI_FirstDevId  [internal]
 132  */
 133 UINT16 MCI_FirstDevID(void)
 134 {
 135     return MCI_MAGIC;
 136 }
 137
 138 /**************************************************************************
 139  *                              MCI_NextDevId   [internal]
 140  */
 141 UINT16 MCI_NextDevID(UINT16 wDevID)
 142 {
 143     return wDevID + 1;
 144 }
 145
 146 /**************************************************************************
 147  *                              MCI_DevIDValid  [internal]
 148  */
 149 BOOL32 MCI_DevIDValid(UINT16 wDevID)
 150 {
 151     return wDevID >= MCI_MAGIC && wDevID < (MCI_MAGIC + MAXMCIDRIVERS);
 152 }
 153
 154 /**************************************************************************
 155  *                              MMSYSTEM_WEP            [MMSYSTEM.1]
 156  */
 157 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
 158                         WORD cbHeapSize, LPSTR lpCmdLine)
 159 {
 160     FIXME(mmsys, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
 161     return(TRUE);
 162 }
 163
 164 static void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16,LPMMTIME32 mmt32)
 165 {
 166     mmt16->wType = mmt32->wType;
 167     /* layout of rest is the same for 32/16 */
 168     memcpy(&(mmt32->u),&(mmt16->u),sizeof(mmt16->u));
 169 }
 170
 171 static void MMSYSTEM_MMTIME16to32(LPMMTIME32 mmt32,LPMMTIME16 mmt16)
 172 {
 173     mmt32->wType = mmt16->wType;
 174     /* layout of rest is the same for 32/16,
 175      * Note: mmt16->u is 2 bytes smaller than mmt32->u
 176      */
 177     memcpy(&(mmt16->u),&(mmt32->u),sizeof(mmt16->u));
 178 }
 179
 180 static HANDLE32         PlaySound_hThread = 0;
 181 static HANDLE32         PlaySound_hPlayEvent = 0;
 182 static HANDLE32         PlaySound_hReadyEvent = 0;
 183 static HANDLE32         PlaySound_hMiddleEvent = 0;
 184 static BOOL32           PlaySound_Result = FALSE;
 185 static int              PlaySound_Stop = FALSE;
 186 static int              PlaySound_Playing = FALSE;
 187
 188 static LPCSTR           PlaySound_pszSound = NULL;
 189 static HMODULE32        PlaySound_hmod = 0;
 190 static DWORD            PlaySound_fdwSound = 0;
 191 static int              PlaySound_Loop = FALSE;
 192 static int              PlaySound_SearchMode = 0; /* 1 - sndPlaySound search order
 193                                                      2 - PlaySound order */
 194
 195 static HMMIO16  get_mmioFromFile(LPCSTR lpszName)
 196 {
 197     return mmioOpen16((LPSTR)lpszName, NULL,
 198                       MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 199 }
 200
 201 static HMMIO16 get_mmioFromProfile(UINT32 uFlags, LPCSTR lpszName)
 202 {
 203     char        str[128];
 204     LPSTR       ptr;
 205     HMMIO16     hmmio;
 206
 207     TRACE(mmsys, "searching in SystemSound List !\n");
 208     GetProfileString32A("Sounds", (LPSTR)lpszName, "", str, sizeof(str));
 209     if (strlen(str) == 0) {
 210         if (uFlags & SND_NODEFAULT) return 0;
 211         GetProfileString32A("Sounds", "Default", "", str, sizeof(str));
 212         if (strlen(str) == 0) return 0;
 213     }
 214     if ( (ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0';
 215     hmmio = get_mmioFromFile(str);
 216     if (hmmio == 0) {
 217         WARN(mmsys, "can't find SystemSound='%s' !\n", str);
 218         return 0;
 219     }
 220     return hmmio;
 221 }
 222
 223 static BOOL16 WINAPI proc_PlaySound(LPCSTR lpszSoundName, UINT32 uFlags)
 224 {
 225     BOOL16              bRet = FALSE;
 226     HMMIO16             hmmio;
 227     MMCKINFO            ckMainRIFF;
 228
 229     TRACE(mmsys, "SoundName='%s' uFlags=%04X !\n", lpszSoundName, uFlags);
 230     if (lpszSoundName == NULL) {
 231         TRACE(mmsys, "Stop !\n");
 232         return FALSE;
 233     }
 234     if (uFlags & SND_MEMORY) {
 235         MMIOINFO16 mminfo;
 236         memset(&mminfo, 0, sizeof(mminfo));
 237         mminfo.fccIOProc = FOURCC_MEM;
 238         mminfo.pchBuffer = (LPSTR)lpszSoundName;
 239         mminfo.cchBuffer = -1;
 240         TRACE(mmsys, "Memory sound %p\n",lpszSoundName);
 241         hmmio = mmioOpen16(NULL, &mminfo, MMIO_READ);
 242     } else {
 243         hmmio = 0;
 244         if (uFlags & SND_ALIAS)
 245             if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0)
 246                 return FALSE;
 247
 248         if (uFlags & SND_FILENAME)
 249             if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0) return FALSE;
 250
 251         if (PlaySound_SearchMode == 1) {
 252             PlaySound_SearchMode = 0;
 253             if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0)
 254                 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0)
 255                     return FALSE;
 256         }
 257
 258         if (PlaySound_SearchMode == 2) {
 259             PlaySound_SearchMode = 0;
 260             if ((hmmio=get_mmioFromProfile(uFlags | SND_NODEFAULT, lpszSoundName)) == 0)
 261                 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0)
 262                     if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0) return FALSE;
 263         }
 264     }
 265
 266     if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
 267         do {
 268             TRACE(mmsys, "ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
 269                   (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
 270                   ckMainRIFF.cksize);
 271
 272             if ((ckMainRIFF.ckid == FOURCC_RIFF) &&
 273                 (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E'))) {
 274                 MMCKINFO        mmckInfo;
 275
 276                 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
 277
 278                 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
 279                     PCMWAVEFORMAT           pcmWaveFormat;
 280
 281                     TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
 282                           (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
 283
 284                     if (mmioRead32(hmmio,(HPSTR)&pcmWaveFormat,
 285                                    (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT)) {
 286                         TRACE(mmsys, "wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
 287                         TRACE(mmsys, "nChannels=%d \n", pcmWaveFormat.wf.nChannels);
 288                         TRACE(mmsys, "nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
 289                         TRACE(mmsys, "nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
 290                         TRACE(mmsys, "nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
 291                         TRACE(mmsys, "wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample);
 292
 293                         mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
 294                         if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
 295                             WAVEOPENDESC        waveDesc;
 296                             DWORD               dwRet;
 297
 298                             TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
 299                                   (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
 300
 301                             pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec *
 302                                 pcmWaveFormat.wf.nBlockAlign;
 303                             waveDesc.hWave    = 0;
 304                             waveDesc.lpFormat = (LPWAVEFORMAT)&pcmWaveFormat;
 305
 306                             dwRet = wodMessage( 0, WODM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL);
 307                             if (dwRet == MMSYSERR_NOERROR) {
 308                                 WAVEHDR         waveHdr;
 309                                 HGLOBAL16       hData;
 310                                 INT32           count, bufsize, left = mmckInfo.cksize;
 311
 312                                 bufsize = 64000;
 313                                 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
 314                                 waveHdr.lpData = (LPSTR)GlobalLock16(hData);
 315                                 waveHdr.dwBufferLength = bufsize;
 316                                 waveHdr.dwUser = 0L;
 317                                 waveHdr.dwFlags = 0L;
 318                                 waveHdr.dwLoops = 0L;
 319
 320                                 dwRet = wodMessage(0,WODM_PREPARE,0,(DWORD)&waveHdr,sizeof(WAVEHDR));
 321                                 if (dwRet == MMSYSERR_NOERROR) {
 322                                     while (left) {
 323                                         if (PlaySound_Stop) {
 324                                             PlaySound_Stop = FALSE;
 325                                             PlaySound_Loop = FALSE;
 326                                             break;
 327                                         }
 328                                         if (bufsize > left) bufsize = left;
 329                                         count = mmioRead32(hmmio,waveHdr.lpData,bufsize);
 330                                         if (count < 1) break;
 331                                         left -= count;
 332                                         waveHdr.dwBufferLength = count;
 333                                 /*      waveHdr.dwBytesRecorded = count; */
 334                                         /* FIXME: doesn't expect async ops */
 335                                         wodMessage( 0, WODM_WRITE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
 336                                     }
 337                                     wodMessage( 0, WODM_UNPREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
 338                                     wodMessage( 0, WODM_CLOSE, 0, 0L, 0L);
 339
 340                                     bRet = TRUE;
 341                                 } else
 342                                     WARN(mmsys, "can't prepare WaveOut device !\n");
 343
 344                                 GlobalUnlock16(hData);
 345                                 GlobalFree16(hData);
 346                             }
 347                         }
 348                     }
 349                 }
 350             }
 351         } while (PlaySound_Loop);
 352
 353     if (hmmio != 0) mmioClose32(hmmio, 0);
 354     return bRet;
 355 }
 356
 357 static DWORD WINAPI PlaySound_Thread(LPVOID arg)
 358 {
 359     DWORD     res;
 360
 361     for (;;) {
 362         PlaySound_Playing = FALSE;
 363         SetEvent(PlaySound_hReadyEvent);
 364         res = WaitForSingleObject(PlaySound_hPlayEvent, INFINITE32);
 365         ResetEvent(PlaySound_hReadyEvent);
 366         SetEvent(PlaySound_hMiddleEvent);
 367         if (res == WAIT_FAILED) ExitThread(2);
 368         if (res != WAIT_OBJECT_0) continue;
 369         PlaySound_Playing = TRUE;
 370
 371         if ((PlaySound_fdwSound & SND_RESOURCE) == SND_RESOURCE) {
 372             HRSRC32   hRES;
 373             HGLOBAL32 hGLOB;
 374             void      *ptr;
 375
 376             if ((hRES = FindResource32A(PlaySound_hmod, PlaySound_pszSound, "WAVE")) == 0) {
 377                 PlaySound_Result = FALSE;
 378                 continue;
 379             }
 380             if ((hGLOB = LoadResource32(PlaySound_hmod, hRES)) == 0) {
 381                 PlaySound_Result = FALSE;
 382                 continue;
 383             }
 384             if ((ptr = LockResource32(hGLOB)) == NULL) {
 385                 FreeResource32(hGLOB);
 386                 PlaySound_Result = FALSE;
 387                 continue;
 388             }
 389             PlaySound_Result = proc_PlaySound(ptr,
 390                                               ((UINT16)PlaySound_fdwSound ^ SND_RESOURCE) | SND_MEMORY);
 391             FreeResource32(hGLOB);
 392             continue;
 393         }
 394         PlaySound_Result=proc_PlaySound(PlaySound_pszSound, (UINT16)PlaySound_fdwSound);
 395     }
 396 }
 397
 398 /**************************************************************************
 399  *                              PlaySoundA              [WINMM.1]
 400  */
 401 BOOL32 WINAPI PlaySound32A(LPCSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
 402 {
 403     static LPSTR StrDup = NULL;
 404
 405     TRACE(mmsys, "pszSound='%p' hmod=%04X fdwSound=%08lX\n",
 406           pszSound, hmod, fdwSound);
 407
 408     if (PlaySound_hThread == 0) { /* This is the first time they called us */
 409         DWORD   id;
 410         if ((PlaySound_hReadyEvent = CreateEvent32A(NULL, TRUE, FALSE, NULL)) == 0)
 411             return FALSE;
 412         if ((PlaySound_hMiddleEvent = CreateEvent32A(NULL, FALSE, FALSE, NULL)) == 0)
 413             return FALSE;
 414         if ((PlaySound_hPlayEvent = CreateEvent32A(NULL, FALSE, FALSE, NULL)) == 0)
 415             return FALSE;
 416         if ((PlaySound_hThread = CreateThread(NULL, 0, PlaySound_Thread, 0, 0, &id)) == 0)
 417             return FALSE;
 418     }
 419
 420     /* FIXME? I see no difference between SND_WAIT and SND_NOSTOP ! */
 421     if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && PlaySound_Playing)
 422         return FALSE;
 423
 424     /* Trying to stop if playing */
 425     if (PlaySound_Playing) PlaySound_Stop = TRUE;
 426
 427     /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave*/
 428     if (WaitForSingleObject(PlaySound_hReadyEvent, 1000*10) != WAIT_OBJECT_0)
 429         return FALSE;
 430
 431     if (!pszSound || (fdwSound & SND_PURGE))
 432         return FALSE; /* We stoped playing so leaving */
 433
 434     if (PlaySound_SearchMode != 1) PlaySound_SearchMode = 2;
 435     if (!(fdwSound & SND_ASYNC)) {
 436         if (fdwSound & SND_LOOP)
 437             return FALSE;
 438         PlaySound_pszSound = pszSound;
 439         PlaySound_hmod = hmod;
 440         PlaySound_fdwSound = fdwSound;
 441         PlaySound_Result = FALSE;
 442         SetEvent(PlaySound_hPlayEvent);
 443         if (WaitForSingleObject(PlaySound_hMiddleEvent, INFINITE32) != WAIT_OBJECT_0)
 444             return FALSE;
 445         if (WaitForSingleObject(PlaySound_hReadyEvent, INFINITE32) != WAIT_OBJECT_0)
 446             return FALSE;
 447         return PlaySound_Result;
 448     } else {
 449         PlaySound_hmod = hmod;
 450         PlaySound_fdwSound = fdwSound;
 451         PlaySound_Result = FALSE;
 452         if (StrDup) {
 453             HeapFree(GetProcessHeap(), 0, StrDup);
 454             StrDup = NULL;
 455         }
 456         if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) &&
 457                                           !((DWORD)pszSound >> 16)) || !pszSound)) {
 458             StrDup = HEAP_strdupA(GetProcessHeap(),0,pszSound);
 459             PlaySound_pszSound = StrDup;
 460         } else PlaySound_pszSound = pszSound;
 461         PlaySound_Loop = fdwSound & SND_LOOP;
 462         SetEvent(PlaySound_hPlayEvent);
 463         ResetEvent(PlaySound_hMiddleEvent);
 464         return TRUE;
 465     }
 466     return FALSE;
 467 }
 468
 469 /**************************************************************************
 470  *                              PlaySoundW              [WINMM.18]
 471  */
 472 BOOL32 WINAPI PlaySound32W(LPCWSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
 473 {
 474     LPSTR       pszSoundA;
 475     BOOL32      bSound;
 476
 477     if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) &&
 478                                       !((DWORD)pszSound >> 16)) || !pszSound)) {
 479         pszSoundA = HEAP_strdupWtoA(GetProcessHeap(),0,pszSound);
 480         bSound = PlaySound32A(pszSoundA, hmod, fdwSound);
 481         HeapFree(GetProcessHeap(),0,pszSoundA);
 482     } else
 483         bSound = PlaySound32A((LPCSTR)pszSound, hmod, fdwSound);
 484
 485     return bSound;
 486 }
 487
 488 /**************************************************************************
 489  *                              sndPlaySound            [MMSYSTEM.2]
 490  */
 491 BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
 492 {
 493     PlaySound_SearchMode = 1;
 494     return PlaySound32A(lpszSoundName, 0, uFlags);
 495 }
 496
 497 /**************************************************************************
 498  *                              mmsystemGetVersion      [WINMM.134]
 499  */
 500 UINT32 WINAPI mmsystemGetVersion32()
 501 {
 502     return mmsystemGetVersion16();
 503 }
 504
 505 /**************************************************************************
 506  *                              mmsystemGetVersion      [MMSYSTEM.5]
 507  * return value borrowed from Win95 winmm.dll ;)
 508  */
 509 UINT16 WINAPI mmsystemGetVersion16()
 510 {
 511     TRACE(mmsys, "3.10 (Win95?)\n");
 512     return 0x030a;
 513 }
 514
 515 /**************************************************************************
 516  *                              DriverProc      [MMSYSTEM.6]
 517  */
 518 LRESULT WINAPI DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
 519                           DWORD dwParam1, DWORD dwParam2)
 520 {
 521     return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 522 }
 523
 524 /**************************************************************************
 525  *                              DriverCallback  [MMSYSTEM.31]
 526  */
 527 BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
 528                              WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
 529 {
 530     TRACE(mmsys, "(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
 531           dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
 532
 533     switch (uFlags & DCB_TYPEMASK) {
 534     case DCB_NULL:
 535         TRACE(mmsys, "CALLBACK_NULL !\n");
 536         break;
 537     case DCB_WINDOW:
 538         TRACE(mmsys, "CALLBACK_WINDOW = %04lX handle = %04X!\n",
 539               dwCallBack,hDev);
 540         if (!IsWindow32(dwCallBack) || USER_HEAP_LIN_ADDR(hDev) == NULL)
 541             return FALSE;
 542
 543         PostMessage16((HWND16)dwCallBack, wMsg, hDev, dwParam1);
 544         break;
 545     case DCB_TASK:
 546         TRACE(mmsys, "CALLBACK_TASK !\n");
 547         return FALSE;
 548     case DCB_FUNCTION:
 549         TRACE(mmsys, "CALLBACK_FUNCTION !\n");
 550         Callbacks->CallDriverCallback( (FARPROC16)dwCallBack,
 551                                        hDev, wMsg, dwUser,
 552                                        dwParam1, dwParam2 );
 553         break;
 554     case DCB_FUNC32:
 555         TRACE(mmsys, "CALLBACK_FUNCTION !\n");
 556         ((LPDRVCALLBACK32)dwCallBack)( hDev, wMsg, dwUser,
 557                                        dwParam1, dwParam2 );
 558         break;
 559     default:
 560         WARN(mmsys, "Unknown callback type\n");
 561         break;
 562     }
 563     return TRUE;
 564 }
 565
 566 /**************************************************************************
 567  *      Mixer devices. New to Win95
 568  */
 569 /**************************************************************************
 570  * find out the real mixer ID depending on hmix (depends on dwFlags)
 571  * FIXME: also fix dwInstance passing to mixMessage
 572  */
 573 static UINT32 _get_mixerID_from_handle(HMIXEROBJ32 hmix,DWORD dwFlags) {
 574     /* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix
 575      * accordingly. For now we always use mixerdevice 0.
 576      */
 577     return 0;
 578 }
 579 /**************************************************************************
 580  *                              mixerGetNumDevs         [WINMM.108]
 581  */
 582 UINT32 WINAPI mixerGetNumDevs32()
 583 {
 584     return mixerGetNumDevs16();
 585 }
 586
 587 /**************************************************************************
 588  *                              mixerGetNumDevs
 589  */
 590 UINT16 WINAPI mixerGetNumDevs16()
 591 {
 592     UINT16      count;
 593
 594     count = mixMessage(0,MXDM_GETNUMDEVS,0L,0L,0L);
 595     TRACE(mmaux,"mixerGetNumDevs returns %d\n",count);
 596     return count;
 597 }
 598
 599 /**************************************************************************
 600  *                              mixerGetDevCapsW                [WINMM.102]
 601  */
 602 UINT32 WINAPI mixerGetDevCaps32W(UINT32 devid,LPMIXERCAPS32W mixcaps,UINT32 size)
 603 {
 604     MIXERCAPS16 mic16;
 605     UINT32      ret = mixerGetDevCaps16(devid,&mic16,sizeof(mic16));
 606
 607     mixcaps->wMid = mic16.wMid;
 608     mixcaps->wPid = mic16.wPid;
 609     mixcaps->vDriverVersion = mic16.vDriverVersion;
 610     lstrcpyAtoW(mixcaps->szPname,mic16.szPname);
 611     mixcaps->fdwSupport = mic16.fdwSupport;
 612     mixcaps->cDestinations = mic16.cDestinations;
 613     return ret;
 614 }
 615 /**************************************************************************
 616  *                              mixerGetDevCaps         [WINMM.101]
 617  */
 618 UINT32 WINAPI mixerGetDevCaps32A(UINT32 devid,LPMIXERCAPS32A mixcaps,UINT32 size)
 619 {
 620     MIXERCAPS16 mic16;
 621     UINT32      ret = mixerGetDevCaps16(devid,&mic16,sizeof(mic16));
 622
 623     mixcaps->wMid = mic16.wMid;
 624     mixcaps->wPid = mic16.wPid;
 625     mixcaps->vDriverVersion = mic16.vDriverVersion;
 626     strcpy(mixcaps->szPname,mic16.szPname);
 627     mixcaps->fdwSupport = mic16.fdwSupport;
 628     mixcaps->cDestinations = mic16.cDestinations;
 629     return ret;
 630 }
 631
 632 /**************************************************************************
 633  *                              mixerGetDevCaps
 634  */
 635 UINT16 WINAPI mixerGetDevCaps16(UINT16 devid,LPMIXERCAPS16 mixcaps,UINT16 size)
 636 {
 637     FIXME(mmsys,"should this be a fixme?\n");
 638     return mixMessage(devid,MXDM_GETDEVCAPS,0L,(DWORD)mixcaps,(DWORD)size);
 639 }
 640
 641 /**************************************************************************
 642  *                              mixerOpen               [WINMM.110]
 643  */
 644 UINT32 WINAPI mixerOpen32(LPHMIXER32 lphmix,UINT32 uDeviceID,DWORD dwCallback,
 645                           DWORD dwInstance,DWORD fdwOpen)
 646 {
 647     HMIXER16    hmix16;
 648     UINT32      ret;
 649
 650     FIXME(mmsys,"(%p,%d,%08lx,%08lx,%08lx): semi stub?\n",
 651           lphmix,uDeviceID,dwCallback,dwInstance,fdwOpen);
 652     ret = mixerOpen16(&hmix16,uDeviceID,dwCallback,dwInstance,fdwOpen);
 653     if (lphmix) *lphmix = hmix16;
 654     return ret;
 655 }
 656
 657 /**************************************************************************
 658  *                              mixerOpen
 659  */
 660 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix,UINT16 uDeviceID,DWORD dwCallback,
 661                           DWORD dwInstance,DWORD fdwOpen)
 662 {
 663     HMIXER16            hmix;
 664     LPMIXEROPENDESC     lpmod;
 665     BOOL32              mapperflag = (uDeviceID==0);
 666     DWORD               dwRet;
 667
 668     TRACE(mmsys,"(%p,%d,%08lx,%08lx,%08lx)\n",
 669           lphmix,uDeviceID,dwCallback,dwInstance,fdwOpen);
 670     hmix = USER_HEAP_ALLOC(sizeof(MIXEROPENDESC));
 671     if (lphmix) *lphmix = hmix;
 672     lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
 673     lpmod->hmx = hmix;
 674     lpmod->dwCallback = dwCallback;
 675     lpmod->dwInstance = dwInstance;
 676     if (uDeviceID >= MAXMIXERDRIVERS)
 677         uDeviceID = 0;
 678     while (uDeviceID < MAXMIXERDRIVERS) {
 679         dwRet=mixMessage(uDeviceID,MXDM_OPEN,dwInstance,(DWORD)lpmod,fdwOpen);
 680         if (dwRet == MMSYSERR_NOERROR) break;
 681         if (!mapperflag) break;
 682         uDeviceID++;
 683     }
 684     lpmod->uDeviceID = uDeviceID;
 685     return dwRet;
 686 }
 687
 688 /**************************************************************************
 689  *                              mixerClose              [WINMM.98]
 690  */
 691 UINT32 WINAPI mixerClose32(HMIXER32 hmix)
 692 {
 693     return mixerClose16(hmix);
 694 }
 695
 696 /**************************************************************************
 697  *                              mixerClose
 698  */
 699 UINT16 WINAPI mixerClose16(HMIXER16 hmix)
 700 {
 701     LPMIXEROPENDESC     lpmod;
 702
 703     FIXME(mmsys,"(%04x): semi-stub?\n",hmix);
 704     lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
 705     return mixMessage(lpmod->uDeviceID,MXDM_CLOSE,lpmod->dwInstance,0L,0L);
 706 }
 707
 708 /**************************************************************************
 709  *                              mixerGetID              [WINMM.103]
 710  */
 711 UINT32 WINAPI mixerGetID32(HMIXEROBJ32 hmix,LPUINT32 lpid,DWORD fdwID)
 712 {
 713     UINT16      xid;
 714     UINT32      ret = mixerGetID16(hmix,&xid,fdwID);
 715
 716     if (*lpid) *lpid = xid;
 717     return ret;
 718 }
 719
 720 /**************************************************************************
 721  *                              mixerGetID
 722  */
 723 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix,LPUINT16 lpid,DWORD fdwID)
 724 {
 725     FIXME(mmsys,"(%04x): semi-stub\n",hmix);
 726     return _get_mixerID_from_handle(hmix,fdwID);
 727 }
 728
 729 /**************************************************************************
 730  *                              mixerGetControlDetailsA [WINMM.99]
 731  */
 732 UINT32 WINAPI mixerGetControlDetails32A(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails)
 733 {
 734     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
 735     return MMSYSERR_NOTENABLED;
 736 }
 737
 738 /**************************************************************************
 739  *                              mixerGetControlDetailsW [WINMM.100]
 740  */
 741 UINT32 WINAPI mixerGetControlDetails32W(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails)
 742 {
 743     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",     hmix,lpmcd,fdwDetails);
 744     return MMSYSERR_NOTENABLED;
 745 }
 746
 747 /**************************************************************************
 748  *                              mixerGetControlDetails  [MMSYSTEM.808]
 749  */
 750 UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails)
 751 {
 752     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
 753     return MMSYSERR_NOTENABLED;
 754 }
 755
 756 /**************************************************************************
 757  *                              mixerGetLineControlsA   [WINMM.104]
 758  */
 759 UINT32 WINAPI mixerGetLineControls32A(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32A lpmlc,DWORD fdwControls)
 760 {
 761     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
 762     return MMSYSERR_NOTENABLED;
 763 }
 764
 765 /**************************************************************************
 766  *                              mixerGetLineControlsW   [WINMM.105]
 767  */
 768 UINT32 WINAPI mixerGetLineControls32W(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32W lpmlc,DWORD fdwControls)
 769 {
 770     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
 771     return MMSYSERR_NOTENABLED;
 772 }
 773
 774 /**************************************************************************
 775  *                              mixerGetLineControls    [MMSYSTEM.807]
 776  */
 777 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,LPMIXERLINECONTROLS16 lpmlc,DWORD fdwControls)
 778 {
 779     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
 780     return MMSYSERR_NOTENABLED;
 781 }
 782
 783 /**************************************************************************
 784  *                              mixerGetLineInfoA       [WINMM.106]
 785  */
 786 UINT32 WINAPI mixerGetLineInfo32A(HMIXEROBJ32 hmix,LPMIXERLINE32A lpml,DWORD fdwInfo)
 787 {
 788     MIXERLINE16         ml16;
 789     UINT32              ret;
 790
 791     ml16.dwDestination = lpml->dwDestination;
 792     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpml,fdwInfo);
 793     ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo);
 794     lpml->cbStruct = sizeof(*lpml);
 795     lpml->dwSource = ml16.dwSource;
 796     lpml->dwLineID = ml16.dwLineID;
 797     lpml->fdwLine = ml16.fdwLine;
 798     lpml->dwUser = ml16.dwUser;
 799     lpml->dwComponentType = ml16.dwComponentType;
 800     lpml->cChannels = ml16.cChannels;
 801     lpml->cConnections = ml16.cConnections;
 802     lpml->cControls = ml16.cControls;
 803     strcpy(lpml->szShortName,ml16.szShortName);
 804     strcpy(lpml->szName,ml16.szName);
 805     lpml->Target.dwType = ml16.Target.dwType;
 806     lpml->Target.dwDeviceID = ml16.Target.dwDeviceID;
 807     lpml->Target.wMid = ml16.Target.wMid;
 808     lpml->Target.wPid = ml16.Target.wPid;
 809     lpml->Target.vDriverVersion = ml16.Target.vDriverVersion;
 810     strcpy(lpml->Target.szPname,ml16.Target.szPname);
 811     return ret;
 812 }
 813
 814 /**************************************************************************
 815  *                              mixerGetLineInfoW       [WINMM.107]
 816  */
 817 UINT32 WINAPI mixerGetLineInfo32W(HMIXEROBJ32 hmix,LPMIXERLINE32W lpml,DWORD fdwInfo)
 818 {
 819     MIXERLINE16         ml16;
 820     UINT32              ret;
 821
 822     ml16.dwDestination = lpml->dwDestination;
 823     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpml,fdwInfo);
 824     ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo);
 825     lpml->cbStruct = sizeof(*lpml);
 826     lpml->dwSource = ml16.dwSource;
 827     lpml->dwLineID = ml16.dwLineID;
 828     lpml->fdwLine = ml16.fdwLine;
 829     lpml->dwUser = ml16.dwUser;
 830     lpml->dwComponentType = ml16.dwComponentType;
 831     lpml->cChannels = ml16.cChannels;
 832     lpml->cConnections = ml16.cConnections;
 833     lpml->cControls = ml16.cControls;
 834     lstrcpyAtoW(lpml->szShortName,ml16.szShortName);
 835     lstrcpyAtoW(lpml->szName,ml16.szName);
 836     lpml->Target.dwType = ml16.Target.dwType;
 837     lpml->Target.dwDeviceID = ml16.Target.dwDeviceID;
 838     lpml->Target.wMid = ml16.Target.wMid;
 839     lpml->Target.wPid = ml16.Target.wPid;
 840     lpml->Target.vDriverVersion = ml16.Target.vDriverVersion;
 841     /*lstrcpyAtoW(lpml->Target.szPname,ml16.Target.szPname);*/
 842     return ret;
 843 }
 844
 845 /**************************************************************************
 846  *                              mixerGetLineInfo        [MMSYSTEM.805]
 847  */
 848 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix,LPMIXERLINE16 lpml,DWORD fdwInfo)
 849 {
 850     UINT16 devid =  _get_mixerID_from_handle(hmix,fdwInfo);
 851
 852     FIXME(mmsys,"(%04x,%p[line %08lx],%08lx) - semi-stub?\n",
 853           hmix,lpml,lpml->dwDestination,fdwInfo);
 854     return mixMessage(devid,MXDM_GETLINEINFO,0,(DWORD)lpml,fdwInfo);
 855 }
 856
 857 /**************************************************************************
 858  *                              mixerSetControlDetails  [WINMM.111]
 859  */
 860 UINT32 WINAPI mixerSetControlDetails32(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails)
 861 {
 862     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
 863     return MMSYSERR_NOTENABLED;
 864 }
 865
 866 /**************************************************************************
 867  *                              mixerSetControlDetails  [MMSYSTEM.809]
 868  */
 869 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails)
 870 {
 871     FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
 872     return MMSYSERR_NOTENABLED;
 873 }
 874
 875 /**************************************************************************
 876  *                              mixerMessage            [WINMM.109]
 877  */
 878 UINT32 WINAPI mixerMessage32(HMIXER32 hmix,UINT32 uMsg,DWORD dwParam1,DWORD dwParam2)
 879 {
 880     LPMIXEROPENDESC     lpmod;
 881     UINT16              uDeviceID;
 882
 883     lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
 884     if (lpmod)
 885         uDeviceID = lpmod->uDeviceID;
 886     else
 887         uDeviceID = 0;
 888     FIXME(mmsys,"(%04lx,%d,%08lx,%08lx): semi-stub?\n",
 889           (DWORD)hmix,uMsg,dwParam1,dwParam2);
 890     return mixMessage(uDeviceID,uMsg,0L,dwParam1,dwParam2);
 891 }
 892
 893 /**************************************************************************
 894  *                              mixerMessage            [MMSYSTEM.804]
 895  */
 896 UINT16 WINAPI mixerMessage16(HMIXER16 hmix,UINT16 uMsg,DWORD dwParam1,DWORD dwParam2)
 897 {
 898     LPMIXEROPENDESC     lpmod;
 899     UINT16              uDeviceID;
 900
 901     lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
 902     if (lpmod)
 903         uDeviceID = lpmod->uDeviceID;
 904     else
 905         uDeviceID = 0;
 906     FIXME(mmsys,"(%04x,%d,%08lx,%08lx) - semi-stub?\n",
 907           hmix,uMsg,dwParam1,dwParam2);
 908     return mixMessage(uDeviceID,uMsg,0L,dwParam1,dwParam2);
 909 }
 910
 911 /**************************************************************************
 912  *                              auxGetNumDevs           [WINMM.22]
 913  */
 914 UINT32 WINAPI auxGetNumDevs32()
 915 {
 916     return auxGetNumDevs16();
 917 }
 918
 919 /**************************************************************************
 920  *                              auxGetNumDevs           [MMSYSTEM.350]
 921  */
 922 UINT16 WINAPI auxGetNumDevs16()
 923 {
 924     UINT16      count = 0;
 925     TRACE(mmsys, "auxGetNumDevs !\n");
 926     count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
 927     TRACE(mmsys, "auxGetNumDevs return %u \n", count);
 928     return count;
 929 }
 930
 931 /**************************************************************************
 932  *                              auxGetDevCaps           [WINMM.20]
 933  */
 934 UINT32 WINAPI auxGetDevCaps32W(UINT32 uDeviceID,LPAUXCAPS32W lpCaps,UINT32 uSize)
 935 {
 936     AUXCAPS16   ac16;
 937     UINT32      ret = auxGetDevCaps16(uDeviceID,&ac16,sizeof(ac16));
 938
 939     lpCaps->wMid = ac16.wMid;
 940     lpCaps->wPid = ac16.wPid;
 941     lpCaps->vDriverVersion = ac16.vDriverVersion;
 942     lstrcpyAtoW(lpCaps->szPname,ac16.szPname);
 943     lpCaps->wTechnology = ac16.wTechnology;
 944     lpCaps->dwSupport = ac16.dwSupport;
 945     return ret;
 946 }
 947
 948 /**************************************************************************
 949  *                              auxGetDevCaps           [WINMM.21]
 950  */
 951 UINT32 WINAPI auxGetDevCaps32A(UINT32 uDeviceID,LPAUXCAPS32A lpCaps,UINT32 uSize)
 952 {
 953     AUXCAPS16   ac16;
 954     UINT32      ret = auxGetDevCaps16(uDeviceID,&ac16,sizeof(ac16));
 955
 956     lpCaps->wMid = ac16.wMid;
 957     lpCaps->wPid = ac16.wPid;
 958     lpCaps->vDriverVersion = ac16.vDriverVersion;
 959     strcpy(lpCaps->szPname,ac16.szPname);
 960     lpCaps->wTechnology = ac16.wTechnology;
 961     lpCaps->dwSupport = ac16.dwSupport;
 962     return ret;
 963 }
 964
 965 /**************************************************************************
 966  *                              auxGetDevCaps           [MMSYSTEM.351]
 967  */
 968 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID,LPAUXCAPS16 lpCaps, UINT16 uSize)
 969 {
 970     TRACE(mmsys, "(%04X, %p, %d) !\n",
 971           uDeviceID, lpCaps, uSize);
 972     return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
 973                       0L, (DWORD)lpCaps, (DWORD)uSize);
 974 }
 975
 976 /**************************************************************************
 977  *                              auxGetVolume            [WINM.23]
 978  */
 979 UINT32 WINAPI auxGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
 980 {
 981     return auxGetVolume16(uDeviceID,lpdwVolume);
 982 }
 983
 984 /**************************************************************************
 985  *                              auxGetVolume            [MMSYSTEM.352]
 986  */
 987 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
 988 {
 989     TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume);
 990     return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
 991 }
 992
 993 /**************************************************************************
 994  *                              auxSetVolume            [WINMM.25]
 995  */
 996 UINT32 WINAPI auxSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
 997 {
 998     return auxSetVolume16(uDeviceID,dwVolume);
 999 }
1000
1001 /**************************************************************************
1002  *                              auxSetVolume            [MMSYSTEM.353]
1003  */
1004 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
1005 {
1006     TRACE(mmsys, "(%04X, %08lX) !\n", uDeviceID, dwVolume);
1007     return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
1008 }
1009
1010 /**************************************************************************
1011  *                              auxOutMessage           [MMSYSTEM.354]
1012  */
1013 DWORD WINAPI auxOutMessage32(UINT32 uDeviceID,UINT32 uMessage,DWORD dw1,DWORD dw2)
1014 {
1015     switch (uMessage) {
1016     case AUXDM_GETNUMDEVS:
1017     case AUXDM_GETVOLUME:
1018     case AUXDM_SETVOLUME:
1019         /* no argument conversion needed */
1020         break;
1021     case AUXDM_GETDEVCAPS:
1022         return auxGetDevCaps32A(uDeviceID,(LPAUXCAPS32A)dw1,dw2);
1023     default:
1024         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1025             uDeviceID,uMessage,dw1,dw2);
1026         break;
1027     }
1028     return auxMessage(uDeviceID,uMessage,0L,dw1,dw2);
1029 }
1030
1031 /**************************************************************************
1032  *                              auxOutMessage           [MMSYSTEM.354]
1033  */
1034 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
1035 {
1036     TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
1037           uDeviceID, uMessage, dw1, dw2);
1038     switch (uMessage) {
1039     case AUXDM_GETNUMDEVS:
1040     case AUXDM_SETVOLUME:
1041         /* no argument conversion needed */
1042         break;
1043     case AUXDM_GETVOLUME:
1044         return auxGetVolume16(uDeviceID,(LPDWORD)PTR_SEG_TO_LIN(dw1));
1045     case AUXDM_GETDEVCAPS:
1046         return auxGetDevCaps16(uDeviceID,(LPAUXCAPS16)PTR_SEG_TO_LIN(dw1),dw2);
1047     default:
1048         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1049             uDeviceID,uMessage,dw1,dw2);
1050         break;
1051     }
1052     return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2);
1053 }
1054
1055 /**************************************************************************
1056  *                              mciGetErrorStringW              [WINMM.46]
1057  */
1058 BOOL32 WINAPI mciGetErrorString32W(DWORD wError,LPWSTR lpstrBuffer,UINT32 uLength)
1059 {
1060     LPSTR       bufstr = HeapAlloc(GetProcessHeap(),0,uLength);
1061     BOOL32      ret = mciGetErrorString32A(wError,bufstr,uLength);
1062
1063     lstrcpyAtoW(lpstrBuffer,bufstr);
1064     HeapFree(GetProcessHeap(),0,bufstr);
1065     return ret;
1066 }
1067
1068 /**************************************************************************
1069  *                              mciGetErrorStringA              [WINMM.45]
1070  */
1071 BOOL32 WINAPI mciGetErrorString32A(DWORD wError,LPSTR lpstrBuffer,UINT32 uLength)
1072 {
1073     return mciGetErrorString16(wError,lpstrBuffer,uLength);
1074 }
1075
1076 /**************************************************************************
1077  *                              mciGetErrorString               [MMSYSTEM.706]
1078  */
1079 BOOL16 WINAPI mciGetErrorString16(DWORD wError,LPSTR lpstrBuffer,UINT16 uLength)
1080 {
1081     LPSTR       msgptr;
1082
1083     TRACE(mmsys, "(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength);
1084
1085     if ((lpstrBuffer == NULL) || (uLength < 1))
1086         return(FALSE);
1087     lpstrBuffer[0] = '\0';
1088
1089     switch (wError) {
1090     case MCIERR_INVALID_DEVICE_ID:
1091         msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
1092         break;
1093     case MCIERR_UNRECOGNIZED_KEYWORD:
1094         msgptr = "The driver cannot recognize the specified command parameter.";
1095         break;
1096     case MCIERR_UNRECOGNIZED_COMMAND:
1097         msgptr = "The driver cannot recognize the specified command.";
1098         break;
1099     case MCIERR_HARDWARE:
1100         msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
1101         break;
1102     case MCIERR_INVALID_DEVICE_NAME:
1103         msgptr = "The specified device is not open or is not recognized by MCI.";
1104         break;
1105     case MCIERR_OUT_OF_MEMORY:
1106         msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
1107         break;
1108     case MCIERR_DEVICE_OPEN:
1109         msgptr = "The device name is already being used as an alias by this application. Use a unique alias.";
1110         break;
1111     case MCIERR_CANNOT_LOAD_DRIVER:
1112         msgptr = "There is an undetectable problem in loading the specified device driver.";
1113         break;
1114     case MCIERR_MISSING_COMMAND_STRING:
1115         msgptr = "No command was specified.";
1116         break;
1117     case MCIERR_PARAM_OVERFLOW:
1118         msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
1119         break;
1120     case MCIERR_MISSING_STRING_ARGUMENT:
1121         msgptr = "The specified command requires a character-string parameter. Please provide one.";
1122         break;
1123     case MCIERR_BAD_INTEGER:
1124         msgptr = "The specified integer is invalid for this command.";
1125         break;
1126     case MCIERR_PARSER_INTERNAL:
1127         msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
1128         break;
1129     case MCIERR_DRIVER_INTERNAL:
1130         msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
1131         break;
1132     case MCIERR_MISSING_PARAMETER:
1133         msgptr = "The specified command requires a parameter. Please supply one.";
1134         break;
1135     case MCIERR_UNSUPPORTED_FUNCTION:
1136         msgptr = "The MCI device you are using does not support the specified command.";
1137         break;
1138     case MCIERR_FILE_NOT_FOUND:
1139         msgptr = "Cannot find the specified file. Make sure the path and filename are correct.";
1140         break;
1141     case MCIERR_DEVICE_NOT_READY:
1142         msgptr = "The device driver is not ready.";
1143         break;
1144     case MCIERR_INTERNAL:
1145         msgptr = "A problem occurred in initializing MCI. Try restarting Windows.";
1146         break;
1147     case MCIERR_DRIVER:
1148         msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error.";
1149         break;
1150     case MCIERR_CANNOT_USE_ALL:
1151         msgptr = "Cannot use 'all' as the device name with the specified command.";
1152         break;
1153     case MCIERR_MULTIPLE:
1154         msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
1155         break;
1156     case MCIERR_EXTENSION_NOT_FOUND:
1157         msgptr = "Cannot determine the device type from the given filename extension.";
1158         break;
1159     case MCIERR_OUTOFRANGE:
1160         msgptr = "The specified parameter is out of range for the specified command.";
1161         break;
1162     case MCIERR_FLAGS_NOT_COMPATIBLE:
1163         msgptr = "The specified parameters cannot be used together.";
1164         break;
1165     case MCIERR_FILE_NOT_SAVED:
1166         msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
1167         break;
1168     case MCIERR_DEVICE_TYPE_REQUIRED:
1169         msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
1170         break;
1171     case MCIERR_DEVICE_LOCKED:
1172         msgptr = "The specified device is now being closed. Wait a few seconds, and then try again.";
1173         break;
1174     case MCIERR_DUPLICATE_ALIAS:
1175         msgptr = "The specified alias is already being used in this application. Use a unique alias.";
1176         break;
1177     case MCIERR_BAD_CONSTANT:
1178         msgptr = "The specified parameter is invalid for this command.";
1179         break;
1180     case MCIERR_MUST_USE_SHAREABLE:
1181         msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
1182         break;
1183     case MCIERR_MISSING_DEVICE_NAME:
1184         msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one.";
1185         break;
1186     case MCIERR_BAD_TIME_FORMAT:
1187         msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
1188         break;
1189     case MCIERR_NO_CLOSING_QUOTE:
1190         msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one.";
1191         break;
1192     case MCIERR_DUPLICATE_FLAGS:
1193         msgptr = "A parameter or value was specified twice. Only specify it once.";
1194         break;
1195     case MCIERR_INVALID_FILE:
1196         msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
1197         break;
1198     case MCIERR_NULL_PARAMETER_BLOCK:
1199         msgptr = "A null parameter block was passed to MCI.";
1200         break;
1201     case MCIERR_UNNAMED_RESOURCE:
1202         msgptr = "Cannot save an unnamed file. Supply a filename.";
1203         break;
1204     case MCIERR_NEW_REQUIRES_ALIAS:
1205         msgptr = "You must specify an alias when using the 'new' parameter.";
1206         break;
1207     case MCIERR_NOTIFY_ON_AUTO_OPEN:
1208         msgptr = "Cannot use the 'notify' flag with auto-opened devices.";
1209         break;
1210     case MCIERR_NO_ELEMENT_ALLOWED:
1211         msgptr = "Cannot use a filename with the specified device.";
1212         break;
1213     case MCIERR_NONAPPLICABLE_FUNCTION:
1214         msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
1215         break;
1216     case MCIERR_ILLEGAL_FOR_AUTO_OPEN:
1217         msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
1218         break;
1219     case MCIERR_FILENAME_REQUIRED:
1220         msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
1221         break;
1222     case MCIERR_EXTRA_CHARACTERS:
1223         msgptr = "Cannot specify extra characters after a string enclosed in quotation marks.";
1224         break;
1225     case MCIERR_DEVICE_NOT_INSTALLED:
1226         msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
1227         break;
1228     case MCIERR_GET_CD:
1229         msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
1230         break;
1231     case MCIERR_SET_CD:
1232         msgptr = "Cannot access the specified file or MCI device because the application cannot change directories.";
1233         break;
1234     case MCIERR_SET_DRIVE:
1235         msgptr = "Cannot access specified file or MCI device because the application cannot change drives.";
1236         break;
1237     case MCIERR_DEVICE_LENGTH:
1238         msgptr = "Specify a device or driver name that is less than 79 characters.";
1239         break;
1240     case MCIERR_DEVICE_ORD_LENGTH:
1241         msgptr = "Specify a device or driver name that is less than 69 characters.";
1242         break;
1243     case MCIERR_NO_INTEGER:
1244         msgptr = "The specified command requires an integer parameter. Please provide one.";
1245         break;
1246     case MCIERR_WAVE_OUTPUTSINUSE:
1247         msgptr = "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again.";
1248         break;
1249     case MCIERR_WAVE_SETOUTPUTINUSE:
1250         msgptr = "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again.";
1251         break;
1252     case MCIERR_WAVE_INPUTSINUSE:
1253         msgptr = "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again.";
1254         break;
1255     case MCIERR_WAVE_SETINPUTINUSE:
1256         msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
1257         break;
1258     case MCIERR_WAVE_OUTPUTUNSPECIFIED:
1259         msgptr = "Any compatible waveform playback device may be used.";
1260         break;
1261     case MCIERR_WAVE_INPUTUNSPECIFIED:
1262         msgptr = "Any compatible waveform recording device may be used.";
1263         break;
1264     case MCIERR_WAVE_OUTPUTSUNSUITABLE:
1265         msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
1266         break;
1267     case MCIERR_WAVE_SETOUTPUTUNSUITABLE:
1268         msgptr = "The device you are trying to play to cannot recognize the current file format.";
1269         break;
1270     case MCIERR_WAVE_INPUTSUNSUITABLE:
1271         msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
1272         break;
1273     case MCIERR_WAVE_SETINPUTUNSUITABLE:
1274         msgptr = "The device you are trying to record from cannot recognize the current file format.";
1275         break;
1276     case MCIERR_NO_WINDOW:
1277         msgptr = "There is no display window.";
1278         break;
1279     case MCIERR_CREATEWINDOW:
1280         msgptr = "Could not create or use window.";
1281         break;
1282     case MCIERR_FILE_READ:
1283         msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
1284         break;
1285     case MCIERR_FILE_WRITE:
1286         msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
1287         break;
1288     case MCIERR_SEQ_DIV_INCOMPATIBLE:
1289         msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
1290         break;
1291     case MCIERR_SEQ_NOMIDIPRESENT:
1292         msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
1293         break;
1294     case MCIERR_SEQ_PORT_INUSE:
1295         msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again.";
1296         break;
1297     case MCIERR_SEQ_PORT_MAPNODEVICE:
1298         msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup.";
1299         break;
1300     case MCIERR_SEQ_PORT_MISCERROR:
1301         msgptr = "An error occurred with the specified port.";
1302         break;
1303     case MCIERR_SEQ_PORT_NONEXISTENT:
1304         msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
1305         break;
1306     case MCIERR_SEQ_PORTUNSPECIFIED:
1307         msgptr = "The system doesnot have a current MIDI port specified.";
1308         break;
1309     case MCIERR_SEQ_TIMER:
1310         msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
1311         break;
1312
1313         /*
1314            msg# 513 : vcr
1315            msg# 514 : videodisc
1316            msg# 515 : overlay
1317            msg# 516 : cdaudio
1318            msg# 517 : dat
1319            msg# 518 : scanner
1320            msg# 519 : animation
1321            msg# 520 : digitalvideo
1322            msg# 521 : other
1323            msg# 522 : waveaudio
1324            msg# 523 : sequencer
1325            msg# 524 : not ready
1326            msg# 525 : stopped
1327            msg# 526 : playing
1328            msg# 527 : recording
1329            msg# 528 : seeking
1330            msg# 529 : paused
1331            msg# 530 : open
1332            msg# 531 : false
1333            msg# 532 : true
1334            msg# 533 : milliseconds
1335            msg# 534 : hms
1336            msg# 535 : msf
1337            msg# 536 : frames
1338            msg# 537 : smpte 24
1339            msg# 538 : smpte 25
1340            msg# 539 : smpte 30
1341            msg# 540 : smpte 30 drop
1342            msg# 541 : bytes
1343            msg# 542 : samples
1344            msg# 543 : tmsf
1345         */
1346     default:
1347         msgptr = "Unknown MCI Error !\n";
1348         break;
1349     }
1350     lstrcpyn32A(lpstrBuffer, msgptr, uLength);
1351     TRACE(mmsys, "msg = %s;\n", msgptr);
1352     return TRUE;
1353 }
1354
1355 /**************************************************************************
1356  *                              mciDriverNotify                 [MMSYSTEM.711]
1357  */
1358 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
1359 {
1360     TRACE(mmsys, "(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
1361     if (!IsWindow32(hWndCallBack)) return FALSE;
1362     TRACE(mmsys, "before PostMessage\n");
1363     PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus,
1364                    MAKELONG(wDevID, 0));
1365     return TRUE;
1366 }
1367
1368 /**************************************************************************
1369  *                      mciDriverNotify32                       [WINMM.36]
1370  */
1371 BOOL32 WINAPI mciDriverNotify32(HWND32 hWndCallBack, UINT32 wDevID, UINT32 wStatus)
1372 {
1373     FIXME(mmsys, "stub(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
1374     return FALSE;
1375 }
1376
1377 /**************************************************************************
1378  *                      mciGetDriverData                        [MMSYSTEM.708]
1379  */
1380 DWORD WINAPI mciGetDriverData16(HDRVR16 hdrv)
1381 {
1382     FIXME(mmsys,"(%04x): stub!\n",hdrv);
1383     return 0x42;
1384 }
1385
1386 /**************************************************************************
1387  *                      mciGetDriverData                        [WINMM.44]
1388  */
1389 DWORD WINAPI mciGetDriverData32(HDRVR32 hdrv)
1390 {
1391     FIXME(mmsys,"(%04x): stub!\n",hdrv);
1392     return 0x42;
1393 }
1394
1395 /**************************************************************************
1396  *                      mciSetDriverData                        [MMSYSTEM.707]
1397  */
1398 BOOL16 WINAPI mciSetDriverData16(HDRVR16 hdrv, DWORD data)
1399 {
1400     FIXME(mmsys,"(%04x,%08lx): stub!\n",hdrv,data);
1401     return 0;
1402 }
1403
1404 /**************************************************************************
1405  *                      mciSetDriverData                        [WINMM.53]
1406  */
1407 BOOL32 WINAPI mciSetDriverData32(HDRVR32 hdrv, DWORD data)
1408 {
1409     FIXME(mmsys,"(%04x,%08lx): stub!\n",hdrv,data);
1410         return 0;
1411     }
1412
1413 /**************************************************************************
1414  *                      mciLoadCommandResource                  [MMSYSTEM.705]
1415  */
1416 UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hinst,LPCSTR resname,UINT16 type)
1417 {
1418     char            buf[200];
1419     OFSTRUCT        ofs;
1420     HANDLE16        xhinst;
1421     HRSRC16         hrsrc;
1422     HGLOBAL16       hmem;
1423     LPSTR           segstr;
1424     SEGPTR          xmem;
1425     LPBYTE          lmem;
1426     static UINT16   mcidevtype = 0;
1427
1428     FIXME(mmsys,"(%04x,%s,%d): stub!\n",hinst,resname,type);
1429     if (!lstrcmpi32A(resname,"core")) {
1430         FIXME(mmsys,"(...,\"core\",...), have to use internal tables... (not there yet)\n");
1431         return 0;
1432     }
1433     /* if file exists "resname.mci", then load resource "resname" from it
1434      * otherwise directly from driver
1435      */
1436     strcpy(buf,resname);
1437     strcat(buf,".mci");
1438     if (OpenFile32(buf,&ofs,OF_EXIST)!=HFILE_ERROR32) {
1439         xhinst = LoadLibrary16(buf);
1440         if (xhinst >32)
1441             hinst = xhinst;
1442     } /* else use passed hinst */
1443     segstr = SEGPTR_STRDUP(resname);
1444     hrsrc = FindResource16(hinst,SEGPTR_GET(segstr),type);
1445     SEGPTR_FREE(segstr);
1446     if (!hrsrc) {
1447         WARN(mmsys,"no special commandlist found in resource\n");
1448         return MCI_NO_COMMAND_TABLE;
1449     }
1450     hmem = LoadResource16(hinst,hrsrc);
1451     if (!hmem) {
1452         WARN(mmsys,"couldn't load resource??\n");
1453         return MCI_NO_COMMAND_TABLE;
1454     }
1455     xmem = WIN16_LockResource16(hmem);
1456     if (!xmem) {
1457         WARN(mmsys,"couldn't lock resource??\n");
1458         FreeResource16(hmem);
1459         return MCI_NO_COMMAND_TABLE;
1460     }
1461     lmem = PTR_SEG_TO_LIN(xmem);
1462     TRACE(mmsys,"first resource entry is %s\n",(char*)lmem);
1463     /* parse resource, register stuff, return unique id */
1464     return ++mcidevtype;
1465 }
1466
1467 /**************************************************************************
1468  *                      mciFreeCommandResource                  [MMSYSTEM.713]
1469  */
1470 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
1471 {
1472     FIXME(mci, "(%04x) stub\n", uTable);
1473     return 0;
1474 }
1475
1476 /**************************************************************************
1477  *                      mciFreeCommandResource                  [WINMM.39]
1478  */
1479 BOOL32 WINAPI mciFreeCommandResource32(UINT32 uTable)
1480  {
1481     FIXME(mci, "(%08x) stub\n", uTable);
1482     return 0;
1483  }
1484
1485 /**************************************************************************
1486  *                      mciLoadCommandResource                  [WINMM.48]
1487  */
1488 UINT32 WINAPI mciLoadCommandResource32(HANDLE32 hinst,LPCSTR resname,UINT32 type)
1489 {
1490     return mciLoadCommandResource16(hinst, resname, type);
1491 }
1492
1493 const char* MCI_CommandToString(UINT16 wMsg)
1494 {
1495     static char buffer[100];
1496
1497 #define CASE(s) case (s): return #s
1498
1499     switch (wMsg) {
1500         CASE(MCI_OPEN);
1501         CASE(MCI_CLOSE);
1502         CASE(MCI_ESCAPE);
1503         CASE(MCI_PLAY);
1504         CASE(MCI_SEEK);
1505         CASE(MCI_STOP);
1506         CASE(MCI_PAUSE);
1507         CASE(MCI_INFO);
1508         CASE(MCI_GETDEVCAPS);
1509         CASE(MCI_SPIN);
1510         CASE(MCI_SET);
1511         CASE(MCI_STEP);
1512         CASE(MCI_RECORD);
1513         CASE(MCI_SYSINFO);
1514         CASE(MCI_BREAK);
1515         CASE(MCI_SAVE);
1516         CASE(MCI_STATUS);
1517         CASE(MCI_CUE);
1518         CASE(MCI_REALIZE);
1519         CASE(MCI_WINDOW);
1520         CASE(MCI_PUT);
1521         CASE(MCI_WHERE);
1522         CASE(MCI_FREEZE);
1523         CASE(MCI_UNFREEZE);
1524         CASE(MCI_LOAD);
1525         CASE(MCI_CUT);
1526         CASE(MCI_COPY);
1527         CASE(MCI_PASTE);
1528         CASE(MCI_UPDATE);
1529         CASE(MCI_RESUME);
1530         CASE(MCI_DELETE);
1531     default:
1532         sprintf(buffer, "MCI_<<%04X>>", wMsg);
1533         return buffer;
1534     }
1535 }
1536
1537 /**************************************************************************
1538  *                      MCI_SendCommand32                       [internal]
1539  */
1540 DWORD MCI_SendCommand32(UINT32 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1541 {
1542     DWORD               dwRet = MCIERR_INTERNAL;
1543     MCIPROC32           proc = 0;
1544
1545     if (!MCI_DevIDValid(wDevID))
1546         return MMSYSERR_INVALPARAM;
1547
1548     proc = MCI_GetProc32(MCI_GetDrv(wDevID)->modp.wType);
1549     if (proc) {
1550         dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID,
1551                         MCI_GetDrv(wDevID)->hDrv,
1552                         wMsg, dwParam1, dwParam2);
1553     } else if (MCI_GetDrv(wDevID)->driverProc) {
1554         FIXME(mmsys, "is that correct ?\n");
1555         dwRet = Callbacks->CallDriverProc(MCI_GetDrv(wDevID)->driverProc,
1556                                           MCI_GetDrv(wDevID)->modp.wDeviceID,
1557                                           MCI_GetDrv(wDevID)->hDrv,
1558                                           wMsg, dwParam1, dwParam2);
1559     } else {
1560         WARN(mmsys, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType);
1561     }
1562     return dwRet;
1563 }
1564
1565 /**************************************************************************
1566  *                      MCI_Open                                [internal]
1567  */
1568 static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms)
1569 {
1570     char                str[128];
1571     UINT16              uDevTyp = 0;
1572     UINT16              wDevID = MCI_FirstDevID();
1573     DWORD               dwRet;
1574
1575     TRACE(mmsys, "(%08lX, %p)\n", dwParam, lpParms);
1576     if (lpParms == NULL) return MCIERR_INTERNAL;
1577
1578     if ((dwParam & ~(MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) {
1579         FIXME(mmsys, "unsupported yet dwFlags=%08lX\n",
1580               (dwParam & ~(MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)));
1581     }
1582
1583     while (MCI_GetDrv(wDevID)->modp.wType != 0) {
1584         wDevID = MCI_NextDevID(wDevID);
1585         if (!MCI_DevIDValid(wDevID)) {
1586             TRACE(mmsys, "MAXMCIDRIVERS reached !\n");
1587             return MCIERR_INTERNAL;
1588         }
1589     }
1590
1591     TRACE(mmsys, "wDevID=%04X \n", wDevID);
1592     memcpy(MCI_GetOpenDrv(wDevID), lpParms, sizeof(*lpParms));
1593
1594     if (dwParam & MCI_OPEN_ELEMENT) {
1595         char    *s,*t;
1596
1597         TRACE(mmsys,"lpstrElementName='%s'\n", lpParms->lpstrElementName);
1598         s = lpParms->lpstrElementName;
1599         t = strrchr(s, '.');
1600         if (t) {
1601             GetProfileString32A("mci extensions", t+1, "*", str, sizeof(str));
1602             CharUpper32A(str);
1603             uDevTyp = MCI_GetDevType(str);
1604             if (uDevTyp == 0) {
1605                 if (strcmp(str,"*") == 0) {
1606                 TRACE(mmsys,"No [mci extensions] entry for %s found.\n",t);
1607                 return MCIERR_EXTENSION_NOT_FOUND;
1608                 }
1609 #if testing32
1610                 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
1611                 else  {
1612                 HDRVR16 hdrv = OpenDriver(str, "mci", NULL);
1613                 if (hdrv) {
1614                     HMODULE16   hmod;
1615
1616                     hmod = GetDriverModuleHandle(hdrv);
1617                         MCI_GetDrv(wDevID)->hDrv = hdrv;
1618                         MCI_GetDrv(wDevID)->driverProc = GetProcAddress16(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC")));
1619                     uDevTyp = MCI_DEVTYPE_OTHER;
1620                 } else {
1621                     FIXME(mmsys, "[mci extensions] entry %s for %s not supported.\n",str,t);
1622                     return MCIERR_DEVICE_NOT_INSTALLED;
1623                 }
1624                 }
1625 #endif
1626             }
1627         } else if (GetDriveType32A(s) == DRIVE_CDROM) {
1628             /* FIXME: this will not work if several CDROM drives are installed on the machine */
1629             uDevTyp = MCI_DEVTYPE_CD_AUDIO;
1630         } else {
1631             return MCIERR_EXTENSION_NOT_FOUND;
1632     }
1633     }
1634
1635     if (dwParam & MCI_OPEN_ALIAS) {
1636         TRACE(mmsys, "Alias='%s' !\n", lpParms->lpstrAlias);
1637         /* FIXME is there any memory leak here ? */
1638         MCI_GetOpenDrv(wDevID)->lpstrAlias = strdup(lpParms->lpstrAlias);
1639         /* mplayer does allocate alias to CDAUDIO */
1640     }
1641     if (dwParam & MCI_OPEN_TYPE) {
1642         if (dwParam & MCI_OPEN_TYPE_ID) {
1643             TRACE(mmsys, "Dev=%08lx!\n", (DWORD)lpParms->lpstrDeviceType);
1644             uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType);
1645             MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType;
1646         } else {
1647             if (lpParms->lpstrDeviceType == NULL)
1648                 return MCIERR_INTERNAL;
1649             TRACE(mmsys, "Dev='%s' !\n", lpParms->lpstrDeviceType);
1650             /* FIXME is there any memory leak here ? */
1651             MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType);
1652             strcpy(str, lpParms->lpstrDeviceType);
1653             CharUpper32A(str);
1654             uDevTyp = MCI_GetDevType(str);
1655             if (uDevTyp == 0) {
1656 #if testing32
1657                 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
1658                 HDRVR16 hdrv;
1659                 TRACE(mmsys,"trying to load driver...\n");
1660                 hdrv = OpenDriver(str,"mci",NULL);
1661                 if (hdrv) {
1662                     HMODULE16   hmod;
1663
1664                     hmod = GetDriverModuleHandle(hdrv);
1665                     MCI_GetDrv(wDevID)->hDrv = hdrv;
1666                     MCI_GetDrv(wDevID)->driverProc = GetProcAddress16(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC")));
1667                     uDevTyp = MCI_DEVTYPE_OTHER;
1668                 } else
1669 #endif
1670                     return MCIERR_DEVICE_NOT_INSTALLED;
1671             }
1672         }
1673     }
1674     MCI_GetDrv(wDevID)->modp.wType = uDevTyp;
1675     MCI_GetDrv(wDevID)->modp.wDeviceID = 0;  /* FIXME? for multiple devices */
1676     lpParms->wDeviceID = wDevID;
1677     TRACE(mmsys, "mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
1678           wDevID, uDevTyp, lpParms->wDeviceID);
1679     dwRet = MCI_SendCommand32(wDevID, MCI_OPEN_DRIVER, dwParam, (DWORD)lpParms);
1680
1681     if (dwRet == 0) {
1682         /* only handled devices fall through */
1683         TRACE(mmsys, "wDevID = %04X wDeviceID = %d dwRet = %ld\n",wDevID, lpParms->wDeviceID, dwRet);
1684     } else {
1685         TRACE(mmsys, "failed to open driver (MCI_OPEN_DRIVER msg) [%08lx], closing\n", dwRet);
1686         MCI_GetDrv(wDevID)->modp.wType = 0;
1687     }
1688     if (dwParam & MCI_NOTIFY)
1689         mciDriverNotify16(lpParms->dwCallback, wDevID, dwRet == 0 ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
1690
1691     return dwRet;
1692 }
1693
1694 /**************************************************************************
1695  *                      MCI_Close                               [internal]
1696  */
1697 static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
1698 {
1699     DWORD       dwRet = MCIERR_INTERNAL;
1700
1701     TRACE(mmsys, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
1702
1703     if (wDevID == MCI_ALL_DEVICE_ID) {
1704         FIXME(mmsys, "unhandled MCI_ALL_DEVICE_ID\n");
1705         return MCIERR_CANNOT_USE_ALL;
1706     }
1707
1708     dwRet = MCI_SendCommand32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
1709     MCI_GetDrv(wDevID)->modp.wType = 0;
1710
1711     if (dwParam&MCI_NOTIFY)
1712         mciDriverNotify16(lpParms->dwCallback,wDevID,
1713                         (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
1714
1715     TRACE(mmsys, "returns %ld\n",dwRet);
1716     return dwRet;
1717 }
1718
1719 /**************************************************************************
1720  *                      MCI_WriteString                         [internal]
1721  */
1722 DWORD   MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
1723 {
1724     DWORD       ret;
1725
1726     if (dstSize <= strlen(lpSrcStr)) {
1727         lstrcpyn32A(lpDstStr, lpSrcStr, dstSize - 1);
1728         ret = MCIERR_PARAM_OVERFLOW;
1729     } else {
1730         strcpy(lpDstStr, lpSrcStr);
1731         ret = 0;
1732     }
1733     return ret;
1734 }
1735
1736 /**************************************************************************
1737  *                      MCI_Sysinfo                             [internal]
1738  */
1739 static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lpParms)
1740 {
1741     DWORD       ret = MMSYSERR_INVALPARAM;
1742
1743     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1744
1745     TRACE(mci, "(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
1746           uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
1747
1748     switch (dwFlags & ~MCI_SYSINFO_OPEN) {
1749     case MCI_SYSINFO_QUANTITY:
1750         {
1751             DWORD       cnt = 0;
1752             WORD        i;
1753
1754             if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
1755                 if (dwFlags & MCI_SYSINFO_OPEN) {
1756                     TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1757                     for (i = 0; i < MAXMCIDRIVERS; i++) {
1758                         if (mciDrv[i].modp.wType != 0) cnt++;
1759                     }
1760                 } else {
1761                     TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1762                     cnt = mciInstalledCount;
1763                 }
1764             } else {
1765                 if (dwFlags & MCI_SYSINFO_OPEN) {
1766                     TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType);
1767                     for (i = 0; i < MAXMCIDRIVERS; i++) {
1768                         if (mciDrv[i].modp.wType == lpParms->wDeviceType) cnt++;
1769                     }
1770                 } else {
1771                     TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType);
1772                     FIXME(mci, "Don't know how to get # of MCI devices of a given type\n");
1773                     cnt = 1;
1774                 }
1775             }
1776             *(DWORD*)lpParms->lpstrReturn = cnt;
1777         }
1778         TRACE(mci, "(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
1779         ret = 0;
1780         break;
1781     case MCI_SYSINFO_INSTALLNAME:
1782         TRACE(mci, "MCI_SYSINFO_INSTALLNAME \n");
1783         if (MCI_DevIDValid(uDevID)) {
1784             LPCSTR      str = MCI_GetDevTypeString(MCI_GetDrv(uDevID)->modp.wType);
1785             ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str);
1786         } else {
1787             *lpParms->lpstrReturn = 0;
1788             ret = MCIERR_INVALID_DEVICE_ID;
1789         }
1790         TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
1791         break;
1792     case MCI_SYSINFO_NAME:
1793         TRACE(mci, "MCI_SYSINFO_NAME\n");
1794         if (dwFlags & MCI_SYSINFO_OPEN) {
1795             FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
1796             ret = MMSYSERR_INVALPARAM;
1797         } else if (lpParms->dwNumber > mciInstalledCount) {
1798             ret = MMSYSERR_INVALPARAM;
1799         } else {
1800             DWORD       count = lpParms->dwNumber;
1801             LPSTR       ptr = lpmciInstallNames;
1802
1803             while (--count > 0) ptr += strlen(ptr) + 1;
1804             ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
1805         }
1806         TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
1807         break;
1808     default:
1809         TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags);
1810         ret = MMSYSERR_INVALPARAM;
1811     }
1812     return ret;
1813 }
1814
1815 struct SCA32 {
1816     UINT32      wDevID;
1817     UINT32      wMsg;
1818     DWORD       dwParam1;
1819     DWORD       dwParam2;
1820 };
1821
1822 DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2);
1823
1824 /**************************************************************************
1825  *                              MCI_SCAStarter32                        [internal]
1826  */
1827 static DWORD WINAPI MCI_SCAStarter32(LPVOID arg)
1828 {
1829     struct SCA32*       sca = (struct SCA32*)arg;
1830     DWORD               ret;
1831
1832     TRACE(mci, "In thread before async command (%08x,%s,%08lx,%08lx)\n",
1833           sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
1834     ret = mciSendCommand32A(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
1835     TRACE(mci, "In thread after async command (%08x,%s,%08lx,%08lx)\n",
1836           sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
1837     free(sca);
1838     ExitThread(ret);
1839     WARN(mci, "Should not happen ? what's wrong \n");
1840     /* should not go after this point */
1841     return ret;
1842 }
1843
1844 /**************************************************************************
1845  *                              MCI_SendCommandAsync32          [internal]
1846  */
1847 DWORD MCI_SendCommandAsync32(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2)
1848 {
1849     struct SCA32*       sca = malloc(sizeof(struct SCA32));
1850
1851     if (sca == 0)       return MCIERR_OUT_OF_MEMORY;
1852
1853     sca->wDevID   = wDevID;
1854     sca->wMsg     = wMsg;
1855     sca->dwParam1 = dwParam1;
1856     sca->dwParam2 = dwParam2;
1857
1858     if (CreateThread(NULL, 0, MCI_SCAStarter32, sca, 0, NULL) == 0) {
1859         WARN(mci, "Couldn't allocate thread for async command handling, sending synchonously\n");
1860         return MCI_SCAStarter32(&sca);
1861     }
1862     return 0;
1863 }
1864
1865 /**************************************************************************
1866  *                      MCI_MapMsg16To32A                       [internal]
1867  */
1868 int     MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1869 {
1870     if (*lParam == 0)
1871         return 0;
1872     /* FIXME: to add also (with seg/linear modifications to do):
1873      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1874      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO, MCI_WINDOW
1875      */
1876     switch (wMsg) {
1877         /* case MCI_CAPTURE */
1878     case MCI_CLOSE:
1879     case MCI_CLOSE_DRIVER:
1880         /* case MCI_CONFIGURE:*/
1881     case MCI_COPY:
1882     case MCI_CUE:
1883     case MCI_CUT:
1884     case MCI_DELETE:
1885     case MCI_FREEZE:
1886     case MCI_GETDEVCAPS:
1887         /* case MCI_INDEX: */
1888         /* case MCI_MARK: */
1889         /* case MCI_MONITOR: */
1890     case MCI_PASTE:
1891     case MCI_PAUSE:
1892     case MCI_PLAY:
1893     case MCI_PUT:
1894     case MCI_REALIZE:
1895     case MCI_RECORD:
1896     case MCI_RESUME:
1897     case MCI_SEEK:
1898     case MCI_SET:
1899         /* case MCI_SETTIMECODE:*/
1900         /* case MCI_SIGNAL:*/
1901     case MCI_SPIN:
1902     case MCI_STATUS:            /* FIXME: is wrong for digital video */
1903     case MCI_STEP:
1904     case MCI_STOP:
1905         /* case MCI_UNDO: */
1906     case MCI_UNFREEZE:
1907     case MCI_UPDATE:
1908     case MCI_WHERE:
1909         *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
1910         return 0;
1911     case MCI_BREAK:
1912         {
1913             LPMCI_BREAK_PARMS32         mbp32 = HeapAlloc(SystemHeap, 0, sizeof(MCI_BREAK_PARMS32));
1914             LPMCI_BREAK_PARMS16         mbp16  = PTR_SEG_TO_LIN(*lParam);
1915
1916             if (mbp32) {
1917                 mbp32->dwCallback = mbp16->dwCallback;
1918                 mbp32->nVirtKey = mbp16->nVirtKey;
1919                 mbp32->hwndBreak = mbp16->hwndBreak;
1920             } else {
1921                 return -2;
1922             }
1923             *lParam = (DWORD)mbp32;
1924         }
1925         return 1;
1926     case MCI_ESCAPE:
1927         {
1928             LPMCI_VD_ESCAPE_PARMS32A    mvep32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_VD_ESCAPE_PARMS32A));
1929             LPMCI_VD_ESCAPE_PARMS16     mvep16  = PTR_SEG_TO_LIN(*lParam);
1930
1931             if (mvep32a) {
1932                 mvep32a->dwCallback       = mvep16->dwCallback;
1933                 mvep32a->lpstrCommand     = PTR_SEG_TO_LIN(mvep16->lpstrCommand);
1934             } else {
1935                 return -2;
1936             }
1937             *lParam = (DWORD)mvep32a;
1938         }
1939         return 1;
1940     case MCI_INFO:
1941         {
1942             LPMCI_INFO_PARMS32A mip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_INFO_PARMS32A));
1943             LPMCI_INFO_PARMS16  mip16  = PTR_SEG_TO_LIN(*lParam);
1944
1945             /* FIXME this is wrong if device is of type
1946              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1947              */
1948             if (mip32a) {
1949                 mip32a->dwCallback  = mip16->dwCallback;
1950                 mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn);
1951                 mip32a->dwRetSize   = mip16->dwRetSize;
1952             } else {
1953                 return -2;
1954             }
1955             *lParam = (DWORD)mip32a;
1956         }
1957         return 1;
1958     case MCI_OPEN:
1959     case MCI_OPEN_DRIVER:
1960         {
1961             LPMCI_OPEN_PARMS32A mop32a = HeapAlloc(SystemHeap, 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMS32A) + 2 * sizeof(DWORD));
1962             LPMCI_OPEN_PARMS16  mop16  = PTR_SEG_TO_LIN(*lParam);
1963
1964             if (mop32a) {
1965                 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1966                 mop32a = (LPMCI_OPEN_PARMS32A)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
1967                 mop32a->dwCallback       = mop16->dwCallback;
1968                 mop32a->wDeviceID        = mop16->wDeviceID;
1969                 mop32a->lpstrDeviceType  = PTR_SEG_TO_LIN(mop16->lpstrDeviceType);
1970                 mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName);
1971                 mop32a->lpstrAlias       = PTR_SEG_TO_LIN(mop16->lpstrAlias);
1972                 /* copy extended information if any...
1973                  * FIXME: this may seg fault if initial structure does not contain them and
1974                  * the reads after msip16 fail under LDT limits...
1975                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1976                  * should not take care of extended parameters, and should be used by MCI_Open
1977                  * to fetch uDevTyp. When, this is known, the mapping for sending the
1978                  * MCI_OPEN_DRIVER shall be done depending on uDevTyp.
1979                  */
1980                 ((DWORD*)(mop32a + 1))[0] = ((DWORD*)(mop16 + 1))[0];
1981                 ((DWORD*)(mop32a + 1))[1] = ((DWORD*)(mop16 + 1))[1];
1982             } else {
1983                 return -2;
1984             }
1985             *lParam = (DWORD)mop32a;
1986         }
1987         return 1;
1988     case MCI_SYSINFO:
1989         {
1990             LPMCI_SYSINFO_PARMS32A      msip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_SYSINFO_PARMS32A));
1991             LPMCI_SYSINFO_PARMS16       msip16  = PTR_SEG_TO_LIN(*lParam);
1992
1993             if (msip32a) {
1994                 msip32a->dwCallback       = msip16->dwCallback;
1995                 msip32a->lpstrReturn      = PTR_SEG_TO_LIN(msip16->lpstrReturn);
1996                 msip32a->dwRetSize        = msip16->dwRetSize;
1997                 msip32a->dwNumber         = msip16->dwNumber;
1998                 msip32a->wDeviceType      = msip16->wDeviceType;
1999             } else {
2000                 return -2;
2001             }
2002             *lParam = (DWORD)msip32a;
2003         }
2004         return 1;
2005     default:
2006         WARN(mci, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg));
2007     }
2008     return -1;
2009 }
2010
2011 /**************************************************************************
2012  *                      MCI_UnMapMsg16To32A                     [internal]
2013  */
2014 int     MCI_UnMapMsg16To32A(WORD uDevTyp, WORD wMsg, DWORD lParam)
2015 {
2016     switch (wMsg) {
2017         /* case MCI_CAPTURE */
2018     case MCI_CLOSE:
2019     case MCI_CLOSE_DRIVER:
2020         /* case MCI_CONFIGURE:*/
2021     case MCI_COPY:
2022     case MCI_CUE:
2023     case MCI_CUT:
2024     case MCI_DELETE:
2025     case MCI_FREEZE:
2026     case MCI_GETDEVCAPS:
2027         /* case MCI_INDEX: */
2028         /* case MCI_MARK: */
2029         /* case MCI_MONITOR: */
2030     case MCI_PASTE:
2031     case MCI_PAUSE:
2032     case MCI_PLAY:
2033     case MCI_PUT:
2034     case MCI_REALIZE:
2035     case MCI_RECORD:
2036     case MCI_RESUME:
2037     case MCI_SEEK:
2038     case MCI_SET:
2039         /* case MCI_SETTIMECODE:*/
2040         /* case MCI_SIGNAL:*/
2041     case MCI_SPIN:
2042     case MCI_STATUS:
2043     case MCI_STEP:
2044     case MCI_STOP:
2045         /* case MCI_UNDO: */
2046     case MCI_UNFREEZE:
2047     case MCI_UPDATE:
2048     case MCI_WHERE:
2049         return 0;
2050
2051     case MCI_BREAK:
2052     case MCI_ESCAPE:
2053     case MCI_INFO:
2054     case MCI_SYSINFO:
2055         HeapFree(SystemHeap, 0, (LPVOID)lParam);
2056         return 0;
2057     case MCI_OPEN:
2058     case MCI_OPEN_DRIVER:
2059         {
2060             LPMCI_OPEN_PARMS32A mop32a = (MCI_OPEN_PARMS32A*)lParam;
2061             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16*));
2062
2063             mop16->wDeviceID = mop32a->wDeviceID;
2064         }
2065         HeapFree(SystemHeap, 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16)));
2066         return 0;
2067     default:
2068         FIXME(mci, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg));
2069     }
2070     return -1;
2071 }
2072
2073 /**************************************************************************
2074  *                              mciSendCommandA                 [WINMM.49]
2075  */
2076 DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2)
2077         {
2078     TRACE(mci, "(%08x,%s,%08lx,%08lx)\n", wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
2079
2080     switch (wMsg) {
2081     case MCI_OPEN:
2082         return MCI_Open(dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2);
2083     case MCI_CLOSE:
2084         return MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2085     case MCI_SYSINFO:
2086         return MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMS32A)dwParam2);
2087     default:
2088             if (wDevID == MCI_ALL_DEVICE_ID) {
2089                 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
2090                 return MCIERR_CANNOT_USE_ALL;
2091             }
2092
2093         return MCI_SendCommand32(wDevID, wMsg, dwParam1, dwParam2);
2094         }
2095     }
2096
2097 /**************************************************************************
2098  *                              mciSendCommandW                 [WINMM.50]
2099  */
2100 DWORD WINAPI mciSendCommand32W(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2)
2101 {
2102     return 0x1; /* !ok */
2103 }
2104
2105 /**************************************************************************
2106  *                              mciSendCommand                  [MMSYSTEM.701]
2107  */
2108 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1,
2109                             DWORD dwParam2)
2110 {
2111     DWORD       dwRet = MCIERR_INTERNAL;
2112
2113     TRACE(mmsys, "(%04X, %s, %08lX, %08lX)\n",
2114           wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
2115
2116     switch (wMsg) {
2117     case MCI_OPEN:
2118         if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
2119             dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2);
2120             MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
2121         }
2122         break;
2123     case MCI_CLOSE:
2124         if (wDevID == MCI_ALL_DEVICE_ID) {
2125             FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
2126             dwRet = MCIERR_CANNOT_USE_ALL;
2127         } else if (!MCI_DevIDValid(wDevID)) {
2128             dwRet = MMSYSERR_INVALPARAM;
2129         } else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
2130             dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2131             MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
2132         }
2133         break;
2134     case MCI_SYSINFO:
2135         if (MCI_MapMsg16To32A(0, wDevID, &dwParam2) >= 0) {
2136             dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMS32A)dwParam2);
2137             MCI_UnMapMsg16To32A(0, wDevID, dwParam2);
2138         }
2139         break;
2140     default:
2141             if (wDevID == MCI_ALL_DEVICE_ID) {
2142                 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
2143             dwRet = MCIERR_CANNOT_USE_ALL;
2144         } else if (!MCI_DevIDValid(wDevID)) {
2145             dwRet = MMSYSERR_INVALPARAM;
2146         } else {
2147             int                 res;
2148
2149             switch (res = MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) {
2150             case -1:
2151                 TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg));
2152                 break;
2153             case -2:
2154                 TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg));
2155             case 0:
2156             case 1:
2157                 dwRet = MCI_SendCommand32(wDevID, wMsg, dwParam1, dwParam2);
2158                 if (res)
2159                     MCI_UnMapMsg16To32A(MCI_DEVTYPE_SEQUENCER, wMsg, dwParam2);
2160                 break;
2161             }
2162         }
2163     }
2164     return dwRet;
2165             }
2166
2167 /**************************************************************************
2168  *                              mciGetDeviceID                  [MMSYSTEM.703]
2169  */
2170 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
2171 {
2172     UINT16      wDevID;
2173
2174     TRACE(mmsys, "(\"%s\")\n", lpstrName);
2175
2176     if (!lpstrName)
2177         return 0;
2178
2179     if (!lstrcmpi32A(lpstrName, "ALL"))
2180         return MCI_ALL_DEVICE_ID;
2181
2182     wDevID = MCI_FirstDevID();
2183     while (MCI_DevIDValid(wDevID) && MCI_GetDrv(wDevID)->modp.wType) {
2184         if (MCI_GetOpenDrv(wDevID)->lpstrDeviceType && strcmp(MCI_GetOpenDrv(wDevID)->lpstrDeviceType, lpstrName) == 0)
2185             return wDevID;
2186
2187         if (MCI_GetOpenDrv(wDevID)->lpstrAlias && strcmp(MCI_GetOpenDrv(wDevID)->lpstrAlias, lpstrName) == 0)
2188             return wDevID;
2189
2190         wDevID = MCI_NextDevID(wDevID);
2191             }
2192
2193     return 0;
2194             }
2195
2196 /**************************************************************************
2197  *                              mciGetDeviceIDA                 [WINMM.41]
2198  */
2199 UINT32 WINAPI mciGetDeviceID32A(LPCSTR lpstrName)
2200 {
2201     return mciGetDeviceID16(lpstrName);
2202         }
2203
2204 /**************************************************************************
2205  *                              mciGetDeviceIDW                 [WINMM.43]
2206  */
2207 UINT32 WINAPI mciGetDeviceID32W(LPCWSTR lpwstrName)
2208 {
2209     LPSTR       lpstrName;
2210     UINT32      ret;
2211
2212     lpstrName = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName);
2213     ret = mciGetDeviceID16(lpstrName);
2214     HeapFree(GetProcessHeap(), 0, lpstrName);
2215     return ret;
2216     }
2217
2218 /**************************************************************************
2219  *                              mciSetYieldProc                 [MMSYSTEM.714]
2220  */
2221 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID,
2222                                 YIELDPROC fpYieldProc, DWORD dwYieldData)
2223 {
2224     FIXME(mci, "(%u, %p, %08lx) stub\n", uDeviceID, fpYieldProc, dwYieldData);
2225     return FALSE;
2226 }
2227
2228 /**************************************************************************
2229  *                              mciSetYieldProc                 [WINMM.54]
2230  */
2231 BOOL32 WINAPI mciSetYieldProc32(UINT32 uDeviceID,
2232                                 YIELDPROC fpYieldProc, DWORD dwYieldData)
2233 {
2234     FIXME(mci, "(%u, %p, %08lx) stub\n", uDeviceID, fpYieldProc, dwYieldData);
2235     return FALSE;
2236 }
2237
2238 /**************************************************************************
2239  *                              mciGetDeviceIDFromElementID     [MMSYSTEM.715]
2240  */
2241 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
2242 {
2243     FIXME(mci, "(%lu, %s) stub\n", dwElementID, lpstrType);
2244         return 0;
2245 }
2246
2247 /**************************************************************************
2248  *                              mciGetDeviceIDFromElementIDW    [WINMM.42]
2249  */
2250 UINT32 WINAPI mciGetDeviceIDFromElementID32W(DWORD dwElementID, LPCWSTR lpstrType)
2251 {
2252     /* FIXME: that's rather strange, there is no
2253      * mciGetDeviceIDFromElementID32A in winmm.spec
2254      */
2255     FIXME(mci, "(%lu, %p) stub\n", dwElementID, lpstrType);
2256     return 0;
2257 }
2258
2259 /**************************************************************************
2260  *                              mciGetYieldProc                 [MMSYSTEM.716]
2261  */
2262 YIELDPROC WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
2263 {
2264     FIXME(mci, "(%u, %p) stub\n", uDeviceID, lpdwYieldData);
2265     return NULL;
2266     }
2267
2268 /**************************************************************************
2269  *                              mciGetYieldProc                 [WINMM.47]
2270  */
2271 YIELDPROC WINAPI mciGetYieldProc32(UINT32 uDeviceID, DWORD* lpdwYieldData)
2272 {
2273     FIXME(mci, "(%u, %p) stub\n", uDeviceID, lpdwYieldData);
2274     return NULL;
2275 }
2276
2277 /**************************************************************************
2278  *                              mciGetCreatorTask               [MMSYSTEM.717]
2279  */
2280 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
2281 {
2282     FIXME(mci, "(%u) stub\n", uDeviceID);
2283     return 0;
2284 }
2285
2286 /**************************************************************************
2287  *                              mciGetCreatorTask               [WINMM.40]
2288  */
2289 HTASK32 WINAPI mciGetCreatorTask32(UINT32 uDeviceID)
2290 {
2291     FIXME(mci, "(%u) stub\n", uDeviceID);
2292     return 0;
2293 }
2294
2295 /**************************************************************************
2296  *                              mciDriverYield                  [MMSYSTEM.710]
2297  */
2298 UINT16 WINAPI mciDriverYield16(HANDLE16 hnd)
2299 {
2300     FIXME(mmsys,"(%04x): stub!\n",hnd);
2301     return 0;
2302 }
2303
2304 /**************************************************************************
2305  *                      mciDriverYield                          [WINMM.37]
2306  */
2307 UINT32 WINAPI mciDriverYield32(HANDLE32 hnd)
2308 {
2309     FIXME(mmsys,"(%04x): stub!\n",hnd);
2310     return 0;
2311 }
2312
2313 /**************************************************************************
2314  *                              midiOutGetNumDevs       [WINMM.80]
2315  */
2316 UINT32 WINAPI midiOutGetNumDevs32(void)
2317 {
2318     return midiOutGetNumDevs16();
2319 }
2320
2321 /**************************************************************************
2322  *                              midiOutGetNumDevs       [MMSYSTEM.201]
2323  */
2324 UINT16 WINAPI midiOutGetNumDevs16(void)
2325 {
2326     UINT16      count = modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
2327     TRACE(mmsys, "returns %u\n", count);
2328     return count;
2329 }
2330
2331 /**************************************************************************
2332  *                              midiOutGetDevCapsW      [WINMM.76]
2333  */
2334 UINT32 WINAPI midiOutGetDevCaps32W(UINT32 uDeviceID,LPMIDIOUTCAPS32W lpCaps, UINT32 uSize)
2335 {
2336     MIDIOUTCAPS16       moc16;
2337     UINT32              ret;
2338
2339     ret = midiOutGetDevCaps16(uDeviceID,&moc16,sizeof(moc16));
2340     lpCaps->wMid                = moc16.wMid;
2341     lpCaps->wPid                = moc16.wPid;
2342     lpCaps->vDriverVersion      = moc16.vDriverVersion;
2343     lstrcpyAtoW(lpCaps->szPname,moc16.szPname);
2344     lpCaps->wTechnology = moc16.wTechnology;
2345     lpCaps->wVoices             = moc16.wVoices;
2346     lpCaps->wNotes              = moc16.wNotes;
2347     lpCaps->wChannelMask        = moc16.wChannelMask;
2348     lpCaps->dwSupport   = moc16.dwSupport;
2349     return ret;
2350 }
2351 /**************************************************************************
2352  *                              midiOutGetDevCapsA      [WINMM.75]
2353  */
2354 UINT32 WINAPI midiOutGetDevCaps32A(UINT32 uDeviceID,LPMIDIOUTCAPS32A lpCaps, UINT32 uSize)
2355 {
2356     MIDIOUTCAPS16       moc16;
2357     UINT32              ret;
2358
2359     ret = midiOutGetDevCaps16(uDeviceID,&moc16,sizeof(moc16));
2360     lpCaps->wMid                = moc16.wMid;
2361     lpCaps->wPid                = moc16.wPid;
2362     lpCaps->vDriverVersion      = moc16.vDriverVersion;
2363     strcpy(lpCaps->szPname,moc16.szPname);
2364     lpCaps->wTechnology = moc16.wTechnology;
2365     lpCaps->wVoices             = moc16.wVoices;
2366     lpCaps->wNotes              = moc16.wNotes;
2367     lpCaps->wChannelMask        = moc16.wChannelMask;
2368     lpCaps->dwSupport   = moc16.dwSupport;
2369     return ret;
2370 }
2371
2372 /**************************************************************************
2373  *                              midiOutGetDevCaps       [MMSYSTEM.202]
2374  */
2375 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID,LPMIDIOUTCAPS16 lpCaps, UINT16 uSize)
2376 {
2377     TRACE(mmsys, "midiOutGetDevCaps\n");
2378     return modMessage(uDeviceID,MODM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);
2379 }
2380
2381 /**************************************************************************
2382  *                              midiOutGetErrorTextA    [WINMM.77]
2383  */
2384 UINT32 WINAPI midiOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2385 {
2386     TRACE(mmsys, "midiOutGetErrorText\n");
2387     return midiGetErrorText(uError, lpText, uSize);
2388 }
2389
2390 /**************************************************************************
2391  *                              midiOutGetErrorTextW    [WINMM.78]
2392  */
2393 UINT32 WINAPI midiOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2394 {
2395     LPSTR       xstr = HeapAlloc(GetProcessHeap(),0,uSize);
2396     UINT32      ret;
2397
2398     TRACE(mmsys, "midiOutGetErrorText\n");
2399     ret = midiGetErrorText(uError, xstr, uSize);
2400     lstrcpyAtoW(lpText,xstr);
2401     HeapFree(GetProcessHeap(),0,xstr);
2402     return ret;
2403 }
2404
2405 /**************************************************************************
2406  *                              midiOutGetErrorText     [MMSYSTEM.203]
2407  */
2408 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2409 {
2410     TRACE(mmsys, "midiOutGetErrorText\n");
2411     return midiGetErrorText(uError, lpText, uSize);
2412 }
2413
2414 /**************************************************************************
2415  *                              midiGetErrorText        [internal]
2416  */
2417 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
2418 {
2419     LPSTR       msgptr;
2420     if ((lpText == NULL) || (uSize < 1)) return(FALSE);
2421     lpText[0] = '\0';
2422     switch (uError) {
2423     case MIDIERR_UNPREPARED:
2424         msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
2425         break;
2426     case MIDIERR_STILLPLAYING:
2427         msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
2428         break;
2429     case MIDIERR_NOMAP:
2430         msgptr = "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing.";
2431         break;
2432     case MIDIERR_NOTREADY:
2433         msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
2434         break;
2435     case MIDIERR_NODEVICE:
2436         msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.";
2437         break;
2438     case MIDIERR_INVALIDSETUP:
2439         msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
2440         break;
2441         /*
2442           msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
2443           msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
2444           msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
2445           msg# 339 : The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.
2446           msg# 340 : An error occurred using the specified port.
2447           msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
2448           msg# 342 : There is no current MIDI port.
2449           msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
2450         */
2451     default:
2452         msgptr = "Unknown MIDI Error !\n";
2453         break;
2454     }
2455     lstrcpyn32A(lpText, msgptr, uSize);
2456     return TRUE;
2457 }
2458
2459 /**************************************************************************
2460  *                              midiOutOpen             [WINM.84]
2461  */
2462 UINT32 WINAPI midiOutOpen32(HMIDIOUT32 * lphMidiOut, UINT32 uDeviceID,
2463                             DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2464 {
2465     HMIDIOUT16  hmo16;
2466     UINT32      ret;
2467
2468     ret = midiOutOpen16(&hmo16,uDeviceID,dwCallback,dwInstance,
2469                         CALLBACK32CONV(dwFlags));
2470     if (lphMidiOut) *lphMidiOut = hmo16;
2471     return ret;
2472 }
2473
2474 /**************************************************************************
2475  *                              midiOutOpen             [MMSYSTEM.204]
2476  */
2477 UINT16 WINAPI midiOutOpen16(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
2478                             DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2479 {
2480     HMIDI16                     hMidiOut;
2481     LPMIDIOPENDESC              lpDesc;
2482     DWORD                       dwRet = 0;
2483     BOOL32                      bMapperFlg = FALSE;
2484
2485     if (lphMidiOut != NULL) *lphMidiOut = 0;
2486     TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
2487           lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
2488     if (uDeviceID == (UINT16)MIDI_MAPPER) {
2489         TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
2490         bMapperFlg = TRUE;
2491         uDeviceID = 0;
2492     }
2493     hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
2494     if (lphMidiOut != NULL)
2495         *lphMidiOut = hMidiOut;
2496     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2497     if (lpDesc == NULL)
2498         return MMSYSERR_NOMEM;
2499     lpDesc->hMidi = hMidiOut;
2500     lpDesc->dwCallback = dwCallback;
2501     lpDesc->dwInstance = dwInstance;
2502
2503     while (uDeviceID < MAXMIDIDRIVERS) {
2504         dwRet = modMessage(uDeviceID, MODM_OPEN,
2505                            lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2506         if (dwRet == MMSYSERR_NOERROR) break;
2507         if (!bMapperFlg) break;
2508         uDeviceID++;
2509         TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
2510     }
2511     lpDesc->wDevID = uDeviceID;
2512     return dwRet;
2513 }
2514
2515 /**************************************************************************
2516  *                              midiOutClose            [WINMM.74]
2517  */
2518 UINT32 WINAPI midiOutClose32(HMIDIOUT32 hMidiOut)
2519 {
2520     return midiOutClose16(hMidiOut);
2521 }
2522
2523 /**************************************************************************
2524  *                              midiOutClose            [MMSYSTEM.205]
2525  */
2526 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
2527 {
2528     LPMIDIOPENDESC      lpDesc;
2529
2530     TRACE(mmsys, "(%04X)\n", hMidiOut);
2531
2532     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2533     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2534     return modMessage(lpDesc->wDevID, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2535 }
2536
2537 /**************************************************************************
2538  *                              midiOutPrepareHeader    [WINMM.85]
2539  */
2540 UINT32 WINAPI midiOutPrepareHeader32(HMIDIOUT32 hMidiOut,
2541                                      MIDIHDR * lpMidiOutHdr, UINT32 uSize)
2542 {
2543     LPMIDIOPENDESC      lpDesc;
2544
2545     TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2546
2547     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2548     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2549     lpMidiOutHdr->reserved = (DWORD)lpMidiOutHdr->lpData;
2550     return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance,
2551                       (DWORD)lpMidiOutHdr, (DWORD)uSize);
2552 }
2553
2554 /**************************************************************************
2555  *                              midiOutPrepareHeader    [MMSYSTEM.206]
2556  */
2557 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,
2558                                      MIDIHDR * lpMidiOutHdr, UINT16 uSize)
2559 {
2560     LPMIDIOPENDESC      lpDesc;
2561
2562     TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2563
2564     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2565     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2566     lpMidiOutHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiOutHdr->lpData);
2567     return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance,
2568                       (DWORD)lpMidiOutHdr, (DWORD)uSize);
2569 }
2570
2571 /**************************************************************************
2572  *                              midiOutUnprepareHeader  [WINMM.89]
2573  */
2574 UINT32 WINAPI midiOutUnprepareHeader32(HMIDIOUT32 hMidiOut,
2575                                        MIDIHDR * lpMidiOutHdr, UINT32 uSize)
2576 {
2577     return midiOutUnprepareHeader16(hMidiOut,lpMidiOutHdr,uSize);
2578 }
2579
2580 /**************************************************************************
2581  *                              midiOutUnprepareHeader  [MMSYSTEM.207]
2582  */
2583 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,
2584                                        MIDIHDR * lpMidiOutHdr, UINT16 uSize)
2585 {
2586     LPMIDIOPENDESC      lpDesc;
2587
2588     TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2589
2590     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2591     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2592     return modMessage(lpDesc->wDevID, MODM_UNPREPARE, lpDesc->dwInstance,
2593                       (DWORD)lpMidiOutHdr, (DWORD)uSize);
2594 }
2595
2596 /**************************************************************************
2597  *                              midiOutShortMsg         [WINMM.88]
2598  */
2599 UINT32 WINAPI midiOutShortMsg32(HMIDIOUT32 hMidiOut, DWORD dwMsg)
2600 {
2601     return midiOutShortMsg16(hMidiOut,dwMsg);
2602 }
2603
2604 /**************************************************************************
2605  *                              midiOutShortMsg         [MMSYSTEM.208]
2606  */
2607 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
2608 {
2609     LPMIDIOPENDESC      lpDesc;
2610
2611     TRACE(mmsys, "(%04X, %08lX)\n", hMidiOut, dwMsg);
2612
2613     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2614     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2615     return modMessage(lpDesc->wDevID, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
2616 }
2617
2618 /**************************************************************************
2619  *                              midiOutLongMsg          [WINMM.82]
2620  */
2621 UINT32 WINAPI midiOutLongMsg32(HMIDIOUT32 hMidiOut,
2622                                MIDIHDR * lpMidiOutHdr, UINT32 uSize)
2623 {
2624     return midiOutLongMsg16(hMidiOut,lpMidiOutHdr,uSize);
2625 }
2626
2627 /**************************************************************************
2628  *                              midiOutLongMsg          [MMSYSTEM.209]
2629  */
2630 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,
2631                                MIDIHDR * lpMidiOutHdr, UINT16 uSize)
2632 {
2633     LPMIDIOPENDESC      lpDesc;
2634
2635     TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2636
2637     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2638     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2639     return modMessage(lpDesc->wDevID, MODM_LONGDATA, lpDesc->dwInstance,
2640                       (DWORD)lpMidiOutHdr, (DWORD)uSize);
2641 }
2642
2643 /**************************************************************************
2644  *                              midiOutReset            [WINMM.86]
2645  */
2646 UINT32 WINAPI midiOutReset32(HMIDIOUT32 hMidiOut)
2647 {
2648     return midiOutReset16(hMidiOut);
2649 }
2650
2651 /**************************************************************************
2652  *                              midiOutReset            [MMSYSTEM.210]
2653  */
2654 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
2655 {
2656     LPMIDIOPENDESC      lpDesc;
2657
2658     TRACE(mmsys, "(%04X)\n", hMidiOut);
2659
2660     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2661     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2662     return modMessage(lpDesc->wDevID, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
2663 }
2664
2665 /**************************************************************************
2666  *                              midiOutGetVolume        [WINM.81]
2667  */
2668 UINT32 WINAPI midiOutGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
2669 {
2670     return midiOutGetVolume16(uDeviceID,lpdwVolume);
2671 }
2672 /**************************************************************************
2673  *                              midiOutGetVolume        [MMSYSTEM.211]
2674  */
2675 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
2676 {
2677     TRACE(mmsys, "(%04X, %p);\n", uDeviceID, lpdwVolume);
2678     return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
2679 }
2680
2681 /**************************************************************************
2682  *                              midiOutSetVolume        [WINMM.87]
2683  */
2684 UINT32 WINAPI midiOutSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
2685 {
2686     return midiOutSetVolume16(uDeviceID,dwVolume);
2687 }
2688
2689 /**************************************************************************
2690  *                              midiOutSetVolume        [MMSYSTEM.212]
2691  */
2692 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
2693 {
2694     TRACE(mmsys, "(%04X, %08lX);\n", uDeviceID, dwVolume);
2695     return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
2696 }
2697
2698 /**************************************************************************
2699  *                              midiOutCachePatches             [WINMM.73]
2700  */
2701 UINT32 WINAPI midiOutCachePatches32(HMIDIOUT32 hMidiOut, UINT32 uBank,
2702                                     WORD * lpwPatchArray, UINT32 uFlags)
2703 {
2704     return midiOutCachePatches16(hMidiOut,uBank,lpwPatchArray,uFlags);
2705 }
2706
2707 /**************************************************************************
2708  *                              midiOutCachePatches             [MMSYSTEM.213]
2709  */
2710 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
2711                                     WORD * lpwPatchArray, UINT16 uFlags)
2712 {
2713     /* not really necessary to support this */
2714     FIXME(mmsys, "not supported yet\n");
2715     return MMSYSERR_NOTSUPPORTED;
2716 }
2717
2718 /**************************************************************************
2719  *                              midiOutCacheDrumPatches [WINMM.72]
2720  */
2721 UINT32 WINAPI midiOutCacheDrumPatches32(HMIDIOUT32 hMidiOut, UINT32 uPatch,
2722                                         WORD * lpwKeyArray, UINT32 uFlags)
2723 {
2724     return midiOutCacheDrumPatches16(hMidiOut,uPatch,lpwKeyArray,uFlags);
2725 }
2726
2727 /**************************************************************************
2728  *                              midiOutCacheDrumPatches [MMSYSTEM.214]
2729  */
2730 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
2731                                         WORD * lpwKeyArray, UINT16 uFlags)
2732 {
2733     FIXME(mmsys, "not supported yet\n");
2734     return MMSYSERR_NOTSUPPORTED;
2735 }
2736
2737 /**************************************************************************
2738  *                              midiOutGetID            [WINMM.79]
2739  */
2740 UINT32 WINAPI midiOutGetID32(HMIDIOUT32 hMidiOut, UINT32 * lpuDeviceID)
2741 {
2742     UINT16      xid;
2743     UINT32      ret;
2744
2745     ret = midiOutGetID16(hMidiOut,&xid);
2746     *lpuDeviceID = xid;
2747     return ret;
2748 }
2749
2750 /**************************************************************************
2751  *                              midiOutGetID            [MMSYSTEM.215]
2752  */
2753 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
2754 {
2755     TRACE(mmsys, "midiOutGetID\n");
2756     return 0;
2757 }
2758
2759 /**************************************************************************
2760  *                              midiOutMessage          [WINMM.83]
2761  */
2762 DWORD WINAPI midiOutMessage32(HMIDIOUT32 hMidiOut, UINT32 uMessage,
2763                               DWORD dwParam1, DWORD dwParam2)
2764 {
2765     LPMIDIOPENDESC      lpDesc;
2766
2767     TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2768           hMidiOut, uMessage, dwParam1, dwParam2);
2769     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2770     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2771     switch (uMessage) {
2772     case MODM_OPEN:
2773         FIXME(mmsys,"can't handle MODM_OPEN!\n");
2774         return 0;
2775     case MODM_GETDEVCAPS:
2776         return midiOutGetDevCaps32A(hMidiOut,(LPMIDIOUTCAPS32A)dwParam1,dwParam2);
2777     case MODM_GETNUMDEVS:
2778     case MODM_RESET:
2779     case MODM_CLOSE:
2780     case MODM_GETVOLUME:
2781     case MODM_SETVOLUME:
2782     case MODM_LONGDATA:
2783     case MODM_PREPARE:
2784     case MODM_UNPREPARE:
2785         /* no argument conversion needed */
2786         break;
2787     default:
2788         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2789             hMidiOut,uMessage,dwParam1,dwParam2);
2790         break;
2791     }
2792     return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2793 }
2794
2795 /**************************************************************************
2796  *                              midiOutMessage          [MMSYSTEM.216]
2797  */
2798 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
2799                               DWORD dwParam1, DWORD dwParam2)
2800 {
2801     LPMIDIOPENDESC      lpDesc;
2802
2803     TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2804           hMidiOut, uMessage, dwParam1, dwParam2);
2805     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2806     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2807     switch (uMessage) {
2808     case MODM_OPEN:
2809         FIXME(mmsys,"can't handle MODM_OPEN!\n");
2810         return 0;
2811     case MODM_GETNUMDEVS:
2812     case MODM_RESET:
2813     case MODM_CLOSE:
2814     case MODM_SETVOLUME:
2815         /* no argument conversion needed */
2816         break;
2817     case MODM_GETVOLUME:
2818         return midiOutGetVolume16(hMidiOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
2819     case MODM_LONGDATA:
2820         return midiOutLongMsg16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2821     case MODM_PREPARE:
2822         return midiOutPrepareHeader16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2823     case MODM_UNPREPARE:
2824         return midiOutUnprepareHeader16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2825     default:
2826         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2827             hMidiOut,uMessage,dwParam1,dwParam2);
2828         break;
2829     }
2830     return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2831 }
2832
2833 /**************************************************************************
2834  *                              midiInGetNumDevs        [WINMM.64]
2835  */
2836 UINT32 WINAPI midiInGetNumDevs32(void)
2837 {
2838     return midiInGetNumDevs16();
2839 }
2840
2841 /**************************************************************************
2842  *                              midiInGetNumDevs        [MMSYSTEM.301]
2843  */
2844 UINT16 WINAPI midiInGetNumDevs16(void)
2845 {
2846     UINT16      count = 0;
2847     TRACE(mmsys, "midiInGetNumDevs\n");
2848     count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
2849     TRACE(mmsys, "midiInGetNumDevs return %u \n", count);
2850     return count;
2851 }
2852
2853 /**************************************************************************
2854  *                              midiInGetDevCaps        [WINMM.60]
2855  */
2856 UINT32 WINAPI midiInGetDevCaps32W(UINT32 uDeviceID,
2857                                   LPMIDIINCAPS32W lpCaps, UINT32 uSize)
2858 {
2859     MIDIINCAPS16        mic16;
2860     UINT32              ret = midiInGetDevCaps16(uDeviceID,&mic16,uSize);
2861
2862     lpCaps->wMid = mic16.wMid;
2863     lpCaps->wPid = mic16.wPid;
2864     lpCaps->vDriverVersion = mic16.vDriverVersion;
2865     lstrcpyAtoW(lpCaps->szPname,mic16.szPname);
2866     lpCaps->dwSupport = mic16.dwSupport;
2867     return ret;
2868 }
2869
2870 /**************************************************************************
2871  *                              midiInGetDevCaps        [WINMM.59]
2872  */
2873 UINT32 WINAPI midiInGetDevCaps32A(UINT32 uDeviceID,
2874                                   LPMIDIINCAPS32A lpCaps, UINT32 uSize)
2875 {
2876     MIDIINCAPS16        mic16;
2877     UINT32              ret = midiInGetDevCaps16(uDeviceID,&mic16,uSize);
2878
2879     lpCaps->wMid = mic16.wMid;
2880     lpCaps->wPid = mic16.wPid;
2881     lpCaps->vDriverVersion = mic16.vDriverVersion;
2882     strcpy(lpCaps->szPname,mic16.szPname);
2883     lpCaps->dwSupport = mic16.dwSupport;
2884     return ret;
2885 }
2886
2887 /**************************************************************************
2888  *                              midiInGetDevCaps        [MMSYSTEM.302]
2889  */
2890 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID,
2891                                  LPMIDIINCAPS16 lpCaps, UINT16 uSize)
2892 {
2893     TRACE(mmsys, "midiInGetDevCaps\n");
2894     return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);;
2895 }
2896
2897 /**************************************************************************
2898  *                              midiInGetErrorText              [WINMM.62]
2899  */
2900 UINT32 WINAPI midiInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2901 {
2902     LPSTR       xstr = HeapAlloc(GetProcessHeap(),0,uSize);
2903     UINT32      ret = midiInGetErrorText16(uError,xstr,uSize);
2904     lstrcpyAtoW(lpText,xstr);
2905     HeapFree(GetProcessHeap(),0,xstr);
2906     return ret;
2907 }
2908 /**************************************************************************
2909  *                              midiInGetErrorText              [WINMM.61]
2910  */
2911 UINT32 WINAPI midiInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2912 {
2913     return midiInGetErrorText16(uError,lpText,uSize);
2914 }
2915
2916 /**************************************************************************
2917  *                              midiInGetErrorText              [MMSYSTEM.303]
2918  */
2919 UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2920 {
2921     TRACE(mmsys, "midiInGetErrorText\n");
2922     return (midiGetErrorText(uError, lpText, uSize));
2923 }
2924
2925 /**************************************************************************
2926  *                              midiInOpen              [WINMM.66]
2927  */
2928 UINT32 WINAPI midiInOpen32(HMIDIIN32 * lphMidiIn, UINT32 uDeviceID,
2929                            DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2930 {
2931     HMIDIIN16   xhmid16;
2932     UINT32              ret = midiInOpen16(&xhmid16,uDeviceID,dwCallback,dwInstance,
2933                                            CALLBACK32CONV(dwFlags));
2934     if (lphMidiIn)
2935         *lphMidiIn = xhmid16;
2936     return ret;
2937 }
2938
2939 /**************************************************************************
2940  *                              midiInOpen              [MMSYSTEM.304]
2941  */
2942 UINT16 WINAPI midiInOpen16(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
2943                            DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2944 {
2945     HMIDI16                     hMidiIn;
2946     LPMIDIOPENDESC              lpDesc;
2947     DWORD                       dwRet = 0;
2948     BOOL32                      bMapperFlg = FALSE;
2949
2950     if (lphMidiIn != NULL)
2951         *lphMidiIn = 0;
2952     TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
2953           lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
2954     if (uDeviceID == (UINT16)MIDI_MAPPER) {
2955         TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
2956         bMapperFlg = TRUE;
2957         uDeviceID = 0;
2958     }
2959     hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
2960     if (lphMidiIn != NULL)
2961         *lphMidiIn = hMidiIn;
2962     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2963     if (lpDesc == NULL)
2964         return MMSYSERR_NOMEM;
2965     lpDesc->hMidi = hMidiIn;
2966     lpDesc->dwCallback = dwCallback;
2967     lpDesc->dwInstance = dwInstance;
2968
2969     while (uDeviceID < MAXMIDIDRIVERS) {
2970         dwRet = midMessage(uDeviceID, MIDM_OPEN,
2971                            lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2972         if (dwRet == MMSYSERR_NOERROR)
2973             break;
2974         if (!bMapperFlg)
2975             break;
2976         uDeviceID++;
2977         TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
2978     }
2979     lpDesc->wDevID = uDeviceID;
2980     return dwRet;
2981 }
2982
2983 /**************************************************************************
2984  *                              midiInClose             [WINMM.58]
2985  */
2986 UINT32 WINAPI midiInClose32(HMIDIIN32 hMidiIn)
2987 {
2988     return midiInClose16(hMidiIn);
2989 }
2990
2991 /**************************************************************************
2992  *                              midiInClose             [MMSYSTEM.305]
2993  */
2994 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
2995 {
2996     LPMIDIOPENDESC      lpDesc;
2997     TRACE(mmsys, "(%04X)\n", hMidiIn);
2998     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2999     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3000     return midMessage(lpDesc->wDevID, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3001 }
3002
3003 /**************************************************************************
3004  *                              midiInPrepareHeader     [WINMM.67]
3005  */
3006 UINT32 WINAPI midiInPrepareHeader32(HMIDIIN32 hMidiIn,
3007                                     MIDIHDR * lpMidiInHdr, UINT32 uSize)
3008 {
3009     LPMIDIOPENDESC      lpDesc;
3010
3011     TRACE(mmsys, "(%04X, %p, %d)\n",
3012           hMidiIn, lpMidiInHdr, uSize);
3013     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3014     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3015     lpMidiInHdr->reserved = (DWORD)lpMidiInHdr->lpData;
3016     return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance,
3017                       (DWORD)lpMidiInHdr, (DWORD)uSize);
3018 }
3019
3020 /**************************************************************************
3021  *                              midiInPrepareHeader     [MMSYSTEM.306]
3022  */
3023 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,
3024                                     MIDIHDR * lpMidiInHdr, UINT16 uSize)
3025 {
3026     LPMIDIOPENDESC      lpDesc;
3027
3028     TRACE(mmsys, "(%04X, %p, %d)\n",
3029           hMidiIn, lpMidiInHdr, uSize);
3030     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3031     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3032     lpMidiInHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiInHdr->lpData);
3033     return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance,
3034                       (DWORD)lpMidiInHdr, (DWORD)uSize);
3035 }
3036
3037 /**************************************************************************
3038  *                              midiInUnprepareHeader   [WINMM.71]
3039  */
3040 UINT32 WINAPI midiInUnprepareHeader32(HMIDIIN32 hMidiIn,
3041                                       MIDIHDR * lpMidiInHdr, UINT32 uSize)
3042 {
3043     return midiInUnprepareHeader16(hMidiIn,lpMidiInHdr,uSize);
3044 }
3045
3046 /**************************************************************************
3047  *                              midiInUnprepareHeader   [MMSYSTEM.307]
3048  */
3049 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,
3050                                       MIDIHDR * lpMidiInHdr, UINT16 uSize)
3051 {
3052     LPMIDIOPENDESC      lpDesc;
3053     TRACE(mmsys, "(%04X, %p, %d)\n",
3054           hMidiIn, lpMidiInHdr, uSize);
3055     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3056     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3057     return midMessage(lpDesc->wDevID, MIDM_UNPREPARE, lpDesc->dwInstance,
3058                       (DWORD)lpMidiInHdr, (DWORD)uSize);
3059 }
3060
3061 /**************************************************************************
3062  *                              midiInAddBuffer         [WINMM.57]
3063  */
3064 UINT32 WINAPI midiInAddBuffer32(HMIDIIN32 hMidiIn,
3065                                 MIDIHDR * lpMidiInHdr, UINT32 uSize)
3066 {
3067     return midiInAddBuffer16(hMidiIn,lpMidiInHdr,uSize);
3068 }
3069
3070 /**************************************************************************
3071  *                              midiInAddBuffer         [MMSYSTEM.308]
3072  */
3073 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,
3074                                 MIDIHDR * lpMidiInHdr, UINT16 uSize)
3075 {
3076     TRACE(mmsys, "midiInAddBuffer\n");
3077     return 0;
3078 }
3079
3080 /**************************************************************************
3081  *                              midiInStart                     [WINMM.69]
3082  */
3083 UINT32 WINAPI midiInStart32(HMIDIIN32 hMidiIn)
3084 {
3085     return midiInStart16(hMidiIn);
3086 }
3087
3088 /**************************************************************************
3089  *                              midiInStart                     [MMSYSTEM.309]
3090  */
3091 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
3092 {
3093     LPMIDIOPENDESC      lpDesc;
3094
3095     TRACE(mmsys, "(%04X)\n", hMidiIn);
3096     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3097     if (lpDesc == NULL)
3098         return MMSYSERR_INVALHANDLE;
3099     return midMessage(lpDesc->wDevID, MIDM_START, lpDesc->dwInstance, 0L, 0L);
3100 }
3101
3102 /**************************************************************************
3103  *                              midiInStop                      [WINMM.70]
3104  */
3105 UINT32 WINAPI midiInStop32(HMIDIIN32 hMidiIn)
3106 {
3107     return midiInStop16(hMidiIn);
3108 }
3109
3110 /**************************************************************************
3111  *                              midiInStop                      [MMSYSTEM.310]
3112  */
3113 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
3114 {
3115     LPMIDIOPENDESC      lpDesc;
3116
3117     TRACE(mmsys, "(%04X)\n", hMidiIn);
3118     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3119     if (lpDesc == NULL)
3120         return MMSYSERR_INVALHANDLE;
3121     return midMessage(lpDesc->wDevID, MIDM_STOP, lpDesc->dwInstance, 0L, 0L);
3122 }
3123
3124 /**************************************************************************
3125  *                              midiInReset                     [WINMM.68]
3126  */
3127 UINT32 WINAPI midiInReset32(HMIDIIN32 hMidiIn)
3128 {
3129     return midiInReset16(hMidiIn);
3130 }
3131
3132 /**************************************************************************
3133  *                              midiInReset                     [MMSYSTEM.311]
3134  */
3135 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
3136 {
3137     LPMIDIOPENDESC      lpDesc;
3138
3139     TRACE(mmsys, "(%04X)\n", hMidiIn);
3140     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3141     if (lpDesc == NULL)
3142         return MMSYSERR_INVALHANDLE;
3143     return midMessage(lpDesc->wDevID, MIDM_RESET, lpDesc->dwInstance, 0L, 0L);
3144 }
3145
3146 /**************************************************************************
3147  *                              midiInGetID                     [WINMM.63]
3148  */
3149 UINT32 WINAPI midiInGetID32(HMIDIIN32 hMidiIn, UINT32* lpuDeviceID)
3150 {
3151     LPMIDIOPENDESC      lpDesc;
3152
3153     TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID);
3154     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3155     if (lpDesc == NULL)
3156         return MMSYSERR_INVALHANDLE;
3157     if (lpuDeviceID == NULL)
3158         return MMSYSERR_INVALPARAM;
3159     *lpuDeviceID = lpDesc->wDevID;
3160
3161     return MMSYSERR_NOERROR;
3162 }
3163
3164 /**************************************************************************
3165  *                              midiInGetID                     [MMSYSTEM.312]
3166  */
3167 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
3168 {
3169     LPMIDIOPENDESC      lpDesc;
3170
3171     TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID);
3172     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3173     if (lpDesc == NULL)
3174         return MMSYSERR_INVALHANDLE;
3175     if (lpuDeviceID == NULL)
3176         return MMSYSERR_INVALPARAM;
3177     *lpuDeviceID = lpDesc->wDevID;
3178
3179     return MMSYSERR_NOERROR;
3180 }
3181
3182 /**************************************************************************
3183  *                              midiInMessage           [WINMM.65]
3184  */
3185 DWORD WINAPI midiInMessage32(HMIDIIN32 hMidiIn, UINT32 uMessage,
3186                              DWORD dwParam1, DWORD dwParam2)
3187 {
3188     LPMIDIOPENDESC      lpDesc;
3189
3190     TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
3191           hMidiIn, uMessage, dwParam1, dwParam2);
3192     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3193     if (lpDesc == NULL)
3194         return MMSYSERR_INVALHANDLE;
3195
3196     switch (uMessage) {
3197     case MIDM_OPEN:
3198         FIXME(mmsys,"can't handle MIDM_OPEN!\n");
3199         return 0;
3200     case MIDM_GETDEVCAPS:
3201         return midiInGetDevCaps32A(hMidiIn,(LPMIDIINCAPS32A)dwParam1,dwParam2);
3202     case MIDM_GETNUMDEVS:
3203     case MIDM_RESET:
3204     case MIDM_STOP:
3205     case MIDM_START:
3206     case MIDM_CLOSE:
3207         /* no argument conversion needed */
3208         break;
3209     case MIDM_PREPARE:
3210         return midiInPrepareHeader32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
3211     case MIDM_UNPREPARE:
3212         return midiInUnprepareHeader32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
3213     case MIDM_ADDBUFFER:
3214         return midiInAddBuffer32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
3215     default:
3216         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
3217             hMidiIn,uMessage,dwParam1,dwParam2);
3218         break;
3219     }
3220     return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3221 }
3222
3223 /**************************************************************************
3224  *                              midiInMessage           [MMSYSTEM.313]
3225  */
3226 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
3227                              DWORD dwParam1, DWORD dwParam2)
3228 {
3229     LPMIDIOPENDESC      lpDesc;
3230
3231     TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
3232
3233     lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3234     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3235     switch (uMessage) {
3236     case MIDM_OPEN:
3237         WARN(mmsys,"can't handle MIDM_OPEN!\n");
3238         return 0;
3239     case MIDM_GETDEVCAPS:
3240         return midiInGetDevCaps16(hMidiIn,(LPMIDIINCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3241     case MIDM_GETNUMDEVS:
3242     case MIDM_RESET:
3243     case MIDM_STOP:
3244     case MIDM_START:
3245     case MIDM_CLOSE:
3246         /* no argument conversion needed */
3247         break;
3248     case MIDM_PREPARE:
3249         return midiInPrepareHeader16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3250     case MIDM_UNPREPARE:
3251         return midiInUnprepareHeader16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3252     case MIDM_ADDBUFFER:
3253         return midiInAddBuffer16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3254     default:
3255         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
3256             hMidiIn,uMessage,dwParam1,dwParam2);
3257         break;
3258     }
3259     return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3260 }
3261
3262 #define MIDI_STREAM_MAGIC       0xC9080F17
3263
3264 typedef struct {
3265     DWORD               dwMagic;
3266     HMIDIOUT32          hDevice;
3267     /*     thread ID */
3268     DWORD               dwTempo;
3269     DWORD               dwTimeDiv;
3270     DWORD               dwMS;
3271     DWORD               dwStatus;
3272     LPMIDIHDR_WIN32     lpMidiHdr;
3273 } WINE_MIDIStream;
3274
3275 /**************************************************************************
3276  *                              MMSYSTEM_MidiStreamPlayer       [internal]
3277  */
3278 static  void    MMSYSTEM_MidiStreamPlayer(WINE_MIDIStream* ms)
3279 {
3280     /* FIXME: should I sleep a bit when there is no pending lpMidiHdr ?
3281      * => provide a better synchronization system
3282      * midiStreamPause/midiStreamRestart should freeze/thaw this thread
3283      * global resource should guard access to ms->lpMidiHdr list, or
3284      * use a MB to send new LPMIDIHDR
3285      * an empty ms->lpMidiHdr list should freeze this thread
3286      */
3287     for (;;) {
3288         if (ms->dwStatus && ms->lpMidiHdr) {
3289             LPMIDIEVENT         me = (LPMIDIEVENT)(ms->lpMidiHdr->lpData + ms->lpMidiHdr->dwOffset);
3290
3291             FIXME(mmsys, "Should wait for current time to be in sync with me->dwDeltaTime\n");
3292
3293             if (me->dwEvent & MEVT_F_CALLBACK) {
3294                 WARN(mmsys, "Should generate callback when encountering F_CALLBACK flagged midi events...\n");
3295             }
3296             switch (MEVT_EVENTTYPE(me->dwEvent)) {
3297             case MEVT_COMMENT:
3298                 /* do nothing, skip bytes */
3299                 break;
3300             case MEVT_LONGMSG:
3301                 WARN(mmsys, "NIY: sending Sysex Event");
3302                 break;
3303             case MEVT_NOP:
3304                 break;
3305             case MEVT_SHORTMSG:
3306                 midiOutShortMsg32(ms->hDevice, MEVT_EVENTPARM(me->dwEvent));
3307                 break;
3308             case MEVT_TEMPO:
3309                 ms->dwTempo = MEVT_EVENTPARM(me->dwEvent);
3310                 break;
3311             case MEVT_VERSION:
3312                 break;
3313             }
3314             ms->lpMidiHdr->dwOffset += sizeof(MIDIEVENT);
3315             if (me->dwEvent & MEVT_F_LONG) {
3316                 ms->lpMidiHdr->dwOffset += MEVT_EVENTPARM(me->dwEvent);
3317             }
3318             if (ms->lpMidiHdr->dwOffset >= ms->lpMidiHdr->dwBufferLength) {
3319                 ms->lpMidiHdr->dwFlags |= MHDR_DONE;
3320                 ms->lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
3321                 ms->lpMidiHdr = (LPMIDIHDR_WIN32)ms->lpMidiHdr->lpNext;
3322                 WARN(mmsys, "Should generate callback when done with MIDIHDR...\n");
3323             }
3324             FIXME(mmsys, "Should accordingly update ms->dwMS with me->dwDeltaTime\n");
3325         }
3326     }
3327 }
3328
3329 /**************************************************************************
3330  *                              midiStreamClose                 [WINMM.90]
3331  */
3332 MMRESULT32 WINAPI midiStreamClose32(HMIDISTRM32 hms)
3333 {
3334     WINE_MIDIStream*    ms;
3335
3336     TRACE(midi, "(%08x)!\n", hms);
3337
3338     ms = (WINE_MIDIStream*)hms;
3339     if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
3340         return MMSYSERR_INVALHANDLE;
3341
3342     free(ms);
3343
3344     return MMSYSERR_NOTSUPPORTED;
3345 }
3346
3347 /**************************************************************************
3348  *                              midiStreamOpen                  [WINMM.91]
3349  */
3350 MMRESULT32 WINAPI midiStreamOpen32(HMIDISTRM32* phms, LPUINT32 lpuDeviceID,
3351                                    DWORD cMidi, DWORD dwCallback,
3352                                    DWORD dwInstance, DWORD fdwOpen)
3353 {
3354     WINE_MIDIStream*    ms;
3355
3356     TRACE(midi, "(%p,%p,%ld,0x%08lx,0x%08lx,0x%08lx),stub!\n",
3357           phms,lpuDeviceID,cMidi,dwCallback,dwInstance,fdwOpen);
3358
3359     if (cMidi != 1 || phms == NULL || lpuDeviceID == NULL)
3360         return MMSYSERR_INVALPARAM;
3361
3362     ms = malloc(sizeof(WINE_MIDIStream));
3363     *phms = (HMIDISTRM32)ms;
3364     ms->dwMagic = MIDI_STREAM_MAGIC;
3365     ms->dwTempo = 50000;        /* FIXME */
3366     ms->dwTimeDiv = 1;          /* FIXME */
3367     ms->dwMS = 0;
3368     ms->dwStatus = 0;
3369
3370     /* FIXME is this correct ? */
3371     *lpuDeviceID = 0;
3372     /* FIXME is this correct ? */
3373     return midiOutOpen32(&(ms->hDevice), *lpuDeviceID, dwCallback, dwInstance, fdwOpen);
3374 }
3375
3376 /**************************************************************************
3377  *                              midiStreamOut                   [WINMM.92]
3378  */
3379 MMRESULT32 WINAPI midiStreamOut32(HMIDISTRM32 hms, LPMIDIHDR lpMidiHdr, UINT32 cbMidiHdr)
3380 {
3381     FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMidiHdr, cbMidiHdr);
3382     return MMSYSERR_NOTSUPPORTED;
3383 }
3384
3385 /**************************************************************************
3386  *                              midiStreamPause                 [WINMM.93]
3387  */
3388 MMRESULT32 WINAPI midiStreamPause32(HMIDISTRM32 hms)
3389 {
3390     WINE_MIDIStream*    ms;
3391
3392     TRACE(midi, "(%08x)!\n", hms);
3393
3394     ms = (WINE_MIDIStream*)hms;
3395     if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
3396         return MMSYSERR_INVALHANDLE;
3397
3398     ms->dwStatus = 0;
3399     return MMSYSERR_NOERROR;
3400 }
3401
3402 /**************************************************************************
3403  *                              midiStreamPosition              [WINMM.94]
3404  */
3405 MMRESULT32 WINAPI midiStreamPosition32(HMIDISTRM32 hms, LPMMTIME32 lpMMT, UINT32 cbmmt)
3406 {
3407     WINE_MIDIStream*    ms;
3408     DWORD               ret = MMSYSERR_NOERROR;
3409
3410     FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMMT, cbmmt);
3411
3412     ms = (WINE_MIDIStream*)hms;
3413
3414     if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) {
3415         ret = MMSYSERR_INVALHANDLE;
3416     } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME32)) {
3417         ret = MMSYSERR_INVALPARAM;
3418     } else {
3419         switch (lpMMT->wType) {
3420         case TIME_MS:
3421             lpMMT->u.ms = ms->dwMS;
3422             break;
3423         default:
3424             lpMMT->wType = TIME_MS;
3425             ret = MMSYSERR_INVALPARAM;
3426         }
3427     }
3428     return ret;
3429 }
3430
3431 /**************************************************************************
3432  *                              midiStreamProperty              [WINMM.95]
3433  */
3434 MMRESULT32 WINAPI midiStreamProperty32(HMIDISTRM32 hms, LPBYTE lpPropData, DWORD dwProperty)
3435 {
3436     WINE_MIDIStream*    ms = (WINE_MIDIStream*)hms;
3437     MMRESULT32          ret = MMSYSERR_NOERROR;
3438
3439     TRACE(midi, "(%08x, %p, %lx)\n", hms, lpPropData, dwProperty);
3440
3441     if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) {
3442         ret = MMSYSERR_INVALHANDLE;
3443     } else if ((dwProperty & (MIDIPROP_GET|MIDIPROP_SET)) == 0) {
3444         return MMSYSERR_INVALPARAM;
3445     } else if (dwProperty & MIDIPROP_TEMPO) {
3446         MIDIPROPTEMPO*  mpt = (MIDIPROPTEMPO*)lpPropData;
3447
3448         if (sizeof(MIDIPROPTEMPO) != mpt->cbStruct) {
3449             ret = MMSYSERR_INVALPARAM;
3450         } else if (dwProperty & MIDIPROP_GET) {
3451             ms->dwTempo = mpt->dwTempo;
3452         } else if (dwProperty & MIDIPROP_SET) {
3453             mpt->dwTempo = ms->dwTempo;
3454         }
3455     } else if (dwProperty & MIDIPROP_TIMEDIV) {
3456         MIDIPROPTIMEDIV*        mptd = (MIDIPROPTIMEDIV*)lpPropData;
3457
3458         if (sizeof(MIDIPROPTIMEDIV) != mptd->cbStruct) {
3459             ret = MMSYSERR_INVALPARAM;
3460         } else if (dwProperty & MIDIPROP_GET) {
3461             ms->dwTimeDiv = mptd->dwTimeDiv;
3462         } else if (dwProperty & MIDIPROP_SET) {
3463             mptd->dwTimeDiv = ms->dwTimeDiv;
3464         }
3465     } else {
3466         ret = MMSYSERR_INVALPARAM;
3467     }
3468
3469     return ret;
3470 }
3471
3472 /**************************************************************************
3473  *                              midiStreamRestart               [WINMM.96]
3474  */
3475 MMRESULT32 WINAPI midiStreamRestart32(HMIDISTRM32 hms)
3476 {
3477     WINE_MIDIStream*    ms;
3478
3479     TRACE(midi, "(%08x)!\n", hms);
3480
3481     ms = (WINE_MIDIStream*)hms;
3482     if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
3483         return MMSYSERR_INVALHANDLE;
3484
3485     ms->dwStatus = 1;
3486     return MMSYSERR_NOERROR;
3487 }
3488
3489 /**************************************************************************
3490  *                              midiStreamStop                  [WINMM.97]
3491  */
3492 MMRESULT32 WINAPI midiStreamStop32(HMIDISTRM32 hms)
3493 {
3494     FIXME(midi, "(%08x stub!)\n", hms);
3495         return MMSYSERR_NOTSUPPORTED;
3496 }
3497
3498 /**************************************************************************
3499  *                              midiStreamClose                 [MMSYSTEM.252]
3500  */
3501 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms)
3502 {
3503     return midiStreamClose32(hms);
3504 }
3505
3506 /**************************************************************************
3507  *                              midiStreamOpen                  [MMSYSTEM.251]
3508  */
3509 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phms, LPUINT16 devid,
3510                                    DWORD cMidi, DWORD dwCallback,
3511                                    DWORD dwInstance, DWORD fdwOpen)
3512 {
3513     HMIDISTRM32 hms32;
3514     MMRESULT32  ret;
3515     UINT32      devid32;
3516
3517     if (!phms || !devid)
3518         return MMSYSERR_INVALPARAM;
3519     devid32 = *devid;
3520     ret = midiStreamOpen32(&hms32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen);
3521     *phms = hms32;
3522     *devid = devid32;
3523     return ret;
3524 }
3525
3526 /**************************************************************************
3527  *                              midiStreamOut                   [MMSYSTEM.254]
3528  */
3529 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hms, LPMIDIHDR lpMidiHdr, UINT16 cbMidiHdr)
3530 {
3531     return midiStreamOut32(hms, lpMidiHdr, cbMidiHdr);
3532 }
3533
3534 /**************************************************************************
3535  *                              midiStreamPause                 [MMSYSTEM.255]
3536  */
3537 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hms)
3538 {
3539     return midiStreamPause32(hms);
3540 }
3541
3542 /**************************************************************************
3543  *                              midiStreamPosition              [MMSYSTEM.253]
3544  */
3545 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hms, LPMMTIME16 lpmmt, UINT16 cbmmt)
3546 {
3547     MMTIME32    mmt32;
3548     MMRESULT32  ret;
3549
3550     if (!lpmmt)
3551         return MMSYSERR_INVALPARAM;
3552     MMSYSTEM_MMTIME16to32(&mmt32, lpmmt);
3553     ret = midiStreamPosition32(hms, &mmt32, cbmmt);
3554     MMSYSTEM_MMTIME32to16(lpmmt, &mmt32);
3555     return ret;
3556 }
3557
3558 /**************************************************************************
3559  *                              midiStreamProperty              [MMSYSTEM.250]
3560  */
3561 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hms, LPBYTE lpPropData, DWORD dwProperty)
3562 {
3563     return midiStreamProperty32(hms, lpPropData, dwProperty);
3564 }
3565
3566 /**************************************************************************
3567  *                              midiStreamRestart               [MMSYSTEM.256]
3568  */
3569 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hms)
3570 {
3571     return midiStreamRestart32(hms);
3572 }
3573
3574 /**************************************************************************
3575  *                              midiStreamStop                  [MMSYSTEM.257]
3576  */
3577 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hms)
3578 {
3579     return midiStreamStop32(hms);
3580 }
3581
3582 /**************************************************************************
3583  *                              waveOutGetNumDevs               [MMSYSTEM.401]
3584  */
3585 UINT32 WINAPI waveOutGetNumDevs32() {
3586     return waveOutGetNumDevs16();
3587 }
3588
3589 /**************************************************************************
3590  *                              waveOutGetNumDevs               [WINMM.167]
3591  */
3592 UINT16 WINAPI waveOutGetNumDevs16()
3593 {
3594     UINT16      count = 0;
3595     TRACE(mmsys, "waveOutGetNumDevs\n");
3596     /* FIXME: I'm not sure MCI_FirstDevID() is correct */
3597     count += wodMessage( MCI_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
3598     TRACE(mmsys, "waveOutGetNumDevs return %u \n", count);
3599     return count;
3600 }
3601
3602 /**************************************************************************
3603  *                              waveOutGetDevCaps               [MMSYSTEM.402]
3604  */
3605 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, WAVEOUTCAPS16 * lpCaps,
3606                                   UINT16 uSize)
3607 {
3608     if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID;
3609     if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
3610     TRACE(mmsys, "waveOutGetDevCaps\n");
3611     return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
3612 }
3613
3614 /**************************************************************************
3615  *                              waveOutGetDevCapsA              [WINMM.162]
3616  */
3617 UINT32 WINAPI waveOutGetDevCaps32A(UINT32 uDeviceID, LPWAVEOUTCAPS32A lpCaps,
3618                                    UINT32 uSize)
3619 {
3620     WAVEOUTCAPS16       woc16;
3621     UINT16 ret = waveOutGetDevCaps16(uDeviceID,&woc16,sizeof(woc16));
3622
3623     lpCaps->wMid = woc16.wMid;
3624     lpCaps->wPid = woc16.wPid;
3625     lpCaps->vDriverVersion = woc16.vDriverVersion;
3626     strcpy(lpCaps->szPname,woc16.szPname);
3627     lpCaps->dwFormats = woc16.dwFormats;
3628     lpCaps->wChannels = woc16.wChannels;
3629     lpCaps->dwSupport = woc16.dwSupport;
3630     return ret;
3631 }
3632
3633 /**************************************************************************
3634  *                              waveOutGetDevCapsW              [WINMM.163]
3635  */
3636 UINT32 WINAPI waveOutGetDevCaps32W(UINT32 uDeviceID, LPWAVEOUTCAPS32W lpCaps,
3637                                    UINT32 uSize)
3638 {
3639     WAVEOUTCAPS16       woc16;
3640     UINT32 ret = waveOutGetDevCaps16(uDeviceID,&woc16,sizeof(woc16));
3641
3642     lpCaps->wMid = woc16.wMid;
3643     lpCaps->wPid = woc16.wPid;
3644     lpCaps->vDriverVersion = woc16.vDriverVersion;
3645     lstrcpyAtoW(lpCaps->szPname,woc16.szPname);
3646     lpCaps->dwFormats = woc16.dwFormats;
3647     lpCaps->wChannels = woc16.wChannels;
3648     lpCaps->dwSupport = woc16.dwSupport;
3649     return ret;
3650 }
3651
3652 /**************************************************************************
3653  *                              waveOutGetErrorText     [MMSYSTEM.403]
3654  */
3655 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3656 {
3657     TRACE(mmsys, "waveOutGetErrorText\n");
3658     return(waveGetErrorText(uError, lpText, uSize));
3659 }
3660
3661 /**************************************************************************
3662  *                              waveOutGetErrorTextA    [WINMM.164]
3663  */
3664 UINT32 WINAPI waveOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
3665 {
3666     return(waveOutGetErrorText16(uError, lpText, uSize));
3667 }
3668
3669 /**************************************************************************
3670  *                              waveOutGetErrorTextW    [WINMM.165]
3671  */
3672 UINT32 WINAPI waveOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
3673 {
3674     LPSTR       xstr = HeapAlloc(GetProcessHeap(),0,uSize);
3675     UINT32      ret = waveOutGetErrorText32A(uError, xstr, uSize);
3676
3677     lstrcpyAtoW(lpText,xstr);
3678     HeapFree(GetProcessHeap(),0,xstr);
3679     return ret;
3680 }
3681
3682
3683 /**************************************************************************
3684  *                              waveGetErrorText                [internal]
3685  */
3686 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
3687 {
3688     LPSTR       msgptr;
3689     TRACE(mmsys, "(%04X, %p, %d);\n",
3690           uError, lpText, uSize);
3691     if ((lpText == NULL) || (uSize < 1)) return(FALSE);
3692     lpText[0] = '\0';
3693     switch (uError) {
3694     case MMSYSERR_NOERROR:
3695         msgptr = "The specified command was carried out.";
3696         break;
3697     case MMSYSERR_ERROR:
3698         msgptr = "Undefined external error.";
3699         break;
3700     case MMSYSERR_BADDEVICEID:
3701         msgptr = "A device ID has been used that is out of range for your system.";
3702         break;
3703     case MMSYSERR_NOTENABLED:
3704         msgptr = "The driver was not enabled.";
3705         break;
3706     case MMSYSERR_ALLOCATED:
3707         msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
3708         break;
3709     case MMSYSERR_INVALHANDLE:
3710         msgptr = "The specified device handle is invalid.";
3711         break;
3712     case MMSYSERR_NODRIVER:
3713         msgptr = "There is no driver installed on your system !\n";
3714         break;
3715     case MMSYSERR_NOMEM:
3716         msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
3717         break;
3718     case MMSYSERR_NOTSUPPORTED:
3719         msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
3720         break;
3721     case MMSYSERR_BADERRNUM:
3722         msgptr = "An error number was specified that is not defined in the system.";
3723         break;
3724     case MMSYSERR_INVALFLAG:
3725         msgptr = "An invalid flag was passed to a system function.";
3726         break;
3727     case MMSYSERR_INVALPARAM:
3728         msgptr = "An invalid parameter was passed to a system function.";
3729         break;
3730     case WAVERR_BADFORMAT:
3731         msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
3732         break;
3733     case WAVERR_STILLPLAYING:
3734         msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
3735         break;
3736     case WAVERR_UNPREPARED:
3737         msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
3738         break;
3739     case WAVERR_SYNC:
3740         msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
3741         break;
3742     default:
3743         msgptr = "Unknown MMSYSTEM Error !\n";
3744         break;
3745     }
3746     lstrcpyn32A(lpText, msgptr, uSize);
3747     return TRUE;
3748 }
3749
3750 /**************************************************************************
3751  *                      waveOutOpen                     [WINMM.173]
3752  * All the args/structs have the same layout as the win16 equivalents
3753  */
3754 UINT32 WINAPI waveOutOpen32(HWAVEOUT32 * lphWaveOut, UINT32 uDeviceID,
3755                             const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3756                             DWORD dwInstance, DWORD dwFlags)
3757 {
3758     HWAVEOUT16  hwo16;
3759     UINT32      ret = waveOutOpen16(&hwo16,uDeviceID,lpFormat,dwCallback,dwInstance,
3760                                     CALLBACK32CONV(dwFlags));
3761
3762     if (lphWaveOut) *lphWaveOut=hwo16;
3763     return ret;
3764 }
3765 /**************************************************************************
3766  *                      waveOutOpen                     [MMSYSTEM.404]
3767  */
3768 UINT16 WINAPI waveOutOpen16(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
3769                             const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3770                             DWORD dwInstance, DWORD dwFlags)
3771 {
3772     HWAVEOUT16  hWaveOut;
3773     LPWAVEOPENDESC      lpDesc;
3774     DWORD               dwRet = 0;
3775     BOOL32              bMapperFlg = FALSE;
3776
3777     TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3778           lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
3779     if (dwFlags & WAVE_FORMAT_QUERY)
3780         TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
3781     if (uDeviceID == (UINT16)WAVE_MAPPER) {
3782         TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
3783         bMapperFlg = TRUE;
3784         uDeviceID = 0;
3785     }
3786     if (lpFormat == NULL) return WAVERR_BADFORMAT;
3787
3788     hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
3789     if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
3790     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3791     if (lpDesc == NULL) return MMSYSERR_NOMEM;
3792     lpDesc->hWave = hWaveOut;
3793     lpDesc->lpFormat = (LPWAVEFORMAT)lpFormat;  /* should the struct be copied iso pointer? */
3794     lpDesc->dwCallBack = dwCallback;
3795     lpDesc->dwInstance = dwInstance;
3796     if (uDeviceID >= MAXWAVEDRIVERS)
3797         uDeviceID = 0;
3798     while (uDeviceID < MAXWAVEDRIVERS) {
3799         dwRet = wodMessage(uDeviceID, WODM_OPEN,
3800                            lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
3801         if (dwRet == MMSYSERR_NOERROR) break;
3802         if (!bMapperFlg) break;
3803         uDeviceID++;
3804         TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
3805     }
3806     lpDesc->uDeviceID = uDeviceID;  /* save physical Device ID */
3807     if (dwFlags & WAVE_FORMAT_QUERY) {
3808         TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
3809         dwRet = waveOutClose32(hWaveOut);
3810     }
3811     return dwRet;
3812 }
3813
3814 /**************************************************************************
3815  *                              waveOutClose            [WINMM.161]
3816  */
3817 UINT32 WINAPI waveOutClose32(HWAVEOUT32 hWaveOut)
3818 {
3819     return waveOutClose16(hWaveOut);
3820 }
3821 /**************************************************************************
3822  *                              waveOutClose            [MMSYSTEM.405]
3823  */
3824 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
3825 {
3826     LPWAVEOPENDESC      lpDesc;
3827
3828     TRACE(mmsys, "(%04X)\n", hWaveOut);
3829
3830     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3831     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3832     return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3833 }
3834
3835 /**************************************************************************
3836  *                              waveOutPrepareHeader    [WINMM.175]
3837  */
3838 UINT32 WINAPI waveOutPrepareHeader32(HWAVEOUT32 hWaveOut,
3839                                      WAVEHDR * lpWaveOutHdr, UINT32 uSize)
3840 {
3841     LPWAVEOPENDESC      lpDesc;
3842
3843     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3844
3845     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3846     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3847     return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
3848                        (DWORD)lpWaveOutHdr,uSize);
3849 }
3850 /**************************************************************************
3851  *                              waveOutPrepareHeader    [MMSYSTEM.406]
3852  */
3853 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,
3854                                      WAVEHDR * lpWaveOutHdr, UINT16 uSize)
3855 {
3856     LPWAVEOPENDESC      lpDesc;
3857     LPBYTE              saveddata = lpWaveOutHdr->lpData;
3858     UINT16              ret;
3859
3860     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3861
3862     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3863     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3864     lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3865     ret = wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
3866                       (DWORD)lpWaveOutHdr,uSize);
3867     lpWaveOutHdr->lpData = saveddata;
3868     return ret;
3869 }
3870
3871 /**************************************************************************
3872  *                              waveOutUnprepareHeader  [WINMM.181]
3873  */
3874 UINT32 WINAPI waveOutUnprepareHeader32(HWAVEOUT32 hWaveOut,
3875                                        WAVEHDR * lpWaveOutHdr, UINT32 uSize)
3876 {
3877     LPWAVEOPENDESC      lpDesc;
3878
3879     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3880
3881     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3882     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3883     return wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
3884                       (DWORD)lpWaveOutHdr, uSize);
3885 }
3886 /**************************************************************************
3887  *                              waveOutUnprepareHeader  [MMSYSTEM.407]
3888  */
3889 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,
3890                                        WAVEHDR * lpWaveOutHdr, UINT16 uSize)
3891 {
3892     LPWAVEOPENDESC      lpDesc;
3893     LPBYTE              saveddata = lpWaveOutHdr->lpData;
3894     UINT16              ret;
3895
3896     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3897
3898     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3899     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3900     lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3901     ret = wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
3902                      (DWORD)lpWaveOutHdr, uSize);
3903     lpWaveOutHdr->lpData = saveddata;
3904     return ret;
3905 }
3906
3907 /**************************************************************************
3908  *                              waveOutWrite            [MMSYSTEM.408]
3909  */
3910 UINT32 WINAPI waveOutWrite32(HWAVEOUT32 hWaveOut, WAVEHDR * lpWaveOutHdr,
3911                              UINT32 uSize)
3912 {
3913     LPWAVEOPENDESC      lpDesc;
3914
3915     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3916
3917     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3918     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3919     lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3920     return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
3921 }
3922 /**************************************************************************
3923  *                              waveOutWrite            [MMSYSTEM.408]
3924  */
3925 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
3926                              UINT16 uSize)
3927 {
3928     LPWAVEOPENDESC      lpDesc;
3929     UINT16              ret;
3930
3931     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3932
3933     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3934     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3935     lpWaveOutHdr->reserved=(DWORD)lpWaveOutHdr->lpData;/*save original ptr*/
3936     lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3937     ret = wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
3938     lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
3939     return ret;
3940 }
3941
3942 /**************************************************************************
3943  *                              waveOutPause            [WINMM.174]
3944  */
3945 UINT32 WINAPI waveOutPause32(HWAVEOUT32 hWaveOut)
3946 {
3947     return waveOutPause16(hWaveOut);
3948 }
3949
3950 /**************************************************************************
3951  *                              waveOutPause            [MMSYSTEM.409]
3952  */
3953 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut)
3954 {
3955     LPWAVEOPENDESC      lpDesc;
3956
3957     TRACE(mmsys, "(%04X)\n", hWaveOut);
3958
3959     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3960     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3961     return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
3962 }
3963
3964 /**************************************************************************
3965  *                              waveOutRestart          [WINMM.177]
3966  */
3967 UINT32 WINAPI waveOutRestart32(HWAVEOUT32 hWaveOut)
3968 {
3969     return waveOutRestart16(hWaveOut);
3970 }
3971
3972 /**************************************************************************
3973  *                              waveOutRestart          [MMSYSTEM.410]
3974  */
3975 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut)
3976 {
3977     LPWAVEOPENDESC      lpDesc;
3978
3979     TRACE(mmsys, "(%04X)\n", hWaveOut);
3980
3981     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3982     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3983     return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
3984 }
3985
3986 /**************************************************************************
3987  *                              waveOutReset            [WINMM.176]
3988  */
3989 UINT32 WINAPI waveOutReset32(HWAVEOUT32 hWaveOut)
3990 {
3991     return waveOutReset16(hWaveOut);
3992 }
3993
3994 /**************************************************************************
3995  *                              waveOutReset            [MMSYSTEM.411]
3996  */
3997 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut)
3998 {
3999     LPWAVEOPENDESC      lpDesc;
4000
4001     TRACE(mmsys, "(%04X)\n", hWaveOut);
4002
4003     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4004     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4005     return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
4006 }
4007
4008 /**************************************************************************
4009  *                              waveOutGetPosition      [WINMM.170]
4010  */
4011 UINT32 WINAPI waveOutGetPosition32(HWAVEOUT32 hWaveOut, LPMMTIME32 lpTime,
4012                                    UINT32 uSize)
4013 {
4014     MMTIME16    mmt16;
4015     UINT32 ret;
4016
4017     mmt16.wType = lpTime->wType;
4018     ret = waveOutGetPosition16(hWaveOut,&mmt16,sizeof(mmt16));
4019     MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
4020     return ret;
4021 }
4022 /**************************************************************************
4023  *                              waveOutGetPosition      [MMSYSTEM.412]
4024  */
4025 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut,LPMMTIME16 lpTime,
4026                                    UINT16 uSize)
4027 {
4028     LPWAVEOPENDESC      lpDesc;
4029     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
4030     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4031     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4032     return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
4033                        (DWORD)lpTime, (DWORD)uSize);
4034 }
4035
4036 #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \
4037         UINT32 WINAPI waveOut##xx##32(HWAVEOUT32 hWaveOut, atype x)     \
4038 {                                                                       \
4039         return waveOut##xx##16(hWaveOut,x);                             \
4040 }                                                                       \
4041 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x)             \
4042 {                                                                       \
4043         LPWAVEOPENDESC  lpDesc;                                         \
4044         TRACE(mmsys, "waveOut"#xx"(%04X, %08lx);\n", hWaveOut,(DWORD)x);\
4045         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);         \
4046         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;                \
4047         return wodMessage(lpDesc->uDeviceID, WODM_##XX, lpDesc->dwInstance,\
4048                           (DWORD)x, 0L);                                \
4049 }
4050
4051 WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH,DWORD*)
4052 WAVEOUT_SHORTCUT_1(SetPitch,SETPITCH,DWORD)
4053 WAVEOUT_SHORTCUT_1(GetPlaybackRate,GETPLAYBACKRATE,DWORD*)
4054 WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE,DWORD)
4055
4056 #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \
4057         UINT32 WINAPI waveOut##xx##32(UINT32 devid, atype x)            \
4058 {                                                                       \
4059         return waveOut##xx##16(devid,x);                                \
4060 }                                                                       \
4061 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x)                    \
4062 {                                                                       \
4063         TRACE(mmsys, "waveOut"#xx"(%04X, %08lx);\n", devid,(DWORD)x);   \
4064         return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L);          \
4065 }
4066
4067
4068 WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME,DWORD*)
4069 WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME,DWORD)
4070
4071
4072 /**************************************************************************
4073  *                              waveOutBreakLoop        [MMSYSTEM.419]
4074  */
4075 UINT32 WINAPI waveOutBreakLoop32(HWAVEOUT32 hWaveOut)
4076 {
4077     return waveOutBreakLoop16(hWaveOut);
4078 }
4079 /**************************************************************************
4080  *                              waveOutBreakLoop        [MMSYSTEM.419]
4081  */
4082 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut)
4083 {
4084     TRACE(mmsys, "(%04X)\n", hWaveOut);
4085     return MMSYSERR_INVALHANDLE;
4086 }
4087
4088 /**************************************************************************
4089  *                              waveOutGetID            [MMSYSTEM.420]
4090  */
4091 UINT32 WINAPI waveOutGetID32(HWAVEOUT32 hWaveOut, UINT32 * lpuDeviceID)
4092 {
4093     LPWAVEOPENDESC      lpDesc;
4094
4095     TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
4096
4097     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4098     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4099     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4100     *lpuDeviceID = lpDesc->uDeviceID;
4101     return 0;
4102 }
4103 /**************************************************************************
4104  *                              waveOutGetID            [MMSYSTEM.420]
4105  */
4106 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
4107 {
4108     LPWAVEOPENDESC      lpDesc;
4109
4110     TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
4111
4112     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4113     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4114     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4115     *lpuDeviceID = lpDesc->uDeviceID;
4116     return 0;
4117 }
4118
4119 /**************************************************************************
4120  *                              waveOutMessage          [MMSYSTEM.421]
4121  */
4122 DWORD WINAPI waveOutMessage32(HWAVEOUT32 hWaveOut, UINT32 uMessage,
4123                               DWORD dwParam1, DWORD dwParam2)
4124 {
4125     LPWAVEOPENDESC      lpDesc;
4126
4127     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4128     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4129     switch (uMessage) {
4130     case WODM_GETNUMDEVS:
4131     case WODM_GETPOS:
4132     case WODM_GETVOLUME:
4133     case WODM_GETPITCH:
4134     case WODM_GETPLAYBACKRATE:
4135     case WODM_SETVOLUME:
4136     case WODM_SETPITCH:
4137     case WODM_SETPLAYBACKRATE:
4138     case WODM_RESET:
4139     case WODM_PAUSE:
4140     case WODM_PREPARE:
4141     case WODM_UNPREPARE:
4142     case WODM_STOP:
4143     case WODM_CLOSE:
4144         /* no argument conversion needed */
4145         break;
4146     case WODM_WRITE:
4147         return waveOutWrite32(hWaveOut,(LPWAVEHDR)dwParam1,dwParam2);
4148     case WODM_GETDEVCAPS:
4149         /* FIXME: UNICODE/ANSI? */
4150         return waveOutGetDevCaps32A(hWaveOut,(LPWAVEOUTCAPS32A)dwParam1,dwParam2);
4151     case WODM_OPEN:
4152         FIXME(mmsys,"can't handle WODM_OPEN, please report.\n");
4153         break;
4154     default:
4155         ERR(mmsys,"(0x%04x,0x%04x,%08lx,%08lx): unhandled message\n",
4156             hWaveOut,uMessage,dwParam1,dwParam2);
4157         break;
4158     }
4159     return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4160 }
4161
4162 /**************************************************************************
4163  *                              waveOutMessage          [MMSYSTEM.421]
4164  */
4165 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
4166                               DWORD dwParam1, DWORD dwParam2)
4167 {
4168     LPWAVEOPENDESC      lpDesc;
4169
4170     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4171     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4172     switch (uMessage) {
4173     case WODM_GETNUMDEVS:
4174     case WODM_SETVOLUME:
4175     case WODM_SETPITCH:
4176     case WODM_SETPLAYBACKRATE:
4177     case WODM_RESET:
4178     case WODM_PAUSE:
4179     case WODM_STOP:
4180     case WODM_CLOSE:
4181         /* no argument conversion needed */
4182         break;
4183     case WODM_GETPOS:
4184         return waveOutGetPosition16(hWaveOut,(LPMMTIME16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4185     case WODM_GETVOLUME:
4186         return waveOutGetVolume16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
4187     case WODM_GETPITCH:
4188         return waveOutGetPitch16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
4189     case WODM_GETPLAYBACKRATE:
4190         return waveOutGetPlaybackRate16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
4191     case WODM_GETDEVCAPS:
4192         return waveOutGetDevCaps16(hWaveOut,(LPWAVEOUTCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4193     case WODM_PREPARE:
4194         return waveOutPrepareHeader16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4195     case WODM_UNPREPARE:
4196         return waveOutUnprepareHeader16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4197     case WODM_WRITE:
4198         return waveOutWrite16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4199     case WODM_OPEN:
4200         FIXME(mmsys,"can't handle WODM_OPEN, please report.\n");
4201         break;
4202     default:
4203         ERR(mmsys,"(0x%04x,0x%04x,%08lx,%08lx): unhandled message\n",
4204             hWaveOut,uMessage,dwParam1,dwParam2);
4205     }
4206     return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4207 }
4208
4209 /**************************************************************************
4210  *                              waveInGetNumDevs                [WINMM.151]
4211  */
4212 UINT32 WINAPI waveInGetNumDevs32()
4213 {
4214     return waveInGetNumDevs16();
4215 }
4216
4217 /**************************************************************************
4218  *                              waveInGetNumDevs                [MMSYSTEM.501]
4219  */
4220 UINT16 WINAPI waveInGetNumDevs16()
4221 {
4222     UINT16      count = 0;
4223
4224     TRACE(mmsys, "waveInGetNumDevs\n");
4225     count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
4226     TRACE(mmsys, "waveInGetNumDevs return %u \n", count);
4227     return count;
4228 }
4229
4230 /**************************************************************************
4231  *                              waveInGetDevCapsA               [WINMM.147]
4232  */
4233 UINT32 WINAPI waveInGetDevCaps32W(UINT32 uDeviceID, LPWAVEINCAPS32W lpCaps, UINT32 uSize)
4234 {
4235     WAVEINCAPS16        wic16;
4236     UINT32      ret = waveInGetDevCaps16(uDeviceID,&wic16,uSize);
4237
4238     lpCaps->wMid = wic16.wMid;
4239     lpCaps->wPid = wic16.wPid;
4240     lpCaps->vDriverVersion = wic16.vDriverVersion;
4241     lstrcpyAtoW(lpCaps->szPname,wic16.szPname);
4242     lpCaps->dwFormats = wic16.dwFormats;
4243     lpCaps->wChannels = wic16.wChannels;
4244
4245     return ret;
4246 }
4247 /**************************************************************************
4248  *                              waveInGetDevCapsA               [WINMM.146]
4249  */
4250 UINT32 WINAPI waveInGetDevCaps32A(UINT32 uDeviceID, LPWAVEINCAPS32A lpCaps, UINT32 uSize)
4251 {
4252     WAVEINCAPS16        wic16;
4253     UINT32      ret = waveInGetDevCaps16(uDeviceID,&wic16,uSize);
4254
4255     lpCaps->wMid = wic16.wMid;
4256     lpCaps->wPid = wic16.wPid;
4257     lpCaps->vDriverVersion = wic16.vDriverVersion;
4258     strcpy(lpCaps->szPname,wic16.szPname);
4259     lpCaps->dwFormats = wic16.dwFormats;
4260     lpCaps->wChannels = wic16.wChannels;
4261     return ret;
4262 }
4263 /**************************************************************************
4264  *                              waveInGetDevCaps                [MMSYSTEM.502]
4265  */
4266 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize)
4267 {
4268     TRACE(mmsys, "waveInGetDevCaps\n");
4269     return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
4270 }
4271
4272 /**************************************************************************
4273  *                              waveInGetErrorTextA     [WINMM.148]
4274  */
4275 UINT32 WINAPI waveInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
4276 {
4277     TRACE(mmsys, "waveInGetErrorText\n");
4278     return(waveGetErrorText(uError, lpText, uSize));
4279 }
4280
4281 /**************************************************************************
4282  *                              waveInGetErrorTextW     [WINMM.149]
4283  */
4284 UINT32 WINAPI waveInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
4285 {
4286     LPSTR txt = HeapAlloc(GetProcessHeap(),0,uSize);
4287     UINT32      ret = waveGetErrorText(uError, txt, uSize);
4288
4289     lstrcpyAtoW(lpText,txt);
4290     HeapFree(GetProcessHeap(),0,txt);
4291     return ret;
4292 }
4293
4294 /**************************************************************************
4295  *                              waveInGetErrorText      [MMSYSTEM.503]
4296  */
4297 UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
4298 {
4299     TRACE(mmsys, "waveInGetErrorText\n");
4300     return(waveGetErrorText(uError, lpText, uSize));
4301 }
4302
4303
4304 /**************************************************************************
4305  *                              waveInOpen                      [WINMM.154]
4306  */
4307 UINT32 WINAPI waveInOpen32(HWAVEIN32 * lphWaveIn, UINT32 uDeviceID,
4308                            const LPWAVEFORMAT lpFormat, DWORD dwCallback,
4309                            DWORD dwInstance, DWORD dwFlags)
4310 {
4311     HWAVEIN16   hwin16;
4312     UINT32      ret = waveInOpen16(&hwin16,uDeviceID,lpFormat,dwCallback,dwInstance,
4313                                  CALLBACK32CONV(dwFlags));
4314     if (lphWaveIn) *lphWaveIn = hwin16;
4315     return ret;
4316 }
4317
4318 /**************************************************************************
4319  *                              waveInOpen                      [MMSYSTEM.504]
4320  */
4321 UINT16 WINAPI waveInOpen16(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
4322                            const LPWAVEFORMAT lpFormat, DWORD dwCallback,
4323                            DWORD dwInstance, DWORD dwFlags)
4324 {
4325     HWAVEIN16 hWaveIn;
4326     LPWAVEOPENDESC      lpDesc;
4327     DWORD       dwRet = 0;
4328     BOOL32      bMapperFlg = FALSE;
4329
4330     TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
4331           lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
4332     if (dwFlags & WAVE_FORMAT_QUERY)
4333         TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
4334     if (uDeviceID == (UINT16)WAVE_MAPPER) {
4335         TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
4336         bMapperFlg = TRUE;
4337         uDeviceID = 0;
4338     }
4339     if (lpFormat == NULL) return WAVERR_BADFORMAT;
4340     hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
4341     if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
4342     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4343     if (lpDesc == NULL) return MMSYSERR_NOMEM;
4344     lpDesc->hWave = hWaveIn;
4345     lpDesc->lpFormat = lpFormat;
4346     lpDesc->dwCallBack = dwCallback;
4347     lpDesc->dwInstance = dwInstance;
4348     while (uDeviceID < MAXWAVEDRIVERS) {
4349         dwRet = widMessage(uDeviceID, WIDM_OPEN,
4350                            lpDesc->dwInstance, (DWORD)lpDesc, 0L);
4351         if (dwRet == MMSYSERR_NOERROR) break;
4352         if (!bMapperFlg) break;
4353         uDeviceID++;
4354         TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
4355     }
4356     lpDesc->uDeviceID = uDeviceID;
4357     if (dwFlags & WAVE_FORMAT_QUERY) {
4358         TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
4359         dwRet = waveInClose16(hWaveIn);
4360     }
4361     return dwRet;
4362 }
4363
4364 /**************************************************************************
4365  *                              waveInClose                     [WINMM.145]
4366  */
4367 UINT32 WINAPI waveInClose32(HWAVEIN32 hWaveIn)
4368 {
4369     return waveInClose16(hWaveIn);
4370 }
4371 /**************************************************************************
4372  *                              waveInClose                     [MMSYSTEM.505]
4373  */
4374 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
4375 {
4376     LPWAVEOPENDESC      lpDesc;
4377
4378     TRACE(mmsys, "(%04X)\n", hWaveIn);
4379     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4380     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4381     return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
4382 }
4383
4384 /**************************************************************************
4385  *                              waveInPrepareHeader             [WINMM.155]
4386  */
4387 UINT32 WINAPI waveInPrepareHeader32(HWAVEIN32 hWaveIn,
4388                                     WAVEHDR * lpWaveInHdr, UINT32 uSize)
4389 {
4390     LPWAVEOPENDESC      lpDesc;
4391
4392     TRACE(mmsys, "(%04X, %p, %u);\n",
4393           hWaveIn, lpWaveInHdr, uSize);
4394     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4395     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4396     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4397     lpWaveInHdr = lpWaveInHdr;
4398     lpWaveInHdr->lpNext = NULL;
4399     lpWaveInHdr->dwBytesRecorded = 0;
4400     TRACE(mmsys, "lpData=%p size=%lu \n",
4401           lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4402     return widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
4403                       (DWORD)lpWaveInHdr, uSize);
4404 }
4405 /**************************************************************************
4406  *                              waveInPrepareHeader             [MMSYSTEM.506]
4407  */
4408 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
4409                                     WAVEHDR * lpWaveInHdr, UINT16 uSize)
4410 {
4411     LPWAVEOPENDESC      lpDesc;
4412     LPBYTE              saveddata = lpWaveInHdr->lpData;
4413     UINT16              ret;
4414
4415     TRACE(mmsys, "(%04X, %p, %u);\n",
4416           hWaveIn, lpWaveInHdr, uSize);
4417     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4418     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4419     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4420     lpWaveInHdr = lpWaveInHdr;
4421     lpWaveInHdr->lpNext = NULL;
4422     lpWaveInHdr->dwBytesRecorded = 0;
4423
4424     TRACE(mmsys, "lpData=%p size=%lu \n",
4425           lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4426     lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
4427     ret = widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
4428                      (DWORD)lpWaveInHdr,uSize);
4429     lpWaveInHdr->lpData = saveddata;
4430     return ret;
4431 }
4432
4433
4434 /**************************************************************************
4435  *                              waveInUnprepareHeader   [WINMM.159]
4436  */
4437 UINT32 WINAPI waveInUnprepareHeader32(HWAVEIN32 hWaveIn,
4438                                       WAVEHDR * lpWaveInHdr, UINT32 uSize)
4439 {
4440     LPWAVEOPENDESC      lpDesc;
4441
4442     TRACE(mmsys, "(%04X, %p, %u);\n",
4443           hWaveIn, lpWaveInHdr, uSize);
4444     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4445     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4446     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4447     /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4448     lpWaveInHdr->lpData = NULL;
4449     lpWaveInHdr->lpNext = NULL;
4450     return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
4451                       (DWORD)lpWaveInHdr, uSize);
4452 }
4453 /**************************************************************************
4454  *                              waveInUnprepareHeader   [MMSYSTEM.507]
4455  */
4456 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,
4457                                       WAVEHDR * lpWaveInHdr, UINT16 uSize)
4458 {
4459     LPWAVEOPENDESC      lpDesc;
4460
4461     TRACE(mmsys, "(%04X, %p, %u);\n",
4462           hWaveIn, lpWaveInHdr, uSize);
4463     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4464     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4465     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4466     /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4467     lpWaveInHdr->lpData = NULL;
4468     lpWaveInHdr->lpNext = NULL;
4469     return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
4470                       (DWORD)lpWaveInHdr, uSize);
4471 }
4472
4473 /**************************************************************************
4474  *                              waveInAddBuffer         [WINMM.144]
4475  */
4476 UINT32 WINAPI waveInAddBuffer32(HWAVEIN32 hWaveIn,
4477                                 WAVEHDR * lpWaveInHdr, UINT32 uSize)
4478 {
4479     LPWAVEOPENDESC      lpDesc;
4480
4481     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4482     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4483     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4484     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4485     lpWaveInHdr->lpNext = NULL;
4486     lpWaveInHdr->dwBytesRecorded = 0;
4487     TRACE(mmsys, "lpData=%p size=%lu \n",
4488           lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4489     return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
4490                       (DWORD)lpWaveInHdr, uSize);
4491
4492 }
4493
4494 /**************************************************************************
4495  *                              waveInAddBuffer         [MMSYSTEM.508]
4496  */
4497 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,
4498                                 WAVEHDR * lpWaveInHdr, UINT16 uSize)
4499 {
4500     LPWAVEOPENDESC      lpDesc;
4501     UINT16              ret;
4502
4503     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4504     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4505     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4506     if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4507     lpWaveInHdr->lpNext = NULL;
4508     lpWaveInHdr->dwBytesRecorded = 0;
4509     lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
4510     TRACE(mmsys, "lpData=%p size=%lu \n",
4511           lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4512     ret = widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
4513                      (DWORD)lpWaveInHdr, uSize);
4514     /*lpWaveInHdr->lpData = saveddata;*/
4515     return ret;
4516 }
4517
4518 /**************************************************************************
4519  *                              waveInStart                     [WINMM.157]
4520  */
4521 UINT32 WINAPI waveInStart32(HWAVEIN32 hWaveIn)
4522 {
4523     return waveInStart16(hWaveIn);
4524 }
4525
4526 /**************************************************************************
4527  *                              waveInStart                     [MMSYSTEM.509]
4528  */
4529 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn)
4530 {
4531     LPWAVEOPENDESC      lpDesc;
4532
4533     TRACE(mmsys, "(%04X)\n", hWaveIn);
4534     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4535     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4536     return widMessage(lpDesc->uDeviceID,WIDM_START,lpDesc->dwInstance,0,0);
4537 }
4538
4539 /**************************************************************************
4540  *                              waveInStop                      [WINMM.158]
4541  */
4542 UINT32 WINAPI waveInStop32(HWAVEIN32 hWaveIn)
4543 {
4544     return waveInStop16(hWaveIn);
4545 }
4546
4547 /**************************************************************************
4548  *                              waveInStop                      [MMSYSTEM.510]
4549  */
4550 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn)
4551 {
4552     LPWAVEOPENDESC      lpDesc;
4553
4554     TRACE(mmsys, "(%04X)\n", hWaveIn);
4555     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4556     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4557     return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
4558 }
4559
4560 /**************************************************************************
4561  *                              waveInReset                     [WINMM.156]
4562  */
4563 UINT32 WINAPI waveInReset32(HWAVEIN32 hWaveIn)
4564 {
4565     return waveInReset16(hWaveIn);
4566 }
4567
4568 /**************************************************************************
4569  *                              waveInReset                     [MMSYSTEM.511]
4570  */
4571 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn)
4572 {
4573     LPWAVEOPENDESC      lpDesc;
4574
4575     TRACE(mmsys, "(%04X)\n", hWaveIn);
4576     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4577     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4578     return widMessage(lpDesc->uDeviceID,WIDM_RESET,lpDesc->dwInstance,0,0);
4579 }
4580
4581 /**************************************************************************
4582  *                              waveInGetPosition       [WINMM.152]
4583  */
4584 UINT32 WINAPI waveInGetPosition32(HWAVEIN32 hWaveIn, LPMMTIME32 lpTime,
4585                                   UINT32 uSize)
4586 {
4587     MMTIME16    mmt16;
4588     UINT32      ret;
4589
4590     mmt16.wType = lpTime->wType;
4591     ret = waveInGetPosition16(hWaveIn,&mmt16,uSize);
4592
4593     MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
4594     return ret;
4595 }
4596
4597 /**************************************************************************
4598  *                              waveInGetPosition       [MMSYSTEM.512]
4599  */
4600 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn,LPMMTIME16 lpTime,
4601                                   UINT16 uSize)
4602 {
4603     LPWAVEOPENDESC      lpDesc;
4604
4605     TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
4606     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4607     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4608     return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
4609                       (DWORD)lpTime, (DWORD)uSize);
4610 }
4611
4612 /**************************************************************************
4613  *                              waveInGetID                     [WINMM.150]
4614  */
4615 UINT32 WINAPI waveInGetID32(HWAVEIN32 hWaveIn, UINT32 * lpuDeviceID)
4616 {
4617     LPWAVEOPENDESC      lpDesc;
4618
4619     TRACE(mmsys, "waveInGetID\n");
4620     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4621     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4622     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4623     *lpuDeviceID = lpDesc->uDeviceID;
4624     return 0;
4625 }
4626
4627
4628 /**************************************************************************
4629  *                              waveInGetID                     [MMSYSTEM.513]
4630  */
4631 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
4632 {
4633     LPWAVEOPENDESC      lpDesc;
4634
4635     TRACE(mmsys, "waveInGetID\n");
4636     if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4637     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4638     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4639     *lpuDeviceID = lpDesc->uDeviceID;
4640     return 0;
4641 }
4642
4643 /**************************************************************************
4644  *                              waveInMessage           [WINMM.153]
4645  */
4646 DWORD WINAPI waveInMessage32(HWAVEIN32 hWaveIn, UINT32 uMessage,
4647                              DWORD dwParam1, DWORD dwParam2)
4648 {
4649     LPWAVEOPENDESC      lpDesc;
4650
4651     FIXME(mmsys, "(%04X, %04X, %08lX, %08lX),FIXME!\n",
4652           hWaveIn, uMessage, dwParam1, dwParam2);
4653     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4654     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4655     switch (uMessage) {
4656     case WIDM_OPEN:
4657         FIXME(mmsys, "cannot handle WIDM_OPEN, please report.\n");
4658         break;
4659     case WIDM_GETNUMDEVS:
4660     case WIDM_GETPOS:
4661     case WIDM_CLOSE:
4662     case WIDM_STOP :
4663     case WIDM_RESET:
4664     case WIDM_START:
4665     case WIDM_PREPARE:
4666     case WIDM_UNPREPARE:
4667     case WIDM_ADDBUFFER:
4668     case WIDM_PAUSE:
4669         /* no argument conversion needed */
4670         break;
4671     case WIDM_GETDEVCAPS:
4672         /*FIXME: ANSI/UNICODE */
4673         return waveInGetDevCaps32A(hWaveIn,(LPWAVEINCAPS32A)dwParam1,dwParam2);
4674     default:
4675         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4676             hWaveIn,uMessage,dwParam1,dwParam2);
4677         break;
4678     }
4679     return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4680 }
4681
4682 /**************************************************************************
4683  *                              waveInMessage           [MMSYSTEM.514]
4684  */
4685 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
4686                              DWORD dwParam1, DWORD dwParam2)
4687 {
4688     LPWAVEOPENDESC      lpDesc;
4689
4690     FIXME(mmsys, "(%04X, %04X, %08lX, %08lX),FIXME!\n",
4691           hWaveIn, uMessage, dwParam1, dwParam2);
4692     lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4693     if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4694     switch (uMessage) {
4695     case WIDM_OPEN:
4696         FIXME(mmsys,"cannot handle WIDM_OPEN, please report.\n");
4697         break;
4698     case WIDM_GETNUMDEVS:
4699     case WIDM_CLOSE:
4700     case WIDM_STOP :
4701     case WIDM_RESET:
4702     case WIDM_START:
4703     case WIDM_PAUSE:
4704         /* no argument conversion needed */
4705         break;
4706     case WIDM_GETDEVCAPS:
4707         return waveInGetDevCaps16(hWaveIn,(LPWAVEINCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4708     case WIDM_GETPOS:
4709         return waveInGetPosition16(hWaveIn,(LPMMTIME16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4710     case WIDM_PREPARE:
4711         return waveInPrepareHeader16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4712     case WIDM_UNPREPARE:
4713         return waveInUnprepareHeader16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4714     case WIDM_ADDBUFFER:
4715         return waveInAddBuffer16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
4716     default:
4717         ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4718             hWaveIn,uMessage,dwParam1,dwParam2);
4719         break;
4720     }
4721     return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4722 }
4723
4724 /**************************************************************************
4725  *                              DrvOpen                 [MMSYSTEM.1100]
4726  */
4727 HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
4728 {
4729     TRACE(mmsys,"('%s','%s',%08lX);\n",lpDriverName,lpSectionName,lParam);
4730
4731     return OpenDriver16(lpDriverName, lpSectionName, lParam);
4732 }
4733
4734
4735 /**************************************************************************
4736  *                              DrvClose                [MMSYSTEM.1101]
4737  */
4738 LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
4739 {
4740     TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
4741
4742     return CloseDriver16(hDrvr, lParam1, lParam2);
4743 }
4744
4745
4746 /**************************************************************************
4747  *                              DrvSendMessage          [MMSYSTEM.1102]
4748  */
4749 LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1,
4750                               LPARAM lParam2)
4751 {
4752     /* DWORD    dwDriverID = 0; */
4753
4754     FIXME(mmsys, "(%04X, %04X, %08lX, %08lX);\n", hDriver, msg, lParam1, lParam2);
4755     return MMSYSERR_NOTENABLED;
4756     /* FIXME: wrong ... */
4757     /* should known the mapping between hDrv and wDevIDs */
4758     /* MCICDAUDIO_DriverProc16(dwDriverID, hDriver, msg, lParam1, lParam2); */
4759 }
4760
4761 /**************************************************************************
4762  *                              DrvGetModuleHandle      [MMSYSTEM.1103]
4763  */
4764 HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrvr)
4765 {
4766     return GetDriverModuleHandle16(hDrvr);
4767 }
4768
4769 /**************************************************************************
4770  *                              DrvDefDriverProc        [MMSYSTEM.1104]
4771  */
4772 LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
4773                                 DWORD dwParam1, DWORD dwParam2)
4774 {
4775     return DefDriverProc16(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
4776 }
4777
4778 /**************************************************************************
4779  *                              DefDriverProc32  [WINMM.5]
4780  */
4781 LRESULT WINAPI DefDriverProc32(DWORD dwDriverIdentifier, HDRVR32 hdrvr,
4782                                UINT32 Msg, LPARAM lParam1, LPARAM lParam2)
4783 {
4784     switch (Msg) {
4785       case DRV_LOAD:
4786       case DRV_DISABLE:
4787       case DRV_INSTALL:
4788         return 0;
4789       case DRV_ENABLE:
4790       case DRV_FREE:
4791       case DRV_REMOVE:
4792         return 1;
4793       default:
4794         return 0;
4795     }
4796 }
4797
4798 /**************************************************************************
4799  *                              mmThreadCreate          [MMSYSTEM.1120]
4800  */
4801 LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4)
4802 {
4803     FIXME(mmsys,"(%p,%p,%08lx,%08lx): stub!\n",x1,x2,x3,x4);
4804     *x2 = 0xbabe;
4805     return 0;
4806 }
4807
4808 /**************************************************************************
4809  *                              mmThreadGetTask         [MMSYSTEM.1125]
4810  */
4811 LRESULT WINAPI mmThreadGetTask16(WORD hnd) {
4812     FIXME(mmsys,"(%04x): stub!\n",hnd);
4813     return GetCurrentTask();
4814 }
4815
4816 /**************************************************************************
4817  *                              mmThreadSignal          [MMSYSTEM.1121]
4818  */
4819 LRESULT WINAPI mmThreadSignal16(WORD hnd)
4820 {
4821     FIXME(mmsys,"(%04x): stub!\n",hnd);
4822     return 0;
4823 }
4824
4825 /**************************************************************************
4826  *                              mmTaskCreate            [MMSYSTEM.900]
4827  */
4828 HINSTANCE16 WINAPI mmTaskCreate16(LPWORD lphnd,HINSTANCE16 *hMmTask,DWORD x2)
4829 {
4830     DWORD showCmd = 0x40002;
4831     LPSTR cmdline;
4832     WORD sel1, sel2;
4833     LOADPARAMS *lp;
4834     HINSTANCE16 ret, handle;
4835
4836     TRACE(mmsys,"(%p,%p,%08lx);\n",lphnd,hMmTask,x2);
4837     cmdline = (LPSTR)HeapAlloc(GetProcessHeap(), 0, 0x0d);
4838     cmdline[0] = 0x0d;
4839     (DWORD)cmdline[1] = (DWORD)lphnd;
4840     (DWORD)cmdline[5] = x2;
4841     (DWORD)cmdline[9] = 0;
4842
4843     sel1 = SELECTOR_AllocBlock(cmdline, 0x0d, SEGMENT_DATA, FALSE, FALSE);
4844     sel2 = SELECTOR_AllocBlock(&showCmd, sizeof(showCmd),
4845                                SEGMENT_DATA, FALSE, FALSE);
4846
4847     lp = (LOADPARAMS *)HeapAlloc(GetProcessHeap(), 0, sizeof(LOADPARAMS));
4848     lp->hEnvironment = 0;
4849     lp->cmdLine = PTR_SEG_OFF_TO_SEGPTR(sel1, 0);
4850     lp->showCmd = PTR_SEG_OFF_TO_SEGPTR(sel2, 0);
4851     lp->reserved = 0;
4852
4853     ret = LoadModule16("c:\\windows\\mmtask.tsk", lp);
4854     if (ret < 32) {
4855         if (ret)
4856             ret = 1;
4857         else
4858             ret = 2;
4859         handle = 0;
4860     }
4861     else {
4862         handle = ret;
4863         ret = 0;
4864     }
4865     if (hMmTask)
4866         *(HINSTANCE16 *)PTR_SEG_TO_LIN(hMmTask) = handle;
4867
4868     UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel2, 0));
4869     UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel1, 0));
4870
4871     HeapFree(GetProcessHeap(), 0, lp);
4872     HeapFree(GetProcessHeap(), 0, cmdline);
4873
4874     return ret;
4875 }
4876
4877 /**************************************************************************
4878  *                              mmTaskSignal            [MMSYSTEM.903]
4879  */
4880 LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
4881 {
4882     TRACE(mmsys,"(%04x);\n",ht);
4883     return PostAppMessage16(ht,WM_USER,0,0);
4884 }
4885
4886