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

   1 /*
   2  * MMSYSTEM MCI and low level mapping functions
   3  *
   4  * Copyright 1999 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <string.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <assert.h>
  25 #include "wine/winbase16.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "winver.h"
  30 #include "wownt32.h"
  31 #include "winemm16.h"
  32 #include "digitalv.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  36
  37 /**************************************************************************
  38  *                              MMDRV_Callback                  [internal]
  39  */
  40 static  void    MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
  41 {
  42     TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
  43           mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
  44
  45     if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION)
  46     {
  47         WORD args[8];
  48         /* 16 bit func, call it */
  49         TRACE("Function (16 bit) !\n");
  50
  51         args[7] = HDRVR_16(hDev);
  52         args[6] = uMsg;
  53         args[5] = HIWORD(mld->dwClientInstance);
  54         args[4] = LOWORD(mld->dwClientInstance);
  55         args[3] = HIWORD(dwParam1);
  56         args[2] = LOWORD(dwParam1);
  57         args[1] = HIWORD(dwParam2);
  58         args[0] = LOWORD(dwParam2);
  59         WOWCallback16Ex( mld->dwCallback, WCB16_PASCAL, sizeof(args), args, NULL );
  60     } else {
  61         DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg,
  62                        mld->dwClientInstance, dwParam1, dwParam2);
  63     }
  64 }
  65
  66 /* =================================
  67  *       A U X    M A P P E R S
  68  * ================================= */
  69
  70 /**************************************************************************
  71  *                              MMDRV_Aux_Map16To32W            [internal]
  72  */
  73 static  WINMM_MapType   MMDRV_Aux_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
  74 {
  75     return WINMM_MAP_MSGERROR;
  76 }
  77
  78 /**************************************************************************
  79  *                              MMDRV_Aux_UnMap16To32W          [internal]
  80  */
  81 static  WINMM_MapType   MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
  82 {
  83     return WINMM_MAP_MSGERROR;
  84 }
  85
  86 /**************************************************************************
  87  *                              MMDRV_Aux_Map32WTo16            [internal]
  88  */
  89 static  WINMM_MapType   MMDRV_Aux_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
  90 {
  91     return WINMM_MAP_MSGERROR;
  92 }
  93
  94 /**************************************************************************
  95  *                              MMDRV_Aux_UnMap32WTo16          [internal]
  96  */
  97 static  WINMM_MapType   MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
  98 {
  99 #if 0
 100  case AUXDM_GETDEVCAPS:
 101     lpCaps->wMid = ac16.wMid;
 102     lpCaps->wPid = ac16.wPid;
 103     lpCaps->vDriverVersion = ac16.vDriverVersion;
 104     strcpy(lpCaps->szPname, ac16.szPname);
 105     lpCaps->wTechnology = ac16.wTechnology;
 106     lpCaps->dwSupport = ac16.dwSupport;
 107 #endif
 108     return WINMM_MAP_MSGERROR;
 109 }
 110
 111 /**************************************************************************
 112  *                              MMDRV_Aux_Callback              [internal]
 113  */
 114 static  void    CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 115 {
 116     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 117
 118     FIXME("NIY\n");
 119     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 120 }
 121
 122 /* =================================
 123  *     M I X E R  M A P P E R S
 124  * ================================= */
 125
 126 /**************************************************************************
 127  *                              xMMDRV_Mixer_Map16To32W         [internal]
 128  */
 129 static  WINMM_MapType   MMDRV_Mixer_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 130 {
 131     return WINMM_MAP_MSGERROR;
 132 }
 133
 134 /**************************************************************************
 135  *                              MMDRV_Mixer_UnMap16To32W        [internal]
 136  */
 137 static  WINMM_MapType   MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 138 {
 139 #if 0
 140     MIXERCAPSA  micA;
 141     UINT        ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
 142
 143     if (ret == MMSYSERR_NOERROR) {
 144         mixcaps->wMid           = micA.wMid;
 145         mixcaps->wPid           = micA.wPid;
 146         mixcaps->vDriverVersion = micA.vDriverVersion;
 147         strcpy(mixcaps->szPname, micA.szPname);
 148         mixcaps->fdwSupport     = micA.fdwSupport;
 149         mixcaps->cDestinations  = micA.cDestinations;
 150     }
 151     return ret;
 152 #endif
 153     return WINMM_MAP_MSGERROR;
 154 }
 155
 156 /**************************************************************************
 157  *                              MMDRV_Mixer_Map32WTo16          [internal]
 158  */
 159 static  WINMM_MapType   MMDRV_Mixer_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 160 {
 161     return WINMM_MAP_MSGERROR;
 162 }
 163
 164 /**************************************************************************
 165  *                              MMDRV_Mixer_UnMap32WTo16        [internal]
 166  */
 167 static  WINMM_MapType   MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 168 {
 169     return WINMM_MAP_MSGERROR;
 170 }
 171
 172 /**************************************************************************
 173  *                              MMDRV_Mixer_Callback            [internal]
 174  */
 175 static  void    CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 176 {
 177     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 178
 179     FIXME("NIY\n");
 180     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 181 }
 182
 183 /* =================================
 184  *   M I D I  I N    M A P P E R S
 185  * ================================= */
 186
 187 /**************************************************************************
 188  *                              MMDRV_MidiIn_Map16To32W         [internal]
 189  */
 190 static  WINMM_MapType   MMDRV_MidiIn_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 191 {
 192     return WINMM_MAP_MSGERROR;
 193 }
 194
 195 /**************************************************************************
 196  *                              MMDRV_MidiIn_UnMap16To32W       [internal]
 197  */
 198 static  WINMM_MapType   MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 199 {
 200     return WINMM_MAP_MSGERROR;
 201 }
 202
 203 /**************************************************************************
 204  *                              MMDRV_MidiIn_Map32WTo16         [internal]
 205  */
 206 static  WINMM_MapType   MMDRV_MidiIn_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 207 {
 208     return WINMM_MAP_MSGERROR;
 209 }
 210
 211 /**************************************************************************
 212  *                              MMDRV_MidiIn_UnMap32WTo16       [internal]
 213  */
 214 static  WINMM_MapType   MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 215 {
 216     return WINMM_MAP_MSGERROR;
 217 }
 218
 219 /**************************************************************************
 220  *                              MMDRV_MidiIn_Callback           [internal]
 221  */
 222 static  void    CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 223 {
 224     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 225
 226     switch (uMsg) {
 227     case MIM_OPEN:
 228     case MIM_CLOSE:
 229         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 230
 231     case MIM_DATA:
 232     case MIM_MOREDATA:
 233     case MIM_ERROR:
 234         /* dwParam1 & dwParam2 are data, nothing to do */
 235         break;
 236     case MIM_LONGDATA:
 237     case MIM_LONGERROR:
 238         /* dwParam1 points to a MidiHdr, work to be done !!! */
 239         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
 240             /* initial map is: 32 => 16 */
 241             LPMIDIHDR           mh16 = MapSL(dwParam1);
 242             LPMIDIHDR           mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
 243
 244             dwParam1 = (DWORD)mh32;
 245             mh32->dwFlags = mh16->dwFlags;
 246             mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 247             if (mh32->reserved >= sizeof(MIDIHDR))
 248                 mh32->dwOffset = mh16->dwOffset;
 249         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
 250             /* initial map is: 16 => 32 */
 251             LPMIDIHDR           mh32 = (LPMIDIHDR)(dwParam1);
 252             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 253             LPMIDIHDR           mh16 = MapSL(segmh16);
 254
 255             dwParam1 = (DWORD)segmh16;
 256             mh16->dwFlags = mh32->dwFlags;
 257             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 258             if (mh16->reserved >= sizeof(MIDIHDR))
 259                 mh16->dwOffset = mh32->dwOffset;
 260         }
 261         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
 262         break;
 263     /* case MOM_POSITIONCB: */
 264     default:
 265         ERR("Unknown msg %u\n", uMsg);
 266     }
 267
 268     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 269 }
 270
 271 /* =================================
 272  *   M I D I  O U T  M A P P E R S
 273  * ================================= */
 274
 275 /**************************************************************************
 276  *                              MMDRV_MidiOut_Map16To32W        [internal]
 277  */
 278 static  WINMM_MapType   MMDRV_MidiOut_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 279 {
 280     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 281
 282     switch (wMsg) {
 283     case MODM_GETNUMDEVS:
 284     case MODM_DATA:
 285     case MODM_RESET:
 286     case MODM_SETVOLUME:
 287         ret = WINMM_MAP_OK;
 288         break;
 289
 290     case MODM_OPEN:
 291     case MODM_CLOSE:
 292     case MODM_GETVOLUME:
 293         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 294         break;
 295
 296     case MODM_GETDEVCAPS:
 297         {
 298             LPMIDIOUTCAPSW      moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW));
 299             LPMIDIOUTCAPS16     moc16 = MapSL(*lpParam1);
 300
 301             if (moc32) {
 302                 *(LPMIDIOUTCAPS16*)moc32 = moc16;
 303                 moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
 304                 *lpParam1 = (DWORD)moc32;
 305                 *lpParam2 = sizeof(MIDIOUTCAPSW);
 306
 307                 ret = WINMM_MAP_OKMEM;
 308             } else {
 309                 ret = WINMM_MAP_NOMEM;
 310             }
 311         }
 312         break;
 313     case MODM_PREPARE:
 314         {
 315             LPMIDIHDR           mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
 316             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 317
 318             if (mh32) {
 319                 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
 320                 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
 321                 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
 322                 mh32->dwBufferLength = mh16->dwBufferLength;
 323                 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 324                 mh32->dwUser = mh16->dwUser;
 325                 mh32->dwFlags = mh16->dwFlags;
 326                 /* FIXME: nothing on mh32->lpNext */
 327                 /* could link the mh32->lpNext at this level for memory house keeping */
 328                 mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0;
 329                 mh16->lpNext = mh32; /* for reuse in unprepare and write */
 330                 /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
 331                 mh16->reserved = *lpParam2;
 332                 *lpParam1 = (DWORD)mh32;
 333                 *lpParam2 = sizeof(MIDIHDR);
 334
 335                 ret = WINMM_MAP_OKMEM;
 336             } else {
 337                 ret = WINMM_MAP_NOMEM;
 338             }
 339         }
 340         break;
 341     case MODM_UNPREPARE:
 342     case MODM_LONGDATA:
 343         {
 344             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 345             LPMIDIHDR           mh32 = (LPMIDIHDR)mh16->lpNext;
 346
 347             *lpParam1 = (DWORD)mh32;
 348             *lpParam2 = sizeof(MIDIHDR);
 349             /* dwBufferLength can be reduced between prepare & write */
 350             if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
 351                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
 352                     mh32->dwBufferLength, mh16->dwBufferLength);
 353             } else
 354                 mh32->dwBufferLength = mh16->dwBufferLength;
 355             ret = WINMM_MAP_OKMEM;
 356         }
 357         break;
 358
 359     case MODM_CACHEPATCHES:
 360     case MODM_CACHEDRUMPATCHES:
 361     default:
 362         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 363         break;
 364     }
 365     return ret;
 366 }
 367
 368 /**************************************************************************
 369  *                              MMDRV_MidiOut_UnMap16To32W      [internal]
 370  */
 371 static  WINMM_MapType   MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 372 {
 373     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 374
 375     switch (wMsg) {
 376     case MODM_GETNUMDEVS:
 377     case MODM_DATA:
 378     case MODM_RESET:
 379     case MODM_SETVOLUME:
 380         ret = WINMM_MAP_OK;
 381         break;
 382
 383     case MODM_OPEN:
 384     case MODM_CLOSE:
 385     case MODM_GETVOLUME:
 386         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 387         break;
 388
 389     case MODM_GETDEVCAPS:
 390         {
 391             LPMIDIOUTCAPSW              moc32 = (LPMIDIOUTCAPSW)(*lpParam1);
 392             LPMIDIOUTCAPS16             moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
 393
 394             moc16->wMid                 = moc32->wMid;
 395             moc16->wPid                 = moc32->wPid;
 396             moc16->vDriverVersion       = moc32->vDriverVersion;
 397             WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
 398                                  sizeof(moc16->szPname), NULL, NULL );
 399             moc16->wTechnology          = moc32->wTechnology;
 400             moc16->wVoices              = moc32->wVoices;
 401             moc16->wNotes               = moc32->wNotes;
 402             moc16->wChannelMask         = moc32->wChannelMask;
 403             moc16->dwSupport            = moc32->dwSupport;
 404             HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
 405             ret = WINMM_MAP_OK;
 406         }
 407         break;
 408     case MODM_PREPARE:
 409     case MODM_UNPREPARE:
 410     case MODM_LONGDATA:
 411         {
 412             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
 413             LPMIDIHDR           mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
 414
 415             assert(mh16->lpNext == mh32);
 416             mh16->dwBufferLength = mh32->dwBufferLength;
 417             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 418             mh16->dwUser = mh32->dwUser;
 419             mh16->dwFlags = mh32->dwFlags;
 420             if (mh16->reserved >= sizeof(MIDIHDR))
 421                 mh16->dwOffset = mh32->dwOffset;
 422
 423             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 424                 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
 425                 mh16->lpNext = 0;
 426             }
 427             ret = WINMM_MAP_OK;
 428         }
 429         break;
 430
 431     case MODM_CACHEPATCHES:
 432     case MODM_CACHEDRUMPATCHES:
 433     default:
 434         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 435         break;
 436     }
 437     return ret;
 438 }
 439
 440 /**************************************************************************
 441  *                              MMDRV_MidiOut_Map32WTo16        [internal]
 442  */
 443 static  WINMM_MapType   MMDRV_MidiOut_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 444 {
 445     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 446
 447     switch (wMsg) {
 448     case MODM_CLOSE:
 449     case MODM_GETNUMDEVS:
 450     case MODM_DATA:
 451     case MODM_RESET:
 452     case MODM_SETVOLUME:
 453         ret = WINMM_MAP_OK;
 454         break;
 455     case MODM_GETDEVCAPS:
 456         {
 457             LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)*lpParam1;
 458             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSW)+sizeof(MIDIOUTCAPS16));
 459
 460             if (ptr) {
 461                 *(LPMIDIOUTCAPSW*)ptr = moc32;
 462                 ret = WINMM_MAP_OKMEM;
 463             } else {
 464                 ret = WINMM_MAP_NOMEM;
 465             }
 466             *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSW);
 467             *lpParam2 = sizeof(MIDIOUTCAPS16);
 468         }
 469         break;
 470     case MODM_PREPARE:
 471         {
 472             LPMIDIHDR           mh32 = (LPMIDIHDR)*lpParam1;
 473             LPMIDIHDR           mh16;
 474             LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
 475                                     sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength);
 476
 477             if (ptr) {
 478                 *(LPMIDIHDR*)ptr = mh32;
 479                 mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR));
 480                 *lpParam1 = MapLS(mh16);
 481                 mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR);
 482                 /* data will be copied on WODM_WRITE */
 483                 mh16->dwBufferLength = mh32->dwBufferLength;
 484                 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
 485                 mh16->dwUser = mh32->dwUser;
 486                 mh16->dwFlags = mh32->dwFlags;
 487                 /* FIXME: nothing on mh32->lpNext */
 488                 /* could link the mh32->lpNext at this level for memory house keeping */
 489                 mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0;
 490
 491                 mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */
 492                 mh32->reserved = *lpParam2;
 493
 494                 TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
 495                       *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
 496                 *lpParam2 = sizeof(MIDIHDR);
 497
 498                 ret = WINMM_MAP_OKMEM;
 499             } else {
 500                 ret = WINMM_MAP_NOMEM;
 501             }
 502         }
 503         break;
 504     case MODM_UNPREPARE:
 505     case MODM_LONGDATA:
 506         {
 507             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
 508             LPMIDIHDR           mh16 = (LPMIDIHDR)mh32->lpNext;
 509             LPSTR               ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
 510
 511             assert(*(LPMIDIHDR*)ptr == mh32);
 512
 513             if (wMsg == MODM_LONGDATA)
 514                 memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
 515
 516             *lpParam1 = MapLS(mh16);
 517             *lpParam2 = sizeof(MIDIHDR);
 518             TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
 519                   *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
 520
 521             /* dwBufferLength can be reduced between prepare & write */
 522             if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
 523                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
 524                     mh16->dwBufferLength, mh32->dwBufferLength);
 525             } else
 526                 mh16->dwBufferLength = mh32->dwBufferLength;
 527             ret = WINMM_MAP_OKMEM;
 528         }
 529         break;
 530     case MODM_OPEN:
 531         {
 532             LPMIDIOPENDESC              mod32 = (LPMIDIOPENDESC)*lpParam1;
 533             LPVOID                      ptr;
 534             LPMIDIOPENDESC16            mod16;
 535
 536             /* allocated data are mapped as follows:
 537                LPMIDIOPENDESC   ptr to orig lParam1
 538                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
 539                DWORD            dwUser passed to driver
 540                MIDIOPENDESC16   mod16: openDesc passed to driver
 541                MIDIOPENSTRMID   cIds
 542             */
 543             ptr = HeapAlloc( GetProcessHeap(), 0,
 544                              sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
 545                              mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
 546
 547             if (ptr) {
 548                 SEGPTR segptr = MapLS(ptr);
 549                 *(LPMIDIOPENDESC*)ptr = mod32;
 550                 *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
 551                 mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
 552
 553                 mod16->hMidi = HMIDI_16(mod32->hMidi);
 554                 mod16->dwCallback = mod32->dwCallback;
 555                 mod16->dwInstance = mod32->dwInstance;
 556                 mod16->dnDevNode = mod32->dnDevNode;
 557                 mod16->cIds = mod32->cIds;
 558                 memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
 559
 560                 *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
 561                 *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
 562
 563                 ret = WINMM_MAP_OKMEM;
 564             } else {
 565                 ret = WINMM_MAP_NOMEM;
 566             }
 567         }
 568         break;
 569     case MODM_GETVOLUME:
 570     case MODM_CACHEPATCHES:
 571     case MODM_CACHEDRUMPATCHES:
 572     default:
 573         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 574         break;
 575     }
 576     return ret;
 577 }
 578
 579 /**************************************************************************
 580  *                              MMDRV_MidiOut_UnMap32WTo16      [internal]
 581  */
 582 static  WINMM_MapType   MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 583 {
 584     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 585
 586     switch (wMsg) {
 587     case MODM_CLOSE:
 588     case MODM_GETNUMDEVS:
 589     case MODM_DATA:
 590     case MODM_RESET:
 591     case MODM_SETVOLUME:
 592         ret = WINMM_MAP_OK;
 593         break;
 594     case MODM_GETDEVCAPS:
 595         {
 596             LPMIDIOUTCAPS16             moc16 = MapSL(*lpParam1);
 597             LPSTR                       ptr   = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSW);
 598             LPMIDIOUTCAPSW              moc32 = *(LPMIDIOUTCAPSW*)ptr;
 599
 600             moc32->wMid                 = moc16->wMid;
 601             moc32->wPid                 = moc16->wPid;
 602             moc32->vDriverVersion       = moc16->vDriverVersion;
 603             WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
 604                                  sizeof(moc16->szPname), NULL, NULL );
 605             moc32->wTechnology          = moc16->wTechnology;
 606             moc32->wVoices              = moc16->wVoices;
 607             moc32->wNotes               = moc16->wNotes;
 608             moc32->wChannelMask         = moc16->wChannelMask;
 609             moc32->dwSupport            = moc16->dwSupport;
 610             UnMapLS( *lpParam1 );
 611             HeapFree( GetProcessHeap(), 0, ptr );
 612             ret = WINMM_MAP_OK;
 613         }
 614         break;
 615     case MODM_PREPARE:
 616     case MODM_UNPREPARE:
 617     case MODM_LONGDATA:
 618         {
 619             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 620             LPSTR               ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
 621             LPMIDIHDR           mh32 = *(LPMIDIHDR*)ptr;
 622
 623             assert(mh32->lpNext == (LPMIDIHDR)mh16);
 624             UnMapLS( *lpParam1 );
 625             mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 626             mh32->dwUser = mh16->dwUser;
 627             mh32->dwFlags = mh16->dwFlags;
 628
 629             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 630                 HeapFree( GetProcessHeap(), 0, ptr );
 631                 mh32->lpNext = 0;
 632             }
 633             ret = WINMM_MAP_OK;
 634         }
 635         break;
 636     case MODM_OPEN:
 637         {
 638             LPMIDIOPENDESC16            mod16 = MapSL(*lpParam1);
 639             LPSTR                       ptr   = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
 640             UnMapLS( *lpParam1 );
 641             **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
 642
 643             HeapFree( GetProcessHeap(), 0, ptr );
 644             ret = WINMM_MAP_OK;
 645         }
 646         break;
 647     case MODM_GETVOLUME:
 648     case MODM_CACHEPATCHES:
 649     case MODM_CACHEDRUMPATCHES:
 650     default:
 651         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 652         break;
 653     }
 654     return ret;
 655 }
 656
 657 /**************************************************************************
 658  *                              MMDRV_MidiOut_Callback          [internal]
 659  */
 660 static  void    CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 661 {
 662     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 663
 664     switch (uMsg) {
 665     case MOM_OPEN:
 666     case MOM_CLOSE:
 667         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 668         break;
 669     case MOM_DONE:
 670         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
 671             /* initial map is: 32 => 16 */
 672             LPMIDIHDR           mh16 = MapSL(dwParam1);
 673             LPMIDIHDR           mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
 674
 675             dwParam1 = (DWORD)mh32;
 676             mh32->dwFlags = mh16->dwFlags;
 677             mh32->dwOffset = mh16->dwOffset;
 678             if (mh32->reserved >= sizeof(MIDIHDR))
 679                 mh32->dwOffset = mh16->dwOffset;
 680         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
 681             /* initial map is: 16 => 32 */
 682             LPMIDIHDR           mh32 = (LPMIDIHDR)(dwParam1);
 683             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 684             LPMIDIHDR           mh16 = MapSL(segmh16);
 685
 686             dwParam1 = (DWORD)segmh16;
 687             mh16->dwFlags = mh32->dwFlags;
 688             if (mh16->reserved >= sizeof(MIDIHDR))
 689                 mh16->dwOffset = mh32->dwOffset;
 690         }
 691         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
 692         break;
 693     /* case MOM_POSITIONCB: */
 694     default:
 695         ERR("Unknown msg %u\n", uMsg);
 696     }
 697
 698     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 699 }
 700
 701 /* =================================
 702  *   W A V E  I N    M A P P E R S
 703  * ================================= */
 704
 705 /**************************************************************************
 706  *                              MMDRV_WaveIn_Map16To32W         [internal]
 707  */
 708 static  WINMM_MapType   MMDRV_WaveIn_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
 709 {
 710     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 711
 712     switch (wMsg) {
 713     case WIDM_GETNUMDEVS:
 714     case WIDM_RESET:
 715     case WIDM_START:
 716     case WIDM_STOP:
 717         ret = WINMM_MAP_OK;
 718         break;
 719     case WIDM_OPEN:
 720     case WIDM_CLOSE:
 721         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 722         break;
 723     case WIDM_GETDEVCAPS:
 724         {
 725             LPWAVEINCAPSW       wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
 726             LPWAVEINCAPS16      wic16 = MapSL(*lpParam1);
 727
 728             if (wic32) {
 729                 *(LPWAVEINCAPS16*)wic32 = wic16;
 730                 wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
 731                 *lpParam1 = (DWORD)wic32;
 732                 *lpParam2 = sizeof(WAVEINCAPSW);
 733
 734                 ret = WINMM_MAP_OKMEM;
 735             } else {
 736                 ret = WINMM_MAP_NOMEM;
 737             }
 738         }
 739         break;
 740     case WIDM_GETPOS:
 741         {
 742             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
 743             LPMMTIME16          mmt16 = MapSL(*lpParam1);
 744
 745             if (mmt32) {
 746                 *(LPMMTIME16*)mmt32 = mmt16;
 747                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
 748
 749                 mmt32->wType = mmt16->wType;
 750                 *lpParam1 = (DWORD)mmt32;
 751                 *lpParam2 = sizeof(MMTIME);
 752
 753                 ret = WINMM_MAP_OKMEM;
 754             } else {
 755                 ret = WINMM_MAP_NOMEM;
 756             }
 757         }
 758         break;
 759     case WIDM_PREPARE:
 760         {
 761             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
 762             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 763
 764             if (wh32) {
 765                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
 766                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
 767                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
 768                 wh32->dwBufferLength = wh16->dwBufferLength;
 769                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
 770                 wh32->dwUser = wh16->dwUser;
 771                 wh32->dwFlags = wh16->dwFlags;
 772                 wh32->dwLoops = wh16->dwLoops;
 773                 /* FIXME: nothing on wh32->lpNext */
 774                 /* could link the wh32->lpNext at this level for memory house keeping */
 775                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
 776                 *lpParam1 = (DWORD)wh32;
 777                 *lpParam2 = sizeof(WAVEHDR);
 778
 779                 ret = WINMM_MAP_OKMEM;
 780             } else {
 781                 ret = WINMM_MAP_NOMEM;
 782             }
 783         }
 784         break;
 785     case WIDM_ADDBUFFER:
 786     case WIDM_UNPREPARE:
 787         {
 788             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 789             LPWAVEHDR           wh32 = (LPWAVEHDR)wh16->lpNext;
 790
 791             *lpParam1 = (DWORD)wh32;
 792             *lpParam2 = sizeof(WAVEHDR);
 793             /* dwBufferLength can be reduced between prepare & write */
 794             if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
 795                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
 796                     wh32->dwBufferLength, wh16->dwBufferLength);
 797             } else
 798                 wh32->dwBufferLength = wh16->dwBufferLength;
 799             ret = WINMM_MAP_OKMEM;
 800         }
 801         break;
 802     case WIDM_MAPPER_STATUS:
 803         /* just a single DWORD */
 804         *lpParam2 = (DWORD)MapSL(*lpParam2);
 805         ret = WINMM_MAP_OK;
 806         break;
 807     default:
 808         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 809         break;
 810     }
 811     return ret;
 812 }
 813
 814 /**************************************************************************
 815  *                              MMDRV_WaveIn_UnMap16To32W       [internal]
 816  */
 817 static  WINMM_MapType   MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
 818 {
 819     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 820
 821     switch (wMsg) {
 822     case WIDM_GETNUMDEVS:
 823     case WIDM_RESET:
 824     case WIDM_START:
 825     case WIDM_STOP:
 826     case WIDM_MAPPER_STATUS:
 827         ret = WINMM_MAP_OK;
 828         break;
 829     case WIDM_OPEN:
 830     case WIDM_CLOSE:
 831         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 832         break;
 833     case WIDM_GETDEVCAPS:
 834         {
 835             LPWAVEINCAPSW               wic32 = (LPWAVEINCAPSW)(*lpParam1);
 836             LPWAVEINCAPS16              wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 837
 838             wic16->wMid = wic32->wMid;
 839             wic16->wPid = wic32->wPid;
 840             wic16->vDriverVersion = wic32->vDriverVersion;
 841             WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
 842                                  sizeof(wic16->szPname), NULL, NULL );
 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_Map32WTo16         [internal]
 889  */
 890 static  WINMM_MapType   MMDRV_WaveIn_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* 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                 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
 972                 *lpParam2 = sizeof(WAVEHDR);
 973                 TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
 974                       *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
 975
 976                 ret = WINMM_MAP_OKMEM;
 977             } else {
 978                 ret = WINMM_MAP_NOMEM;
 979             }
 980         }
 981         break;
 982     case WIDM_ADDBUFFER:
 983     case WIDM_UNPREPARE:
 984         {
 985             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 986             LPWAVEHDR           wh16 = wh32->lpNext;
 987             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
 988             SEGPTR seg_ptr = MapLS( ptr );
 989
 990             assert(*(LPWAVEHDR*)ptr == wh32);
 991
 992             if (wMsg == WIDM_ADDBUFFER)
 993                 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
 994
 995             *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
 996             *lpParam2 = sizeof(WAVEHDR);
 997             TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
 998                   *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
 999
1000             /* dwBufferLength can be reduced between prepare & write */
1001             if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
1002                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
1003                     wh16->dwBufferLength, wh32->dwBufferLength);
1004             } else
1005                 wh16->dwBufferLength = wh32->dwBufferLength;
1006             ret = WINMM_MAP_OKMEM;
1007         }
1008         break;
1009    case WIDM_GETDEVCAPS:
1010         {
1011             LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)*lpParam1;
1012             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSW) + sizeof(WAVEINCAPS16));
1013
1014             if (ptr) {
1015                 *(LPWAVEINCAPSW*)ptr = wic32;
1016                 ret = WINMM_MAP_OKMEM;
1017             } else {
1018                 ret = WINMM_MAP_NOMEM;
1019             }
1020             *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSW);
1021             *lpParam2 = sizeof(WAVEINCAPS16);
1022         }
1023         break;
1024     case WIDM_GETPOS:
1025         {
1026             LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1027             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1028             LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1029
1030             if (ptr) {
1031                 *(LPMMTIME*)ptr = mmt32;
1032                 mmt16->wType = mmt32->wType;
1033                 ret = WINMM_MAP_OKMEM;
1034             } else {
1035                 ret = WINMM_MAP_NOMEM;
1036             }
1037             *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1038             *lpParam2 = sizeof(MMTIME16);
1039         }
1040         break;
1041     case DRVM_MAPPER_STATUS:
1042         {
1043             LPDWORD p32 = (LPDWORD)*lpParam2;
1044             *lpParam2 = MapLS(p32);
1045             ret = WINMM_MAP_OKMEM;
1046         }
1047         break;
1048     default:
1049         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1050         break;
1051     }
1052     return ret;
1053 }
1054
1055 /**************************************************************************
1056  *                              MMDRV_WaveIn_UnMap32WTo16       [internal]
1057  */
1058 static  WINMM_MapType   MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
1059 {
1060     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1061
1062     switch (wMsg) {
1063     case WIDM_CLOSE:
1064     case WIDM_GETNUMDEVS:
1065     case WIDM_RESET:
1066     case WIDM_START:
1067     case WIDM_STOP:
1068         ret = WINMM_MAP_OK;
1069         break;
1070
1071     case WIDM_OPEN:
1072         {
1073             LPWAVEOPENDESC16            wod16 = MapSL(*lpParam1);
1074             LPSTR                       ptr   = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1075             LPWAVEOPENDESC              wod32 = *(LPWAVEOPENDESC*)ptr;
1076
1077             UnMapLS( *lpParam1 );
1078             wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1079             **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1080             HeapFree( GetProcessHeap(), 0, ptr );
1081             ret = WINMM_MAP_OK;
1082         }
1083         break;
1084
1085     case WIDM_ADDBUFFER:
1086     case WIDM_PREPARE:
1087     case WIDM_UNPREPARE:
1088         {
1089             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1090             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1091             LPWAVEHDR           wh32 = *(LPWAVEHDR*)ptr;
1092
1093             assert(wh32->lpNext == wh16);
1094             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1095             wh32->dwUser = wh16->dwUser;
1096             wh32->dwFlags = wh16->dwFlags;
1097             wh32->dwLoops = wh16->dwLoops;
1098             UnMapLS( *lpParam1 );
1099
1100             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1101                 HeapFree( GetProcessHeap(), 0, ptr );
1102                 wh32->lpNext = 0;
1103             }
1104             ret = WINMM_MAP_OK;
1105         }
1106         break;
1107      case WIDM_GETDEVCAPS:
1108         {
1109             LPWAVEINCAPS16              wic16 = MapSL(*lpParam1);
1110             LPSTR                       ptr   = (LPSTR)wic16 - sizeof(LPWAVEINCAPSW);
1111             LPWAVEINCAPSW               wic32 = *(LPWAVEINCAPSW*)ptr;
1112
1113             wic32->wMid = wic16->wMid;
1114             wic32->wPid = wic16->wPid;
1115             wic32->vDriverVersion = wic16->vDriverVersion;
1116             WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
1117                                  sizeof(wic16->szPname), NULL, NULL );
1118             wic32->dwFormats = wic16->dwFormats;
1119             wic32->wChannels = wic16->wChannels;
1120             UnMapLS( *lpParam1 );
1121             HeapFree( GetProcessHeap(), 0, ptr );
1122             ret = WINMM_MAP_OK;
1123         }
1124         break;
1125     case WIDM_GETPOS:
1126         {
1127             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1128             LPSTR               ptr   = (LPSTR)mmt16 - sizeof(LPMMTIME);
1129             LPMMTIME            mmt32 = *(LPMMTIME*)ptr;
1130
1131             MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1132             UnMapLS( *lpParam1 );
1133             HeapFree( GetProcessHeap(), 0, ptr );
1134             ret = WINMM_MAP_OK;
1135         }
1136         break;
1137     case DRVM_MAPPER_STATUS:
1138         {
1139             UnMapLS( *lpParam2 );
1140             ret = WINMM_MAP_OK;
1141         }
1142         break;
1143     default:
1144         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1145         break;
1146     }
1147     return ret;
1148 }
1149
1150 /**************************************************************************
1151  *                              MMDRV_WaveIn_Callback           [internal]
1152  */
1153 static  void    CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1154 {
1155     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
1156
1157     switch (uMsg) {
1158     case WIM_OPEN:
1159     case WIM_CLOSE:
1160         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1161         break;
1162     case WIM_DATA:
1163         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1164             /* initial map is: 32 => 16 */
1165             LPWAVEHDR           wh16 = MapSL(dwParam1);
1166             LPWAVEHDR           wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1167
1168             dwParam1 = (DWORD)wh32;
1169             wh32->dwFlags = wh16->dwFlags;
1170             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1171         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1172             /* initial map is: 16 => 32 */
1173             LPWAVEHDR           wh32 = (LPWAVEHDR)(dwParam1);
1174             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1175             LPWAVEHDR           wh16 = MapSL(segwh16);
1176
1177             dwParam1 = (DWORD)segwh16;
1178             wh16->dwFlags = wh32->dwFlags;
1179             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1180         }
1181         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1182         break;
1183     default:
1184         ERR("Unknown msg %u\n", uMsg);
1185     }
1186
1187     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1188 }
1189
1190 /* =================================
1191  *   W A V E  O U T  M A P P E R S
1192  * ================================= */
1193
1194 /**************************************************************************
1195  *                              MMDRV_WaveOut_Map16To32W        [internal]
1196  */
1197 static  WINMM_MapType   MMDRV_WaveOut_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
1198 {
1199     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1200
1201     switch (wMsg) {
1202     /* nothing to do */
1203     case WODM_BREAKLOOP:
1204     case WODM_CLOSE:
1205     case WODM_GETNUMDEVS:
1206     case WODM_PAUSE:
1207     case WODM_RESET:
1208     case WODM_RESTART:
1209     case WODM_SETPITCH:
1210     case WODM_SETPLAYBACKRATE:
1211     case WODM_SETVOLUME:
1212         ret = WINMM_MAP_OK;
1213         break;
1214
1215     case WODM_GETPITCH:
1216     case WODM_GETPLAYBACKRATE:
1217     case WODM_GETVOLUME:
1218     case WODM_OPEN:
1219         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
1220         break;
1221
1222     case WODM_GETDEVCAPS:
1223         {
1224             LPWAVEOUTCAPSW              woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
1225             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
1226
1227             if (woc32) {
1228                 *(LPWAVEOUTCAPS16*)woc32 = woc16;
1229                 woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
1230                 *lpParam1 = (DWORD)woc32;
1231                 *lpParam2 = sizeof(WAVEOUTCAPSW);
1232
1233                 ret = WINMM_MAP_OKMEM;
1234             } else {
1235                 ret = WINMM_MAP_NOMEM;
1236             }
1237         }
1238         break;
1239     case WODM_GETPOS:
1240         {
1241             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
1242             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1243
1244             if (mmt32) {
1245                 *(LPMMTIME16*)mmt32 = mmt16;
1246                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
1247
1248                 mmt32->wType = mmt16->wType;
1249                 *lpParam1 = (DWORD)mmt32;
1250                 *lpParam2 = sizeof(MMTIME);
1251
1252                 ret = WINMM_MAP_OKMEM;
1253             } else {
1254                 ret = WINMM_MAP_NOMEM;
1255             }
1256         }
1257         break;
1258     case WODM_PREPARE:
1259         {
1260             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
1261             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1262
1263             if (wh32) {
1264                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
1265                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
1266                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
1267                 wh32->dwBufferLength = wh16->dwBufferLength;
1268                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1269                 wh32->dwUser = wh16->dwUser;
1270                 wh32->dwFlags = wh16->dwFlags;
1271                 wh32->dwLoops = wh16->dwLoops;
1272                 /* FIXME: nothing on wh32->lpNext */
1273                 /* could link the wh32->lpNext at this level for memory house keeping */
1274                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
1275                 *lpParam1 = (DWORD)wh32;
1276                 *lpParam2 = sizeof(WAVEHDR);
1277
1278                 ret = WINMM_MAP_OKMEM;
1279             } else {
1280                 ret = WINMM_MAP_NOMEM;
1281             }
1282         }
1283         break;
1284     case WODM_UNPREPARE:
1285     case WODM_WRITE:
1286         {
1287             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1288             LPWAVEHDR           wh32 = (LPWAVEHDR)wh16->lpNext;
1289
1290             *lpParam1 = (DWORD)wh32;
1291             *lpParam2 = sizeof(WAVEHDR);
1292             /* dwBufferLength can be reduced between prepare & write */
1293             if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
1294                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
1295                     wh32->dwBufferLength, wh16->dwBufferLength);
1296             } else
1297                 wh32->dwBufferLength = wh16->dwBufferLength;
1298             ret = WINMM_MAP_OKMEM;
1299         }
1300         break;
1301     case WODM_MAPPER_STATUS:
1302         *lpParam2 = (DWORD)MapSL(*lpParam2);
1303         ret = WINMM_MAP_OK;
1304         break;
1305     default:
1306         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1307         break;
1308     }
1309     return ret;
1310 }
1311
1312 /**************************************************************************
1313  *                              MMDRV_WaveOut_UnMap16To32W      [internal]
1314  */
1315 static  WINMM_MapType   MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
1316 {
1317     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1318
1319     switch (wMsg) {
1320     /* nothing to do */
1321     case WODM_BREAKLOOP:
1322     case WODM_CLOSE:
1323     case WODM_GETNUMDEVS:
1324     case WODM_PAUSE:
1325     case WODM_RESET:
1326     case WODM_RESTART:
1327     case WODM_SETPITCH:
1328     case WODM_SETPLAYBACKRATE:
1329     case WODM_SETVOLUME:
1330     case WODM_MAPPER_STATUS:
1331         ret = WINMM_MAP_OK;
1332         break;
1333
1334     case WODM_GETPITCH:
1335     case WODM_GETPLAYBACKRATE:
1336     case WODM_GETVOLUME:
1337     case WODM_OPEN:
1338         FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
1339         break;
1340
1341     case WODM_GETDEVCAPS:
1342         {
1343             LPWAVEOUTCAPSW              woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
1344             LPWAVEOUTCAPS16             woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1345
1346             woc16->wMid = woc32->wMid;
1347             woc16->wPid = woc32->wPid;
1348             woc16->vDriverVersion = woc32->vDriverVersion;
1349             WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
1350                                  sizeof(woc16->szPname), NULL, NULL );
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_Map32WTo16        [internal]
1398  */
1399 static  WINMM_MapType   MMDRV_WaveOut_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* 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             LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)*lpParam1;
1420             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
1421                                    sizeof(LPWAVEOUTCAPSW) + sizeof(WAVEOUTCAPS16));
1422
1423             if (ptr) {
1424                 *(LPWAVEOUTCAPSW*)ptr = woc32;
1425                 ret = WINMM_MAP_OKMEM;
1426             } else {
1427                 ret = WINMM_MAP_NOMEM;
1428             }
1429             *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSW);
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                 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1531                 *lpParam2 = sizeof(WAVEHDR);
1532                 TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
1533                       *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
1534
1535                 ret = WINMM_MAP_OKMEM;
1536             } else {
1537                 ret = WINMM_MAP_NOMEM;
1538             }
1539         }
1540         break;
1541     case WODM_UNPREPARE:
1542     case WODM_WRITE:
1543         {
1544             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
1545             LPWAVEHDR           wh16 = wh32->lpNext;
1546             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1547             SEGPTR seg_ptr = MapLS( ptr );
1548
1549             assert(*(LPWAVEHDR*)ptr == wh32);
1550
1551             if (wMsg == WODM_WRITE)
1552                 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
1553
1554             *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1555             *lpParam2 = sizeof(WAVEHDR);
1556             TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
1557                   *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
1558
1559             /* dwBufferLength can be reduced between prepare & write */
1560             if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
1561                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
1562                     wh16->dwBufferLength, wh32->dwBufferLength);
1563             } else
1564                 wh16->dwBufferLength = wh32->dwBufferLength;
1565             ret = WINMM_MAP_OKMEM;
1566         }
1567         break;
1568     case DRVM_MAPPER_STATUS:
1569         {
1570             LPDWORD p32 = (LPDWORD)*lpParam2;
1571             *lpParam2 = MapLS(p32);
1572             ret = WINMM_MAP_OKMEM;
1573         }
1574         break;
1575     default:
1576         FIXME("NIY: no conversion yet\n");
1577         ret = WINMM_MAP_MSGERROR;
1578         break;
1579     }
1580     return ret;
1581 }
1582
1583 /**************************************************************************
1584  *                              MMDRV_WaveOut_UnMap32WTo16      [internal]
1585  */
1586 static  WINMM_MapType   MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
1587 {
1588     WINMM_MapType       ret;
1589
1590     switch (wMsg) {
1591         /* nothing to do */
1592     case WODM_BREAKLOOP:
1593     case WODM_CLOSE:
1594     case WODM_GETNUMDEVS:
1595     case WODM_PAUSE:
1596     case WODM_RESET:
1597     case WODM_RESTART:
1598     case WODM_SETPITCH:
1599     case WODM_SETPLAYBACKRATE:
1600     case WODM_SETVOLUME:
1601         ret = WINMM_MAP_OK;
1602         break;
1603
1604     case WODM_GETDEVCAPS:
1605         {
1606             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
1607             LPSTR                       ptr   = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSW);
1608             LPWAVEOUTCAPSW              woc32 = *(LPWAVEOUTCAPSW*)ptr;
1609
1610             woc32->wMid = woc16->wMid;
1611             woc32->wPid = woc16->wPid;
1612             woc32->vDriverVersion = woc16->vDriverVersion;
1613             WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
1614                                  sizeof(woc16->szPname), NULL, NULL );
1615             woc32->dwFormats = woc16->dwFormats;
1616             woc32->wChannels = woc16->wChannels;
1617             woc32->dwSupport = woc16->dwSupport;
1618             UnMapLS( *lpParam1 );
1619             HeapFree( GetProcessHeap(), 0, ptr );
1620             ret = WINMM_MAP_OK;
1621         }
1622         break;
1623     case WODM_GETPITCH:
1624         FIXME("NIY: no conversion yet\n");
1625         ret = WINMM_MAP_MSGERROR;
1626         break;
1627     case WODM_GETPLAYBACKRATE:
1628         FIXME("NIY: no conversion yet\n");
1629         ret = WINMM_MAP_MSGERROR;
1630         break;
1631     case WODM_GETPOS:
1632         {
1633             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1634             LPSTR               ptr   = (LPSTR)mmt16 - sizeof(LPMMTIME);
1635             LPMMTIME            mmt32 = *(LPMMTIME*)ptr;
1636
1637             MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1638             UnMapLS( *lpParam1 );
1639             HeapFree( GetProcessHeap(), 0, ptr );
1640             ret = WINMM_MAP_OK;
1641         }
1642         break;
1643     case WODM_OPEN:
1644         {
1645             LPWAVEOPENDESC16            wod16 = MapSL(*lpParam1);
1646             LPSTR                       ptr   = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1647             LPWAVEOPENDESC              wod32 = *(LPWAVEOPENDESC*)ptr;
1648
1649             wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1650             **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1651             UnMapLS( *lpParam1 );
1652             HeapFree( GetProcessHeap(), 0, ptr );
1653             ret = WINMM_MAP_OK;
1654         }
1655         break;
1656     case WODM_PREPARE:
1657     case WODM_UNPREPARE:
1658     case WODM_WRITE:
1659         {
1660             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1661             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1662             LPWAVEHDR           wh32 = *(LPWAVEHDR*)ptr;
1663
1664             assert(wh32->lpNext == wh16);
1665             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1666             wh32->dwUser = wh16->dwUser;
1667             wh32->dwFlags = wh16->dwFlags;
1668             wh32->dwLoops = wh16->dwLoops;
1669
1670             UnMapLS( *lpParam1 );
1671             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1672                 HeapFree( GetProcessHeap(), 0, ptr );
1673                 wh32->lpNext = 0;
1674             }
1675             ret = WINMM_MAP_OK;
1676         }
1677         break;
1678     case WODM_GETVOLUME:
1679         FIXME("NIY: no conversion yet\n");
1680         ret = WINMM_MAP_MSGERROR;
1681         break;
1682     case DRVM_MAPPER_STATUS:
1683         {
1684             UnMapLS( *lpParam2 );
1685             ret = WINMM_MAP_OK;
1686         }
1687         break;
1688     default:
1689         FIXME("NIY: no conversion yet\n");
1690         ret = WINMM_MAP_MSGERROR;
1691         break;
1692     }
1693     return ret;
1694 }
1695
1696 /**************************************************************************
1697  *                              MMDRV_WaveOut_Callback          [internal]
1698  */
1699 static  void    CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1700 {
1701     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
1702
1703     switch (uMsg) {
1704     case WOM_OPEN:
1705     case WOM_CLOSE:
1706         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1707         break;
1708     case WOM_DONE:
1709         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1710             /* initial map is: 32 => 16 */
1711             LPWAVEHDR           wh16 = MapSL(dwParam1);
1712             LPWAVEHDR           wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1713
1714             dwParam1 = (DWORD)wh32;
1715             wh32->dwFlags = wh16->dwFlags;
1716         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1717             /* initial map is: 16 => 32 */
1718             LPWAVEHDR           wh32 = (LPWAVEHDR)(dwParam1);
1719             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1720             LPWAVEHDR           wh16 = MapSL(segwh16);
1721
1722             dwParam1 = (DWORD)segwh16;
1723             wh16->dwFlags = wh32->dwFlags;
1724         }
1725         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1726         break;
1727     default:
1728         ERR("Unknown msg %u\n", uMsg);
1729     }
1730
1731     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1732 }
1733
1734 /* =================================
1735  *  M A P P E R S   H A N D L I N G
1736  * ================================= */
1737
1738 static  LRESULT    MMDRV_CallMMDrvFunc16(DWORD fp16, WORD dev, WORD msg, LONG instance,
1739                                          LONG lp1, LONG lp2)
1740 {
1741     WORD args[8];
1742     DWORD ret;
1743
1744     args[7] = dev;
1745     args[6] = msg;
1746     args[5] = HIWORD(instance);
1747     args[4] = LOWORD(instance);
1748     args[3] = HIWORD(lp1);
1749     args[2] = LOWORD(lp1);
1750     args[1] = HIWORD(lp2);
1751     args[0] = LOWORD(lp2);
1752     WOWCallback16Ex( fp16, WCB16_PASCAL, sizeof(args), args, &ret );
1753     return LOWORD(ret);
1754 }
1755
1756 /**************************************************************************
1757  *                              MMDRV_GetDescription16          [internal]
1758  */
1759 static  BOOL    MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
1760 {
1761     OFSTRUCT    ofs;
1762     HFILE       hFile;
1763     WORD        w;
1764     DWORD       dw;
1765     BOOL        ret = FALSE;
1766
1767     if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
1768         ERR("Can't open file %s (builtin driver ?)\n", fname);
1769         return FALSE;
1770     }
1771
1772 #define E(_x)   do {TRACE _x;goto theEnd;} while(0)
1773
1774     if (_lread(hFile, &w, 2) != 2)                      E(("Can't read sig\n"));
1775     if (w != ('Z' * 256 + 'M'))                         E(("Bad sig %04x\n", w));
1776     if (_llseek(hFile, 0x3C, SEEK_SET) < 0)             E(("Can't seek to ext header offset\n"));
1777     if (_lread(hFile, &dw, 4) != 4)                     E(("Can't read ext header offset\n"));
1778     if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0)        E(("Can't seek to ext header.nr table %u\n", dw+0x2C));
1779     if (_lread(hFile, &dw, 4) != 4)                     E(("Can't read nr table offset\n"));
1780     if (_llseek(hFile, dw, SEEK_SET) < 0)               E(("Can't seek to nr table %u\n", dw));
1781     if (_lread(hFile, buf, 1) != 1)                     E(("Can't read descr length\n"));
1782     buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
1783     if (_lread(hFile, buf, buflen) != buflen)           E(("Can't read descr (%d)\n", buflen));
1784     buf[buflen] = '\0';
1785     ret = TRUE;
1786     TRACE("Got '%s' [%d]\n", buf, buflen);
1787 theEnd:
1788     _lclose(hFile);
1789     return ret;
1790 }
1791
1792 /******************************************************************
1793  *              MMDRV_LoadMMDrvFunc16
1794  *
1795  */
1796 unsigned   MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
1797                                  LPWINE_MM_DRIVER lpDrv)
1798 {
1799     WINEMM_msgFunc16    func;
1800     unsigned            count = 0;
1801     char                buffer[128];
1802     /*
1803      * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
1804      * The beginning of the module description indicates the driver supports
1805      * waveform, auxiliary, and mixer devices. Use one of the following
1806      * device-type names, followed by a colon (:) to indicate the type of
1807      * device your driver supports. If the driver supports more than one
1808      * type of device, separate each device-type name with a comma (,).
1809      *
1810      * wave for waveform audio devices
1811      * wavemapper for wave mappers
1812      * midi for MIDI audio devices
1813      * midimapper for midi mappers
1814      * aux for auxiliary audio devices
1815      * mixer for mixer devices
1816      */
1817
1818     if (d->d.d16.hDriver16) {
1819         HMODULE16       hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
1820
1821 #define AA(_h,_w,_x,_y,_z)                                      \
1822     func = (WINEMM_msgFunc##_y) _z ((_h), #_x);                 \
1823     if (func != NULL)                                           \
1824         { lpDrv->parts[_w].u.fnMessage##_y = func; count++;     \
1825           TRACE("Got %d bit func '%s'\n", _y, #_x);         }
1826
1827 #define A(_x,_y)        AA(hMod16,_x,_y,16,GetProcAddress16)
1828         A(MMDRV_AUX,    auxMessage);
1829         A(MMDRV_MIXER,  mxdMessage);
1830         A(MMDRV_MIDIIN, midMessage);
1831         A(MMDRV_MIDIOUT,modMessage);
1832         A(MMDRV_WAVEIN, widMessage);
1833         A(MMDRV_WAVEOUT,wodMessage);
1834 #undef A
1835 #undef AA
1836     }
1837     if (TRACE_ON(winmm)) {
1838         if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
1839             TRACE("%s => %s\n", drvName, buffer);
1840         else
1841             TRACE("%s => No description\n", drvName);
1842     }
1843
1844     return count;
1845 }
1846
1847 /* =================================
1848  *              M C I
1849  * ================================= */
1850
1851 #if 0
1852 /* FIXME: this code is kept for not yet implemented optimisation for an application
1853  * using the 32A MCI interface and calling a 16 bit driver.
1854  * For now, we're doing two conversions:
1855  * - 32A => 32W (in 32 bit MCI code)
1856  * - 32W => 16  in this file
1857  */
1858
1859 /*
1860  * 0000 stop
1861  * 0001 squeeze   signed 4 bytes to 2 bytes     *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2;     S += 4
1862  * 0010 squeeze unsigned 4 bytes to 2 bytes     *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2;     S += 4
1863  * 0100
1864  * 0101
1865  * 0110 zero 4 bytes                            *(DWORD)D = 0                        D += 4;     S += 4
1866  * 0111 copy string                             *(LPSTR*)D = seg dup(*(LPSTR*)S)     D += 4;     S += 4
1867  * 1xxx copy xxx + 1 bytes                      memcpy(D, S, xxx + 1);               D += xxx+1; S += xxx+1
1868  */
1869
1870 /**************************************************************************
1871  *                      MCI_MsgMapper32ATo16_Create             [internal]
1872  *
1873  * Helper for MCI_MapMsg32ATo16.
1874  * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1875  * segmented pointer.
1876  * map contains a list of action to be performed for the mapping (see list
1877  * above)
1878  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1879  */
1880 static  WINMM_MapType   MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
1881 {
1882     void*       lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
1883     LPBYTE      p16, p32;
1884
1885     if (!lp) {
1886         return WINMM_MAP_NOMEM;
1887     }
1888     p32 = (LPBYTE)(*ptr);
1889     if (keep) {
1890         *(void**)lp = *ptr;
1891         p16 = (LPBYTE)lp + sizeof(void**);
1892         *ptr = (char*)MapLS(lp) + sizeof(void**);
1893     } else {
1894         p16 = lp;
1895         *ptr = (void*)MapLS(lp);
1896     }
1897
1898     if (map == 0) {
1899         memcpy(p16, p32, size16);
1900     } else {
1901         unsigned        nibble;
1902         unsigned        sz;
1903
1904         while (map & 0xF) {
1905             nibble = map & 0xF;
1906             if (nibble & 0x8) {
1907                 sz = (nibble & 7) + 1;
1908                 memcpy(p16, p32, sz);
1909                 p16 += sz;
1910                 p32 += sz;
1911                 size16 -= sz;   /* DEBUG only */
1912             } else {
1913                 switch (nibble) {
1914                 case 0x1:
1915                     *(LPINT16)p16 = *(LPINT)p32;
1916                     p16 += sizeof(INT16);
1917                     p32 += sizeof(INT);
1918                     size16 -= sizeof(INT16);
1919                     break;
1920                 case 0x2:
1921                     *(LPUINT16)p16 = *(LPUINT)p32;
1922                     p16 += sizeof(UINT16);
1923                     p32 += sizeof(UINT);
1924                     size16 -= sizeof(UINT16);
1925                     break;
1926                 case 0x6:
1927                     *(LPDWORD)p16 = 0;
1928                     p16 += sizeof(DWORD);
1929                     p32 += sizeof(DWORD);
1930                     size16 -= sizeof(DWORD);
1931                     break;
1932                 case 0x7:
1933                     *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
1934                     p16 += sizeof(SEGPTR);
1935                     p32 += sizeof(LPSTR);
1936                     size16 -= sizeof(SEGPTR);
1937                     break;
1938                 default:
1939                     FIXME("Unknown nibble for mapping (%x)\n", nibble);
1940                 }
1941             }
1942             map >>= 4;
1943         }
1944         if (size16 != 0) /* DEBUG only */
1945             FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1946     }
1947     return WINMM_MAP_OKMEM;
1948 }
1949
1950 /**************************************************************************
1951  *                      MCI_MsgMapper32ATo16_Destroy            [internal]
1952  *
1953  * Helper for MCI_UnMapMsg32ATo16.
1954  */
1955 static  WINMM_MapType   MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
1956 {
1957     if (ptr) {
1958         void*           msg16 = MapSL((SEGPTR)ptr);
1959         void*           alloc;
1960         LPBYTE          p32, p16;
1961         unsigned        nibble;
1962
1963         UnMapLS( (SEGPTR)ptr );
1964         if (kept) {
1965             alloc = (char*)msg16 - sizeof(void**);
1966             p32 = *(void**)alloc;
1967             p16 = msg16;
1968
1969             if (map == 0) {
1970                 memcpy(p32, p16, size16);
1971             } else {
1972                 while (map & 0xF) {
1973                     nibble = map & 0xF;
1974                     if (nibble & 0x8) {
1975                         memcpy(p32, p16, (nibble & 7) + 1);
1976                         p16 += (nibble & 7) + 1;
1977                         p32 += (nibble & 7) + 1;
1978                         size16 -= (nibble & 7) + 1;
1979                     } else {
1980                         switch (nibble) {
1981                         case 0x1:
1982                             *(LPINT)p32 = *(LPINT16)p16;
1983                             p16 += sizeof(INT16);
1984                             p32 += sizeof(INT);
1985                             size16 -= sizeof(INT16);
1986                             break;
1987                         case 0x2:
1988                             *(LPUINT)p32 = *(LPUINT16)p16;
1989                             p16 += sizeof(UINT16);
1990                             p32 += sizeof(UINT);
1991                             size16 -= sizeof(UINT16);
1992                             break;
1993                         case 0x6:
1994                             p16 += sizeof(UINT);
1995                             p32 += sizeof(UINT);
1996                             size16 -= sizeof(UINT);
1997                             break;
1998                         case 0x7:
1999                             UnMapLS( *(SEGPTR *)p16 );
2000                             p16 += sizeof(SEGPTR);
2001                             p32 += sizeof(char*);
2002                             size16 -= sizeof(SEGPTR);
2003                             break;
2004                         default:
2005                             FIXME("Unknown nibble for mapping (%x)\n", nibble);
2006                         }
2007                     }
2008                     map >>= 4;
2009                 }
2010                 if (size16 != 0) /* DEBUG only */
2011                     FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2012             }
2013         } else {
2014             alloc = msg16;
2015         }
2016
2017         HeapFree( GetProcessHeap(), 0, alloc );
2018     }
2019     return WINMM_MAP_OK;
2020 }
2021
2022 /**************************************************************************
2023  *                      MCI_MapMsg32ATo16                       [internal]
2024  *
2025  * Map a 32-A bit MCI message to a 16 bit MCI message.
2026  */
2027 static  WINMM_MapType   MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
2028 {
2029     int         size;
2030     BOOLEAN     keep = FALSE;
2031     DWORD       map = 0;
2032
2033     if (*lParam == 0)
2034         return WINMM_MAP_OK;
2035
2036     /* FIXME: to add also (with seg/linear modifications to do):
2037      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2038      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2039      */
2040     switch (wMsg) {
2041     case MCI_BREAK:
2042         size = sizeof(MCI_BREAK_PARMS);
2043         break;
2044         /* case MCI_CAPTURE */
2045     case MCI_CLOSE:
2046     case MCI_CLOSE_DRIVER:
2047     case MCI_CONFIGURE:
2048         size = sizeof(MCI_GENERIC_PARMS);
2049         break;
2050         /* case MCI_COPY: */
2051     case MCI_CUE:
2052         switch (uDevType) {
2053         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS);       break;
2054         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_CUE_PARMS);     break;*/        FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2055         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2056         }
2057         break;
2058         /* case MCI_CUT:*/
2059     case MCI_DELETE:
2060         switch (uDevType) {
2061         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16);  map = 0x0F1111FB;       break;
2062         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS);   break;
2063         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2064         }
2065         break;
2066         /* case MCI_ESCAPE: */
2067     case MCI_FREEZE:
2068         switch (uDevType) {
2069         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS);    map = 0x0001111B;       break;
2070         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
2071         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2072         }
2073         break;
2074     case MCI_GETDEVCAPS:
2075         keep = TRUE;
2076         size = sizeof(MCI_GETDEVCAPS_PARMS);
2077         break;
2078         /* case MCI_INDEX: */
2079     case MCI_INFO:
2080         {
2081             LPMCI_INFO_PARMSA   mip32a = (LPMCI_INFO_PARMSA)(*lParam);
2082             LPMCI_INFO_PARMS16  mip16;
2083
2084             switch (uDevType) {
2085             case MCI_DEVTYPE_DIGITAL_VIDEO:     size = sizeof(MCI_DGV_INFO_PARMS16);    break;
2086             default:                            size = sizeof(MCI_INFO_PARMS16);        break;
2087             }
2088             mip16 = HeapAlloc( GetProcessHeap(), 0, size);
2089             if (mip16)
2090             {
2091                 mip16->dwCallback  = mip32a->dwCallback;
2092                 mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
2093                 mip16->dwRetSize   = mip32a->dwRetSize;
2094                 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
2095                     ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
2096                 }
2097             } else {
2098                 return WINMM_MAP_NOMEM;
2099             }
2100             *lParam = MapLS(mip16);
2101         }
2102         return WINMM_MAP_OKMEM;
2103         /* case MCI_MARK: */
2104         /* case MCI_MONITOR: */
2105     case MCI_OPEN:
2106     case MCI_OPEN_DRIVER:
2107         {
2108             LPMCI_OPEN_PARMSA   mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
2109             char* ptr = HeapAlloc( GetProcessHeap(), 0,
2110                                    sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
2111             LPMCI_OPEN_PARMS16  mop16;
2112
2113
2114             if (ptr) {
2115                 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
2116                 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
2117                 mop16->dwCallback       = mop32a->dwCallback;
2118                 mop16->wDeviceID        = mop32a->wDeviceID;
2119                 if (dwFlags & MCI_OPEN_TYPE) {
2120                     if (dwFlags & MCI_OPEN_TYPE_ID) {
2121                         /* dword "transparent" value */
2122                         mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
2123                     } else {
2124                         /* string */
2125                         mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
2126                     }
2127                 } else {
2128                     /* nuthin' */
2129                     mop16->lpstrDeviceType = 0;
2130                 }
2131                 if (dwFlags & MCI_OPEN_ELEMENT) {
2132                     if (dwFlags & MCI_OPEN_ELEMENT_ID) {
2133                         mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
2134                     } else {
2135                         mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
2136                     }
2137                 } else {
2138                     mop16->lpstrElementName = 0;
2139                 }
2140                 if (dwFlags & MCI_OPEN_ALIAS) {
2141                     mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
2142                 } else {
2143                     mop16->lpstrAlias = 0;
2144                 }
2145                 /* copy extended information if any...
2146                  * FIXME: this may seg fault if initial structure does not contain them and
2147                  * the reads after msip16 fail under LDT limits...
2148                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2149                  * should not take care of extended parameters, and should be used by MCI_Open
2150                  * to fetch uDevType. When, this is known, the mapping for sending the
2151                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
2152                  */
2153                 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
2154             } else {
2155                 return WINMM_MAP_NOMEM;
2156             }
2157             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
2158         }
2159         return WINMM_MAP_OKMEM;
2160         /* case MCI_PASTE:*/
2161     case MCI_PAUSE:
2162         size = sizeof(MCI_GENERIC_PARMS);
2163         break;
2164     case MCI_PLAY:
2165         size = sizeof(MCI_PLAY_PARMS);
2166         break;
2167     case MCI_PUT:
2168         switch (uDevType) {
2169         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
2170         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
2171         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2172         }
2173         break;
2174     case MCI_REALIZE:
2175         size = sizeof(MCI_GENERIC_PARMS);
2176         break;
2177     case MCI_RECORD:
2178         switch (uDevType) {
2179         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16);  map = 0x0F1111FB;       break;
2180         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_RECORD_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2181         default:                        size = sizeof(MCI_RECORD_PARMS);        break;
2182         }
2183         break;
2184     case MCI_RESUME:
2185         size = sizeof(MCI_GENERIC_PARMS);
2186         break;
2187     case MCI_SEEK:
2188         switch (uDevType) {
2189         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SEEK_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2190         default:                        size = sizeof(MCI_SEEK_PARMS);          break;
2191         }
2192         break;
2193     case MCI_SET:
2194         switch (uDevType) {
2195         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS);       break;
2196         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SET_PARMS);     break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2197         case MCI_DEVTYPE_SEQUENCER:     size = sizeof(MCI_SEQ_SET_PARMS);       break;
2198         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
2199          * so not doing anything should work...
2200          */
2201         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS);      break;
2202         default:                        size = sizeof(MCI_SET_PARMS);           break;
2203         }
2204         break;
2205     case MCI_SETAUDIO:
2206         switch (uDevType) {
2207         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;      break;
2208         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2209         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2210         }
2211         break;
2212         /* case MCI_SETTIMECODE:*/
2213         /* case MCI_SIGNAL:*/
2214         /* case MCI_SOUND:*/
2215     case MCI_SPIN:
2216         size = sizeof(MCI_SET_PARMS);
2217         break;
2218     case MCI_STATUS:
2219         keep = TRUE;
2220         switch (uDevType) {
2221         /* FIXME:
2222          * don't know if buffer for value is the one passed through lpstrDevice
2223          * or is provided by MCI driver.
2224          * Assuming solution 2: provided by MCI driver, so zeroing on entry
2225          */
2226         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16);  map = 0x0B6FF;          break;
2227         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2228         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2229         }
2230         break;
2231     case MCI_STEP:
2232         switch (uDevType) {
2233         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS);      break;
2234         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STEP_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2235         case MCI_DEVTYPE_VIDEODISC:     size = sizeof(MCI_VD_STEP_PARMS);       break;
2236         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2237         }
2238         break;
2239     case MCI_STOP:
2240         size = sizeof(MCI_SET_PARMS);
2241         break;
2242     case MCI_SYSINFO:
2243         {
2244             LPMCI_SYSINFO_PARMSA  msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
2245             LPMCI_SYSINFO_PARMS16 msip16;
2246             char* ptr = HeapAlloc( GetProcessHeap(), 0,
2247                                    sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
2248
2249             if (ptr) {
2250                 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
2251                 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
2252
2253                 msip16->dwCallback       = msip32a->dwCallback;
2254                 msip16->lpstrReturn      = MapLS( msip32a->lpstrReturn );
2255                 msip16->dwRetSize        = msip32a->dwRetSize;
2256                 msip16->dwNumber         = msip32a->dwNumber;
2257                 msip16->wDeviceType      = msip32a->wDeviceType;
2258             } else {
2259                 return WINMM_MAP_NOMEM;
2260             }
2261             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
2262         }
2263         return WINMM_MAP_OKMEM;
2264         /* case MCI_UNDO: */
2265     case MCI_UNFREEZE:
2266         switch (uDevType) {
2267         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
2268         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       break;
2269         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2270         }
2271         break;
2272     case MCI_UPDATE:
2273         switch (uDevType) {
2274         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16);  map = 0x000B1111B;      break;
2275         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2276         }
2277         break;
2278     case MCI_WHERE:
2279         switch (uDevType) {
2280         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       keep = TRUE;    break;
2281         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       keep = TRUE;    break;
2282         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2283         }
2284         break;
2285     case MCI_WINDOW:
2286         switch (uDevType) {
2287         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7FB;        break;
2288         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB;        break;
2289         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2290         }
2291         break;
2292     case DRV_OPEN:
2293         {
2294             LPMCI_OPEN_DRIVER_PARMSA  modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
2295             LPMCI_OPEN_DRIVER_PARMS16 modp16;
2296             char *ptr = HeapAlloc( GetProcessHeap(), 0,
2297                                    sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
2298
2299             if (ptr) {
2300                 *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
2301                 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2302                 modp16->wDeviceID = modp32a->wDeviceID;
2303                 modp16->lpstrParams = MapLS( modp32a->lpstrParams );
2304                 /* other fields are gonna be filled by the driver, don't copy them */
2305             } else {
2306                 return WINMM_MAP_NOMEM;
2307             }
2308             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
2309         }
2310         return WINMM_MAP_OKMEM;
2311     case DRV_LOAD:
2312     case DRV_ENABLE:
2313     case DRV_CLOSE:
2314     case DRV_DISABLE:
2315     case DRV_FREE:
2316     case DRV_CONFIGURE:
2317     case DRV_QUERYCONFIGURE:
2318     case DRV_INSTALL:
2319     case DRV_REMOVE:
2320     case DRV_EXITSESSION:
2321     case DRV_EXITAPPLICATION:
2322     case DRV_POWER:
2323         return WINMM_MAP_OK;
2324
2325     default:
2326         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2327         return WINMM_MAP_MSGERROR;
2328     }
2329     return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep);
2330 }
2331
2332 /**************************************************************************
2333  *                      MCI_UnMapMsg32ATo16                     [internal]
2334  */
2335 static  WINMM_MapType   MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
2336 {
2337     int         size = 0;
2338     BOOLEAN     kept = FALSE;   /* there is no need to compute size when kept is FALSE */
2339     DWORD       map = 0;
2340
2341     switch (wMsg) {
2342     case MCI_BREAK:
2343         break;
2344         /* case MCI_CAPTURE */
2345     case MCI_CLOSE:
2346     case MCI_CLOSE_DRIVER:
2347     case MCI_CONFIGURE:
2348         break;
2349         /* case MCI_COPY: */
2350     case MCI_CUE:
2351         break;
2352         /* case MCI_CUT: */
2353     case MCI_DELETE:
2354         break;
2355         /* case MCI_ESCAPE: */
2356     case MCI_FREEZE:
2357         break;
2358     case MCI_GETDEVCAPS:
2359         kept = TRUE;
2360         size = sizeof(MCI_GETDEVCAPS_PARMS);
2361         break;
2362         /* case MCI_INDEX: */
2363     case MCI_INFO:
2364         {
2365             LPMCI_INFO_PARMS16 mip16  = (LPMCI_INFO_PARMS16)MapSL(lParam);
2366             UnMapLS( lParam );
2367             UnMapLS( mip16->lpstrReturn );
2368             HeapFree( GetProcessHeap(), 0, mip16 );
2369         }
2370         return WINMM_MAP_OK;
2371         /* case MCI_MARK: */
2372         /* case MCI_MONITOR: */
2373     case MCI_OPEN:
2374     case MCI_OPEN_DRIVER:
2375         if (lParam) {
2376             LPMCI_OPEN_PARMS16  mop16  = (LPMCI_OPEN_PARMS16)MapSL(lParam);
2377             LPMCI_OPEN_PARMSA   mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
2378             UnMapLS( lParam );
2379             mop32a->wDeviceID = mop16->wDeviceID;
2380             if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
2381                 UnMapLS( mop16->lpstrDeviceType );
2382             if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
2383                 UnMapLS( mop16->lpstrElementName );
2384             if (dwFlags & MCI_OPEN_ALIAS)
2385                 UnMapLS( mop16->lpstrAlias );
2386             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
2387         }
2388         return WINMM_MAP_OK;
2389         /* case MCI_PASTE:*/
2390     case MCI_PAUSE:
2391         break;
2392     case MCI_PLAY:
2393         break;
2394     case MCI_PUT:
2395         break;
2396     case MCI_REALIZE:
2397         break;
2398     case MCI_RECORD:
2399         break;
2400     case MCI_RESUME:
2401         break;
2402     case MCI_SEEK:
2403         break;
2404     case MCI_SET:
2405         break;
2406     case MCI_SETAUDIO:
2407         switch (uDevType) {
2408         case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF;      break;
2409         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2410         }
2411         break;
2412         /* case MCI_SETTIMECODE:*/
2413         /* case MCI_SIGNAL:*/
2414         /* case MCI_SOUND:*/
2415     case MCI_SPIN:
2416         break;
2417     case MCI_STATUS:
2418         kept = TRUE;
2419         switch (uDevType) {
2420         case MCI_DEVTYPE_DIGITAL_VIDEO:
2421         if (lParam) {
2422             LPMCI_DGV_STATUS_PARMS16    mdsp16  = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
2423             LPMCI_DGV_STATUS_PARMSA     mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
2424
2425             UnMapLS( lParam );
2426             if (mdsp16) {
2427                 mdsp32a->dwReturn = mdsp16->dwReturn;
2428                 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2429                     TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
2430                     TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
2431                     UnMapLS( mdsp16->lpstrDrive );
2432                 }
2433                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
2434             } else {
2435                 return WINMM_MAP_NOMEM;
2436             }
2437         }
2438         return WINMM_MAP_OKMEM;
2439         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2440         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2441         }
2442         break;
2443     case MCI_STEP:
2444         break;
2445     case MCI_STOP:
2446         break;
2447     case MCI_SYSINFO:
2448         if (lParam) {
2449             LPMCI_SYSINFO_PARMS16       msip16  = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
2450             LPMCI_SYSINFO_PARMSA        msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
2451
2452             UnMapLS( lParam );
2453             if (msip16) {
2454                 msip16->dwCallback = msip32a->dwCallback;
2455                 UnMapLS( msip16->lpstrReturn );
2456                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
2457             } else {
2458                 return WINMM_MAP_NOMEM;
2459             }
2460         }
2461         return WINMM_MAP_OKMEM;
2462         /* case MCI_UNDO: */
2463     case MCI_UNFREEZE:
2464         break;
2465     case MCI_UPDATE:
2466         break;
2467     case MCI_WHERE:
2468         switch (uDevType) {
2469         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       kept = TRUE;    break;
2470         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       kept = TRUE;    break;
2471         default:                        break;
2472         }
2473         break;
2474     case MCI_WINDOW:
2475         switch (uDevType) {
2476         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7666;       break;
2477         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666;       break;
2478         default:                        break;
2479         }
2480         /* FIXME: see map function */
2481         break;
2482
2483     case DRV_OPEN:
2484         if (lParam) {
2485             LPMCI_OPEN_DRIVER_PARMS16   modp16  = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
2486             LPMCI_OPEN_DRIVER_PARMSA    modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2487
2488             UnMapLS( lParam );
2489             modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
2490             modp32a->wType = modp16->wType;
2491             UnMapLS( modp16->lpstrParams );
2492             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
2493         }
2494         return WINMM_MAP_OK;
2495     case DRV_LOAD:
2496     case DRV_ENABLE:
2497     case DRV_CLOSE:
2498     case DRV_DISABLE:
2499     case DRV_FREE:
2500     case DRV_CONFIGURE:
2501     case DRV_QUERYCONFIGURE:
2502     case DRV_INSTALL:
2503     case DRV_REMOVE:
2504     case DRV_EXITSESSION:
2505     case DRV_EXITAPPLICATION:
2506     case DRV_POWER:
2507         FIXME("This is a hack\n");
2508         return WINMM_MAP_OK;
2509     default:
2510         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2511         return WINMM_MAP_MSGERROR;
2512     }
2513     return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept);
2514 }
2515 #endif
2516
2517 /**************************************************************************
2518  *                      MCI_MapMsg16To32W                       [internal]
2519  */
2520 static WINMM_MapType    MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
2521 {
2522     if (*lParam == 0)
2523         return WINMM_MAP_OK;
2524     /* FIXME: to add also (with seg/linear modifications to do):
2525      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2526      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2527      */
2528     switch (wMsg) {
2529         /* case MCI_CAPTURE */
2530     case MCI_CLOSE:
2531     case MCI_CLOSE_DRIVER:
2532     case MCI_CONFIGURE:
2533     case MCI_COPY:
2534     case MCI_CUE:
2535     case MCI_CUT:
2536     case MCI_DELETE:
2537     case MCI_FREEZE:
2538     case MCI_GETDEVCAPS:
2539         /* case MCI_INDEX: */
2540         /* case MCI_MARK: */
2541         /* case MCI_MONITOR: */
2542     case MCI_PASTE:
2543     case MCI_PAUSE:
2544     case MCI_PLAY:
2545     case MCI_PUT:
2546     case MCI_REALIZE:
2547     case MCI_RECORD:
2548     case MCI_RESUME:
2549     case MCI_SEEK:
2550     case MCI_SET:
2551         /* case MCI_SETTIMECODE:*/
2552         /* case MCI_SIGNAL:*/
2553     case MCI_SPIN:
2554     case MCI_STATUS:            /* FIXME: is wrong for digital video */
2555     case MCI_STEP:
2556     case MCI_STOP:
2557         /* case MCI_UNDO: */
2558     case MCI_UNFREEZE:
2559     case MCI_UPDATE:
2560     case MCI_WHERE:
2561         *lParam = (DWORD)MapSL(*lParam);
2562         return WINMM_MAP_OK;
2563     case MCI_WINDOW:
2564         /* in fact, I would also need the dwFlags... to see
2565          * which members of lParam are effectively used
2566          */
2567         *lParam = (DWORD)MapSL(*lParam);
2568         FIXME("Current mapping may be wrong\n");
2569         break;
2570     case MCI_BREAK:
2571         {
2572             LPMCI_BREAK_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
2573             LPMCI_BREAK_PARMS16         mbp16 = MapSL(*lParam);
2574
2575             if (mbp32) {
2576                 mbp32->dwCallback = mbp16->dwCallback;
2577                 mbp32->nVirtKey = mbp16->nVirtKey;
2578                 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
2579             } else {
2580                 return WINMM_MAP_NOMEM;
2581             }
2582             *lParam = (DWORD)mbp32;
2583         }
2584         return WINMM_MAP_OKMEM;
2585     case MCI_ESCAPE:
2586         {
2587             LPMCI_VD_ESCAPE_PARMSW      mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
2588             LPMCI_VD_ESCAPE_PARMS16     mvep16  = MapSL(*lParam);
2589
2590             if (mvep32w) {
2591                 mvep32w->dwCallback       = mvep16->dwCallback;
2592                 mvep32w->lpstrCommand     = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
2593             } else {
2594                 return WINMM_MAP_NOMEM;
2595             }
2596             *lParam = (DWORD)mvep32w;
2597         }
2598         return WINMM_MAP_OKMEM;
2599     case MCI_INFO:
2600         {
2601             LPMCI_INFO_PARMSW   mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
2602             LPMCI_INFO_PARMS16  mip16  = MapSL(*lParam);
2603
2604             /* FIXME this is wrong if device is of type
2605              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
2606              */
2607             if (mip32w) {
2608                 *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
2609                 mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
2610                 mip32w->dwCallback  = mip16->dwCallback;
2611                 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
2612                 mip32w->dwRetSize   = mip16->dwRetSize * sizeof(WCHAR);
2613             } else {
2614                 return WINMM_MAP_NOMEM;
2615             }
2616             *lParam = (DWORD)mip32w;
2617         }
2618         return WINMM_MAP_OKMEM;
2619     case MCI_OPEN:
2620     case MCI_OPEN_DRIVER:
2621         {
2622             LPMCI_OPEN_PARMSW   mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
2623             LPMCI_OPEN_PARMS16  mop16  = MapSL(*lParam);
2624
2625             if (mop32w) {
2626                 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
2627                 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
2628                 mop32w->dwCallback       = mop16->dwCallback;
2629                 mop32w->wDeviceID        = mop16->wDeviceID;
2630                 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
2631                     mop32w->lpstrDeviceType  = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
2632                 else
2633                     mop32w->lpstrDeviceType  = (LPWSTR) mop16->lpstrDeviceType;
2634                 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
2635                     mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
2636                 else
2637                     mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
2638                 if( ( dwFlags &  MCI_OPEN_ALIAS))
2639                     mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
2640                 else
2641                     mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
2642                 /* copy extended information if any...
2643                  * FIXME: this may seg fault if initial structure does not contain them and
2644                  * the reads after msip16 fail under LDT limits...
2645                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2646                  * should not take care of extended parameters, and should be used by MCI_Open
2647                  * to fetch uDevType. When, this is known, the mapping for sending the
2648                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
2649                  */
2650                 memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
2651             } else {
2652                 return WINMM_MAP_NOMEM;
2653             }
2654             *lParam = (DWORD)mop32w;
2655         }
2656         return WINMM_MAP_OKMEM;
2657     case MCI_SYSINFO:
2658         {
2659             LPMCI_SYSINFO_PARMSW        msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
2660             LPMCI_SYSINFO_PARMS16       msip16  = MapSL(*lParam);
2661
2662             if (msip32w) {
2663                 *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
2664                 msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
2665                 msip32w->dwCallback       = msip16->dwCallback;
2666                 msip32w->lpstrReturn      = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
2667                 msip32w->dwRetSize        = msip16->dwRetSize;
2668                 msip32w->dwNumber         = msip16->dwNumber;
2669                 msip32w->wDeviceType      = msip16->wDeviceType;
2670             } else {
2671                 return WINMM_MAP_NOMEM;
2672             }
2673             *lParam = (DWORD)msip32w;
2674         }
2675         return WINMM_MAP_OKMEM;
2676     case MCI_SOUND:
2677         {
2678             LPMCI_SOUND_PARMSW          mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
2679             LPMCI_SOUND_PARMS16         mbp16 = MapSL(*lParam);
2680
2681             if (mbp32) {
2682                 mbp32->dwCallback = mbp16->dwCallback;
2683                 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
2684             } else {
2685                 return WINMM_MAP_NOMEM;
2686             }
2687             *lParam = (DWORD)mbp32;
2688         }
2689         return WINMM_MAP_OKMEM;
2690     case DRV_LOAD:
2691     case DRV_ENABLE:
2692     case DRV_OPEN:
2693     case DRV_CLOSE:
2694     case DRV_DISABLE:
2695     case DRV_FREE:
2696     case DRV_CONFIGURE:
2697     case DRV_QUERYCONFIGURE:
2698     case DRV_INSTALL:
2699     case DRV_REMOVE:
2700     case DRV_EXITSESSION:
2701     case DRV_EXITAPPLICATION:
2702     case DRV_POWER:
2703         FIXME("This is a hack\n");
2704         return WINMM_MAP_OK;
2705     default:
2706         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2707     }
2708     return WINMM_MAP_MSGERROR;
2709 }
2710
2711 /**************************************************************************
2712  *                      MCI_UnMapMsg16To32W                     [internal]
2713  */
2714 static  WINMM_MapType   MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
2715 {
2716     switch (wMsg) {
2717         /* case MCI_CAPTURE */
2718     case MCI_CLOSE:
2719     case MCI_CLOSE_DRIVER:
2720     case MCI_CONFIGURE:
2721     case MCI_COPY:
2722     case MCI_CUE:
2723     case MCI_CUT:
2724     case MCI_DELETE:
2725     case MCI_FREEZE:
2726     case MCI_GETDEVCAPS:
2727         /* case MCI_INDEX: */
2728         /* case MCI_MARK: */
2729         /* case MCI_MONITOR: */
2730     case MCI_PASTE:
2731     case MCI_PAUSE:
2732     case MCI_PLAY:
2733     case MCI_PUT:
2734     case MCI_REALIZE:
2735     case MCI_RECORD:
2736     case MCI_RESUME:
2737     case MCI_SEEK:
2738     case MCI_SET:
2739         /* case MCI_SETTIMECODE:*/
2740         /* case MCI_SIGNAL:*/
2741     case MCI_SPIN:
2742     case MCI_STATUS:
2743     case MCI_STEP:
2744     case MCI_STOP:
2745         /* case MCI_UNDO: */
2746     case MCI_UNFREEZE:
2747     case MCI_UPDATE:
2748     case MCI_WHERE:
2749         return WINMM_MAP_OK;
2750
2751     case MCI_WINDOW:
2752         /* FIXME ?? see Map function */
2753         return WINMM_MAP_OK;
2754
2755     case MCI_BREAK:
2756         HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2757         return WINMM_MAP_OK;
2758     case MCI_ESCAPE:
2759         if (lParam) {
2760             LPMCI_VD_ESCAPE_PARMSW      mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
2761             HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
2762             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2763         }
2764         return WINMM_MAP_OK;
2765     case MCI_INFO:
2766         if (lParam) {
2767             LPMCI_INFO_PARMSW           mip32w = (LPMCI_INFO_PARMSW)lParam;
2768             LPMCI_INFO_PARMS16          mip16  = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
2769
2770             WideCharToMultiByte(CP_ACP, 0,
2771                                 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
2772                                 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
2773                                 NULL, NULL);
2774             HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn);
2775             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2776         }
2777         return WINMM_MAP_OK;
2778     case MCI_SYSINFO:
2779         if (lParam) {
2780             LPMCI_SYSINFO_PARMSW           msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
2781             LPMCI_SYSINFO_PARMS16          msip16  = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
2782
2783             WideCharToMultiByte(CP_ACP, 0,
2784                                 msip32w->lpstrReturn, msip32w->dwRetSize,
2785                                 MapSL(msip16->lpstrReturn), msip16->dwRetSize,
2786                                 NULL, NULL);
2787             HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn);
2788             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2789         }
2790         return WINMM_MAP_OK;
2791     case MCI_SOUND:
2792         if (lParam) {
2793             LPMCI_SOUND_PARMSW          msp32W = (LPMCI_SOUND_PARMSW)lParam;
2794             HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
2795             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2796         }
2797         return WINMM_MAP_OK;
2798     case MCI_OPEN:
2799     case MCI_OPEN_DRIVER:
2800         if (lParam) {
2801             LPMCI_OPEN_PARMSW   mop32w = (LPMCI_OPEN_PARMSW)lParam;
2802             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
2803
2804             mop16->wDeviceID = mop32w->wDeviceID;
2805             if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
2806                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
2807             if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
2808                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
2809             if( ( dwFlags &  MCI_OPEN_ALIAS))
2810                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
2811             if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
2812                 FIXME("bad free line=%d\n", __LINE__);
2813         }
2814         return WINMM_MAP_OK;
2815     case DRV_LOAD:
2816     case DRV_ENABLE:
2817     case DRV_OPEN:
2818     case DRV_CLOSE:
2819     case DRV_DISABLE:
2820     case DRV_FREE:
2821     case DRV_CONFIGURE:
2822     case DRV_QUERYCONFIGURE:
2823     case DRV_INSTALL:
2824     case DRV_REMOVE:
2825     case DRV_EXITSESSION:
2826     case DRV_EXITAPPLICATION:
2827     case DRV_POWER:
2828         FIXME("This is a hack\n");
2829         return WINMM_MAP_OK;
2830     default:
2831         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2832     }
2833     return WINMM_MAP_MSGERROR;
2834 }
2835
2836 /*
2837  * 0000 stop
2838  * 0001 squeeze   signed 4 bytes to 2 bytes     *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2;     S += 4
2839  * 0010 squeeze unsigned 4 bytes to 2 bytes     *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2;     S += 4
2840  * 0100
2841  * 0101
2842  * 0110 zero 4 bytes                            *(DWORD)D = 0                        D += 4;     S += 4
2843  * 0111 copy string                             *(LPSTR*)D = seg dup(*(LPSTR*)S)     D += 4;     S += 4
2844  * 1xxx copy xxx + 1 bytes                      memcpy(D, S, xxx + 1);               D += xxx+1; S += xxx+1
2845  */
2846
2847 /**************************************************************************
2848  *                      MCI_MsgMapper32WTo16_Create             [internal]
2849  *
2850  * Helper for MCI_MapMsg32WTo16.
2851  * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
2852  * segmented pointer.
2853  * map contains a list of action to be performed for the mapping (see list
2854  * above)
2855  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
2856  */
2857 static  WINMM_MapType   MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
2858 {
2859     void*       lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
2860     LPBYTE      p16, p32;
2861
2862     if (!lp) {
2863         return WINMM_MAP_NOMEM;
2864     }
2865     p32 = (LPBYTE)(*ptr);
2866     if (keep) {
2867         *(void**)lp = *ptr;
2868         p16 = (LPBYTE)lp + sizeof(void**);
2869         *ptr = (char*)MapLS(lp) + sizeof(void**);
2870     } else {
2871         p16 = lp;
2872         *ptr = (void*)MapLS(lp);
2873     }
2874
2875     if (map == 0) {
2876         memcpy(p16, p32, size16);
2877     } else {
2878         unsigned        nibble;
2879         unsigned        sz;
2880
2881         while (map & 0xF) {
2882             nibble = map & 0xF;
2883             if (nibble & 0x8) {
2884                 sz = (nibble & 7) + 1;
2885                 memcpy(p16, p32, sz);
2886                 p16 += sz;
2887                 p32 += sz;
2888                 size16 -= sz;   /* DEBUG only */
2889             } else {
2890                 switch (nibble) {
2891                 case 0x1:
2892                     *(LPINT16)p16 = *(LPINT)p32;
2893                     p16 += sizeof(INT16);
2894                     p32 += sizeof(INT);
2895                     size16 -= sizeof(INT16);
2896                     break;
2897                 case 0x2:
2898                     *(LPUINT16)p16 = *(LPUINT)p32;
2899                     p16 += sizeof(UINT16);
2900                     p32 += sizeof(UINT);
2901                     size16 -= sizeof(UINT16);
2902                     break;
2903                 case 0x6:
2904                     *(LPDWORD)p16 = 0;
2905                     p16 += sizeof(DWORD);
2906                     p32 += sizeof(DWORD);
2907                     size16 -= sizeof(DWORD);
2908                     break;
2909                 case 0x7:
2910                     *(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) );
2911                     p16 += sizeof(SEGPTR);
2912                     p32 += sizeof(LPSTR);
2913                     size16 -= sizeof(SEGPTR);
2914                     break;
2915                 default:
2916                     FIXME("Unknown nibble for mapping (%x)\n", nibble);
2917                 }
2918             }
2919             map >>= 4;
2920         }
2921         if (size16 != 0) /* DEBUG only */
2922             FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2923     }
2924     return WINMM_MAP_OKMEM;
2925 }
2926
2927 /**************************************************************************
2928  *                      MCI_MsgMapper32WTo16_Destroy            [internal]
2929  *
2930  * Helper for MCI_UnMapMsg32WTo16.
2931  */
2932 static  WINMM_MapType   MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
2933 {
2934     if (ptr) {
2935         void*           msg16 = MapSL((SEGPTR)ptr);
2936         void*           alloc;
2937         LPBYTE          p32, p16;
2938         unsigned        nibble;
2939
2940         UnMapLS( (SEGPTR)ptr );
2941         if (kept) {
2942             alloc = (char*)msg16 - sizeof(void**);
2943             p32 = *(void**)alloc;
2944             p16 = msg16;
2945
2946             if (map == 0) {
2947                 memcpy(p32, p16, size16);
2948             } else {
2949                 while (map & 0xF) {
2950                     nibble = map & 0xF;
2951                     if (nibble & 0x8) {
2952                         memcpy(p32, p16, (nibble & 7) + 1);
2953                         p16 += (nibble & 7) + 1;
2954                         p32 += (nibble & 7) + 1;
2955                         size16 -= (nibble & 7) + 1;
2956                     } else {
2957                         switch (nibble) {
2958                         case 0x1:
2959                             *(LPINT)p32 = *(LPINT16)p16;
2960                             p16 += sizeof(INT16);
2961                             p32 += sizeof(INT);
2962                             size16 -= sizeof(INT16);
2963                             break;
2964                         case 0x2:
2965                             *(LPUINT)p32 = *(LPUINT16)p16;
2966                             p16 += sizeof(UINT16);
2967                             p32 += sizeof(UINT);
2968                             size16 -= sizeof(UINT16);
2969                             break;
2970                         case 0x6:
2971                             p16 += sizeof(UINT);
2972                             p32 += sizeof(UINT);
2973                             size16 -= sizeof(UINT);
2974                             break;
2975                         case 0x7:
2976                             HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16));
2977                             UnMapLS( *(SEGPTR *)p16 );
2978                             p16 += sizeof(SEGPTR);
2979                             p32 += sizeof(char*);
2980                             size16 -= sizeof(SEGPTR);
2981                             break;
2982                         default:
2983                             FIXME("Unknown nibble for mapping (%x)\n", nibble);
2984                         }
2985                     }
2986                     map >>= 4;
2987                 }
2988                 if (size16 != 0) /* DEBUG only */
2989                     FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2990             }
2991         } else {
2992             alloc = msg16;
2993         }
2994
2995         HeapFree( GetProcessHeap(), 0, alloc );
2996     }
2997     return WINMM_MAP_OK;
2998 }
2999
3000 /**************************************************************************
3001  *                      MCI_MapMsg32WTo16                       [internal]
3002  *
3003  * Map a 32W bit MCI message to a 16 bit MCI message.
3004  */
3005 static  WINMM_MapType   MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
3006 {
3007     int         size;
3008     BOOLEAN     keep = FALSE;
3009     DWORD       map = 0;
3010
3011     if (*lParam == 0)
3012         return WINMM_MAP_OK;
3013
3014     /* FIXME: to add also (with seg/linear modifications to do):
3015      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
3016      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
3017      */
3018     switch (wMsg) {
3019     case MCI_BREAK:
3020         size = sizeof(MCI_BREAK_PARMS);
3021         break;
3022         /* case MCI_CAPTURE */
3023     case MCI_CLOSE:
3024     case MCI_CLOSE_DRIVER:
3025     case MCI_CONFIGURE:
3026         size = sizeof(MCI_GENERIC_PARMS);
3027         break;
3028         /* case MCI_COPY: */
3029     case MCI_CUE:
3030         switch (uDevType) {
3031         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS);       break;
3032         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_CUE_PARMS);     break;*/        FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3033         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3034         }
3035         break;
3036         /* case MCI_CUT:*/
3037     case MCI_DELETE:
3038         switch (uDevType) {
3039         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16);  map = 0x0F1111FB;       break;
3040         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS);   break;
3041         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3042         }
3043         break;
3044         /* case MCI_ESCAPE: */
3045     case MCI_FREEZE:
3046         switch (uDevType) {
3047         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS);    map = 0x0001111B;       break;
3048         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
3049         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3050         }
3051         break;
3052     case MCI_GETDEVCAPS:
3053         keep = TRUE;
3054         size = sizeof(MCI_GETDEVCAPS_PARMS);
3055         break;
3056         /* case MCI_INDEX: */
3057     case MCI_INFO:
3058         {
3059             LPMCI_INFO_PARMSW   mip32w = (LPMCI_INFO_PARMSW)(*lParam);
3060             char*               ptr;
3061             LPMCI_INFO_PARMS16  mip16;
3062
3063             switch (uDevType) {
3064             case MCI_DEVTYPE_DIGITAL_VIDEO:     size = sizeof(MCI_DGV_INFO_PARMS16);    break;
3065             default:                            size = sizeof(MCI_INFO_PARMS16);        break;
3066             }
3067             ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size);
3068             if (ptr)
3069             {
3070                 *(LPMCI_INFO_PARMSW*)ptr = mip32w;
3071                 mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW));
3072                 mip16->dwCallback  = mip32w->dwCallback;
3073                 mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) );
3074                 mip16->dwRetSize   = mip32w->dwRetSize / sizeof(WCHAR);
3075                 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
3076                     ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem;
3077                 }
3078             } else {
3079                 return WINMM_MAP_NOMEM;
3080             }
3081             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW);
3082         }
3083         return WINMM_MAP_OKMEM;
3084         /* case MCI_MARK: */
3085         /* case MCI_MONITOR: */
3086     case MCI_OPEN:
3087     case MCI_OPEN_DRIVER:
3088         {
3089             LPMCI_OPEN_PARMSW   mop32w = (LPMCI_OPEN_PARMSW)(*lParam);
3090             char* ptr = HeapAlloc( GetProcessHeap(), 0,
3091                                    sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
3092             LPMCI_OPEN_PARMS16  mop16;
3093
3094
3095             if (ptr) {
3096                 *(LPMCI_OPEN_PARMSW*)(ptr) = mop32w;
3097                 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW));
3098                 mop16->dwCallback       = mop32w->dwCallback;
3099                 mop16->wDeviceID        = mop32w->wDeviceID;
3100                 if (dwFlags & MCI_OPEN_TYPE) {
3101                     if (dwFlags & MCI_OPEN_TYPE_ID) {
3102                         /* dword "transparent" value */
3103                         mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType;
3104                     } else {
3105                         /* string */
3106                         mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) );
3107                     }
3108                 } else {
3109                     /* nuthin' */
3110                     mop16->lpstrDeviceType = 0;
3111                 }
3112                 if (dwFlags & MCI_OPEN_ELEMENT) {
3113                     if (dwFlags & MCI_OPEN_ELEMENT_ID) {
3114                         mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName;
3115                     } else {
3116                         mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) );
3117                     }
3118                 } else {
3119                     mop16->lpstrElementName = 0;
3120                 }
3121                 if (dwFlags & MCI_OPEN_ALIAS) {
3122                     mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) );
3123                 } else {
3124                     mop16->lpstrAlias = 0;
3125                 }
3126                 /* copy extended information if any...
3127                  * FIXME: this may seg fault if initial structure does not contain them and
3128                  * the reads after msip16 fail under LDT limits...
3129                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
3130                  * should not take care of extended parameters, and should be used by MCI_Open
3131                  * to fetch uDevType. When, this is known, the mapping for sending the
3132                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
3133                  */
3134                 memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD));
3135             } else {
3136                 return WINMM_MAP_NOMEM;
3137             }
3138             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW);
3139         }
3140         return WINMM_MAP_OKMEM;
3141         /* case MCI_PASTE:*/
3142     case MCI_PAUSE:
3143         size = sizeof(MCI_GENERIC_PARMS);
3144         break;
3145     case MCI_PLAY:
3146         size = sizeof(MCI_PLAY_PARMS);
3147         break;
3148     case MCI_PUT:
3149         switch (uDevType) {
3150         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
3151         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
3152         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3153         }
3154         break;
3155     case MCI_REALIZE:
3156         size = sizeof(MCI_GENERIC_PARMS);
3157         break;
3158     case MCI_RECORD:
3159         switch (uDevType) {
3160         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16);  map = 0x0F1111FB;       break;
3161         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_RECORD_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3162         default:                        size = sizeof(MCI_RECORD_PARMS);        break;
3163         }
3164         break;
3165     case MCI_RESUME:
3166         size = sizeof(MCI_GENERIC_PARMS);
3167         break;
3168     case MCI_SEEK:
3169         switch (uDevType) {
3170         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SEEK_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3171         default:                        size = sizeof(MCI_SEEK_PARMS);          break;
3172         }
3173         break;
3174     case MCI_SET:
3175         switch (uDevType) {
3176         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS);       break;
3177         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SET_PARMS);     break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3178         case MCI_DEVTYPE_SEQUENCER:     size = sizeof(MCI_SEQ_SET_PARMS);       break;
3179         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
3180          * so not doing anything should work...
3181          */
3182         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS);      break;
3183         default:                        size = sizeof(MCI_SET_PARMS);           break;
3184         }
3185         break;
3186     case MCI_SETAUDIO:
3187         switch (uDevType) {
3188         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;      break;
3189         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3190         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3191         }
3192         break;
3193         /* case MCI_SETTIMECODE:*/
3194         /* case MCI_SIGNAL:*/
3195         /* case MCI_SOUND:*/
3196     case MCI_SPIN:
3197         size = sizeof(MCI_SET_PARMS);
3198         break;
3199     case MCI_STATUS:
3200         keep = TRUE;
3201         switch (uDevType) {
3202         /* FIXME:
3203          * don't know if buffer for value is the one passed through lpstrDevice
3204          * or is provided by MCI driver.
3205          * Assuming solution 2: provided by MCI driver, so zeroing on entry
3206          */
3207         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16);  map = 0x0B6FF;          break;
3208         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3209         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
3210         }
3211         break;
3212     case MCI_STEP:
3213         switch (uDevType) {
3214         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS);      break;
3215         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STEP_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3216         case MCI_DEVTYPE_VIDEODISC:     size = sizeof(MCI_VD_STEP_PARMS);       break;
3217         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3218         }
3219         break;
3220     case MCI_STOP:
3221         size = sizeof(MCI_SET_PARMS);
3222         break;
3223     case MCI_SYSINFO:
3224         {
3225             LPMCI_SYSINFO_PARMSW  msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam);
3226             LPMCI_SYSINFO_PARMS16 msip16;
3227             char* ptr = HeapAlloc( GetProcessHeap(), 0,
3228                                    sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) );
3229
3230             if (ptr) {
3231                 *(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w;
3232                 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW));
3233
3234                 msip16->dwCallback       = msip32w->dwCallback;
3235                 msip16->lpstrReturn      = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) );
3236                 msip16->dwRetSize        = msip32w->dwRetSize;
3237                 msip16->dwNumber         = msip32w->dwNumber;
3238                 msip16->wDeviceType      = msip32w->wDeviceType;
3239             } else {
3240                 return WINMM_MAP_NOMEM;
3241             }
3242             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW);
3243         }
3244         return WINMM_MAP_OKMEM;
3245         /* case MCI_UNDO: */
3246     case MCI_UNFREEZE:
3247         switch (uDevType) {
3248         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
3249         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       break;
3250         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3251         }
3252         break;
3253     case MCI_UPDATE:
3254         switch (uDevType) {
3255         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16);  map = 0x000B1111B;      break;
3256         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3257         }
3258         break;
3259     case MCI_WHERE:
3260         switch (uDevType) {
3261         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       keep = TRUE;    break;
3262         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       keep = TRUE;    break;
3263         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3264         }
3265         break;
3266     case MCI_WINDOW:
3267         switch (uDevType) {
3268         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7FB;        break;
3269         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB;        break;
3270         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3271         }
3272         break;
3273     case DRV_OPEN:
3274         {
3275             LPMCI_OPEN_DRIVER_PARMSW  modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam);
3276             LPMCI_OPEN_DRIVER_PARMS16 modp16;
3277             char *ptr = HeapAlloc( GetProcessHeap(), 0,
3278                                    sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16));
3279
3280             if (ptr) {
3281                 *(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w;
3282                 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW));
3283                 modp16->wDeviceID = modp32w->wDeviceID;
3284                 modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) );
3285                 /* other fields are gonna be filled by the driver, don't copy them */
3286             } else {
3287                 return WINMM_MAP_NOMEM;
3288             }
3289             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW);
3290         }
3291         return WINMM_MAP_OKMEM;
3292     case DRV_LOAD:
3293     case DRV_ENABLE:
3294     case DRV_CLOSE:
3295     case DRV_DISABLE:
3296     case DRV_FREE:
3297     case DRV_CONFIGURE:
3298     case DRV_QUERYCONFIGURE:
3299     case DRV_INSTALL:
3300     case DRV_REMOVE:
3301     case DRV_EXITSESSION:
3302     case DRV_EXITAPPLICATION:
3303     case DRV_POWER:
3304         return WINMM_MAP_OK;
3305
3306     default:
3307         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
3308         return WINMM_MAP_MSGERROR;
3309     }
3310     return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep);
3311 }
3312
3313 /**************************************************************************
3314  *                      MCI_UnMapMsg32WTo16                     [internal]
3315  */
3316 static  WINMM_MapType   MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
3317 {
3318     int         size = 0;
3319     BOOLEAN     kept = FALSE;   /* there is no need to compute size when kept is FALSE */
3320     DWORD       map = 0;
3321
3322     switch (wMsg) {
3323     case MCI_BREAK:
3324         break;
3325         /* case MCI_CAPTURE */
3326     case MCI_CLOSE:
3327     case MCI_CLOSE_DRIVER:
3328     case MCI_CONFIGURE:
3329         break;
3330         /* case MCI_COPY: */
3331     case MCI_CUE:
3332         break;
3333         /* case MCI_CUT: */
3334     case MCI_DELETE:
3335         break;
3336         /* case MCI_ESCAPE: */
3337     case MCI_FREEZE:
3338         break;
3339     case MCI_GETDEVCAPS:
3340         kept = TRUE;
3341         size = sizeof(MCI_GETDEVCAPS_PARMS);
3342         break;
3343         /* case MCI_INDEX: */
3344     case MCI_INFO:
3345         if (lParam) {
3346             LPMCI_INFO_PARMS16  mip16  = (LPMCI_INFO_PARMS16)MapSL(lParam);
3347             LPMCI_INFO_PARMSW   mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW));
3348
3349             MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize,
3350                                 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR));
3351             UnMapLS( lParam );
3352             UnMapLS( mip16->lpstrReturn );
3353             HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) );
3354             HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) );
3355         }
3356         return WINMM_MAP_OK;
3357         /* case MCI_MARK: */
3358         /* case MCI_MONITOR: */
3359     case MCI_OPEN:
3360     case MCI_OPEN_DRIVER:
3361         if (lParam) {
3362             LPMCI_OPEN_PARMS16  mop16  = (LPMCI_OPEN_PARMS16)MapSL(lParam);
3363             LPMCI_OPEN_PARMSW   mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW));
3364             UnMapLS( lParam );
3365             mop32w->wDeviceID = mop16->wDeviceID;
3366             if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
3367             {
3368                 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType));
3369                 UnMapLS( mop16->lpstrDeviceType );
3370             }
3371             if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
3372             {
3373                 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName));
3374                 UnMapLS( mop16->lpstrElementName );
3375             }
3376             if (dwFlags & MCI_OPEN_ALIAS)
3377             {
3378                 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias));
3379                 UnMapLS( mop16->lpstrAlias );
3380             }
3381             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) );
3382         }
3383         return WINMM_MAP_OK;
3384         /* case MCI_PASTE:*/
3385     case MCI_PAUSE:
3386         break;
3387     case MCI_PLAY:
3388         break;
3389     case MCI_PUT:
3390         break;
3391     case MCI_REALIZE:
3392         break;
3393     case MCI_RECORD:
3394         break;
3395     case MCI_RESUME:
3396         break;
3397     case MCI_SEEK:
3398         break;
3399     case MCI_SET:
3400         break;
3401     case MCI_SETAUDIO:
3402         switch (uDevType) {
3403         case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF;      break;
3404         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3405         }
3406         break;
3407         /* case MCI_SETTIMECODE:*/
3408         /* case MCI_SIGNAL:*/
3409         /* case MCI_SOUND:*/
3410     case MCI_SPIN:
3411         break;
3412     case MCI_STATUS:
3413         kept = TRUE;
3414         switch (uDevType) {
3415         case MCI_DEVTYPE_DIGITAL_VIDEO:
3416         if (lParam) {
3417             LPMCI_DGV_STATUS_PARMS16    mdsp16  = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
3418             LPMCI_DGV_STATUS_PARMSA     mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
3419
3420             UnMapLS( lParam );
3421             if (mdsp16) {
3422                 mdsp32a->dwReturn = mdsp16->dwReturn;
3423                 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
3424                     TRACE("MCI_STATUS (DGV) lpstrDrive=%08x\n", mdsp16->lpstrDrive);
3425                     TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
3426                     UnMapLS( mdsp16->lpstrDrive );
3427                 }
3428                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
3429             } else {
3430                 return WINMM_MAP_NOMEM;
3431             }
3432         }
3433         return WINMM_MAP_OKMEM;
3434         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3435         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
3436         }
3437         break;
3438     case MCI_STEP:
3439         break;
3440     case MCI_STOP:
3441         break;
3442     case MCI_SYSINFO:
3443         if (lParam) {
3444             LPMCI_SYSINFO_PARMS16       msip16  = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
3445             LPMCI_SYSINFO_PARMSW        msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW));
3446
3447             UnMapLS( lParam );
3448             if (msip16) {
3449                 MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize,
3450                                     msip32w->lpstrReturn, msip32w->dwRetSize/sizeof(WCHAR));
3451                 UnMapLS( msip16->lpstrReturn );
3452                 HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) );
3453                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) );
3454             } else {
3455                 return WINMM_MAP_NOMEM;
3456             }
3457         }
3458         return WINMM_MAP_OKMEM;
3459         /* case MCI_UNDO: */
3460     case MCI_UNFREEZE:
3461         break;
3462     case MCI_UPDATE:
3463         break;
3464     case MCI_WHERE:
3465         switch (uDevType) {
3466         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       kept = TRUE;    break;
3467         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       kept = TRUE;    break;
3468         default:                        break;
3469         }
3470         break;
3471     case MCI_WINDOW:
3472         switch (uDevType) {
3473         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7666;       break;
3474         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666;       break;
3475         default:                        break;
3476         }
3477         /* FIXME: see map function */
3478         break;
3479     case DRV_OPEN:
3480         if (lParam) {
3481             LPMCI_OPEN_DRIVER_PARMS16   modp16  = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
3482             LPMCI_OPEN_DRIVER_PARMSW    modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW));
3483
3484             UnMapLS( lParam );
3485             modp32w->wCustomCommandTable = modp16->wCustomCommandTable;
3486             modp32w->wType = modp16->wType;
3487             HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams));
3488             UnMapLS( modp16->lpstrParams );
3489             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) );
3490         }
3491         return WINMM_MAP_OK;
3492     case DRV_LOAD:
3493     case DRV_ENABLE:
3494     case DRV_CLOSE:
3495     case DRV_DISABLE:
3496     case DRV_FREE:
3497     case DRV_CONFIGURE:
3498     case DRV_QUERYCONFIGURE:
3499     case DRV_INSTALL:
3500     case DRV_REMOVE:
3501     case DRV_EXITSESSION:
3502     case DRV_EXITAPPLICATION:
3503     case DRV_POWER:
3504         FIXME("This is a hack\n");
3505         return WINMM_MAP_OK;
3506
3507     default:
3508         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
3509         return WINMM_MAP_MSGERROR;
3510     }
3511     return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept);
3512 }
3513
3514 void    MMDRV_Init16(void)
3515 {
3516 #define A(_x,_y) MMDRV_InstallMap(_x, \
3517 MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \
3518 MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \
3519 MMDRV_##_y##_Callback)
3520     A(MMDRV_AUX,        Aux);
3521     A(MMDRV_MIXER,      Mixer);
3522     A(MMDRV_MIDIIN,     MidiIn);
3523     A(MMDRV_MIDIOUT,    MidiOut);
3524     A(MMDRV_WAVEIN,     WaveIn);
3525     A(MMDRV_WAVEOUT,    WaveOut);
3526 #undef A
3527
3528     pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
3529     pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
3530
3531     pFnMciMapMsg16To32W   = MCI_MapMsg16To32W;
3532     pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W;
3533     pFnMciMapMsg32WTo16   = MCI_MapMsg32WTo16;
3534     pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16;
3535 }