git.oblomov.eu Git - wine/blob - dlls/winmm/message16.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * MMSYTEM MCI and low level mapping functions
   5  *
   6  * Copyright 1999 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <string.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <assert.h>
  27 #include "wine/winbase16.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winreg.h"
  31 #include "winver.h"
  32 #include "wownt32.h"
  33 #include "winemm16.h"
  34 #include "digitalv.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  38
  39 /**************************************************************************
  40  *                              MMDRV_Callback                  [internal]
  41  */
  42 static  void    MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
  43 {
  44     TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
  45           mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
  46
  47     if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION)
  48     {
  49         WORD args[8];
  50         /* 16 bit func, call it */
  51         TRACE("Function (16 bit) !\n");
  52
  53         args[7] = HDRVR_16(hDev);
  54         args[6] = uMsg;
  55         args[5] = HIWORD(mld->dwClientInstance);
  56         args[4] = LOWORD(mld->dwClientInstance);
  57         args[3] = HIWORD(dwParam1);
  58         args[2] = LOWORD(dwParam1);
  59         args[1] = HIWORD(dwParam2);
  60         args[0] = LOWORD(dwParam2);
  61         WOWCallback16Ex( mld->dwCallback, WCB16_PASCAL, sizeof(args), args, NULL );
  62     } else {
  63         DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg,
  64                        mld->dwClientInstance, dwParam1, dwParam2);
  65     }
  66 }
  67
  68 /* =================================
  69  *       A U X    M A P P E R S
  70  * ================================= */
  71
  72 /**************************************************************************
  73  *                              MMDRV_Aux_Map16To32A            [internal]
  74  */
  75 static  WINMM_MapType   MMDRV_Aux_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
  76 {
  77     return WINMM_MAP_MSGERROR;
  78 }
  79
  80 /**************************************************************************
  81  *                              MMDRV_Aux_UnMap16To32A          [internal]
  82  */
  83 static  WINMM_MapType   MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
  84 {
  85     return WINMM_MAP_MSGERROR;
  86 }
  87
  88 /**************************************************************************
  89  *                              MMDRV_Aux_Map32ATo16            [internal]
  90  */
  91 static  WINMM_MapType   MMDRV_Aux_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
  92 {
  93     return WINMM_MAP_MSGERROR;
  94 }
  95
  96 /**************************************************************************
  97  *                              MMDRV_Aux_UnMap32ATo16          [internal]
  98  */
  99 static  WINMM_MapType   MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 100 {
 101 #if 0
 102  case AUXDM_GETDEVCAPS:
 103     lpCaps->wMid = ac16.wMid;
 104     lpCaps->wPid = ac16.wPid;
 105     lpCaps->vDriverVersion = ac16.vDriverVersion;
 106     strcpy(lpCaps->szPname, ac16.szPname);
 107     lpCaps->wTechnology = ac16.wTechnology;
 108     lpCaps->dwSupport = ac16.dwSupport;
 109 #endif
 110     return WINMM_MAP_MSGERROR;
 111 }
 112
 113 /**************************************************************************
 114  *                              MMDRV_Aux_Callback              [internal]
 115  */
 116 static  void    CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
 117 {
 118     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 119
 120     FIXME("NIY\n");
 121     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 122 }
 123
 124 /* =================================
 125  *     M I X E R  M A P P E R S
 126  * ================================= */
 127
 128 /**************************************************************************
 129  *                              xMMDRV_Mixer_Map16To32A         [internal]
 130  */
 131 static  WINMM_MapType   MMDRV_Mixer_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 132 {
 133     return WINMM_MAP_MSGERROR;
 134 }
 135
 136 /**************************************************************************
 137  *                              MMDRV_Mixer_UnMap16To32A        [internal]
 138  */
 139 static  WINMM_MapType   MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 140 {
 141 #if 0
 142     MIXERCAPSA  micA;
 143     UINT        ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
 144
 145     if (ret == MMSYSERR_NOERROR) {
 146         mixcaps->wMid           = micA.wMid;
 147         mixcaps->wPid           = micA.wPid;
 148         mixcaps->vDriverVersion = micA.vDriverVersion;
 149         strcpy(mixcaps->szPname, micA.szPname);
 150         mixcaps->fdwSupport     = micA.fdwSupport;
 151         mixcaps->cDestinations  = micA.cDestinations;
 152     }
 153     return ret;
 154 #endif
 155     return WINMM_MAP_MSGERROR;
 156 }
 157
 158 /**************************************************************************
 159  *                              MMDRV_Mixer_Map32ATo16          [internal]
 160  */
 161 static  WINMM_MapType   MMDRV_Mixer_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 162 {
 163     return WINMM_MAP_MSGERROR;
 164 }
 165
 166 /**************************************************************************
 167  *                              MMDRV_Mixer_UnMap32ATo16        [internal]
 168  */
 169 static  WINMM_MapType   MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 170 {
 171     return WINMM_MAP_MSGERROR;
 172 }
 173
 174 /**************************************************************************
 175  *                              MMDRV_Mixer_Callback            [internal]
 176  */
 177 static  void    CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
 178 {
 179     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 180
 181     FIXME("NIY\n");
 182     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 183 }
 184
 185 /* =================================
 186  *   M I D I  I N    M A P P E R S
 187  * ================================= */
 188
 189 /**************************************************************************
 190  *                              MMDRV_MidiIn_Map16To32A         [internal]
 191  */
 192 static  WINMM_MapType   MMDRV_MidiIn_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 193 {
 194     return WINMM_MAP_MSGERROR;
 195 }
 196
 197 /**************************************************************************
 198  *                              MMDRV_MidiIn_UnMap16To32A       [internal]
 199  */
 200 static  WINMM_MapType   MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 201 {
 202     return WINMM_MAP_MSGERROR;
 203 }
 204
 205 /**************************************************************************
 206  *                              MMDRV_MidiIn_Map32ATo16         [internal]
 207  */
 208 static  WINMM_MapType   MMDRV_MidiIn_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 209 {
 210     return WINMM_MAP_MSGERROR;
 211 }
 212
 213 /**************************************************************************
 214  *                              MMDRV_MidiIn_UnMap32ATo16       [internal]
 215  */
 216 static  WINMM_MapType   MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 217 {
 218     return WINMM_MAP_MSGERROR;
 219 }
 220
 221 /**************************************************************************
 222  *                              MMDRV_MidiIn_Callback           [internal]
 223  */
 224 static  void    CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
 225 {
 226     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 227
 228     switch (uMsg) {
 229     case MIM_OPEN:
 230     case MIM_CLOSE:
 231         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 232
 233     case MIM_DATA:
 234     case MIM_MOREDATA:
 235     case MIM_ERROR:
 236         /* dwParam1 & dwParam2 are are data, nothing to do */
 237         break;
 238     case MIM_LONGDATA:
 239     case MIM_LONGERROR:
 240         /* dwParam1 points to a MidiHdr, work to be done !!! */
 241         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
 242             /* initial map is: 32 => 16 */
 243             LPMIDIHDR           mh16 = MapSL(dwParam1);
 244             LPMIDIHDR           mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
 245
 246             dwParam1 = (DWORD)mh32;
 247             mh32->dwFlags = mh16->dwFlags;
 248             mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 249             if (mh32->reserved >= sizeof(MIDIHDR))
 250                 mh32->dwOffset = mh16->dwOffset;
 251         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
 252             /* initial map is: 16 => 32 */
 253             LPMIDIHDR           mh32 = (LPMIDIHDR)(dwParam1);
 254             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 255             LPMIDIHDR           mh16 = MapSL(segmh16);
 256
 257             dwParam1 = (DWORD)segmh16;
 258             mh16->dwFlags = mh32->dwFlags;
 259             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 260             if (mh16->reserved >= sizeof(MIDIHDR))
 261                 mh16->dwOffset = mh32->dwOffset;
 262         }
 263         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
 264         break;
 265     /* case MOM_POSITIONCB: */
 266     default:
 267         ERR("Unknown msg %u\n", uMsg);
 268     }
 269
 270     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 271 }
 272
 273 /* =================================
 274  *   M I D I  O U T  M A P P E R S
 275  * ================================= */
 276
 277 /**************************************************************************
 278  *                              MMDRV_MidiOut_Map16To32A        [internal]
 279  */
 280 static  WINMM_MapType   MMDRV_MidiOut_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 281 {
 282     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 283
 284     switch (wMsg) {
 285     case MODM_GETNUMDEVS:
 286     case MODM_DATA:
 287     case MODM_RESET:
 288     case MODM_SETVOLUME:
 289         ret = WINMM_MAP_OK;
 290         break;
 291
 292     case MODM_OPEN:
 293     case MODM_CLOSE:
 294     case MODM_GETVOLUME:
 295         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 296         break;
 297
 298     case MODM_GETDEVCAPS:
 299         {
 300             LPMIDIOUTCAPSA      moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSA));
 301             LPMIDIOUTCAPS16     moc16 = MapSL(*lpParam1);
 302
 303             if (moc32) {
 304                 *(LPMIDIOUTCAPS16*)moc32 = moc16;
 305                 moc32 = (LPMIDIOUTCAPSA)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
 306                 *lpParam1 = (DWORD)moc32;
 307                 *lpParam2 = sizeof(MIDIOUTCAPSA);
 308
 309                 ret = WINMM_MAP_OKMEM;
 310             } else {
 311                 ret = WINMM_MAP_NOMEM;
 312             }
 313         }
 314         break;
 315     case MODM_PREPARE:
 316         {
 317             LPMIDIHDR           mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
 318             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 319
 320             if (mh32) {
 321                 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
 322                 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
 323                 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
 324                 mh32->dwBufferLength = mh16->dwBufferLength;
 325                 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 326                 mh32->dwUser = mh16->dwUser;
 327                 mh32->dwFlags = mh16->dwFlags;
 328                 /* FIXME: nothing on mh32->lpNext */
 329                 /* could link the mh32->lpNext at this level for memory house keeping */
 330                 mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0;
 331                 mh16->lpNext = mh32; /* for reuse in unprepare and write */
 332                 /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
 333                 mh16->reserved = *lpParam2;
 334                 *lpParam1 = (DWORD)mh32;
 335                 *lpParam2 = sizeof(MIDIHDR);
 336
 337                 ret = WINMM_MAP_OKMEM;
 338             } else {
 339                 ret = WINMM_MAP_NOMEM;
 340             }
 341         }
 342         break;
 343     case MODM_UNPREPARE:
 344     case MODM_LONGDATA:
 345         {
 346             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 347             LPMIDIHDR           mh32 = (LPMIDIHDR)mh16->lpNext;
 348
 349             *lpParam1 = (DWORD)mh32;
 350             *lpParam2 = sizeof(MIDIHDR);
 351             /* dwBufferLength can be reduced between prepare & write */
 352             if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
 353                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
 354                     mh32->dwBufferLength, mh16->dwBufferLength);
 355             } else
 356                 mh32->dwBufferLength = mh16->dwBufferLength;
 357             ret = WINMM_MAP_OKMEM;
 358         }
 359         break;
 360
 361     case MODM_CACHEPATCHES:
 362     case MODM_CACHEDRUMPATCHES:
 363     default:
 364         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 365         break;
 366     }
 367     return ret;
 368 }
 369
 370 /**************************************************************************
 371  *                              MMDRV_MidiOut_UnMap16To32A      [internal]
 372  */
 373 static  WINMM_MapType   MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 374 {
 375     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 376
 377     switch (wMsg) {
 378     case MODM_GETNUMDEVS:
 379     case MODM_DATA:
 380     case MODM_RESET:
 381     case MODM_SETVOLUME:
 382         ret = WINMM_MAP_OK;
 383         break;
 384
 385     case MODM_OPEN:
 386     case MODM_CLOSE:
 387     case MODM_GETVOLUME:
 388         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 389         break;
 390
 391     case MODM_GETDEVCAPS:
 392         {
 393             LPMIDIOUTCAPSA              moc32 = (LPMIDIOUTCAPSA)(*lpParam1);
 394             LPMIDIOUTCAPS16             moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
 395
 396             moc16->wMid                 = moc32->wMid;
 397             moc16->wPid                 = moc32->wPid;
 398             moc16->vDriverVersion       = moc32->vDriverVersion;
 399             strcpy(moc16->szPname, moc32->szPname);
 400             moc16->wTechnology          = moc32->wTechnology;
 401             moc16->wVoices              = moc32->wVoices;
 402             moc16->wNotes               = moc32->wNotes;
 403             moc16->wChannelMask         = moc32->wChannelMask;
 404             moc16->dwSupport            = moc32->dwSupport;
 405             HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
 406             ret = WINMM_MAP_OK;
 407         }
 408         break;
 409     case MODM_PREPARE:
 410     case MODM_UNPREPARE:
 411     case MODM_LONGDATA:
 412         {
 413             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
 414             LPMIDIHDR           mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
 415
 416             assert(mh16->lpNext == mh32);
 417             mh16->dwBufferLength = mh32->dwBufferLength;
 418             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 419             mh16->dwUser = mh32->dwUser;
 420             mh16->dwFlags = mh32->dwFlags;
 421             if (mh16->reserved >= sizeof(MIDIHDR))
 422                 mh16->dwOffset = mh32->dwOffset;
 423
 424             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 425                 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
 426                 mh16->lpNext = 0;
 427             }
 428             ret = WINMM_MAP_OK;
 429         }
 430         break;
 431
 432     case MODM_CACHEPATCHES:
 433     case MODM_CACHEDRUMPATCHES:
 434     default:
 435         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 436         break;
 437     }
 438     return ret;
 439 }
 440
 441 /**************************************************************************
 442  *                              MMDRV_MidiOut_Map32ATo16        [internal]
 443  */
 444 static  WINMM_MapType   MMDRV_MidiOut_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 445 {
 446     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 447
 448     switch (wMsg) {
 449     case MODM_CLOSE:
 450     case MODM_GETNUMDEVS:
 451     case MODM_DATA:
 452     case MODM_RESET:
 453     case MODM_SETVOLUME:
 454         ret = WINMM_MAP_OK;
 455         break;
 456     case MODM_GETDEVCAPS:
 457         {
 458             LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)*lpParam1;
 459             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSA)+sizeof(MIDIOUTCAPS16));
 460
 461             if (ptr) {
 462                 *(LPMIDIOUTCAPSA*)ptr = moc32;
 463                 ret = WINMM_MAP_OKMEM;
 464             } else {
 465                 ret = WINMM_MAP_NOMEM;
 466             }
 467             *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSA);
 468             *lpParam2 = sizeof(MIDIOUTCAPS16);
 469         }
 470         break;
 471     case MODM_PREPARE:
 472         {
 473             LPMIDIHDR           mh32 = (LPMIDIHDR)*lpParam1;
 474             LPMIDIHDR           mh16;
 475             LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
 476                                     sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength);
 477
 478             if (ptr) {
 479                 *(LPMIDIHDR*)ptr = mh32;
 480                 mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR));
 481                 *lpParam1 = MapLS(mh16);
 482                 mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR);
 483                 /* data will be copied on WODM_WRITE */
 484                 mh16->dwBufferLength = mh32->dwBufferLength;
 485                 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 486                 mh16->dwUser = mh32->dwUser;
 487                 mh16->dwFlags = mh32->dwFlags;
 488                 /* FIXME: nothing on mh32->lpNext */
 489                 /* could link the mh32->lpNext at this level for memory house keeping */
 490                 mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0;
 491
 492                 mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */
 493                 mh32->reserved = *lpParam2;
 494
 495                 TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n",
 496                       *lpParam1, (DWORD)mh16->lpData,
 497                       mh32->dwBufferLength, (DWORD)mh32->lpData);
 498                 *lpParam2 = sizeof(MIDIHDR);
 499
 500                 ret = WINMM_MAP_OKMEM;
 501             } else {
 502                 ret = WINMM_MAP_NOMEM;
 503             }
 504         }
 505         break;
 506     case MODM_UNPREPARE:
 507     case MODM_LONGDATA:
 508         {
 509             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
 510             LPMIDIHDR           mh16 = (LPMIDIHDR)mh32->lpNext;
 511             LPSTR               ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
 512
 513             assert(*(LPMIDIHDR*)ptr == mh32);
 514
 515             if (wMsg == MODM_LONGDATA)
 516                 memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
 517
 518             *lpParam1 = MapLS(mh16);
 519             *lpParam2 = sizeof(MIDIHDR);
 520             TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n",
 521                   *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData);
 522
 523             /* dwBufferLength can be reduced between prepare & write */
 524             if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
 525                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
 526                     mh16->dwBufferLength, mh32->dwBufferLength);
 527             } else
 528                 mh16->dwBufferLength = mh32->dwBufferLength;
 529             ret = WINMM_MAP_OKMEM;
 530         }
 531         break;
 532     case MODM_OPEN:
 533         {
 534             LPMIDIOPENDESC              mod32 = (LPMIDIOPENDESC)*lpParam1;
 535             LPVOID                      ptr;
 536             LPMIDIOPENDESC16            mod16;
 537
 538             /* allocated data are mapped as follows:
 539                LPMIDIOPENDESC   ptr to orig lParam1
 540                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
 541                DWORD            dwUser passed to driver
 542                MIDIOPENDESC16   mod16: openDesc passed to driver
 543                MIDIOPENSTRMID   cIds
 544             */
 545             ptr = HeapAlloc( GetProcessHeap(), 0,
 546                              sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
 547                              mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
 548
 549             if (ptr) {
 550                 SEGPTR segptr = MapLS(ptr);
 551                 *(LPMIDIOPENDESC*)ptr = mod32;
 552                 *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
 553                 mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
 554
 555                 mod16->hMidi = HMIDI_16(mod32->hMidi);
 556                 mod16->dwCallback = mod32->dwCallback;
 557                 mod16->dwInstance = mod32->dwInstance;
 558                 mod16->dnDevNode = mod32->dnDevNode;
 559                 mod16->cIds = mod32->cIds;
 560                 memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
 561
 562                 *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
 563                 *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
 564
 565                 ret = WINMM_MAP_OKMEM;
 566             } else {
 567                 ret = WINMM_MAP_NOMEM;
 568             }
 569         }
 570         break;
 571     case MODM_GETVOLUME:
 572     case MODM_CACHEPATCHES:
 573     case MODM_CACHEDRUMPATCHES:
 574     default:
 575         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 576         break;
 577     }
 578     return ret;
 579 }
 580
 581 /**************************************************************************
 582  *                              MMDRV_MidiOut_UnMap32ATo16      [internal]
 583  */
 584 static  WINMM_MapType   MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 585 {
 586     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 587
 588     switch (wMsg) {
 589     case MODM_CLOSE:
 590     case MODM_GETNUMDEVS:
 591     case MODM_DATA:
 592     case MODM_RESET:
 593     case MODM_SETVOLUME:
 594         ret = WINMM_MAP_OK;
 595         break;
 596     case MODM_GETDEVCAPS:
 597         {
 598             LPMIDIOUTCAPS16             moc16 = MapSL(*lpParam1);
 599             LPSTR                       ptr   = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSA);
 600             LPMIDIOUTCAPSA              moc32 = *(LPMIDIOUTCAPSA*)ptr;
 601
 602             moc32->wMid                 = moc16->wMid;
 603             moc32->wPid                 = moc16->wPid;
 604             moc32->vDriverVersion       = moc16->vDriverVersion;
 605             strcpy(moc32->szPname, moc16->szPname);
 606             moc32->wTechnology          = moc16->wTechnology;
 607             moc32->wVoices              = moc16->wVoices;
 608             moc32->wNotes               = moc16->wNotes;
 609             moc32->wChannelMask         = moc16->wChannelMask;
 610             moc32->dwSupport            = moc16->dwSupport;
 611             UnMapLS( *lpParam1 );
 612             HeapFree( GetProcessHeap(), 0, ptr );
 613             ret = WINMM_MAP_OK;
 614         }
 615         break;
 616     case MODM_PREPARE:
 617     case MODM_UNPREPARE:
 618     case MODM_LONGDATA:
 619         {
 620             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 621             LPSTR               ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
 622             LPMIDIHDR           mh32 = *(LPMIDIHDR*)ptr;
 623
 624             assert(mh32->lpNext == (LPMIDIHDR)mh16);
 625             UnMapLS( *lpParam1 );
 626             mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 627             mh32->dwUser = mh16->dwUser;
 628             mh32->dwFlags = mh16->dwFlags;
 629
 630             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 631                 HeapFree( GetProcessHeap(), 0, ptr );
 632                 mh32->lpNext = 0;
 633             }
 634             ret = WINMM_MAP_OK;
 635         }
 636         break;
 637     case MODM_OPEN:
 638         {
 639             LPMIDIOPENDESC16            mod16 = MapSL(*lpParam1);
 640             LPSTR                       ptr   = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
 641             UnMapLS( *lpParam1 );
 642             **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
 643
 644             HeapFree( GetProcessHeap(), 0, ptr );
 645             ret = WINMM_MAP_OK;
 646         }
 647         break;
 648     case MODM_GETVOLUME:
 649     case MODM_CACHEPATCHES:
 650     case MODM_CACHEDRUMPATCHES:
 651     default:
 652         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 653         break;
 654     }
 655     return ret;
 656 }
 657
 658 /**************************************************************************
 659  *                              MMDRV_MidiOut_Callback          [internal]
 660  */
 661 static  void    CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
 662 {
 663     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 664
 665     switch (uMsg) {
 666     case MOM_OPEN:
 667     case MOM_CLOSE:
 668         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 669         break;
 670     case MOM_DONE:
 671         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
 672             /* initial map is: 32 => 16 */
 673             LPMIDIHDR           mh16 = MapSL(dwParam1);
 674             LPMIDIHDR           mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
 675
 676             dwParam1 = (DWORD)mh32;
 677             mh32->dwFlags = mh16->dwFlags;
 678             mh32->dwOffset = mh16->dwOffset;
 679             if (mh32->reserved >= sizeof(MIDIHDR))
 680                 mh32->dwOffset = mh16->dwOffset;
 681         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
 682             /* initial map is: 16 => 32 */
 683             LPMIDIHDR           mh32 = (LPMIDIHDR)(dwParam1);
 684             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 685             LPMIDIHDR           mh16 = MapSL(segmh16);
 686
 687             dwParam1 = (DWORD)segmh16;
 688             mh16->dwFlags = mh32->dwFlags;
 689             if (mh16->reserved >= sizeof(MIDIHDR))
 690                 mh16->dwOffset = mh32->dwOffset;
 691         }
 692         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
 693         break;
 694     /* case MOM_POSITIONCB: */
 695     default:
 696         ERR("Unknown msg %u\n", uMsg);
 697     }
 698
 699     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 700 }
 701
 702 /* =================================
 703  *   W A V E  I N    M A P P E R S
 704  * ================================= */
 705
 706 /**************************************************************************
 707  *                              MMDRV_WaveIn_Map16To32A         [internal]
 708  */
 709 static  WINMM_MapType   MMDRV_WaveIn_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 710 {
 711     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 712
 713     switch (wMsg) {
 714     case WIDM_GETNUMDEVS:
 715     case WIDM_RESET:
 716     case WIDM_START:
 717     case WIDM_STOP:
 718         ret = WINMM_MAP_OK;
 719         break;
 720     case WIDM_OPEN:
 721     case WIDM_CLOSE:
 722         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 723         break;
 724     case WIDM_GETDEVCAPS:
 725         {
 726             LPWAVEINCAPSA       wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSA));
 727             LPWAVEINCAPS16      wic16 = MapSL(*lpParam1);
 728
 729             if (wic32) {
 730                 *(LPWAVEINCAPS16*)wic32 = wic16;
 731                 wic32 = (LPWAVEINCAPSA)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
 732                 *lpParam1 = (DWORD)wic32;
 733                 *lpParam2 = sizeof(WAVEINCAPSA);
 734
 735                 ret = WINMM_MAP_OKMEM;
 736             } else {
 737                 ret = WINMM_MAP_NOMEM;
 738             }
 739         }
 740         break;
 741     case WIDM_GETPOS:
 742         {
 743             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
 744             LPMMTIME16          mmt16 = MapSL(*lpParam1);
 745
 746             if (mmt32) {
 747                 *(LPMMTIME16*)mmt32 = mmt16;
 748                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
 749
 750                 mmt32->wType = mmt16->wType;
 751                 *lpParam1 = (DWORD)mmt32;
 752                 *lpParam2 = sizeof(MMTIME);
 753
 754                 ret = WINMM_MAP_OKMEM;
 755             } else {
 756                 ret = WINMM_MAP_NOMEM;
 757             }
 758         }
 759         break;
 760     case WIDM_PREPARE:
 761         {
 762             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
 763             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 764
 765             if (wh32) {
 766                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
 767                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
 768                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
 769                 wh32->dwBufferLength = wh16->dwBufferLength;
 770                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
 771                 wh32->dwUser = wh16->dwUser;
 772                 wh32->dwFlags = wh16->dwFlags;
 773                 wh32->dwLoops = wh16->dwLoops;
 774                 /* FIXME: nothing on wh32->lpNext */
 775                 /* could link the wh32->lpNext at this level for memory house keeping */
 776                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
 777                 *lpParam1 = (DWORD)wh32;
 778                 *lpParam2 = sizeof(WAVEHDR);
 779
 780                 ret = WINMM_MAP_OKMEM;
 781             } else {
 782                 ret = WINMM_MAP_NOMEM;
 783             }
 784         }
 785         break;
 786     case WIDM_ADDBUFFER:
 787     case WIDM_UNPREPARE:
 788         {
 789             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 790             LPWAVEHDR           wh32 = (LPWAVEHDR)wh16->lpNext;
 791
 792             *lpParam1 = (DWORD)wh32;
 793             *lpParam2 = sizeof(WAVEHDR);
 794             /* dwBufferLength can be reduced between prepare & write */
 795             if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
 796                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
 797                     wh32->dwBufferLength, wh16->dwBufferLength);
 798             } else
 799                 wh32->dwBufferLength = wh16->dwBufferLength;
 800             ret = WINMM_MAP_OKMEM;
 801         }
 802         break;
 803     case WIDM_MAPPER_STATUS:
 804         /* just a single DWORD */
 805         *lpParam2 = (DWORD)MapSL(*lpParam2);
 806         ret = WINMM_MAP_OK;
 807         break;
 808     default:
 809         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 810         break;
 811     }
 812     return ret;
 813 }
 814
 815 /**************************************************************************
 816  *                              MMDRV_WaveIn_UnMap16To32A       [internal]
 817  */
 818 static  WINMM_MapType   MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 819 {
 820     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 821
 822     switch (wMsg) {
 823     case WIDM_GETNUMDEVS:
 824     case WIDM_RESET:
 825     case WIDM_START:
 826     case WIDM_STOP:
 827     case WIDM_MAPPER_STATUS:
 828         ret = WINMM_MAP_OK;
 829         break;
 830     case WIDM_OPEN:
 831     case WIDM_CLOSE:
 832         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 833         break;
 834     case WIDM_GETDEVCAPS:
 835         {
 836             LPWAVEINCAPSA               wic32 = (LPWAVEINCAPSA)(*lpParam1);
 837             LPWAVEINCAPS16              wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 838
 839             wic16->wMid = wic32->wMid;
 840             wic16->wPid = wic32->wPid;
 841             wic16->vDriverVersion = wic32->vDriverVersion;
 842             strcpy(wic16->szPname, wic32->szPname);
 843             wic16->dwFormats = wic32->dwFormats;
 844             wic16->wChannels = wic32->wChannels;
 845             HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 846             ret = WINMM_MAP_OK;
 847         }
 848         break;
 849     case WIDM_GETPOS:
 850         {
 851             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
 852             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
 853
 854             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
 855             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
 856             ret = WINMM_MAP_OK;
 857         }
 858         break;
 859     case WIDM_ADDBUFFER:
 860     case WIDM_PREPARE:
 861     case WIDM_UNPREPARE:
 862         {
 863             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 864             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
 865
 866             assert(wh16->lpNext == wh32);
 867             wh16->dwBufferLength = wh32->dwBufferLength;
 868             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
 869             wh16->dwUser = wh32->dwUser;
 870             wh16->dwFlags = wh32->dwFlags;
 871             wh16->dwLoops = wh32->dwLoops;
 872
 873             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 874                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
 875                 wh16->lpNext = 0;
 876             }
 877             ret = WINMM_MAP_OK;
 878         }
 879         break;
 880     default:
 881         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 882         break;
 883     }
 884     return ret;
 885 }
 886
 887 /**************************************************************************
 888  *                              MMDRV_WaveIn_Map32ATo16         [internal]
 889  */
 890 static  WINMM_MapType   MMDRV_WaveIn_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 891 {
 892     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 893
 894     switch (wMsg) {
 895     case WIDM_CLOSE:
 896     case WIDM_GETNUMDEVS:
 897     case WIDM_RESET:
 898     case WIDM_START:
 899     case WIDM_STOP:
 900         ret = WINMM_MAP_OK;
 901         break;
 902
 903     case WIDM_OPEN:
 904         {
 905             LPWAVEOPENDESC              wod32 = (LPWAVEOPENDESC)*lpParam1;
 906             int                         sz = sizeof(WAVEFORMATEX);
 907             LPVOID                      ptr;
 908             LPWAVEOPENDESC16            wod16;
 909
 910             /* allocated data are mapped as follows:
 911                LPWAVEOPENDESC   ptr to orig lParam1
 912                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
 913                DWORD            dwUser passed to driver
 914                WAVEOPENDESC16   wod16: openDesc passed to driver
 915                WAVEFORMATEX     openDesc->lpFormat passed to driver
 916                xxx              extra bytes to WAVEFORMATEX
 917             */
 918             if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
 919                 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
 920                 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
 921             }
 922
 923             ptr = HeapAlloc( GetProcessHeap(), 0,
 924                              sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
 925
 926             if (ptr) {
 927                 SEGPTR seg_ptr = MapLS( ptr );
 928                 *(LPWAVEOPENDESC*)ptr = wod32;
 929                 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
 930                 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
 931
 932                 wod16->hWave = HWAVE_16(wod32->hWave);
 933                 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
 934                 memcpy(wod16 + 1, wod32->lpFormat, sz);
 935
 936                 wod16->dwCallback = wod32->dwCallback;
 937                 wod16->dwInstance = wod32->dwInstance;
 938                 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
 939                 wod16->dnDevNode = wod32->dnDevNode;
 940
 941                 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
 942                 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
 943
 944                 ret = WINMM_MAP_OKMEM;
 945             } else {
 946                 ret = WINMM_MAP_NOMEM;
 947             }
 948         }
 949         break;
 950     case WIDM_PREPARE:
 951         {
 952             LPWAVEHDR           wh32 = (LPWAVEHDR)*lpParam1;
 953             LPWAVEHDR           wh16;
 954             LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
 955                                     sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
 956
 957             if (ptr) {
 958                 SEGPTR seg_ptr = MapLS( ptr );
 959                 *(LPWAVEHDR*)ptr = wh32;
 960                 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
 961                 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
 962                 /* data will be copied on WODM_WRITE */
 963                 wh16->dwBufferLength = wh32->dwBufferLength;
 964                 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
 965                 wh16->dwUser = wh32->dwUser;
 966                 wh16->dwFlags = wh32->dwFlags;
 967                 wh16->dwLoops = wh32->dwLoops;
 968                 /* FIXME: nothing on wh32->lpNext */
 969                 /* could link the wh32->lpNext at this level for memory house keeping */
 970                 wh32->lpNext = wh16; /* for reuse in unprepare and write */
 971                 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
 972                       seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
 973                       wh32->dwBufferLength, (DWORD)wh32->lpData);
 974                 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
 975                 *lpParam2 = sizeof(WAVEHDR);
 976
 977                 ret = WINMM_MAP_OKMEM;
 978             } else {
 979                 ret = WINMM_MAP_NOMEM;
 980             }
 981         }
 982         break;
 983     case WIDM_ADDBUFFER:
 984     case WIDM_UNPREPARE:
 985         {
 986             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 987             LPWAVEHDR           wh16 = wh32->lpNext;
 988             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
 989             SEGPTR seg_ptr = MapLS( ptr );
 990
 991             assert(*(LPWAVEHDR*)ptr == wh32);
 992
 993             TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
 994                   seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
 995                   wh32->dwBufferLength, (DWORD)wh32->lpData);
 996
 997             if (wMsg == WIDM_ADDBUFFER)
 998                 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
 999
1000             *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1001             *lpParam2 = sizeof(WAVEHDR);
1002             /* dwBufferLength can be reduced between prepare & write */
1003             if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
1004                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1005                     wh16->dwBufferLength, wh32->dwBufferLength);
1006             } else
1007                 wh16->dwBufferLength = wh32->dwBufferLength;
1008             ret = WINMM_MAP_OKMEM;
1009         }
1010         break;
1011    case WIDM_GETDEVCAPS:
1012         {
1013             LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)*lpParam1;
1014             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSA) + sizeof(WAVEINCAPS16));
1015
1016             if (ptr) {
1017                 *(LPWAVEINCAPSA*)ptr = wic32;
1018                 ret = WINMM_MAP_OKMEM;
1019             } else {
1020                 ret = WINMM_MAP_NOMEM;
1021             }
1022             *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSA);
1023             *lpParam2 = sizeof(WAVEINCAPS16);
1024         }
1025         break;
1026     case WIDM_GETPOS:
1027         {
1028             LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1029             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1030             LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1031
1032             if (ptr) {
1033                 *(LPMMTIME*)ptr = mmt32;
1034                 mmt16->wType = mmt32->wType;
1035                 ret = WINMM_MAP_OKMEM;
1036             } else {
1037                 ret = WINMM_MAP_NOMEM;
1038             }
1039             *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1040             *lpParam2 = sizeof(MMTIME16);
1041         }
1042         break;
1043     case DRVM_MAPPER_STATUS:
1044         {
1045             LPDWORD p32 = (LPDWORD)*lpParam2;
1046             *lpParam2 = MapLS(p32);
1047             ret = WINMM_MAP_OKMEM;
1048         }
1049         break;
1050     default:
1051         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1052         break;
1053     }
1054     return ret;
1055 }
1056
1057 /**************************************************************************
1058  *                              MMDRV_WaveIn_UnMap32ATo16       [internal]
1059  */
1060 static  WINMM_MapType   MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1061 {
1062     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1063
1064     switch (wMsg) {
1065     case WIDM_CLOSE:
1066     case WIDM_GETNUMDEVS:
1067     case WIDM_RESET:
1068     case WIDM_START:
1069     case WIDM_STOP:
1070         ret = WINMM_MAP_OK;
1071         break;
1072
1073     case WIDM_OPEN:
1074         {
1075             LPWAVEOPENDESC16            wod16 = MapSL(*lpParam1);
1076             LPSTR                       ptr   = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1077             LPWAVEOPENDESC              wod32 = *(LPWAVEOPENDESC*)ptr;
1078
1079             UnMapLS( *lpParam1 );
1080             wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1081             **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1082             HeapFree( GetProcessHeap(), 0, ptr );
1083             ret = WINMM_MAP_OK;
1084         }
1085         break;
1086
1087     case WIDM_ADDBUFFER:
1088     case WIDM_PREPARE:
1089     case WIDM_UNPREPARE:
1090         {
1091             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1092             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1093             LPWAVEHDR           wh32 = *(LPWAVEHDR*)ptr;
1094
1095             assert(wh32->lpNext == wh16);
1096             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1097             wh32->dwUser = wh16->dwUser;
1098             wh32->dwFlags = wh16->dwFlags;
1099             wh32->dwLoops = wh16->dwLoops;
1100             UnMapLS( *lpParam1 );
1101
1102             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1103                 HeapFree( GetProcessHeap(), 0, ptr );
1104                 wh32->lpNext = 0;
1105             }
1106             ret = WINMM_MAP_OK;
1107         }
1108         break;
1109      case WIDM_GETDEVCAPS:
1110         {
1111             LPWAVEINCAPS16              wic16 = MapSL(*lpParam1);
1112             LPSTR                       ptr   = (LPSTR)wic16 - sizeof(LPWAVEINCAPSA);
1113             LPWAVEINCAPSA               wic32 = *(LPWAVEINCAPSA*)ptr;
1114
1115             wic32->wMid = wic16->wMid;
1116             wic32->wPid = wic16->wPid;
1117             wic32->vDriverVersion = wic16->vDriverVersion;
1118             strcpy(wic32->szPname, wic16->szPname);
1119             wic32->dwFormats = wic16->dwFormats;
1120             wic32->wChannels = wic16->wChannels;
1121             UnMapLS( *lpParam1 );
1122             HeapFree( GetProcessHeap(), 0, ptr );
1123             ret = WINMM_MAP_OK;
1124         }
1125         break;
1126     case WIDM_GETPOS:
1127         {
1128             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1129             LPSTR               ptr   = (LPSTR)mmt16 - sizeof(LPMMTIME);
1130             LPMMTIME            mmt32 = *(LPMMTIME*)ptr;
1131
1132             MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1133             UnMapLS( *lpParam1 );
1134             HeapFree( GetProcessHeap(), 0, ptr );
1135             ret = WINMM_MAP_OK;
1136         }
1137         break;
1138     case DRVM_MAPPER_STATUS:
1139         {
1140             UnMapLS( *lpParam2 );
1141             ret = WINMM_MAP_OK;
1142         }
1143         break;
1144     default:
1145         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1146         break;
1147     }
1148     return ret;
1149 }
1150
1151 /**************************************************************************
1152  *                              MMDRV_WaveIn_Callback           [internal]
1153  */
1154 static  void    CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
1155 {
1156     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
1157
1158     switch (uMsg) {
1159     case WIM_OPEN:
1160     case WIM_CLOSE:
1161         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1162         break;
1163     case WIM_DATA:
1164         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1165             /* initial map is: 32 => 16 */
1166             LPWAVEHDR           wh16 = MapSL(dwParam1);
1167             LPWAVEHDR           wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1168
1169             dwParam1 = (DWORD)wh32;
1170             wh32->dwFlags = wh16->dwFlags;
1171             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1172         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1173             /* initial map is: 16 => 32 */
1174             LPWAVEHDR           wh32 = (LPWAVEHDR)(dwParam1);
1175             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1176             LPWAVEHDR           wh16 = MapSL(segwh16);
1177
1178             dwParam1 = (DWORD)segwh16;
1179             wh16->dwFlags = wh32->dwFlags;
1180             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1181         }
1182         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1183         break;
1184     default:
1185         ERR("Unknown msg %u\n", uMsg);
1186     }
1187
1188     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1189 }
1190
1191 /* =================================
1192  *   W A V E  O U T  M A P P E R S
1193  * ================================= */
1194
1195 /**************************************************************************
1196  *                              MMDRV_WaveOut_Map16To32A        [internal]
1197  */
1198 static  WINMM_MapType   MMDRV_WaveOut_Map16To32A  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
1199 {
1200     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1201
1202     switch (wMsg) {
1203     /* nothing to do */
1204     case WODM_BREAKLOOP:
1205     case WODM_CLOSE:
1206     case WODM_GETNUMDEVS:
1207     case WODM_PAUSE:
1208     case WODM_RESET:
1209     case WODM_RESTART:
1210     case WODM_SETPITCH:
1211     case WODM_SETPLAYBACKRATE:
1212     case WODM_SETVOLUME:
1213         ret = WINMM_MAP_OK;
1214         break;
1215
1216     case WODM_GETPITCH:
1217     case WODM_GETPLAYBACKRATE:
1218     case WODM_GETVOLUME:
1219     case WODM_OPEN:
1220         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
1221         break;
1222
1223     case WODM_GETDEVCAPS:
1224         {
1225             LPWAVEOUTCAPSA              woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSA));
1226             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
1227
1228             if (woc32) {
1229                 *(LPWAVEOUTCAPS16*)woc32 = woc16;
1230                 woc32 = (LPWAVEOUTCAPSA)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
1231                 *lpParam1 = (DWORD)woc32;
1232                 *lpParam2 = sizeof(WAVEOUTCAPSA);
1233
1234                 ret = WINMM_MAP_OKMEM;
1235             } else {
1236                 ret = WINMM_MAP_NOMEM;
1237             }
1238         }
1239         break;
1240     case WODM_GETPOS:
1241         {
1242             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
1243             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1244
1245             if (mmt32) {
1246                 *(LPMMTIME16*)mmt32 = mmt16;
1247                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
1248
1249                 mmt32->wType = mmt16->wType;
1250                 *lpParam1 = (DWORD)mmt32;
1251                 *lpParam2 = sizeof(MMTIME);
1252
1253                 ret = WINMM_MAP_OKMEM;
1254             } else {
1255                 ret = WINMM_MAP_NOMEM;
1256             }
1257         }
1258         break;
1259     case WODM_PREPARE:
1260         {
1261             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
1262             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1263
1264             if (wh32) {
1265                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
1266                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
1267                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
1268                 wh32->dwBufferLength = wh16->dwBufferLength;
1269                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1270                 wh32->dwUser = wh16->dwUser;
1271                 wh32->dwFlags = wh16->dwFlags;
1272                 wh32->dwLoops = wh16->dwLoops;
1273                 /* FIXME: nothing on wh32->lpNext */
1274                 /* could link the wh32->lpNext at this level for memory house keeping */
1275                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
1276                 *lpParam1 = (DWORD)wh32;
1277                 *lpParam2 = sizeof(WAVEHDR);
1278
1279                 ret = WINMM_MAP_OKMEM;
1280             } else {
1281                 ret = WINMM_MAP_NOMEM;
1282             }
1283         }
1284         break;
1285     case WODM_UNPREPARE:
1286     case WODM_WRITE:
1287         {
1288             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1289             LPWAVEHDR           wh32 = (LPWAVEHDR)wh16->lpNext;
1290
1291             *lpParam1 = (DWORD)wh32;
1292             *lpParam2 = sizeof(WAVEHDR);
1293             /* dwBufferLength can be reduced between prepare & write */
1294             if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
1295                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1296                     wh32->dwBufferLength, wh16->dwBufferLength);
1297             } else
1298                 wh32->dwBufferLength = wh16->dwBufferLength;
1299             ret = WINMM_MAP_OKMEM;
1300         }
1301         break;
1302     case WODM_MAPPER_STATUS:
1303         *lpParam2 = (DWORD)MapSL(*lpParam2);
1304         ret = WINMM_MAP_OK;
1305         break;
1306     default:
1307         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1308         break;
1309     }
1310     return ret;
1311 }
1312
1313 /**************************************************************************
1314  *                              MMDRV_WaveOut_UnMap16To32A      [internal]
1315  */
1316 static  WINMM_MapType   MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1317 {
1318     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1319
1320     switch (wMsg) {
1321     /* nothing to do */
1322     case WODM_BREAKLOOP:
1323     case WODM_CLOSE:
1324     case WODM_GETNUMDEVS:
1325     case WODM_PAUSE:
1326     case WODM_RESET:
1327     case WODM_RESTART:
1328     case WODM_SETPITCH:
1329     case WODM_SETPLAYBACKRATE:
1330     case WODM_SETVOLUME:
1331     case WODM_MAPPER_STATUS:
1332         ret = WINMM_MAP_OK;
1333         break;
1334
1335     case WODM_GETPITCH:
1336     case WODM_GETPLAYBACKRATE:
1337     case WODM_GETVOLUME:
1338     case WODM_OPEN:
1339         FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
1340         break;
1341
1342     case WODM_GETDEVCAPS:
1343         {
1344             LPWAVEOUTCAPSA              woc32 = (LPWAVEOUTCAPSA)(*lpParam1);
1345             LPWAVEOUTCAPS16             woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1346
1347             woc16->wMid = woc32->wMid;
1348             woc16->wPid = woc32->wPid;
1349             woc16->vDriverVersion = woc32->vDriverVersion;
1350             strcpy(woc16->szPname, woc32->szPname);
1351             woc16->dwFormats = woc32->dwFormats;
1352             woc16->wChannels = woc32->wChannels;
1353             woc16->dwSupport = woc32->dwSupport;
1354             HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1355             ret = WINMM_MAP_OK;
1356         }
1357         break;
1358     case WODM_GETPOS:
1359         {
1360             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
1361             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
1362
1363             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
1364             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
1365             ret = WINMM_MAP_OK;
1366         }
1367         break;
1368     case WODM_PREPARE:
1369     case WODM_UNPREPARE:
1370     case WODM_WRITE:
1371         {
1372             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
1373             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
1374
1375             assert(wh16->lpNext == wh32);
1376             wh16->dwBufferLength = wh32->dwBufferLength;
1377             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1378             wh16->dwUser = wh32->dwUser;
1379             wh16->dwFlags = wh32->dwFlags;
1380             wh16->dwLoops = wh32->dwLoops;
1381
1382             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1383                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
1384                 wh16->lpNext = 0;
1385             }
1386             ret = WINMM_MAP_OK;
1387         }
1388         break;
1389     default:
1390         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1391         break;
1392     }
1393     return ret;
1394 }
1395
1396 /**************************************************************************
1397  *                              MMDRV_WaveOut_Map32ATo16        [internal]
1398  */
1399 static  WINMM_MapType   MMDRV_WaveOut_Map32ATo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
1400 {
1401     WINMM_MapType       ret;
1402
1403     switch (wMsg) {
1404         /* nothing to do */
1405     case WODM_BREAKLOOP:
1406     case WODM_CLOSE:
1407     case WODM_GETNUMDEVS:
1408     case WODM_PAUSE:
1409     case WODM_RESET:
1410     case WODM_RESTART:
1411     case WODM_SETPITCH:
1412     case WODM_SETPLAYBACKRATE:
1413     case WODM_SETVOLUME:
1414         ret = WINMM_MAP_OK;
1415         break;
1416
1417     case WODM_GETDEVCAPS:
1418         {
1419             LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)*lpParam1;
1420             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
1421                                    sizeof(LPWAVEOUTCAPSA) + sizeof(WAVEOUTCAPS16));
1422
1423             if (ptr) {
1424                 *(LPWAVEOUTCAPSA*)ptr = woc32;
1425                 ret = WINMM_MAP_OKMEM;
1426             } else {
1427                 ret = WINMM_MAP_NOMEM;
1428             }
1429             *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSA);
1430             *lpParam2 = sizeof(WAVEOUTCAPS16);
1431         }
1432         break;
1433     case WODM_GETPITCH:
1434         FIXME("NIY: no conversion yet\n");
1435         ret = WINMM_MAP_MSGERROR;
1436         break;
1437     case WODM_GETPLAYBACKRATE:
1438         FIXME("NIY: no conversion yet\n");
1439         ret = WINMM_MAP_MSGERROR;
1440         break;
1441     case WODM_GETPOS:
1442         {
1443             LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1444             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1445             LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1446
1447             if (ptr) {
1448                 *(LPMMTIME*)ptr = mmt32;
1449                 mmt16->wType = mmt32->wType;
1450                 ret = WINMM_MAP_OKMEM;
1451             } else {
1452                 ret = WINMM_MAP_NOMEM;
1453             }
1454             *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1455             *lpParam2 = sizeof(MMTIME16);
1456         }
1457         break;
1458     case WODM_GETVOLUME:
1459         FIXME("NIY: no conversion yet\n");
1460         ret = WINMM_MAP_MSGERROR;
1461         break;
1462     case WODM_OPEN:
1463         {
1464             LPWAVEOPENDESC              wod32 = (LPWAVEOPENDESC)*lpParam1;
1465             int                         sz = sizeof(WAVEFORMATEX);
1466             LPVOID                      ptr;
1467             LPWAVEOPENDESC16            wod16;
1468
1469             /* allocated data are mapped as follows:
1470                LPWAVEOPENDESC   ptr to orig lParam1
1471                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
1472                DWORD            dwUser passed to driver
1473                WAVEOPENDESC16   wod16: openDesc passed to driver
1474                WAVEFORMATEX     openDesc->lpFormat passed to driver
1475                xxx              extra bytes to WAVEFORMATEX
1476             */
1477             if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
1478                 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
1479                 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
1480             }
1481
1482             ptr = HeapAlloc( GetProcessHeap(), 0,
1483                              sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
1484
1485             if (ptr) {
1486                 SEGPTR seg_ptr = MapLS( ptr );
1487                 *(LPWAVEOPENDESC*)ptr = wod32;
1488                 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
1489                 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
1490
1491                 wod16->hWave = HWAVE_16(wod32->hWave);
1492                 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
1493                 memcpy(wod16 + 1, wod32->lpFormat, sz);
1494
1495                 wod16->dwCallback = wod32->dwCallback;
1496                 wod16->dwInstance = wod32->dwInstance;
1497                 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
1498                 wod16->dnDevNode = wod32->dnDevNode;
1499
1500                 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
1501                 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
1502
1503                 ret = WINMM_MAP_OKMEM;
1504             } else {
1505                 ret = WINMM_MAP_NOMEM;
1506             }
1507         }
1508         break;
1509     case WODM_PREPARE:
1510         {
1511             LPWAVEHDR           wh32 = (LPWAVEHDR)*lpParam1;
1512             LPWAVEHDR           wh16;
1513             LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
1514                                     sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
1515
1516             if (ptr) {
1517                 SEGPTR seg_ptr = MapLS( ptr );
1518                 *(LPWAVEHDR*)ptr = wh32;
1519                 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
1520                 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
1521                 /* data will be copied on WODM_WRITE */
1522                 wh16->dwBufferLength = wh32->dwBufferLength;
1523                 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1524                 wh16->dwUser = wh32->dwUser;
1525                 wh16->dwFlags = wh32->dwFlags;
1526                 wh16->dwLoops = wh32->dwLoops;
1527                 /* FIXME: nothing on wh32->lpNext */
1528                 /* could link the wh32->lpNext at this level for memory house keeping */
1529                 wh32->lpNext = wh16; /* for reuse in unprepare and write */
1530                 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
1531                       seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
1532                       wh32->dwBufferLength, (DWORD)wh32->lpData);
1533                 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1534                 *lpParam2 = sizeof(WAVEHDR);
1535
1536                 ret = WINMM_MAP_OKMEM;
1537             } else {
1538                 ret = WINMM_MAP_NOMEM;
1539             }
1540         }
1541         break;
1542     case WODM_UNPREPARE:
1543     case WODM_WRITE:
1544         {
1545             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
1546             LPWAVEHDR           wh16 = wh32->lpNext;
1547             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1548             SEGPTR seg_ptr = MapLS( ptr );
1549
1550             assert(*(LPWAVEHDR*)ptr == wh32);
1551
1552             TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
1553                   seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
1554                   wh32->dwBufferLength, (DWORD)wh32->lpData);
1555
1556             if (wMsg == WODM_WRITE)
1557                 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
1558
1559             *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1560             *lpParam2 = sizeof(WAVEHDR);
1561             /* dwBufferLength can be reduced between prepare & write */
1562             if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
1563                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1564                     wh16->dwBufferLength, wh32->dwBufferLength);
1565             } else
1566                 wh16->dwBufferLength = wh32->dwBufferLength;
1567             ret = WINMM_MAP_OKMEM;
1568         }
1569         break;
1570     case DRVM_MAPPER_STATUS:
1571         {
1572             LPDWORD p32 = (LPDWORD)*lpParam2;
1573             *lpParam2 = MapLS(p32);
1574             ret = WINMM_MAP_OKMEM;
1575         }
1576         break;
1577     default:
1578         FIXME("NIY: no conversion yet\n");
1579         ret = WINMM_MAP_MSGERROR;
1580         break;
1581     }
1582     return ret;
1583 }
1584
1585 /**************************************************************************
1586  *                              MMDRV_WaveOut_UnMap32ATo16      [internal]
1587  */
1588 static  WINMM_MapType   MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1589 {
1590     WINMM_MapType       ret;
1591
1592     switch (wMsg) {
1593         /* nothing to do */
1594     case WODM_BREAKLOOP:
1595     case WODM_CLOSE:
1596     case WODM_GETNUMDEVS:
1597     case WODM_PAUSE:
1598     case WODM_RESET:
1599     case WODM_RESTART:
1600     case WODM_SETPITCH:
1601     case WODM_SETPLAYBACKRATE:
1602     case WODM_SETVOLUME:
1603         ret = WINMM_MAP_OK;
1604         break;
1605
1606     case WODM_GETDEVCAPS:
1607         {
1608             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
1609             LPSTR                       ptr   = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSA);
1610             LPWAVEOUTCAPSA              woc32 = *(LPWAVEOUTCAPSA*)ptr;
1611
1612             woc32->wMid = woc16->wMid;
1613             woc32->wPid = woc16->wPid;
1614             woc32->vDriverVersion = woc16->vDriverVersion;
1615             strcpy(woc32->szPname, woc16->szPname);
1616             woc32->dwFormats = woc16->dwFormats;
1617             woc32->wChannels = woc16->wChannels;
1618             woc32->dwSupport = woc16->dwSupport;
1619             UnMapLS( *lpParam1 );
1620             HeapFree( GetProcessHeap(), 0, ptr );
1621             ret = WINMM_MAP_OK;
1622         }
1623         break;
1624     case WODM_GETPITCH:
1625         FIXME("NIY: no conversion yet\n");
1626         ret = WINMM_MAP_MSGERROR;
1627         break;
1628     case WODM_GETPLAYBACKRATE:
1629         FIXME("NIY: no conversion yet\n");
1630         ret = WINMM_MAP_MSGERROR;
1631         break;
1632     case WODM_GETPOS:
1633         {
1634             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1635             LPSTR               ptr   = (LPSTR)mmt16 - sizeof(LPMMTIME);
1636             LPMMTIME            mmt32 = *(LPMMTIME*)ptr;
1637
1638             MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1639             UnMapLS( *lpParam1 );
1640             HeapFree( GetProcessHeap(), 0, ptr );
1641             ret = WINMM_MAP_OK;
1642         }
1643         break;
1644     case WODM_OPEN:
1645         {
1646             LPWAVEOPENDESC16            wod16 = MapSL(*lpParam1);
1647             LPSTR                       ptr   = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1648             LPWAVEOPENDESC              wod32 = *(LPWAVEOPENDESC*)ptr;
1649
1650             wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1651             **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1652             UnMapLS( *lpParam1 );
1653             HeapFree( GetProcessHeap(), 0, ptr );
1654             ret = WINMM_MAP_OK;
1655         }
1656         break;
1657     case WODM_PREPARE:
1658     case WODM_UNPREPARE:
1659     case WODM_WRITE:
1660         {
1661             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1662             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1663             LPWAVEHDR           wh32 = *(LPWAVEHDR*)ptr;
1664
1665             assert(wh32->lpNext == wh16);
1666             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1667             wh32->dwUser = wh16->dwUser;
1668             wh32->dwFlags = wh16->dwFlags;
1669             wh32->dwLoops = wh16->dwLoops;
1670
1671             UnMapLS( *lpParam1 );
1672             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1673                 HeapFree( GetProcessHeap(), 0, ptr );
1674                 wh32->lpNext = 0;
1675             }
1676             ret = WINMM_MAP_OK;
1677         }
1678         break;
1679     case WODM_GETVOLUME:
1680         FIXME("NIY: no conversion yet\n");
1681         ret = WINMM_MAP_MSGERROR;
1682         break;
1683     case DRVM_MAPPER_STATUS:
1684         {
1685             UnMapLS( *lpParam2 );
1686             ret = WINMM_MAP_OK;
1687         }
1688         break;
1689     default:
1690         FIXME("NIY: no conversion yet\n");
1691         ret = WINMM_MAP_MSGERROR;
1692         break;
1693     }
1694     return ret;
1695 }
1696
1697 /**************************************************************************
1698  *                              MMDRV_WaveOut_Callback          [internal]
1699  */
1700 static  void    CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
1701 {
1702     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
1703
1704     switch (uMsg) {
1705     case WOM_OPEN:
1706     case WOM_CLOSE:
1707         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1708         break;
1709     case WOM_DONE:
1710         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1711             /* initial map is: 32 => 16 */
1712             LPWAVEHDR           wh16 = MapSL(dwParam1);
1713             LPWAVEHDR           wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1714
1715             dwParam1 = (DWORD)wh32;
1716             wh32->dwFlags = wh16->dwFlags;
1717         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1718             /* initial map is: 16 => 32 */
1719             LPWAVEHDR           wh32 = (LPWAVEHDR)(dwParam1);
1720             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1721             LPWAVEHDR           wh16 = MapSL(segwh16);
1722
1723             dwParam1 = (DWORD)segwh16;
1724             wh16->dwFlags = wh32->dwFlags;
1725         }
1726         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1727         break;
1728     default:
1729         ERR("Unknown msg %u\n", uMsg);
1730     }
1731
1732     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1733 }
1734
1735 /* =================================
1736  *  M A P P E R S   H A N D L I N G
1737  * ================================= */
1738
1739 static  LRESULT    MMDRV_CallMMDrvFunc16(DWORD fp16, WORD dev, WORD msg, LONG instance,
1740                                          LONG lp1, LONG lp2)
1741 {
1742     WORD args[8];
1743     DWORD ret;
1744
1745     args[7] = dev;
1746     args[6] = msg;
1747     args[5] = HIWORD(instance);
1748     args[4] = LOWORD(instance);
1749     args[3] = HIWORD(lp1);
1750     args[2] = LOWORD(lp1);
1751     args[1] = HIWORD(lp2);
1752     args[0] = LOWORD(lp2);
1753     WOWCallback16Ex( fp16, WCB16_PASCAL, sizeof(args), args, &ret );
1754     return LOWORD(ret);
1755 }
1756
1757 /**************************************************************************
1758  *                              MMDRV_GetDescription16          [internal]
1759  */
1760 static  BOOL    MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
1761 {
1762     OFSTRUCT    ofs;
1763     HFILE       hFile;
1764     WORD        w;
1765     DWORD       dw;
1766     BOOL        ret = FALSE;
1767
1768     if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
1769         ERR("Can't open file %s (builtin driver ?)\n", fname);
1770         return FALSE;
1771     }
1772
1773 #define E(_x)   do {TRACE _x;goto theEnd;} while(0)
1774
1775     if (_lread(hFile, &w, 2) != 2)                      E(("Can't read sig\n"));
1776     if (w != ('Z' * 256 + 'M'))                         E(("Bad sig %04x\n", w));
1777     if (_llseek(hFile, 0x3C, SEEK_SET) < 0)             E(("Can't seek to ext header offset\n"));
1778     if (_lread(hFile, &dw, 4) != 4)                     E(("Can't read ext header offset\n"));
1779     if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0)        E(("Can't seek to ext header.nr table %lu\n", dw+0x2C));
1780     if (_lread(hFile, &dw, 4) != 4)                     E(("Can't read nr table offset\n"));
1781     if (_llseek(hFile, dw, SEEK_SET) < 0)               E(("Can't seek to nr table %lu\n", dw));
1782     if (_lread(hFile, buf, 1) != 1)                     E(("Can't read descr length\n"));
1783     buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
1784     if (_lread(hFile, buf, buflen) != buflen)           E(("Can't read descr (%d)\n", buflen));
1785     buf[buflen] = '\0';
1786     ret = TRUE;
1787     TRACE("Got '%s' [%d]\n", buf, buflen);
1788 theEnd:
1789     _lclose(hFile);
1790     return ret;
1791 }
1792
1793 /******************************************************************
1794  *              MMDRV_LoadMMDrvFunc16
1795  *
1796  */
1797 unsigned   MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
1798                                  LPWINE_MM_DRIVER lpDrv)
1799 {
1800     WINEMM_msgFunc16    func;
1801     unsigned            count = 0;
1802     char                buffer[128];
1803     /*
1804      * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
1805      * The beginning of the module description indicates the driver supports
1806      * waveform, auxiliary, and mixer devices. Use one of the following
1807      * device-type names, followed by a colon (:) to indicate the type of
1808      * device your driver supports. If the driver supports more than one
1809      * type of device, separate each device-type name with a comma (,).
1810      *
1811      * wave for waveform audio devices
1812      * wavemapper for wave mappers
1813      * midi for MIDI audio devices
1814      * midimapper for midi mappers
1815      * aux for auxiliary audio devices
1816      * mixer for mixer devices
1817      */
1818
1819     if (d->d.d16.hDriver16) {
1820         HMODULE16       hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
1821
1822 #define AA(_h,_w,_x,_y,_z)                                      \
1823     func = (WINEMM_msgFunc##_y) _z ((_h), #_x);                 \
1824     if (func != NULL)                                           \
1825         { lpDrv->parts[_w].u.fnMessage##_y = func; count++;     \
1826           TRACE("Got %d bit func '%s'\n", _y, #_x);         }
1827
1828 #define A(_x,_y)        AA(hMod16,_x,_y,16,GetProcAddress16)
1829         A(MMDRV_AUX,    auxMessage);
1830         A(MMDRV_MIXER,  mxdMessage);
1831         A(MMDRV_MIDIIN, midMessage);
1832         A(MMDRV_MIDIOUT,modMessage);
1833         A(MMDRV_WAVEIN, widMessage);
1834         A(MMDRV_WAVEOUT,wodMessage);
1835 #undef A
1836 #undef AA
1837     }
1838     if (TRACE_ON(winmm)) {
1839         if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
1840             TRACE("%s => %s\n", drvName, buffer);
1841         else
1842             TRACE("%s => No description\n", drvName);
1843     }
1844
1845     return count;
1846 }
1847
1848 /* =================================
1849  *              M C I
1850  * ================================= */
1851
1852 /**************************************************************************
1853  *                      MCI_MapMsg16To32A                       [internal]
1854  */
1855 static WINMM_MapType    MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1856 {
1857     if (*lParam == 0)
1858         return WINMM_MAP_OK;
1859     /* FIXME: to add also (with seg/linear modifications to do):
1860      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1861      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1862      */
1863     switch (wMsg) {
1864         /* case MCI_CAPTURE */
1865     case MCI_CLOSE:
1866     case MCI_CLOSE_DRIVER:
1867     case MCI_CONFIGURE:
1868     case MCI_COPY:
1869     case MCI_CUE:
1870     case MCI_CUT:
1871     case MCI_DELETE:
1872     case MCI_FREEZE:
1873     case MCI_GETDEVCAPS:
1874         /* case MCI_INDEX: */
1875         /* case MCI_MARK: */
1876         /* case MCI_MONITOR: */
1877     case MCI_PASTE:
1878     case MCI_PAUSE:
1879     case MCI_PLAY:
1880     case MCI_PUT:
1881     case MCI_REALIZE:
1882     case MCI_RECORD:
1883     case MCI_RESUME:
1884     case MCI_SEEK:
1885     case MCI_SET:
1886         /* case MCI_SETTIMECODE:*/
1887         /* case MCI_SIGNAL:*/
1888     case MCI_SPIN:
1889     case MCI_STATUS:            /* FIXME: is wrong for digital video */
1890     case MCI_STEP:
1891     case MCI_STOP:
1892         /* case MCI_UNDO: */
1893     case MCI_UNFREEZE:
1894     case MCI_UPDATE:
1895     case MCI_WHERE:
1896         *lParam = (DWORD)MapSL(*lParam);
1897         return WINMM_MAP_OK;
1898     case MCI_WINDOW:
1899         /* in fact, I would also need the dwFlags... to see
1900          * which members of lParam are effectively used
1901          */
1902         *lParam = (DWORD)MapSL(*lParam);
1903         FIXME("Current mapping may be wrong\n");
1904         break;
1905     case MCI_BREAK:
1906         {
1907             LPMCI_BREAK_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
1908             LPMCI_BREAK_PARMS16         mbp16 = MapSL(*lParam);
1909
1910             if (mbp32) {
1911                 mbp32->dwCallback = mbp16->dwCallback;
1912                 mbp32->nVirtKey = mbp16->nVirtKey;
1913                 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
1914             } else {
1915                 return WINMM_MAP_NOMEM;
1916             }
1917             *lParam = (DWORD)mbp32;
1918         }
1919         return WINMM_MAP_OKMEM;
1920     case MCI_ESCAPE:
1921         {
1922             LPMCI_VD_ESCAPE_PARMSA      mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
1923             LPMCI_VD_ESCAPE_PARMS16     mvep16  = MapSL(*lParam);
1924
1925             if (mvep32a) {
1926                 mvep32a->dwCallback       = mvep16->dwCallback;
1927                 mvep32a->lpstrCommand     = MapSL(mvep16->lpstrCommand);
1928             } else {
1929                 return WINMM_MAP_NOMEM;
1930             }
1931             *lParam = (DWORD)mvep32a;
1932         }
1933         return WINMM_MAP_OKMEM;
1934     case MCI_INFO:
1935         {
1936             LPMCI_INFO_PARMSA   mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
1937             LPMCI_INFO_PARMS16  mip16  = MapSL(*lParam);
1938
1939             /* FIXME this is wrong if device is of type
1940              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1941              */
1942             if (mip32a) {
1943                 mip32a->dwCallback  = mip16->dwCallback;
1944                 mip32a->lpstrReturn = MapSL(mip16->lpstrReturn);
1945                 mip32a->dwRetSize   = mip16->dwRetSize;
1946             } else {
1947                 return WINMM_MAP_NOMEM;
1948             }
1949             *lParam = (DWORD)mip32a;
1950         }
1951         return WINMM_MAP_OKMEM;
1952     case MCI_OPEN:
1953     case MCI_OPEN_DRIVER:
1954         {
1955             LPMCI_OPEN_PARMSA   mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
1956             LPMCI_OPEN_PARMS16  mop16  = MapSL(*lParam);
1957
1958             if (mop32a) {
1959                 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1960                 mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
1961                 mop32a->dwCallback       = mop16->dwCallback;
1962                 mop32a->wDeviceID        = mop16->wDeviceID;
1963                 mop32a->lpstrDeviceType  = MapSL(mop16->lpstrDeviceType);
1964                 mop32a->lpstrElementName = MapSL(mop16->lpstrElementName);
1965                 mop32a->lpstrAlias       = MapSL(mop16->lpstrAlias);
1966                 /* copy extended information if any...
1967                  * FIXME: this may seg fault if initial structure does not contain them and
1968                  * the reads after msip16 fail under LDT limits...
1969                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1970                  * should not take care of extended parameters, and should be used by MCI_Open
1971                  * to fetch uDevType. When, this is known, the mapping for sending the
1972                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
1973                  */
1974                 memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
1975             } else {
1976                 return WINMM_MAP_NOMEM;
1977             }
1978             *lParam = (DWORD)mop32a;
1979         }
1980         return WINMM_MAP_OKMEM;
1981     case MCI_SYSINFO:
1982         {
1983             LPMCI_SYSINFO_PARMSA        msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
1984             LPMCI_SYSINFO_PARMS16       msip16  = MapSL(*lParam);
1985
1986             if (msip32a) {
1987                 msip32a->dwCallback       = msip16->dwCallback;
1988                 msip32a->lpstrReturn      = MapSL(msip16->lpstrReturn);
1989                 msip32a->dwRetSize        = msip16->dwRetSize;
1990                 msip32a->dwNumber         = msip16->dwNumber;
1991                 msip32a->wDeviceType      = msip16->wDeviceType;
1992             } else {
1993                 return WINMM_MAP_NOMEM;
1994             }
1995             *lParam = (DWORD)msip32a;
1996         }
1997         return WINMM_MAP_OKMEM;
1998     case MCI_SOUND:
1999         {
2000             LPMCI_SOUND_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMS));
2001             LPMCI_SOUND_PARMS16         mbp16 = MapSL(*lParam);
2002
2003             if (mbp32) {
2004                 mbp32->dwCallback = mbp16->dwCallback;
2005                 mbp32->lpstrSoundName = MapSL(mbp16->lpstrSoundName);
2006             } else {
2007                 return WINMM_MAP_NOMEM;
2008             }
2009             *lParam = (DWORD)mbp32;
2010         }
2011         return WINMM_MAP_OKMEM;
2012     case DRV_LOAD:
2013     case DRV_ENABLE:
2014     case DRV_OPEN:
2015     case DRV_CLOSE:
2016     case DRV_DISABLE:
2017     case DRV_FREE:
2018     case DRV_CONFIGURE:
2019     case DRV_QUERYCONFIGURE:
2020     case DRV_INSTALL:
2021     case DRV_REMOVE:
2022     case DRV_EXITSESSION:
2023     case DRV_EXITAPPLICATION:
2024     case DRV_POWER:
2025         FIXME("This is a hack\n");
2026         return WINMM_MAP_OK;
2027
2028     default:
2029         WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2030     }
2031     return WINMM_MAP_MSGERROR;
2032 }
2033
2034 /**************************************************************************
2035  *                      MCI_UnMapMsg16To32A                     [internal]
2036  */
2037 static  WINMM_MapType   MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
2038 {
2039     switch (wMsg) {
2040         /* case MCI_CAPTURE */
2041     case MCI_CLOSE:
2042     case MCI_CLOSE_DRIVER:
2043     case MCI_CONFIGURE:
2044     case MCI_COPY:
2045     case MCI_CUE:
2046     case MCI_CUT:
2047     case MCI_DELETE:
2048     case MCI_FREEZE:
2049     case MCI_GETDEVCAPS:
2050         /* case MCI_INDEX: */
2051         /* case MCI_MARK: */
2052         /* case MCI_MONITOR: */
2053     case MCI_PASTE:
2054     case MCI_PAUSE:
2055     case MCI_PLAY:
2056     case MCI_PUT:
2057     case MCI_REALIZE:
2058     case MCI_RECORD:
2059     case MCI_RESUME:
2060     case MCI_SEEK:
2061     case MCI_SET:
2062         /* case MCI_SETTIMECODE:*/
2063         /* case MCI_SIGNAL:*/
2064     case MCI_SPIN:
2065     case MCI_STATUS:
2066     case MCI_STEP:
2067     case MCI_STOP:
2068         /* case MCI_UNDO: */
2069     case MCI_UNFREEZE:
2070     case MCI_UPDATE:
2071     case MCI_WHERE:
2072         return WINMM_MAP_OK;
2073
2074     case MCI_WINDOW:
2075         /* FIXME ?? see Map function */
2076         return WINMM_MAP_OK;
2077
2078     case MCI_BREAK:
2079     case MCI_ESCAPE:
2080     case MCI_INFO:
2081     case MCI_SYSINFO:
2082     case MCI_SOUND:
2083         HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2084         return WINMM_MAP_OK;
2085     case MCI_OPEN:
2086     case MCI_OPEN_DRIVER:
2087         if (lParam) {
2088             LPMCI_OPEN_PARMSA   mop32a = (LPMCI_OPEN_PARMSA)lParam;
2089             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16));
2090
2091             mop16->wDeviceID = mop32a->wDeviceID;
2092             if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
2093                 FIXME("bad free line=%d\n", __LINE__);
2094         }
2095         return WINMM_MAP_OK;
2096     case DRV_LOAD:
2097     case DRV_ENABLE:
2098     case DRV_OPEN:
2099     case DRV_CLOSE:
2100     case DRV_DISABLE:
2101     case DRV_FREE:
2102     case DRV_CONFIGURE:
2103     case DRV_QUERYCONFIGURE:
2104     case DRV_INSTALL:
2105     case DRV_REMOVE:
2106     case DRV_EXITSESSION:
2107     case DRV_EXITAPPLICATION:
2108     case DRV_POWER:
2109         FIXME("This is a hack\n");
2110         return WINMM_MAP_OK;
2111     default:
2112         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2113     }
2114     return WINMM_MAP_MSGERROR;
2115 }
2116
2117 /*
2118  * 0000 stop
2119  * 0001 squeeze   signed 4 bytes to 2 bytes     *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2;     S += 4
2120  * 0010 squeeze unsigned 4 bytes to 2 bytes     *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2;     S += 4
2121  * 0100
2122  * 0101
2123  * 0110 zero 4 bytes                            *(DWORD)D = 0                        D += 4;     S += 4
2124  * 0111 copy string                             *(LPSTR*)D = seg dup(*(LPSTR*)S)     D += 4;     S += 4
2125  * 1xxx copy xxx + 1 bytes                      memcpy(D, S, xxx + 1);               D += xxx+1; S += xxx+1
2126  */
2127
2128 /**************************************************************************
2129  *                      MCI_MsgMapper32To16_Create              [internal]
2130  *
2131  * Helper for MCI_MapMsg32ATo16.
2132  * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
2133  * segmented pointer.
2134  * map contains a list of action to be performed for the mapping (see list
2135  * above)
2136  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
2137  */
2138 static  WINMM_MapType   MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
2139 {
2140     void*       lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
2141     LPBYTE      p16, p32;
2142
2143     if (!lp) {
2144         return WINMM_MAP_NOMEM;
2145     }
2146     p32 = (LPBYTE)(*ptr);
2147     if (keep) {
2148         *(void**)lp = *ptr;
2149         p16 = (LPBYTE)lp + sizeof(void**);
2150         *ptr = (char*)MapLS(lp) + sizeof(void**);
2151     } else {
2152         p16 = lp;
2153         *ptr = (void*)MapLS(lp);
2154     }
2155
2156     if (map == 0) {
2157         memcpy(p16, p32, size16);
2158     } else {
2159         unsigned        nibble;
2160         unsigned        sz;
2161
2162         while (map & 0xF) {
2163             nibble = map & 0xF;
2164             if (nibble & 0x8) {
2165                 sz = (nibble & 7) + 1;
2166                 memcpy(p16, p32, sz);
2167                 p16 += sz;
2168                 p32 += sz;
2169                 size16 -= sz;   /* DEBUG only */
2170             } else {
2171                 switch (nibble) {
2172                 case 0x1:
2173                     *(LPINT16)p16 = *(LPINT)p32;
2174                     p16 += sizeof(INT16);
2175                     p32 += sizeof(INT);
2176                     size16 -= sizeof(INT16);
2177                     break;
2178                 case 0x2:
2179                     *(LPUINT16)p16 = *(LPUINT)p32;
2180                     p16 += sizeof(UINT16);
2181                     p32 += sizeof(UINT);
2182                     size16 -= sizeof(UINT16);
2183                     break;
2184                 case 0x6:
2185                     *(LPDWORD)p16 = 0;
2186                     p16 += sizeof(DWORD);
2187                     p32 += sizeof(DWORD);
2188                     size16 -= sizeof(DWORD);
2189                     break;
2190                 case 0x7:
2191                     *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
2192                     p16 += sizeof(SEGPTR);
2193                     p32 += sizeof(LPSTR);
2194                     size16 -= sizeof(SEGPTR);
2195                     break;
2196                 default:
2197                     FIXME("Unknown nibble for mapping (%x)\n", nibble);
2198                 }
2199             }
2200             map >>= 4;
2201         }
2202         if (size16 != 0) /* DEBUG only */
2203             FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2204     }
2205     return WINMM_MAP_OKMEM;
2206 }
2207
2208 /**************************************************************************
2209  *                      MCI_MsgMapper32To16_Destroy             [internal]
2210  *
2211  * Helper for MCI_UnMapMsg32ATo16.
2212  */
2213 static  WINMM_MapType   MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
2214 {
2215     if (ptr) {
2216         void*           msg16 = MapSL((SEGPTR)ptr);
2217         void*           alloc;
2218         LPBYTE          p32, p16;
2219         unsigned        nibble;
2220
2221         UnMapLS( (SEGPTR)ptr );
2222         if (kept) {
2223             alloc = (char*)msg16 - sizeof(void**);
2224             p32 = *(void**)alloc;
2225             p16 = msg16;
2226
2227             if (map == 0) {
2228                 memcpy(p32, p16, size16);
2229             } else {
2230                 while (map & 0xF) {
2231                     nibble = map & 0xF;
2232                     if (nibble & 0x8) {
2233                         memcpy(p32, p16, (nibble & 7) + 1);
2234                         p16 += (nibble & 7) + 1;
2235                         p32 += (nibble & 7) + 1;
2236                         size16 -= (nibble & 7) + 1;
2237                     } else {
2238                         switch (nibble) {
2239                         case 0x1:
2240                             *(LPINT)p32 = *(LPINT16)p16;
2241                             p16 += sizeof(INT16);
2242                             p32 += sizeof(INT);
2243                             size16 -= sizeof(INT16);
2244                             break;
2245                         case 0x2:
2246                             *(LPUINT)p32 = *(LPUINT16)p16;
2247                             p16 += sizeof(UINT16);
2248                             p32 += sizeof(UINT);
2249                             size16 -= sizeof(UINT16);
2250                             break;
2251                         case 0x6:
2252                             p16 += sizeof(UINT);
2253                             p32 += sizeof(UINT);
2254                             size16 -= sizeof(UINT);
2255                             break;
2256                         case 0x7:
2257                             UnMapLS( *(SEGPTR *)p16 );
2258                             p16 += sizeof(SEGPTR);
2259                             p32 += sizeof(char*);
2260                             size16 -= sizeof(SEGPTR);
2261                             break;
2262                         default:
2263                             FIXME("Unknown nibble for mapping (%x)\n", nibble);
2264                         }
2265                     }
2266                     map >>= 4;
2267                 }
2268                 if (size16 != 0) /* DEBUG only */
2269                     FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2270             }
2271         } else {
2272             alloc = msg16;
2273         }
2274
2275         HeapFree( GetProcessHeap(), 0, alloc );
2276     }
2277     return WINMM_MAP_OK;
2278 }
2279
2280 /**************************************************************************
2281  *                      MCI_MapMsg32ATo16                       [internal]
2282  *
2283  * Map a 32-A bit MCI message to a 16 bit MCI message.
2284  */
2285 static  WINMM_MapType   MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
2286 {
2287     int         size;
2288     BOOLEAN     keep = FALSE;
2289     DWORD       map = 0;
2290
2291     if (*lParam == 0)
2292         return WINMM_MAP_OK;
2293
2294     /* FIXME: to add also (with seg/linear modifications to do):
2295      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2296      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2297      */
2298     switch (wMsg) {
2299     case MCI_BREAK:
2300         size = sizeof(MCI_BREAK_PARMS);
2301         break;
2302         /* case MCI_CAPTURE */
2303     case MCI_CLOSE:
2304     case MCI_CLOSE_DRIVER:
2305     case MCI_CONFIGURE:
2306         size = sizeof(MCI_GENERIC_PARMS);
2307         break;
2308         /* case MCI_COPY: */
2309     case MCI_CUE:
2310         switch (uDevType) {
2311         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS);       break;
2312         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_CUE_PARMS);     break;*/        FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2313         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2314         }
2315         break;
2316         /* case MCI_CUT:*/
2317     case MCI_DELETE:
2318         switch (uDevType) {
2319         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16);  map = 0x0F1111FB;       break;
2320         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS);   break;
2321         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2322         }
2323         break;
2324         /* case MCI_ESCAPE: */
2325     case MCI_FREEZE:
2326         switch (uDevType) {
2327         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS);    map = 0x0001111B;       break;
2328         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
2329         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2330         }
2331         break;
2332     case MCI_GETDEVCAPS:
2333         keep = TRUE;
2334         size = sizeof(MCI_GETDEVCAPS_PARMS);
2335         break;
2336         /* case MCI_INDEX: */
2337     case MCI_INFO:
2338         {
2339             LPMCI_INFO_PARMSA   mip32a = (LPMCI_INFO_PARMSA)(*lParam);
2340             LPMCI_INFO_PARMS16  mip16;
2341
2342             switch (uDevType) {
2343             case MCI_DEVTYPE_DIGITAL_VIDEO:     size = sizeof(MCI_DGV_INFO_PARMS16);    break;
2344             default:                            size = sizeof(MCI_INFO_PARMS16);        break;
2345             }
2346             mip16 = HeapAlloc( GetProcessHeap(), 0, size);
2347             if (mip16)
2348             {
2349                 mip16->dwCallback  = mip32a->dwCallback;
2350                 mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
2351                 mip16->dwRetSize   = mip32a->dwRetSize;
2352                 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
2353                     ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
2354                 }
2355             } else {
2356                 return WINMM_MAP_NOMEM;
2357             }
2358             *lParam = MapLS(mip16);
2359         }
2360         return WINMM_MAP_OKMEM;
2361         /* case MCI_MARK: */
2362         /* case MCI_MONITOR: */
2363     case MCI_OPEN:
2364     case MCI_OPEN_DRIVER:
2365         {
2366             LPMCI_OPEN_PARMSA   mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
2367             char* ptr = HeapAlloc( GetProcessHeap(), 0,
2368                                    sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
2369             LPMCI_OPEN_PARMS16  mop16;
2370
2371
2372             if (ptr) {
2373                 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
2374                 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
2375                 mop16->dwCallback       = mop32a->dwCallback;
2376                 mop16->wDeviceID        = mop32a->wDeviceID;
2377                 if (dwFlags & MCI_OPEN_TYPE) {
2378                     if (dwFlags & MCI_OPEN_TYPE_ID) {
2379                         /* dword "transparent" value */
2380                         mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
2381                     } else {
2382                         /* string */
2383                         mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
2384                     }
2385                 } else {
2386                     /* nuthin' */
2387                     mop16->lpstrDeviceType = 0;
2388                 }
2389                 if (dwFlags & MCI_OPEN_ELEMENT) {
2390                     if (dwFlags & MCI_OPEN_ELEMENT_ID) {
2391                         mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
2392                     } else {
2393                         mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
2394                     }
2395                 } else {
2396                     mop16->lpstrElementName = 0;
2397                 }
2398                 if (dwFlags & MCI_OPEN_ALIAS) {
2399                     mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
2400                 } else {
2401                     mop16->lpstrAlias = 0;
2402                 }
2403                 /* copy extended information if any...
2404                  * FIXME: this may seg fault if initial structure does not contain them and
2405                  * the reads after msip16 fail under LDT limits...
2406                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2407                  * should not take care of extended parameters, and should be used by MCI_Open
2408                  * to fetch uDevType. When, this is known, the mapping for sending the
2409                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
2410                  */
2411                 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
2412             } else {
2413                 return WINMM_MAP_NOMEM;
2414             }
2415             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
2416         }
2417         return WINMM_MAP_OKMEM;
2418         /* case MCI_PASTE:*/
2419     case MCI_PAUSE:
2420         size = sizeof(MCI_GENERIC_PARMS);
2421         break;
2422     case MCI_PLAY:
2423         size = sizeof(MCI_PLAY_PARMS);
2424         break;
2425     case MCI_PUT:
2426         switch (uDevType) {
2427         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
2428         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
2429         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2430         }
2431         break;
2432     case MCI_REALIZE:
2433         size = sizeof(MCI_GENERIC_PARMS);
2434         break;
2435     case MCI_RECORD:
2436         switch (uDevType) {
2437         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16);  map = 0x0F1111FB;       break;
2438         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_RECORD_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2439         default:                        size = sizeof(MCI_RECORD_PARMS);        break;
2440         }
2441         break;
2442     case MCI_RESUME:
2443         size = sizeof(MCI_GENERIC_PARMS);
2444         break;
2445     case MCI_SEEK:
2446         switch (uDevType) {
2447         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SEEK_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2448         default:                        size = sizeof(MCI_SEEK_PARMS);          break;
2449         }
2450         break;
2451     case MCI_SET:
2452         switch (uDevType) {
2453         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS);       break;
2454         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SET_PARMS);     break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2455         case MCI_DEVTYPE_SEQUENCER:     size = sizeof(MCI_SEQ_SET_PARMS);       break;
2456         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
2457          * so not doing anything should work...
2458          */
2459         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS);      break;
2460         default:                        size = sizeof(MCI_SET_PARMS);           break;
2461         }
2462         break;
2463     case MCI_SETAUDIO:
2464         switch (uDevType) {
2465         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;      break;
2466         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2467         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2468         }
2469         break;
2470         /* case MCI_SETTIMECODE:*/
2471         /* case MCI_SIGNAL:*/
2472         /* case MCI_SOUND:*/
2473     case MCI_SPIN:
2474         size = sizeof(MCI_SET_PARMS);
2475         break;
2476     case MCI_STATUS:
2477         keep = TRUE;
2478         switch (uDevType) {
2479         /* FIXME:
2480          * don't know if buffer for value is the one passed through lpstrDevice
2481          * or is provided by MCI driver.
2482          * Assuming solution 2: provided by MCI driver, so zeroing on entry
2483          */
2484         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16);  map = 0x0B6FF;          break;
2485         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2486         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2487         }
2488         break;
2489     case MCI_STEP:
2490         switch (uDevType) {
2491         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS);      break;
2492         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STEP_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2493         case MCI_DEVTYPE_VIDEODISC:     size = sizeof(MCI_VD_STEP_PARMS);       break;
2494         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2495         }
2496         break;
2497     case MCI_STOP:
2498         size = sizeof(MCI_SET_PARMS);
2499         break;
2500     case MCI_SYSINFO:
2501         {
2502             LPMCI_SYSINFO_PARMSA  msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
2503             LPMCI_SYSINFO_PARMS16 msip16;
2504             char* ptr = HeapAlloc( GetProcessHeap(), 0,
2505                                    sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
2506
2507             if (ptr) {
2508                 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
2509                 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
2510
2511                 msip16->dwCallback       = msip32a->dwCallback;
2512                 msip16->lpstrReturn      = MapLS( msip32a->lpstrReturn );
2513                 msip16->dwRetSize        = msip32a->dwRetSize;
2514                 msip16->dwNumber         = msip32a->dwNumber;
2515                 msip16->wDeviceType      = msip32a->wDeviceType;
2516             } else {
2517                 return WINMM_MAP_NOMEM;
2518             }
2519             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
2520         }
2521         return WINMM_MAP_OKMEM;
2522         /* case MCI_UNDO: */
2523     case MCI_UNFREEZE:
2524         switch (uDevType) {
2525         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
2526         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       break;
2527         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2528         }
2529         break;
2530     case MCI_UPDATE:
2531         switch (uDevType) {
2532         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16);  map = 0x000B1111B;      break;
2533         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2534         }
2535         break;
2536     case MCI_WHERE:
2537         switch (uDevType) {
2538         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       keep = TRUE;    break;
2539         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       keep = TRUE;    break;
2540         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2541         }
2542         break;
2543     case MCI_WINDOW:
2544         switch (uDevType) {
2545         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7FB;        break;
2546         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB;        break;
2547         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2548         }
2549         break;
2550     case DRV_OPEN:
2551         {
2552             LPMCI_OPEN_DRIVER_PARMSA  modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
2553             LPMCI_OPEN_DRIVER_PARMS16 modp16;
2554             char *ptr = HeapAlloc( GetProcessHeap(), 0,
2555                                   sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
2556
2557             if (ptr) {
2558                 *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
2559                 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2560                 modp16->wDeviceID = modp32a->wDeviceID;
2561                 modp16->lpstrParams = MapLS( modp32a->lpstrParams );
2562                 /* other fields are gonna be filled by the driver, don't copy them */
2563             } else {
2564                 return WINMM_MAP_NOMEM;
2565             }
2566             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
2567         }
2568         return WINMM_MAP_OKMEM;
2569     case DRV_LOAD:
2570     case DRV_ENABLE:
2571     case DRV_CLOSE:
2572     case DRV_DISABLE:
2573     case DRV_FREE:
2574     case DRV_CONFIGURE:
2575     case DRV_QUERYCONFIGURE:
2576     case DRV_INSTALL:
2577     case DRV_REMOVE:
2578     case DRV_EXITSESSION:
2579     case DRV_EXITAPPLICATION:
2580     case DRV_POWER:
2581         return WINMM_MAP_OK;
2582
2583     default:
2584         WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2585         return WINMM_MAP_MSGERROR;
2586     }
2587     return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
2588 }
2589
2590 /**************************************************************************
2591  *                      MCI_UnMapMsg32ATo16                     [internal]
2592  */
2593 static  WINMM_MapType   MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
2594 {
2595     int         size = 0;
2596     BOOLEAN     kept = FALSE;   /* there is no need to compute size when kept is FALSE */
2597     DWORD       map = 0;
2598
2599     switch (wMsg) {
2600     case MCI_BREAK:
2601         break;
2602         /* case MCI_CAPTURE */
2603     case MCI_CLOSE:
2604     case MCI_CLOSE_DRIVER:
2605     case MCI_CONFIGURE:
2606         break;
2607         /* case MCI_COPY: */
2608     case MCI_CUE:
2609         break;
2610         /* case MCI_CUT: */
2611     case MCI_DELETE:
2612         break;
2613         /* case MCI_ESCAPE: */
2614     case MCI_FREEZE:
2615         break;
2616     case MCI_GETDEVCAPS:
2617         kept = TRUE;
2618         size = sizeof(MCI_GETDEVCAPS_PARMS);
2619         break;
2620         /* case MCI_INDEX: */
2621     case MCI_INFO:
2622         {
2623             LPMCI_INFO_PARMS16 mip16  = (LPMCI_INFO_PARMS16)MapSL(lParam);
2624             UnMapLS( lParam );
2625             UnMapLS( mip16->lpstrReturn );
2626             HeapFree( GetProcessHeap(), 0, mip16 );
2627         }
2628         return WINMM_MAP_OK;
2629         /* case MCI_MARK: */
2630         /* case MCI_MONITOR: */
2631     case MCI_OPEN:
2632     case MCI_OPEN_DRIVER:
2633         if (lParam) {
2634             LPMCI_OPEN_PARMS16  mop16  = (LPMCI_OPEN_PARMS16)MapSL(lParam);
2635             LPMCI_OPEN_PARMSA   mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
2636             UnMapLS( lParam );
2637             mop32a->wDeviceID = mop16->wDeviceID;
2638             if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
2639                 UnMapLS( mop16->lpstrDeviceType );
2640             if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
2641                 UnMapLS( mop16->lpstrElementName );
2642             if (dwFlags & MCI_OPEN_ALIAS)
2643                 UnMapLS( mop16->lpstrAlias );
2644             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
2645         }
2646         return WINMM_MAP_OK;
2647         /* case MCI_PASTE:*/
2648     case MCI_PAUSE:
2649         break;
2650     case MCI_PLAY:
2651         break;
2652     case MCI_PUT:
2653         break;
2654     case MCI_REALIZE:
2655         break;
2656     case MCI_RECORD:
2657         break;
2658     case MCI_RESUME:
2659         break;
2660     case MCI_SEEK:
2661         break;
2662     case MCI_SET:
2663         break;
2664     case MCI_SETAUDIO:
2665         switch (uDevType) {
2666         case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF;      break;
2667         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2668         }
2669         break;
2670         /* case MCI_SETTIMECODE:*/
2671         /* case MCI_SIGNAL:*/
2672         /* case MCI_SOUND:*/
2673     case MCI_SPIN:
2674         break;
2675     case MCI_STATUS:
2676         kept = TRUE;
2677         switch (uDevType) {
2678         case MCI_DEVTYPE_DIGITAL_VIDEO:
2679         if (lParam) {
2680             LPMCI_DGV_STATUS_PARMS16    mdsp16  = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
2681             LPMCI_DGV_STATUS_PARMSA     mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
2682
2683             UnMapLS( lParam );
2684             if (mdsp16) {
2685                 mdsp32a->dwReturn = mdsp16->dwReturn;
2686                 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2687                     TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
2688                     TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
2689                     UnMapLS( mdsp16->lpstrDrive );
2690                 }
2691                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
2692             } else {
2693                 return WINMM_MAP_NOMEM;
2694             }
2695         }
2696         return WINMM_MAP_OKMEM;
2697         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2698         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2699         }
2700         break;
2701     case MCI_STEP:
2702         break;
2703     case MCI_STOP:
2704         break;
2705     case MCI_SYSINFO:
2706         if (lParam) {
2707             LPMCI_SYSINFO_PARMS16       msip16  = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
2708             LPMCI_SYSINFO_PARMSA        msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
2709
2710             UnMapLS( lParam );
2711             if (msip16) {
2712                 msip16->dwCallback = msip32a->dwCallback;
2713                 UnMapLS( msip16->lpstrReturn );
2714                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
2715             } else {
2716                 return WINMM_MAP_NOMEM;
2717             }
2718         }
2719         return WINMM_MAP_OKMEM;
2720         /* case MCI_UNDO: */
2721     case MCI_UNFREEZE:
2722         break;
2723     case MCI_UPDATE:
2724         break;
2725     case MCI_WHERE:
2726         switch (uDevType) {
2727         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       kept = TRUE;    break;
2728         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       kept = TRUE;    break;
2729         default:                        break;
2730         }
2731         break;
2732     case MCI_WINDOW:
2733         switch (uDevType) {
2734         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7666;       break;
2735         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666;       break;
2736         default:                        break;
2737         }
2738         /* FIXME: see map function */
2739         break;
2740
2741     case DRV_OPEN:
2742         if (lParam) {
2743             LPMCI_OPEN_DRIVER_PARMS16   modp16  = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
2744             LPMCI_OPEN_DRIVER_PARMSA    modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2745
2746             UnMapLS( lParam );
2747             modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
2748             modp32a->wType = modp16->wType;
2749             UnMapLS( modp16->lpstrParams );
2750             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
2751         }
2752         return WINMM_MAP_OK;
2753     case DRV_LOAD:
2754     case DRV_ENABLE:
2755     case DRV_CLOSE:
2756     case DRV_DISABLE:
2757     case DRV_FREE:
2758     case DRV_CONFIGURE:
2759     case DRV_QUERYCONFIGURE:
2760     case DRV_INSTALL:
2761     case DRV_REMOVE:
2762     case DRV_EXITSESSION:
2763     case DRV_EXITAPPLICATION:
2764     case DRV_POWER:
2765         FIXME("This is a hack\n");
2766         return WINMM_MAP_OK;
2767     default:
2768         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2769         return WINMM_MAP_MSGERROR;
2770     }
2771     return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
2772 }
2773
2774 void    MMDRV_Init16(void)
2775 {
2776 #define A(_x,_y) MMDRV_InstallMap(_x, \
2777 MMDRV_##_y##_Map16To32A, MMDRV_##_y##_UnMap16To32A, \
2778 MMDRV_##_y##_Map32ATo16, MMDRV_##_y##_UnMap32ATo16, \
2779 MMDRV_##_y##_Callback)
2780     A(MMDRV_AUX,        Aux);
2781     A(MMDRV_MIXER,      Mixer);
2782     A(MMDRV_MIDIIN,     MidiIn);
2783     A(MMDRV_MIDIOUT,    MidiOut);
2784     A(MMDRV_WAVEIN,     WaveIn);
2785     A(MMDRV_WAVEOUT,    WaveOut);
2786 #undef A
2787
2788     pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
2789     pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
2790
2791     pFnMciMapMsg16To32A   = MCI_MapMsg16To32A;
2792     pFnMciUnMapMsg16To32A = MCI_UnMapMsg16To32A;
2793     pFnMciMapMsg32ATo16   = MCI_MapMsg32ATo16;
2794     pFnMciUnMapMsg32ATo16 = MCI_UnMapMsg32ATo16;
2795 }