dlls/mmsystem.dll16/mci16.c

   1 /*
   2  * MMSYSTEM functions
   3  *
   4  * Copyright 1993      Martin Ayotte
   5  *           1998-2003,2009 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "mmsystem.h"
  31 #include "winternl.h"
  32 #include "wownt32.h"
  33 #include "winnls.h"
  34
  35 #include "wine/winuser16.h"
  36 #include "winemm16.h"
  37 #include "digitalv.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
  42
  43 /**************************************************************************
  44  *                      MCI_MessageToString                     [internal]
  45  */
  46 static const char* MCI_MessageToString(UINT wMsg)
  47 {
  48     static char buffer[100];
  49
  50 #define CASE(s) case (s): return #s
  51
  52     switch (wMsg) {
  53         CASE(DRV_LOAD);
  54         CASE(DRV_ENABLE);
  55         CASE(DRV_OPEN);
  56         CASE(DRV_CLOSE);
  57         CASE(DRV_DISABLE);
  58         CASE(DRV_FREE);
  59         CASE(DRV_CONFIGURE);
  60         CASE(DRV_QUERYCONFIGURE);
  61         CASE(DRV_INSTALL);
  62         CASE(DRV_REMOVE);
  63         CASE(DRV_EXITSESSION);
  64         CASE(DRV_EXITAPPLICATION);
  65         CASE(DRV_POWER);
  66         CASE(MCI_BREAK);
  67         CASE(MCI_CLOSE);
  68         CASE(MCI_CLOSE_DRIVER);
  69         CASE(MCI_COPY);
  70         CASE(MCI_CUE);
  71         CASE(MCI_CUT);
  72         CASE(MCI_DELETE);
  73         CASE(MCI_ESCAPE);
  74         CASE(MCI_FREEZE);
  75         CASE(MCI_PAUSE);
  76         CASE(MCI_PLAY);
  77         CASE(MCI_GETDEVCAPS);
  78         CASE(MCI_INFO);
  79         CASE(MCI_LOAD);
  80         CASE(MCI_OPEN);
  81         CASE(MCI_OPEN_DRIVER);
  82         CASE(MCI_PASTE);
  83         CASE(MCI_PUT);
  84         CASE(MCI_REALIZE);
  85         CASE(MCI_RECORD);
  86         CASE(MCI_RESUME);
  87         CASE(MCI_SAVE);
  88         CASE(MCI_SEEK);
  89         CASE(MCI_SET);
  90         CASE(MCI_SOUND);
  91         CASE(MCI_SPIN);
  92         CASE(MCI_STATUS);
  93         CASE(MCI_STEP);
  94         CASE(MCI_STOP);
  95         CASE(MCI_SYSINFO);
  96         CASE(MCI_UNFREEZE);
  97         CASE(MCI_UPDATE);
  98         CASE(MCI_WHERE);
  99         CASE(MCI_WINDOW);
 100         /* constants for digital video */
 101         CASE(MCI_CAPTURE);
 102         CASE(MCI_MONITOR);
 103         CASE(MCI_RESERVE);
 104         CASE(MCI_SETAUDIO);
 105         CASE(MCI_SIGNAL);
 106         CASE(MCI_SETVIDEO);
 107         CASE(MCI_QUALITY);
 108         CASE(MCI_LIST);
 109         CASE(MCI_UNDO);
 110         CASE(MCI_CONFIGURE);
 111         CASE(MCI_RESTORE);
 112 #undef CASE
 113     default:
 114         sprintf(buffer, "MCI_<<%04X>>", wMsg);
 115         return buffer;
 116     }
 117 }
 118
 119 static LPWSTR MCI_strdupAtoW( LPCSTR str )
 120 {
 121     LPWSTR ret;
 122     INT len;
 123
 124     if (!str) return NULL;
 125     len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 126     ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 127     if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 128     return ret;
 129 }
 130
 131 static DWORD MCI_get_device_type(UINT16 deviceId)
 132 {
 133     MCI_GETDEVCAPS_PARMS parms;
 134     MCIERROR err;
 135
 136     err = mciSendCommandW(deviceId, MCI_GETDEVCAPS, MCI_GETDEVCAPS_DEVICE_TYPE | MCI_WAIT, (DWORD_PTR)&parms);
 137     if (err != MMSYSERR_NOERROR)
 138         return MCI_DEVTYPE_OTHER;
 139     return parms.dwReturn;
 140 }
 141
 142 /**************************************************************************
 143  *                      MCI_MapMsg16To32W                       [internal]
 144  */
 145 static MMSYSTEM_MapType MCI_MapMsg16To32W(UINT16 wDevID, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
 146 {
 147     if (*lParam == 0)
 148         return MMSYSTEM_MAP_OK;
 149     /* FIXME: to add also (with seg/linear modifications to do):
 150      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
 151      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
 152      */
 153     switch (wMsg) {
 154         /* case MCI_CAPTURE */
 155     case MCI_CLOSE:
 156     case MCI_CLOSE_DRIVER:
 157     case MCI_CONFIGURE:
 158     case MCI_COPY:
 159     case MCI_CUE:
 160     case MCI_CUT:
 161     case MCI_DELETE:
 162     case MCI_GETDEVCAPS:
 163         /* case MCI_INDEX: */
 164         /* case MCI_MARK: */
 165         /* case MCI_MONITOR: */
 166     case MCI_PASTE:
 167     case MCI_PAUSE:
 168     case MCI_PLAY:
 169     case MCI_REALIZE:
 170     case MCI_RECORD:
 171     case MCI_RESUME:
 172     case MCI_SEEK:
 173     case MCI_SET:
 174         /* case MCI_SETTIMECODE:*/
 175         /* case MCI_SIGNAL:*/
 176     case MCI_SPIN:
 177     case MCI_STEP:
 178     case MCI_STOP:
 179         /* case MCI_UNDO: */
 180     case MCI_UPDATE:
 181         *lParam = (DWORD)MapSL(*lParam);
 182         return MMSYSTEM_MAP_OK;
 183     case MCI_WHERE:
 184     case MCI_FREEZE:
 185     case MCI_UNFREEZE:
 186     case MCI_PUT:
 187         {
 188             LPMCI_DGV_RECT_PARMS mdrp32 = HeapAlloc(GetProcessHeap(), 0,
 189                 sizeof(LPMCI_DGV_RECT_PARMS16) + sizeof(MCI_DGV_RECT_PARMS));
 190             LPMCI_DGV_RECT_PARMS16 mdrp16 = MapSL(*lParam);
 191             if (mdrp32) {
 192                 *(LPMCI_DGV_RECT_PARMS16*)(mdrp32) = mdrp16;
 193                 mdrp32 = (LPMCI_DGV_RECT_PARMS)((char*)mdrp32 + sizeof(LPMCI_DGV_RECT_PARMS16));
 194                 mdrp32->dwCallback = mdrp16->dwCallback;
 195                 mdrp32->rc.left = mdrp16->rc.left;
 196                 mdrp32->rc.top = mdrp16->rc.top;
 197                 mdrp32->rc.right = mdrp16->rc.right;
 198                 mdrp32->rc.bottom = mdrp16->rc.bottom;
 199             } else {
 200                 return MMSYSTEM_MAP_NOMEM;
 201             }
 202             *lParam = (DWORD)mdrp32;
 203         }
 204         return MMSYSTEM_MAP_OKMEM;
 205     case MCI_STATUS:
 206         {
 207             if (MCI_get_device_type(wDevID) == MCI_DEVTYPE_DIGITAL_VIDEO) {
 208                 LPMCI_DGV_STATUS_PARMSW mdsp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 209                     sizeof(LPMCI_DGV_STATUS_PARMS16) + sizeof(MCI_DGV_STATUS_PARMSW));
 210                 LPMCI_DGV_STATUS_PARMS16 mdsp16 = MapSL(*lParam);
 211                 if (mdsp32w) {
 212                     *(LPMCI_DGV_STATUS_PARMS16*)(mdsp32w) = mdsp16;
 213                     mdsp32w = (LPMCI_DGV_STATUS_PARMSW)((char*)mdsp32w + sizeof(LPMCI_DGV_STATUS_PARMS16));
 214                     mdsp32w->dwCallback = mdsp16->dwCallback;
 215                     mdsp32w->dwReturn = mdsp16->dwReturn;
 216                     mdsp32w->dwItem = mdsp16->dwItem;
 217                     mdsp32w->dwTrack = mdsp16->dwTrack;
 218                     if (dwFlags & MCI_DGV_STATUS_DISKSPACE)
 219                         mdsp32w->lpstrDrive = MCI_strdupAtoW(MapSL(mdsp16->lpstrDrive));
 220                     mdsp32w->dwReference = mdsp16->dwReference;
 221                     *lParam = (DWORD)mdsp32w;
 222                 } else {
 223                     return MMSYSTEM_MAP_NOMEM;
 224                 }
 225             } else {
 226                 *lParam = (DWORD)MapSL(*lParam);
 227             }
 228         }
 229         return MMSYSTEM_MAP_OKMEM;
 230     case MCI_WINDOW:
 231         {
 232             LPMCI_OVLY_WINDOW_PARMSW mowp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MCI_OVLY_WINDOW_PARMSW));
 233             LPMCI_OVLY_WINDOW_PARMS16 mowp16 = MapSL(*lParam);
 234             if (mowp32w) {
 235                 mowp32w->dwCallback = mowp16->dwCallback;
 236                 mowp32w->hWnd = HWND_32(mowp16->hWnd);
 237                 mowp32w->nCmdShow = mowp16->nCmdShow;
 238                 if (dwFlags & (MCI_DGV_WINDOW_TEXT | MCI_OVLY_WINDOW_TEXT))
 239                     mowp32w->lpstrText = MCI_strdupAtoW(MapSL(mowp16->lpstrText));
 240             } else {
 241                 return MMSYSTEM_MAP_NOMEM;
 242             }
 243             *lParam = (DWORD)mowp32w;
 244         }
 245         return MMSYSTEM_MAP_OKMEM;
 246     case MCI_BREAK:
 247         {
 248             LPMCI_BREAK_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
 249             LPMCI_BREAK_PARMS16         mbp16 = MapSL(*lParam);
 250
 251             if (mbp32) {
 252                 mbp32->dwCallback = mbp16->dwCallback;
 253                 mbp32->nVirtKey = mbp16->nVirtKey;
 254                 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
 255             } else {
 256                 return MMSYSTEM_MAP_NOMEM;
 257             }
 258             *lParam = (DWORD)mbp32;
 259         }
 260         return MMSYSTEM_MAP_OKMEM;
 261     case MCI_ESCAPE:
 262         {
 263             LPMCI_VD_ESCAPE_PARMSW      mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
 264             LPMCI_VD_ESCAPE_PARMS16     mvep16  = MapSL(*lParam);
 265
 266             if (mvep32w) {
 267                 mvep32w->dwCallback       = mvep16->dwCallback;
 268                 mvep32w->lpstrCommand     = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
 269             } else {
 270                 return MMSYSTEM_MAP_NOMEM;
 271             }
 272             *lParam = (DWORD)mvep32w;
 273         }
 274         return MMSYSTEM_MAP_OKMEM;
 275     case MCI_INFO:
 276         {
 277             LPMCI_INFO_PARMSW   mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
 278             LPMCI_INFO_PARMS16  mip16  = MapSL(*lParam);
 279
 280             /* FIXME this is wrong if device is of type
 281              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
 282              */
 283             if (mip32w) {
 284                 *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
 285                 mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
 286                 mip32w->dwCallback  = mip16->dwCallback;
 287                 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
 288                 mip32w->dwRetSize   = mip16->dwRetSize * sizeof(WCHAR);
 289             } else {
 290                 return MMSYSTEM_MAP_NOMEM;
 291             }
 292             *lParam = (DWORD)mip32w;
 293         }
 294         return MMSYSTEM_MAP_OKMEM;
 295     case MCI_OPEN:
 296     case MCI_OPEN_DRIVER:
 297         {
 298             LPMCI_OPEN_PARMSW   mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
 299             LPMCI_OPEN_PARMS16  mop16  = MapSL(*lParam);
 300
 301             if (mop32w) {
 302                 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
 303                 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
 304                 mop32w->dwCallback       = mop16->dwCallback;
 305                 mop32w->wDeviceID        = mop16->wDeviceID;
 306                 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
 307                     mop32w->lpstrDeviceType  = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
 308                 else
 309                     mop32w->lpstrDeviceType  = (LPWSTR) mop16->lpstrDeviceType;
 310                 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
 311                     mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
 312                 else
 313                     mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
 314                 if( ( dwFlags &  MCI_OPEN_ALIAS))
 315                     mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
 316                 else
 317                     mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
 318                 /* copy extended information if any...
 319                  * FIXME: this may seg fault if initial structure does not contain them and
 320                  * the reads after msip16 fail under LDT limits...
 321                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
 322                  * should not take care of extended parameters, and should be used by MCI_Open
 323                  * to fetch uDevType. When, this is known, the mapping for sending the
 324                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
 325                  */
 326                 memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
 327             } else {
 328                 return MMSYSTEM_MAP_NOMEM;
 329             }
 330             *lParam = (DWORD)mop32w;
 331         }
 332         return MMSYSTEM_MAP_OKMEM;
 333     case MCI_SYSINFO:
 334     {
 335         MCI_SYSINFO_PARMSW *msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16 *) + sizeof(MCI_SYSINFO_PARMSW));
 336         MCI_SYSINFO_PARMS16 *msip16 = MapSL(*lParam);
 337
 338         if (!msip32w)
 339             return MMSYSTEM_MAP_NOMEM;
 340
 341         *(MCI_SYSINFO_PARMS16 **)msip32w = msip16;
 342         msip32w = (MCI_SYSINFO_PARMSW *)((char *)msip32w + sizeof(MCI_OPEN_PARMS16 *));
 343         msip32w->dwCallback       = msip16->dwCallback;
 344         msip32w->lpstrReturn      = HeapAlloc(GetProcessHeap(), 0, (dwFlags & MCI_SYSINFO_QUANTITY) ?
 345                                                                     sizeof(DWORD) :
 346                                                                     msip16->dwRetSize * sizeof(WCHAR));
 347         if (!msip32w->lpstrReturn)
 348         {
 349             HeapFree(GetProcessHeap(), 0, msip32w);
 350             return MMSYSTEM_MAP_NOMEM;
 351         }
 352         msip32w->dwRetSize        = (dwFlags & MCI_SYSINFO_QUANTITY) ? sizeof(DWORD) : msip16->dwRetSize;
 353         msip32w->dwNumber         = msip16->dwNumber;
 354         msip32w->wDeviceType      = msip16->wDeviceType;
 355
 356         *lParam = (DWORD)msip32w;
 357     }
 358         return MMSYSTEM_MAP_OKMEM;
 359     case MCI_SOUND:
 360         {
 361             LPMCI_SOUND_PARMSW          mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
 362             LPMCI_SOUND_PARMS16         mbp16 = MapSL(*lParam);
 363
 364             if (mbp32) {
 365                 mbp32->dwCallback = mbp16->dwCallback;
 366                 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
 367             } else {
 368                 return MMSYSTEM_MAP_NOMEM;
 369             }
 370             *lParam = (DWORD)mbp32;
 371         }
 372         return MMSYSTEM_MAP_OKMEM;
 373     case DRV_LOAD:
 374     case DRV_ENABLE:
 375     case DRV_OPEN:
 376     case DRV_CLOSE:
 377     case DRV_DISABLE:
 378     case DRV_FREE:
 379     case DRV_CONFIGURE:
 380     case DRV_QUERYCONFIGURE:
 381     case DRV_INSTALL:
 382     case DRV_REMOVE:
 383     case DRV_EXITSESSION:
 384     case DRV_EXITAPPLICATION:
 385     case DRV_POWER:
 386         FIXME("This is a hack\n");
 387         return MMSYSTEM_MAP_OK;
 388     default:
 389         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
 390     }
 391     return MMSYSTEM_MAP_MSGERROR;
 392 }
 393
 394 /**************************************************************************
 395  *                      MCI_UnMapMsg16To32W                     [internal]
 396  */
 397 static  MMSYSTEM_MapType        MCI_UnMapMsg16To32W(UINT16 wDevID, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
 398 {
 399     switch (wMsg) {
 400         /* case MCI_CAPTURE */
 401     case MCI_CLOSE:
 402     case MCI_CLOSE_DRIVER:
 403     case MCI_CONFIGURE:
 404     case MCI_COPY:
 405     case MCI_CUE:
 406     case MCI_CUT:
 407     case MCI_DELETE:
 408     case MCI_GETDEVCAPS:
 409         /* case MCI_INDEX: */
 410         /* case MCI_MARK: */
 411         /* case MCI_MONITOR: */
 412     case MCI_PASTE:
 413     case MCI_PAUSE:
 414     case MCI_PLAY:
 415     case MCI_REALIZE:
 416     case MCI_RECORD:
 417     case MCI_RESUME:
 418     case MCI_SEEK:
 419     case MCI_SET:
 420         /* case MCI_SETTIMECODE:*/
 421         /* case MCI_SIGNAL:*/
 422     case MCI_SPIN:
 423     case MCI_STEP:
 424     case MCI_STOP:
 425         /* case MCI_UNDO: */
 426     case MCI_UPDATE:
 427         return MMSYSTEM_MAP_OK;
 428
 429     case MCI_WHERE:
 430     case MCI_FREEZE:
 431     case MCI_UNFREEZE:
 432     case MCI_PUT:
 433         if (lParam) {
 434             LPMCI_DGV_RECT_PARMS mdrp32 = (LPMCI_DGV_RECT_PARMS)lParam;
 435             char *base = (char*)lParam - sizeof(LPMCI_DGV_RECT_PARMS16);
 436             LPMCI_DGV_RECT_PARMS16 mdrp16 = *(LPMCI_DGV_RECT_PARMS16*)base;
 437             mdrp16->dwCallback = mdrp32->dwCallback;
 438             mdrp16->rc.left = mdrp32->rc.left;
 439             mdrp16->rc.top = mdrp32->rc.top;
 440             mdrp16->rc.right = mdrp32->rc.right;
 441             mdrp16->rc.bottom = mdrp32->rc.bottom;
 442             HeapFree(GetProcessHeap(), 0, base);
 443         }
 444         return MMSYSTEM_MAP_OK;
 445     case MCI_STATUS:
 446         if (lParam && MCI_get_device_type(wDevID) == MCI_DEVTYPE_DIGITAL_VIDEO) {
 447             LPMCI_DGV_STATUS_PARMSW mdsp32w = (LPMCI_DGV_STATUS_PARMSW)lParam;
 448             char *base = (char*)lParam - sizeof(LPMCI_DGV_STATUS_PARMS16);
 449             LPMCI_DGV_STATUS_PARMS16 mdsp16 = *(LPMCI_DGV_STATUS_PARMS16*)base;
 450             mdsp16->dwCallback = mdsp32w->dwCallback;
 451             mdsp16->dwReturn = mdsp32w->dwReturn;
 452             mdsp16->dwItem = mdsp32w->dwItem;
 453             mdsp16->dwTrack = mdsp32w->dwTrack;
 454             mdsp16->dwReference = mdsp32w->dwReference;
 455             HeapFree(GetProcessHeap(), 0, (LPVOID)mdsp32w->lpstrDrive);
 456             HeapFree(GetProcessHeap(), 0, base);
 457         }
 458         return MMSYSTEM_MAP_OK;
 459     case MCI_WINDOW:
 460         if (lParam) {
 461             LPMCI_OVLY_WINDOW_PARMSW mowp32w = (LPMCI_OVLY_WINDOW_PARMSW)lParam;
 462             HeapFree(GetProcessHeap(), 0, (LPVOID)mowp32w->lpstrText);
 463             HeapFree(GetProcessHeap(), 0, mowp32w);
 464         }
 465         return MMSYSTEM_MAP_OK;
 466
 467     case MCI_BREAK:
 468         HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 469         return MMSYSTEM_MAP_OK;
 470     case MCI_ESCAPE:
 471         if (lParam) {
 472             LPMCI_VD_ESCAPE_PARMSW      mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
 473             HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
 474             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 475         }
 476         return MMSYSTEM_MAP_OK;
 477     case MCI_INFO:
 478         if (lParam) {
 479             LPMCI_INFO_PARMSW           mip32w = (LPMCI_INFO_PARMSW)lParam;
 480             char                       *base   = (char*)lParam - sizeof(LPMCI_INFO_PARMS16);
 481             LPMCI_INFO_PARMS16          mip16  = *(LPMCI_INFO_PARMS16*)base;
 482
 483             WideCharToMultiByte(CP_ACP, 0,
 484                                 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
 485                                 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
 486                                 NULL, NULL);
 487             HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
 488             HeapFree(GetProcessHeap(), 0, base);
 489         }
 490         return MMSYSTEM_MAP_OK;
 491     case MCI_SYSINFO:
 492         if (lParam) {
 493             MCI_SYSINFO_PARMSW *msip32w = (MCI_SYSINFO_PARMSW *)lParam;
 494             char               *base    = (char*)lParam - sizeof(MCI_SYSINFO_PARMS16 *);
 495             MCI_SYSINFO_PARMS16 *msip16  = *(MCI_SYSINFO_PARMS16 **)base;
 496
 497             if (dwFlags & MCI_SYSINFO_QUANTITY) {
 498                 DWORD *quantity = MapSL(msip16->lpstrReturn);
 499
 500                 *quantity = *(DWORD *)msip32w->lpstrReturn;
 501             }
 502             else {
 503                 WideCharToMultiByte(CP_ACP, 0,
 504                                     msip32w->lpstrReturn, msip32w->dwRetSize,
 505                                     MapSL(msip16->lpstrReturn), msip16->dwRetSize,
 506                                     NULL, NULL);
 507             }
 508
 509             HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
 510             HeapFree(GetProcessHeap(), 0, base);
 511         }
 512         return MMSYSTEM_MAP_OK;
 513     case MCI_SOUND:
 514         if (lParam) {
 515             LPMCI_SOUND_PARMSW          msp32W = (LPMCI_SOUND_PARMSW)lParam;
 516             HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
 517             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 518         }
 519         return MMSYSTEM_MAP_OK;
 520     case MCI_OPEN:
 521     case MCI_OPEN_DRIVER:
 522         if (lParam) {
 523             LPMCI_OPEN_PARMSW   mop32w = (LPMCI_OPEN_PARMSW)lParam;
 524             char               *base   = (char*)lParam - sizeof(LPMCI_OPEN_PARMS16);
 525             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)base;
 526
 527             mop16->wDeviceID = mop32w->wDeviceID;
 528             if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
 529                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
 530             if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
 531                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
 532             if( ( dwFlags &  MCI_OPEN_ALIAS))
 533                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
 534             if (!HeapFree(GetProcessHeap(), 0, base))
 535                 FIXME("bad free line=%d\n", __LINE__);
 536         }
 537         return MMSYSTEM_MAP_OK;
 538     case DRV_LOAD:
 539     case DRV_ENABLE:
 540     case DRV_OPEN:
 541     case DRV_CLOSE:
 542     case DRV_DISABLE:
 543     case DRV_FREE:
 544     case DRV_CONFIGURE:
 545     case DRV_QUERYCONFIGURE:
 546     case DRV_INSTALL:
 547     case DRV_REMOVE:
 548     case DRV_EXITSESSION:
 549     case DRV_EXITAPPLICATION:
 550     case DRV_POWER:
 551         FIXME("This is a hack\n");
 552         return MMSYSTEM_MAP_OK;
 553     default:
 554         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
 555     }
 556     return MMSYSTEM_MAP_MSGERROR;
 557 }
 558
 559 /* ###################################################
 560  * #                     MCI                         #
 561  * ###################################################
 562  */
 563
 564 #include <pshpack1.h>
 565 #define MCI_MAX_THUNKS      32
 566
 567 static struct mci_thunk
 568 {
 569     BYTE        popl_eax;       /* popl  %eax (return address) */
 570     BYTE        pushl_func;     /* pushl $pfn16 (16bit callback function) */
 571     YIELDPROC16 yield16;
 572     BYTE        pushl_eax;      /* pushl %eax */
 573     BYTE        jmp;            /* ljmp MCI_Yield1632 */
 574     DWORD       callback;
 575     MCIDEVICEID id;
 576 } *MCI_Thunks;
 577
 578 #include <poppack.h>
 579
 580 static CRITICAL_SECTION mci_cs;
 581 static CRITICAL_SECTION_DEBUG mci_critsect_debug =
 582 {
 583     0, 0, &mci_cs,
 584     { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
 585       0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
 586 };
 587 static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
 588
 589 static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
 590 {
 591     WORD args[8];
 592
 593     if (!pfn16)
 594     {
 595         MSG msg;
 596         PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
 597         return 0;
 598     }
 599
 600     /* 16 bit func, call it */
 601     TRACE("Function (16 bit) !\n");
 602
 603     args[2] = (MCIDEVICEID16)id;
 604     args[1] = HIWORD(yield_data);
 605     args[0] = LOWORD(yield_data);
 606     return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
 607 }
 608
 609 /******************************************************************
 610  *              MCI_AddThunk
 611  *
 612  */
 613 static struct mci_thunk*       MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
 614 {
 615      struct mci_thunk* thunk;
 616
 617      if (!MCI_Thunks)
 618      {
 619          MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
 620                                    PAGE_EXECUTE_READWRITE);
 621          if (!MCI_Thunks) return NULL;
 622          for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
 623          {
 624              thunk->popl_eax     = 0x58;   /* popl  %eax */
 625              thunk->pushl_func   = 0x68;   /* pushl $pfn16 */
 626              thunk->yield16      = 0;
 627              thunk->pushl_eax    = 0x50;   /* pushl %eax */
 628              thunk->jmp          = 0xe9;   /* jmp MCI_Yield1632 */
 629              thunk->callback     = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
 630              thunk->id           = 0;
 631          }
 632      }
 633      for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
 634      {
 635          if (thunk->yield16 == 0)
 636          {
 637              thunk->yield16 = pfn16;
 638              thunk->id      = id;
 639              return thunk;
 640          }
 641      }
 642      FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
 643      return NULL;
 644 }
 645
 646 /******************************************************************
 647  *              MCI_HasThunk
 648  *
 649  */
 650 static struct mci_thunk*    MCI_HasThunk(YIELDPROC pfn)
 651 {
 652     struct mci_thunk* thunk;
 653
 654     if (!MCI_Thunks) return NULL;
 655     for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
 656     {
 657         if ((YIELDPROC)thunk == pfn) return thunk;
 658     }
 659     return NULL;
 660 }
 661
 662 /**************************************************************************
 663  *                              mciSetYieldProc                 [MMSYSTEM.714]
 664  */
 665 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
 666 {
 667     struct mci_thunk*   thunk;
 668     BOOL                ret;
 669
 670     TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
 671
 672     if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
 673         return FALSE;
 674     ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
 675     if (!ret) thunk->yield16 = NULL;
 676     return ret;
 677 }
 678
 679 /**************************************************************************
 680  *                              mciGetYieldProc                 [MMSYSTEM.716]
 681  */
 682 YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
 683 {
 684     YIELDPROC           yield;
 685     DWORD               data;
 686     struct mci_thunk*   thunk;
 687
 688     TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
 689
 690     yield = mciGetYieldProc(uDeviceID, &data);
 691     if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
 692
 693     if (lpdwYieldData) *lpdwYieldData = data;
 694     return thunk->yield16;
 695 }
 696
 697 /**************************************************************************
 698  *                              mciGetErrorString               [MMSYSTEM.706]
 699  */
 700 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
 701 {
 702     return mciGetErrorStringA(wError, lpstrBuffer, uLength);
 703 }
 704
 705 /**************************************************************************
 706  *                              mciDriverNotify                 [MMSYSTEM.711]
 707  */
 708 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
 709 {
 710     TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
 711
 712     return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
 713 }
 714
 715 /**************************************************************************
 716  *                      mciGetDriverData                        [MMSYSTEM.708]
 717  */
 718 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
 719 {
 720     return mciGetDriverData(uDeviceID);
 721 }
 722
 723 /**************************************************************************
 724  *                      mciSetDriverData                        [MMSYSTEM.707]
 725  */
 726 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
 727 {
 728     return mciSetDriverData(uDeviceID, data);
 729 }
 730
 731 /**************************************************************************
 732  *                              mciSendCommand                  [MMSYSTEM.701]
 733  */
 734 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
 735 {
 736     DWORD               dwRet;
 737     BOOL                to32;
 738     DWORD_PTR           dwParam2 = p2;
 739
 740     TRACE("(%04X, %s, %08X, %08lX)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
 741
 742     switch (wMsg) {
 743     case MCI_CLOSE:
 744     case MCI_OPEN:
 745     case MCI_SYSINFO:
 746     case MCI_BREAK:
 747     case MCI_SOUND:
 748         to32 = TRUE;
 749         break;
 750     default:
 751         /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
 752          * doing 16=>32W, then 32W=>16 conversions.
 753          * We could directly call the 16bit driver if we had the information.
 754          */
 755         to32 = TRUE;
 756     }
 757     if (to32) {
 758         MMSYSTEM_MapType res;
 759
 760         dwRet = MCIERR_INVALID_DEVICE_ID;
 761
 762         switch (res = MCI_MapMsg16To32W(wDevID, wMsg, dwParam1, &dwParam2)) {
 763         case MMSYSTEM_MAP_MSGERROR:
 764             TRACE("%s not handled yet\n", MCI_MessageToString(wMsg));
 765             dwRet = MCIERR_DRIVER_INTERNAL;
 766             break;
 767         case MMSYSTEM_MAP_NOMEM:
 768             TRACE("Problem mapping %s from 16 to 32a\n", MCI_MessageToString(wMsg));
 769             dwRet = MCIERR_OUT_OF_MEMORY;
 770             break;
 771         case MMSYSTEM_MAP_OK:
 772         case MMSYSTEM_MAP_OKMEM:
 773             dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
 774             if (res == MMSYSTEM_MAP_OKMEM)
 775                 MCI_UnMapMsg16To32W(wDevID, wMsg, dwParam1, dwParam2);
 776             break;
 777         }
 778     }
 779     else
 780     {
 781 #if 0
 782         if (wDevID == MCI_ALL_DEVICE_ID) {
 783             FIXME("unhandled MCI_ALL_DEVICE_ID\n");
 784             dwRet = MCIERR_CANNOT_USE_ALL;
 785         } else {
 786             dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
 787         }
 788 #endif
 789     }
 790     if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
 791     {
 792         /* free yield thunks, if any */
 793         unsigned    i;
 794         for (i = 0; i < MCI_MAX_THUNKS; i++)
 795         {
 796             if (MCI_Thunks[i].id == wDevID)
 797                 MCI_Thunks[i].yield16 = NULL;
 798         }
 799     }
 800     return dwRet;
 801 }
 802
 803 /**************************************************************************
 804  *                              mciGetDeviceID                  [MMSYSTEM.703]
 805  */
 806 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
 807 {
 808     TRACE("(\"%s\")\n", lpstrName);
 809
 810     return mciGetDeviceIDA(lpstrName);
 811 }
 812
 813 /**************************************************************************
 814  *                              mciGetDeviceIDFromElementID     [MMSYSTEM.715]
 815  */
 816 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
 817 {
 818     return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
 819 }
 820
 821 /**************************************************************************
 822  *                              mciGetCreatorTask               [MMSYSTEM.717]
 823  */
 824 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
 825 {
 826     return HTASK_16(mciGetCreatorTask(uDeviceID));
 827 }
 828
 829 /**************************************************************************
 830  *                              mciDriverYield                  [MMSYSTEM.710]
 831  */
 832 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
 833 {
 834     return mciDriverYield(uDeviceID);
 835 }
 836
 837 /**************************************************************************
 838  *                              mciSendString                   [MMSYSTEM.702]
 839  */
 840 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
 841                              UINT16 uRetLen, HWND16 hwndCallback)
 842 {
 843     return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
 844 }
 845
 846 /**************************************************************************
 847  *                      mciLoadCommandResource                  [MMSYSTEM.705]
 848  */
 849 UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
 850 {
 851     TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
 852     return MCI_NO_COMMAND_TABLE;
 853 }
 854
 855 /**************************************************************************
 856  *                      mciFreeCommandResource                  [MMSYSTEM.713]
 857  */
 858 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
 859 {
 860     TRACE("(%04x)!\n", uTable);
 861
 862     return FALSE;
 863 }
 864
 865 /**************************************************************************
 866  *                              mciExecute                      [MMSYSTEM.712]
 867  */
 868 BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
 869 {
 870     return mciExecute(lpstrCommand);
 871 }