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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 dwParam1, DWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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 dwInstance, DWORD dwParam1, DWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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 dwInstance, DWORD dwParam1, DWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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 dwInstance, DWORD dwParam1, DWORD 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 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, LPDWORD lpParam1, LPDWORD 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 %ld to %ld, 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, LPDWORD lpParam1, LPDWORD 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, LPDWORD lpParam1, LPDWORD 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=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n",
 495                       *lpParam1, (DWORD)mh16->lpData,
 496                       mh32->dwBufferLength, (DWORD)mh32->lpData);
 497                 *lpParam2 = sizeof(MIDIHDR);
 498
 499                 ret = WINMM_MAP_OKMEM;
 500             } else {
 501                 ret = WINMM_MAP_NOMEM;
 502             }
 503         }
 504         break;
 505     case MODM_UNPREPARE:
 506     case MODM_LONGDATA:
 507         {
 508             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
 509             LPMIDIHDR           mh16 = (LPMIDIHDR)mh32->lpNext;
 510             LPSTR               ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
 511
 512             assert(*(LPMIDIHDR*)ptr == mh32);
 513
 514             if (wMsg == MODM_LONGDATA)
 515                 memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
 516
 517             *lpParam1 = MapLS(mh16);
 518             *lpParam2 = sizeof(MIDIHDR);
 519             TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n",
 520                   *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData);
 521
 522             /* dwBufferLength can be reduced between prepare & write */
 523             if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
 524                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
 525                     mh16->dwBufferLength, mh32->dwBufferLength);
 526             } else
 527                 mh16->dwBufferLength = mh32->dwBufferLength;
 528             ret = WINMM_MAP_OKMEM;
 529         }
 530         break;
 531     case MODM_OPEN:
 532         {
 533             LPMIDIOPENDESC              mod32 = (LPMIDIOPENDESC)*lpParam1;
 534             LPVOID                      ptr;
 535             LPMIDIOPENDESC16            mod16;
 536
 537             /* allocated data are mapped as follows:
 538                LPMIDIOPENDESC   ptr to orig lParam1
 539                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
 540                DWORD            dwUser passed to driver
 541                MIDIOPENDESC16   mod16: openDesc passed to driver
 542                MIDIOPENSTRMID   cIds
 543             */
 544             ptr = HeapAlloc( GetProcessHeap(), 0,
 545                              sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
 546                              mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
 547
 548             if (ptr) {
 549                 SEGPTR segptr = MapLS(ptr);
 550                 *(LPMIDIOPENDESC*)ptr = mod32;
 551                 *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
 552                 mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
 553
 554                 mod16->hMidi = HMIDI_16(mod32->hMidi);
 555                 mod16->dwCallback = mod32->dwCallback;
 556                 mod16->dwInstance = mod32->dwInstance;
 557                 mod16->dnDevNode = mod32->dnDevNode;
 558                 mod16->cIds = mod32->cIds;
 559                 memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
 560
 561                 *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
 562                 *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
 563
 564                 ret = WINMM_MAP_OKMEM;
 565             } else {
 566                 ret = WINMM_MAP_NOMEM;
 567             }
 568         }
 569         break;
 570     case MODM_GETVOLUME:
 571     case MODM_CACHEPATCHES:
 572     case MODM_CACHEDRUMPATCHES:
 573     default:
 574         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 575         break;
 576     }
 577     return ret;
 578 }
 579
 580 /**************************************************************************
 581  *                              MMDRV_MidiOut_UnMap32WTo16      [internal]
 582  */
 583 static  WINMM_MapType   MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 584 {
 585     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 586
 587     switch (wMsg) {
 588     case MODM_CLOSE:
 589     case MODM_GETNUMDEVS:
 590     case MODM_DATA:
 591     case MODM_RESET:
 592     case MODM_SETVOLUME:
 593         ret = WINMM_MAP_OK;
 594         break;
 595     case MODM_GETDEVCAPS:
 596         {
 597             LPMIDIOUTCAPS16             moc16 = MapSL(*lpParam1);
 598             LPSTR                       ptr   = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSW);
 599             LPMIDIOUTCAPSW              moc32 = *(LPMIDIOUTCAPSW*)ptr;
 600
 601             moc32->wMid                 = moc16->wMid;
 602             moc32->wPid                 = moc16->wPid;
 603             moc32->vDriverVersion       = moc16->vDriverVersion;
 604             WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
 605                                  sizeof(moc16->szPname), NULL, NULL );
 606             moc32->wTechnology          = moc16->wTechnology;
 607             moc32->wVoices              = moc16->wVoices;
 608             moc32->wNotes               = moc16->wNotes;
 609             moc32->wChannelMask         = moc16->wChannelMask;
 610             moc32->dwSupport            = moc16->dwSupport;
 611             UnMapLS( *lpParam1 );
 612             HeapFree( GetProcessHeap(), 0, ptr );
 613             ret = WINMM_MAP_OK;
 614         }
 615         break;
 616     case MODM_PREPARE:
 617     case MODM_UNPREPARE:
 618     case MODM_LONGDATA:
 619         {
 620             LPMIDIHDR           mh16 = MapSL(*lpParam1);
 621             LPSTR               ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
 622             LPMIDIHDR           mh32 = *(LPMIDIHDR*)ptr;
 623
 624             assert(mh32->lpNext == (LPMIDIHDR)mh16);
 625             UnMapLS( *lpParam1 );
 626             mh32->dwBytesRecorded = mh16->dwBytesRecorded;
 627             mh32->dwUser = mh16->dwUser;
 628             mh32->dwFlags = mh16->dwFlags;
 629
 630             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 631                 HeapFree( GetProcessHeap(), 0, ptr );
 632                 mh32->lpNext = 0;
 633             }
 634             ret = WINMM_MAP_OK;
 635         }
 636         break;
 637     case MODM_OPEN:
 638         {
 639             LPMIDIOPENDESC16            mod16 = MapSL(*lpParam1);
 640             LPSTR                       ptr   = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
 641             UnMapLS( *lpParam1 );
 642             **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
 643
 644             HeapFree( GetProcessHeap(), 0, ptr );
 645             ret = WINMM_MAP_OK;
 646         }
 647         break;
 648     case MODM_GETVOLUME:
 649     case MODM_CACHEPATCHES:
 650     case MODM_CACHEDRUMPATCHES:
 651     default:
 652         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 653         break;
 654     }
 655     return ret;
 656 }
 657
 658 /**************************************************************************
 659  *                              MMDRV_MidiOut_Callback          [internal]
 660  */
 661 static  void    CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
 662 {
 663     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
 664
 665     switch (uMsg) {
 666     case MOM_OPEN:
 667     case MOM_CLOSE:
 668         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
 669         break;
 670     case MOM_DONE:
 671         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
 672             /* initial map is: 32 => 16 */
 673             LPMIDIHDR           mh16 = MapSL(dwParam1);
 674             LPMIDIHDR           mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
 675
 676             dwParam1 = (DWORD)mh32;
 677             mh32->dwFlags = mh16->dwFlags;
 678             mh32->dwOffset = mh16->dwOffset;
 679             if (mh32->reserved >= sizeof(MIDIHDR))
 680                 mh32->dwOffset = mh16->dwOffset;
 681         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
 682             /* initial map is: 16 => 32 */
 683             LPMIDIHDR           mh32 = (LPMIDIHDR)(dwParam1);
 684             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
 685             LPMIDIHDR           mh16 = MapSL(segmh16);
 686
 687             dwParam1 = (DWORD)segmh16;
 688             mh16->dwFlags = mh32->dwFlags;
 689             if (mh16->reserved >= sizeof(MIDIHDR))
 690                 mh16->dwOffset = mh32->dwOffset;
 691         }
 692         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
 693         break;
 694     /* case MOM_POSITIONCB: */
 695     default:
 696         ERR("Unknown msg %u\n", uMsg);
 697     }
 698
 699     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
 700 }
 701
 702 /* =================================
 703  *   W A V E  I N    M A P P E R S
 704  * ================================= */
 705
 706 /**************************************************************************
 707  *                              MMDRV_WaveIn_Map16To32W         [internal]
 708  */
 709 static  WINMM_MapType   MMDRV_WaveIn_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 710 {
 711     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 712
 713     switch (wMsg) {
 714     case WIDM_GETNUMDEVS:
 715     case WIDM_RESET:
 716     case WIDM_START:
 717     case WIDM_STOP:
 718         ret = WINMM_MAP_OK;
 719         break;
 720     case WIDM_OPEN:
 721     case WIDM_CLOSE:
 722         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 723         break;
 724     case WIDM_GETDEVCAPS:
 725         {
 726             LPWAVEINCAPSW       wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
 727             LPWAVEINCAPS16      wic16 = MapSL(*lpParam1);
 728
 729             if (wic32) {
 730                 *(LPWAVEINCAPS16*)wic32 = wic16;
 731                 wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
 732                 *lpParam1 = (DWORD)wic32;
 733                 *lpParam2 = sizeof(WAVEINCAPSW);
 734
 735                 ret = WINMM_MAP_OKMEM;
 736             } else {
 737                 ret = WINMM_MAP_NOMEM;
 738             }
 739         }
 740         break;
 741     case WIDM_GETPOS:
 742         {
 743             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
 744             LPMMTIME16          mmt16 = MapSL(*lpParam1);
 745
 746             if (mmt32) {
 747                 *(LPMMTIME16*)mmt32 = mmt16;
 748                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
 749
 750                 mmt32->wType = mmt16->wType;
 751                 *lpParam1 = (DWORD)mmt32;
 752                 *lpParam2 = sizeof(MMTIME);
 753
 754                 ret = WINMM_MAP_OKMEM;
 755             } else {
 756                 ret = WINMM_MAP_NOMEM;
 757             }
 758         }
 759         break;
 760     case WIDM_PREPARE:
 761         {
 762             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
 763             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 764
 765             if (wh32) {
 766                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
 767                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
 768                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
 769                 wh32->dwBufferLength = wh16->dwBufferLength;
 770                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
 771                 wh32->dwUser = wh16->dwUser;
 772                 wh32->dwFlags = wh16->dwFlags;
 773                 wh32->dwLoops = wh16->dwLoops;
 774                 /* FIXME: nothing on wh32->lpNext */
 775                 /* could link the wh32->lpNext at this level for memory house keeping */
 776                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
 777                 *lpParam1 = (DWORD)wh32;
 778                 *lpParam2 = sizeof(WAVEHDR);
 779
 780                 ret = WINMM_MAP_OKMEM;
 781             } else {
 782                 ret = WINMM_MAP_NOMEM;
 783             }
 784         }
 785         break;
 786     case WIDM_ADDBUFFER:
 787     case WIDM_UNPREPARE:
 788         {
 789             LPWAVEHDR           wh16 = MapSL(*lpParam1);
 790             LPWAVEHDR           wh32 = (LPWAVEHDR)wh16->lpNext;
 791
 792             *lpParam1 = (DWORD)wh32;
 793             *lpParam2 = sizeof(WAVEHDR);
 794             /* dwBufferLength can be reduced between prepare & write */
 795             if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
 796                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
 797                     wh32->dwBufferLength, wh16->dwBufferLength);
 798             } else
 799                 wh32->dwBufferLength = wh16->dwBufferLength;
 800             ret = WINMM_MAP_OKMEM;
 801         }
 802         break;
 803     case WIDM_MAPPER_STATUS:
 804         /* just a single DWORD */
 805         *lpParam2 = (DWORD)MapSL(*lpParam2);
 806         ret = WINMM_MAP_OK;
 807         break;
 808     default:
 809         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 810         break;
 811     }
 812     return ret;
 813 }
 814
 815 /**************************************************************************
 816  *                              MMDRV_WaveIn_UnMap16To32W       [internal]
 817  */
 818 static  WINMM_MapType   MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
 819 {
 820     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 821
 822     switch (wMsg) {
 823     case WIDM_GETNUMDEVS:
 824     case WIDM_RESET:
 825     case WIDM_START:
 826     case WIDM_STOP:
 827     case WIDM_MAPPER_STATUS:
 828         ret = WINMM_MAP_OK;
 829         break;
 830     case WIDM_OPEN:
 831     case WIDM_CLOSE:
 832         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
 833         break;
 834     case WIDM_GETDEVCAPS:
 835         {
 836             LPWAVEINCAPSW               wic32 = (LPWAVEINCAPSW)(*lpParam1);
 837             LPWAVEINCAPS16              wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 838
 839             wic16->wMid = wic32->wMid;
 840             wic16->wPid = wic32->wPid;
 841             wic16->vDriverVersion = wic32->vDriverVersion;
 842             WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
 843                                  sizeof(wic16->szPname), NULL, NULL );
 844             wic16->dwFormats = wic32->dwFormats;
 845             wic16->wChannels = wic32->wChannels;
 846             HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
 847             ret = WINMM_MAP_OK;
 848         }
 849         break;
 850     case WIDM_GETPOS:
 851         {
 852             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
 853             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
 854
 855             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
 856             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
 857             ret = WINMM_MAP_OK;
 858         }
 859         break;
 860     case WIDM_ADDBUFFER:
 861     case WIDM_PREPARE:
 862     case WIDM_UNPREPARE:
 863         {
 864             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 865             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
 866
 867             assert(wh16->lpNext == wh32);
 868             wh16->dwBufferLength = wh32->dwBufferLength;
 869             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
 870             wh16->dwUser = wh32->dwUser;
 871             wh16->dwFlags = wh32->dwFlags;
 872             wh16->dwLoops = wh32->dwLoops;
 873
 874             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
 875                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
 876                 wh16->lpNext = 0;
 877             }
 878             ret = WINMM_MAP_OK;
 879         }
 880         break;
 881     default:
 882         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
 883         break;
 884     }
 885     return ret;
 886 }
 887
 888 /**************************************************************************
 889  *                              MMDRV_WaveIn_Map32WTo16         [internal]
 890  */
 891 static  WINMM_MapType   MMDRV_WaveIn_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
 892 {
 893     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
 894
 895     switch (wMsg) {
 896     case WIDM_CLOSE:
 897     case WIDM_GETNUMDEVS:
 898     case WIDM_RESET:
 899     case WIDM_START:
 900     case WIDM_STOP:
 901         ret = WINMM_MAP_OK;
 902         break;
 903
 904     case WIDM_OPEN:
 905         {
 906             LPWAVEOPENDESC              wod32 = (LPWAVEOPENDESC)*lpParam1;
 907             int                         sz = sizeof(WAVEFORMATEX);
 908             LPVOID                      ptr;
 909             LPWAVEOPENDESC16            wod16;
 910
 911             /* allocated data are mapped as follows:
 912                LPWAVEOPENDESC   ptr to orig lParam1
 913                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
 914                DWORD            dwUser passed to driver
 915                WAVEOPENDESC16   wod16: openDesc passed to driver
 916                WAVEFORMATEX     openDesc->lpFormat passed to driver
 917                xxx              extra bytes to WAVEFORMATEX
 918             */
 919             if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
 920                 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
 921                 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
 922             }
 923
 924             ptr = HeapAlloc( GetProcessHeap(), 0,
 925                              sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
 926
 927             if (ptr) {
 928                 SEGPTR seg_ptr = MapLS( ptr );
 929                 *(LPWAVEOPENDESC*)ptr = wod32;
 930                 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
 931                 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
 932
 933                 wod16->hWave = HWAVE_16(wod32->hWave);
 934                 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
 935                 memcpy(wod16 + 1, wod32->lpFormat, sz);
 936
 937                 wod16->dwCallback = wod32->dwCallback;
 938                 wod16->dwInstance = wod32->dwInstance;
 939                 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
 940                 wod16->dnDevNode = wod32->dnDevNode;
 941
 942                 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
 943                 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
 944
 945                 ret = WINMM_MAP_OKMEM;
 946             } else {
 947                 ret = WINMM_MAP_NOMEM;
 948             }
 949         }
 950         break;
 951     case WIDM_PREPARE:
 952         {
 953             LPWAVEHDR           wh32 = (LPWAVEHDR)*lpParam1;
 954             LPWAVEHDR           wh16;
 955             LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
 956                                     sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
 957
 958             if (ptr) {
 959                 SEGPTR seg_ptr = MapLS( ptr );
 960                 *(LPWAVEHDR*)ptr = wh32;
 961                 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
 962                 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
 963                 /* data will be copied on WODM_WRITE */
 964                 wh16->dwBufferLength = wh32->dwBufferLength;
 965                 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
 966                 wh16->dwUser = wh32->dwUser;
 967                 wh16->dwFlags = wh32->dwFlags;
 968                 wh16->dwLoops = wh32->dwLoops;
 969                 /* FIXME: nothing on wh32->lpNext */
 970                 /* could link the wh32->lpNext at this level for memory house keeping */
 971                 wh32->lpNext = wh16; /* for reuse in unprepare and write */
 972                 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
 973                       seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
 974                       wh32->dwBufferLength, (DWORD)wh32->lpData);
 975                 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
 976                 *lpParam2 = sizeof(WAVEHDR);
 977
 978                 ret = WINMM_MAP_OKMEM;
 979             } else {
 980                 ret = WINMM_MAP_NOMEM;
 981             }
 982         }
 983         break;
 984     case WIDM_ADDBUFFER:
 985     case WIDM_UNPREPARE:
 986         {
 987             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
 988             LPWAVEHDR           wh16 = wh32->lpNext;
 989             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
 990             SEGPTR seg_ptr = MapLS( ptr );
 991
 992             assert(*(LPWAVEHDR*)ptr == wh32);
 993
 994             TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
 995                   seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
 996                   wh32->dwBufferLength, (DWORD)wh32->lpData);
 997
 998             if (wMsg == WIDM_ADDBUFFER)
 999                 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
1000
1001             *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1002             *lpParam2 = sizeof(WAVEHDR);
1003             /* dwBufferLength can be reduced between prepare & write */
1004             if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
1005                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1006                     wh16->dwBufferLength, wh32->dwBufferLength);
1007             } else
1008                 wh16->dwBufferLength = wh32->dwBufferLength;
1009             ret = WINMM_MAP_OKMEM;
1010         }
1011         break;
1012    case WIDM_GETDEVCAPS:
1013         {
1014             LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)*lpParam1;
1015             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSW) + sizeof(WAVEINCAPS16));
1016
1017             if (ptr) {
1018                 *(LPWAVEINCAPSW*)ptr = wic32;
1019                 ret = WINMM_MAP_OKMEM;
1020             } else {
1021                 ret = WINMM_MAP_NOMEM;
1022             }
1023             *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSW);
1024             *lpParam2 = sizeof(WAVEINCAPS16);
1025         }
1026         break;
1027     case WIDM_GETPOS:
1028         {
1029             LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1030             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1031             LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1032
1033             if (ptr) {
1034                 *(LPMMTIME*)ptr = mmt32;
1035                 mmt16->wType = mmt32->wType;
1036                 ret = WINMM_MAP_OKMEM;
1037             } else {
1038                 ret = WINMM_MAP_NOMEM;
1039             }
1040             *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1041             *lpParam2 = sizeof(MMTIME16);
1042         }
1043         break;
1044     case DRVM_MAPPER_STATUS:
1045         {
1046             LPDWORD p32 = (LPDWORD)*lpParam2;
1047             *lpParam2 = MapLS(p32);
1048             ret = WINMM_MAP_OKMEM;
1049         }
1050         break;
1051     default:
1052         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1053         break;
1054     }
1055     return ret;
1056 }
1057
1058 /**************************************************************************
1059  *                              MMDRV_WaveIn_UnMap32WTo16       [internal]
1060  */
1061 static  WINMM_MapType   MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1062 {
1063     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1064
1065     switch (wMsg) {
1066     case WIDM_CLOSE:
1067     case WIDM_GETNUMDEVS:
1068     case WIDM_RESET:
1069     case WIDM_START:
1070     case WIDM_STOP:
1071         ret = WINMM_MAP_OK;
1072         break;
1073
1074     case WIDM_OPEN:
1075         {
1076             LPWAVEOPENDESC16            wod16 = MapSL(*lpParam1);
1077             LPSTR                       ptr   = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1078             LPWAVEOPENDESC              wod32 = *(LPWAVEOPENDESC*)ptr;
1079
1080             UnMapLS( *lpParam1 );
1081             wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1082             **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1083             HeapFree( GetProcessHeap(), 0, ptr );
1084             ret = WINMM_MAP_OK;
1085         }
1086         break;
1087
1088     case WIDM_ADDBUFFER:
1089     case WIDM_PREPARE:
1090     case WIDM_UNPREPARE:
1091         {
1092             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1093             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1094             LPWAVEHDR           wh32 = *(LPWAVEHDR*)ptr;
1095
1096             assert(wh32->lpNext == wh16);
1097             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1098             wh32->dwUser = wh16->dwUser;
1099             wh32->dwFlags = wh16->dwFlags;
1100             wh32->dwLoops = wh16->dwLoops;
1101             UnMapLS( *lpParam1 );
1102
1103             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1104                 HeapFree( GetProcessHeap(), 0, ptr );
1105                 wh32->lpNext = 0;
1106             }
1107             ret = WINMM_MAP_OK;
1108         }
1109         break;
1110      case WIDM_GETDEVCAPS:
1111         {
1112             LPWAVEINCAPS16              wic16 = MapSL(*lpParam1);
1113             LPSTR                       ptr   = (LPSTR)wic16 - sizeof(LPWAVEINCAPSW);
1114             LPWAVEINCAPSW               wic32 = *(LPWAVEINCAPSW*)ptr;
1115
1116             wic32->wMid = wic16->wMid;
1117             wic32->wPid = wic16->wPid;
1118             wic32->vDriverVersion = wic16->vDriverVersion;
1119             WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
1120                                  sizeof(wic16->szPname), NULL, NULL );
1121             wic32->dwFormats = wic16->dwFormats;
1122             wic32->wChannels = wic16->wChannels;
1123             UnMapLS( *lpParam1 );
1124             HeapFree( GetProcessHeap(), 0, ptr );
1125             ret = WINMM_MAP_OK;
1126         }
1127         break;
1128     case WIDM_GETPOS:
1129         {
1130             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1131             LPSTR               ptr   = (LPSTR)mmt16 - sizeof(LPMMTIME);
1132             LPMMTIME            mmt32 = *(LPMMTIME*)ptr;
1133
1134             MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1135             UnMapLS( *lpParam1 );
1136             HeapFree( GetProcessHeap(), 0, ptr );
1137             ret = WINMM_MAP_OK;
1138         }
1139         break;
1140     case DRVM_MAPPER_STATUS:
1141         {
1142             UnMapLS( *lpParam2 );
1143             ret = WINMM_MAP_OK;
1144         }
1145         break;
1146     default:
1147         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1148         break;
1149     }
1150     return ret;
1151 }
1152
1153 /**************************************************************************
1154  *                              MMDRV_WaveIn_Callback           [internal]
1155  */
1156 static  void    CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
1157 {
1158     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
1159
1160     switch (uMsg) {
1161     case WIM_OPEN:
1162     case WIM_CLOSE:
1163         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1164         break;
1165     case WIM_DATA:
1166         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1167             /* initial map is: 32 => 16 */
1168             LPWAVEHDR           wh16 = MapSL(dwParam1);
1169             LPWAVEHDR           wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1170
1171             dwParam1 = (DWORD)wh32;
1172             wh32->dwFlags = wh16->dwFlags;
1173             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1174         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1175             /* initial map is: 16 => 32 */
1176             LPWAVEHDR           wh32 = (LPWAVEHDR)(dwParam1);
1177             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1178             LPWAVEHDR           wh16 = MapSL(segwh16);
1179
1180             dwParam1 = (DWORD)segwh16;
1181             wh16->dwFlags = wh32->dwFlags;
1182             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1183         }
1184         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1185         break;
1186     default:
1187         ERR("Unknown msg %u\n", uMsg);
1188     }
1189
1190     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1191 }
1192
1193 /* =================================
1194  *   W A V E  O U T  M A P P E R S
1195  * ================================= */
1196
1197 /**************************************************************************
1198  *                              MMDRV_WaveOut_Map16To32W        [internal]
1199  */
1200 static  WINMM_MapType   MMDRV_WaveOut_Map16To32W  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
1201 {
1202     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1203
1204     switch (wMsg) {
1205     /* nothing to do */
1206     case WODM_BREAKLOOP:
1207     case WODM_CLOSE:
1208     case WODM_GETNUMDEVS:
1209     case WODM_PAUSE:
1210     case WODM_RESET:
1211     case WODM_RESTART:
1212     case WODM_SETPITCH:
1213     case WODM_SETPLAYBACKRATE:
1214     case WODM_SETVOLUME:
1215         ret = WINMM_MAP_OK;
1216         break;
1217
1218     case WODM_GETPITCH:
1219     case WODM_GETPLAYBACKRATE:
1220     case WODM_GETVOLUME:
1221     case WODM_OPEN:
1222         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
1223         break;
1224
1225     case WODM_GETDEVCAPS:
1226         {
1227             LPWAVEOUTCAPSW              woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
1228             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
1229
1230             if (woc32) {
1231                 *(LPWAVEOUTCAPS16*)woc32 = woc16;
1232                 woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
1233                 *lpParam1 = (DWORD)woc32;
1234                 *lpParam2 = sizeof(WAVEOUTCAPSW);
1235
1236                 ret = WINMM_MAP_OKMEM;
1237             } else {
1238                 ret = WINMM_MAP_NOMEM;
1239             }
1240         }
1241         break;
1242     case WODM_GETPOS:
1243         {
1244             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
1245             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1246
1247             if (mmt32) {
1248                 *(LPMMTIME16*)mmt32 = mmt16;
1249                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
1250
1251                 mmt32->wType = mmt16->wType;
1252                 *lpParam1 = (DWORD)mmt32;
1253                 *lpParam2 = sizeof(MMTIME);
1254
1255                 ret = WINMM_MAP_OKMEM;
1256             } else {
1257                 ret = WINMM_MAP_NOMEM;
1258             }
1259         }
1260         break;
1261     case WODM_PREPARE:
1262         {
1263             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
1264             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1265
1266             if (wh32) {
1267                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
1268                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
1269                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
1270                 wh32->dwBufferLength = wh16->dwBufferLength;
1271                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1272                 wh32->dwUser = wh16->dwUser;
1273                 wh32->dwFlags = wh16->dwFlags;
1274                 wh32->dwLoops = wh16->dwLoops;
1275                 /* FIXME: nothing on wh32->lpNext */
1276                 /* could link the wh32->lpNext at this level for memory house keeping */
1277                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
1278                 *lpParam1 = (DWORD)wh32;
1279                 *lpParam2 = sizeof(WAVEHDR);
1280
1281                 ret = WINMM_MAP_OKMEM;
1282             } else {
1283                 ret = WINMM_MAP_NOMEM;
1284             }
1285         }
1286         break;
1287     case WODM_UNPREPARE:
1288     case WODM_WRITE:
1289         {
1290             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1291             LPWAVEHDR           wh32 = (LPWAVEHDR)wh16->lpNext;
1292
1293             *lpParam1 = (DWORD)wh32;
1294             *lpParam2 = sizeof(WAVEHDR);
1295             /* dwBufferLength can be reduced between prepare & write */
1296             if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
1297                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1298                     wh32->dwBufferLength, wh16->dwBufferLength);
1299             } else
1300                 wh32->dwBufferLength = wh16->dwBufferLength;
1301             ret = WINMM_MAP_OKMEM;
1302         }
1303         break;
1304     case WODM_MAPPER_STATUS:
1305         *lpParam2 = (DWORD)MapSL(*lpParam2);
1306         ret = WINMM_MAP_OK;
1307         break;
1308     default:
1309         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1310         break;
1311     }
1312     return ret;
1313 }
1314
1315 /**************************************************************************
1316  *                              MMDRV_WaveOut_UnMap16To32W      [internal]
1317  */
1318 static  WINMM_MapType   MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1319 {
1320     WINMM_MapType       ret = WINMM_MAP_MSGERROR;
1321
1322     switch (wMsg) {
1323     /* nothing to do */
1324     case WODM_BREAKLOOP:
1325     case WODM_CLOSE:
1326     case WODM_GETNUMDEVS:
1327     case WODM_PAUSE:
1328     case WODM_RESET:
1329     case WODM_RESTART:
1330     case WODM_SETPITCH:
1331     case WODM_SETPLAYBACKRATE:
1332     case WODM_SETVOLUME:
1333     case WODM_MAPPER_STATUS:
1334         ret = WINMM_MAP_OK;
1335         break;
1336
1337     case WODM_GETPITCH:
1338     case WODM_GETPLAYBACKRATE:
1339     case WODM_GETVOLUME:
1340     case WODM_OPEN:
1341         FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
1342         break;
1343
1344     case WODM_GETDEVCAPS:
1345         {
1346             LPWAVEOUTCAPSW              woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
1347             LPWAVEOUTCAPS16             woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1348
1349             woc16->wMid = woc32->wMid;
1350             woc16->wPid = woc32->wPid;
1351             woc16->vDriverVersion = woc32->vDriverVersion;
1352             WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
1353                                  sizeof(woc16->szPname), NULL, NULL );
1354             woc16->dwFormats = woc32->dwFormats;
1355             woc16->wChannels = woc32->wChannels;
1356             woc16->dwSupport = woc32->dwSupport;
1357             HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1358             ret = WINMM_MAP_OK;
1359         }
1360         break;
1361     case WODM_GETPOS:
1362         {
1363             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
1364             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
1365
1366             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
1367             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
1368             ret = WINMM_MAP_OK;
1369         }
1370         break;
1371     case WODM_PREPARE:
1372     case WODM_UNPREPARE:
1373     case WODM_WRITE:
1374         {
1375             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
1376             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
1377
1378             assert(wh16->lpNext == wh32);
1379             wh16->dwBufferLength = wh32->dwBufferLength;
1380             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1381             wh16->dwUser = wh32->dwUser;
1382             wh16->dwFlags = wh32->dwFlags;
1383             wh16->dwLoops = wh32->dwLoops;
1384
1385             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1386                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
1387                 wh16->lpNext = 0;
1388             }
1389             ret = WINMM_MAP_OK;
1390         }
1391         break;
1392     default:
1393         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1394         break;
1395     }
1396     return ret;
1397 }
1398
1399 /**************************************************************************
1400  *                              MMDRV_WaveOut_Map32WTo16        [internal]
1401  */
1402 static  WINMM_MapType   MMDRV_WaveOut_Map32WTo16  (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
1403 {
1404     WINMM_MapType       ret;
1405
1406     switch (wMsg) {
1407         /* nothing to do */
1408     case WODM_BREAKLOOP:
1409     case WODM_CLOSE:
1410     case WODM_GETNUMDEVS:
1411     case WODM_PAUSE:
1412     case WODM_RESET:
1413     case WODM_RESTART:
1414     case WODM_SETPITCH:
1415     case WODM_SETPLAYBACKRATE:
1416     case WODM_SETVOLUME:
1417         ret = WINMM_MAP_OK;
1418         break;
1419
1420     case WODM_GETDEVCAPS:
1421         {
1422             LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)*lpParam1;
1423             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
1424                                    sizeof(LPWAVEOUTCAPSW) + sizeof(WAVEOUTCAPS16));
1425
1426             if (ptr) {
1427                 *(LPWAVEOUTCAPSW*)ptr = woc32;
1428                 ret = WINMM_MAP_OKMEM;
1429             } else {
1430                 ret = WINMM_MAP_NOMEM;
1431             }
1432             *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSW);
1433             *lpParam2 = sizeof(WAVEOUTCAPS16);
1434         }
1435         break;
1436     case WODM_GETPITCH:
1437         FIXME("NIY: no conversion yet\n");
1438         ret = WINMM_MAP_MSGERROR;
1439         break;
1440     case WODM_GETPLAYBACKRATE:
1441         FIXME("NIY: no conversion yet\n");
1442         ret = WINMM_MAP_MSGERROR;
1443         break;
1444     case WODM_GETPOS:
1445         {
1446             LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1447             LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1448             LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1449
1450             if (ptr) {
1451                 *(LPMMTIME*)ptr = mmt32;
1452                 mmt16->wType = mmt32->wType;
1453                 ret = WINMM_MAP_OKMEM;
1454             } else {
1455                 ret = WINMM_MAP_NOMEM;
1456             }
1457             *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1458             *lpParam2 = sizeof(MMTIME16);
1459         }
1460         break;
1461     case WODM_GETVOLUME:
1462         FIXME("NIY: no conversion yet\n");
1463         ret = WINMM_MAP_MSGERROR;
1464         break;
1465     case WODM_OPEN:
1466         {
1467             LPWAVEOPENDESC              wod32 = (LPWAVEOPENDESC)*lpParam1;
1468             int                         sz = sizeof(WAVEFORMATEX);
1469             LPVOID                      ptr;
1470             LPWAVEOPENDESC16            wod16;
1471
1472             /* allocated data are mapped as follows:
1473                LPWAVEOPENDESC   ptr to orig lParam1
1474                DWORD            orig dwUser, which is a pointer to DWORD:driver dwInstance
1475                DWORD            dwUser passed to driver
1476                WAVEOPENDESC16   wod16: openDesc passed to driver
1477                WAVEFORMATEX     openDesc->lpFormat passed to driver
1478                xxx              extra bytes to WAVEFORMATEX
1479             */
1480             if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
1481                 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
1482                 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
1483             }
1484
1485             ptr = HeapAlloc( GetProcessHeap(), 0,
1486                              sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
1487
1488             if (ptr) {
1489                 SEGPTR seg_ptr = MapLS( ptr );
1490                 *(LPWAVEOPENDESC*)ptr = wod32;
1491                 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
1492                 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
1493
1494                 wod16->hWave = HWAVE_16(wod32->hWave);
1495                 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
1496                 memcpy(wod16 + 1, wod32->lpFormat, sz);
1497
1498                 wod16->dwCallback = wod32->dwCallback;
1499                 wod16->dwInstance = wod32->dwInstance;
1500                 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
1501                 wod16->dnDevNode = wod32->dnDevNode;
1502
1503                 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
1504                 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
1505
1506                 ret = WINMM_MAP_OKMEM;
1507             } else {
1508                 ret = WINMM_MAP_NOMEM;
1509             }
1510         }
1511         break;
1512     case WODM_PREPARE:
1513         {
1514             LPWAVEHDR           wh32 = (LPWAVEHDR)*lpParam1;
1515             LPWAVEHDR           wh16;
1516             LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
1517                                     sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
1518
1519             if (ptr) {
1520                 SEGPTR seg_ptr = MapLS( ptr );
1521                 *(LPWAVEHDR*)ptr = wh32;
1522                 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
1523                 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
1524                 /* data will be copied on WODM_WRITE */
1525                 wh16->dwBufferLength = wh32->dwBufferLength;
1526                 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1527                 wh16->dwUser = wh32->dwUser;
1528                 wh16->dwFlags = wh32->dwFlags;
1529                 wh16->dwLoops = wh32->dwLoops;
1530                 /* FIXME: nothing on wh32->lpNext */
1531                 /* could link the wh32->lpNext at this level for memory house keeping */
1532                 wh32->lpNext = wh16; /* for reuse in unprepare and write */
1533                 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
1534                       seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
1535                       wh32->dwBufferLength, (DWORD)wh32->lpData);
1536                 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1537                 *lpParam2 = sizeof(WAVEHDR);
1538
1539                 ret = WINMM_MAP_OKMEM;
1540             } else {
1541                 ret = WINMM_MAP_NOMEM;
1542             }
1543         }
1544         break;
1545     case WODM_UNPREPARE:
1546     case WODM_WRITE:
1547         {
1548             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
1549             LPWAVEHDR           wh16 = wh32->lpNext;
1550             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1551             SEGPTR seg_ptr = MapLS( ptr );
1552
1553             assert(*(LPWAVEHDR*)ptr == wh32);
1554
1555             TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
1556                   seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
1557                   wh32->dwBufferLength, (DWORD)wh32->lpData);
1558
1559             if (wMsg == WODM_WRITE)
1560                 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
1561
1562             *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1563             *lpParam2 = sizeof(WAVEHDR);
1564             /* dwBufferLength can be reduced between prepare & write */
1565             if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
1566                 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1567                     wh16->dwBufferLength, wh32->dwBufferLength);
1568             } else
1569                 wh16->dwBufferLength = wh32->dwBufferLength;
1570             ret = WINMM_MAP_OKMEM;
1571         }
1572         break;
1573     case DRVM_MAPPER_STATUS:
1574         {
1575             LPDWORD p32 = (LPDWORD)*lpParam2;
1576             *lpParam2 = MapLS(p32);
1577             ret = WINMM_MAP_OKMEM;
1578         }
1579         break;
1580     default:
1581         FIXME("NIY: no conversion yet\n");
1582         ret = WINMM_MAP_MSGERROR;
1583         break;
1584     }
1585     return ret;
1586 }
1587
1588 /**************************************************************************
1589  *                              MMDRV_WaveOut_UnMap32WTo16      [internal]
1590  */
1591 static  WINMM_MapType   MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1592 {
1593     WINMM_MapType       ret;
1594
1595     switch (wMsg) {
1596         /* nothing to do */
1597     case WODM_BREAKLOOP:
1598     case WODM_CLOSE:
1599     case WODM_GETNUMDEVS:
1600     case WODM_PAUSE:
1601     case WODM_RESET:
1602     case WODM_RESTART:
1603     case WODM_SETPITCH:
1604     case WODM_SETPLAYBACKRATE:
1605     case WODM_SETVOLUME:
1606         ret = WINMM_MAP_OK;
1607         break;
1608
1609     case WODM_GETDEVCAPS:
1610         {
1611             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
1612             LPSTR                       ptr   = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSW);
1613             LPWAVEOUTCAPSW              woc32 = *(LPWAVEOUTCAPSW*)ptr;
1614
1615             woc32->wMid = woc16->wMid;
1616             woc32->wPid = woc16->wPid;
1617             woc32->vDriverVersion = woc16->vDriverVersion;
1618             WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
1619                                  sizeof(woc16->szPname), NULL, NULL );
1620             woc32->dwFormats = woc16->dwFormats;
1621             woc32->wChannels = woc16->wChannels;
1622             woc32->dwSupport = woc16->dwSupport;
1623             UnMapLS( *lpParam1 );
1624             HeapFree( GetProcessHeap(), 0, ptr );
1625             ret = WINMM_MAP_OK;
1626         }
1627         break;
1628     case WODM_GETPITCH:
1629         FIXME("NIY: no conversion yet\n");
1630         ret = WINMM_MAP_MSGERROR;
1631         break;
1632     case WODM_GETPLAYBACKRATE:
1633         FIXME("NIY: no conversion yet\n");
1634         ret = WINMM_MAP_MSGERROR;
1635         break;
1636     case WODM_GETPOS:
1637         {
1638             LPMMTIME16          mmt16 = MapSL(*lpParam1);
1639             LPSTR               ptr   = (LPSTR)mmt16 - sizeof(LPMMTIME);
1640             LPMMTIME            mmt32 = *(LPMMTIME*)ptr;
1641
1642             MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1643             UnMapLS( *lpParam1 );
1644             HeapFree( GetProcessHeap(), 0, ptr );
1645             ret = WINMM_MAP_OK;
1646         }
1647         break;
1648     case WODM_OPEN:
1649         {
1650             LPWAVEOPENDESC16            wod16 = MapSL(*lpParam1);
1651             LPSTR                       ptr   = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1652             LPWAVEOPENDESC              wod32 = *(LPWAVEOPENDESC*)ptr;
1653
1654             wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1655             **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1656             UnMapLS( *lpParam1 );
1657             HeapFree( GetProcessHeap(), 0, ptr );
1658             ret = WINMM_MAP_OK;
1659         }
1660         break;
1661     case WODM_PREPARE:
1662     case WODM_UNPREPARE:
1663     case WODM_WRITE:
1664         {
1665             LPWAVEHDR           wh16 = MapSL(*lpParam1);
1666             LPSTR               ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1667             LPWAVEHDR           wh32 = *(LPWAVEHDR*)ptr;
1668
1669             assert(wh32->lpNext == wh16);
1670             wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1671             wh32->dwUser = wh16->dwUser;
1672             wh32->dwFlags = wh16->dwFlags;
1673             wh32->dwLoops = wh16->dwLoops;
1674
1675             UnMapLS( *lpParam1 );
1676             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1677                 HeapFree( GetProcessHeap(), 0, ptr );
1678                 wh32->lpNext = 0;
1679             }
1680             ret = WINMM_MAP_OK;
1681         }
1682         break;
1683     case WODM_GETVOLUME:
1684         FIXME("NIY: no conversion yet\n");
1685         ret = WINMM_MAP_MSGERROR;
1686         break;
1687     case DRVM_MAPPER_STATUS:
1688         {
1689             UnMapLS( *lpParam2 );
1690             ret = WINMM_MAP_OK;
1691         }
1692         break;
1693     default:
1694         FIXME("NIY: no conversion yet\n");
1695         ret = WINMM_MAP_MSGERROR;
1696         break;
1697     }
1698     return ret;
1699 }
1700
1701 /**************************************************************************
1702  *                              MMDRV_WaveOut_Callback          [internal]
1703  */
1704 static  void    CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
1705 {
1706     LPWINE_MLD  mld = (LPWINE_MLD)dwInstance;
1707
1708     switch (uMsg) {
1709     case WOM_OPEN:
1710     case WOM_CLOSE:
1711         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1712         break;
1713     case WOM_DONE:
1714         if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1715             /* initial map is: 32 => 16 */
1716             LPWAVEHDR           wh16 = MapSL(dwParam1);
1717             LPWAVEHDR           wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1718
1719             dwParam1 = (DWORD)wh32;
1720             wh32->dwFlags = wh16->dwFlags;
1721         } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1722             /* initial map is: 16 => 32 */
1723             LPWAVEHDR           wh32 = (LPWAVEHDR)(dwParam1);
1724             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1725             LPWAVEHDR           wh16 = MapSL(segwh16);
1726
1727             dwParam1 = (DWORD)segwh16;
1728             wh16->dwFlags = wh32->dwFlags;
1729         }
1730         /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1731         break;
1732     default:
1733         ERR("Unknown msg %u\n", uMsg);
1734     }
1735
1736     MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1737 }
1738
1739 /* =================================
1740  *  M A P P E R S   H A N D L I N G
1741  * ================================= */
1742
1743 static  LRESULT    MMDRV_CallMMDrvFunc16(DWORD fp16, WORD dev, WORD msg, LONG instance,
1744                                          LONG lp1, LONG lp2)
1745 {
1746     WORD args[8];
1747     DWORD ret;
1748
1749     args[7] = dev;
1750     args[6] = msg;
1751     args[5] = HIWORD(instance);
1752     args[4] = LOWORD(instance);
1753     args[3] = HIWORD(lp1);
1754     args[2] = LOWORD(lp1);
1755     args[1] = HIWORD(lp2);
1756     args[0] = LOWORD(lp2);
1757     WOWCallback16Ex( fp16, WCB16_PASCAL, sizeof(args), args, &ret );
1758     return LOWORD(ret);
1759 }
1760
1761 /**************************************************************************
1762  *                              MMDRV_GetDescription16          [internal]
1763  */
1764 static  BOOL    MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
1765 {
1766     OFSTRUCT    ofs;
1767     HFILE       hFile;
1768     WORD        w;
1769     DWORD       dw;
1770     BOOL        ret = FALSE;
1771
1772     if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
1773         ERR("Can't open file %s (builtin driver ?)\n", fname);
1774         return FALSE;
1775     }
1776
1777 #define E(_x)   do {TRACE _x;goto theEnd;} while(0)
1778
1779     if (_lread(hFile, &w, 2) != 2)                      E(("Can't read sig\n"));
1780     if (w != ('Z' * 256 + 'M'))                         E(("Bad sig %04x\n", w));
1781     if (_llseek(hFile, 0x3C, SEEK_SET) < 0)             E(("Can't seek to ext header offset\n"));
1782     if (_lread(hFile, &dw, 4) != 4)                     E(("Can't read ext header offset\n"));
1783     if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0)        E(("Can't seek to ext header.nr table %lu\n", dw+0x2C));
1784     if (_lread(hFile, &dw, 4) != 4)                     E(("Can't read nr table offset\n"));
1785     if (_llseek(hFile, dw, SEEK_SET) < 0)               E(("Can't seek to nr table %lu\n", dw));
1786     if (_lread(hFile, buf, 1) != 1)                     E(("Can't read descr length\n"));
1787     buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
1788     if (_lread(hFile, buf, buflen) != buflen)           E(("Can't read descr (%d)\n", buflen));
1789     buf[buflen] = '\0';
1790     ret = TRUE;
1791     TRACE("Got '%s' [%d]\n", buf, buflen);
1792 theEnd:
1793     _lclose(hFile);
1794     return ret;
1795 }
1796
1797 /******************************************************************
1798  *              MMDRV_LoadMMDrvFunc16
1799  *
1800  */
1801 unsigned   MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
1802                                  LPWINE_MM_DRIVER lpDrv)
1803 {
1804     WINEMM_msgFunc16    func;
1805     unsigned            count = 0;
1806     char                buffer[128];
1807     /*
1808      * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
1809      * The beginning of the module description indicates the driver supports
1810      * waveform, auxiliary, and mixer devices. Use one of the following
1811      * device-type names, followed by a colon (:) to indicate the type of
1812      * device your driver supports. If the driver supports more than one
1813      * type of device, separate each device-type name with a comma (,).
1814      *
1815      * wave for waveform audio devices
1816      * wavemapper for wave mappers
1817      * midi for MIDI audio devices
1818      * midimapper for midi mappers
1819      * aux for auxiliary audio devices
1820      * mixer for mixer devices
1821      */
1822
1823     if (d->d.d16.hDriver16) {
1824         HMODULE16       hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
1825
1826 #define AA(_h,_w,_x,_y,_z)                                      \
1827     func = (WINEMM_msgFunc##_y) _z ((_h), #_x);                 \
1828     if (func != NULL)                                           \
1829         { lpDrv->parts[_w].u.fnMessage##_y = func; count++;     \
1830           TRACE("Got %d bit func '%s'\n", _y, #_x);         }
1831
1832 #define A(_x,_y)        AA(hMod16,_x,_y,16,GetProcAddress16)
1833         A(MMDRV_AUX,    auxMessage);
1834         A(MMDRV_MIXER,  mxdMessage);
1835         A(MMDRV_MIDIIN, midMessage);
1836         A(MMDRV_MIDIOUT,modMessage);
1837         A(MMDRV_WAVEIN, widMessage);
1838         A(MMDRV_WAVEOUT,wodMessage);
1839 #undef A
1840 #undef AA
1841     }
1842     if (TRACE_ON(winmm)) {
1843         if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
1844             TRACE("%s => %s\n", drvName, buffer);
1845         else
1846             TRACE("%s => No description\n", drvName);
1847     }
1848
1849     return count;
1850 }
1851
1852 /* =================================
1853  *              M C I
1854  * ================================= */
1855
1856 #if 0
1857 /* FIXME: this code is kept for not yet implemented optimisation for an application
1858  * using the 32A MCI interface and calling a 16 bit driver.
1859  * For now, we're doing two conversions:
1860  * - 32A => 32W (in 32 bit MCI code)
1861  * - 32W => 16  in this file
1862  */
1863
1864 /*
1865  * 0000 stop
1866  * 0001 squeeze   signed 4 bytes to 2 bytes     *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2;     S += 4
1867  * 0010 squeeze unsigned 4 bytes to 2 bytes     *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2;     S += 4
1868  * 0100
1869  * 0101
1870  * 0110 zero 4 bytes                            *(DWORD)D = 0                        D += 4;     S += 4
1871  * 0111 copy string                             *(LPSTR*)D = seg dup(*(LPSTR*)S)     D += 4;     S += 4
1872  * 1xxx copy xxx + 1 bytes                      memcpy(D, S, xxx + 1);               D += xxx+1; S += xxx+1
1873  */
1874
1875 /**************************************************************************
1876  *                      MCI_MsgMapper32ATo16_Create             [internal]
1877  *
1878  * Helper for MCI_MapMsg32ATo16.
1879  * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1880  * segmented pointer.
1881  * map contains a list of action to be performed for the mapping (see list
1882  * above)
1883  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1884  */
1885 static  WINMM_MapType   MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
1886 {
1887     void*       lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
1888     LPBYTE      p16, p32;
1889
1890     if (!lp) {
1891         return WINMM_MAP_NOMEM;
1892     }
1893     p32 = (LPBYTE)(*ptr);
1894     if (keep) {
1895         *(void**)lp = *ptr;
1896         p16 = (LPBYTE)lp + sizeof(void**);
1897         *ptr = (char*)MapLS(lp) + sizeof(void**);
1898     } else {
1899         p16 = lp;
1900         *ptr = (void*)MapLS(lp);
1901     }
1902
1903     if (map == 0) {
1904         memcpy(p16, p32, size16);
1905     } else {
1906         unsigned        nibble;
1907         unsigned        sz;
1908
1909         while (map & 0xF) {
1910             nibble = map & 0xF;
1911             if (nibble & 0x8) {
1912                 sz = (nibble & 7) + 1;
1913                 memcpy(p16, p32, sz);
1914                 p16 += sz;
1915                 p32 += sz;
1916                 size16 -= sz;   /* DEBUG only */
1917             } else {
1918                 switch (nibble) {
1919                 case 0x1:
1920                     *(LPINT16)p16 = *(LPINT)p32;
1921                     p16 += sizeof(INT16);
1922                     p32 += sizeof(INT);
1923                     size16 -= sizeof(INT16);
1924                     break;
1925                 case 0x2:
1926                     *(LPUINT16)p16 = *(LPUINT)p32;
1927                     p16 += sizeof(UINT16);
1928                     p32 += sizeof(UINT);
1929                     size16 -= sizeof(UINT16);
1930                     break;
1931                 case 0x6:
1932                     *(LPDWORD)p16 = 0;
1933                     p16 += sizeof(DWORD);
1934                     p32 += sizeof(DWORD);
1935                     size16 -= sizeof(DWORD);
1936                     break;
1937                 case 0x7:
1938                     *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
1939                     p16 += sizeof(SEGPTR);
1940                     p32 += sizeof(LPSTR);
1941                     size16 -= sizeof(SEGPTR);
1942                     break;
1943                 default:
1944                     FIXME("Unknown nibble for mapping (%x)\n", nibble);
1945                 }
1946             }
1947             map >>= 4;
1948         }
1949         if (size16 != 0) /* DEBUG only */
1950             FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1951     }
1952     return WINMM_MAP_OKMEM;
1953 }
1954
1955 /**************************************************************************
1956  *                      MCI_MsgMapper32ATo16_Destroy            [internal]
1957  *
1958  * Helper for MCI_UnMapMsg32ATo16.
1959  */
1960 static  WINMM_MapType   MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
1961 {
1962     if (ptr) {
1963         void*           msg16 = MapSL((SEGPTR)ptr);
1964         void*           alloc;
1965         LPBYTE          p32, p16;
1966         unsigned        nibble;
1967
1968         UnMapLS( (SEGPTR)ptr );
1969         if (kept) {
1970             alloc = (char*)msg16 - sizeof(void**);
1971             p32 = *(void**)alloc;
1972             p16 = msg16;
1973
1974             if (map == 0) {
1975                 memcpy(p32, p16, size16);
1976             } else {
1977                 while (map & 0xF) {
1978                     nibble = map & 0xF;
1979                     if (nibble & 0x8) {
1980                         memcpy(p32, p16, (nibble & 7) + 1);
1981                         p16 += (nibble & 7) + 1;
1982                         p32 += (nibble & 7) + 1;
1983                         size16 -= (nibble & 7) + 1;
1984                     } else {
1985                         switch (nibble) {
1986                         case 0x1:
1987                             *(LPINT)p32 = *(LPINT16)p16;
1988                             p16 += sizeof(INT16);
1989                             p32 += sizeof(INT);
1990                             size16 -= sizeof(INT16);
1991                             break;
1992                         case 0x2:
1993                             *(LPUINT)p32 = *(LPUINT16)p16;
1994                             p16 += sizeof(UINT16);
1995                             p32 += sizeof(UINT);
1996                             size16 -= sizeof(UINT16);
1997                             break;
1998                         case 0x6:
1999                             p16 += sizeof(UINT);
2000                             p32 += sizeof(UINT);
2001                             size16 -= sizeof(UINT);
2002                             break;
2003                         case 0x7:
2004                             UnMapLS( *(SEGPTR *)p16 );
2005                             p16 += sizeof(SEGPTR);
2006                             p32 += sizeof(char*);
2007                             size16 -= sizeof(SEGPTR);
2008                             break;
2009                         default:
2010                             FIXME("Unknown nibble for mapping (%x)\n", nibble);
2011                         }
2012                     }
2013                     map >>= 4;
2014                 }
2015                 if (size16 != 0) /* DEBUG only */
2016                     FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2017             }
2018         } else {
2019             alloc = msg16;
2020         }
2021
2022         HeapFree( GetProcessHeap(), 0, alloc );
2023     }
2024     return WINMM_MAP_OK;
2025 }
2026
2027 /**************************************************************************
2028  *                      MCI_MapMsg32ATo16                       [internal]
2029  *
2030  * Map a 32-A bit MCI message to a 16 bit MCI message.
2031  */
2032 static  WINMM_MapType   MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
2033 {
2034     int         size;
2035     BOOLEAN     keep = FALSE;
2036     DWORD       map = 0;
2037
2038     if (*lParam == 0)
2039         return WINMM_MAP_OK;
2040
2041     /* FIXME: to add also (with seg/linear modifications to do):
2042      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2043      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2044      */
2045     switch (wMsg) {
2046     case MCI_BREAK:
2047         size = sizeof(MCI_BREAK_PARMS);
2048         break;
2049         /* case MCI_CAPTURE */
2050     case MCI_CLOSE:
2051     case MCI_CLOSE_DRIVER:
2052     case MCI_CONFIGURE:
2053         size = sizeof(MCI_GENERIC_PARMS);
2054         break;
2055         /* case MCI_COPY: */
2056     case MCI_CUE:
2057         switch (uDevType) {
2058         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS);       break;
2059         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_CUE_PARMS);     break;*/        FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2060         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2061         }
2062         break;
2063         /* case MCI_CUT:*/
2064     case MCI_DELETE:
2065         switch (uDevType) {
2066         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16);  map = 0x0F1111FB;       break;
2067         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS);   break;
2068         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2069         }
2070         break;
2071         /* case MCI_ESCAPE: */
2072     case MCI_FREEZE:
2073         switch (uDevType) {
2074         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS);    map = 0x0001111B;       break;
2075         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
2076         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2077         }
2078         break;
2079     case MCI_GETDEVCAPS:
2080         keep = TRUE;
2081         size = sizeof(MCI_GETDEVCAPS_PARMS);
2082         break;
2083         /* case MCI_INDEX: */
2084     case MCI_INFO:
2085         {
2086             LPMCI_INFO_PARMSA   mip32a = (LPMCI_INFO_PARMSA)(*lParam);
2087             LPMCI_INFO_PARMS16  mip16;
2088
2089             switch (uDevType) {
2090             case MCI_DEVTYPE_DIGITAL_VIDEO:     size = sizeof(MCI_DGV_INFO_PARMS16);    break;
2091             default:                            size = sizeof(MCI_INFO_PARMS16);        break;
2092             }
2093             mip16 = HeapAlloc( GetProcessHeap(), 0, size);
2094             if (mip16)
2095             {
2096                 mip16->dwCallback  = mip32a->dwCallback;
2097                 mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
2098                 mip16->dwRetSize   = mip32a->dwRetSize;
2099                 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
2100                     ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
2101                 }
2102             } else {
2103                 return WINMM_MAP_NOMEM;
2104             }
2105             *lParam = MapLS(mip16);
2106         }
2107         return WINMM_MAP_OKMEM;
2108         /* case MCI_MARK: */
2109         /* case MCI_MONITOR: */
2110     case MCI_OPEN:
2111     case MCI_OPEN_DRIVER:
2112         {
2113             LPMCI_OPEN_PARMSA   mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
2114             char* ptr = HeapAlloc( GetProcessHeap(), 0,
2115                                    sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
2116             LPMCI_OPEN_PARMS16  mop16;
2117
2118
2119             if (ptr) {
2120                 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
2121                 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
2122                 mop16->dwCallback       = mop32a->dwCallback;
2123                 mop16->wDeviceID        = mop32a->wDeviceID;
2124                 if (dwFlags & MCI_OPEN_TYPE) {
2125                     if (dwFlags & MCI_OPEN_TYPE_ID) {
2126                         /* dword "transparent" value */
2127                         mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
2128                     } else {
2129                         /* string */
2130                         mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
2131                     }
2132                 } else {
2133                     /* nuthin' */
2134                     mop16->lpstrDeviceType = 0;
2135                 }
2136                 if (dwFlags & MCI_OPEN_ELEMENT) {
2137                     if (dwFlags & MCI_OPEN_ELEMENT_ID) {
2138                         mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
2139                     } else {
2140                         mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
2141                     }
2142                 } else {
2143                     mop16->lpstrElementName = 0;
2144                 }
2145                 if (dwFlags & MCI_OPEN_ALIAS) {
2146                     mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
2147                 } else {
2148                     mop16->lpstrAlias = 0;
2149                 }
2150                 /* copy extended information if any...
2151                  * FIXME: this may seg fault if initial structure does not contain them and
2152                  * the reads after msip16 fail under LDT limits...
2153                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2154                  * should not take care of extended parameters, and should be used by MCI_Open
2155                  * to fetch uDevType. When, this is known, the mapping for sending the
2156                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
2157                  */
2158                 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
2159             } else {
2160                 return WINMM_MAP_NOMEM;
2161             }
2162             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
2163         }
2164         return WINMM_MAP_OKMEM;
2165         /* case MCI_PASTE:*/
2166     case MCI_PAUSE:
2167         size = sizeof(MCI_GENERIC_PARMS);
2168         break;
2169     case MCI_PLAY:
2170         size = sizeof(MCI_PLAY_PARMS);
2171         break;
2172     case MCI_PUT:
2173         switch (uDevType) {
2174         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
2175         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
2176         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2177         }
2178         break;
2179     case MCI_REALIZE:
2180         size = sizeof(MCI_GENERIC_PARMS);
2181         break;
2182     case MCI_RECORD:
2183         switch (uDevType) {
2184         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16);  map = 0x0F1111FB;       break;
2185         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_RECORD_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2186         default:                        size = sizeof(MCI_RECORD_PARMS);        break;
2187         }
2188         break;
2189     case MCI_RESUME:
2190         size = sizeof(MCI_GENERIC_PARMS);
2191         break;
2192     case MCI_SEEK:
2193         switch (uDevType) {
2194         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SEEK_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2195         default:                        size = sizeof(MCI_SEEK_PARMS);          break;
2196         }
2197         break;
2198     case MCI_SET:
2199         switch (uDevType) {
2200         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS);       break;
2201         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SET_PARMS);     break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2202         case MCI_DEVTYPE_SEQUENCER:     size = sizeof(MCI_SEQ_SET_PARMS);       break;
2203         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
2204          * so not doing anything should work...
2205          */
2206         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS);      break;
2207         default:                        size = sizeof(MCI_SET_PARMS);           break;
2208         }
2209         break;
2210     case MCI_SETAUDIO:
2211         switch (uDevType) {
2212         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;      break;
2213         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2214         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2215         }
2216         break;
2217         /* case MCI_SETTIMECODE:*/
2218         /* case MCI_SIGNAL:*/
2219         /* case MCI_SOUND:*/
2220     case MCI_SPIN:
2221         size = sizeof(MCI_SET_PARMS);
2222         break;
2223     case MCI_STATUS:
2224         keep = TRUE;
2225         switch (uDevType) {
2226         /* FIXME:
2227          * don't know if buffer for value is the one passed through lpstrDevice
2228          * or is provided by MCI driver.
2229          * Assuming solution 2: provided by MCI driver, so zeroing on entry
2230          */
2231         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16);  map = 0x0B6FF;          break;
2232         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2233         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2234         }
2235         break;
2236     case MCI_STEP:
2237         switch (uDevType) {
2238         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS);      break;
2239         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STEP_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2240         case MCI_DEVTYPE_VIDEODISC:     size = sizeof(MCI_VD_STEP_PARMS);       break;
2241         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2242         }
2243         break;
2244     case MCI_STOP:
2245         size = sizeof(MCI_SET_PARMS);
2246         break;
2247     case MCI_SYSINFO:
2248         {
2249             LPMCI_SYSINFO_PARMSA  msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
2250             LPMCI_SYSINFO_PARMS16 msip16;
2251             char* ptr = HeapAlloc( GetProcessHeap(), 0,
2252                                    sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
2253
2254             if (ptr) {
2255                 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
2256                 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
2257
2258                 msip16->dwCallback       = msip32a->dwCallback;
2259                 msip16->lpstrReturn      = MapLS( msip32a->lpstrReturn );
2260                 msip16->dwRetSize        = msip32a->dwRetSize;
2261                 msip16->dwNumber         = msip32a->dwNumber;
2262                 msip16->wDeviceType      = msip32a->wDeviceType;
2263             } else {
2264                 return WINMM_MAP_NOMEM;
2265             }
2266             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
2267         }
2268         return WINMM_MAP_OKMEM;
2269         /* case MCI_UNDO: */
2270     case MCI_UNFREEZE:
2271         switch (uDevType) {
2272         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
2273         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       break;
2274         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2275         }
2276         break;
2277     case MCI_UPDATE:
2278         switch (uDevType) {
2279         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16);  map = 0x000B1111B;      break;
2280         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2281         }
2282         break;
2283     case MCI_WHERE:
2284         switch (uDevType) {
2285         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       keep = TRUE;    break;
2286         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       keep = TRUE;    break;
2287         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2288         }
2289         break;
2290     case MCI_WINDOW:
2291         switch (uDevType) {
2292         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7FB;        break;
2293         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB;        break;
2294         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
2295         }
2296         break;
2297     case DRV_OPEN:
2298         {
2299             LPMCI_OPEN_DRIVER_PARMSA  modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
2300             LPMCI_OPEN_DRIVER_PARMS16 modp16;
2301             char *ptr = HeapAlloc( GetProcessHeap(), 0,
2302                                    sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
2303
2304             if (ptr) {
2305                 *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
2306                 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2307                 modp16->wDeviceID = modp32a->wDeviceID;
2308                 modp16->lpstrParams = MapLS( modp32a->lpstrParams );
2309                 /* other fields are gonna be filled by the driver, don't copy them */
2310             } else {
2311                 return WINMM_MAP_NOMEM;
2312             }
2313             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
2314         }
2315         return WINMM_MAP_OKMEM;
2316     case DRV_LOAD:
2317     case DRV_ENABLE:
2318     case DRV_CLOSE:
2319     case DRV_DISABLE:
2320     case DRV_FREE:
2321     case DRV_CONFIGURE:
2322     case DRV_QUERYCONFIGURE:
2323     case DRV_INSTALL:
2324     case DRV_REMOVE:
2325     case DRV_EXITSESSION:
2326     case DRV_EXITAPPLICATION:
2327     case DRV_POWER:
2328         return WINMM_MAP_OK;
2329
2330     default:
2331         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2332         return WINMM_MAP_MSGERROR;
2333     }
2334     return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep);
2335 }
2336
2337 /**************************************************************************
2338  *                      MCI_UnMapMsg32ATo16                     [internal]
2339  */
2340 static  WINMM_MapType   MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
2341 {
2342     int         size = 0;
2343     BOOLEAN     kept = FALSE;   /* there is no need to compute size when kept is FALSE */
2344     DWORD       map = 0;
2345
2346     switch (wMsg) {
2347     case MCI_BREAK:
2348         break;
2349         /* case MCI_CAPTURE */
2350     case MCI_CLOSE:
2351     case MCI_CLOSE_DRIVER:
2352     case MCI_CONFIGURE:
2353         break;
2354         /* case MCI_COPY: */
2355     case MCI_CUE:
2356         break;
2357         /* case MCI_CUT: */
2358     case MCI_DELETE:
2359         break;
2360         /* case MCI_ESCAPE: */
2361     case MCI_FREEZE:
2362         break;
2363     case MCI_GETDEVCAPS:
2364         kept = TRUE;
2365         size = sizeof(MCI_GETDEVCAPS_PARMS);
2366         break;
2367         /* case MCI_INDEX: */
2368     case MCI_INFO:
2369         {
2370             LPMCI_INFO_PARMS16 mip16  = (LPMCI_INFO_PARMS16)MapSL(lParam);
2371             UnMapLS( lParam );
2372             UnMapLS( mip16->lpstrReturn );
2373             HeapFree( GetProcessHeap(), 0, mip16 );
2374         }
2375         return WINMM_MAP_OK;
2376         /* case MCI_MARK: */
2377         /* case MCI_MONITOR: */
2378     case MCI_OPEN:
2379     case MCI_OPEN_DRIVER:
2380         if (lParam) {
2381             LPMCI_OPEN_PARMS16  mop16  = (LPMCI_OPEN_PARMS16)MapSL(lParam);
2382             LPMCI_OPEN_PARMSA   mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
2383             UnMapLS( lParam );
2384             mop32a->wDeviceID = mop16->wDeviceID;
2385             if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
2386                 UnMapLS( mop16->lpstrDeviceType );
2387             if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
2388                 UnMapLS( mop16->lpstrElementName );
2389             if (dwFlags & MCI_OPEN_ALIAS)
2390                 UnMapLS( mop16->lpstrAlias );
2391             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
2392         }
2393         return WINMM_MAP_OK;
2394         /* case MCI_PASTE:*/
2395     case MCI_PAUSE:
2396         break;
2397     case MCI_PLAY:
2398         break;
2399     case MCI_PUT:
2400         break;
2401     case MCI_REALIZE:
2402         break;
2403     case MCI_RECORD:
2404         break;
2405     case MCI_RESUME:
2406         break;
2407     case MCI_SEEK:
2408         break;
2409     case MCI_SET:
2410         break;
2411     case MCI_SETAUDIO:
2412         switch (uDevType) {
2413         case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF;      break;
2414         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2415         }
2416         break;
2417         /* case MCI_SETTIMECODE:*/
2418         /* case MCI_SIGNAL:*/
2419         /* case MCI_SOUND:*/
2420     case MCI_SPIN:
2421         break;
2422     case MCI_STATUS:
2423         kept = TRUE;
2424         switch (uDevType) {
2425         case MCI_DEVTYPE_DIGITAL_VIDEO:
2426         if (lParam) {
2427             LPMCI_DGV_STATUS_PARMS16    mdsp16  = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
2428             LPMCI_DGV_STATUS_PARMSA     mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
2429
2430             UnMapLS( lParam );
2431             if (mdsp16) {
2432                 mdsp32a->dwReturn = mdsp16->dwReturn;
2433                 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2434                     TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
2435                     TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
2436                     UnMapLS( mdsp16->lpstrDrive );
2437                 }
2438                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
2439             } else {
2440                 return WINMM_MAP_NOMEM;
2441             }
2442         }
2443         return WINMM_MAP_OKMEM;
2444         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
2445         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2446         }
2447         break;
2448     case MCI_STEP:
2449         break;
2450     case MCI_STOP:
2451         break;
2452     case MCI_SYSINFO:
2453         if (lParam) {
2454             LPMCI_SYSINFO_PARMS16       msip16  = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
2455             LPMCI_SYSINFO_PARMSA        msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
2456
2457             UnMapLS( lParam );
2458             if (msip16) {
2459                 msip16->dwCallback = msip32a->dwCallback;
2460                 UnMapLS( msip16->lpstrReturn );
2461                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
2462             } else {
2463                 return WINMM_MAP_NOMEM;
2464             }
2465         }
2466         return WINMM_MAP_OKMEM;
2467         /* case MCI_UNDO: */
2468     case MCI_UNFREEZE:
2469         break;
2470     case MCI_UPDATE:
2471         break;
2472     case MCI_WHERE:
2473         switch (uDevType) {
2474         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       kept = TRUE;    break;
2475         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       kept = TRUE;    break;
2476         default:                        break;
2477         }
2478         break;
2479     case MCI_WINDOW:
2480         switch (uDevType) {
2481         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7666;       break;
2482         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666;       break;
2483         default:                        break;
2484         }
2485         /* FIXME: see map function */
2486         break;
2487
2488     case DRV_OPEN:
2489         if (lParam) {
2490             LPMCI_OPEN_DRIVER_PARMS16   modp16  = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
2491             LPMCI_OPEN_DRIVER_PARMSA    modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2492
2493             UnMapLS( lParam );
2494             modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
2495             modp32a->wType = modp16->wType;
2496             UnMapLS( modp16->lpstrParams );
2497             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
2498         }
2499         return WINMM_MAP_OK;
2500     case DRV_LOAD:
2501     case DRV_ENABLE:
2502     case DRV_CLOSE:
2503     case DRV_DISABLE:
2504     case DRV_FREE:
2505     case DRV_CONFIGURE:
2506     case DRV_QUERYCONFIGURE:
2507     case DRV_INSTALL:
2508     case DRV_REMOVE:
2509     case DRV_EXITSESSION:
2510     case DRV_EXITAPPLICATION:
2511     case DRV_POWER:
2512         FIXME("This is a hack\n");
2513         return WINMM_MAP_OK;
2514     default:
2515         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2516         return WINMM_MAP_MSGERROR;
2517     }
2518     return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept);
2519 }
2520 #endif
2521
2522 /**************************************************************************
2523  *                      MCI_MapMsg16To32W                       [internal]
2524  */
2525 static WINMM_MapType    MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
2526 {
2527     if (*lParam == 0)
2528         return WINMM_MAP_OK;
2529     /* FIXME: to add also (with seg/linear modifications to do):
2530      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2531      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2532      */
2533     switch (wMsg) {
2534         /* case MCI_CAPTURE */
2535     case MCI_CLOSE:
2536     case MCI_CLOSE_DRIVER:
2537     case MCI_CONFIGURE:
2538     case MCI_COPY:
2539     case MCI_CUE:
2540     case MCI_CUT:
2541     case MCI_DELETE:
2542     case MCI_FREEZE:
2543     case MCI_GETDEVCAPS:
2544         /* case MCI_INDEX: */
2545         /* case MCI_MARK: */
2546         /* case MCI_MONITOR: */
2547     case MCI_PASTE:
2548     case MCI_PAUSE:
2549     case MCI_PLAY:
2550     case MCI_PUT:
2551     case MCI_REALIZE:
2552     case MCI_RECORD:
2553     case MCI_RESUME:
2554     case MCI_SEEK:
2555     case MCI_SET:
2556         /* case MCI_SETTIMECODE:*/
2557         /* case MCI_SIGNAL:*/
2558     case MCI_SPIN:
2559     case MCI_STATUS:            /* FIXME: is wrong for digital video */
2560     case MCI_STEP:
2561     case MCI_STOP:
2562         /* case MCI_UNDO: */
2563     case MCI_UNFREEZE:
2564     case MCI_UPDATE:
2565     case MCI_WHERE:
2566         *lParam = (DWORD)MapSL(*lParam);
2567         return WINMM_MAP_OK;
2568     case MCI_WINDOW:
2569         /* in fact, I would also need the dwFlags... to see
2570          * which members of lParam are effectively used
2571          */
2572         *lParam = (DWORD)MapSL(*lParam);
2573         FIXME("Current mapping may be wrong\n");
2574         break;
2575     case MCI_BREAK:
2576         {
2577             LPMCI_BREAK_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
2578             LPMCI_BREAK_PARMS16         mbp16 = MapSL(*lParam);
2579
2580             if (mbp32) {
2581                 mbp32->dwCallback = mbp16->dwCallback;
2582                 mbp32->nVirtKey = mbp16->nVirtKey;
2583                 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
2584             } else {
2585                 return WINMM_MAP_NOMEM;
2586             }
2587             *lParam = (DWORD)mbp32;
2588         }
2589         return WINMM_MAP_OKMEM;
2590     case MCI_ESCAPE:
2591         {
2592             LPMCI_VD_ESCAPE_PARMSW      mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
2593             LPMCI_VD_ESCAPE_PARMS16     mvep16  = MapSL(*lParam);
2594
2595             if (mvep32w) {
2596                 mvep32w->dwCallback       = mvep16->dwCallback;
2597                 mvep32w->lpstrCommand     = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
2598             } else {
2599                 return WINMM_MAP_NOMEM;
2600             }
2601             *lParam = (DWORD)mvep32w;
2602         }
2603         return WINMM_MAP_OKMEM;
2604     case MCI_INFO:
2605         {
2606             LPMCI_INFO_PARMSW   mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
2607             LPMCI_INFO_PARMS16  mip16  = MapSL(*lParam);
2608
2609             /* FIXME this is wrong if device is of type
2610              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
2611              */
2612             if (mip32w) {
2613                 *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
2614                 mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
2615                 mip32w->dwCallback  = mip16->dwCallback;
2616                 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
2617                 mip32w->dwRetSize   = mip16->dwRetSize * sizeof(WCHAR);
2618             } else {
2619                 return WINMM_MAP_NOMEM;
2620             }
2621             *lParam = (DWORD)mip32w;
2622         }
2623         return WINMM_MAP_OKMEM;
2624     case MCI_OPEN:
2625     case MCI_OPEN_DRIVER:
2626         {
2627             LPMCI_OPEN_PARMSW   mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
2628             LPMCI_OPEN_PARMS16  mop16  = MapSL(*lParam);
2629
2630             if (mop32w) {
2631                 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
2632                 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
2633                 mop32w->dwCallback       = mop16->dwCallback;
2634                 mop32w->wDeviceID        = mop16->wDeviceID;
2635                 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
2636                     mop32w->lpstrDeviceType  = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
2637                 else
2638                     mop32w->lpstrDeviceType  = (LPWSTR) mop16->lpstrDeviceType;
2639                 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
2640                     mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
2641                 else
2642                     mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
2643                 if( ( dwFlags &  MCI_OPEN_ALIAS))
2644                     mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
2645                 else
2646                     mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
2647                 /* copy extended information if any...
2648                  * FIXME: this may seg fault if initial structure does not contain them and
2649                  * the reads after msip16 fail under LDT limits...
2650                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2651                  * should not take care of extended parameters, and should be used by MCI_Open
2652                  * to fetch uDevType. When, this is known, the mapping for sending the
2653                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
2654                  */
2655                 memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
2656             } else {
2657                 return WINMM_MAP_NOMEM;
2658             }
2659             *lParam = (DWORD)mop32w;
2660         }
2661         return WINMM_MAP_OKMEM;
2662     case MCI_SYSINFO:
2663         {
2664             LPMCI_SYSINFO_PARMSW        msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
2665             LPMCI_SYSINFO_PARMS16       msip16  = MapSL(*lParam);
2666
2667             if (msip32w) {
2668                 *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
2669                 msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
2670                 msip32w->dwCallback       = msip16->dwCallback;
2671                 msip32w->lpstrReturn      = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
2672                 msip32w->dwRetSize        = msip16->dwRetSize;
2673                 msip32w->dwNumber         = msip16->dwNumber;
2674                 msip32w->wDeviceType      = msip16->wDeviceType;
2675             } else {
2676                 return WINMM_MAP_NOMEM;
2677             }
2678             *lParam = (DWORD)msip32w;
2679         }
2680         return WINMM_MAP_OKMEM;
2681     case MCI_SOUND:
2682         {
2683             LPMCI_SOUND_PARMSW          mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
2684             LPMCI_SOUND_PARMS16         mbp16 = MapSL(*lParam);
2685
2686             if (mbp32) {
2687                 mbp32->dwCallback = mbp16->dwCallback;
2688                 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
2689             } else {
2690                 return WINMM_MAP_NOMEM;
2691             }
2692             *lParam = (DWORD)mbp32;
2693         }
2694         return WINMM_MAP_OKMEM;
2695     case DRV_LOAD:
2696     case DRV_ENABLE:
2697     case DRV_OPEN:
2698     case DRV_CLOSE:
2699     case DRV_DISABLE:
2700     case DRV_FREE:
2701     case DRV_CONFIGURE:
2702     case DRV_QUERYCONFIGURE:
2703     case DRV_INSTALL:
2704     case DRV_REMOVE:
2705     case DRV_EXITSESSION:
2706     case DRV_EXITAPPLICATION:
2707     case DRV_POWER:
2708         FIXME("This is a hack\n");
2709         return WINMM_MAP_OK;
2710     default:
2711         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2712     }
2713     return WINMM_MAP_MSGERROR;
2714 }
2715
2716 /**************************************************************************
2717  *                      MCI_UnMapMsg16To32W                     [internal]
2718  */
2719 static  WINMM_MapType   MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
2720 {
2721     switch (wMsg) {
2722         /* case MCI_CAPTURE */
2723     case MCI_CLOSE:
2724     case MCI_CLOSE_DRIVER:
2725     case MCI_CONFIGURE:
2726     case MCI_COPY:
2727     case MCI_CUE:
2728     case MCI_CUT:
2729     case MCI_DELETE:
2730     case MCI_FREEZE:
2731     case MCI_GETDEVCAPS:
2732         /* case MCI_INDEX: */
2733         /* case MCI_MARK: */
2734         /* case MCI_MONITOR: */
2735     case MCI_PASTE:
2736     case MCI_PAUSE:
2737     case MCI_PLAY:
2738     case MCI_PUT:
2739     case MCI_REALIZE:
2740     case MCI_RECORD:
2741     case MCI_RESUME:
2742     case MCI_SEEK:
2743     case MCI_SET:
2744         /* case MCI_SETTIMECODE:*/
2745         /* case MCI_SIGNAL:*/
2746     case MCI_SPIN:
2747     case MCI_STATUS:
2748     case MCI_STEP:
2749     case MCI_STOP:
2750         /* case MCI_UNDO: */
2751     case MCI_UNFREEZE:
2752     case MCI_UPDATE:
2753     case MCI_WHERE:
2754         return WINMM_MAP_OK;
2755
2756     case MCI_WINDOW:
2757         /* FIXME ?? see Map function */
2758         return WINMM_MAP_OK;
2759
2760     case MCI_BREAK:
2761         HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2762         return WINMM_MAP_OK;
2763     case MCI_ESCAPE:
2764         if (lParam) {
2765             LPMCI_VD_ESCAPE_PARMSW      mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
2766             HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
2767             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2768         }
2769         return WINMM_MAP_OK;
2770     case MCI_INFO:
2771         if (lParam) {
2772             LPMCI_INFO_PARMSW           mip32w = (LPMCI_INFO_PARMSW)lParam;
2773             LPMCI_INFO_PARMS16          mip16  = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
2774
2775             WideCharToMultiByte(CP_ACP, 0,
2776                                 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
2777                                 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
2778                                 NULL, NULL);
2779             HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn);
2780             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2781         }
2782         return WINMM_MAP_OK;
2783     case MCI_SYSINFO:
2784         if (lParam) {
2785             LPMCI_SYSINFO_PARMSW           msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
2786             LPMCI_SYSINFO_PARMS16          msip16  = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
2787
2788             WideCharToMultiByte(CP_ACP, 0,
2789                                 msip32w->lpstrReturn, msip32w->dwRetSize,
2790                                 MapSL(msip16->lpstrReturn), msip16->dwRetSize,
2791                                 NULL, NULL);
2792             HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn);
2793             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2794         }
2795         return WINMM_MAP_OK;
2796     case MCI_SOUND:
2797         if (lParam) {
2798             LPMCI_SOUND_PARMSW          msp32W = (LPMCI_SOUND_PARMSW)lParam;
2799             HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
2800             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2801         }
2802         return WINMM_MAP_OK;
2803     case MCI_OPEN:
2804     case MCI_OPEN_DRIVER:
2805         if (lParam) {
2806             LPMCI_OPEN_PARMSW   mop32w = (LPMCI_OPEN_PARMSW)lParam;
2807             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
2808
2809             mop16->wDeviceID = mop32w->wDeviceID;
2810             if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
2811                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
2812             if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
2813                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
2814             if( ( dwFlags &  MCI_OPEN_ALIAS))
2815                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
2816             if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
2817                 FIXME("bad free line=%d\n", __LINE__);
2818         }
2819         return WINMM_MAP_OK;
2820     case DRV_LOAD:
2821     case DRV_ENABLE:
2822     case DRV_OPEN:
2823     case DRV_CLOSE:
2824     case DRV_DISABLE:
2825     case DRV_FREE:
2826     case DRV_CONFIGURE:
2827     case DRV_QUERYCONFIGURE:
2828     case DRV_INSTALL:
2829     case DRV_REMOVE:
2830     case DRV_EXITSESSION:
2831     case DRV_EXITAPPLICATION:
2832     case DRV_POWER:
2833         FIXME("This is a hack\n");
2834         return WINMM_MAP_OK;
2835     default:
2836         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2837     }
2838     return WINMM_MAP_MSGERROR;
2839 }
2840
2841 /*
2842  * 0000 stop
2843  * 0001 squeeze   signed 4 bytes to 2 bytes     *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2;     S += 4
2844  * 0010 squeeze unsigned 4 bytes to 2 bytes     *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2;     S += 4
2845  * 0100
2846  * 0101
2847  * 0110 zero 4 bytes                            *(DWORD)D = 0                        D += 4;     S += 4
2848  * 0111 copy string                             *(LPSTR*)D = seg dup(*(LPSTR*)S)     D += 4;     S += 4
2849  * 1xxx copy xxx + 1 bytes                      memcpy(D, S, xxx + 1);               D += xxx+1; S += xxx+1
2850  */
2851
2852 /**************************************************************************
2853  *                      MCI_MsgMapper32WTo16_Create             [internal]
2854  *
2855  * Helper for MCI_MapMsg32WTo16.
2856  * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
2857  * segmented pointer.
2858  * map contains a list of action to be performed for the mapping (see list
2859  * above)
2860  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
2861  */
2862 static  WINMM_MapType   MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
2863 {
2864     void*       lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
2865     LPBYTE      p16, p32;
2866
2867     if (!lp) {
2868         return WINMM_MAP_NOMEM;
2869     }
2870     p32 = (LPBYTE)(*ptr);
2871     if (keep) {
2872         *(void**)lp = *ptr;
2873         p16 = (LPBYTE)lp + sizeof(void**);
2874         *ptr = (char*)MapLS(lp) + sizeof(void**);
2875     } else {
2876         p16 = lp;
2877         *ptr = (void*)MapLS(lp);
2878     }
2879
2880     if (map == 0) {
2881         memcpy(p16, p32, size16);
2882     } else {
2883         unsigned        nibble;
2884         unsigned        sz;
2885
2886         while (map & 0xF) {
2887             nibble = map & 0xF;
2888             if (nibble & 0x8) {
2889                 sz = (nibble & 7) + 1;
2890                 memcpy(p16, p32, sz);
2891                 p16 += sz;
2892                 p32 += sz;
2893                 size16 -= sz;   /* DEBUG only */
2894             } else {
2895                 switch (nibble) {
2896                 case 0x1:
2897                     *(LPINT16)p16 = *(LPINT)p32;
2898                     p16 += sizeof(INT16);
2899                     p32 += sizeof(INT);
2900                     size16 -= sizeof(INT16);
2901                     break;
2902                 case 0x2:
2903                     *(LPUINT16)p16 = *(LPUINT)p32;
2904                     p16 += sizeof(UINT16);
2905                     p32 += sizeof(UINT);
2906                     size16 -= sizeof(UINT16);
2907                     break;
2908                 case 0x6:
2909                     *(LPDWORD)p16 = 0;
2910                     p16 += sizeof(DWORD);
2911                     p32 += sizeof(DWORD);
2912                     size16 -= sizeof(DWORD);
2913                     break;
2914                 case 0x7:
2915                     *(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) );
2916                     p16 += sizeof(SEGPTR);
2917                     p32 += sizeof(LPSTR);
2918                     size16 -= sizeof(SEGPTR);
2919                     break;
2920                 default:
2921                     FIXME("Unknown nibble for mapping (%x)\n", nibble);
2922                 }
2923             }
2924             map >>= 4;
2925         }
2926         if (size16 != 0) /* DEBUG only */
2927             FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2928     }
2929     return WINMM_MAP_OKMEM;
2930 }
2931
2932 /**************************************************************************
2933  *                      MCI_MsgMapper32WTo16_Destroy            [internal]
2934  *
2935  * Helper for MCI_UnMapMsg32WTo16.
2936  */
2937 static  WINMM_MapType   MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
2938 {
2939     if (ptr) {
2940         void*           msg16 = MapSL((SEGPTR)ptr);
2941         void*           alloc;
2942         LPBYTE          p32, p16;
2943         unsigned        nibble;
2944
2945         UnMapLS( (SEGPTR)ptr );
2946         if (kept) {
2947             alloc = (char*)msg16 - sizeof(void**);
2948             p32 = *(void**)alloc;
2949             p16 = msg16;
2950
2951             if (map == 0) {
2952                 memcpy(p32, p16, size16);
2953             } else {
2954                 while (map & 0xF) {
2955                     nibble = map & 0xF;
2956                     if (nibble & 0x8) {
2957                         memcpy(p32, p16, (nibble & 7) + 1);
2958                         p16 += (nibble & 7) + 1;
2959                         p32 += (nibble & 7) + 1;
2960                         size16 -= (nibble & 7) + 1;
2961                     } else {
2962                         switch (nibble) {
2963                         case 0x1:
2964                             *(LPINT)p32 = *(LPINT16)p16;
2965                             p16 += sizeof(INT16);
2966                             p32 += sizeof(INT);
2967                             size16 -= sizeof(INT16);
2968                             break;
2969                         case 0x2:
2970                             *(LPUINT)p32 = *(LPUINT16)p16;
2971                             p16 += sizeof(UINT16);
2972                             p32 += sizeof(UINT);
2973                             size16 -= sizeof(UINT16);
2974                             break;
2975                         case 0x6:
2976                             p16 += sizeof(UINT);
2977                             p32 += sizeof(UINT);
2978                             size16 -= sizeof(UINT);
2979                             break;
2980                         case 0x7:
2981                             HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16));
2982                             UnMapLS( *(SEGPTR *)p16 );
2983                             p16 += sizeof(SEGPTR);
2984                             p32 += sizeof(char*);
2985                             size16 -= sizeof(SEGPTR);
2986                             break;
2987                         default:
2988                             FIXME("Unknown nibble for mapping (%x)\n", nibble);
2989                         }
2990                     }
2991                     map >>= 4;
2992                 }
2993                 if (size16 != 0) /* DEBUG only */
2994                     FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2995             }
2996         } else {
2997             alloc = msg16;
2998         }
2999
3000         HeapFree( GetProcessHeap(), 0, alloc );
3001     }
3002     return WINMM_MAP_OK;
3003 }
3004
3005 /**************************************************************************
3006  *                      MCI_MapMsg32WTo16                       [internal]
3007  *
3008  * Map a 32W bit MCI message to a 16 bit MCI message.
3009  */
3010 static  WINMM_MapType   MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
3011 {
3012     int         size;
3013     BOOLEAN     keep = FALSE;
3014     DWORD       map = 0;
3015
3016     if (*lParam == 0)
3017         return WINMM_MAP_OK;
3018
3019     /* FIXME: to add also (with seg/linear modifications to do):
3020      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
3021      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
3022      */
3023     switch (wMsg) {
3024     case MCI_BREAK:
3025         size = sizeof(MCI_BREAK_PARMS);
3026         break;
3027         /* case MCI_CAPTURE */
3028     case MCI_CLOSE:
3029     case MCI_CLOSE_DRIVER:
3030     case MCI_CONFIGURE:
3031         size = sizeof(MCI_GENERIC_PARMS);
3032         break;
3033         /* case MCI_COPY: */
3034     case MCI_CUE:
3035         switch (uDevType) {
3036         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS);       break;
3037         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_CUE_PARMS);     break;*/        FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3038         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3039         }
3040         break;
3041         /* case MCI_CUT:*/
3042     case MCI_DELETE:
3043         switch (uDevType) {
3044         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16);  map = 0x0F1111FB;       break;
3045         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS);   break;
3046         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3047         }
3048         break;
3049         /* case MCI_ESCAPE: */
3050     case MCI_FREEZE:
3051         switch (uDevType) {
3052         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS);    map = 0x0001111B;       break;
3053         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
3054         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3055         }
3056         break;
3057     case MCI_GETDEVCAPS:
3058         keep = TRUE;
3059         size = sizeof(MCI_GETDEVCAPS_PARMS);
3060         break;
3061         /* case MCI_INDEX: */
3062     case MCI_INFO:
3063         {
3064             LPMCI_INFO_PARMSW   mip32w = (LPMCI_INFO_PARMSW)(*lParam);
3065             char*               ptr;
3066             LPMCI_INFO_PARMS16  mip16;
3067
3068             switch (uDevType) {
3069             case MCI_DEVTYPE_DIGITAL_VIDEO:     size = sizeof(MCI_DGV_INFO_PARMS16);    break;
3070             default:                            size = sizeof(MCI_INFO_PARMS16);        break;
3071             }
3072             ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size);
3073             if (ptr)
3074             {
3075                 *(LPMCI_INFO_PARMSW*)ptr = mip32w;
3076                 mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW));
3077                 mip16->dwCallback  = mip32w->dwCallback;
3078                 mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) );
3079                 mip16->dwRetSize   = mip32w->dwRetSize / sizeof(WCHAR);
3080                 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
3081                     ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem;
3082                 }
3083             } else {
3084                 return WINMM_MAP_NOMEM;
3085             }
3086             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW);
3087         }
3088         return WINMM_MAP_OKMEM;
3089         /* case MCI_MARK: */
3090         /* case MCI_MONITOR: */
3091     case MCI_OPEN:
3092     case MCI_OPEN_DRIVER:
3093         {
3094             LPMCI_OPEN_PARMSW   mop32w = (LPMCI_OPEN_PARMSW)(*lParam);
3095             char* ptr = HeapAlloc( GetProcessHeap(), 0,
3096                                    sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
3097             LPMCI_OPEN_PARMS16  mop16;
3098
3099
3100             if (ptr) {
3101                 *(LPMCI_OPEN_PARMSW*)(ptr) = mop32w;
3102                 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW));
3103                 mop16->dwCallback       = mop32w->dwCallback;
3104                 mop16->wDeviceID        = mop32w->wDeviceID;
3105                 if (dwFlags & MCI_OPEN_TYPE) {
3106                     if (dwFlags & MCI_OPEN_TYPE_ID) {
3107                         /* dword "transparent" value */
3108                         mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType;
3109                     } else {
3110                         /* string */
3111                         mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) );
3112                     }
3113                 } else {
3114                     /* nuthin' */
3115                     mop16->lpstrDeviceType = 0;
3116                 }
3117                 if (dwFlags & MCI_OPEN_ELEMENT) {
3118                     if (dwFlags & MCI_OPEN_ELEMENT_ID) {
3119                         mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName;
3120                     } else {
3121                         mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) );
3122                     }
3123                 } else {
3124                     mop16->lpstrElementName = 0;
3125                 }
3126                 if (dwFlags & MCI_OPEN_ALIAS) {
3127                     mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) );
3128                 } else {
3129                     mop16->lpstrAlias = 0;
3130                 }
3131                 /* copy extended information if any...
3132                  * FIXME: this may seg fault if initial structure does not contain them and
3133                  * the reads after msip16 fail under LDT limits...
3134                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
3135                  * should not take care of extended parameters, and should be used by MCI_Open
3136                  * to fetch uDevType. When, this is known, the mapping for sending the
3137                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
3138                  */
3139                 memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD));
3140             } else {
3141                 return WINMM_MAP_NOMEM;
3142             }
3143             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW);
3144         }
3145         return WINMM_MAP_OKMEM;
3146         /* case MCI_PASTE:*/
3147     case MCI_PAUSE:
3148         size = sizeof(MCI_GENERIC_PARMS);
3149         break;
3150     case MCI_PLAY:
3151         size = sizeof(MCI_PLAY_PARMS);
3152         break;
3153     case MCI_PUT:
3154         switch (uDevType) {
3155         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
3156         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
3157         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3158         }
3159         break;
3160     case MCI_REALIZE:
3161         size = sizeof(MCI_GENERIC_PARMS);
3162         break;
3163     case MCI_RECORD:
3164         switch (uDevType) {
3165         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16);  map = 0x0F1111FB;       break;
3166         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_RECORD_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3167         default:                        size = sizeof(MCI_RECORD_PARMS);        break;
3168         }
3169         break;
3170     case MCI_RESUME:
3171         size = sizeof(MCI_GENERIC_PARMS);
3172         break;
3173     case MCI_SEEK:
3174         switch (uDevType) {
3175         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SEEK_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3176         default:                        size = sizeof(MCI_SEEK_PARMS);          break;
3177         }
3178         break;
3179     case MCI_SET:
3180         switch (uDevType) {
3181         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS);       break;
3182         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SET_PARMS);     break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3183         case MCI_DEVTYPE_SEQUENCER:     size = sizeof(MCI_SEQ_SET_PARMS);       break;
3184         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
3185          * so not doing anything should work...
3186          */
3187         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS);      break;
3188         default:                        size = sizeof(MCI_SET_PARMS);           break;
3189         }
3190         break;
3191     case MCI_SETAUDIO:
3192         switch (uDevType) {
3193         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;      break;
3194         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3195         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3196         }
3197         break;
3198         /* case MCI_SETTIMECODE:*/
3199         /* case MCI_SIGNAL:*/
3200         /* case MCI_SOUND:*/
3201     case MCI_SPIN:
3202         size = sizeof(MCI_SET_PARMS);
3203         break;
3204     case MCI_STATUS:
3205         keep = TRUE;
3206         switch (uDevType) {
3207         /* FIXME:
3208          * don't know if buffer for value is the one passed through lpstrDevice
3209          * or is provided by MCI driver.
3210          * Assuming solution 2: provided by MCI driver, so zeroing on entry
3211          */
3212         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16);  map = 0x0B6FF;          break;
3213         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3214         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
3215         }
3216         break;
3217     case MCI_STEP:
3218         switch (uDevType) {
3219         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS);      break;
3220         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STEP_PARMS);    break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3221         case MCI_DEVTYPE_VIDEODISC:     size = sizeof(MCI_VD_STEP_PARMS);       break;
3222         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3223         }
3224         break;
3225     case MCI_STOP:
3226         size = sizeof(MCI_SET_PARMS);
3227         break;
3228     case MCI_SYSINFO:
3229         {
3230             LPMCI_SYSINFO_PARMSW  msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam);
3231             LPMCI_SYSINFO_PARMS16 msip16;
3232             char* ptr = HeapAlloc( GetProcessHeap(), 0,
3233                                    sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) );
3234
3235             if (ptr) {
3236                 *(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w;
3237                 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW));
3238
3239                 msip16->dwCallback       = msip32w->dwCallback;
3240                 msip16->lpstrReturn      = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) );
3241                 msip16->dwRetSize        = msip32w->dwRetSize;
3242                 msip16->dwNumber         = msip32w->dwNumber;
3243                 msip16->wDeviceType      = msip32w->wDeviceType;
3244             } else {
3245                 return WINMM_MAP_NOMEM;
3246             }
3247             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW);
3248         }
3249         return WINMM_MAP_OKMEM;
3250         /* case MCI_UNDO: */
3251     case MCI_UNFREEZE:
3252         switch (uDevType) {
3253         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
3254         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       break;
3255         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3256         }
3257         break;
3258     case MCI_UPDATE:
3259         switch (uDevType) {
3260         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16);  map = 0x000B1111B;      break;
3261         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3262         }
3263         break;
3264     case MCI_WHERE:
3265         switch (uDevType) {
3266         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       keep = TRUE;    break;
3267         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       keep = TRUE;    break;
3268         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3269         }
3270         break;
3271     case MCI_WINDOW:
3272         switch (uDevType) {
3273         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7FB;        break;
3274         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB;        break;
3275         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
3276         }
3277         break;
3278     case DRV_OPEN:
3279         {
3280             LPMCI_OPEN_DRIVER_PARMSW  modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam);
3281             LPMCI_OPEN_DRIVER_PARMS16 modp16;
3282             char *ptr = HeapAlloc( GetProcessHeap(), 0,
3283                                    sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16));
3284
3285             if (ptr) {
3286                 *(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w;
3287                 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW));
3288                 modp16->wDeviceID = modp32w->wDeviceID;
3289                 modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) );
3290                 /* other fields are gonna be filled by the driver, don't copy them */
3291             } else {
3292                 return WINMM_MAP_NOMEM;
3293             }
3294             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW);
3295         }
3296         return WINMM_MAP_OKMEM;
3297     case DRV_LOAD:
3298     case DRV_ENABLE:
3299     case DRV_CLOSE:
3300     case DRV_DISABLE:
3301     case DRV_FREE:
3302     case DRV_CONFIGURE:
3303     case DRV_QUERYCONFIGURE:
3304     case DRV_INSTALL:
3305     case DRV_REMOVE:
3306     case DRV_EXITSESSION:
3307     case DRV_EXITAPPLICATION:
3308     case DRV_POWER:
3309         return WINMM_MAP_OK;
3310
3311     default:
3312         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
3313         return WINMM_MAP_MSGERROR;
3314     }
3315     return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep);
3316 }
3317
3318 /**************************************************************************
3319  *                      MCI_UnMapMsg32WTo16                     [internal]
3320  */
3321 static  WINMM_MapType   MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
3322 {
3323     int         size = 0;
3324     BOOLEAN     kept = FALSE;   /* there is no need to compute size when kept is FALSE */
3325     DWORD       map = 0;
3326
3327     switch (wMsg) {
3328     case MCI_BREAK:
3329         break;
3330         /* case MCI_CAPTURE */
3331     case MCI_CLOSE:
3332     case MCI_CLOSE_DRIVER:
3333     case MCI_CONFIGURE:
3334         break;
3335         /* case MCI_COPY: */
3336     case MCI_CUE:
3337         break;
3338         /* case MCI_CUT: */
3339     case MCI_DELETE:
3340         break;
3341         /* case MCI_ESCAPE: */
3342     case MCI_FREEZE:
3343         break;
3344     case MCI_GETDEVCAPS:
3345         kept = TRUE;
3346         size = sizeof(MCI_GETDEVCAPS_PARMS);
3347         break;
3348         /* case MCI_INDEX: */
3349     case MCI_INFO:
3350         if (lParam) {
3351             LPMCI_INFO_PARMS16  mip16  = (LPMCI_INFO_PARMS16)MapSL(lParam);
3352             LPMCI_INFO_PARMSW   mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW));
3353
3354             MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize,
3355                                 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR));
3356             UnMapLS( lParam );
3357             UnMapLS( mip16->lpstrReturn );
3358             HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) );
3359             HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) );
3360         }
3361         return WINMM_MAP_OK;
3362         /* case MCI_MARK: */
3363         /* case MCI_MONITOR: */
3364     case MCI_OPEN:
3365     case MCI_OPEN_DRIVER:
3366         if (lParam) {
3367             LPMCI_OPEN_PARMS16  mop16  = (LPMCI_OPEN_PARMS16)MapSL(lParam);
3368             LPMCI_OPEN_PARMSW   mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW));
3369             UnMapLS( lParam );
3370             mop32w->wDeviceID = mop16->wDeviceID;
3371             if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
3372             {
3373                 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType));
3374                 UnMapLS( mop16->lpstrDeviceType );
3375             }
3376             if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
3377             {
3378                 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName));
3379                 UnMapLS( mop16->lpstrElementName );
3380             }
3381             if (dwFlags & MCI_OPEN_ALIAS)
3382             {
3383                 HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias));
3384                 UnMapLS( mop16->lpstrAlias );
3385             }
3386             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) );
3387         }
3388         return WINMM_MAP_OK;
3389         /* case MCI_PASTE:*/
3390     case MCI_PAUSE:
3391         break;
3392     case MCI_PLAY:
3393         break;
3394     case MCI_PUT:
3395         break;
3396     case MCI_REALIZE:
3397         break;
3398     case MCI_RECORD:
3399         break;
3400     case MCI_RESUME:
3401         break;
3402     case MCI_SEEK:
3403         break;
3404     case MCI_SET:
3405         break;
3406     case MCI_SETAUDIO:
3407         switch (uDevType) {
3408         case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF;      break;
3409         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3410         }
3411         break;
3412         /* case MCI_SETTIMECODE:*/
3413         /* case MCI_SIGNAL:*/
3414         /* case MCI_SOUND:*/
3415     case MCI_SPIN:
3416         break;
3417     case MCI_STATUS:
3418         kept = TRUE;
3419         switch (uDevType) {
3420         case MCI_DEVTYPE_DIGITAL_VIDEO:
3421         if (lParam) {
3422             LPMCI_DGV_STATUS_PARMS16    mdsp16  = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
3423             LPMCI_DGV_STATUS_PARMSA     mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
3424
3425             UnMapLS( lParam );
3426             if (mdsp16) {
3427                 mdsp32a->dwReturn = mdsp16->dwReturn;
3428                 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
3429                     TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
3430                     TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
3431                     UnMapLS( mdsp16->lpstrDrive );
3432                 }
3433                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
3434             } else {
3435                 return WINMM_MAP_NOMEM;
3436             }
3437         }
3438         return WINMM_MAP_OKMEM;
3439         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return WINMM_MAP_NOMEM;
3440         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
3441         }
3442         break;
3443     case MCI_STEP:
3444         break;
3445     case MCI_STOP:
3446         break;
3447     case MCI_SYSINFO:
3448         if (lParam) {
3449             LPMCI_SYSINFO_PARMS16       msip16  = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
3450             LPMCI_SYSINFO_PARMSW        msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW));
3451
3452             UnMapLS( lParam );
3453             if (msip16) {
3454                 MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize,
3455                                     msip32w->lpstrReturn, msip32w->dwRetSize);
3456                 UnMapLS( msip16->lpstrReturn );
3457                 HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) );
3458                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) );
3459             } else {
3460                 return WINMM_MAP_NOMEM;
3461             }
3462         }
3463         return WINMM_MAP_OKMEM;
3464         /* case MCI_UNDO: */
3465     case MCI_UNFREEZE:
3466         break;
3467     case MCI_UPDATE:
3468         break;
3469     case MCI_WHERE:
3470         switch (uDevType) {
3471         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       kept = TRUE;    break;
3472         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       kept = TRUE;    break;
3473         default:                        break;
3474         }
3475         break;
3476     case MCI_WINDOW:
3477         switch (uDevType) {
3478         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7666;       break;
3479         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666;       break;
3480         default:                        break;
3481         }
3482         /* FIXME: see map function */
3483         break;
3484     case DRV_OPEN:
3485         if (lParam) {
3486             LPMCI_OPEN_DRIVER_PARMS16   modp16  = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
3487             LPMCI_OPEN_DRIVER_PARMSW    modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW));
3488
3489             UnMapLS( lParam );
3490             modp32w->wCustomCommandTable = modp16->wCustomCommandTable;
3491             modp32w->wType = modp16->wType;
3492             HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams));
3493             UnMapLS( modp16->lpstrParams );
3494             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) );
3495         }
3496         return WINMM_MAP_OK;
3497     case DRV_LOAD:
3498     case DRV_ENABLE:
3499     case DRV_CLOSE:
3500     case DRV_DISABLE:
3501     case DRV_FREE:
3502     case DRV_CONFIGURE:
3503     case DRV_QUERYCONFIGURE:
3504     case DRV_INSTALL:
3505     case DRV_REMOVE:
3506     case DRV_EXITSESSION:
3507     case DRV_EXITAPPLICATION:
3508     case DRV_POWER:
3509         FIXME("This is a hack\n");
3510         return WINMM_MAP_OK;
3511
3512     default:
3513         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
3514         return WINMM_MAP_MSGERROR;
3515     }
3516     return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept);
3517 }
3518
3519 void    MMDRV_Init16(void)
3520 {
3521 #define A(_x,_y) MMDRV_InstallMap(_x, \
3522 MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \
3523 MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \
3524 MMDRV_##_y##_Callback)
3525     A(MMDRV_AUX,        Aux);
3526     A(MMDRV_MIXER,      Mixer);
3527     A(MMDRV_MIDIIN,     MidiIn);
3528     A(MMDRV_MIDIOUT,    MidiOut);
3529     A(MMDRV_WAVEIN,     WaveIn);
3530     A(MMDRV_WAVEOUT,    WaveOut);
3531 #undef A
3532
3533     pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
3534     pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
3535
3536     pFnMciMapMsg16To32W   = MCI_MapMsg16To32W;
3537     pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W;
3538     pFnMciMapMsg32WTo16   = MCI_MapMsg32WTo16;
3539     pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16;
3540 }