multimedia/mmsystem.c

   1 /*
   2  * MMSYTEM functions
   3  *
   4  * Copyright 1993 Martin Ayotte
   5  */
   6 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
   7  *        and long term pointers to 16 bit space in here
   8  */
   9
  10 #include <unistd.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <fcntl.h>
  15 #include <errno.h>
  16 #include <sys/ioctl.h>
  17 #include "windows.h"
  18 #include "win.h"
  19 #include "heap.h"
  20 #include "ldt.h"
  21 #include "user.h"
  22 #include "driver.h"
  23 #include "file.h"
  24 #include "mmsystem.h"
  25 #include "stddebug.h"
  26 #include "debug.h"
  27 #include "xmalloc.h"
  28 #include "callback.h"
  29
  30 static int      InstalledCount;
  31 static int      InstalledListLen;
  32 static LPSTR    lpInstallNames = NULL;
  33
  34 MCI_OPEN_DRIVER_PARMS   mciDrv[MAXMCIDRIVERS];
  35 /* struct below is to remember alias/devicenames for mcistring.c
  36  * FIXME: should use some internal struct ...
  37  */
  38 MCI_OPEN_PARMS          mciOpenDrv[MAXMCIDRIVERS];
  39
  40 UINT16 midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
  41 UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
  42 LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
  43                              DWORD dwParam1, DWORD dwParam2);
  44
  45 LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
  46                      DWORD dwParam1, DWORD dwParam2);
  47 LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
  48                      DWORD dwParam1, DWORD dwParam2);
  49 LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
  50                         DWORD dwParam1, DWORD dwParam2);
  51 LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
  52                      DWORD dwParam1, DWORD dwParam2);
  53
  54
  55 #define GetDrv(wDevID) (&mciDrv[MMSYSTEM_DevIDToIndex(wDevID)])
  56 #define GetOpenDrv(wDevID) (&mciOpenDrv[MMSYSTEM_DevIDToIndex(wDevID)])
  57
  58 /* The wDevID's returned by wine were originally in the range
  59  * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices.
  60  * Unfortunately, ms-windows uses wDevID of zero to indicate
  61  * errors.  Now, multimedia drivers must pass the wDevID through
  62  * MMSYSTEM_DevIDToIndex to get an index in that range.  An
  63  * aribtrary value, MMSYSTEM_MAGIC is added to the wDevID seen
  64  * by the windows programs.
  65  */
  66
  67 #define MMSYSTEM_MAGIC 0x0F00
  68
  69 /**************************************************************************
  70 *                               MMSYSTEM_DevIDToIndex   [internal]
  71 */
  72 int MMSYSTEM_DevIDToIndex(UINT16 wDevID) {
  73         return wDevID - MMSYSTEM_MAGIC;
  74 }
  75
  76 /**************************************************************************
  77 *                               MMSYSTEM_FirstDevId     [internal]
  78 */
  79 UINT16 MMSYSTEM_FirstDevID(void)
  80 {
  81         return MMSYSTEM_MAGIC;
  82 }
  83
  84 /**************************************************************************
  85 *                               MMSYSTEM_NextDevId      [internal]
  86 */
  87 UINT16 MMSYSTEM_NextDevID(UINT16 wDevID) {
  88         return wDevID + 1;
  89 }
  90
  91 /**************************************************************************
  92 *                               MMSYSTEM_DevIdValid     [internal]
  93 */
  94 BOOL32 MMSYSTEM_DevIDValid(UINT16 wDevID) {
  95         return wDevID >= 0x0F00 && wDevID < (0x0F00 + MAXMCIDRIVERS);
  96 }
  97
  98 /**************************************************************************
  99 *                               MMSYSTEM_WEP            [MMSYSTEM.1]
 100 */
 101 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
 102                         WORD cbHeapSize, LPSTR lpCmdLine)
 103 {
 104         fprintf(stderr, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
 105         return(TRUE);
 106 }
 107
 108 /**************************************************************************
 109 *                               PlaySoundA              [WINMM.1]
 110 */
 111 BOOL32 WINAPI PlaySound32A(LPCSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
 112 {
 113   dprintf_mmsys(stddeb, "PlaySoundA: pszSound='%s' hmod=%04X fdwSound=%08lX\n",
 114                 pszSound, hmod, fdwSound);
 115   if(hmod != 0 || !(fdwSound & SND_FILENAME)) {
 116     fprintf(stderr, "PlaySoundA: only disk sound files are supported\n");
 117     return FALSE;
 118   } else {
 119     BOOL16 bSound;
 120     bSound = sndPlaySound(pszSound, (UINT16) fdwSound);
 121     return (BOOL32) bSound;
 122   }
 123 }
 124
 125 /**************************************************************************
 126 *                               PlaySoundW              [WINMM.18]
 127 */
 128 BOOL32 WINAPI PlaySound32W(LPCWSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
 129 {
 130   LPSTR pszSoundA = xmalloc((lstrlen32W(pszSound)+1)*sizeof(WCHAR));
 131   BOOL32 bSound;
 132   lstrcpyWtoA(pszSoundA, pszSound);
 133   bSound = PlaySound32A(pszSoundA, hmod, fdwSound);
 134   free(pszSoundA);
 135   return bSound;
 136 }
 137
 138 /**************************************************************************
 139 *                               sndPlaySound            [MMSYSTEM.2]
 140 */
 141 BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
 142 {
 143         BOOL16                  bRet = FALSE;
 144         HMMIO16                 hmmio;
 145         MMCKINFO                ckMainRIFF;
 146         char                    str[128];
 147         LPSTR                   ptr;
 148
 149         dprintf_mmsys(stddeb, "sndPlaySound // SoundName='%s' uFlags=%04X !\n",
 150                                                                         lpszSoundName, uFlags);
 151         if (lpszSoundName == NULL) {
 152                 dprintf_mmsys(stddeb, "sndPlaySound // Stop !\n");
 153                 return FALSE;
 154                 }
 155         hmmio = mmioOpen((LPSTR)lpszSoundName, NULL,
 156                 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 157
 158         if (uFlags & SND_MEMORY) {
 159                 dprintf_mmsys(stddeb, "sndPlaySound // SND_MEMORY flag not implemented!\n");
 160                 return FALSE;
 161         }
 162
 163         if (hmmio == 0)
 164         {
 165                 dprintf_mmsys(stddeb, "sndPlaySound // searching in SystemSound List !\n");
 166                 GetProfileString32A("Sounds", (LPSTR)lpszSoundName, "", str, sizeof(str));
 167                 if (strlen(str) == 0) return FALSE;
 168                 if ( (ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0';
 169                 hmmio = mmioOpen(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 170                 if (hmmio == 0)
 171                 {
 172                         dprintf_mmsys(stddeb, "sndPlaySound // can't find SystemSound='%s' !\n", str);
 173                         return FALSE;
 174                 }
 175         }
 176
 177         if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
 178         {
 179             dprintf_mmsys(stddeb, "sndPlaySound // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
 180                                 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
 181
 182             if ((ckMainRIFF.ckid == FOURCC_RIFF) &&
 183                 (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E')))
 184             {
 185                 MMCKINFO        mmckInfo;
 186
 187                 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
 188
 189                 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0)
 190                 {
 191                     PCMWAVEFORMAT           pcmWaveFormat;
 192
 193                     dprintf_mmsys(stddeb, "sndPlaySound // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
 194                                 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
 195
 196                     if (mmioRead(hmmio, (HPSTR) &pcmWaveFormat,
 197                                 (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT))
 198                     {
 199
 200                         dprintf_mmsys(stddeb, "sndPlaySound // wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
 201                         dprintf_mmsys(stddeb, "sndPlaySound // nChannels=%d \n", pcmWaveFormat.wf.nChannels);
 202                         dprintf_mmsys(stddeb, "sndPlaySound // nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
 203                         dprintf_mmsys(stddeb, "sndPlaySound // nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
 204                         dprintf_mmsys(stddeb, "sndPlaySound // nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
 205                         dprintf_mmsys(stddeb, "sndPlaySound // wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample);
 206
 207                         mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
 208                         if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0)
 209                         {
 210                             LPWAVEFORMAT     lpFormat   = (LPWAVEFORMAT) SEGPTR_ALLOC(sizeof(PCMWAVEFORMAT));
 211                             LPWAVEOPENDESC   lpWaveDesc = (LPWAVEOPENDESC) SEGPTR_ALLOC(sizeof(WAVEOPENDESC));
 212                             DWORD            dwRet;
 213
 214                             dprintf_mmsys(stddeb, "sndPlaySound // Chunk Found \
 215  ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
 216
 217                             pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec *
 218                                                            pcmWaveFormat.wf.nBlockAlign;
 219                             memcpy(lpFormat, &pcmWaveFormat, sizeof(PCMWAVEFORMAT));
 220
 221                             lpWaveDesc->hWave    = 0;
 222                             lpWaveDesc->lpFormat = (LPWAVEFORMAT) SEGPTR_GET(lpFormat);
 223
 224                             dwRet = wodMessage( 0,
 225                                                 WODM_OPEN, 0, (DWORD)SEGPTR_GET(lpWaveDesc), CALLBACK_NULL);
 226                             SEGPTR_FREE(lpFormat);
 227                             SEGPTR_FREE(lpWaveDesc);
 228
 229                             if (dwRet == MMSYSERR_NOERROR)
 230                             {
 231                                 LPWAVEHDR    lpWaveHdr = (LPWAVEHDR) SEGPTR_ALLOC(sizeof(WAVEHDR));
 232                                 SEGPTR       spWaveHdr = SEGPTR_GET(lpWaveHdr);
 233                                 HGLOBAL16    hData;
 234                                 INT32        count, bufsize;
 235
 236                                 bufsize = 64000;
 237                                 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
 238                                 lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData);
 239                                 lpWaveHdr->dwBufferLength = bufsize;
 240                                 lpWaveHdr->dwUser = 0L;
 241                                 lpWaveHdr->dwFlags = 0L;
 242                                 lpWaveHdr->dwLoops = 0L;
 243
 244                                 dwRet = wodMessage( 0,
 245                                                     WODM_PREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR));
 246                                 if (dwRet == MMSYSERR_NOERROR)
 247                                 {
 248                                     while( TRUE )
 249                                     {
 250                                         count = mmioRead(hmmio, PTR_SEG_TO_LIN(lpWaveHdr->lpData), bufsize);
 251                                         if (count < 1) break;
 252                                         lpWaveHdr->dwBufferLength = count;
 253                                 /*      lpWaveHdr->dwBytesRecorded = count; */
 254                                         wodMessage( 0, WODM_WRITE,
 255                                                     0, (DWORD)spWaveHdr, sizeof(WAVEHDR));
 256                                     }
 257                                     wodMessage( 0,
 258                                                 WODM_UNPREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR));
 259                                     wodMessage( 0,
 260                                                 WODM_CLOSE, 0, 0L, 0L);
 261
 262                                     bRet = TRUE;
 263                                 }
 264                                 else dprintf_mmsys(stddeb, "sndPlaySound // can't prepare WaveOut device !\n");
 265
 266                                 GlobalUnlock16(hData);
 267                                 GlobalFree16(hData);
 268
 269                                 SEGPTR_FREE(lpWaveHdr);
 270                             }
 271                         }
 272                     }
 273                 }
 274             }
 275         }
 276
 277         if (hmmio != 0) mmioClose(hmmio, 0);
 278         return bRet;
 279 }
 280
 281 /**************************************************************************
 282 *                               mmsystemGetVersion      [MMSYSTEM.5]
 283 */
 284 WORD WINAPI mmsystemGetVersion()
 285 {
 286         dprintf_mmsys(stddeb, "mmsystemGetVersion // 0.4.0 ...?... :-) !\n");
 287         return 0x0040;
 288 }
 289
 290 /**************************************************************************
 291 *                               DriverProc      [MMSYSTEM.6]
 292 */
 293 LRESULT WINAPI DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
 294                           DWORD dwParam1, DWORD dwParam2)
 295 {
 296         return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 297 }
 298
 299 /**************************************************************************
 300 *                               DriverCallback  [MMSYSTEM.31]
 301 */
 302 BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
 303                              WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
 304 {
 305         LPWAVEOPENDESC  lpDesc;
 306
 307         dprintf_mmsys(stddeb, "DriverCallback(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
 308                 dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
 309         switch(uFlags & DCB_TYPEMASK) {
 310                 case DCB_NULL:
 311                         dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_NULL !\n");
 312                         break;
 313                 case DCB_WINDOW:
 314                         dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_WINDOW = %04lX handle = %04X!\n",dwCallBack,hDev);
 315                         if (!IsWindow32(dwCallBack)) return FALSE;
 316                         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDev);
 317                         if (lpDesc == NULL) return FALSE;
 318
 319                         PostMessage16((HWND16)dwCallBack, wMsg, hDev, dwParam1);
 320                         break;
 321                 case DCB_TASK:
 322                         dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_TASK !\n");
 323                         return FALSE;
 324                 case DCB_FUNCTION:
 325                         dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_FUNCTION !\n");
 326                         CallDriverCallback( (FARPROC16)dwCallBack, hDev, wMsg,
 327                                             dwUser, dwParam1, dwParam2 );
 328                         break;
 329                 }
 330         return TRUE;
 331 }
 332
 333 /**************************************************************************
 334 *                               auxGetNumDevs           [MMSYSTEM.350]
 335 */
 336 UINT16 WINAPI auxGetNumDevs()
 337 {
 338         UINT16  count = 0;
 339         dprintf_mmsys(stddeb, "auxGetNumDevs !\n");
 340         count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
 341         dprintf_mmsys(stddeb, "auxGetNumDevs return %u \n", count);
 342         return count;
 343 }
 344
 345 /**************************************************************************
 346 *                               auxGetDevCaps           [MMSYSTEM.351]
 347 */
 348 UINT16 WINAPI auxGetDevCaps(UINT16 uDeviceID, AUXCAPS * lpCaps, UINT16 uSize)
 349 {
 350         dprintf_mmsys(stddeb, "auxGetDevCaps(%04X, %p, %d) !\n",
 351                                         uDeviceID, lpCaps, uSize);
 352         return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
 353                                 0L, (DWORD)lpCaps, (DWORD)uSize);
 354 }
 355
 356 /**************************************************************************
 357 *                               auxGetVolume            [MMSYSTEM.352]
 358 */
 359 UINT16 WINAPI auxGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume)
 360 {
 361         dprintf_mmsys(stddeb, "auxGetVolume(%04X, %p) !\n", uDeviceID, lpdwVolume);
 362         return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
 363 }
 364
 365 /**************************************************************************
 366 *                               auxSetVolume            [MMSYSTEM.353]
 367 */
 368 UINT16 WINAPI auxSetVolume(UINT16 uDeviceID, DWORD dwVolume)
 369 {
 370         dprintf_mmsys(stddeb, "auxSetVolume(%04X, %08lX) !\n", uDeviceID, dwVolume);
 371         return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
 372 }
 373
 374 /**************************************************************************
 375 *                               auxOutMessage           [MMSYSTEM.354]
 376 */
 377 DWORD WINAPI auxOutMessage(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
 378 {
 379         dprintf_mmsys(stddeb, "auxOutMessage(%04X, %04X, %08lX, %08lX)\n",
 380                                 uDeviceID, uMessage, dw1, dw2);
 381         return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2);
 382 }
 383
 384 /**************************************************************************
 385 *                               mciGetErrorString               [MMSYSTEM.706]
 386 */
 387 BOOL16 WINAPI mciGetErrorString (DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
 388 {
 389         LPSTR   msgptr;
 390         dprintf_mmsys(stddeb, "mciGetErrorString(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength);
 391         if ((lpstrBuffer == NULL) || (uLength < 1)) return(FALSE);
 392         lpstrBuffer[0] = '\0';
 393         switch(wError) {
 394                 case MCIERR_INVALID_DEVICE_ID:
 395                         msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
 396                         break;
 397                 case MCIERR_UNRECOGNIZED_KEYWORD:
 398                         msgptr = "The driver cannot recognize the specified command parameter.";
 399                         break;
 400                 case MCIERR_UNRECOGNIZED_COMMAND:
 401                         msgptr = "The driver cannot recognize the specified command.";
 402                         break;
 403                 case MCIERR_HARDWARE:
 404                         msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
 405                         break;
 406                 case MCIERR_INVALID_DEVICE_NAME:
 407                         msgptr = "The specified device is not open or is not recognized by MCI.";
 408                         break;
 409                 case MCIERR_OUT_OF_MEMORY:
 410                         msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
 411                         break;
 412                 case MCIERR_DEVICE_OPEN:
 413                         msgptr = "The device name is already being used as an alias by this application. Use a unique alias.";
 414                         break;
 415                 case MCIERR_CANNOT_LOAD_DRIVER:
 416                         msgptr = "There is an undetectable problem in loading the specified device driver.";
 417                         break;
 418                 case MCIERR_MISSING_COMMAND_STRING:
 419                         msgptr = "No command was specified.";
 420                         break;
 421                 case MCIERR_PARAM_OVERFLOW:
 422                         msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
 423                         break;
 424                 case MCIERR_MISSING_STRING_ARGUMENT:
 425                         msgptr = "The specified command requires a character-string parameter. Please provide one.";
 426                         break;
 427                 case MCIERR_BAD_INTEGER:
 428                         msgptr = "The specified integer is invalid for this command.";
 429                         break;
 430                 case MCIERR_PARSER_INTERNAL:
 431                         msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
 432                         break;
 433                 case MCIERR_DRIVER_INTERNAL:
 434                         msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
 435                         break;
 436                 case MCIERR_MISSING_PARAMETER:
 437                         msgptr = "The specified command requires a parameter. Please supply one.";
 438                         break;
 439                 case MCIERR_UNSUPPORTED_FUNCTION:
 440                         msgptr = "The MCI device you are using does not support the specified command.";
 441                         break;
 442                 case MCIERR_FILE_NOT_FOUND:
 443                         msgptr = "Cannot find the specified file. Make sure the path and filename are correct.";
 444                         break;
 445                 case MCIERR_DEVICE_NOT_READY:
 446                         msgptr = "The device driver is not ready.";
 447                         break;
 448                 case MCIERR_INTERNAL:
 449                         msgptr = "A problem occurred in initializing MCI. Try restarting Windows.";
 450                         break;
 451                 case MCIERR_DRIVER:
 452                         msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error.";
 453                         break;
 454                 case MCIERR_CANNOT_USE_ALL:
 455                         msgptr = "Cannot use 'all' as the device name with the specified command.";
 456                         break;
 457                 case MCIERR_MULTIPLE:
 458                         msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
 459                         break;
 460                 case MCIERR_EXTENSION_NOT_FOUND:
 461                         msgptr = "Cannot determine the device type from the given filename extension.";
 462                         break;
 463                 case MCIERR_OUTOFRANGE:
 464                         msgptr = "The specified parameter is out of range for the specified command.";
 465                         break;
 466                 case MCIERR_FLAGS_NOT_COMPATIBLE:
 467                         msgptr = "The specified parameters cannot be used together.";
 468                         break;
 469                 case MCIERR_FILE_NOT_SAVED:
 470                         msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
 471                         break;
 472                 case MCIERR_DEVICE_TYPE_REQUIRED:
 473                         msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
 474                         break;
 475                 case MCIERR_DEVICE_LOCKED:
 476                         msgptr = "The specified device is now being closed. Wait a few seconds, and then try again.";
 477                         break;
 478                 case MCIERR_DUPLICATE_ALIAS:
 479                         msgptr = "The specified alias is already being used in this application. Use a unique alias.";
 480                         break;
 481                 case MCIERR_BAD_CONSTANT:
 482                         msgptr = "The specified parameter is invalid for this command.";
 483                         break;
 484                 case MCIERR_MUST_USE_SHAREABLE:
 485                         msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
 486                         break;
 487                 case MCIERR_MISSING_DEVICE_NAME:
 488                         msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one.";
 489                         break;
 490                 case MCIERR_BAD_TIME_FORMAT:
 491                         msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
 492                         break;
 493                 case MCIERR_NO_CLOSING_QUOTE:
 494                         msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one.";
 495                         break;
 496                 case MCIERR_DUPLICATE_FLAGS:
 497                         msgptr = "A parameter or value was specified twice. Only specify it once.";
 498                         break;
 499                 case MCIERR_INVALID_FILE:
 500                         msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
 501                         break;
 502                 case MCIERR_NULL_PARAMETER_BLOCK:
 503                         msgptr = "A null parameter block was passed to MCI.";
 504                         break;
 505                 case MCIERR_UNNAMED_RESOURCE:
 506                         msgptr = "Cannot save an unnamed file. Supply a filename.";
 507                         break;
 508                 case MCIERR_NEW_REQUIRES_ALIAS:
 509                         msgptr = "You must specify an alias when using the 'new' parameter.";
 510                         break;
 511                 case MCIERR_NOTIFY_ON_AUTO_OPEN:
 512                         msgptr = "Cannot use the 'notify' flag with auto-opened devices.";
 513                         break;
 514                 case MCIERR_NO_ELEMENT_ALLOWED:
 515                         msgptr = "Cannot use a filename with the specified device.";
 516                         break;
 517                 case MCIERR_NONAPPLICABLE_FUNCTION:
 518                         msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
 519                         break;
 520                 case MCIERR_ILLEGAL_FOR_AUTO_OPEN:
 521                         msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
 522                         break;
 523                 case MCIERR_FILENAME_REQUIRED:
 524                         msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
 525                         break;
 526                 case MCIERR_EXTRA_CHARACTERS:
 527                         msgptr = "Cannot specify extra characters after a string enclosed in quotation marks.";
 528                         break;
 529                 case MCIERR_DEVICE_NOT_INSTALLED:
 530                         msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
 531                         break;
 532                 case MCIERR_GET_CD:
 533                         msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
 534                         break;
 535                 case MCIERR_SET_CD:
 536                         msgptr = "Cannot access the specified file or MCI device because the application cannot change directories.";
 537                         break;
 538                 case MCIERR_SET_DRIVE:
 539                         msgptr = "Cannot access specified file or MCI device because the application cannot change drives.";
 540                         break;
 541                 case MCIERR_DEVICE_LENGTH:
 542                         msgptr = "Specify a device or driver name that is less than 79 characters.";
 543                         break;
 544                 case MCIERR_DEVICE_ORD_LENGTH:
 545                         msgptr = "Specify a device or driver name that is less than 69 characters.";
 546                         break;
 547                 case MCIERR_NO_INTEGER:
 548                         msgptr = "The specified command requires an integer parameter. Please provide one.";
 549                         break;
 550                 case MCIERR_WAVE_OUTPUTSINUSE:
 551                         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.";
 552                         break;
 553                 case MCIERR_WAVE_SETOUTPUTINUSE:
 554                         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.";
 555                         break;
 556                 case MCIERR_WAVE_INPUTSINUSE:
 557                         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.";
 558                         break;
 559                 case MCIERR_WAVE_SETINPUTINUSE:
 560                         msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
 561                         break;
 562                 case MCIERR_WAVE_OUTPUTUNSPECIFIED:
 563                         msgptr = "Any compatible waveform playback device may be used.";
 564                         break;
 565                 case MCIERR_WAVE_INPUTUNSPECIFIED:
 566                         msgptr = "Any compatible waveform recording device may be used.";
 567                         break;
 568                 case MCIERR_WAVE_OUTPUTSUNSUITABLE:
 569                         msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
 570                         break;
 571                 case MCIERR_WAVE_SETOUTPUTUNSUITABLE:
 572                         msgptr = "The device you are trying to play to cannot recognize the current file format.";
 573                         break;
 574                 case MCIERR_WAVE_INPUTSUNSUITABLE:
 575                         msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
 576                         break;
 577                 case MCIERR_WAVE_SETINPUTUNSUITABLE:
 578                         msgptr = "The device you are trying to record from cannot recognize the current file format.";
 579                         break;
 580                 case MCIERR_NO_WINDOW:
 581                         msgptr = "There is no display window.";
 582                         break;
 583                 case MCIERR_CREATEWINDOW:
 584                         msgptr = "Could not create or use window.";
 585                         break;
 586                 case MCIERR_FILE_READ:
 587                         msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
 588                         break;
 589                 case MCIERR_FILE_WRITE:
 590                         msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
 591                         break;
 592                 case MCIERR_SEQ_DIV_INCOMPATIBLE:
 593                         msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
 594                         break;
 595                 case MCIERR_SEQ_NOMIDIPRESENT:
 596                         msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
 597                         break;
 598                 case MCIERR_SEQ_PORT_INUSE:
 599                         msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again.";
 600                         break;
 601                 case MCIERR_SEQ_PORT_MAPNODEVICE:
 602                         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.";
 603                         break;
 604                 case MCIERR_SEQ_PORT_MISCERROR:
 605                         msgptr = "An error occurred with the specified port.";
 606                         break;
 607                 case MCIERR_SEQ_PORT_NONEXISTENT:
 608                         msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
 609                         break;
 610                 case MCIERR_SEQ_PORTUNSPECIFIED:
 611                         msgptr = "The system doesnot have a current MIDI port specified.";
 612                         break;
 613                 case MCIERR_SEQ_TIMER:
 614                         msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
 615                         break;
 616
 617 /*
 618 msg# 513 : vcr
 619 msg# 514 : videodisc
 620 msg# 515 : overlay
 621 msg# 516 : cdaudio
 622 msg# 517 : dat
 623 msg# 518 : scanner
 624 msg# 519 : animation
 625 msg# 520 : digitalvideo
 626 msg# 521 : other
 627 msg# 522 : waveaudio
 628 msg# 523 : sequencer
 629 msg# 524 : not ready
 630 msg# 525 : stopped
 631 msg# 526 : playing
 632 msg# 527 : recording
 633 msg# 528 : seeking
 634 msg# 529 : paused
 635 msg# 530 : open
 636 msg# 531 : false
 637 msg# 532 : true
 638 msg# 533 : milliseconds
 639 msg# 534 : hms
 640 msg# 535 : msf
 641 msg# 536 : frames
 642 msg# 537 : smpte 24
 643 msg# 538 : smpte 25
 644 msg# 539 : smpte 30
 645 msg# 540 : smpte 30 drop
 646 msg# 541 : bytes
 647 msg# 542 : samples
 648 msg# 543 : tmsf
 649 */
 650                 default:
 651                         msgptr = "Unknown MCI Error !\n";
 652                         break;
 653                 }
 654         lstrcpyn32A(lpstrBuffer, msgptr, uLength);
 655         dprintf_mmsys(stddeb, "mciGetErrorString // msg = %s;\n", msgptr);
 656         return TRUE;
 657 }
 658
 659
 660 /**************************************************************************
 661 *                               mciDriverNotify                 [MMSYSTEM.711]
 662 */
 663 BOOL16 WINAPI mciDriverNotify(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
 664 {
 665         dprintf_mmsys(stddeb, "mciDriverNotify(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
 666         if (!IsWindow32(hWndCallBack)) return FALSE;
 667         dprintf_mmsys(stddeb, "mciDriverNotify // before PostMessage\n");
 668         PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus,
 669                        MAKELONG(wDevID, 0));
 670         return TRUE;
 671 }
 672
 673 /**************************************************************************
 674 *                               mciOpen                                 [internal]
 675 */
 676
 677 DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms)
 678 {
 679         char    str[128];
 680         LPMCI_OPEN_PARMS lpParms;
 681         UINT16  uDevTyp = 0;
 682         UINT16  wDevID = MMSYSTEM_FirstDevID();
 683         DWORD dwret;
 684
 685         lpParms = PTR_SEG_TO_LIN(lp16Parms);
 686         dprintf_mmsys(stddeb, "mciOpen(%08lX, %p (%p))\n", dwParam, lp16Parms, lpParms);
 687         if (lp16Parms == NULL) return MCIERR_INTERNAL;
 688
 689         while(GetDrv(wDevID)->wType != 0) {
 690                 wDevID = MMSYSTEM_NextDevID(wDevID);
 691                 if (!MMSYSTEM_DevIDValid(wDevID)) {
 692                         dprintf_mmsys(stddeb, "MCI_OPEN // MAXMCIDRIVERS reached !\n");
 693                         return MCIERR_INTERNAL;
 694                 }
 695         }
 696         dprintf_mmsys(stddeb, "mciOpen // wDevID=%04X \n", wDevID);
 697         memcpy(GetOpenDrv(wDevID),lpParms,sizeof(*lpParms));
 698
 699         if (dwParam & MCI_OPEN_ELEMENT) {
 700                 char    *s,*t;
 701
 702                 dprintf_mmsys(stddeb,"mciOpen // lpstrElementName='%s'\n",
 703                         (char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName)
 704                 );
 705                 s=(char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
 706                 t=strrchr(s,'.');
 707                 if (t) {
 708                         GetProfileString32A("mci extensions",t+1,"*",str,sizeof(str));
 709                         CharUpper32A(str);
 710                         dprintf_mmsys(stddeb, "mciOpen // str = %s \n", str);
 711                         if (strcmp(str, "CDAUDIO") == 0) {
 712                                 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
 713                         } else
 714                         if (strcmp(str, "WAVEAUDIO") == 0) {
 715                                 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
 716                         } else
 717                         if (strcmp(str, "SEQUENCER") == 0)      {
 718                                 uDevTyp = MCI_DEVTYPE_SEQUENCER;
 719                         } else
 720                         if (strcmp(str, "ANIMATION1") == 0) {
 721                                 uDevTyp = MCI_DEVTYPE_ANIMATION;
 722                         } else
 723                         if (strcmp(str, "AVIVIDEO") == 0) {
 724                                 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
 725                         } else
 726                         if (strcmp(str,"*") == 0) {
 727                                 dprintf_mmsys(stddeb,"No [mci extensions] entry for %s found.\n",t);
 728                                 return MCIERR_EXTENSION_NOT_FOUND;
 729                         } else  {
 730                                 dprintf_mmsys(stddeb,"[mci extensions] entry %s for %s not supported.\n",str,t);
 731                         }
 732                 } else
 733                         return MCIERR_EXTENSION_NOT_FOUND;
 734         }
 735
 736         if (dwParam & MCI_OPEN_ALIAS) {
 737                 dprintf_mmsys(stddeb, "MCI_OPEN // Alias='%s' !\n",
 738                         (char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias));
 739                 GetOpenDrv(wDevID)->lpstrAlias = SEGPTR_GET(
 740                     SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias)));
 741                 /* mplayer does allocate alias to CDAUDIO */
 742         }
 743         if (dwParam & MCI_OPEN_TYPE) {
 744                 if (dwParam & MCI_OPEN_TYPE_ID) {
 745                         dprintf_mmsys(stddeb, "MCI_OPEN // Dev=%08lx !\n", lpParms->lpstrDeviceType);
 746                         uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType);
 747                         GetOpenDrv(wDevID)->lpstrDeviceType=lpParms->lpstrDeviceType;
 748                 } else {
 749                         if (lpParms->lpstrDeviceType == (SEGPTR)NULL) return MCIERR_INTERNAL;
 750                         dprintf_mmsys(stddeb, "MCI_OPEN // Dev='%s' !\n",
 751                               (char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType));
 752                         GetOpenDrv(wDevID)->lpstrDeviceType = SEGPTR_GET(
 753               SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType)));
 754                         strcpy(str, PTR_SEG_TO_LIN(lpParms->lpstrDeviceType));
 755                         CharUpper32A(str);
 756                         if (strcmp(str, "CDAUDIO") == 0) {
 757                                 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
 758                         } else
 759                         if (strcmp(str, "WAVEAUDIO") == 0) {
 760                                 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
 761                         } else
 762                         if (strcmp(str, "SEQUENCER") == 0)      {
 763                                 uDevTyp = MCI_DEVTYPE_SEQUENCER;
 764                         } else
 765                         if (strcmp(str, "ANIMATION1") == 0) {
 766                                 uDevTyp = MCI_DEVTYPE_ANIMATION;
 767                         } else
 768                         if (strcmp(str, "AVIVIDEO") == 0) {
 769                                 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
 770                         }
 771                 }
 772         }
 773         GetDrv(wDevID)->wType = uDevTyp;
 774         GetDrv(wDevID)->wDeviceID = 0;  /* FIXME? for multiple devices */
 775         lpParms->wDeviceID = wDevID;
 776         dprintf_mmsys(stddeb, "MCI_OPEN // mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
 777                                 wDevID, uDevTyp, lpParms->wDeviceID);
 778         switch(uDevTyp)
 779         {
 780         case MCI_DEVTYPE_CD_AUDIO:
 781           dwret = CDAUDIO_DriverProc( 0, 0, MCI_OPEN_DRIVER,
 782                                      dwParam, (DWORD)lp16Parms);
 783           break;
 784         case MCI_DEVTYPE_WAVEFORM_AUDIO:
 785           dwret =  WAVE_DriverProc( 0, 0, MCI_OPEN_DRIVER,
 786                                    dwParam, (DWORD)lp16Parms);
 787           break;
 788         case MCI_DEVTYPE_SEQUENCER:
 789           dwret = MIDI_DriverProc( 0, 0, MCI_OPEN_DRIVER,
 790                                   dwParam, (DWORD)lp16Parms);
 791           break;
 792         case MCI_DEVTYPE_ANIMATION:
 793           dwret = ANIM_DriverProc( 0, 0, MCI_OPEN_DRIVER,
 794                                   dwParam, (DWORD)lp16Parms);
 795           break;
 796         case MCI_DEVTYPE_DIGITAL_VIDEO:
 797           dprintf_mmsys(stddeb, "MCI_OPEN // No DIGITAL_VIDEO yet !\n");
 798           return MCIERR_DEVICE_NOT_INSTALLED;
 799         default:
 800           dprintf_mmsys(stddeb, "MCI_OPEN // Invalid Device Name '%08lx' !\n", lpParms->lpstrDeviceType);
 801           return MCIERR_INVALID_DEVICE_NAME;
 802         }
 803
 804
 805         if (dwParam&MCI_NOTIFY)
 806           mciDriverNotify(lpParms->dwCallback,wDevID,
 807                           (dwret==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
 808
 809         /* only handled devices fall through */
 810         dprintf_mmsys(stddeb, "MCI_OPEN // wDevID = %04X wDeviceID = %d dwret = %ld\n",wDevID, lpParms->wDeviceID, dwret);
 811         return dwret;
 812 }
 813
 814
 815 /**************************************************************************
 816 *                               mciClose                                [internal]
 817 */
 818 DWORD mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
 819 {
 820         DWORD   dwRet = MCIERR_INTERNAL;
 821
 822         dprintf_mmsys(stddeb, "mciClose(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
 823         switch(GetDrv(wDevID)->wType) {
 824                 case MCI_DEVTYPE_CD_AUDIO:
 825                         dwRet = CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID,0,
 826                                            MCI_CLOSE, dwParam, (DWORD)lpParms);
 827                         break;
 828                 case MCI_DEVTYPE_WAVEFORM_AUDIO:
 829                         dwRet = WAVE_DriverProc(GetDrv(wDevID)->wDeviceID, 0,
 830                                                 MCI_CLOSE, dwParam,
 831                                                 (DWORD)lpParms);
 832                         break;
 833                 case MCI_DEVTYPE_SEQUENCER:
 834                         dwRet = MIDI_DriverProc(GetDrv(wDevID)->wDeviceID, 0,
 835                                                 MCI_CLOSE, dwParam,
 836                                                 (DWORD)lpParms);
 837                         break;
 838                 case MCI_DEVTYPE_ANIMATION:
 839                         dwRet = ANIM_DriverProc(GetDrv(wDevID)->wDeviceID, 0,
 840                                                 MCI_CLOSE, dwParam,
 841                                                 (DWORD)lpParms);
 842                         break;
 843                 default:
 844                         dprintf_mmsys(stddeb, "mciClose() // unknown device type=%04X !\n", GetDrv(wDevID)->wType);
 845                         dwRet = MCIERR_DEVICE_NOT_INSTALLED;
 846                 }
 847         GetDrv(wDevID)->wType = 0;
 848
 849         if (dwParam&MCI_NOTIFY)
 850           mciDriverNotify(lpParms->dwCallback,wDevID,
 851                           (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
 852
 853         dprintf_mmsys(stddeb, "mciClose() // returns %ld\n",dwRet);
 854         return dwRet;
 855 }
 856
 857
 858 /**************************************************************************
 859 *                               mciSysinfo                              [internal]
 860 */
 861 DWORD mciSysInfo(DWORD dwFlags, LPMCI_SYSINFO_PARMS lpParms)
 862 {
 863         int     len;
 864         LPSTR   ptr;
 865         LPSTR   lpstrReturn;
 866         DWORD   *lpdwRet;
 867         LPSTR   SysFile = "SYSTEM.INI";
 868         dprintf_mci(stddeb, "mciSysInfo(%08lX, %08lX)\n", dwFlags, (DWORD)lpParms);
 869         lpstrReturn = PTR_SEG_TO_LIN(lpParms->lpstrReturn);
 870         switch(dwFlags) {
 871                 case MCI_SYSINFO_QUANTITY:
 872                         dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_QUANTITY \n");
 873                         lpdwRet = (DWORD *)lpstrReturn;
 874                         *(lpdwRet) = InstalledCount;
 875                         return 0;
 876                 case MCI_SYSINFO_INSTALLNAME:
 877                         dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_INSTALLNAME \n");
 878                         if (lpInstallNames == NULL) {
 879                                 InstalledCount = 0;
 880                                 InstalledListLen = 0;
 881                                 ptr = lpInstallNames = xmalloc(2048);
 882                                 GetPrivateProfileString32A("mci", NULL, "", lpInstallNames, 2000, SysFile);
 883                                 while(strlen(ptr) > 0) {
 884                                         dprintf_mci(stddeb, "---> '%s' \n", ptr);
 885                                         len = strlen(ptr) + 1;
 886                                         ptr += len;
 887                                         InstalledListLen += len;
 888                                         InstalledCount++;
 889                                 }
 890                         }
 891                         if (lpParms->dwRetSize < InstalledListLen)
 892                                 lstrcpyn32A(lpstrReturn, lpInstallNames, lpParms->dwRetSize - 1);
 893                         else
 894                                 strcpy(lpstrReturn, lpInstallNames);
 895                         return 0;
 896                 case MCI_SYSINFO_NAME:
 897                         dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_NAME \n");
 898                         return 0;
 899                 case MCI_SYSINFO_OPEN:
 900                         dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_OPEN \n");
 901                         return 0;
 902                 }
 903         return MMSYSERR_INVALPARAM;
 904 }
 905
 906 /**************************************************************************
 907 *                               mciSound                                [internal]
 908 *  not used anymore ??
 909
 910 DWORD mciSound(UINT16 wDevID, DWORD dwParam, LPMCI_SOUND_PARMS lpParms)
 911 {
 912         if (lpParms == NULL) return MCIERR_INTERNAL;
 913         if (dwParam & MCI_SOUND_NAME)
 914                 dprintf_mci(stddeb, "MCI_SOUND // file='%s' !\n", lpParms->lpstrSoundName);
 915         return MCIERR_INVALID_DEVICE_ID;
 916 }
 917 *
 918 */
 919
 920 static const char *_mciCommandToString(UINT16 wMsg)
 921 {
 922         static char buffer[100];
 923
 924 #define CASE(s) case (s): return #s
 925
 926         switch (wMsg) {
 927                 CASE(MCI_OPEN);
 928                 CASE(MCI_CLOSE);
 929                 CASE(MCI_ESCAPE);
 930                 CASE(MCI_PLAY);
 931                 CASE(MCI_SEEK);
 932                 CASE(MCI_STOP);
 933                 CASE(MCI_PAUSE);
 934                 CASE(MCI_INFO);
 935                 CASE(MCI_GETDEVCAPS);
 936                 CASE(MCI_SPIN);
 937                 CASE(MCI_SET);
 938                 CASE(MCI_STEP);
 939                 CASE(MCI_RECORD);
 940                 CASE(MCI_SYSINFO);
 941                 CASE(MCI_BREAK);
 942                 CASE(MCI_SAVE);
 943                 CASE(MCI_STATUS);
 944                 CASE(MCI_CUE);
 945                 CASE(MCI_REALIZE);
 946                 CASE(MCI_WINDOW);
 947                 CASE(MCI_PUT);
 948                 CASE(MCI_WHERE);
 949                 CASE(MCI_FREEZE);
 950                 CASE(MCI_UNFREEZE);
 951                 CASE(MCI_LOAD);
 952                 CASE(MCI_CUT);
 953                 CASE(MCI_COPY);
 954                 CASE(MCI_PASTE);
 955                 CASE(MCI_UPDATE);
 956                 CASE(MCI_RESUME);
 957                 CASE(MCI_DELETE);
 958                 default:
 959                         sprintf(buffer, "%04X", wMsg);
 960                         return buffer;
 961
 962         }
 963 }
 964
 965 /**************************************************************************
 966 *                               mciSendCommand                  [MMSYSTEM.701]
 967 */
 968 DWORD WINAPI mciSendCommand(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1,
 969                             DWORD dwParam2)
 970 {
 971     HDRVR16 hDrv = 0;
 972     dprintf_mci(stddeb, "mciSendCommand(%04X, %s, %08lX, %08lX)\n",
 973                 wDevID, _mciCommandToString(wMsg), dwParam1, dwParam2);
 974     switch(wMsg)
 975     {
 976     case MCI_OPEN:
 977         return mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
 978     case MCI_CLOSE:
 979         return mciClose( wDevID, dwParam1,
 980                          (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
 981     case MCI_SYSINFO:
 982         return mciSysInfo( dwParam1,
 983                            (LPMCI_SYSINFO_PARMS)PTR_SEG_TO_LIN(dwParam2));
 984     default:
 985         switch(GetDrv(wDevID)->wType)
 986         {
 987         case MCI_DEVTYPE_CD_AUDIO:
 988             return CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
 989                                       wMsg, dwParam1, dwParam2);
 990         case MCI_DEVTYPE_WAVEFORM_AUDIO:
 991             return WAVE_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
 992                                    wMsg, dwParam1, dwParam2);
 993         case MCI_DEVTYPE_SEQUENCER:
 994             return MIDI_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
 995                                    wMsg, dwParam1, dwParam2);
 996         case MCI_DEVTYPE_ANIMATION:
 997             return ANIM_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
 998                                    wMsg, dwParam1, dwParam2);
 999         default:
1000             dprintf_mci(stddeb,
1001                         "mciSendCommand() // unknown device type=%04X !\n",
1002                         GetDrv(wDevID)->wType);
1003         }
1004     }
1005     return MMSYSERR_INVALPARAM;
1006 }
1007
1008 /**************************************************************************
1009 *                               mciGetDeviceID          [MMSYSTEM.703]
1010 */
1011 UINT16 WINAPI mciGetDeviceID (LPCSTR lpstrName)
1012 {
1013     UINT16 wDevID;
1014
1015     dprintf_mci(stddeb, "mciGetDeviceID(\"%s\")\n", lpstrName);
1016     if (lpstrName && !lstrcmpi32A(lpstrName, "ALL"))
1017         return MCI_ALL_DEVICE_ID;
1018
1019     if (!lpstrName)
1020         return 0;
1021
1022     wDevID = MMSYSTEM_FirstDevID();
1023     while(MMSYSTEM_DevIDValid(wDevID) && GetDrv(wDevID)->wType) {
1024         if (GetOpenDrv(wDevID)->lpstrDeviceType &&
1025             strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrDeviceType), lpstrName) == 0)
1026             return wDevID;
1027
1028         if (GetOpenDrv(wDevID)->lpstrAlias &&
1029             strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrAlias), lpstrName) == 0)
1030             return wDevID;
1031
1032         wDevID = MMSYSTEM_NextDevID(wDevID);
1033     }
1034
1035     return 0;
1036 }
1037
1038 /**************************************************************************
1039 *                               mciSetYieldProc         [MMSYSTEM.714]
1040 */
1041 BOOL16 WINAPI mciSetYieldProc (UINT16 uDeviceID,
1042                                YIELDPROC fpYieldProc, DWORD dwYieldData)
1043 {
1044     return FALSE;
1045 }
1046
1047 /**************************************************************************
1048 *                               mciGetDeviceIDFromElementID     [MMSYSTEM.715]
1049 */
1050 UINT16 WINAPI mciGetDeviceIDFromElementID(DWORD dwElementID, LPCSTR lpstrType)
1051 {
1052     return 0;
1053 }
1054
1055 /**************************************************************************
1056 *                               mciGetYieldProc         [MMSYSTEM.716]
1057 */
1058 YIELDPROC WINAPI mciGetYieldProc(UINT16 uDeviceID, DWORD * lpdwYieldData)
1059 {
1060     return NULL;
1061 }
1062
1063 /**************************************************************************
1064 *                               mciGetCreatorTask       [MMSYSTEM.717]
1065 */
1066 HTASK16 WINAPI mciGetCreatorTask(UINT16 uDeviceID)
1067 {
1068     return 0;
1069 }
1070
1071 /**************************************************************************
1072 *                               midiOutGetNumDevs       [MMSYSTEM.201]
1073 */
1074 UINT16 WINAPI midiOutGetNumDevs(void)
1075 {
1076         UINT16  count = 0;
1077         dprintf_mmsys(stddeb, "midiOutGetNumDevs\n");
1078         count += modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
1079         dprintf_mmsys(stddeb, "midiOutGetNumDevs return %u \n", count);
1080         return count;
1081 }
1082
1083 /**************************************************************************
1084 *                               midiOutGetDevCaps       [MMSYSTEM.202]
1085 */
1086 UINT16 WINAPI midiOutGetDevCaps(UINT16 uDeviceID, MIDIOUTCAPS * lpCaps, UINT16 uSize)
1087 {
1088         dprintf_mmsys(stddeb, "midiOutGetDevCaps\n");
1089         return modMessage(uDeviceID,MODM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);
1090 }
1091
1092 /**************************************************************************
1093 *                               midiOutGetErrorText     [MMSYSTEM.203]
1094 */
1095 UINT16 WINAPI midiOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1096 {
1097         dprintf_mmsys(stddeb, "midiOutGetErrorText\n");
1098         return midiGetErrorText(uError, lpText, uSize);
1099 }
1100
1101
1102 /**************************************************************************
1103 *                               midiGetErrorText        [internal]
1104 */
1105 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1106 {
1107         LPSTR   msgptr;
1108         if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1109         lpText[0] = '\0';
1110         switch(uError) {
1111                 case MIDIERR_UNPREPARED:
1112                         msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1113                         break;
1114                 case MIDIERR_STILLPLAYING:
1115                         msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1116                         break;
1117                 case MIDIERR_NOMAP:
1118                         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.";
1119                         break;
1120                 case MIDIERR_NOTREADY:
1121                         msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
1122                         break;
1123                 case MIDIERR_NODEVICE:
1124                         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.";
1125                         break;
1126                 case MIDIERR_INVALIDSETUP:
1127                         msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
1128                         break;
1129 /*
1130 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
1131 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
1132 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
1133 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.
1134 msg# 340 : An error occurred using the specified port.
1135 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
1136 msg# 342 : There is no current MIDI port.
1137 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
1138 */
1139                 default:
1140                         msgptr = "Unknown MIDI Error !\n";
1141                         break;
1142                 }
1143         lstrcpyn32A(lpText, msgptr, uSize);
1144         return TRUE;
1145 }
1146
1147 /**************************************************************************
1148 *                               midiOutOpen             [MMSYSTEM.204]
1149 */
1150 UINT16 WINAPI midiOutOpen(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
1151                           DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1152 {
1153         HMIDI16 hMidiOut;
1154         LPMIDIOPENDESC  lpDesc;
1155         LPMIDIOPENDESC  lp16Desc;
1156         DWORD   dwRet = 0;
1157         BOOL32  bMapperFlg = FALSE;
1158         if (lphMidiOut != NULL) *lphMidiOut = 0;
1159         dprintf_mmsys(stddeb, "midiOutOpen(%p, %d, %08lX, %08lX, %08lX);\n",
1160                 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
1161         if (uDeviceID == (UINT16)MIDI_MAPPER) {
1162                 dprintf_mmsys(stddeb, "midiOutOpen      // MIDI_MAPPER mode requested !\n");
1163                 bMapperFlg = TRUE;
1164                 uDeviceID = 0;
1165         }
1166         hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1167         if (lphMidiOut != NULL) *lphMidiOut = hMidiOut;
1168         lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiOut);
1169         lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1170         if (lpDesc == NULL) return MMSYSERR_NOMEM;
1171         lpDesc->hMidi = hMidiOut;
1172         lpDesc->dwCallback = dwCallback;
1173         lpDesc->dwInstance = dwInstance;
1174         while(uDeviceID < MAXMIDIDRIVERS) {
1175                 dwRet = modMessage(uDeviceID, MODM_OPEN,
1176                         lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
1177                 if (dwRet == MMSYSERR_NOERROR) break;
1178                 if (!bMapperFlg) break;
1179                 uDeviceID++;
1180                 dprintf_mmsys(stddeb, "midiOutOpen      // MIDI_MAPPER mode ! try next driver...\n");
1181                 }
1182         return dwRet;
1183 }
1184
1185 /**************************************************************************
1186 *                               midiOutClose            [MMSYSTEM.205]
1187 */
1188 UINT16 WINAPI midiOutClose(HMIDIOUT16 hMidiOut)
1189 {
1190         LPMIDIOPENDESC  lpDesc;
1191         dprintf_mmsys(stddeb, "midiOutClose(%04X)\n", hMidiOut);
1192         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1193         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1194         return modMessage(0, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1195 }
1196
1197 /**************************************************************************
1198 *                               midiOutPrepareHeader    [MMSYSTEM.206]
1199 */
1200 UINT16 WINAPI midiOutPrepareHeader(HMIDIOUT16 hMidiOut,
1201                                    MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1202 {
1203         LPMIDIOPENDESC  lpDesc;
1204         dprintf_mmsys(stddeb, "midiOutPrepareHeader(%04X, %p, %d)\n",
1205                                         hMidiOut, lpMidiOutHdr, uSize);
1206         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1207         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1208         return modMessage(0, MODM_PREPARE, lpDesc->dwInstance,
1209                                                 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1210 }
1211
1212 /**************************************************************************
1213 *                               midiOutUnprepareHeader  [MMSYSTEM.207]
1214 */
1215 UINT16 WINAPI midiOutUnprepareHeader(HMIDIOUT16 hMidiOut,
1216                                      MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1217 {
1218         LPMIDIOPENDESC  lpDesc;
1219         dprintf_mmsys(stddeb, "midiOutUnprepareHeader(%04X, %p, %d)\n",
1220                                         hMidiOut, lpMidiOutHdr, uSize);
1221         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1222         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1223         return modMessage(0, MODM_UNPREPARE, lpDesc->dwInstance,
1224                                                 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1225 }
1226
1227 /**************************************************************************
1228 *                               midiOutShortMsg         [MMSYSTEM.208]
1229 */
1230 UINT16 WINAPI midiOutShortMsg(HMIDIOUT16 hMidiOut, DWORD dwMsg)
1231 {
1232         LPMIDIOPENDESC  lpDesc;
1233         dprintf_mmsys(stddeb, "midiOutShortMsg(%04X, %08lX)\n", hMidiOut, dwMsg);
1234         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1235         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1236         return modMessage(0, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
1237 }
1238
1239 /**************************************************************************
1240 *                               midiOutLongMsg          [MMSYSTEM.209]
1241 */
1242 UINT16 WINAPI midiOutLongMsg(HMIDIOUT16 hMidiOut,
1243                              MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1244 {
1245         LPMIDIOPENDESC  lpDesc;
1246         dprintf_mmsys(stddeb, "midiOutLongMsg(%04X, %p, %d)\n",
1247                                 hMidiOut, lpMidiOutHdr, uSize);
1248         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1249         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1250         return modMessage(0, MODM_LONGDATA, lpDesc->dwInstance,
1251                                                 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1252 }
1253
1254 /**************************************************************************
1255 *                               midiOutReset            [MMSYSTEM.210]
1256 */
1257 UINT16 WINAPI midiOutReset(HMIDIOUT16 hMidiOut)
1258 {
1259         LPMIDIOPENDESC  lpDesc;
1260         dprintf_mmsys(stddeb, "midiOutReset(%04X)\n", hMidiOut);
1261         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1262         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1263         return modMessage(0, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
1264 }
1265
1266 /**************************************************************************
1267 *                               midiOutGetVolume        [MMSYSTEM.211]
1268 */
1269 UINT16 WINAPI midiOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume)
1270 {
1271         dprintf_mmsys(stddeb, "midiOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
1272         return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1273         return 0;
1274 }
1275
1276 /**************************************************************************
1277 *                               midiOutSetVolume        [MMSYSTEM.212]
1278 */
1279 UINT16 WINAPI midiOutSetVolume(UINT16 uDeviceID, DWORD dwVolume)
1280 {
1281         dprintf_mmsys(stddeb, "midiOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
1282         return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
1283         return 0;
1284 }
1285
1286 /**************************************************************************
1287 *                               midiOutCachePatches             [MMSYSTEM.213]
1288 */
1289 UINT16 WINAPI midiOutCachePatches(HMIDIOUT16 hMidiOut, UINT16 uBank,
1290                                   WORD * lpwPatchArray, UINT16 uFlags)
1291 {
1292         /* not really necessary to support this */
1293         fprintf(stdnimp, "midiOutCachePatches: not supported yet\n");
1294         return MMSYSERR_NOTSUPPORTED;
1295 }
1296
1297 /**************************************************************************
1298 *                               midiOutCacheDrumPatches [MMSYSTEM.214]
1299 */
1300 UINT16 WINAPI midiOutCacheDrumPatches(HMIDIOUT16 hMidiOut, UINT16 uPatch,
1301                                       WORD * lpwKeyArray, UINT16 uFlags)
1302 {
1303         fprintf(stdnimp, "midiOutCacheDrumPatchesi: not supported yet\n");
1304         return MMSYSERR_NOTSUPPORTED;
1305 }
1306
1307 /**************************************************************************
1308 *                               midiOutGetID            [MMSYSTEM.215]
1309 */
1310 UINT16 WINAPI midiOutGetID(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
1311 {
1312         dprintf_mmsys(stddeb, "midiOutGetID\n");
1313         return 0;
1314 }
1315
1316 /**************************************************************************
1317 *                               midiOutMessage          [MMSYSTEM.216]
1318 */
1319 DWORD WINAPI midiOutMessage(HMIDIOUT16 hMidiOut, UINT16 uMessage,
1320                             DWORD dwParam1, DWORD dwParam2)
1321 {
1322         LPMIDIOPENDESC  lpDesc;
1323         dprintf_mmsys(stddeb, "midiOutMessage(%04X, %04X, %08lX, %08lX)\n",
1324                         hMidiOut, uMessage, dwParam1, dwParam2);
1325         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1326         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1327         return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1328         return 0;
1329 }
1330
1331 /**************************************************************************
1332 *                               midiInGetNumDevs        [MMSYSTEM.301]
1333 */
1334 UINT16 WINAPI midiInGetNumDevs(void)
1335 {
1336         UINT16  count = 0;
1337         dprintf_mmsys(stddeb, "midiInGetNumDevs\n");
1338         count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
1339         dprintf_mmsys(stddeb, "midiInGetNumDevs return %u \n", count);
1340         return count;
1341 }
1342
1343 /**************************************************************************
1344 *                               midiInGetDevCaps        [MMSYSTEM.302]
1345 */
1346 UINT16 WINAPI midiInGetDevCaps(UINT16 uDeviceID,
1347                                LPMIDIINCAPS lpCaps, UINT16 uSize)
1348 {
1349         dprintf_mmsys(stddeb, "midiInGetDevCaps\n");
1350         return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);;
1351 }
1352
1353 /**************************************************************************
1354 *                               midiInGetErrorText              [MMSYSTEM.303]
1355 */
1356 UINT16 WINAPI midiInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1357 {
1358         dprintf_mmsys(stddeb, "midiInGetErrorText\n");
1359         return (midiGetErrorText(uError, lpText, uSize));
1360 }
1361
1362 /**************************************************************************
1363 *                               midiInOpen              [MMSYSTEM.304]
1364 */
1365 UINT16 WINAPI midiInOpen(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
1366                          DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1367 {
1368         HMIDI16 hMidiIn;
1369         LPMIDIOPENDESC  lpDesc;
1370         LPMIDIOPENDESC  lp16Desc;
1371         DWORD   dwRet = 0;
1372         BOOL32  bMapperFlg = FALSE;
1373         if (lphMidiIn != NULL) *lphMidiIn = 0;
1374         dprintf_mmsys(stddeb, "midiInOpen(%p, %d, %08lX, %08lX, %08lX);\n",
1375                 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
1376         if (uDeviceID == (UINT16)MIDI_MAPPER) {
1377                 dprintf_mmsys(stddeb, "midiInOpen       // MIDI_MAPPER mode requested !\n");
1378                 bMapperFlg = TRUE;
1379                 uDeviceID = 0;
1380                 }
1381         hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1382         if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
1383         lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiIn);
1384         lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1385         if (lpDesc == NULL) return MMSYSERR_NOMEM;
1386         lpDesc->hMidi = hMidiIn;
1387         lpDesc->dwCallback = dwCallback;
1388         lpDesc->dwInstance = dwInstance;
1389         while(uDeviceID < MAXMIDIDRIVERS) {
1390                 dwRet = midMessage(uDeviceID, MIDM_OPEN,
1391                         lpDesc->dwInstance, (DWORD)lpDesc, 0L);
1392                 if (dwRet == MMSYSERR_NOERROR) break;
1393                 if (!bMapperFlg) break;
1394                 uDeviceID++;
1395                 dprintf_mmsys(stddeb, "midiInOpen       // MIDI_MAPPER mode ! try next driver...\n");
1396                 }
1397         return dwRet;
1398 }
1399
1400 /**************************************************************************
1401 *                               midiInClose             [MMSYSTEM.305]
1402 */
1403 UINT16 WINAPI midiInClose(HMIDIIN16 hMidiIn)
1404 {
1405         LPMIDIOPENDESC  lpDesc;
1406         dprintf_mmsys(stddeb, "midiInClose(%04X)\n", hMidiIn);
1407         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1408         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1409         return midMessage(0, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1410 }
1411
1412 /**************************************************************************
1413 *                               midiInPrepareHeader     [MMSYSTEM.306]
1414 */
1415 UINT16 WINAPI midiInPrepareHeader(HMIDIIN16 hMidiIn,
1416                                   MIDIHDR * lpMidiInHdr, UINT16 uSize)
1417 {
1418         LPMIDIOPENDESC  lpDesc;
1419         dprintf_mmsys(stddeb, "midiInPrepareHeader(%04X, %p, %d)\n",
1420                                         hMidiIn, lpMidiInHdr, uSize);
1421         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1422         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1423         return midMessage(0, MIDM_PREPARE, lpDesc->dwInstance,
1424                                                 (DWORD)lpMidiInHdr, (DWORD)uSize);
1425 }
1426
1427 /**************************************************************************
1428 *                               midiInUnprepareHeader   [MMSYSTEM.307]
1429 */
1430 UINT16 WINAPI midiInUnprepareHeader(HMIDIIN16 hMidiIn,
1431                                     MIDIHDR * lpMidiInHdr, UINT16 uSize)
1432 {
1433         LPMIDIOPENDESC  lpDesc;
1434         dprintf_mmsys(stddeb, "midiInUnprepareHeader(%04X, %p, %d)\n",
1435                                         hMidiIn, lpMidiInHdr, uSize);
1436         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1437         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1438         return midMessage(0, MIDM_UNPREPARE, lpDesc->dwInstance,
1439                                                 (DWORD)lpMidiInHdr, (DWORD)uSize);
1440 }
1441
1442 /**************************************************************************
1443 *                               midiInAddBuffer         [MMSYSTEM.308]
1444 */
1445 UINT16 WINAPI midiInAddBuffer(HMIDIIN16 hMidiIn,
1446                               MIDIHDR * lpMidiInHdr, UINT16 uSize)
1447 {
1448         dprintf_mmsys(stddeb, "midiInAddBuffer\n");
1449         return 0;
1450 }
1451
1452 /**************************************************************************
1453 *                               midiInStart                     [MMSYSTEM.309]
1454 */
1455 UINT16 WINAPI midiInStart(HMIDIIN16 hMidiIn)
1456 {
1457         dprintf_mmsys(stddeb, "midiInStart\n");
1458         return 0;
1459 }
1460
1461 /**************************************************************************
1462 *                               midiInStop                      [MMSYSTEM.310]
1463 */
1464 UINT16 WINAPI midiInStop(HMIDIIN16 hMidiIn)
1465 {
1466         dprintf_mmsys(stddeb, "midiInStop\n");
1467         return 0;
1468 }
1469
1470 /**************************************************************************
1471 *                               midiInReset                     [MMSYSTEM.311]
1472 */
1473 UINT16 WINAPI midiInReset(HMIDIIN16 hMidiIn)
1474 {
1475         dprintf_mmsys(stddeb, "midiInReset\n");
1476         return 0;
1477 }
1478
1479 /**************************************************************************
1480 *                               midiInGetID                     [MMSYSTEM.312]
1481 */
1482 UINT16 WINAPI midiInGetID(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID)
1483 {
1484         dprintf_mmsys(stddeb, "midiInGetID\n");
1485         return 0;
1486 }
1487
1488 /**************************************************************************
1489 *                               midiInMessage           [MMSYSTEM.313]
1490 */
1491 DWORD WINAPI midiInMessage(HMIDIIN16 hMidiIn, UINT16 uMessage,
1492                            DWORD dwParam1, DWORD dwParam2)
1493 {
1494         LPMIDIOPENDESC  lpDesc;
1495         dprintf_mmsys(stddeb, "midiInMessage(%04X, %04X, %08lX, %08lX)\n",
1496                         hMidiIn, uMessage, dwParam1, dwParam2);
1497         lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1498         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1499         return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1500 }
1501
1502
1503 /**************************************************************************
1504 *                               waveOutGetNumDevs               [MMSYSTEM.401]
1505 */
1506 UINT16 WINAPI waveOutGetNumDevs()
1507 {
1508         UINT16  count = 0;
1509         dprintf_mmsys(stddeb, "waveOutGetNumDevs\n");
1510         count += wodMessage( MMSYSTEM_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
1511         dprintf_mmsys(stddeb, "waveOutGetNumDevs return %u \n", count);
1512         return count;
1513 }
1514
1515 /**************************************************************************
1516 *                               waveOutGetDevCaps               [MMSYSTEM.402]
1517 */
1518 UINT16 WINAPI waveOutGetDevCaps(UINT16 uDeviceID, WAVEOUTCAPS * lpCaps,
1519                                 UINT16 uSize)
1520 {
1521         if (uDeviceID > waveOutGetNumDevs() - 1) return MMSYSERR_BADDEVICEID;
1522         if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
1523         dprintf_mmsys(stddeb, "waveOutGetDevCaps\n");
1524         return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
1525 }
1526
1527 /**************************************************************************
1528 *                               waveOutGetErrorText     [MMSYSTEM.403]
1529 */
1530 UINT16 WINAPI waveOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1531 {
1532    dprintf_mmsys(stddeb, "waveOutGetErrorText\n");
1533    return(waveGetErrorText(uError, lpText, uSize));
1534 }
1535
1536
1537 /**************************************************************************
1538 *                               waveGetErrorText                [internal]
1539 */
1540 UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1541 {
1542         LPSTR   msgptr;
1543         dprintf_mmsys(stddeb, "waveGetErrorText(%04X, %p, %d);\n", uError, lpText, uSize);
1544         if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1545         lpText[0] = '\0';
1546         switch(uError) {
1547                 case MMSYSERR_NOERROR:
1548                         msgptr = "The specified command was carried out.";
1549                         break;
1550                 case MMSYSERR_ERROR:
1551                         msgptr = "Undefined external error.";
1552                         break;
1553                 case MMSYSERR_BADDEVICEID:
1554                         msgptr = "A device ID has been used that is out of range for your system.";
1555                         break;
1556                 case MMSYSERR_NOTENABLED:
1557                         msgptr = "The driver was not enabled.";
1558                         break;
1559                 case MMSYSERR_ALLOCATED:
1560                         msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
1561                         break;
1562                 case MMSYSERR_INVALHANDLE:
1563                         msgptr = "The specified device handle is invalid.";
1564                         break;
1565                 case MMSYSERR_NODRIVER:
1566                         msgptr = "There is no driver installed on your system !\n";
1567                         break;
1568                 case MMSYSERR_NOMEM:
1569                         msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
1570                         break;
1571                 case MMSYSERR_NOTSUPPORTED:
1572                         msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
1573                         break;
1574                 case MMSYSERR_BADERRNUM:
1575                         msgptr = "An error number was specified that is not defined in the system.";
1576                         break;
1577                 case MMSYSERR_INVALFLAG:
1578                         msgptr = "An invalid flag was passed to a system function.";
1579                         break;
1580                 case MMSYSERR_INVALPARAM:
1581                         msgptr = "An invalid parameter was passed to a system function.";
1582                         break;
1583                 case WAVERR_BADFORMAT:
1584                         msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
1585                         break;
1586                 case WAVERR_STILLPLAYING:
1587                         msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1588                         break;
1589                 case WAVERR_UNPREPARED:
1590                         msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1591                         break;
1592                 case WAVERR_SYNC:
1593                         msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
1594                         break;
1595                 default:
1596                         msgptr = "Unknown MMSYSTEM Error !\n";
1597                         break;
1598                 }
1599         lstrcpyn32A(lpText, msgptr, uSize);
1600         return TRUE;
1601 }
1602
1603 /**************************************************************************
1604 *                               waveOutOpen                     [MMSYSTEM.404]
1605 */
1606 UINT16 WINAPI waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
1607                           const LPWAVEFORMAT lpFormat, DWORD dwCallback,
1608                           DWORD dwInstance, DWORD dwFlags)
1609 {
1610         HWAVEOUT16 hWaveOut;
1611         LPWAVEOPENDESC  lpDesc;
1612         LPWAVEOPENDESC  lp16Desc;
1613         DWORD   dwRet = 0;
1614         BOOL32  bMapperFlg = FALSE;
1615
1616         dprintf_mmsys(stddeb, "waveOutOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
1617                 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
1618         if (dwFlags & WAVE_FORMAT_QUERY) {
1619                 dprintf_mmsys(stddeb, "waveOutOpen      // WAVE_FORMAT_QUERY requested !\n");
1620                 }
1621         if (uDeviceID == (UINT16)WAVE_MAPPER) {
1622                 dprintf_mmsys(stddeb, "waveOutOpen      // WAVE_MAPPER mode requested !\n");
1623                 bMapperFlg = TRUE;
1624                 uDeviceID = 0;
1625                 }
1626         if (lpFormat == NULL) return WAVERR_BADFORMAT;
1627
1628         hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
1629         if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
1630         lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveOut);
1631         lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1632         if (lpDesc == NULL) return MMSYSERR_NOMEM;
1633         lpDesc->hWave = hWaveOut;
1634         lpDesc->lpFormat = lpFormat;  /* should the struct be copied iso pointer? */
1635         lpDesc->dwCallBack = dwCallback;
1636         lpDesc->dwInstance = dwInstance;
1637         if (uDeviceID >= MAXWAVEDRIVERS) uDeviceID = 0;
1638         while(uDeviceID < MAXWAVEDRIVERS) {
1639                 dwRet = wodMessage(uDeviceID, WODM_OPEN,
1640                         lpDesc->dwInstance, (DWORD)lp16Desc, dwFlags);
1641                 if (dwRet == MMSYSERR_NOERROR) break;
1642                 if (!bMapperFlg) break;
1643                 uDeviceID++;
1644                 dprintf_mmsys(stddeb, "waveOutOpen      // WAVE_MAPPER mode ! try next driver...\n");
1645                 }
1646         lpDesc->uDeviceID = uDeviceID;  /* save physical Device ID */
1647         if (dwFlags & WAVE_FORMAT_QUERY) {
1648                 dprintf_mmsys(stddeb, "waveOutOpen      // End of WAVE_FORMAT_QUERY !\n");
1649                 dwRet = waveOutClose(hWaveOut);
1650                 }
1651         return dwRet;
1652 }
1653
1654 /**************************************************************************
1655 *                               waveOutClose            [MMSYSTEM.405]
1656 */
1657 UINT16 WINAPI waveOutClose(HWAVEOUT16 hWaveOut)
1658 {
1659         LPWAVEOPENDESC  lpDesc;
1660
1661         dprintf_mmsys(stddeb, "waveOutClose(%04X)\n", hWaveOut);
1662         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1663         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1664         return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1665 }
1666
1667 /**************************************************************************
1668 *                               waveOutPrepareHeader    [MMSYSTEM.406]
1669 */
1670 UINT16 WINAPI waveOutPrepareHeader(HWAVEOUT16 hWaveOut,
1671                                    WAVEHDR * lpWaveOutHdr, UINT16 uSize)
1672 {
1673         LPWAVEOPENDESC  lpDesc;
1674
1675         dprintf_mmsys(stddeb, "waveOutPrepareHeader(%04X, %p, %u);\n",
1676                                         hWaveOut, lpWaveOutHdr, uSize);
1677         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1678         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1679         return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
1680                                                         (DWORD)lpWaveOutHdr, uSize);
1681 }
1682
1683 /**************************************************************************
1684 *                               waveOutUnprepareHeader  [MMSYSTEM.407]
1685 */
1686 UINT16 WINAPI waveOutUnprepareHeader(HWAVEOUT16 hWaveOut,
1687                                      WAVEHDR * lpWaveOutHdr, UINT16 uSize)
1688 {
1689         LPWAVEOPENDESC  lpDesc;
1690
1691         dprintf_mmsys(stddeb, "waveOutUnprepareHeader(%04X, %p, %u);\n",
1692                                                 hWaveOut, lpWaveOutHdr, uSize);
1693         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1694         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1695         return wodMessage( lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance,
1696                                                         (DWORD)lpWaveOutHdr, uSize);
1697 }
1698
1699 /**************************************************************************
1700 *                               waveOutWrite            [MMSYSTEM.408]
1701 */
1702 UINT16 WINAPI waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
1703                            UINT16 uSize)
1704 {
1705         LPWAVEOPENDESC  lpDesc;
1706
1707         dprintf_mmsys(stddeb, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
1708         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1709         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1710         return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance,
1711                                                         (DWORD)lpWaveOutHdr, uSize);
1712 }
1713
1714 /**************************************************************************
1715 *                               waveOutPause            [MMSYSTEM.409]
1716 */
1717 UINT16 WINAPI waveOutPause(HWAVEOUT16 hWaveOut)
1718 {
1719         LPWAVEOPENDESC  lpDesc;
1720
1721         dprintf_mmsys(stddeb, "waveOutPause(%04X)\n", hWaveOut);
1722         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1723         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1724         return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
1725 }
1726
1727 /**************************************************************************
1728 *                               waveOutRestart          [MMSYSTEM.410]
1729 */
1730 UINT16 WINAPI waveOutRestart(HWAVEOUT16 hWaveOut)
1731 {
1732         LPWAVEOPENDESC  lpDesc;
1733
1734         dprintf_mmsys(stddeb, "waveOutRestart(%04X)\n", hWaveOut);
1735         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1736         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1737         return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
1738 }
1739
1740 /**************************************************************************
1741 *                               waveOutReset            [MMSYSTEM.411]
1742 */
1743 UINT16 WINAPI waveOutReset(HWAVEOUT16 hWaveOut)
1744 {
1745         LPWAVEOPENDESC  lpDesc;
1746         dprintf_mmsys(stddeb, "waveOutReset(%04X)\n", hWaveOut);
1747         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1748         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1749         return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
1750 }
1751
1752 /**************************************************************************
1753 *                               waveOutGetPosition      [MMSYSTEM.412]
1754 */
1755 UINT16 WINAPI waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpTime,
1756                                  UINT16 uSize)
1757 {
1758         LPWAVEOPENDESC  lpDesc;
1759         dprintf_mmsys(stddeb, "waveOutGetPosition(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
1760         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1761         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1762         return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
1763                                                         (DWORD)lpTime, (DWORD)uSize);
1764 }
1765
1766 /**************************************************************************
1767 *                               waveOutGetPitch         [MMSYSTEM.413]
1768 */
1769 UINT16 WINAPI waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch)
1770 {
1771         LPWAVEOPENDESC  lpDesc;
1772         dprintf_mmsys(stddeb, "waveOutGetPitch(%04X, %p);\n", hWaveOut, lpdwPitch);
1773         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1774         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1775         return wodMessage( lpDesc->uDeviceID, WODM_GETPITCH, lpDesc->dwInstance,
1776                                                                 (DWORD)lpdwPitch, 0L);
1777 }
1778
1779 /**************************************************************************
1780 *                               waveOutSetPitch         [MMSYSTEM.414]
1781 */
1782 UINT16 WINAPI waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch)
1783 {
1784         LPWAVEOPENDESC  lpDesc;
1785         dprintf_mmsys(stddeb, "waveOutSetPitch(%04X, %08lX);\n", hWaveOut, dwPitch);
1786         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1787         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1788         return wodMessage( lpDesc->uDeviceID, WODM_SETPITCH, lpDesc->dwInstance, (DWORD)dwPitch, 0L);
1789 }
1790
1791 /**************************************************************************
1792 *                               waveOutGetVolume        [MMSYSTEM.415]
1793 */
1794 UINT16 WINAPI waveOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume)
1795 {
1796         dprintf_mmsys(stddeb, "waveOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
1797         return wodMessage(uDeviceID, WODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1798 }
1799
1800 /**************************************************************************
1801 *                               waveOutSetVolume        [MMSYSTEM.416]
1802 */
1803 UINT16 WINAPI waveOutSetVolume(UINT16 uDeviceID, DWORD dwVolume)
1804 {
1805         dprintf_mmsys(stddeb, "waveOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
1806         return wodMessage(uDeviceID, WODM_SETVOLUME, 0L, dwVolume, 0L);
1807 }
1808
1809 /**************************************************************************
1810 *                               waveOutGetPlaybackRate  [MMSYSTEM.417]
1811 */
1812 UINT16 WINAPI waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate)
1813 {
1814         LPWAVEOPENDESC  lpDesc;
1815         dprintf_mmsys(stddeb, "waveOutGetPlaybackRate(%04X, %p);\n", hWaveOut, lpdwRate);
1816         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1817         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1818         return wodMessage( lpDesc->uDeviceID, WODM_GETPLAYBACKRATE, lpDesc->dwInstance,
1819                                                                 (DWORD)lpdwRate, 0L);
1820 }
1821
1822 /**************************************************************************
1823 *                               waveOutSetPlaybackRate  [MMSYSTEM.418]
1824 */
1825 UINT16 WINAPI waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate)
1826 {
1827         LPWAVEOPENDESC  lpDesc;
1828         dprintf_mmsys(stddeb, "waveOutSetPlaybackRate(%04X, %08lX);\n", hWaveOut, dwRate);
1829         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1830         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1831         return wodMessage( lpDesc->uDeviceID, WODM_SETPLAYBACKRATE,
1832                 lpDesc->dwInstance, (DWORD)dwRate, 0L);
1833 }
1834
1835 /**************************************************************************
1836 *                               waveOutBreakLoop        [MMSYSTEM.419]
1837 */
1838 UINT16 WINAPI waveOutBreakLoop(HWAVEOUT16 hWaveOut)
1839 {
1840         dprintf_mmsys(stddeb, "waveOutBreakLoop(%04X)\n", hWaveOut);
1841         return MMSYSERR_INVALHANDLE;
1842 }
1843
1844 /**************************************************************************
1845 *                               waveOutGetID            [MMSYSTEM.420]
1846 */
1847 UINT16 WINAPI waveOutGetID(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
1848 {
1849         LPWAVEOPENDESC  lpDesc;
1850         dprintf_mmsys(stddeb, "waveOutGetID(%04X, %p);\n", hWaveOut, lpuDeviceID);
1851         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1852         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1853         if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
1854         *lpuDeviceID = lpDesc->uDeviceID;
1855         return 0;
1856 }
1857
1858 /**************************************************************************
1859 *                               waveOutMessage          [MMSYSTEM.421]
1860 */
1861 DWORD WINAPI waveOutMessage(HWAVEOUT16 hWaveOut, UINT16 uMessage,
1862                             DWORD dwParam1, DWORD dwParam2)
1863 {
1864         LPWAVEOPENDESC  lpDesc;
1865         dprintf_mmsys(stddeb, "waveOutMessage(%04X, %04X, %08lX, %08lX)\n",
1866                         hWaveOut, uMessage, dwParam1, dwParam2);
1867         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1868         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1869         return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1870 }
1871
1872 /**************************************************************************
1873 *                               waveInGetNumDevs                [MMSYSTEM.501]
1874 */
1875 UINT16 WINAPI waveInGetNumDevs()
1876 {
1877         UINT16  count = 0;
1878         dprintf_mmsys(stddeb, "waveInGetNumDevs\n");
1879         count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
1880         dprintf_mmsys(stddeb, "waveInGetNumDevs return %u \n", count);
1881         return count;
1882 }
1883
1884
1885 /**************************************************************************
1886 *                               waveInGetDevCaps                [MMSYSTEM.502]
1887 */
1888 UINT16 WINAPI waveInGetDevCaps(UINT16 uDeviceID, WAVEINCAPS * lpCaps, UINT16 uSize)
1889 {
1890         dprintf_mmsys(stddeb, "waveInGetDevCaps\n");
1891         return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
1892 }
1893
1894
1895 /**************************************************************************
1896 *                               waveInGetErrorText      [MMSYSTEM.503]
1897 */
1898 UINT16 WINAPI waveInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1899 {
1900    dprintf_mmsys(stddeb, "waveInGetErrorText\n");
1901    return(waveGetErrorText(uError, lpText, uSize));
1902 }
1903
1904
1905 /**************************************************************************
1906 *                               waveInOpen                      [MMSYSTEM.504]
1907 */
1908 UINT16 WINAPI waveInOpen(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
1909                          const LPWAVEFORMAT lpFormat, DWORD dwCallback,
1910                          DWORD dwInstance, DWORD dwFlags)
1911 {
1912         HWAVEIN16 hWaveIn;
1913         LPWAVEOPENDESC  lpDesc;
1914         LPWAVEOPENDESC  lp16Desc;
1915         DWORD   dwRet = 0;
1916         BOOL32  bMapperFlg = FALSE;
1917         dprintf_mmsys(stddeb, "waveInOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
1918                 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
1919         if (dwFlags & WAVE_FORMAT_QUERY) {
1920                 dprintf_mmsys(stddeb, "waveInOpen // WAVE_FORMAT_QUERY requested !\n");
1921                 }
1922         if (uDeviceID == (UINT16)WAVE_MAPPER) {
1923                 dprintf_mmsys(stddeb, "waveInOpen       // WAVE_MAPPER mode requested !\n");
1924                 bMapperFlg = TRUE;
1925                 uDeviceID = 0;
1926                 }
1927         if (lpFormat == NULL) return WAVERR_BADFORMAT;
1928         hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
1929         if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
1930         lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveIn);
1931         lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1932         if (lpDesc == NULL) return MMSYSERR_NOMEM;
1933         lpDesc->hWave = hWaveIn;
1934         lpDesc->lpFormat = lpFormat;
1935         lpDesc->dwCallBack = dwCallback;
1936         lpDesc->dwInstance = dwInstance;
1937         while(uDeviceID < MAXWAVEDRIVERS) {
1938                 dwRet = widMessage(uDeviceID, WIDM_OPEN,
1939                         lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
1940                 if (dwRet == MMSYSERR_NOERROR) break;
1941                 if (!bMapperFlg) break;
1942                 uDeviceID++;
1943                 dprintf_mmsys(stddeb, "waveInOpen       // WAVE_MAPPER mode ! try next driver...\n");
1944                 }
1945         lpDesc->uDeviceID = uDeviceID;
1946         if (dwFlags & WAVE_FORMAT_QUERY) {
1947                 dprintf_mmsys(stddeb, "waveInOpen       // End of WAVE_FORMAT_QUERY !\n");
1948                 dwRet = waveInClose(hWaveIn);
1949                 }
1950         return dwRet;
1951 }
1952
1953
1954 /**************************************************************************
1955 *                               waveInClose                     [MMSYSTEM.505]
1956 */
1957 UINT16 WINAPI waveInClose(HWAVEIN16 hWaveIn)
1958 {
1959         LPWAVEOPENDESC  lpDesc;
1960
1961         dprintf_mmsys(stddeb, "waveInClose(%04X)\n", hWaveIn);
1962         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1963         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1964         return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1965 }
1966
1967
1968 /**************************************************************************
1969 *                               waveInPrepareHeader             [MMSYSTEM.506]
1970 */
1971 UINT16 WINAPI waveInPrepareHeader(HWAVEIN16 hWaveIn,
1972                                   WAVEHDR * lpWaveInHdr, UINT16 uSize)
1973 {
1974         LPWAVEOPENDESC  lpDesc;
1975         LPWAVEHDR               lp32WaveInHdr;
1976
1977         dprintf_mmsys(stddeb, "waveInPrepareHeader(%04X, %p, %u);\n",
1978                                         hWaveIn, lpWaveInHdr, uSize);
1979         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1980         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1981         if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1982         lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1983         lp32WaveInHdr->lp16Next = (SEGPTR)NULL;
1984     lp32WaveInHdr->dwBytesRecorded = 0;
1985         dprintf_mmsys(stddeb, "waveInPrepareHeader // lpData=%p size=%lu \n",
1986                 lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength);
1987         return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance,
1988                                                         (DWORD)lpWaveInHdr, uSize);
1989 }
1990
1991
1992 /**************************************************************************
1993 *                               waveInUnprepareHeader   [MMSYSTEM.507]
1994 */
1995 UINT16 WINAPI waveInUnprepareHeader(HWAVEIN16 hWaveIn,
1996                                     WAVEHDR * lpWaveInHdr, UINT16 uSize)
1997 {
1998         LPWAVEOPENDESC  lpDesc;
1999         LPWAVEHDR               lp32WaveInHdr;
2000
2001         dprintf_mmsys(stddeb, "waveInUnprepareHeader(%04X, %p, %u);\n",
2002                                                 hWaveIn, lpWaveInHdr, uSize);
2003         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2004         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2005         if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
2006         lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
2007         USER_HEAP_FREE(HIWORD((DWORD)lp32WaveInHdr->lpData));
2008         lp32WaveInHdr->lpData = NULL;
2009         lp32WaveInHdr->lp16Next = (SEGPTR)NULL;
2010         return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance,
2011                                                         (DWORD)lpWaveInHdr, uSize);
2012 }
2013
2014
2015 /**************************************************************************
2016 *                               waveInAddBuffer         [MMSYSTEM.508]
2017 */
2018 UINT16 WINAPI waveInAddBuffer(HWAVEIN16 hWaveIn,
2019                               WAVEHDR * lpWaveInHdr, UINT16 uSize)
2020 {
2021         LPWAVEOPENDESC  lpDesc;
2022         LPWAVEHDR               lp32WaveInHdr;
2023
2024         dprintf_mmsys(stddeb, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
2025         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2026         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2027         if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
2028         lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
2029         lp32WaveInHdr->lp16Next = (SEGPTR)NULL;
2030     lp32WaveInHdr->dwBytesRecorded = 0;
2031         dprintf_mmsys(stddeb, "waveInAddBuffer // lpData=%p size=%lu \n",
2032                 lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength);
2033         return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
2034                                                                 (DWORD)lpWaveInHdr, uSize);
2035 }
2036
2037
2038 /**************************************************************************
2039 *                               waveInStart                     [MMSYSTEM.509]
2040 */
2041 UINT16 WINAPI waveInStart(HWAVEIN16 hWaveIn)
2042 {
2043         LPWAVEOPENDESC  lpDesc;
2044
2045         dprintf_mmsys(stddeb, "waveInStart(%04X)\n", hWaveIn);
2046         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2047         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2048         return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0L, 0L);
2049 }
2050
2051
2052 /**************************************************************************
2053 *                               waveInStop                      [MMSYSTEM.510]
2054 */
2055 UINT16 WINAPI waveInStop(HWAVEIN16 hWaveIn)
2056 {
2057         LPWAVEOPENDESC  lpDesc;
2058
2059         dprintf_mmsys(stddeb, "waveInStop(%04X)\n", hWaveIn);
2060         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2061         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2062         return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
2063 }
2064
2065
2066 /**************************************************************************
2067 *                               waveInReset                     [MMSYSTEM.511]
2068 */
2069 UINT16 WINAPI waveInReset(HWAVEIN16 hWaveIn)
2070 {
2071         LPWAVEOPENDESC  lpDesc;
2072
2073         dprintf_mmsys(stddeb, "waveInReset(%04X)\n", hWaveIn);
2074         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2075         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2076         return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0L, 0L);
2077 }
2078
2079
2080 /**************************************************************************
2081 *                               waveInGetPosition       [MMSYSTEM.512]
2082 */
2083 UINT16 WINAPI waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpTime,
2084                                 UINT16 uSize)
2085 {
2086         LPWAVEOPENDESC  lpDesc;
2087
2088         dprintf_mmsys(stddeb, "waveInGetPosition(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
2089         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2090         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2091         return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
2092                           (DWORD)lpTime, (DWORD)uSize);
2093 }
2094
2095
2096 /**************************************************************************
2097 *                               waveInGetID                     [MMSYSTEM.513]
2098 */
2099 UINT16 WINAPI waveInGetID(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
2100 {
2101         LPWAVEOPENDESC  lpDesc;
2102
2103         dprintf_mmsys(stddeb, "waveInGetID\n");
2104         if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
2105         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2106         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2107         *lpuDeviceID = lpDesc->uDeviceID;
2108         return 0;
2109 }
2110
2111
2112 /**************************************************************************
2113 *                               waveInMessage           [MMSYSTEM.514]
2114 */
2115 DWORD WINAPI waveInMessage(HWAVEIN16 hWaveIn, UINT16 uMessage,
2116                            DWORD dwParam1, DWORD dwParam2)
2117 {
2118         LPWAVEOPENDESC  lpDesc;
2119
2120         dprintf_mmsys(stddeb, "waveInMessage(%04X, %04X, %08lX, %08lX)\n",
2121                         hWaveIn, uMessage, dwParam1, dwParam2);
2122         lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2123         if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2124         return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2125 }
2126
2127
2128 /**************************************************************************
2129 *                               mmioOpen                [MMSYSTEM.1210]
2130 */
2131 HMMIO16 WINAPI mmioOpen(LPSTR szFileName, MMIOINFO * lpmmioinfo,
2132                         DWORD dwOpenFlags)
2133 {
2134         HFILE32 hFile;
2135         HMMIO16         hmmio;
2136         OFSTRUCT        ofs;
2137         LPMMIOINFO      lpmminfo;
2138         dprintf_mmio(stddeb, "mmioOpen('%s', %p, %08lX);\n", szFileName, lpmmioinfo, dwOpenFlags);
2139         if (!szFileName)
2140         {
2141             /* FIXME: should load memory file if szFileName == NULL */
2142             fprintf(stderr, "WARNING: mmioOpen(): szFileName == NULL (memory file ???)\n");
2143             return 0;
2144         }
2145         hFile = OpenFile32(szFileName, &ofs, dwOpenFlags);
2146         if (hFile == -1) return 0;
2147         hmmio = GlobalAlloc16(GMEM_MOVEABLE, sizeof(MMIOINFO));
2148         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2149         if (lpmminfo == NULL) return 0;
2150         memset(lpmminfo, 0, sizeof(MMIOINFO));
2151         lpmminfo->hmmio = hmmio;
2152         lpmminfo->dwReserved2 = hFile;
2153         GlobalUnlock16(hmmio);
2154         dprintf_mmio(stddeb, "mmioOpen // return hmmio=%04X\n", hmmio);
2155         return hmmio;
2156 }
2157
2158
2159 /**************************************************************************
2160 *                               mmioClose               [MMSYSTEM.1211]
2161 */
2162 UINT16 WINAPI mmioClose(HMMIO16 hmmio, UINT16 uFlags)
2163 {
2164         LPMMIOINFO      lpmminfo;
2165         dprintf_mmio(stddeb, "mmioClose(%04X, %04X);\n", hmmio, uFlags);
2166         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2167         if (lpmminfo == NULL) return 0;
2168         _lclose32((HFILE32)lpmminfo->dwReserved2);
2169         GlobalUnlock16(hmmio);
2170         GlobalFree16(hmmio);
2171         return 0;
2172 }
2173
2174
2175
2176 /**************************************************************************
2177 *                               mmioRead                [MMSYSTEM.1212]
2178 */
2179 LONG WINAPI mmioRead(HMMIO16 hmmio, HPSTR pch, LONG cch)
2180 {
2181         LONG            count;
2182         LPMMIOINFO      lpmminfo;
2183         dprintf_mmio(stddeb, "mmioRead(%04X, %p, %ld);\n", hmmio, pch, cch);
2184         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2185         if (lpmminfo == NULL) return 0;
2186         count = _lread32(LOWORD(lpmminfo->dwReserved2), pch, cch);
2187         GlobalUnlock16(hmmio);
2188         dprintf_mmio(stddeb, "mmioRead // count=%ld\n", count);
2189         return count;
2190 }
2191
2192
2193
2194 /**************************************************************************
2195 *                               mmioWrite               [MMSYSTEM.1213]
2196 */
2197 LONG WINAPI mmioWrite(HMMIO16 hmmio, HPCSTR pch, LONG cch)
2198 {
2199         LONG            count;
2200         LPMMIOINFO      lpmminfo;
2201         dprintf_mmio(stddeb, "mmioWrite(%04X, %p, %ld);\n", hmmio, pch, cch);
2202         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2203         if (lpmminfo == NULL) return 0;
2204         count = _lwrite32(LOWORD(lpmminfo->dwReserved2), (LPSTR)pch, cch);
2205         GlobalUnlock16(hmmio);
2206         return count;
2207 }
2208
2209 /**************************************************************************
2210 *                               mmioSeek                [MMSYSTEM.1214]
2211 */
2212 LONG WINAPI mmioSeek(HMMIO16 hmmio, LONG lOffset, int iOrigin)
2213 {
2214         int             count;
2215         LPMMIOINFO      lpmminfo;
2216         dprintf_mmio(stddeb, "mmioSeek(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin);
2217         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2218         if (lpmminfo == NULL) {
2219                 dprintf_mmio(stddeb, "mmioSeek // can't lock hmmio=%04X !\n", hmmio);
2220                 return 0;
2221                 }
2222         count = _llseek32((HFILE32)lpmminfo->dwReserved2, lOffset, iOrigin);
2223         GlobalUnlock16(hmmio);
2224         return count;
2225 }
2226
2227 /**************************************************************************
2228 *                               mmioGetInfo             [MMSYSTEM.1215]
2229 */
2230 UINT16 WINAPI mmioGetInfo(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags)
2231 {
2232         LPMMIOINFO      lpmminfo;
2233         dprintf_mmio(stddeb, "mmioGetInfo\n");
2234         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2235         if (lpmminfo == NULL) return 0;
2236         memcpy(lpmmioinfo, lpmminfo, sizeof(MMIOINFO));
2237         GlobalUnlock16(hmmio);
2238         return 0;
2239 }
2240
2241 /**************************************************************************
2242 *                               mmioSetInfo             [MMSYSTEM.1216]
2243 */
2244 UINT16 WINAPI mmioSetInfo(HMMIO16 hmmio, const MMIOINFO * lpmmioinfo, UINT16 uFlags)
2245 {
2246         LPMMIOINFO      lpmminfo;
2247         dprintf_mmio(stddeb, "mmioSetInfo\n");
2248         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2249         if (lpmminfo == NULL) return 0;
2250         GlobalUnlock16(hmmio);
2251         return 0;
2252 }
2253
2254 /**************************************************************************
2255 *                               mmioSetBuffer           [MMSYSTEM.1217]
2256 */
2257 UINT16 WINAPI mmioSetBuffer(HMMIO16 hmmio, LPSTR pchBuffer,
2258                             LONG cchBuffer, UINT16 uFlags)
2259 {
2260         dprintf_mmio(stddeb, "mmioSetBuffer // empty stub \n");
2261         return 0;
2262 }
2263
2264 /**************************************************************************
2265 *                               mmioFlush               [MMSYSTEM.1218]
2266 */
2267 UINT16 WINAPI mmioFlush(HMMIO16 hmmio, UINT16 uFlags)
2268 {
2269         LPMMIOINFO      lpmminfo;
2270         dprintf_mmio(stddeb, "mmioFlush(%04X, %04X)\n", hmmio, uFlags);
2271         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2272         if (lpmminfo == NULL) return 0;
2273         GlobalUnlock16(hmmio);
2274         return 0;
2275 }
2276
2277 /**************************************************************************
2278 *                               mmioAdvance             [MMSYSTEM.1219]
2279 */
2280 UINT16 WINAPI mmioAdvance(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags)
2281 {
2282         int             count = 0;
2283         LPMMIOINFO      lpmminfo;
2284         dprintf_mmio(stddeb, "mmioAdvance\n");
2285         lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2286         if (lpmminfo == NULL) return 0;
2287         if (uFlags == MMIO_READ) {
2288                 count = _lread32(LOWORD(lpmminfo->dwReserved2),
2289                         lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer);
2290                 }
2291         if (uFlags == MMIO_WRITE) {
2292                 count = _lwrite32(LOWORD(lpmminfo->dwReserved2),
2293                         lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer);
2294                 }
2295         lpmmioinfo->pchNext     += count;
2296         GlobalUnlock16(hmmio);
2297         lpmminfo->lDiskOffset = _llseek32((HFILE32)lpmminfo->dwReserved2, 0, SEEK_CUR);
2298         return 0;
2299 }
2300
2301 /**************************************************************************
2302 *                               mmioStringToFOURCC      [MMSYSTEM.1220]
2303 */
2304 FOURCC WINAPI mmioStringToFOURCC(LPCSTR sz, UINT16 uFlags)
2305 {
2306         dprintf_mmio(stddeb, "mmioStringToFOURCC // empty stub \n");
2307         return 0;
2308 }
2309
2310 /**************************************************************************
2311 *                               mmioInstallIOProc16     [MMSYSTEM.1221]
2312 */
2313 LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc,
2314                                         LPMMIOPROC16 pIOProc, DWORD dwFlags)
2315 {
2316         dprintf_mmio(stddeb, "mmioInstallIOProc // empty stub \n");
2317         return 0;
2318 }
2319
2320 /**************************************************************************
2321  *                              mmioInstallIOProc32A   [WINMM.120]
2322  */
2323 LPMMIOPROC32 WINAPI mmioInstallIOProc32A(FOURCC fccIOProc,
2324                                          LPMMIOPROC32 pIOProc, DWORD dwFlags)
2325 {
2326         dprintf_mmio(stddeb, "mmioInstallIOProcA (%c%c%c%c,%p,0x%08lx)// empty stub \n",
2327                      (char)((fccIOProc&0xff000000)>>24),
2328                      (char)((fccIOProc&0x00ff0000)>>16),
2329                      (char)((fccIOProc&0x0000ff00)>> 8),
2330                      (char)(fccIOProc&0x000000ff),
2331                      pIOProc, dwFlags );
2332         return 0;
2333 }
2334
2335 /**************************************************************************
2336 *                               mmioSendMessage         [MMSYSTEM.1222]
2337 */
2338 LRESULT WINAPI mmioSendMessage(HMMIO16 hmmio, UINT16 uMessage,
2339                                LPARAM lParam1, LPARAM lParam2)
2340 {
2341         dprintf_mmio(stddeb, "mmioSendMessage // empty stub \n");
2342         return 0;
2343 }
2344
2345 /**************************************************************************
2346 *                               mmioDescend             [MMSYSTEM.1223]
2347 */
2348 UINT16 WINAPI mmioDescend(HMMIO16 hmmio, MMCKINFO * lpck,
2349                           const MMCKINFO * lpckParent, UINT16 uFlags)
2350 {
2351         DWORD   dwfcc, dwOldPos;
2352
2353         dprintf_mmio(stddeb, "mmioDescend(%04X, %p, %p, %04X);\n",
2354                                 hmmio, lpck, lpckParent, uFlags);
2355
2356         if (lpck == NULL)
2357             return 0;
2358
2359         dwfcc = lpck->ckid;
2360         dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX\n", dwfcc);
2361
2362         dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
2363         dprintf_mmio(stddeb, "mmioDescend // dwOldPos=%ld\n", dwOldPos);
2364
2365         if (lpckParent != NULL) {
2366                 dprintf_mmio(stddeb, "mmioDescend // seek inside parent at %ld !\n", lpckParent->dwDataOffset);
2367                 dwOldPos = mmioSeek(hmmio, lpckParent->dwDataOffset, SEEK_SET);
2368         }
2369 /*
2370
2371    It seems to be that FINDRIFF should not be treated the same as the
2372    other FINDxxx so I treat it as a MMIO_FINDxxx
2373
2374         if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDRIFF) ||
2375                 (uFlags & MMIO_FINDLIST)) {
2376 */
2377         if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDLIST)) {
2378                 dprintf_mmio(stddeb, "mmioDescend // MMIO_FINDxxxx dwfcc=%08lX !\n", dwfcc);
2379                 while (TRUE) {
2380                         LONG ix;
2381
2382                         ix = mmioRead(hmmio, (LPSTR)lpck, sizeof(MMCKINFO));
2383                         dprintf_mmio(stddeb, "mmioDescend // after _lread32 ix = %ld req = %d, errno = %d\n",ix,sizeof(MMCKINFO),errno);
2384                         if (ix < sizeof(MMCKINFO)) {
2385
2386                                 mmioSeek(hmmio, dwOldPos, SEEK_SET);
2387                                 dprintf_mmio(stddeb, "mmioDescend // return ChunkNotFound\n");
2388                                 return MMIOERR_CHUNKNOTFOUND;
2389                         }
2390                         dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX ckid=%08lX cksize=%08lX !\n",
2391                                                                         dwfcc, lpck->ckid, lpck->cksize);
2392                         if (dwfcc == lpck->ckid)
2393                                 break;
2394
2395                         dwOldPos += lpck->cksize + 2 * sizeof(DWORD);
2396                         if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
2397                                 dwOldPos += sizeof(DWORD);
2398                         mmioSeek(hmmio, dwOldPos, SEEK_SET);
2399                 }
2400         }
2401         else {
2402                 if (mmioRead(hmmio, (LPSTR)lpck, sizeof(MMCKINFO)) < sizeof(MMCKINFO)) {
2403                         mmioSeek(hmmio, dwOldPos, SEEK_SET);
2404                         dprintf_mmio(stddeb, "mmioDescend // return ChunkNotFound 2nd\n");
2405                         return MMIOERR_CHUNKNOTFOUND;
2406                 }
2407         }
2408         lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
2409         if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
2410                 lpck->dwDataOffset += sizeof(DWORD);
2411         mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
2412
2413         dprintf_mmio(stddeb, "mmioDescend // lpck->ckid=%08lX lpck->cksize=%ld !\n",
2414                                                                 lpck->ckid, lpck->cksize);
2415         dprintf_mmio(stddeb, "mmioDescend // lpck->fccType=%08lX !\n", lpck->fccType);
2416
2417         return 0;
2418 }
2419
2420 /**************************************************************************
2421 *                               mmioAscend              [MMSYSTEM.1224]
2422 */
2423 UINT16 WINAPI mmioAscend(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags)
2424 {
2425         dprintf_mmio(stddeb, "mmioAscend // empty stub !\n");
2426         return 0;
2427 }
2428
2429 /**************************************************************************
2430 *                               mmioCreateChunk         [MMSYSTEM.1225]
2431 */
2432 UINT16 WINAPI mmioCreateChunk(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags)
2433 {
2434         dprintf_mmio(stddeb, "mmioCreateChunk // empty stub \n");
2435         return 0;
2436 }
2437
2438
2439 /**************************************************************************
2440 *                               mmioRename              [MMSYSTEM.1226]
2441 */
2442 UINT16 WINAPI mmioRename(LPCSTR szFileName, LPCSTR szNewFileName,
2443                          MMIOINFO * lpmmioinfo, DWORD dwRenameFlags)
2444 {
2445         dprintf_mmio(stddeb, "mmioRename('%s', '%s', %p, %08lX); // empty stub \n",
2446                         szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
2447         return 0;
2448 }
2449
2450 /**************************************************************************
2451 *                               DrvOpen                 [MMSYSTEM.1100]
2452 */
2453 HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
2454 {
2455         dprintf_mmsys(stddeb, "DrvOpen('%s', '%s', %08lX);\n",
2456                 lpDriverName, lpSectionName, lParam);
2457         return OpenDriver(lpDriverName, lpSectionName, lParam);
2458 }
2459
2460
2461 /**************************************************************************
2462 *                               DrvClose                [MMSYSTEM.1101]
2463 */
2464 LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
2465 {
2466         dprintf_mmsys(stddeb, "DrvClose(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
2467         return CloseDriver(hDrvr, lParam1, lParam2);
2468 }
2469
2470
2471 /**************************************************************************
2472 *                               DrvSendMessage          [MMSYSTEM.1102]
2473 */
2474 LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1,
2475                               LPARAM lParam2)
2476 {
2477         DWORD   dwDriverID = 0;
2478         dprintf_mmsys(stddeb, "DrvSendMessage(%04X, %04X, %08lX, %08lX);\n",
2479                                         hDriver, msg, lParam1, lParam2);
2480         return CDAUDIO_DriverProc(dwDriverID, hDriver, msg, lParam1, lParam2);
2481 }
2482
2483 /**************************************************************************
2484 *                               DrvGetModuleHandle      [MMSYSTEM.1103]
2485 */
2486 HANDLE16 WINAPI DrvGetModuleHandle(HDRVR16 hDrvr)
2487 {
2488         dprintf_mmsys(stddeb, "DrvGetModuleHandle(%04X);\n", hDrvr);
2489         return 0;
2490 }
2491
2492
2493 /**************************************************************************
2494 *                               DrvDefDriverProc        [MMSYSTEM.1104]
2495 */
2496 LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
2497                                 DWORD dwParam1, DWORD dwParam2)
2498 {
2499         return DefDriverProc(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
2500 }