dlls/mmsystem.dll16/message16.c

   1 /*
   2  * MMSYSTEM MCI and low level mapping functions
   3  *
   4  * Copyright 1999 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <string.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <assert.h>
  25 #include "wine/winbase16.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "wownt32.h"
  30 #include "winemm16.h"
  31 #include "digitalv.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  35
  36 /* =================================
  37  *       A U X    M A P P E R S
  38  * ================================= */
  39
  40 /* =================================
  41  *     M I X E R  M A P P E R S
  42  * ================================= */
  43
  44 /**************************************************************************
  45  *                              MMSYSTDRV_Mixer_Map16To32W              [internal]
  46  */
  47 static  MMSYSTEM_MapType        MMSYSTDRV_Mixer_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
  48 {
  49     return MMSYSTEM_MAP_MSGERROR;
  50 }
  51
  52 /**************************************************************************
  53  *                              MMSYSTDRV_Mixer_UnMap16To32W    [internal]
  54  */
  55 static  MMSYSTEM_MapType        MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
  56 {
  57 #if 0
  58     MIXERCAPSA  micA;
  59     UINT        ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
  60
  61     if (ret == MMSYSERR_NOERROR) {
  62         mixcaps->wMid           = micA.wMid;
  63         mixcaps->wPid           = micA.wPid;
  64         mixcaps->vDriverVersion = micA.vDriverVersion;
  65         strcpy(mixcaps->szPname, micA.szPname);
  66         mixcaps->fdwSupport     = micA.fdwSupport;
  67         mixcaps->cDestinations  = micA.cDestinations;
  68     }
  69     return ret;
  70 #endif
  71     return MMSYSTEM_MAP_MSGERROR;
  72 }
  73
  74 /**************************************************************************
  75  *                              MMSYSTDRV_Mixer_MapCB
  76  */
  77 static  void                    MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
  78 {
  79     FIXME("NIY\n");
  80 }
  81
  82 /* =================================
  83  *   M I D I  I N    M A P P E R S
  84  * ================================= */
  85
  86 /**************************************************************************
  87  *                              MMSYSTDRV_MidiIn_Map16To32W             [internal]
  88  */
  89 static  MMSYSTEM_MapType        MMSYSTDRV_MidiIn_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
  90 {
  91     return MMSYSTEM_MAP_MSGERROR;
  92 }
  93
  94 /**************************************************************************
  95  *                              MMSYSTDRV_MidiIn_UnMap16To32W   [internal]
  96  */
  97 static  MMSYSTEM_MapType        MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
  98 {
  99     return MMSYSTEM_MAP_MSGERROR;
 100 }
 101
 102 /**************************************************************************
 103  *                              MMSYSTDRV_MidiIn_MapCB          [internal]
 104  */
 105 static  void                    MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
 106 {
 107     switch (uMsg) {
 108     case MIM_OPEN:
 109     case MIM_CLOSE:
 110         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 111
 112     case MIM_DATA:
 113     case MIM_MOREDATA:
 114     case MIM_ERROR:
 115         /* dwParam1 & dwParam2 are data, nothing to do */
 116         break;
 117     case MIM_LONGDATA:
 118     case MIM_LONGERROR:
 119         {
 120             LPMIDIHDR           mh32 = (LPMIDIHDR)(*dwParam1);
 121             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 122             LPMIDIHDR16         mh16 = MapSL(segmh16);
 123
 124             *dwParam1 = (DWORD)segmh16;
 125             mh16->dwFlags = mh32->dwFlags;
 126             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 127         }
 128         break;
 129     default:
 130         ERR("Unknown msg %u\n", uMsg);
 131     }
 132 }
 133
 134 /* =================================
 135  *   M I D I  O U T  M A P P E R S
 136  * ================================= */
 137
 138 /**************************************************************************
 139  *                              MMSYSTDRV_MidiOut_Map16To32W    [internal]
 140  */
 141 static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 142 {
 143     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
 144
 145     switch (wMsg) {
 146     case MODM_GETNUMDEVS:
 147     case MODM_DATA:
 148     case MODM_RESET:
 149     case MODM_SETVOLUME:
 150         ret = MMSYSTEM_MAP_OK;
 151         break;
 152
 153     case MODM_OPEN:
 154     case MODM_CLOSE:
 155     case MODM_GETVOLUME:
 156         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 157         break;
 158
 159     case MODM_GETDEVCAPS:
 160         {
 161             LPMIDIOUTCAPSW      moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW));
 162             LPMIDIOUTCAPS16     moc16 = MapSL(*lpParam1);
 163
 164             if (moc32) {
 165                 *(LPMIDIOUTCAPS16*)moc32 = moc16;
 166                 moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
 167                 *lpParam1 = (DWORD)moc32;
 168                 *lpParam2 = sizeof(MIDIOUTCAPSW);
 169
 170                 ret = MMSYSTEM_MAP_OKMEM;
 171             } else {
 172                 ret = MMSYSTEM_MAP_NOMEM;
 173             }
 174         }
 175         break;
 176     case MODM_PREPARE:
 177         {
 178             LPMIDIHDR           mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
 179             LPMIDIHDR16         mh16 = MapSL(*lpParam1);
 180
 181             if (mh32) {
 182                 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
 183                 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
 184                 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
 185                 mh32->dwBufferLength = mh16->dwBufferLength;
 186                 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 187                 mh32->dwUser = mh16->dwUser;
 188                 mh32->dwFlags = mh16->dwFlags;
 189                 mh16->lpNext = (MIDIHDR16*)mh32; /* for reuse in unprepare and write */
 190                 *lpParam1 = (DWORD)mh32;
 191                 *lpParam2 = offsetof(MIDIHDR,dwOffset); /* old size, without dwOffset */
 192
 193                 ret = MMSYSTEM_MAP_OKMEM;
 194             } else {
 195                 ret = MMSYSTEM_MAP_NOMEM;
 196             }
 197         }
 198         break;
 199     case MODM_UNPREPARE:
 200     case MODM_LONGDATA:
 201         {
 202             LPMIDIHDR16         mh16 = MapSL(*lpParam1);
 203             LPMIDIHDR           mh32 = (MIDIHDR*)mh16->lpNext;
 204
 205             *lpParam1 = (DWORD)mh32;
 206             *lpParam2 = offsetof(MIDIHDR,dwOffset);
 207             /* dwBufferLength can be reduced between prepare & write */
 208             if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
 209                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
 210                     mh32->dwBufferLength, mh16->dwBufferLength);
 211             } else
 212                 mh32->dwBufferLength = mh16->dwBufferLength;
 213             ret = MMSYSTEM_MAP_OKMEM;
 214         }
 215         break;
 216
 217     case MODM_CACHEPATCHES:
 218     case MODM_CACHEDRUMPATCHES:
 219     default:
 220         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 221         break;
 222     }
 223     return ret;
 224 }
 225
 226 /**************************************************************************
 227  *                              MMSYSTDRV_MidiOut_UnMap16To32W  [internal]
 228  */
 229 static  MMSYSTEM_MapType        MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 230 {
 231     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
 232
 233     switch (wMsg) {
 234     case MODM_GETNUMDEVS:
 235     case MODM_DATA:
 236     case MODM_RESET:
 237     case MODM_SETVOLUME:
 238         ret = MMSYSTEM_MAP_OK;
 239         break;
 240
 241     case MODM_OPEN:
 242     case MODM_CLOSE:
 243     case MODM_GETVOLUME:
 244         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 245         break;
 246
 247     case MODM_GETDEVCAPS:
 248         {
 249             LPMIDIOUTCAPSW              moc32 = (LPMIDIOUTCAPSW)(*lpParam1);
 250             LPMIDIOUTCAPS16             moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
 251
 252             moc16->wMid                 = moc32->wMid;
 253             moc16->wPid                 = moc32->wPid;
 254             moc16->vDriverVersion       = moc32->vDriverVersion;
 255             WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
 256                                  sizeof(moc16->szPname), NULL, NULL );
 257             moc16->wTechnology          = moc32->wTechnology;
 258             moc16->wVoices              = moc32->wVoices;
 259             moc16->wNotes               = moc32->wNotes;
 260             moc16->wChannelMask         = moc32->wChannelMask;
 261             moc16->dwSupport            = moc32->dwSupport;
 262             HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
 263             ret = MMSYSTEM_MAP_OK;
 264         }
 265         break;
 266     case MODM_PREPARE:
 267     case MODM_UNPREPARE:
 268     case MODM_LONGDATA:
 269         {
 270             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
 271             LPMIDIHDR16         mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
 272
 273             assert((MIDIHDR*)mh16->lpNext == mh32);
 274             mh16->dwFlags = mh32->dwFlags;
 275
 276             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 277                 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
 278                 mh16->lpNext = 0;
 279             }
 280             ret = MMSYSTEM_MAP_OK;
 281         }
 282         break;
 283
 284     case MODM_CACHEPATCHES:
 285     case MODM_CACHEDRUMPATCHES:
 286     default:
 287         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 288         break;
 289     }
 290     return ret;
 291 }
 292
 293 /******************************************************************
 294  *                                      MMSYSTDRV_MidiOut_MapCB
 295  */
 296 static  void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
 297 {
 298     switch (uMsg) {
 299     case MOM_OPEN:
 300     case MOM_CLOSE:
 301         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 302         break;
 303     case MOM_POSITIONCB:
 304         /* MIDIHDR.dwOffset exists since Win 32 only */
 305         FIXME("MOM_POSITIONCB/MEVT_F_CALLBACK wants MIDIHDR.dwOffset in 16 bit code\n");
 306         /* fall through */
 307     case MOM_DONE:
 308         {
 309             /* initial map is: 16 => 32 */
 310             LPMIDIHDR           mh32 = (LPMIDIHDR)(*dwParam1);
 311             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 312             LPMIDIHDR16         mh16 = MapSL(segmh16);
 313
 314             *dwParam1 = (DWORD)segmh16;
 315             mh16->dwFlags = mh32->dwFlags;
 316         }
 317         break;
 318     default:
 319         ERR("Unknown msg %u\n", uMsg);
 320     }
 321 }
 322
 323 /* =================================
 324  *   W A V E  I N    M A P P E R S
 325  * ================================= */
 326
 327 /**************************************************************************
 328  *                              MMSYSTDRV_WaveIn_Map16To32W             [internal]
 329  */
 330 static  MMSYSTEM_MapType        MMSYSTDRV_WaveIn_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 331 {
 332     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
 333
 334     switch (wMsg) {
 335     case WIDM_GETNUMDEVS:
 336     case WIDM_RESET:
 337     case WIDM_START:
 338     case WIDM_STOP:
 339         ret = MMSYSTEM_MAP_OK;
 340         break;
 341     case WIDM_OPEN:
 342     case WIDM_CLOSE:
 343         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 344         break;
 345     case WIDM_GETDEVCAPS:
 346         {
 347             LPWAVEINCAPSW       wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
 348             LPWAVEINCAPS16      wic16 = MapSL(*lpParam1);
 349
 350             if (wic32) {
 351                 *(LPWAVEINCAPS16*)wic32 = wic16;
 352                 wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
 353                 *lpParam1 = (DWORD)wic32;
 354                 *lpParam2 = sizeof(WAVEINCAPSW);
 355
 356                 ret = MMSYSTEM_MAP_OKMEM;
 357             } else {
 358                 ret = MMSYSTEM_MAP_NOMEM;
 359             }
 360         }
 361         break;
 362     case WIDM_GETPOS:
 363         {
 364             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
 365             LPMMTIME16          mmt16 = MapSL(*lpParam1);
 366
 367             if (mmt32) {
 368                 *(LPMMTIME16*)mmt32 = mmt16;
 369                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
 370
 371                 mmt32->wType = mmt16->wType;
 372                 *lpParam1 = (DWORD)mmt32;
 373                 *lpParam2 = sizeof(MMTIME);
 374
 375                 ret = MMSYSTEM_MAP_OKMEM;
 376             } else {
 377                 ret = MMSYSTEM_MAP_NOMEM;
 378             }
 379         }
 380         break;
 381     case WIDM_PREPARE:
 382         {
 383             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
 384             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 385
 386             if (wh32) {
 387                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
 388                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
 389                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
 390                 wh32->dwBufferLength = wh16->dwBufferLength;
 391                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
 392                 wh32->dwUser = wh16->dwUser;
 393                 wh32->dwFlags = wh16->dwFlags;
 394                 wh32->dwLoops = wh16->dwLoops;
 395                 /* FIXME: nothing on wh32->lpNext */
 396                 /* could link the wh32->lpNext at this level for memory house keeping */
 397                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
 398                 *lpParam1 = (DWORD)wh32;
 399                 *lpParam2 = sizeof(WAVEHDR);
 400
 401                 ret = MMSYSTEM_MAP_OKMEM;
 402             } else {
 403                 ret = MMSYSTEM_MAP_NOMEM;
 404             }
 405         }
 406         break;
 407     case WIDM_ADDBUFFER:
 408     case WIDM_UNPREPARE:
 409         {
 410             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 411             LPWAVEHDR           wh32 = wh16->lpNext;
 412
 413             *lpParam1 = (DWORD)wh32;
 414             *lpParam2 = sizeof(WAVEHDR);
 415             /* dwBufferLength can be reduced between prepare & write */
 416             if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
 417                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
 418                     wh32->dwBufferLength, wh16->dwBufferLength);
 419             } else
 420                 wh32->dwBufferLength = wh16->dwBufferLength;
 421             ret = MMSYSTEM_MAP_OKMEM;
 422         }
 423         break;
 424     case WIDM_MAPPER_STATUS:
 425         /* just a single DWORD */
 426         *lpParam2 = (DWORD)MapSL(*lpParam2);
 427         ret = MMSYSTEM_MAP_OK;
 428         break;
 429     default:
 430         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 431         break;
 432     }
 433     return ret;
 434 }
 435
 436 /**************************************************************************
 437  *                              MMSYSTDRV_WaveIn_UnMap16To32W   [internal]
 438  */
 439 static  MMSYSTEM_MapType        MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 440 {
 441     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
 442
 443     switch (wMsg) {
 444     case WIDM_GETNUMDEVS:
 445     case WIDM_RESET:
 446     case WIDM_START:
 447     case WIDM_STOP:
 448     case WIDM_MAPPER_STATUS:
 449         ret = MMSYSTEM_MAP_OK;
 450         break;
 451     case WIDM_OPEN:
 452     case WIDM_CLOSE:
 453         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 454         break;
 455     case WIDM_GETDEVCAPS:
 456         {
 457             LPWAVEINCAPSW               wic32 = (LPWAVEINCAPSW)(*lpParam1);
 458             LPWAVEINCAPS16              wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 459
 460             wic16->wMid = wic32->wMid;
 461             wic16->wPid = wic32->wPid;
 462             wic16->vDriverVersion = wic32->vDriverVersion;
 463             WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
 464                                  sizeof(wic16->szPname), NULL, NULL );
 465             wic16->dwFormats = wic32->dwFormats;
 466             wic16->wChannels = wic32->wChannels;
 467             HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 468             ret = MMSYSTEM_MAP_OK;
 469         }
 470         break;
 471     case WIDM_GETPOS:
 472         {
 473             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
 474             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
 475
 476             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
 477             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
 478             ret = MMSYSTEM_MAP_OK;
 479         }
 480         break;
 481     case WIDM_ADDBUFFER:
 482     case WIDM_PREPARE:
 483     case WIDM_UNPREPARE:
 484         {
 485             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 486             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
 487
 488             assert(wh16->lpNext == wh32);
 489             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
 490             wh16->dwFlags = wh32->dwFlags;
 491
 492             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 493                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
 494                 wh16->lpNext = 0;
 495             }
 496             ret = MMSYSTEM_MAP_OK;
 497         }
 498         break;
 499     default:
 500         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 501         break;
 502     }
 503     return ret;
 504 }
 505
 506 /**************************************************************************
 507  *                              MMSYSTDRV_WaveIn_MapCB          [internal]
 508  */
 509 static  void    MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
 510 {
 511     switch (uMsg) {
 512     case WIM_OPEN:
 513     case WIM_CLOSE:
 514         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 515         break;
 516     case WIM_DATA:
 517         {
 518             /* initial map is: 16 => 32 */
 519             LPWAVEHDR           wh32 = (LPWAVEHDR)(*dwParam1);
 520             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
 521             LPWAVEHDR           wh16 = MapSL(segwh16);
 522
 523             *dwParam1 = (DWORD)segwh16;
 524             wh16->dwFlags = wh32->dwFlags;
 525             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
 526         }
 527         break;
 528     default:
 529         ERR("Unknown msg %u\n", uMsg);
 530     }
 531 }
 532
 533 /* =================================
 534  *   W A V E  O U T  M A P P E R S
 535  * ================================= */
 536
 537 /**************************************************************************
 538  *                              MMSYSTDRV_WaveOut_Map16To32W    [internal]
 539  */
 540 static  MMSYSTEM_MapType        MMSYSTDRV_WaveOut_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 541 {
 542     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
 543
 544     switch (wMsg) {
 545     /* nothing to do */
 546     case WODM_BREAKLOOP:
 547     case WODM_CLOSE:
 548     case WODM_GETNUMDEVS:
 549     case WODM_PAUSE:
 550     case WODM_RESET:
 551     case WODM_RESTART:
 552     case WODM_SETPITCH:
 553     case WODM_SETPLAYBACKRATE:
 554     case WODM_SETVOLUME:
 555         ret = MMSYSTEM_MAP_OK;
 556         break;
 557
 558     case WODM_GETPITCH:
 559     case WODM_GETPLAYBACKRATE:
 560     case WODM_GETVOLUME:
 561     case WODM_OPEN:
 562         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 563         break;
 564
 565     case WODM_GETDEVCAPS:
 566         {
 567             LPWAVEOUTCAPSW              woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
 568             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
 569
 570             if (woc32) {
 571                 *(LPWAVEOUTCAPS16*)woc32 = woc16;
 572                 woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
 573                 *lpParam1 = (DWORD)woc32;
 574                 *lpParam2 = sizeof(WAVEOUTCAPSW);
 575
 576                 ret = MMSYSTEM_MAP_OKMEM;
 577             } else {
 578                 ret = MMSYSTEM_MAP_NOMEM;
 579             }
 580         }
 581         break;
 582     case WODM_GETPOS:
 583         {
 584             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
 585             LPMMTIME16          mmt16 = MapSL(*lpParam1);
 586
 587             if (mmt32) {
 588                 *(LPMMTIME16*)mmt32 = mmt16;
 589                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
 590
 591                 mmt32->wType = mmt16->wType;
 592                 *lpParam1 = (DWORD)mmt32;
 593                 *lpParam2 = sizeof(MMTIME);
 594
 595                 ret = MMSYSTEM_MAP_OKMEM;
 596             } else {
 597                 ret = MMSYSTEM_MAP_NOMEM;
 598             }
 599         }
 600         break;
 601     case WODM_PREPARE:
 602         {
 603             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
 604             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 605
 606             if (wh32) {
 607                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
 608                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
 609                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
 610                 wh32->dwBufferLength = wh16->dwBufferLength;
 611                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
 612                 wh32->dwUser = wh16->dwUser;
 613                 wh32->dwFlags = wh16->dwFlags;
 614                 wh32->dwLoops = wh16->dwLoops;
 615                 /* FIXME: nothing on wh32->lpNext */
 616                 /* could link the wh32->lpNext at this level for memory house keeping */
 617                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
 618                 *lpParam1 = (DWORD)wh32;
 619                 *lpParam2 = sizeof(WAVEHDR);
 620
 621                 ret = MMSYSTEM_MAP_OKMEM;
 622             } else {
 623                 ret = MMSYSTEM_MAP_NOMEM;
 624             }
 625         }
 626         break;
 627     case WODM_UNPREPARE:
 628     case WODM_WRITE:
 629         {
 630             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 631             LPWAVEHDR           wh32 = wh16->lpNext;
 632
 633             *lpParam1 = (DWORD)wh32;
 634             *lpParam2 = sizeof(WAVEHDR);
 635             /* dwBufferLength can be reduced between prepare & write */
 636             if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
 637                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
 638                     wh32->dwBufferLength, wh16->dwBufferLength);
 639             } else
 640                 wh32->dwBufferLength = wh16->dwBufferLength;
 641             ret = MMSYSTEM_MAP_OKMEM;
 642         }
 643         break;
 644     case WODM_MAPPER_STATUS:
 645         *lpParam2 = (DWORD)MapSL(*lpParam2);
 646         ret = MMSYSTEM_MAP_OK;
 647         break;
 648     default:
 649         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 650         break;
 651     }
 652     return ret;
 653 }
 654
 655 /**************************************************************************
 656  *                              MMSYSTDRV_WaveOut_UnMap16To32W  [internal]
 657  */
 658 static  MMSYSTEM_MapType        MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 659 {
 660     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
 661
 662     switch (wMsg) {
 663     /* nothing to do */
 664     case WODM_BREAKLOOP:
 665     case WODM_CLOSE:
 666     case WODM_GETNUMDEVS:
 667     case WODM_PAUSE:
 668     case WODM_RESET:
 669     case WODM_RESTART:
 670     case WODM_SETPITCH:
 671     case WODM_SETPLAYBACKRATE:
 672     case WODM_SETVOLUME:
 673     case WODM_MAPPER_STATUS:
 674         ret = MMSYSTEM_MAP_OK;
 675         break;
 676
 677     case WODM_GETPITCH:
 678     case WODM_GETPLAYBACKRATE:
 679     case WODM_GETVOLUME:
 680     case WODM_OPEN:
 681         FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
 682         break;
 683
 684     case WODM_GETDEVCAPS:
 685         {
 686             LPWAVEOUTCAPSW              woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
 687             LPWAVEOUTCAPS16             woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
 688
 689             woc16->wMid = woc32->wMid;
 690             woc16->wPid = woc32->wPid;
 691             woc16->vDriverVersion = woc32->vDriverVersion;
 692             WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
 693                                  sizeof(woc16->szPname), NULL, NULL );
 694             woc16->dwFormats = woc32->dwFormats;
 695             woc16->wChannels = woc32->wChannels;
 696             woc16->dwSupport = woc32->dwSupport;
 697             HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
 698             ret = MMSYSTEM_MAP_OK;
 699         }
 700         break;
 701     case WODM_GETPOS:
 702         {
 703             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
 704             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
 705
 706             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
 707             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
 708             ret = MMSYSTEM_MAP_OK;
 709         }
 710         break;
 711     case WODM_PREPARE:
 712     case WODM_UNPREPARE:
 713     case WODM_WRITE:
 714         {
 715             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 716             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
 717
 718             assert(wh16->lpNext == wh32);
 719             wh16->dwFlags = wh32->dwFlags;
 720
 721             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 722                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
 723                 wh16->lpNext = 0;
 724             }
 725             ret = MMSYSTEM_MAP_OK;
 726         }
 727         break;
 728     default:
 729         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 730         break;
 731     }
 732     return ret;
 733 }
 734
 735 /**************************************************************************
 736  *                              MMDRV_WaveOut_Callback          [internal]
 737  */
 738 static  void    MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
 739 {
 740     switch (uMsg) {
 741     case WOM_OPEN:
 742     case WOM_CLOSE:
 743         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 744         break;
 745     case WOM_DONE:
 746         {
 747             /* initial map is: 16 => 32 */
 748             LPWAVEHDR           wh32 = (LPWAVEHDR)(*dwParam1);
 749             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
 750             LPWAVEHDR           wh16 = MapSL(segwh16);
 751
 752             *dwParam1 = (DWORD)segwh16;
 753             wh16->dwFlags = wh32->dwFlags;
 754         }
 755         break;
 756     default:
 757         ERR("Unknown msg %u\n", uMsg);
 758     }
 759 }
 760
 761 /* ###################################################
 762  * #                DRIVER THUNKING                  #
 763  * ###################################################
 764  */
 765 typedef MMSYSTEM_MapType        (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2);
 766 typedef MMSYSTEM_MapType        (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret);
 767 typedef void                    (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2);
 768
 769 #include <pshpack1.h>
 770 #define MMSYSTDRV_MAX_THUNKS      32
 771
 772 static struct mmsystdrv_thunk
 773 {
 774     BYTE                        popl_eax;       /* popl  %eax (return address) */
 775     BYTE                        pushl_this;     /* pushl this (this very thunk) */
 776     struct mmsystdrv_thunk*     this;
 777     BYTE                        pushl_eax;      /* pushl %eax */
 778     BYTE                        jmp;            /* ljmp MMDRV_Callback3216 */
 779     DWORD                       callback3216;
 780     DWORD                       callback;       /* callback value (function, window, event...) */
 781     DWORD                       flags;          /* flags to control callback value (CALLBACK_???) */
 782     void*                       hMmdrv;         /* Handle to 32bit mmdrv object */
 783     enum MMSYSTEM_DriverType    kind;
 784 } *MMSYSTDRV_Thunks;
 785
 786 #include <poppack.h>
 787
 788 static struct MMSYSTDRV_Type
 789 {
 790     MMSYSTDRV_MAPMSG    mapmsg16to32W;
 791     MMSYSTDRV_UNMAPMSG  unmapmsg16to32W;
 792     MMSYSTDRV_MAPCB     mapcb;
 793 } MMSYSTEM_DriversType[MMSYSTDRV_MAX] =
 794 {
 795     {MMSYSTDRV_Mixer_Map16To32W,   MMSYSTDRV_Mixer_UnMap16To32W,   MMSYSTDRV_Mixer_MapCB},
 796     {MMSYSTDRV_MidiIn_Map16To32W,  MMSYSTDRV_MidiIn_UnMap16To32W,  MMSYSTDRV_MidiIn_MapCB},
 797     {MMSYSTDRV_MidiOut_Map16To32W, MMSYSTDRV_MidiOut_UnMap16To32W, MMSYSTDRV_MidiOut_MapCB},
 798     {MMSYSTDRV_WaveIn_Map16To32W,  MMSYSTDRV_WaveIn_UnMap16To32W,  MMSYSTDRV_WaveIn_MapCB},
 799     {MMSYSTDRV_WaveOut_Map16To32W, MMSYSTDRV_WaveOut_UnMap16To32W, MMSYSTDRV_WaveOut_MapCB},
 800 };
 801
 802 /******************************************************************
 803  *              MMSYSTDRV_Callback3216
 804  *
 805  */
 806 static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HDRVR hDev,
 807                                                DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
 808                                                DWORD_PTR dwParam2)
 809 {
 810     WORD args[8];
 811
 812     assert(thunk->kind < MMSYSTDRV_MAX);
 813     assert(MMSYSTEM_DriversType[thunk->kind].mapcb);
 814
 815     MMSYSTEM_DriversType[thunk->kind].mapcb(wMsg, &dwUser, &dwParam1, &dwParam2);
 816
 817     switch (thunk->flags & CALLBACK_TYPEMASK) {
 818     case CALLBACK_NULL:
 819         TRACE("Null !\n");
 820         break;
 821     case CALLBACK_WINDOW:
 822         TRACE("Window(%04X) handle=%p!\n", thunk->callback, hDev);
 823         PostMessageA((HWND)thunk->callback, wMsg, (WPARAM)hDev, dwParam1);
 824         break;
 825     case CALLBACK_TASK: /* aka CALLBACK_THREAD */
 826         TRACE("Task(%04x) !\n", thunk->callback);
 827         PostThreadMessageA(thunk->callback, wMsg, (WPARAM)hDev, dwParam1);
 828         break;
 829     case CALLBACK_FUNCTION:
 830         /* 16 bit func, call it */
 831         TRACE("Function (16 bit) %x!\n", thunk->callback);
 832
 833         args[7] = HDRVR_16(hDev);
 834         args[6] = wMsg;
 835         args[5] = HIWORD(dwUser);
 836         args[4] = LOWORD(dwUser);
 837         args[3] = HIWORD(dwParam1);
 838         args[2] = LOWORD(dwParam1);
 839         args[1] = HIWORD(dwParam2);
 840         args[0] = LOWORD(dwParam2);
 841         return WOWCallback16Ex(thunk->callback, WCB16_PASCAL, sizeof(args), args, NULL);
 842     case CALLBACK_EVENT:
 843         TRACE("Event(%08x) !\n", thunk->callback);
 844         SetEvent((HANDLE)thunk->callback);
 845         break;
 846     default:
 847         WARN("Unknown callback type %x\n", thunk->flags);
 848         return FALSE;
 849     }
 850     TRACE("Done\n");
 851     return TRUE;
 852 }
 853
 854 /******************************************************************
 855  *              MMSYSTDRV_AddThunk
 856  *
 857  */
 858 struct mmsystdrv_thunk*       MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind)
 859 {
 860     struct mmsystdrv_thunk* thunk;
 861
 862     EnterCriticalSection(&mmdrv_cs);
 863     if (!MMSYSTDRV_Thunks)
 864     {
 865         MMSYSTDRV_Thunks = VirtualAlloc(NULL, MMSYSTDRV_MAX_THUNKS * sizeof(*MMSYSTDRV_Thunks),
 866                                         MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 867         if (!MMSYSTDRV_Thunks)
 868         {
 869             LeaveCriticalSection(&mmdrv_cs);
 870             return NULL;
 871         }
 872         for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
 873         {
 874             thunk->popl_eax     = 0x58;   /* popl  %eax */
 875             thunk->pushl_this   = 0x68;   /* pushl this */
 876             thunk->this         = thunk;
 877             thunk->pushl_eax    = 0x50;   /* pushl %eax */
 878             thunk->jmp          = 0xe9;   /* jmp MMDRV_Callback3216 */
 879             thunk->callback3216 = (char *)MMSYSTDRV_Callback3216 - (char *)(&thunk->callback3216 + 1);
 880             thunk->callback     = 0;
 881             thunk->flags        = CALLBACK_NULL;
 882             thunk->hMmdrv       = NULL;
 883             thunk->kind         = MMSYSTDRV_MAX;
 884         }
 885     }
 886     for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
 887     {
 888         if (thunk->callback == 0 && thunk->hMmdrv == NULL)
 889         {
 890             thunk->callback = callback;
 891             thunk->flags = flags;
 892             thunk->hMmdrv = NULL;
 893             thunk->kind = kind;
 894             LeaveCriticalSection(&mmdrv_cs);
 895             return thunk;
 896         }
 897     }
 898     LeaveCriticalSection(&mmdrv_cs);
 899     FIXME("Out of mmdrv-thunks. Bump MMDRV_MAX_THUNKS\n");
 900     return NULL;
 901 }
 902
 903 /******************************************************************
 904  *              MMSYSTDRV_FindHandle
 905  *
 906  * Must be called with lock set
 907  */
 908 static void*    MMSYSTDRV_FindHandle(void* h)
 909 {
 910     struct mmsystdrv_thunk* thunk;
 911
 912     for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
 913     {
 914         if (thunk->hMmdrv == h)
 915         {
 916             if (thunk->kind >= MMSYSTDRV_MAX) FIXME("Kind isn't properly initialized %x\n", thunk->kind);
 917             return thunk;
 918         }
 919     }
 920     return NULL;
 921 }
 922
 923 /******************************************************************
 924  *              MMSYSTDRV_SetHandle
 925  *
 926  */
 927 void    MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h)
 928 {
 929     if (MMSYSTDRV_FindHandle(h)) FIXME("Already has a thunk for this handle %p!!!\n", h);
 930     thunk->hMmdrv = h;
 931 }
 932
 933 /******************************************************************
 934  *              MMSYSTDRV_DeleteThunk
 935  */
 936 void    MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk)
 937 {
 938     thunk->callback = 0;
 939     thunk->flags = CALLBACK_NULL;
 940     thunk->hMmdrv = NULL;
 941     thunk->kind = MMSYSTDRV_MAX;
 942 }
 943
 944 /******************************************************************
 945  *              MMSYSTDRV_CloseHandle
 946  */
 947 void    MMSYSTDRV_CloseHandle(void* h)
 948 {
 949     struct mmsystdrv_thunk* thunk;
 950
 951     EnterCriticalSection(&mmdrv_cs);
 952     if ((thunk = MMSYSTDRV_FindHandle(h)))
 953     {
 954         MMSYSTDRV_DeleteThunk(thunk);
 955     }
 956     LeaveCriticalSection(&mmdrv_cs);
 957 }
 958
 959 /******************************************************************
 960  *              MMSYSTDRV_Message
 961  */
 962 DWORD   MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2)
 963 {
 964     struct mmsystdrv_thunk*     thunk = MMSYSTDRV_FindHandle(h);
 965     struct MMSYSTDRV_Type*      drvtype;
 966     MMSYSTEM_MapType            map;
 967     DWORD                       ret;
 968
 969     if (!thunk) return MMSYSERR_INVALHANDLE;
 970     drvtype = &MMSYSTEM_DriversType[thunk->kind];
 971
 972     map = drvtype->mapmsg16to32W(msg, &param1, &param2);
 973     switch (map) {
 974     case MMSYSTEM_MAP_NOMEM:
 975         ret = MMSYSERR_NOMEM;
 976         break;
 977     case MMSYSTEM_MAP_MSGERROR:
 978         FIXME("NIY: no conversion yet 16->32 kind=%u msg=%u\n", thunk->kind, msg);
 979         ret = MMSYSERR_ERROR;
 980         break;
 981     case MMSYSTEM_MAP_OK:
 982     case MMSYSTEM_MAP_OKMEM:
 983         TRACE("Calling message(msg=%u p1=0x%08lx p2=0x%08lx)\n",
 984               msg, param1, param2);
 985         switch (thunk->kind)
 986         {
 987         case MMSYSTDRV_MIXER:   ret = mixerMessage  (h, msg, param1, param2); break;
 988         case MMSYSTDRV_MIDIIN:
 989             switch (msg)
 990             {
 991             case MIDM_ADDBUFFER: ret = midiInAddBuffer(h, (LPMIDIHDR)param1, param2); break;
 992             case MIDM_PREPARE:   ret = midiInPrepareHeader(h, (LPMIDIHDR)param1, param2); break;
 993             case MIDM_UNPREPARE: ret = midiInUnprepareHeader(h, (LPMIDIHDR)param1, param2); break;
 994             default:             ret = midiInMessage(h, msg, param1, param2); break;
 995             }
 996             break;
 997         case MMSYSTDRV_MIDIOUT:
 998             switch (msg)
 999             {
1000             case MODM_PREPARE:   ret = midiOutPrepareHeader(h, (LPMIDIHDR)param1, param2); break;
1001             case MODM_UNPREPARE: ret = midiOutUnprepareHeader(h, (LPMIDIHDR)param1, param2); break;
1002             case MODM_LONGDATA:  ret = midiOutLongMsg(h, (LPMIDIHDR)param1, param2); break;
1003             default:             ret = midiOutMessage(h, msg, param1, param2); break;
1004             }
1005             break;
1006         case MMSYSTDRV_WAVEIN:
1007             switch (msg)
1008             {
1009             case WIDM_ADDBUFFER: ret = waveInAddBuffer(h, (LPWAVEHDR)param1, param2); break;
1010             case WIDM_PREPARE:   ret = waveInPrepareHeader(h, (LPWAVEHDR)param1, param2); break;
1011             case WIDM_UNPREPARE: ret = waveInUnprepareHeader(h, (LPWAVEHDR)param1, param2); break;
1012             default:             ret = waveInMessage(h, msg, param1, param2); break;
1013             }
1014             break;
1015         case MMSYSTDRV_WAVEOUT:
1016             switch (msg)
1017             {
1018             case WODM_PREPARE:   ret = waveOutPrepareHeader(h, (LPWAVEHDR)param1, param2); break;
1019             case WODM_UNPREPARE: ret = waveOutUnprepareHeader(h, (LPWAVEHDR)param1, param2); break;
1020             case WODM_WRITE:     ret = waveOutWrite(h, (LPWAVEHDR)param1, param2); break;
1021             default:             ret = waveOutMessage(h, msg, param1, param2); break;
1022             }
1023             break;
1024         default: ret = MMSYSERR_INVALHANDLE; break; /* should never be reached */
1025         }
1026         if (map == MMSYSTEM_MAP_OKMEM)
1027             drvtype->unmapmsg16to32W(msg, &param1, &param2, ret);
1028         break;
1029     default:
1030         FIXME("NIY\n");
1031         ret = MMSYSERR_NOTSUPPORTED;
1032         break;
1033     }
1034     return ret;
1035 }