git.oblomov.eu Git - wine/blob - multimedia/mmsystem.c

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