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

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